org.eclipse.tracecompass.lttng2.kernel.core/src/org/eclipse/tracecompass/lttng2/kernel/core/analysis/kernel/LttngKernelThreadInformationProvider.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  *   Geneviève Bastien - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.lttng2.kernel.core.analysis.kernel;
  14
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.List;
  18 import java.util.Set;
  19 import java.util.TreeSet;
  20
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.jdt.annotation.NonNull;
  23 import org.eclipse.jdt.annotation.Nullable;
  24 import org.eclipse.tracecompass.common.core.NonNullUtils;
  25 import org.eclipse.tracecompass.internal.lttng2.kernel.core.Attributes;
  26 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  27 import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
  28 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  29 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
  30 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  31 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  32 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  33
  34 /**
  35  * Information provider utility class that retrieves thread-related information
  36  * from a Linux Kernel Analysis
  37  *
  38  * @author Geneviève Bastien
  39  */
  40 public final class LttngKernelThreadInformationProvider {
  41
  42     private LttngKernelThreadInformationProvider() {
  43     }
  44
  45     /**
  46      * Get the ID of the thread running on the CPU at time ts
  47      *
  48      * TODO: This method may later be replaced by an aspect, when the aspect can
  49      * resolve to something that is not an event
  50      *
  51      * @param module
  52      *            The lttng kernel analysis instance to run this method on
  53      * @param cpuId
  54      *            The CPU number the process is running on
  55      * @param ts
  56      *            The timestamp at which we want the running process
  57      * @return The TID of the thread running on CPU cpuId at time ts or
  58      *         {@code null} if either no thread is running or we do not know.
  59      */
  60     public static @Nullable Integer getThreadOnCpu(LttngKernelAnalysis module, long cpuId, long ts) {
  61         ITmfStateSystem ss = module.getStateSystem();
  62         if (ss == null) {
  63             return null;
  64         }
  65         try {
  66             int cpuQuark = ss.getQuarkAbsolute(Attributes.CPUS, Long.toString(cpuId), Attributes.CURRENT_THREAD);
  67             ITmfStateInterval interval = ss.querySingleState(ts, cpuQuark);
  68             ITmfStateValue val = interval.getStateValue();
  69             switch (val.getType()) {
  70             case INTEGER:
  71                 return val.unboxInt();
  72             case LONG:
  73             case DOUBLE:
  74             case NULL:
  75             case STRING:
  76             default:
  77                 break;
  78             }
  79         } catch (AttributeNotFoundException | StateSystemDisposedException | TimeRangeException e) {
  80         }
  81         return null;
  82     }
  83
  84     /**
  85      * Get the TIDs of the threads from an analysis
  86      *
  87      * @param module
  88      *            The lttng kernel analysis instance to run this method on
  89      * @return The set of TIDs corresponding to the threads
  90      */
  91     public static @NonNull Collection<Integer> getThreadIds(LttngKernelAnalysis module) {
  92         ITmfStateSystem ss = module.getStateSystem();
  93         if (ss == null) {
  94             return NonNullUtils.checkNotNull(Collections.EMPTY_SET);
  95         }
  96         int threadQuark;
  97         try {
  98             threadQuark = ss.getQuarkAbsolute(Attributes.THREADS);
  99             Set<Integer> tids = new TreeSet<>();
 100             for (Integer quark : ss.getSubAttributes(threadQuark, false)) {
 101                 tids.add(Integer.parseInt(ss.getAttributeName(quark)));
 102             }
 103             return tids;
 104         } catch (AttributeNotFoundException e) {
 105         }
 106         return NonNullUtils.checkNotNull(Collections.EMPTY_SET);
 107     }
 108
 109     /**
 110      * Get the parent process ID of a thread
 111      *
 112      * @param module
 113      *            The lttng kernel analysis instance to run this method on
 114      * @param threadId
 115      *            The thread ID of the process for which to get the parent
 116      * @param ts
 117      *            The timestamp at which to get the parent
 118      * @return The parent PID or {@code null} if the PPID is not found.
 119      */
 120     public static @Nullable Integer getParentPid(LttngKernelAnalysis module, @NonNull Integer threadId, long ts) {
 121         Integer ppid = null;
 122         ITmfStateSystem ss = module.getStateSystem();
 123         if (ss == null) {
 124             return ppid;
 125         }
 126         Integer ppidNode;
 127         try {
 128             ppidNode = ss.getQuarkAbsolute(Attributes.THREADS, threadId.toString(), Attributes.PPID);
 129             ITmfStateInterval ppidInterval = ss.querySingleState(ts, ppidNode);
 130             ITmfStateValue ppidValue = ppidInterval.getStateValue();
 131
 132             switch (ppidValue.getType()) {
 133             case INTEGER:
 134                 ppid = NonNullUtils.checkNotNull(Integer.valueOf(ppidValue.unboxInt()));
 135                 break;
 136             case DOUBLE:
 137             case LONG:
 138             case NULL:
 139             case STRING:
 140             default:
 141                 break;
 142             }
 143         } catch (AttributeNotFoundException | StateSystemDisposedException | TimeRangeException e) {
 144         }
 145         return ppid;
 146     }
 147
 148     /**
 149      * Get the executable name of the thread ID. If the thread ID was used
 150      * multiple time or the name changed in between, it will return the last
 151      * name the thread has taken, or {@code null} if no name is found
 152      *
 153      * @param module
 154      *            The lttng kernel analysis instance to run this method on
 155      * @param threadId
 156      *            The thread ID of the process for which to get the name
 157      * @return The last executable name of this process, or {@code null} if not
 158      *         found
 159      */
 160     public static @Nullable String getExecutableName(LttngKernelAnalysis module, @NonNull Integer threadId) {
 161         String execName = null;
 162         ITmfStateSystem ss = module.getStateSystem();
 163         if (ss == null) {
 164             return execName;
 165         }
 166         Integer execNameNode;
 167         try {
 168             execNameNode = ss.getQuarkAbsolute(Attributes.THREADS, threadId.toString(), Attributes.EXEC_NAME);
 169             List<ITmfStateInterval> execNameIntervals = StateSystemUtils.queryHistoryRange(ss, execNameNode, ss.getStartTime(), ss.getCurrentEndTime());
 170
 171             ITmfStateValue execNameValue;
 172             for (ITmfStateInterval interval : execNameIntervals) {
 173                 execNameValue = interval.getStateValue();
 174                 switch (execNameValue.getType()) {
 175                 case STRING:
 176                     execName = NonNullUtils.checkNotNull(execNameValue.unboxStr());
 177                     break;
 178                 case DOUBLE:
 179                 case LONG:
 180                 case NULL:
 181                 case INTEGER:
 182                 default:
 183                     break;
 184                 }
 185             }
 186         } catch (AttributeNotFoundException | StateSystemDisposedException | TimeRangeException e) {
 187         }
 188         return execName;
 189     }
 190
 191     /**
 192      * Get the status intervals for a given thread with a resolution
 193      *
 194      * @param module
 195      *            The lttng kernel analysis instance to run this method on
 196      * @param threadId
 197      *            The ID of the thread to get the intervals for
 198      * @param start
 199      *            The start time of the requested range
 200      * @param end
 201      *            The end time of the requested range
 202      * @param resolution
 203      *            The resolution or the minimal time between the requested
 204      *            intervals. If interval times are smaller than resolution, only
 205      *            the first interval is returned, the others are ignored.
 206      * @param monitor
 207      *            A progress monitor for this task
 208      * @return The list of status intervals for this thread, an empty list is
 209      *         returned if either the state system is {@code null} or the quark
 210      *         is not found
 211      */
 212     public static @NonNull List<ITmfStateInterval> getStatusIntervalsForThread(LttngKernelAnalysis module, Integer threadId, long start, long end, long resolution, IProgressMonitor monitor) {
 213         ITmfStateSystem ss = module.getStateSystem();
 214         if (ss == null) {
 215             return NonNullUtils.checkNotNull(Collections.EMPTY_LIST);
 216         }
 217
 218         try {
 219             int threadQuark = ss.getQuarkAbsolute(Attributes.THREADS, threadId.toString());
 220             int statusQuark = ss.getQuarkRelative(threadQuark, Attributes.STATUS);
 221             List<ITmfStateInterval> statusIntervals = StateSystemUtils.queryHistoryRange(ss, statusQuark, Math.max(start, ss.getStartTime()), Math.min(end - 1, ss.getCurrentEndTime()), resolution, monitor);
 222             return statusIntervals;
 223         } catch (AttributeNotFoundException | StateSystemDisposedException | TimeRangeException e) {
 224         }
 225         return NonNullUtils.checkNotNull(Collections.EMPTY_LIST);
 226     }
 227
 228 }