| /******************************************************************************* |
| * Copyright (c) 2018 École Polytechnique de Montréal |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.handlers; |
| |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.tracecompass.analysis.os.linux.core.event.aspect.LinuxPidAspect; |
| import org.eclipse.tracecompass.analysis.os.linux.core.model.HostThread; |
| import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.IVirtualMachineEventHandler; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.VirtualCPU; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.VirtualMachine; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.analysis.VirtualEnvironmentBuilder; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.analysis.VirtualMachineModelAnalysis; |
| import org.eclipse.tracecompass.incubator.internal.virtual.machine.analysis.core.model.qemukvm.QemuKvmStrings; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEvent; |
| import org.eclipse.tracecompass.tmf.core.event.ITmfEventField; |
| import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils; |
| |
| import com.google.common.collect.ImmutableSet; |
| |
| /** |
| * Handle events coming from a qemu/kvm hypervisor |
| * |
| * @author Geneviève Bastien |
| */ |
| public class QemuKvmEventHandler implements IVirtualMachineModelBuilderEventHandler { |
| |
| private Map<IKernelAnalysisEventLayout, Set<String>> fRequiredEvents = new HashMap<>(); |
| |
| private static final ImmutableSet<String> VMSYNC_EVENTS = ImmutableSet.of( |
| QemuKvmStrings.VMSYNC_GH_GUEST, |
| QemuKvmStrings.VMSYNC_GH_HOST, |
| QemuKvmStrings.VMSYNC_HG_GUEST, |
| QemuKvmStrings.VMSYNC_HG_HOST); |
| |
| /** |
| * Constructor |
| */ |
| public QemuKvmEventHandler() { |
| } |
| |
| @Override |
| public Set<String> getRequiredEvents(IKernelAnalysisEventLayout layout) { |
| Set<String> events = fRequiredEvents.get(layout); |
| if (events == null) { |
| events = new HashSet<>(); |
| events.addAll(layout.eventsKVMEntry()); |
| events.addAll(layout.eventsKVMExit()); |
| events.addAll(VMSYNC_EVENTS); |
| fRequiredEvents.put(layout, events); |
| } |
| return events; |
| } |
| |
| /** |
| * Handle the event for a Qemu/kvm model |
| * |
| * @param ss |
| * The state system builder to fill |
| * @param event |
| * The event to handle |
| */ |
| @Override |
| public void handleBuilderEvent(ITmfStateSystemBuilder ss, ITmfEvent event, VirtualEnvironmentBuilder virtEnv, IKernelAnalysisEventLayout layout) { |
| String eventName = event.getName(); |
| VirtualMachine machine = virtEnv.getCurrentMachineBuild(event); |
| long ts = event.getTimestamp().toNanos(); |
| if (layout.eventsKVMEntry().contains(eventName)) { |
| setMachineHost(ss, machine); |
| handleKvmEntry(ss, ts, event, virtEnv, machine); |
| } else if (layout.eventsKVMExit().contains(eventName)) { |
| setMachineHost(ss, machine); |
| } else if (eventName.equals(QemuKvmStrings.VMSYNC_GH_GUEST) || eventName.equals(QemuKvmStrings.VMSYNC_HG_GUEST)) { |
| if (machine.isGuest()) { |
| // There's nothing more we can learn from these events, return |
| return; |
| } |
| handleGuestEvent(event, machine); |
| } else if (eventName.equals(QemuKvmStrings.VMSYNC_GH_HOST)) { |
| setMachineHost(ss, machine); |
| handleHostEvent(ss, ts, event, virtEnv, machine); |
| } |
| } |
| |
| private static void handleHostEvent(ITmfStateSystemBuilder ss, long ts, ITmfEvent event, VirtualEnvironmentBuilder virtEnv, VirtualMachine hostMachine) { |
| HostThread ht = IVirtualMachineEventHandler.getCurrentHostThread(event, ts); |
| if (ht == null) { |
| return; |
| } |
| |
| VirtualMachine vm = virtEnv.getGuestMachineBuild(event, ht); |
| if (vm != null) { |
| // Machine is already known, exit |
| return; |
| } |
| |
| Long vmUid = event.getContent().getFieldValue(Long.class, QemuKvmStrings.VM_UID_PAYLOAD); |
| if (vmUid == null) { |
| return; |
| } |
| |
| for (VirtualMachine machine : virtEnv.getMachines()) { |
| if (machine.getVmUid() == vmUid) { |
| /* |
| * We found the VM being run, let's associate it with the |
| * thread ID and set its hypervisor |
| */ |
| hostMachine.addChild(machine); |
| int guestQuark = ss.getQuarkAbsoluteAndAdd(hostMachine.getHostId(), VirtualMachineModelAnalysis.GUEST_VMS, machine.getHostId()); |
| ss.modifyAttribute(ts, machine.getTraceName(), guestQuark); |
| |
| virtEnv.setGuestMachine(machine, ht); |
| |
| int hypervisorQuark = ss.getQuarkRelativeAndAdd(guestQuark, VirtualMachineModelAnalysis.HYPERVISOR); |
| ss.modifyAttribute(ts, "Qemu/KVM", hypervisorQuark); //$NON-NLS-1$ |
| |
| // we have the thread running, its associated process represents the guest |
| Integer pid = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(event.getTrace(), LinuxPidAspect.class, event); |
| if (pid == null) { |
| return; |
| } |
| HostThread parentHt = new HostThread(ht.getHost(), pid); |
| // Update guest process if not known |
| if (virtEnv.getGuestMachineBuild(event, parentHt) == null) { |
| virtEnv.setGuestMachine(machine, parentHt); |
| int guestProcessQuark = ss.getQuarkRelativeAndAdd(guestQuark, VirtualMachineModelAnalysis.PROCESS); |
| ss.modifyAttribute(ts, pid, guestProcessQuark); |
| } |
| } |
| } |
| } |
| |
| private static void handleGuestEvent(ITmfEvent event, VirtualMachine machine) { |
| // Set the machine as guest and add its uid |
| Long uid = event.getContent().getFieldValue(Long.class, QemuKvmStrings.VM_UID_PAYLOAD); |
| if (uid != null) { |
| machine.setGuest(uid); |
| } |
| } |
| |
| private static void setMachineHost(ITmfStateSystemBuilder ss, VirtualMachine machine) { |
| // Machine is already a host, ignore |
| if (machine.isHost()) { |
| return; |
| } |
| // Set the machine as host and add the quark for guests |
| machine.setHost(); |
| ss.getQuarkAbsoluteAndAdd(machine.getHostId(), VirtualMachineModelAnalysis.GUEST_VMS); |
| } |
| |
| private static void handleKvmEntry(ITmfStateSystemBuilder ss, long ts, ITmfEvent event, VirtualEnvironmentBuilder virtEnv, VirtualMachine machine) { |
| HostThread ht = IVirtualMachineEventHandler.getCurrentHostThread(event, ts); |
| if (ht == null) { |
| return; |
| } |
| VirtualCPU vcpu = virtEnv.getVirtualCpuBuild(event, ht); |
| if (vcpu != null) { |
| // The current thread has a vcpu configured, ignore |
| return; |
| } |
| // Try to find the guest that corresponds to this one |
| VirtualMachine vm = virtEnv.getGuestMachineBuild(event, ht); |
| if (vm == null) { |
| vm = findVmFromProcess(event, ht, virtEnv); |
| if (vm == null) { |
| return; |
| } |
| } |
| /* Associate this thread with the virtual CPU that is going to be run */ |
| final ITmfEventField content = event.getContent(); |
| Long vcpuId = content.getFieldValue(Long.class, QemuKvmStrings.VCPU_ID); |
| if (vcpuId == null) { |
| return; |
| } |
| VirtualCPU virtualCPU = VirtualCPU.getVirtualCPU(vm, vcpuId); |
| virtEnv.setGuestCpu(virtualCPU, ht); |
| int vcpuQuark = ss.getQuarkAbsoluteAndAdd(machine.getHostId(), VirtualMachineModelAnalysis.GUEST_VMS, vm.getHostId(), VirtualMachineModelAnalysis.CPUS, vcpuId.toString()); |
| ss.modifyAttribute(ts, ht.getTid(), vcpuQuark); |
| } |
| |
| private @Nullable static VirtualMachine findVmFromProcess(ITmfEvent event, HostThread ht, VirtualEnvironmentBuilder virtEnv) { |
| /* |
| * Maybe the process of the current thread has a VM associated, see if we |
| * can infer the VM for this thread |
| */ |
| Integer pid = TmfTraceUtils.resolveIntEventAspectOfClassForEvent(event.getTrace(), LinuxPidAspect.class, event); |
| if (pid == null) { |
| return null; |
| } |
| HostThread parentHt = new HostThread(ht.getHost(), pid); |
| VirtualMachine vm = virtEnv.getGuestMachineBuild(event, parentHt); |
| if (vm != null) { |
| virtEnv.setGuestMachine(vm, ht); |
| } |
| |
| return vm; |
| } |
| |
| } |
