analysis/org.eclipse.tracecompass.analysis.os.linux.core/src/org/eclipse/tracecompass/internal/analysis/os/linux/core/kernelanalysis/KernelStateProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2015 Ericsson
   3  * Copyright (c) 2010, 2011 École Polytechnique de Montréal
   4  * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
   5  *
   6  * All rights reserved. This program and the accompanying materials are
   7  * made available under the terms of the Eclipse Public License v1.0 which
   8  * accompanies this distribution, and is available at
   9  * http://www.eclipse.org/legal/epl-v10.html
  10  *
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.internal.analysis.os.linux.core.kernelanalysis;
  14
  15 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  16
  17 import java.util.Map;
  18
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.Attributes;
  21 import org.eclipse.tracecompass.analysis.os.linux.core.kernelanalysis.StateValues;
  22 import org.eclipse.tracecompass.analysis.os.linux.core.trace.IKernelAnalysisEventLayout;
  23 import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernelanalysis.LinuxValues;
  24 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
  25 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  26 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  27 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  28 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  29 import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
  30 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  31 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
  32 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfCpuAspect;
  33 import org.eclipse.tracecompass.tmf.core.statesystem.AbstractTmfStateProvider;
  34 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  35 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  36
  37 import com.google.common.collect.ImmutableMap;
  38
  39 /**
  40  * This is the state change input plugin for TMF's state system which handles
  41  * the LTTng 2.0 kernel traces in CTF format.
  42  *
  43  * It uses the reference handler defined in CTFKernelHandler.java.
  44  *
  45  * @author alexmont
  46  *
  47  */
  48 public class KernelStateProvider extends AbstractTmfStateProvider {
  49
  50     // ------------------------------------------------------------------------
  51     // Static fields
  52     // ------------------------------------------------------------------------
  53
  54     /**
  55      * Version number of this state provider. Please bump this if you modify the
  56      * contents of the generated state history in some way.
  57      */
  58     private static final int VERSION = 9;
  59
  60     private static final int IRQ_HANDLER_ENTRY_INDEX = 1;
  61     private static final int IRQ_HANDLER_EXIT_INDEX = 2;
  62     private static final int SOFT_IRQ_ENTRY_INDEX = 3;
  63     private static final int SOFT_IRQ_EXIT_INDEX = 4;
  64     private static final int SOFT_IRQ_RAISE_INDEX = 5;
  65     private static final int SCHED_SWITCH_INDEX = 6;
  66     private static final int SCHED_PROCESS_FORK_INDEX = 7;
  67     private static final int SCHED_PROCESS_EXIT_INDEX = 8;
  68     private static final int SCHED_PROCESS_FREE_INDEX = 9;
  69     private static final int STATEDUMP_PROCESS_STATE_INDEX = 10;
  70     private static final int SCHED_WAKEUP_INDEX = 11;
  71     private static final int SCHED_PI_SETPRIO_INDEX = 12;
  72
  73
  74     // ------------------------------------------------------------------------
  75     // Fields
  76     // ------------------------------------------------------------------------
  77
  78     private final Map<String, Integer> fEventNames;
  79     private final IKernelAnalysisEventLayout fLayout;
  80
  81     // ------------------------------------------------------------------------
  82     // Constructor
  83     // ------------------------------------------------------------------------
  84
  85     /**
  86      * Instantiate a new state provider plugin.
  87      *
  88      * @param trace
  89      *            The LTTng 2.0 kernel trace directory
  90      * @param layout
  91      *            The event layout to use for this state provider. Usually
  92      *            depending on the tracer implementation.
  93      */
  94     public KernelStateProvider(ITmfTrace trace, IKernelAnalysisEventLayout layout) {
  95         super(trace, "Kernel"); //$NON-NLS-1$
  96         fLayout = layout;
  97         fEventNames = buildEventNames(layout);
  98     }
  99
 100     // ------------------------------------------------------------------------
 101     // Event names management
 102     // ------------------------------------------------------------------------
 103
 104     private static Map<String, Integer> buildEventNames(IKernelAnalysisEventLayout layout) {
 105         ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
 106
 107         builder.put(layout.eventIrqHandlerEntry(), IRQ_HANDLER_ENTRY_INDEX);
 108         builder.put(layout.eventIrqHandlerExit(), IRQ_HANDLER_EXIT_INDEX);
 109         builder.put(layout.eventSoftIrqEntry(), SOFT_IRQ_ENTRY_INDEX);
 110         builder.put(layout.eventSoftIrqExit(), SOFT_IRQ_EXIT_INDEX);
 111         builder.put(layout.eventSoftIrqRaise(), SOFT_IRQ_RAISE_INDEX);
 112         builder.put(layout.eventSchedSwitch(), SCHED_SWITCH_INDEX);
 113         builder.put(layout.eventSchedPiSetprio(), SCHED_PI_SETPRIO_INDEX);
 114         builder.put(layout.eventSchedProcessFork(), SCHED_PROCESS_FORK_INDEX);
 115         builder.put(layout.eventSchedProcessExit(), SCHED_PROCESS_EXIT_INDEX);
 116         builder.put(layout.eventSchedProcessFree(), SCHED_PROCESS_FREE_INDEX);
 117
 118         final String eventStatedumpProcessState = layout.eventStatedumpProcessState();
 119         if (eventStatedumpProcessState != null) {
 120             builder.put(eventStatedumpProcessState, STATEDUMP_PROCESS_STATE_INDEX);
 121         }
 122
 123         for (String eventSchedWakeup : layout.eventsSchedWakeup()) {
 124             builder.put(eventSchedWakeup, SCHED_WAKEUP_INDEX);
 125         }
 126
 127         return checkNotNull(builder.build());
 128     }
 129
 130     // ------------------------------------------------------------------------
 131     // IStateChangeInput
 132     // ------------------------------------------------------------------------
 133
 134     @Override
 135     public int getVersion() {
 136         return VERSION;
 137     }
 138
 139     @Override
 140     public void assignTargetStateSystem(ITmfStateSystemBuilder ssb) {
 141         /* We can only set up the locations once the state system is assigned */
 142         super.assignTargetStateSystem(ssb);
 143     }
 144
 145     @Override
 146     public KernelStateProvider getNewInstance() {
 147         return new KernelStateProvider(this.getTrace(), fLayout);
 148     }
 149
 150     @Override
 151     protected void eventHandle(@Nullable ITmfEvent event) {
 152         if (event == null) {
 153             return;
 154         }
 155
 156         Object cpuObj = TmfTraceUtils.resolveEventAspectOfClassForEvent(event.getTrace(), TmfCpuAspect.class, event);
 157         if (cpuObj == null) {
 158             /* We couldn't find any CPU information, ignore this event */
 159             return;
 160         }
 161         Integer cpu = (Integer) cpuObj;
 162
 163         final String eventName = event.getName();
 164         final long ts = event.getTimestamp().getValue();
 165
 166         try {
 167             final ITmfStateSystemBuilder ss = checkNotNull(getStateSystemBuilder());
 168
 169             /* Shortcut for the "current CPU" attribute node */
 170             final int currentCPUNode = ss.getQuarkRelativeAndAdd(getNodeCPUs(ss), cpu.toString());
 171
 172             /*
 173              * Shortcut for the "current thread" attribute node. It requires
 174              * querying the current CPU's current thread.
 175              */
 176             int quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.CURRENT_THREAD);
 177             ITmfStateValue value = ss.queryOngoingState(quark);
 178             int thread = value.isNull() ? -1 : value.unboxInt();
 179             final int currentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(thread));
 180
 181             /*
 182              * Feed event to the history system if it's known to cause a state
 183              * transition.
 184              */
 185             Integer idx = fEventNames.get(eventName);
 186             int intval = (idx == null ? -1 : idx.intValue());
 187             switch (intval) {
 188
 189             case IRQ_HANDLER_ENTRY_INDEX:
 190             {
 191                 Integer irqId = ((Long) event.getContent().getField(fLayout.fieldIrq()).getValue()).intValue();
 192
 193                 /* Mark this IRQ as active in the resource tree.
 194                  * The state value = the CPU on which this IRQ is sitting */
 195                 quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(ss), irqId.toString());
 196                 value = TmfStateValue.newValueInt(cpu.intValue());
 197                 ss.modifyAttribute(ts, value, quark);
 198
 199                 /* Change the status of the running process to interrupted */
 200                 quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS);
 201                 value = StateValues.PROCESS_STATUS_INTERRUPTED_VALUE;
 202                 ss.modifyAttribute(ts, value, quark);
 203
 204                 /* Change the status of the CPU to interrupted */
 205                 quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.STATUS);
 206                 value = StateValues.CPU_STATUS_IRQ_VALUE;
 207                 ss.modifyAttribute(ts, value, quark);
 208             }
 209                 break;
 210
 211             case IRQ_HANDLER_EXIT_INDEX:
 212             {
 213                 Integer irqId = ((Long) event.getContent().getField(fLayout.fieldIrq()).getValue()).intValue();
 214
 215                 /* Put this IRQ back to inactive in the resource tree */
 216                 quark = ss.getQuarkRelativeAndAdd(getNodeIRQs(ss), irqId.toString());
 217                 value = TmfStateValue.nullValue();
 218                 ss.modifyAttribute(ts, value, quark);
 219
 220                 /* Set the previous process back to running */
 221                 setProcessToRunning(ss, ts, currentThreadNode);
 222
 223                 /* Set the CPU status back to running or "idle" */
 224                 cpuExitInterrupt(ss, ts, currentCPUNode, currentThreadNode);
 225             }
 226                 break;
 227
 228             case SOFT_IRQ_ENTRY_INDEX:
 229             {
 230                 Integer softIrqId = ((Long) event.getContent().getField(fLayout.fieldVec()).getValue()).intValue();
 231
 232                 /* Mark this SoftIRQ as active in the resource tree.
 233                  * The state value = the CPU on which this SoftIRQ is processed */
 234                 quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString());
 235                 value = TmfStateValue.newValueInt(cpu.intValue());
 236                 ss.modifyAttribute(ts, value, quark);
 237
 238                 /* Change the status of the running process to interrupted */
 239                 quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS);
 240                 value = StateValues.PROCESS_STATUS_INTERRUPTED_VALUE;
 241                 ss.modifyAttribute(ts, value, quark);
 242
 243                 /* Change the status of the CPU to interrupted */
 244                 quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.STATUS);
 245                 value = StateValues.CPU_STATUS_SOFTIRQ_VALUE;
 246                 ss.modifyAttribute(ts, value, quark);
 247             }
 248                 break;
 249
 250             case SOFT_IRQ_EXIT_INDEX:
 251             {
 252                 Integer softIrqId = ((Long) event.getContent().getField(fLayout.fieldVec()).getValue()).intValue();
 253
 254                 /* Put this SoftIRQ back to inactive (= -1) in the resource tree */
 255                 quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString());
 256                 value = TmfStateValue.nullValue();
 257                 ss.modifyAttribute(ts, value, quark);
 258
 259                 /* Set the previous process back to running */
 260                 setProcessToRunning(ss, ts, currentThreadNode);
 261
 262                 /* Set the CPU status back to "busy" or "idle" */
 263                 cpuExitInterrupt(ss, ts, currentCPUNode, currentThreadNode);
 264             }
 265                 break;
 266
 267             case SOFT_IRQ_RAISE_INDEX:
 268             /* Fields: int32 vec */
 269             {
 270                 Integer softIrqId = ((Long) event.getContent().getField(fLayout.fieldVec()).getValue()).intValue();
 271
 272                 /* Mark this SoftIRQ as *raised* in the resource tree.
 273                  * State value = -2 */
 274                 quark = ss.getQuarkRelativeAndAdd(getNodeSoftIRQs(ss), softIrqId.toString());
 275                 value = StateValues.SOFT_IRQ_RAISED_VALUE;
 276                 ss.modifyAttribute(ts, value, quark);
 277             }
 278                 break;
 279
 280             case SCHED_SWITCH_INDEX:
 281             {
 282                 ITmfEventField content = event.getContent();
 283                 Integer prevTid = ((Long) content.getField(fLayout.fieldPrevTid()).getValue()).intValue();
 284                 Long prevState = (Long) content.getField(fLayout.fieldPrevState()).getValue();
 285                 String nextProcessName = (String) content.getField(fLayout.fieldNextComm()).getValue();
 286                 Integer nextTid = ((Long) content.getField(fLayout.fieldNextTid()).getValue()).intValue();
 287                 Integer nextPrio = ((Long) content.getField(fLayout.fieldNextPrio()).getValue()).intValue();
 288
 289                 Integer formerThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), prevTid.toString());
 290                 Integer newCurrentThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), nextTid.toString());
 291
 292                 /*
 293                  * Empirical observations and look into the linux code have
 294                  * shown that the TASK_STATE_MAX flag is used internally and
 295                  * |'ed with other states, most often the running state, so it
 296                  * is ignored from the prevState value.
 297                  */
 298                 prevState = prevState & ~(LinuxValues.TASK_STATE_MAX);
 299
 300                 /* Set the status of the process that got scheduled out. */
 301                 switch (prevState.intValue()) {
 302                 case LinuxValues.TASK_STATE_RUNNING:
 303                     value = StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE;
 304                     break;
 305                 case LinuxValues.TASK_INTERRUPTIBLE:
 306                 case LinuxValues.TASK_UNINTERRUPTIBLE:
 307                     value = StateValues.PROCESS_STATUS_WAIT_BLOCKED_VALUE;
 308                     break;
 309                 case LinuxValues.TASK_DEAD:
 310                     value = TmfStateValue.nullValue();
 311                     break;
 312                 default:
 313                     value = StateValues.PROCESS_STATUS_WAIT_UNKNOWN_VALUE;
 314                     break;
 315                 }
 316
 317                 quark = ss.getQuarkRelativeAndAdd(formerThreadNode, Attributes.STATUS);
 318                 ss.modifyAttribute(ts, value, quark);
 319
 320                 /* Set the status of the new scheduled process */
 321                 setProcessToRunning(ss, ts, newCurrentThreadNode);
 322
 323                 /* Set the exec name of the new process */
 324                 quark = ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.EXEC_NAME);
 325                 value = TmfStateValue.newValueString(nextProcessName);
 326                 ss.modifyAttribute(ts, value, quark);
 327
 328                 /* Set the current prio for the new process */
 329                 quark = ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.PRIO);
 330                 value = TmfStateValue.newValueInt(nextPrio);
 331                 ss.modifyAttribute(ts, value, quark);
 332
 333                 /* Make sure the PPID and system_call sub-attributes exist */
 334                 ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.SYSTEM_CALL);
 335                 ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.PPID);
 336
 337                 /* Set the current scheduled process on the relevant CPU */
 338                 quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.CURRENT_THREAD);
 339                 value = TmfStateValue.newValueInt(nextTid);
 340                 ss.modifyAttribute(ts, value, quark);
 341
 342                 /* Set the status of the CPU itself */
 343                 if (nextTid > 0) {
 344                     /* Check if the entering process is in kernel or user mode */
 345                     quark = ss.getQuarkRelativeAndAdd(newCurrentThreadNode, Attributes.SYSTEM_CALL);
 346                     if (ss.queryOngoingState(quark).isNull()) {
 347                         value = StateValues.CPU_STATUS_RUN_USERMODE_VALUE;
 348                     } else {
 349                         value = StateValues.CPU_STATUS_RUN_SYSCALL_VALUE;
 350                     }
 351                 } else {
 352                     value = StateValues.CPU_STATUS_IDLE_VALUE;
 353                 }
 354                 quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.STATUS);
 355                 ss.modifyAttribute(ts, value, quark);
 356             }
 357                 break;
 358
 359             case SCHED_PI_SETPRIO_INDEX:
 360             {
 361                 ITmfEventField content = event.getContent();
 362                 Integer tid = ((Long) content.getField(fLayout.fieldTid()).getValue()).intValue();
 363                 Integer prio = ((Long) content.getField(fLayout.fieldNewPrio()).getValue()).intValue();
 364
 365                 Integer updateThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), tid.toString());
 366
 367                 /* Set the current prio for the new process */
 368                 quark = ss.getQuarkRelativeAndAdd(updateThreadNode, Attributes.PRIO);
 369                 value = TmfStateValue.newValueInt(prio);
 370                 ss.modifyAttribute(ts, value, quark);
 371             }
 372                 break;
 373
 374             case SCHED_PROCESS_FORK_INDEX:
 375             {
 376                 ITmfEventField content = event.getContent();
 377                 // String parentProcessName = (String) event.getFieldValue("parent_comm");
 378                 String childProcessName = (String) content.getField(fLayout.fieldChildComm()).getValue();
 379                 // assert ( parentProcessName.equals(childProcessName) );
 380
 381                 Integer parentTid = ((Long) content.getField(fLayout.fieldParentTid()).getValue()).intValue();
 382                 Integer childTid = ((Long) content.getField(fLayout.fieldChildTid()).getValue()).intValue();
 383
 384                 Integer parentTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), parentTid.toString());
 385                 Integer childTidNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), childTid.toString());
 386
 387                 /* Assign the PPID to the new process */
 388                 quark = ss.getQuarkRelativeAndAdd(childTidNode, Attributes.PPID);
 389                 value = TmfStateValue.newValueInt(parentTid);
 390                 ss.modifyAttribute(ts, value, quark);
 391
 392                 /* Set the new process' exec_name */
 393                 quark = ss.getQuarkRelativeAndAdd(childTidNode, Attributes.EXEC_NAME);
 394                 value = TmfStateValue.newValueString(childProcessName);
 395                 ss.modifyAttribute(ts, value, quark);
 396
 397                 /* Set the new process' status */
 398                 quark = ss.getQuarkRelativeAndAdd(childTidNode, Attributes.STATUS);
 399                 value = StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE;
 400                 ss.modifyAttribute(ts, value, quark);
 401
 402                 /* Set the process' syscall name, to be the same as the parent's */
 403                 quark = ss.getQuarkRelativeAndAdd(parentTidNode, Attributes.SYSTEM_CALL);
 404                 value = ss.queryOngoingState(quark);
 405                 if (value.isNull()) {
 406                     /*
 407                      * Maybe we were missing info about the parent? At least we
 408                      * will set the child right. Let's suppose "sys_clone".
 409                      */
 410                     value = TmfStateValue.newValueString(fLayout.eventSyscallEntryPrefix() + IKernelAnalysisEventLayout.INITIAL_SYSCALL_NAME);
 411                 }
 412                 quark = ss.getQuarkRelativeAndAdd(childTidNode, Attributes.SYSTEM_CALL);
 413                 ss.modifyAttribute(ts, value, quark);
 414             }
 415                 break;
 416
 417             case SCHED_PROCESS_EXIT_INDEX:
 418                 break;
 419
 420             case SCHED_PROCESS_FREE_INDEX:
 421             {
 422                 Integer tid = ((Long) event.getContent().getField(fLayout.fieldTid()).getValue()).intValue();
 423                 /*
 424                  * Remove the process and all its sub-attributes from the
 425                  * current state
 426                  */
 427                 quark = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), tid.toString());
 428                 ss.removeAttribute(ts, quark);
 429             }
 430                 break;
 431
 432             case STATEDUMP_PROCESS_STATE_INDEX:
 433                 /* LTTng-specific */
 434             {
 435                 ITmfEventField content = event.getContent();
 436                 int tid = ((Long) content.getField("tid").getValue()).intValue(); //$NON-NLS-1$
 437                 int pid = ((Long) content.getField("pid").getValue()).intValue(); //$NON-NLS-1$
 438                 int ppid = ((Long) content.getField("ppid").getValue()).intValue(); //$NON-NLS-1$
 439                 int status = ((Long) content.getField("status").getValue()).intValue(); //$NON-NLS-1$
 440                 String name = (String) content.getField("name").getValue(); //$NON-NLS-1$
 441                 /*
 442                  * "mode" could be interesting too, but it doesn't seem to be
 443                  * populated with anything relevant for now.
 444                  */
 445
 446                 int curThreadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(tid));
 447
 448                 /* Set the process' name */
 449                 quark = ss.getQuarkRelativeAndAdd(curThreadNode, Attributes.EXEC_NAME);
 450                 if (ss.queryOngoingState(quark).isNull()) {
 451                     /* If the value didn't exist previously, set it */
 452                     value = TmfStateValue.newValueString(name);
 453                     ss.modifyAttribute(ts, value, quark);
 454                 }
 455
 456                 /* Set the process' PPID */
 457                 quark = ss.getQuarkRelativeAndAdd(curThreadNode, Attributes.PPID);
 458                 if (ss.queryOngoingState(quark).isNull()) {
 459                     if (pid == tid) {
 460                         /* We have a process. Use the 'PPID' field. */
 461                         value = TmfStateValue.newValueInt(ppid);
 462                     } else {
 463                         /* We have a thread, use the 'PID' field for the parent. */
 464                         value = TmfStateValue.newValueInt(pid);
 465                     }
 466                     ss.modifyAttribute(ts, value, quark);
 467                 }
 468
 469                 /* Set the process' status */
 470                 quark = ss.getQuarkRelativeAndAdd(curThreadNode, Attributes.STATUS);
 471                 if (ss.queryOngoingState(quark).isNull()) {
 472                     switch (status) {
 473                     case LinuxValues.STATEDUMP_PROCESS_STATUS_WAIT_CPU:
 474                         value = StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE;
 475                         break;
 476                     case LinuxValues.STATEDUMP_PROCESS_STATUS_WAIT:
 477                         /*
 478                          * We have no information on what the process is waiting
 479                          * on (unlike a sched_switch for example), so we will
 480                          * use the WAIT_UNKNOWN state instead of the "normal"
 481                          * WAIT_BLOCKED state.
 482                          */
 483                         value = StateValues.PROCESS_STATUS_WAIT_UNKNOWN_VALUE;
 484                         break;
 485                     default:
 486                         value = StateValues.PROCESS_STATUS_UNKNOWN_VALUE;
 487                     }
 488                     ss.modifyAttribute(ts, value, quark);
 489                 }
 490             }
 491                 break;
 492
 493             case SCHED_WAKEUP_INDEX:
 494             {
 495                 final int tid = ((Long) event.getContent().getField(fLayout.fieldTid()).getValue()).intValue();
 496                 final int prio = ((Long) event.getContent().getField(fLayout.fieldPrio()).getValue()).intValue();
 497                 final int threadNode = ss.getQuarkRelativeAndAdd(getNodeThreads(ss), String.valueOf(tid));
 498
 499                 /*
 500                  * The process indicated in the event's payload is now ready to
 501                  * run. Assign it to the "wait for cpu" state, but only if it
 502                  * was not already running.
 503                  */
 504                 quark = ss.getQuarkRelativeAndAdd(threadNode, Attributes.STATUS);
 505                 int status = ss.queryOngoingState(quark).unboxInt();
 506
 507                 if (status != StateValues.PROCESS_STATUS_RUN_SYSCALL &&
 508                     status != StateValues.PROCESS_STATUS_RUN_USERMODE) {
 509                     value = StateValues.PROCESS_STATUS_WAIT_FOR_CPU_VALUE;
 510                     ss.modifyAttribute(ts, value, quark);
 511                 }
 512
 513                 /*
 514                  * When a user changes a threads prio (e.g. with pthread_setschedparam),
 515                  * it shows in ftrace with a sched_wakeup.
 516                  */
 517                 quark = ss.getQuarkRelativeAndAdd(threadNode, Attributes.PRIO);
 518                 value = TmfStateValue.newValueInt(prio);
 519                 ss.modifyAttribute(ts, value, quark);
 520             }
 521                 break;
 522
 523             default:
 524             /* Other event types not covered by the main switch */
 525             {
 526                 if (eventName.startsWith(fLayout.eventSyscallEntryPrefix())
 527                         || eventName.startsWith(fLayout.eventCompatSyscallEntryPrefix())) {
 528
 529                     /* Assign the new system call to the process */
 530                     quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.SYSTEM_CALL);
 531                     value = TmfStateValue.newValueString(eventName);
 532                     ss.modifyAttribute(ts, value, quark);
 533
 534                     /* Put the process in system call mode */
 535                     quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS);
 536                     value = StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE;
 537                     ss.modifyAttribute(ts, value, quark);
 538
 539                     /* Put the CPU in system call (kernel) mode */
 540                     quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.STATUS);
 541                     value = StateValues.CPU_STATUS_RUN_SYSCALL_VALUE;
 542                     ss.modifyAttribute(ts, value, quark);
 543
 544                 } else if (eventName.startsWith(fLayout.eventSyscallExitPrefix())) {
 545
 546                     /* Clear the current system call on the process */
 547                     quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.SYSTEM_CALL);
 548                     value = TmfStateValue.nullValue();
 549                     ss.modifyAttribute(ts, value, quark);
 550
 551                     /* Put the process' status back to user mode */
 552                     quark = ss.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS);
 553                     value = StateValues.PROCESS_STATUS_RUN_USERMODE_VALUE;
 554                     ss.modifyAttribute(ts, value, quark);
 555
 556                     /* Put the CPU's status back to user mode */
 557                     quark = ss.getQuarkRelativeAndAdd(currentCPUNode, Attributes.STATUS);
 558                     value = StateValues.CPU_STATUS_RUN_USERMODE_VALUE;
 559                     ss.modifyAttribute(ts, value, quark);
 560                 }
 561
 562             }
 563                 break;
 564             } // End of big switch
 565
 566         } catch (AttributeNotFoundException ae) {
 567             /*
 568              * This would indicate a problem with the logic of the manager here,
 569              * so it shouldn't happen.
 570              */
 571             ae.printStackTrace();
 572
 573         } catch (TimeRangeException tre) {
 574             /*
 575              * This would happen if the events in the trace aren't ordered
 576              * chronologically, which should never be the case ...
 577              */
 578             System.err.println("TimeRangeExcpetion caught in the state system's event manager."); //$NON-NLS-1$
 579             System.err.println("Are the events in the trace correctly ordered?"); //$NON-NLS-1$
 580             tre.printStackTrace();
 581
 582         } catch (StateValueTypeException sve) {
 583             /*
 584              * This would happen if we were trying to push/pop attributes not of
 585              * type integer. Which, once again, should never happen.
 586              */
 587             sve.printStackTrace();
 588         }
 589     }
 590
 591     // ------------------------------------------------------------------------
 592     // Convenience methods for commonly-used attribute tree locations
 593     // ------------------------------------------------------------------------
 594
 595     private static int getNodeCPUs(ITmfStateSystemBuilder ssb) {
 596         return ssb.getQuarkAbsoluteAndAdd(Attributes.CPUS);
 597     }
 598
 599     private static int getNodeThreads(ITmfStateSystemBuilder ssb) {
 600         return ssb.getQuarkAbsoluteAndAdd(Attributes.THREADS);
 601     }
 602
 603     private static int getNodeIRQs(ITmfStateSystemBuilder ssb) {
 604         return ssb.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.IRQS);
 605     }
 606
 607     private static int getNodeSoftIRQs(ITmfStateSystemBuilder ssb) {
 608         return ssb.getQuarkAbsoluteAndAdd(Attributes.RESOURCES, Attributes.SOFT_IRQS);
 609     }
 610
 611     // ------------------------------------------------------------------------
 612     // Advanced state-setting methods
 613     // ------------------------------------------------------------------------
 614
 615     /**
 616      * When we want to set a process back to a "running" state, first check
 617      * its current System_call attribute. If there is a system call active, we
 618      * put the process back in the syscall state. If not, we put it back in
 619      * user mode state.
 620      */
 621     private static void setProcessToRunning(ITmfStateSystemBuilder ssb, long ts, int currentThreadNode)
 622             throws AttributeNotFoundException, TimeRangeException,
 623             StateValueTypeException {
 624         int quark;
 625         ITmfStateValue value;
 626
 627         quark = ssb.getQuarkRelativeAndAdd(currentThreadNode, Attributes.SYSTEM_CALL);
 628         if (ssb.queryOngoingState(quark).isNull()) {
 629             /* We were in user mode before the interruption */
 630             value = StateValues.PROCESS_STATUS_RUN_USERMODE_VALUE;
 631         } else {
 632             /* We were previously in kernel mode */
 633             value = StateValues.PROCESS_STATUS_RUN_SYSCALL_VALUE;
 634         }
 635         quark = ssb.getQuarkRelativeAndAdd(currentThreadNode, Attributes.STATUS);
 636         ssb.modifyAttribute(ts, value, quark);
 637     }
 638
 639     /**
 640      * Similar logic as above, but to set the CPU's status when it's coming out
 641      * of an interruption.
 642      */
 643     private static void cpuExitInterrupt(ITmfStateSystemBuilder ssb, long ts,
 644             int currentCpuNode, int currentThreadNode)
 645             throws StateValueTypeException, AttributeNotFoundException,
 646             TimeRangeException {
 647         int quark;
 648         ITmfStateValue value;
 649
 650         quark = ssb.getQuarkRelativeAndAdd(currentCpuNode, Attributes.CURRENT_THREAD);
 651         if (ssb.queryOngoingState(quark).unboxInt() > 0) {
 652             /* There was a process on the CPU */
 653             quark = ssb.getQuarkRelative(currentThreadNode, Attributes.SYSTEM_CALL);
 654             if (ssb.queryOngoingState(quark).isNull()) {
 655                 /* That process was in user mode */
 656                 value = StateValues.CPU_STATUS_RUN_USERMODE_VALUE;
 657             } else {
 658                 /* That process was in a system call */
 659                 value = StateValues.CPU_STATUS_RUN_SYSCALL_VALUE;
 660             }
 661         } else {
 662             /* There was no real process scheduled, CPU was idle */
 663             value = StateValues.CPU_STATUS_IDLE_VALUE;
 664         }
 665         quark = ssb.getQuarkRelativeAndAdd(currentCpuNode, Attributes.STATUS);
 666         ssb.modifyAttribute(ts, value, quark);
 667     }
 668 }