LXR linux/include/trace/events/sched.h

   1#undef TRACE_SYSTEM
   2#define TRACE_SYSTEM sched
   3
   4#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
   5#define _TRACE_SCHED_H
   6
   7#include <linux/sched.h>
   8#include <linux/tracepoint.h>
   9
  10/*
  11 * Tracepoint for calling kthread_stop, performed to end a kthread:
  12 */
  13TRACE_EVENT(sched_kthread_stop,
  14
  15        TP_PROTO(struct task_struct *t),
  16
  17        TP_ARGS(t),
  18
  19        TP_STRUCT__entry(
  20                __array(        char,   comm,   TASK_COMM_LEN   )
  21                __field(        pid_t,  pid                     )
  22        ),
  23
  24        TP_fast_assign(
  25                memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
  26                __entry->pid    = t->pid;
  27        ),
  28
  29        TP_printk("task %s:%d", __entry->comm, __entry->pid)
  30);
  31
  32/*
  33 * Tracepoint for the return value of the kthread stopping:
  34 */
  35TRACE_EVENT(sched_kthread_stop_ret,
  36
  37        TP_PROTO(int ret),
  38
  39        TP_ARGS(ret),
  40
  41        TP_STRUCT__entry(
  42                __field(        int,    ret     )
  43        ),
  44
  45        TP_fast_assign(
  46                __entry->ret    = ret;
  47        ),
  48
  49        TP_printk("ret %d", __entry->ret)
  50);
  51
  52/*
  53 * Tracepoint for waiting on task to unschedule:
  54 *
  55 * (NOTE: the 'rq' argument is not used by generic trace events,
  56 *        but used by the latency tracer plugin. )
  57 */
  58TRACE_EVENT(sched_wait_task,
  59
  60        TP_PROTO(struct rq *rq, struct task_struct *p),
  61
  62        TP_ARGS(rq, p),
  63
  64        TP_STRUCT__entry(
  65                __array(        char,   comm,   TASK_COMM_LEN   )
  66                __field(        pid_t,  pid                     )
  67                __field(        int,    prio                    )
  68        ),
  69
  70        TP_fast_assign(
  71                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
  72                __entry->pid    = p->pid;
  73                __entry->prio   = p->prio;
  74        ),
  75
  76        TP_printk("task %s:%d [%d]",
  77                  __entry->comm, __entry->pid, __entry->prio)
  78);
  79
  80/*
  81 * Tracepoint for waking up a task:
  82 *
  83 * (NOTE: the 'rq' argument is not used by generic trace events,
  84 *        but used by the latency tracer plugin. )
  85 */
  86TRACE_EVENT(sched_wakeup,
  87
  88        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
  89
  90        TP_ARGS(rq, p, success),
  91
  92        TP_STRUCT__entry(
  93                __array(        char,   comm,   TASK_COMM_LEN   )
  94                __field(        pid_t,  pid                     )
  95                __field(        int,    prio                    )
  96                __field(        int,    success                 )
  97        ),
  98
  99        TP_fast_assign(
 100                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 101                __entry->pid            = p->pid;
 102                __entry->prio           = p->prio;
 103                __entry->success        = success;
 104        ),
 105
 106        TP_printk("task %s:%d [%d] success=%d",
 107                  __entry->comm, __entry->pid, __entry->prio,
 108                  __entry->success)
 109);
 110
 111/*
 112 * Tracepoint for waking up a new task:
 113 *
 114 * (NOTE: the 'rq' argument is not used by generic trace events,
 115 *        but used by the latency tracer plugin. )
 116 */
 117TRACE_EVENT(sched_wakeup_new,
 118
 119        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
 120
 121        TP_ARGS(rq, p, success),
 122
 123        TP_STRUCT__entry(
 124                __array(        char,   comm,   TASK_COMM_LEN   )
 125                __field(        pid_t,  pid                     )
 126                __field(        int,    prio                    )
 127                __field(        int,    success                 )
 128        ),
 129
 130        TP_fast_assign(
 131                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 132                __entry->pid            = p->pid;
 133                __entry->prio           = p->prio;
 134                __entry->success        = success;
 135        ),
 136
 137        TP_printk("task %s:%d [%d] success=%d",
 138                  __entry->comm, __entry->pid, __entry->prio,
 139                  __entry->success)
 140);
 141
 142/*
 143 * Tracepoint for task switches, performed by the scheduler:
 144 *
 145 * (NOTE: the 'rq' argument is not used by generic trace events,
 146 *        but used by the latency tracer plugin. )
 147 */
 148TRACE_EVENT(sched_switch,
 149
 150        TP_PROTO(struct rq *rq, struct task_struct *prev,
 151                 struct task_struct *next),
 152
 153        TP_ARGS(rq, prev, next),
 154
 155        TP_STRUCT__entry(
 156                __array(        char,   prev_comm,      TASK_COMM_LEN   )
 157                __field(        pid_t,  prev_pid                        )
 158                __field(        int,    prev_prio                       )
 159                __field(        long,   prev_state                      )
 160                __array(        char,   next_comm,      TASK_COMM_LEN   )
 161                __field(        pid_t,  next_pid                        )
 162                __field(        int,    next_prio                       )
 163        ),
 164
 165        TP_fast_assign(
 166                memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
 167                __entry->prev_pid       = prev->pid;
 168                __entry->prev_prio      = prev->prio;
 169                __entry->prev_state     = prev->state;
 170                memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
 171                __entry->next_pid       = next->pid;
 172                __entry->next_prio      = next->prio;
 173        ),
 174
 175        TP_printk("task %s:%d [%d] (%s) ==> %s:%d [%d]",
 176                __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
 177                __entry->prev_state ?
 178                  __print_flags(__entry->prev_state, "|",
 179                                { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
 180                                { 16, "Z" }, { 32, "X" }, { 64, "x" },
 181                                { 128, "W" }) : "R",
 182                __entry->next_comm, __entry->next_pid, __entry->next_prio)
 183);
 184
 185/*
 186 * Tracepoint for a task being migrated:
 187 */
 188TRACE_EVENT(sched_migrate_task,
 189
 190        TP_PROTO(struct task_struct *p, int dest_cpu),
 191
 192        TP_ARGS(p, dest_cpu),
 193
 194        TP_STRUCT__entry(
 195                __array(        char,   comm,   TASK_COMM_LEN   )
 196                __field(        pid_t,  pid                     )
 197                __field(        int,    prio                    )
 198                __field(        int,    orig_cpu                )
 199                __field(        int,    dest_cpu                )
 200        ),
 201
 202        TP_fast_assign(
 203                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 204                __entry->pid            = p->pid;
 205                __entry->prio           = p->prio;
 206                __entry->orig_cpu       = task_cpu(p);
 207                __entry->dest_cpu       = dest_cpu;
 208        ),
 209
 210        TP_printk("task %s:%d [%d] from: %d  to: %d",
 211                  __entry->comm, __entry->pid, __entry->prio,
 212                  __entry->orig_cpu, __entry->dest_cpu)
 213);
 214
 215/*
 216 * Tracepoint for freeing a task:
 217 */
 218TRACE_EVENT(sched_process_free,
 219
 220        TP_PROTO(struct task_struct *p),
 221
 222        TP_ARGS(p),
 223
 224        TP_STRUCT__entry(
 225                __array(        char,   comm,   TASK_COMM_LEN   )
 226                __field(        pid_t,  pid                     )
 227                __field(        int,    prio                    )
 228        ),
 229
 230        TP_fast_assign(
 231                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 232                __entry->pid            = p->pid;
 233                __entry->prio           = p->prio;
 234        ),
 235
 236        TP_printk("task %s:%d [%d]",
 237                  __entry->comm, __entry->pid, __entry->prio)
 238);
 239
 240/*
 241 * Tracepoint for a task exiting:
 242 */
 243TRACE_EVENT(sched_process_exit,
 244
 245        TP_PROTO(struct task_struct *p),
 246
 247        TP_ARGS(p),
 248
 249        TP_STRUCT__entry(
 250                __array(        char,   comm,   TASK_COMM_LEN   )
 251                __field(        pid_t,  pid                     )
 252                __field(        int,    prio                    )
 253        ),
 254
 255        TP_fast_assign(
 256                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 257                __entry->pid            = p->pid;
 258                __entry->prio           = p->prio;
 259        ),
 260
 261        TP_printk("task %s:%d [%d]",
 262                  __entry->comm, __entry->pid, __entry->prio)
 263);
 264
 265/*
 266 * Tracepoint for a waiting task:
 267 */
 268TRACE_EVENT(sched_process_wait,
 269
 270        TP_PROTO(struct pid *pid),
 271
 272        TP_ARGS(pid),
 273
 274        TP_STRUCT__entry(
 275                __array(        char,   comm,   TASK_COMM_LEN   )
 276                __field(        pid_t,  pid                     )
 277                __field(        int,    prio                    )
 278        ),
 279
 280        TP_fast_assign(
 281                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 282                __entry->pid            = pid_nr(pid);
 283                __entry->prio           = current->prio;
 284        ),
 285
 286        TP_printk("task %s:%d [%d]",
 287                  __entry->comm, __entry->pid, __entry->prio)
 288);
 289
 290/*
 291 * Tracepoint for do_fork:
 292 */
 293TRACE_EVENT(sched_process_fork,
 294
 295        TP_PROTO(struct task_struct *parent, struct task_struct *child),
 296
 297        TP_ARGS(parent, child),
 298
 299        TP_STRUCT__entry(
 300                __array(        char,   parent_comm,    TASK_COMM_LEN   )
 301                __field(        pid_t,  parent_pid                      )
 302                __array(        char,   child_comm,     TASK_COMM_LEN   )
 303                __field(        pid_t,  child_pid                       )
 304        ),
 305
 306        TP_fast_assign(
 307                memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
 308                __entry->parent_pid     = parent->pid;
 309                memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
 310                __entry->child_pid      = child->pid;
 311        ),
 312
 313        TP_printk("parent %s:%d  child %s:%d",
 314                __entry->parent_comm, __entry->parent_pid,
 315                __entry->child_comm, __entry->child_pid)
 316);
 317
 318/*
 319 * Tracepoint for sending a signal:
 320 */
 321TRACE_EVENT(sched_signal_send,
 322
 323        TP_PROTO(int sig, struct task_struct *p),
 324
 325        TP_ARGS(sig, p),
 326
 327        TP_STRUCT__entry(
 328                __field(        int,    sig                     )
 329                __array(        char,   comm,   TASK_COMM_LEN   )
 330                __field(        pid_t,  pid                     )
 331        ),
 332
 333        TP_fast_assign(
 334                memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
 335                __entry->pid    = p->pid;
 336                __entry->sig    = sig;
 337        ),
 338
 339        TP_printk("sig: %d  task %s:%d",
 340                  __entry->sig, __entry->comm, __entry->pid)
 341);
 342
 343#endif /* _TRACE_SCHED_H */
 344
 345/* This part must be outside protection */
 346#include <trace/define_trace.h>
 347