lttng/org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/internal/lttng2/kernel/core/analysis/vm/module/VirtualMachineStateProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014, 2015 École Polytechnique de Montréal
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Mohamad Gebai - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.module;
  14
  15 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  16
  17 import java.util.HashMap;
  18 import java.util.Map;
  19
  20 import org.eclipse.jdt.annotation.Nullable;
  21 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelAnalysisModule;
  22 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.KernelThreadInformationProvider;
  23 import org.eclipse.tracecompass.analysis.os.linux.core.model.HostThread;
  24 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
  25 import org.eclipse.tracecompass.common.core.NonNullUtils;
  26 import org.eclipse.tracecompass.internal.lttng2.kernel.core.Activator;
  27 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.VcpuStateValues;
  28 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.VmAttributes;
  29 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.IVirtualMachineModel;
  30 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.VirtualCPU;
  31 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.VirtualMachine;
  32 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.qemukvm.QemuKvmVmModel;
  33 import org.eclipse.tracecompass.internal.lttng2.kernel.core.trace.layout.LttngEventLayout;
  34 import org.eclipse.tracecompass.lttng2.kernel.core.trace.LttngKernelTrace;
  35 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
  36 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  37 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  38 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  39 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  40 import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
  41 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  42 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
  43 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
  44 import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
  45 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  46 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  47 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
  48 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperimentUtils;
  49
  50 import com.google.common.collect.HashBasedTable;
  51 import com.google.common.collect.Table;
  52
  53 /**
  54  * This is the state provider which translates the virtual machine experiment
  55  * events to a state system.
  56  *
  57  * Attribute tree:
  58  *
  59  * <pre>
  60  * |- Virtual Machines
  61  * |  |- <Guest Host ID> -> Friendly name (trace name)
  62  * |  |  |- <VCPU number>
  63  * |  |  |  |- Status -> <Status value>
  64  * </pre>
  65  *
  66  * The status value of the VCPUs are either {@link VcpuStateValues#VCPU_IDLE},
  67  * {@link VcpuStateValues#VCPU_UNKNOWN} or {@link VcpuStateValues#VCPU_RUNNING}.
  68  * Those three values are ORed with flags {@link VcpuStateValues#VCPU_VMM}
  69  * and/or {@link VcpuStateValues#VCPU_PREEMPT} to indicate respectively whether
  70  * they are in hypervisor mode or preempted on the host.
  71  *
  72  * @author Mohamad Gebai
  73  */
  74 public class VirtualMachineStateProvider extends AbstractTmfStateProvider {
  75
  76     /**
  77      * Version number of this state provider. Please bump this if you modify the
  78      * contents of the generated state history in some way.
  79      */
  80     private static final int VERSION = 1;
  81
  82     private static final int SCHED_SWITCH_INDEX = 0;
  83
  84     /* TODO: An analysis should support many hypervisor models */
  85     private IVirtualMachineModel fModel;
  86     private final Table<ITmfTrace, String, Integer> fEventNames;
  87     private final Map<ITmfTrace, IKernelAnalysisEventLayout> fLayouts;
  88
  89     // ------------------------------------------------------------------------
  90     // Constructor
  91     // ------------------------------------------------------------------------
  92
  93     /**
  94      * Constructor
  95      *
  96      * @param experiment
  97      *            The virtual machine experiment
  98      */
  99     public VirtualMachineStateProvider(TmfExperiment experiment) {
 100         super(experiment, "Virtual Machine State Provider"); //$NON-NLS-1$
 101
 102         fModel = new QemuKvmVmModel(experiment);
 103         Table<ITmfTrace, String, Integer> table = NonNullUtils.checkNotNull(HashBasedTable.<ITmfTrace, String, Integer> create());
 104         fEventNames = table;
 105         fLayouts = new HashMap<>();
 106     }
 107
 108     // ------------------------------------------------------------------------
 109     // Event names management
 110     // ------------------------------------------------------------------------
 111
 112     private void buildEventNames(ITmfTrace trace) {
 113         IKernelAnalysisEventLayout layout;
 114         if (trace instanceof LttngKernelTrace) {
 115             layout = ((LttngKernelTrace) trace).getKernelEventLayout();
 116         } else {
 117             /* Fall-back to the base LttngEventLayout */
 118             layout = LttngEventLayout.getInstance();
 119         }
 120         fLayouts.put(trace, layout);
 121         fEventNames.put(trace, layout.eventSchedSwitch(), SCHED_SWITCH_INDEX);
 122     }
 123
 124     // ------------------------------------------------------------------------
 125     // IStateChangeInput
 126     // ------------------------------------------------------------------------
 127
 128     @Override
 129     public TmfExperiment getTrace() {
 130         ITmfTrace trace = super.getTrace();
 131         if (trace instanceof TmfExperiment) {
 132             return (TmfExperiment) trace;
 133         }
 134         throw new IllegalStateException("VirtualMachineStateProvider: The associated trace should be an experiment"); //$NON-NLS-1$
 135     }
 136
 137     @Override
 138     public int getVersion() {
 139         return VERSION;
 140     }
 141
 142     @Override
 143     public VirtualMachineStateProvider getNewInstance() {
 144         TmfExperiment trace = getTrace();
 145         return new VirtualMachineStateProvider(trace);
 146     }
 147
 148     @Override
 149     protected void eventHandle(@Nullable ITmfEvent event) {
 150         if (event == null) {
 151             return;
 152         }
 153
 154         /* Is the event managed by this analysis */
 155         final String eventName = event.getName();
 156
 157         /* TODO When requirements work again, don't hardcode this */
 158         if (!eventName.equals("sched_switch") && //$NON-NLS-1$
 159                 !fModel.getRequiredEvents().contains(eventName)) {
 160             return;
 161         }
 162
 163         ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder());
 164         ITmfStateValue value;
 165
 166         final ITmfEventField content = event.getContent();
 167         final long ts = event.getTimestamp().getValue();
 168         final String hostId = event.getTrace().getHostId();
 169         try {
 170             /* Do we know this trace's role yet? */
 171             VirtualMachine host = fModel.getCurrentMachine(event);
 172             if (host == null) {
 173                 return;
 174             }
 175
 176             /* Make sure guest traces are added to the state system */
 177             if (host.isGuest()) {
 178                 /*
 179                  * If event from a guest OS, make sure the guest exists in the
 180                  * state system
 181                  */
 182                 int vmQuark = -1;
 183                 try {
 184                     vmQuark = ss.getQuarkRelative(getNodeVirtualMachines(), host.getHostId());
 185                 } catch (AttributeNotFoundException e) {
 186                     /*
 187                      * We should enter this catch only once per machine, so it
 188                      * is not so costly to do compared with adding the trace's
 189                      * name for each guest event
 190                      */
 191                     vmQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), host.getHostId());
 192                     TmfStateValue machineName = TmfStateValue.newValueString(event.getTrace().getName());
 193                     ss.modifyAttribute(ts, machineName, vmQuark);
 194                 }
 195             }
 196
 197             /* Have the hypervisor models handle the event first */
 198             fModel.handleEvent(event);
 199
 200             /* Handle the event here */
 201             if (!fEventNames.containsRow(event.getTrace())) {
 202                 buildEventNames(event.getTrace());
 203             }
 204             Integer idx = fEventNames.get(event.getTrace(), eventName);
 205             int intval = (idx == null ? -1 : idx.intValue());
 206             switch (intval) {
 207             case SCHED_SWITCH_INDEX: // "sched_switch":
 208             /*
 209              * Fields: string prev_comm, int32 prev_tid, int32 prev_prio, int64
 210              * prev_state, string next_comm, int32 next_tid, int32 next_prio
 211              */
 212             {
 213                 int prevTid = ((Long) content.getField(fLayouts.get(event.getTrace()).fieldPrevTid()).getValue()).intValue();
 214                 int nextTid = ((Long) content.getField(fLayouts.get(event.getTrace()).fieldNextTid()).getValue()).intValue();
 215
 216                 if (host.isGuest()) {
 217                     /* Get the event's CPU */
 218                     Object cpuObj = TmfTraceUtils.resolveEventAspectOfClassForEvent(event.getTrace(), TmfCpuAspect.class, event);
 219                     if (cpuObj == null) {
 220                         /*
 221                          * We couldn't find any CPU information, ignore this
 222                          * event
 223                          */
 224                         break;
 225                     }
 226                     Integer cpu = (Integer) cpuObj;
 227
 228                     /*
 229                      * If sched switch is from a guest, just update the status
 230                      * of the virtual CPU to either idle or running
 231                      */
 232                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), host.getHostId(),
 233                             cpu.toString(), VmAttributes.STATUS);
 234                     value = TmfStateValue.newValueInt(VcpuStateValues.VCPU_IDLE);
 235                     if (nextTid > 0) {
 236                         value = TmfStateValue.newValueInt(VcpuStateValues.VCPU_RUNNING);
 237                     }
 238                     ss.modifyAttribute(ts, value, curStatusQuark);
 239                     break;
 240                 }
 241
 242                 /* Event is not from a guest */
 243                 /* Verify if the previous thread corresponds to a virtual CPU */
 244                 HostThread ht = new HostThread(hostId, prevTid);
 245                 VirtualCPU vcpu = fModel.getVirtualCpu(ht);
 246
 247                 /*
 248                  * If previous thread is virtual CPU, update status of the
 249                  * virtual CPU to preempted
 250                  */
 251                 if (vcpu != null) {
 252                     VirtualMachine vm = vcpu.getVm();
 253
 254                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 255                             vcpu.getCpuId().toString(), VmAttributes.STATUS);
 256
 257                     /* Add the preempted flag to the status */
 258                     value = ss.queryOngoingState(curStatusQuark);
 259                     if ((value.unboxInt() & VcpuStateValues.VCPU_IDLE) == 0) {
 260                         int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 261                         value = TmfStateValue.newValueInt(newVal | VcpuStateValues.VCPU_PREEMPT);
 262                         ss.modifyAttribute(ts, value, curStatusQuark);
 263                     }
 264                 }
 265
 266                 /* Verify if the next thread corresponds to a virtual CPU */
 267                 ht = new HostThread(hostId, nextTid);
 268                 vcpu = fModel.getVirtualCpu(ht);
 269
 270                 /*
 271                  * If next thread is virtual CPU, update status of the virtual
 272                  * CPU the previous status
 273                  */
 274                 if (vcpu != null) {
 275                     VirtualMachine vm = vcpu.getVm();
 276                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 277                             vcpu.getCpuId().toString(), VmAttributes.STATUS);
 278
 279                     /* Remove the preempted flag from the status */
 280                     value = ss.queryOngoingState(curStatusQuark);
 281                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 282                     value = TmfStateValue.newValueInt(newVal & ~VcpuStateValues.VCPU_PREEMPT);
 283                     ss.modifyAttribute(ts, value, curStatusQuark);
 284
 285                 }
 286
 287             }
 288                 break;
 289
 290             default:
 291             /* Other events not covered by the main switch */
 292             {
 293                 HostThread ht = getCurrentHostThread(event, ts);
 294                 if (ht == null) {
 295                     break;
 296                 }
 297
 298                 /*
 299                  * Are we entering the hypervisor mode and if so, which virtual
 300                  * CPU is concerned?
 301                  */
 302                 VirtualCPU virtualCpu = fModel.getVCpuEnteringHypervisorMode(event, ht);
 303                 if (virtualCpu != null) {
 304                     /* Add the hypervisor flag to the status */
 305                     VirtualMachine vm = virtualCpu.getVm();
 306                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 307                             Long.toString(virtualCpu.getCpuId()), VmAttributes.STATUS);
 308                     value = ss.queryOngoingState(curStatusQuark);
 309                     if ((value.unboxInt() & VcpuStateValues.VCPU_IDLE) == 0) {
 310                         int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 311                         value = TmfStateValue.newValueInt(newVal | VcpuStateValues.VCPU_VMM);
 312                         ss.modifyAttribute(ts, value, curStatusQuark);
 313                     }
 314                 }
 315
 316                 /*
 317                  * Are we exiting the hypervisor mode and if so, which virtual
 318                  * CPU is concerned?
 319                  */
 320                 virtualCpu = fModel.getVCpuExitingHypervisorMode(event, ht);
 321                 if (virtualCpu != null) {
 322                     /* Remove the hypervisor flag from the status */
 323                     VirtualMachine vm = virtualCpu.getVm();
 324                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 325                             Long.toString(virtualCpu.getCpuId()), VmAttributes.STATUS);
 326                     value = ss.queryOngoingState(curStatusQuark);
 327                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 328                     value = TmfStateValue.newValueInt(newVal & ~VcpuStateValues.VCPU_VMM);
 329                     ss.modifyAttribute(ts, value, curStatusQuark);
 330                 }
 331
 332             }
 333                 break;
 334             }
 335
 336         } catch (AttributeNotFoundException | TimeRangeException | StateValueTypeException e) {
 337             Activator.getDefault().logError("Error handling event in VirtualMachineStateProvider", e); //$NON-NLS-1$
 338         }
 339     }
 340
 341     // ------------------------------------------------------------------------
 342     // Convenience methods for commonly-used attribute tree locations
 343     // ------------------------------------------------------------------------
 344
 345     private int getNodeVirtualMachines() {
 346         return checkNotNull(getStateSystemBuilder()).getQuarkAbsoluteAndAdd(VmAttributes.VIRTUAL_MACHINES);
 347     }
 348
 349     private @Nullable HostThread getCurrentHostThread(ITmfEvent event, long ts) {
 350         /* Get the LTTng kernel analysis for the host */
 351         String hostId = event.getTrace().getHostId();
 352         KernelAnalysisModule module = TmfExperimentUtils.getAnalysisModuleOfClassForHost(getTrace(), hostId, KernelAnalysisModule.class);
 353         if (module == null) {
 354             return null;
 355         }
 356
 357         /* Get the CPU the event is running on */
 358         Object cpuObj = TmfTraceUtils.resolveEventAspectOfClassForEvent(event.getTrace(), TmfCpuAspect.class, event);
 359         if (cpuObj == null) {
 360             /* We couldn't find any CPU information, ignore this event */
 361             return null;
 362         }
 363         Integer cpu = (Integer) cpuObj;
 364
 365         Integer currentTid = KernelThreadInformationProvider.getThreadOnCpu(module, cpu, ts);
 366         if (currentTid == null) {
 367             return null;
 368         }
 369         return new HostThread(hostId, currentTid);
 370     }
 371
 372 }