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 */ 13 TRACE_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("comm=%s pid=%d", __entry->comm, __entry->pid) 30 ); 31 32 /* 33 * Tracepoint for the return value of the kthread stopping: 34 */ 35 TRACE_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 waking up a task: 54 */ 55 DECLARE_EVENT_CLASS(sched_wakeup_template, 56 57 TP_PROTO(struct task_struct *p, int success), 58 59 TP_ARGS(p, success), 60 61 TP_STRUCT__entry( 62 __array( char, comm, TASK_COMM_LEN ) 63 __field( pid_t, pid ) 64 __field( int, prio ) 65 __field( int, success ) 66 __field( int, target_cpu ) 67 ), 68 69 TP_fast_assign( 70 memcpy(__entry->comm, p->comm, TASK_COMM_LEN); 71 __entry->pid = p->pid; 72 __entry->prio = p->prio; 73 __entry->success = success; 74 __entry->target_cpu = task_cpu(p); 75 ), 76 77 TP_printk("comm=%s pid=%d prio=%d success=%d target_cpu=%03d", 78 __entry->comm, __entry->pid, __entry->prio, 79 __entry->success, __entry->target_cpu) 80 ); 81 82 DEFINE_EVENT(sched_wakeup_template, sched_wakeup, 83 TP_PROTO(struct task_struct *p, int success), 84 TP_ARGS(p, success)); 85 86 /* 87 * Tracepoint for waking up a new task: 88 */ 89 DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, 90 TP_PROTO(struct task_struct *p, int success), 91 TP_ARGS(p, success)); 92 93 #ifdef CREATE_TRACE_POINTS 94 static inline long __trace_sched_switch_state(struct task_struct *p) 95 { 96 long state = p->state; 97 98 #ifdef CONFIG_PREEMPT 99 /* 100 * For all intents and purposes a preempted task is a running task. 101 */ 102 if (task_thread_info(p)->preempt_count & PREEMPT_ACTIVE) 103 state = TASK_RUNNING; 104 #endif 105 106 return state; 107 } 108 #endif 109 110 /* 111 * Tracepoint for task switches, performed by the scheduler: 112 */ 113 TRACE_EVENT(sched_switch, 114 115 TP_PROTO(struct task_struct *prev, 116 struct task_struct *next), 117 118 TP_ARGS(prev, next), 119 120 TP_STRUCT__entry( 121 __array( char, prev_comm, TASK_COMM_LEN ) 122 __field( pid_t, prev_pid ) 123 __field( int, prev_prio ) 124 __field( long, prev_state ) 125 __array( char, next_comm, TASK_COMM_LEN ) 126 __field( pid_t, next_pid ) 127 __field( int, next_prio ) 128 ), 129 130 TP_fast_assign( 131 memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN); 132 __entry->prev_pid = prev->pid; 133 __entry->prev_prio = prev->prio; 134 __entry->prev_state = __trace_sched_switch_state(prev); 135 memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN); 136 __entry->next_pid = next->pid; 137 __entry->next_prio = next->prio; 138 ), 139 140 TP_printk("prev_comm=%s prev_pid=%d prev_prio=%d prev_state=%s ==> next_comm=%s next_pid=%d next_prio=%d", 141 __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, 142 __entry->prev_state ? 143 __print_flags(__entry->prev_state, "|", 144 { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" }, 145 { 16, "Z" }, { 32, "X" }, { 64, "x" }, 146 { 128, "W" }) : "R", 147 __entry->next_comm, __entry->next_pid, __entry->next_prio) 148 ); 149 150 /* 151 * Tracepoint for a task being migrated: 152 */ 153 TRACE_EVENT(sched_migrate_task, 154 155 TP_PROTO(struct task_struct *p, int dest_cpu), 156 157 TP_ARGS(p, dest_cpu), 158 159 TP_STRUCT__entry( 160 __array( char, comm, TASK_COMM_LEN ) 161 __field( pid_t, pid ) 162 __field( int, prio ) 163 __field( int, orig_cpu ) 164 __field( int, dest_cpu ) 165 ), 166 167 TP_fast_assign( 168 memcpy(__entry->comm, p->comm, TASK_COMM_LEN); 169 __entry->pid = p->pid; 170 __entry->prio = p->prio; 171 __entry->orig_cpu = task_cpu(p); 172 __entry->dest_cpu = dest_cpu; 173 ), 174 175 TP_printk("comm=%s pid=%d prio=%d orig_cpu=%d dest_cpu=%d", 176 __entry->comm, __entry->pid, __entry->prio, 177 __entry->orig_cpu, __entry->dest_cpu) 178 ); 179 180 DECLARE_EVENT_CLASS(sched_process_template, 181 182 TP_PROTO(struct task_struct *p), 183 184 TP_ARGS(p), 185 186 TP_STRUCT__entry( 187 __array( char, comm, TASK_COMM_LEN ) 188 __field( pid_t, pid ) 189 __field( int, prio ) 190 ), 191 192 TP_fast_assign( 193 memcpy(__entry->comm, p->comm, TASK_COMM_LEN); 194 __entry->pid = p->pid; 195 __entry->prio = p->prio; 196 ), 197 198 TP_printk("comm=%s pid=%d prio=%d", 199 __entry->comm, __entry->pid, __entry->prio) 200 ); 201 202 /* 203 * Tracepoint for freeing a task: 204 */ 205 DEFINE_EVENT(sched_process_template, sched_process_free, 206 TP_PROTO(struct task_struct *p), 207 TP_ARGS(p)); 208 209 210 /* 211 * Tracepoint for a task exiting: 212 */ 213 DEFINE_EVENT(sched_process_template, sched_process_exit, 214 TP_PROTO(struct task_struct *p), 215 TP_ARGS(p)); 216 217 /* 218 * Tracepoint for waiting on task to unschedule: 219 */ 220 DEFINE_EVENT(sched_process_template, sched_wait_task, 221 TP_PROTO(struct task_struct *p), 222 TP_ARGS(p)); 223 224 /* 225 * Tracepoint for a waiting task: 226 */ 227 TRACE_EVENT(sched_process_wait, 228 229 TP_PROTO(struct pid *pid), 230 231 TP_ARGS(pid), 232 233 TP_STRUCT__entry( 234 __array( char, comm, TASK_COMM_LEN ) 235 __field( pid_t, pid ) 236 __field( int, prio ) 237 ), 238 239 TP_fast_assign( 240 memcpy(__entry->comm, current->comm, TASK_COMM_LEN); 241 __entry->pid = pid_nr(pid); 242 __entry->prio = current->prio; 243 ), 244 245 TP_printk("comm=%s pid=%d prio=%d", 246 __entry->comm, __entry->pid, __entry->prio) 247 ); 248 249 /* 250 * Tracepoint for do_fork: 251 */ 252 TRACE_EVENT(sched_process_fork, 253 254 TP_PROTO(struct task_struct *parent, struct task_struct *child), 255 256 TP_ARGS(parent, child), 257 258 TP_STRUCT__entry( 259 __array( char, parent_comm, TASK_COMM_LEN ) 260 __field( pid_t, parent_pid ) 261 __array( char, child_comm, TASK_COMM_LEN ) 262 __field( pid_t, child_pid ) 263 ), 264 265 TP_fast_assign( 266 memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN); 267 __entry->parent_pid = parent->pid; 268 memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN); 269 __entry->child_pid = child->pid; 270 ), 271 272 TP_printk("comm=%s pid=%d child_comm=%s child_pid=%d", 273 __entry->parent_comm, __entry->parent_pid, 274 __entry->child_comm, __entry->child_pid) 275 ); 276 277 /* 278 * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE 279 * adding sched_stat support to SCHED_FIFO/RR would be welcome. 280 */ 281 DECLARE_EVENT_CLASS(sched_stat_template, 282 283 TP_PROTO(struct task_struct *tsk, u64 delay), 284 285 TP_ARGS(tsk, delay), 286 287 TP_STRUCT__entry( 288 __array( char, comm, TASK_COMM_LEN ) 289 __field( pid_t, pid ) 290 __field( u64, delay ) 291 ), 292 293 TP_fast_assign( 294 memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN); 295 __entry->pid = tsk->pid; 296 __entry->delay = delay; 297 ) 298 TP_perf_assign( 299 __perf_count(delay); 300 ), 301 302 TP_printk("comm=%s pid=%d delay=%Lu [ns]", 303 __entry->comm, __entry->pid, 304 (unsigned long long)__entry->delay) 305 ); 306 307 308 /* 309 * Tracepoint for accounting wait time (time the task is runnable 310 * but not actually running due to scheduler contention). 311 */ 312 DEFINE_EVENT(sched_stat_template, sched_stat_wait, 313 TP_PROTO(struct task_struct *tsk, u64 delay), 314 TP_ARGS(tsk, delay)); 315 316 /* 317 * Tracepoint for accounting sleep time (time the task is not runnable, 318 * including iowait, see below). 319 */ 320 DEFINE_EVENT(sched_stat_template, sched_stat_sleep, 321 TP_PROTO(struct task_struct *tsk, u64 delay), 322 TP_ARGS(tsk, delay)); 323 324 /* 325 * Tracepoint for accounting iowait time (time the task is not runnable 326 * due to waiting on IO to complete). 327 */ 328 DEFINE_EVENT(sched_stat_template, sched_stat_iowait, 329 TP_PROTO(struct task_struct *tsk, u64 delay), 330 TP_ARGS(tsk, delay)); 331 332 /* 333 * Tracepoint for accounting runtime (time the task is executing 334 * on a CPU). 335 */ 336 TRACE_EVENT(sched_stat_runtime, 337 338 TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), 339 340 TP_ARGS(tsk, runtime, vruntime), 341 342 TP_STRUCT__entry( 343 __array( char, comm, TASK_COMM_LEN ) 344 __field( pid_t, pid ) 345 __field( u64, runtime ) 346 __field( u64, vruntime ) 347 ), 348 349 TP_fast_assign( 350 memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN); 351 __entry->pid = tsk->pid; 352 __entry->runtime = runtime; 353 __entry->vruntime = vruntime; 354 ) 355 TP_perf_assign( 356 __perf_count(runtime); 357 ), 358 359 TP_printk("comm=%s pid=%d runtime=%Lu [ns] vruntime=%Lu [ns]", 360 __entry->comm, __entry->pid, 361 (unsigned long long)__entry->runtime, 362 (unsigned long long)__entry->vruntime) 363 ); 364 365 /* 366 * Tracepoint for showing priority inheritance modifying a tasks 367 * priority. 368 */ 369 TRACE_EVENT(sched_pi_setprio, 370 371 TP_PROTO(struct task_struct *tsk, int newprio), 372 373 TP_ARGS(tsk, newprio), 374 375 TP_STRUCT__entry( 376 __array( char, comm, TASK_COMM_LEN ) 377 __field( pid_t, pid ) 378 __field( int, oldprio ) 379 __field( int, newprio ) 380 ), 381 382 TP_fast_assign( 383 memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN); 384 __entry->pid = tsk->pid; 385 __entry->oldprio = tsk->prio; 386 __entry->newprio = newprio; 387 ), 388 389 TP_printk("comm=%s pid=%d oldprio=%d newprio=%d", 390 __entry->comm, __entry->pid, 391 __entry->oldprio, __entry->newprio) 392 ); 393 394 #endif /* _TRACE_SCHED_H */ 395 396 /* This part must be outside protection */ 397 #include <trace/define_trace.h> 398