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("task %s:%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 * (NOTE: the 'rq' argument is not used by generic trace events, 56 * but used by the latency tracer plugin. ) 57 */ 58 TRACE_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 */ 86 TRACE_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 */ 117 TRACE_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 */ 148 TRACE_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 */ 188 TRACE_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 */ 218 TRACE_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 */ 243 TRACE_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 */ 268 TRACE_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 */ 293 TRACE_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 */ 321 TRACE_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