include/trace/sched_event_types.h

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