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

   1 /*******************************************************************************
   2  * Copyright (c) 2014 É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.common.core.NonNullUtils;
  22 import org.eclipse.tracecompass.internal.lttng2.kernel.core.Activator;
  23 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.VcpuStateValues;
  24 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.VmAttributes;
  25 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.HostThread;
  26 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.IVirtualMachineModel;
  27 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.VirtualCPU;
  28 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.VirtualMachine;
  29 import org.eclipse.tracecompass.internal.lttng2.kernel.core.analysis.vm.model.qemukvm.QemuKvmVmModel;
  30 import org.eclipse.tracecompass.internal.lttng2.kernel.core.trace.layout.IKernelAnalysisEventLayout;
  31 import org.eclipse.tracecompass.internal.lttng2.kernel.core.trace.layout.LttngEventLayout;
  32 import org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel.LttngKernelAnalysis;
  33 import org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel.LttngKernelThreadInformationProvider;
  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, ITmfEvent.class, "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).getEventLayout();
 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.getType().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                 Integer prevTid = ((Long) content.getField(fLayouts.get(event.getTrace()).fieldPrevTid()).getValue()).intValue();
 214                 Integer nextTid = ((Long) content.getField(fLayouts.get(event.getTrace()).fieldNextTid()).getValue()).intValue();
 215
 216                 if (prevTid == null || nextTid == null) {
 217                     break;
 218                 }
 219
 220                 if (host.isGuest()) {
 221                     /* Get the event's CPU */
 222                     Integer cpu = null;
 223                     Iterable<TmfCpuAspect> aspects = TmfTraceUtils.getEventAspectsOfClass(event.getTrace(), TmfCpuAspect.class);
 224                     for (TmfCpuAspect aspect : aspects) {
 225                         Integer aspectRes = aspect.resolve(event);
 226                         if (aspectRes != null) {
 227                             cpu = aspectRes;
 228                             break;
 229                         }
 230                     }
 231                     if (cpu == null) {
 232                         /*
 233                          * We couldn't find any CPU information, ignore this
 234                          * event
 235                          */
 236                         break;
 237                     }
 238
 239                     /*
 240                      * If sched switch is from a guest, just update the status
 241                      * of the virtual CPU to either idle or running
 242                      */
 243                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), host.getHostId(),
 244                             cpu.toString(), VmAttributes.STATUS);
 245                     value = TmfStateValue.newValueInt(VcpuStateValues.VCPU_IDLE);
 246                     if (nextTid > 0) {
 247                         value = TmfStateValue.newValueInt(VcpuStateValues.VCPU_RUNNING);
 248                     }
 249                     ss.modifyAttribute(ts, value, curStatusQuark);
 250                     break;
 251                 }
 252
 253                 /* Event is not from a guest */
 254                 /* Verify if the previous thread corresponds to a virtual CPU */
 255                 HostThread ht = new HostThread(hostId, prevTid);
 256                 VirtualCPU vcpu = fModel.getVirtualCpu(ht);
 257
 258                 /*
 259                  * If previous thread is virtual CPU, update status of the
 260                  * virtual CPU to preempted
 261                  */
 262                 if (vcpu != null) {
 263                     VirtualMachine vm = vcpu.getVm();
 264
 265                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 266                             vcpu.getCpuId().toString(), VmAttributes.STATUS);
 267
 268                     /* Add the preempted flag to the status */
 269                     value = ss.queryOngoingState(curStatusQuark);
 270                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 271                     value = TmfStateValue.newValueInt(newVal | VcpuStateValues.VCPU_PREEMPT);
 272                     ss.modifyAttribute(ts, value, curStatusQuark);
 273                 }
 274
 275                 /* Verify if the next thread corresponds to a virtual CPU */
 276                 ht = new HostThread(hostId, nextTid);
 277                 vcpu = fModel.getVirtualCpu(ht);
 278
 279                 /*
 280                  * If next thread is virtual CPU, update status of the virtual
 281                  * CPU the previous status
 282                  */
 283                 if (vcpu != null) {
 284                     VirtualMachine vm = vcpu.getVm();
 285                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 286                             vcpu.getCpuId().toString(), VmAttributes.STATUS);
 287
 288                     /* Remove the preempted flag from the status */
 289                     value = ss.queryOngoingState(curStatusQuark);
 290                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 291                     value = TmfStateValue.newValueInt(newVal & ~VcpuStateValues.VCPU_PREEMPT);
 292                     ss.modifyAttribute(ts, value, curStatusQuark);
 293
 294                 }
 295
 296             }
 297                 break;
 298
 299             default:
 300             /* Other events not covered by the main switch */
 301             {
 302                 HostThread ht = getCurrentHostThread(event, ts);
 303                 if (ht == null) {
 304                     break;
 305                 }
 306
 307                 /*
 308                  * Are we entering the hypervisor mode and if so, which virtual
 309                  * CPU is concerned?
 310                  */
 311                 VirtualCPU virtualCpu = fModel.getVCpuEnteringHypervisorMode(event, ht);
 312                 if (virtualCpu != null) {
 313                     /* Add the hypervisor flag to the status */
 314                     VirtualMachine vm = virtualCpu.getVm();
 315                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 316                             Long.toString(virtualCpu.getCpuId()), VmAttributes.STATUS);
 317                     value = ss.queryOngoingState(curStatusQuark);
 318                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 319                     value = TmfStateValue.newValueInt(newVal | VcpuStateValues.VCPU_VMM);
 320                     ss.modifyAttribute(ts, value, curStatusQuark);
 321                 }
 322
 323                 /*
 324                  * Are we exiting the hypervisor mode and if so, which virtual
 325                  * CPU is concerned?
 326                  */
 327                 virtualCpu = fModel.getVCpuExitingHypervisorMode(event, ht);
 328                 if (virtualCpu != null) {
 329                     /* Remove the hypervisor flag from the status */
 330                     VirtualMachine vm = virtualCpu.getVm();
 331                     int curStatusQuark = ss.getQuarkRelativeAndAdd(getNodeVirtualMachines(), vm.getHostId(),
 332                             Long.toString(virtualCpu.getCpuId()), VmAttributes.STATUS);
 333                     value = ss.queryOngoingState(curStatusQuark);
 334                     int newVal = Math.max(VcpuStateValues.VCPU_UNKNOWN, value.unboxInt());
 335                     value = TmfStateValue.newValueInt(newVal & ~VcpuStateValues.VCPU_VMM);
 336                     ss.modifyAttribute(ts, value, curStatusQuark);
 337                 }
 338
 339             }
 340                 break;
 341             }
 342
 343         } catch (AttributeNotFoundException | TimeRangeException | StateValueTypeException e) {
 344             Activator.getDefault().logError("Error handling event in VirtualMachineStateProvider", e); //$NON-NLS-1$
 345         }
 346     }
 347
 348     // ------------------------------------------------------------------------
 349     // Convenience methods for commonly-used attribute tree locations
 350     // ------------------------------------------------------------------------
 351
 352     private int getNodeVirtualMachines() {
 353         return checkNotNull(getStateSystemBuilder()).getQuarkAbsoluteAndAdd(VmAttributes.VIRTUAL_MACHINES);
 354     }
 355
 356     private @Nullable HostThread getCurrentHostThread(ITmfEvent event, long ts) {
 357         /* Get the LTTng kernel analysis for the host */
 358         String hostId = event.getTrace().getHostId();
 359         LttngKernelAnalysis module = TmfExperimentUtils.getAnalysisModuleOfClassForHost(getTrace(), hostId, LttngKernelAnalysis.class);
 360         if (module == null) {
 361             return null;
 362         }
 363
 364         /* Get the CPU the event is running on */
 365         Integer cpu = null;
 366         Iterable<TmfCpuAspect> aspects = TmfTraceUtils.getEventAspectsOfClass(event.getTrace(), TmfCpuAspect.class);
 367         for (TmfCpuAspect aspect : aspects) {
 368             Integer aspectRes = aspect.resolve(event);
 369             if (aspectRes != null) {
 370                 cpu = aspectRes;
 371                 break;
 372             }
 373         }
 374         if (cpu == null) {
 375             /* We couldn't find any CPU information, ignore this event */
 376             return null;
 377         }
 378
 379         Integer currentTid = LttngKernelThreadInformationProvider.getThreadOnCpu(module, cpu, ts);
 380         if (currentTid == null) {
 381             return null;
 382         }
 383         return new HostThread(hostId, currentTid);
 384     }
 385
 386 }