1 /* SPDX-License-Identifier: GPL-2.0 */
3 #define TRACE_SYSTEM sched
5 #if !defined(LTTNG_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
6 #define LTTNG_TRACE_SCHED_H
8 #include <probes/lttng-tracepoint-event.h>
9 #include <linux/sched.h>
10 #include <linux/pid_namespace.h>
11 #include <linux/binfmts.h>
12 #include <linux/version.h>
13 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
14 #include <linux/sched/rt.h>
16 #include <wrapper/namespace.h>
18 #define LTTNG_MAX_PID_NS_LEVEL 32
20 #ifndef _TRACE_SCHED_DEF_
21 #define _TRACE_SCHED_DEF_
23 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
25 static inline long __trace_sched_switch_state(bool preempt
, struct task_struct
*p
)
29 #ifdef CONFIG_SCHED_DEBUG
31 #endif /* CONFIG_SCHED_DEBUG */
34 * Preemption ignores task state, therefore preempted tasks are always
35 * RUNNING (we will not have dequeued if state != RUNNING).
38 return TASK_REPORT_MAX
;
41 * task_state_index() uses fls() and returns a value from 0-8 range.
42 * Decrement it by 1 (except TASK_RUNNING state i.e 0) before using
43 * it for left shift operation to get the correct task->state
46 state
= task_state_index(p
);
48 return state
? (1 << (state
- 1)) : state
;
51 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
53 static inline long __trace_sched_switch_state(bool preempt
, struct task_struct
*p
)
57 #ifdef CONFIG_SCHED_DEBUG
59 #endif /* CONFIG_SCHED_DEBUG */
62 * Preemption ignores task state, therefore preempted tasks are always
63 * RUNNING (we will not have dequeued if state != RUNNING).
66 return TASK_REPORT_MAX
;
69 * __get_task_state() uses fls() and returns a value from 0-8 range.
70 * Decrement it by 1 (except TASK_RUNNING state i.e 0) before using
71 * it for left shift operation to get the correct task->state
74 state
= __get_task_state(p
);
76 return state
? (1 << (state
- 1)) : state
;
79 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
81 static inline long __trace_sched_switch_state(bool preempt
, struct task_struct
*p
)
83 #ifdef CONFIG_SCHED_DEBUG
85 #endif /* CONFIG_SCHED_DEBUG */
87 * Preemption ignores task state, therefore preempted tasks are always RUNNING
88 * (we will not have dequeued if state != RUNNING).
90 return preempt
? TASK_RUNNING
| TASK_STATE_MAX
: p
->state
;
93 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,19,0))
95 static inline long __trace_sched_switch_state(struct task_struct
*p
)
97 long state
= p
->state
;
100 #ifdef CONFIG_SCHED_DEBUG
101 BUG_ON(p
!= current
);
102 #endif /* CONFIG_SCHED_DEBUG */
104 * For all intents and purposes a preempted task is a running task.
106 if (preempt_count() & PREEMPT_ACTIVE
)
107 state
= TASK_RUNNING
| TASK_STATE_MAX
;
108 #endif /* CONFIG_PREEMPT */
113 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))
115 static inline long __trace_sched_switch_state(struct task_struct
*p
)
117 long state
= p
->state
;
119 #ifdef CONFIG_PREEMPT
121 * For all intents and purposes a preempted task is a running task.
123 if (task_preempt_count(p
) & PREEMPT_ACTIVE
)
124 state
= TASK_RUNNING
| TASK_STATE_MAX
;
130 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
132 static inline long __trace_sched_switch_state(struct task_struct
*p
)
134 long state
= p
->state
;
136 #ifdef CONFIG_PREEMPT
138 * For all intents and purposes a preempted task is a running task.
140 if (task_thread_info(p
)->preempt_count
& PREEMPT_ACTIVE
)
141 state
= TASK_RUNNING
| TASK_STATE_MAX
;
149 static inline long __trace_sched_switch_state(struct task_struct
*p
)
151 long state
= p
->state
;
153 #ifdef CONFIG_PREEMPT
155 * For all intents and purposes a preempted task is a running task.
157 if (task_thread_info(p
)->preempt_count
& PREEMPT_ACTIVE
)
158 state
= TASK_RUNNING
;
166 #endif /* _TRACE_SCHED_DEF_ */
169 * Tracepoint for calling kthread_stop, performed to end a kthread:
171 LTTNG_TRACEPOINT_EVENT(sched_kthread_stop
,
173 TP_PROTO(struct task_struct
*t
),
178 ctf_array_text(char, comm
, t
->comm
, TASK_COMM_LEN
)
179 ctf_integer(pid_t
, tid
, t
->pid
)
184 * Tracepoint for the return value of the kthread stopping:
186 LTTNG_TRACEPOINT_EVENT(sched_kthread_stop_ret
,
193 ctf_integer(int, ret
, ret
)
198 * Tracepoint for waking up a task:
200 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0) || \
201 LTTNG_RT_KERNEL_RANGE(4,1,10,11, 4,2,0,0) || \
202 LTTNG_RT_KERNEL_RANGE(3,18,27,26, 3,19,0,0) || \
203 LTTNG_RT_KERNEL_RANGE(3,14,61,63, 3,15,0,0) || \
204 LTTNG_RT_KERNEL_RANGE(3,12,54,73, 3,13,0,0) || \
205 LTTNG_RT_KERNEL_RANGE(3,10,97,106, 3,11,0,0) || \
206 LTTNG_RT_KERNEL_RANGE(3,4,110,139, 3,5,0,0) || \
207 LTTNG_RT_KERNEL_RANGE(3,2,77,111, 3,3,0,0))
208 LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template
,
210 TP_PROTO(struct task_struct
*p
),
215 ctf_array_text(char, comm
, p
->comm
, TASK_COMM_LEN
)
216 ctf_integer(pid_t
, tid
, p
->pid
)
217 ctf_integer(int, prio
, p
->prio
- MAX_RT_PRIO
)
218 ctf_integer(int, target_cpu
, task_cpu(p
))
221 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
222 LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template
,
224 TP_PROTO(struct task_struct
*p
, int success
),
229 ctf_array_text(char, comm
, p
->comm
, TASK_COMM_LEN
)
230 ctf_integer(pid_t
, tid
, p
->pid
)
231 ctf_integer(int, prio
, p
->prio
- MAX_RT_PRIO
)
232 ctf_integer(int, success
, success
)
233 ctf_integer(int, target_cpu
, task_cpu(p
))
236 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
238 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0) || \
239 LTTNG_RT_KERNEL_RANGE(4,1,10,11, 4,2,0,0) || \
240 LTTNG_RT_KERNEL_RANGE(3,18,27,26, 3,19,0,0) || \
241 LTTNG_RT_KERNEL_RANGE(3,14,61,63, 3,15,0,0) || \
242 LTTNG_RT_KERNEL_RANGE(3,12,54,73, 3,13,0,0) || \
243 LTTNG_RT_KERNEL_RANGE(3,10,97,106, 3,11,0,0) || \
244 LTTNG_RT_KERNEL_RANGE(3,4,110,139, 3,5,0,0) || \
245 LTTNG_RT_KERNEL_RANGE(3,2,77,111, 3,3,0,0))
248 * Tracepoint called when waking a task; this tracepoint is guaranteed to be
249 * called from the waking context.
251 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template
, sched_waking
,
252 TP_PROTO(struct task_struct
*p
),
256 * Tracepoint called when the task is actually woken; p->state == TASK_RUNNNG.
257 * It it not always called from the waking context.
259 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template
, sched_wakeup
,
260 TP_PROTO(struct task_struct
*p
),
264 * Tracepoint for waking up a new task:
266 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template
, sched_wakeup_new
,
267 TP_PROTO(struct task_struct
*p
),
272 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template
, sched_wakeup
,
273 TP_PROTO(struct task_struct
*p
, int success
),
277 * Tracepoint for waking up a new task:
279 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template
, sched_wakeup_new
,
280 TP_PROTO(struct task_struct
*p
, int success
),
283 #endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
286 * Tracepoint for task switches, performed by the scheduler:
288 LTTNG_TRACEPOINT_EVENT(sched_switch
,
290 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
291 TP_PROTO(bool preempt
,
292 struct task_struct
*prev
,
293 struct task_struct
*next
),
295 TP_ARGS(preempt
, prev
, next
),
297 TP_PROTO(struct task_struct
*prev
,
298 struct task_struct
*next
),
301 #endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0)) */
304 ctf_array_text(char, prev_comm
, prev
->comm
, TASK_COMM_LEN
)
305 ctf_integer(pid_t
, prev_tid
, prev
->pid
)
306 ctf_integer(int, prev_prio
, prev
->prio
- MAX_RT_PRIO
)
307 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
308 ctf_integer(long, prev_state
, __trace_sched_switch_state(preempt
, prev
))
310 ctf_integer(long, prev_state
, __trace_sched_switch_state(prev
))
312 ctf_array_text(char, next_comm
, next
->comm
, TASK_COMM_LEN
)
313 ctf_integer(pid_t
, next_tid
, next
->pid
)
314 ctf_integer(int, next_prio
, next
->prio
- MAX_RT_PRIO
)
319 * Tracepoint for a task being migrated:
321 LTTNG_TRACEPOINT_EVENT(sched_migrate_task
,
323 TP_PROTO(struct task_struct
*p
, int dest_cpu
),
325 TP_ARGS(p
, dest_cpu
),
328 ctf_array_text(char, comm
, p
->comm
, TASK_COMM_LEN
)
329 ctf_integer(pid_t
, tid
, p
->pid
)
330 ctf_integer(int, prio
, p
->prio
- MAX_RT_PRIO
)
331 ctf_integer(int, orig_cpu
, task_cpu(p
))
332 ctf_integer(int, dest_cpu
, dest_cpu
)
336 LTTNG_TRACEPOINT_EVENT_CLASS(sched_process_template
,
338 TP_PROTO(struct task_struct
*p
),
343 ctf_array_text(char, comm
, p
->comm
, TASK_COMM_LEN
)
344 ctf_integer(pid_t
, tid
, p
->pid
)
345 ctf_integer(int, prio
, p
->prio
- MAX_RT_PRIO
)
350 * Tracepoint for freeing a task:
352 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template
, sched_process_free
,
353 TP_PROTO(struct task_struct
*p
),
358 * Tracepoint for a task exiting:
360 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template
, sched_process_exit
,
361 TP_PROTO(struct task_struct
*p
),
365 * Tracepoint for waiting on task to unschedule:
367 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_process_template
, sched_wait_task
,
368 TP_PROTO(struct task_struct
*p
),
372 * Tracepoint for a waiting task:
374 LTTNG_TRACEPOINT_EVENT(sched_process_wait
,
376 TP_PROTO(struct pid
*pid
),
381 ctf_array_text(char, comm
, current
->comm
, TASK_COMM_LEN
)
382 ctf_integer(pid_t
, tid
, pid_nr(pid
))
383 ctf_integer(int, prio
, current
->prio
- MAX_RT_PRIO
)
388 * Tracepoint for do_fork.
389 * Saving both TID and PID information, especially for the child, allows
390 * trace analyzers to distinguish between creation of a new process and
391 * creation of a new thread. Newly created processes will have child_tid
392 * == child_pid, while creation of a thread yields to child_tid !=
395 LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork
,
397 TP_PROTO(struct task_struct
*parent
, struct task_struct
*child
),
399 TP_ARGS(parent
, child
),
402 pid_t vtids
[LTTNG_MAX_PID_NS_LEVEL
];
403 unsigned int ns_level
;
408 struct pid
*child_pid
;
411 child_pid
= task_pid(child
);
412 tp_locvar
->ns_level
=
413 min_t(unsigned int, child_pid
->level
+ 1,
414 LTTNG_MAX_PID_NS_LEVEL
);
415 for (i
= 0; i
< tp_locvar
->ns_level
; i
++)
416 tp_locvar
->vtids
[i
] = child_pid
->numbers
[i
].nr
;
421 ctf_array_text(char, parent_comm
, parent
->comm
, TASK_COMM_LEN
)
422 ctf_integer(pid_t
, parent_tid
, parent
->pid
)
423 ctf_integer(pid_t
, parent_pid
, parent
->tgid
)
424 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
425 ctf_integer(unsigned int, parent_ns_inum
,
427 unsigned int parent_ns_inum
= 0;
430 struct pid_namespace
*pid_ns
;
432 pid_ns
= task_active_pid_ns(parent
);
435 pid_ns
->lttng_ns_inum
;
440 ctf_array_text(char, child_comm
, child
->comm
, TASK_COMM_LEN
)
441 ctf_integer(pid_t
, child_tid
, child
->pid
)
442 ctf_sequence(pid_t
, vtids
, tp_locvar
->vtids
, u8
, tp_locvar
->ns_level
)
443 ctf_integer(pid_t
, child_pid
, child
->tgid
)
444 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
445 ctf_integer(unsigned int, child_ns_inum
,
447 unsigned int child_ns_inum
= 0;
450 struct pid_namespace
*pid_ns
;
452 pid_ns
= task_active_pid_ns(child
);
455 pid_ns
->lttng_ns_inum
;
465 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
467 * Tracepoint for exec:
469 LTTNG_TRACEPOINT_EVENT(sched_process_exec
,
471 TP_PROTO(struct task_struct
*p
, pid_t old_pid
,
472 struct linux_binprm
*bprm
),
474 TP_ARGS(p
, old_pid
, bprm
),
477 ctf_string(filename
, bprm
->filename
)
478 ctf_integer(pid_t
, tid
, p
->pid
)
479 ctf_integer(pid_t
, old_tid
, old_pid
)
485 * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
486 * adding sched_stat support to SCHED_FIFO/RR would be welcome.
488 LTTNG_TRACEPOINT_EVENT_CLASS(sched_stat_template
,
490 TP_PROTO(struct task_struct
*tsk
, u64 delay
),
495 ctf_array_text(char, comm
, tsk
->comm
, TASK_COMM_LEN
)
496 ctf_integer(pid_t
, tid
, tsk
->pid
)
497 ctf_integer(u64
, delay
, delay
)
503 * Tracepoint for accounting wait time (time the task is runnable
504 * but not actually running due to scheduler contention).
506 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template
, sched_stat_wait
,
507 TP_PROTO(struct task_struct
*tsk
, u64 delay
),
511 * Tracepoint for accounting sleep time (time the task is not runnable,
512 * including iowait, see below).
514 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template
, sched_stat_sleep
,
515 TP_PROTO(struct task_struct
*tsk
, u64 delay
),
519 * Tracepoint for accounting iowait time (time the task is not runnable
520 * due to waiting on IO to complete).
522 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template
, sched_stat_iowait
,
523 TP_PROTO(struct task_struct
*tsk
, u64 delay
),
526 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
528 * Tracepoint for accounting blocked time (time the task is in uninterruptible).
530 LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template
, sched_stat_blocked
,
531 TP_PROTO(struct task_struct
*tsk
, u64 delay
),
536 * Tracepoint for accounting runtime (time the task is executing
539 LTTNG_TRACEPOINT_EVENT(sched_stat_runtime
,
541 TP_PROTO(struct task_struct
*tsk
, u64 runtime
, u64 vruntime
),
543 TP_ARGS(tsk
, runtime
, vruntime
),
546 ctf_array_text(char, comm
, tsk
->comm
, TASK_COMM_LEN
)
547 ctf_integer(pid_t
, tid
, tsk
->pid
)
548 ctf_integer(u64
, runtime
, runtime
)
549 ctf_integer(u64
, vruntime
, vruntime
)
553 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0) || \
554 LTTNG_RT_KERNEL_RANGE(4,9,27,18, 4,10,0,0) || \
555 LTTNG_RT_KERNEL_RANGE(4,11,5,1, 4,12,0,0))
557 * Tracepoint for showing priority inheritance modifying a tasks
560 LTTNG_TRACEPOINT_EVENT(sched_pi_setprio
,
562 TP_PROTO(struct task_struct
*tsk
, struct task_struct
*pi_task
),
564 TP_ARGS(tsk
, pi_task
),
567 ctf_array_text(char, comm
, tsk
->comm
, TASK_COMM_LEN
)
568 ctf_integer(pid_t
, tid
, tsk
->pid
)
569 ctf_integer(int, oldprio
, tsk
->prio
- MAX_RT_PRIO
)
570 ctf_integer(int, newprio
, pi_task
? pi_task
->prio
- MAX_RT_PRIO
: tsk
->prio
- MAX_RT_PRIO
)
575 * Tracepoint for showing priority inheritance modifying a tasks
578 LTTNG_TRACEPOINT_EVENT(sched_pi_setprio
,
580 TP_PROTO(struct task_struct
*tsk
, int newprio
),
582 TP_ARGS(tsk
, newprio
),
585 ctf_array_text(char, comm
, tsk
->comm
, TASK_COMM_LEN
)
586 ctf_integer(pid_t
, tid
, tsk
->pid
)
587 ctf_integer(int, oldprio
, tsk
->prio
- MAX_RT_PRIO
)
588 ctf_integer(int, newprio
, newprio
- MAX_RT_PRIO
)
593 #endif /* LTTNG_TRACE_SCHED_H */
595 /* This part must be outside protection */
596 #include <probes/define_trace.h>
This page took 0.053462 seconds and 4 git commands to generate.