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