Add support for RHEL 9.1

[lttng-modules.git] / instrumentation / events / lttng-module / sched.h

diff --git a/instrumentation/events/lttng-module/sched.h b/instrumentation/events/lttng-module/sched.h
index 0f34ff15700782428349b9c2a638d16150811666..6549fbdee81ae942994b9aa53c8812e82d964cad 100644 (file)
--- a/instrumentation/events/lttng-module/sched.h
+++ b/instrumentation/events/lttng-module/sched.h
@@ -9,8 +9,8 @@
 #include <linux/sched.h>
 #include <linux/pid_namespace.h>
 #include <linux/binfmts.h>
-#include <linux/version.h>
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
+#include <lttng-kernel-version.h>
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0))
 #include <linux/sched/rt.h>
 #endif
 #include <wrapper/namespace.h>
@@ -20,7 +20,38 @@
 #ifndef _TRACE_SCHED_DEF_
 #define _TRACE_SCHED_DEF_
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,18,0) \
+       || LTTNG_RHEL_KERNEL_RANGE(5,14,0,162,0,0, 5,15,0,0,0,0))
+
+static inline long __trace_sched_switch_state(bool preempt,
+               unsigned int prev_state,
+               struct task_struct *p)
+{
+        unsigned int state;
+
+#ifdef CONFIG_SCHED_DEBUG
+        BUG_ON(p != current);
+#endif /* CONFIG_SCHED_DEBUG */
+
+        /*
+         * Preemption ignores task state, therefore preempted tasks are always
+         * RUNNING (we will not have dequeued if state != RUNNING).
+         */
+        if (preempt)
+                return TASK_REPORT_MAX;
+
+        /*
+         * task_state_index() uses fls() and returns a value from 0-8 range.
+         * Decrement it by 1 (except TASK_RUNNING state i.e 0) before using
+         * it for left shift operation to get the correct task->state
+         * mapping.
+         */
+       state = __task_state_index(prev_state, p->exit_state);
+
+        return state ? (1 << (state - 1)) : state;
+}
+
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,15,0))
 
 static inline long __trace_sched_switch_state(bool preempt, struct task_struct *p)
 {
@@ -48,7 +79,7 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
         return state ? (1 << (state - 1)) : state;
 }
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,14,0))
 
 static inline long __trace_sched_switch_state(bool preempt, struct task_struct *p)
 {
@@ -76,7 +107,7 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
         return state ? (1 << (state - 1)) : state;
 }
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,4,0))
 
 static inline long __trace_sched_switch_state(bool preempt, struct task_struct *p)
 {
@@ -90,7 +121,7 @@ static inline long __trace_sched_switch_state(bool preempt, struct task_struct *
        return preempt ? TASK_RUNNING | TASK_STATE_MAX : p->state;
 }
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,19,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,19,0))
 
 static inline long __trace_sched_switch_state(struct task_struct *p)
 {
@@ -110,7 +141,7 @@ static inline long __trace_sched_switch_state(struct task_struct *p)
        return state;
 }
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,13,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,13,0))
 
 static inline long __trace_sched_switch_state(struct task_struct *p)
 {
@@ -127,7 +158,7 @@ static inline long __trace_sched_switch_state(struct task_struct *p)
        return state;
 }
 
-#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,2,0))
 
 static inline long __trace_sched_switch_state(struct task_struct *p)
 {
@@ -165,6 +196,42 @@ static inline long __trace_sched_switch_state(struct task_struct *p)
 
 #endif /* _TRACE_SCHED_DEF_ */
 
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
+/*
+ * Enumeration of the task state bitmask.
+ * Only bit flags are enumerated here, not composition of states.
+ */
+LTTNG_TRACEPOINT_ENUM(task_state,
+       TP_ENUM_VALUES(
+               ctf_enum_value("TASK_RUNNING", TASK_RUNNING)
+               ctf_enum_value("TASK_INTERRUPTIBLE", TASK_INTERRUPTIBLE)
+               ctf_enum_value("TASK_UNINTERRUPTIBLE", TASK_UNINTERRUPTIBLE)
+               ctf_enum_value("TASK_STOPPED", __TASK_STOPPED)
+               ctf_enum_value("TASK_TRACED", __TASK_TRACED)
+               ctf_enum_value("EXIT_DEAD", EXIT_DEAD)
+               ctf_enum_value("EXIT_ZOMBIE", EXIT_ZOMBIE)
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0))
+               ctf_enum_value("TASK_PARKED", TASK_PARKED)
+#endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,9,0)) */
+
+               ctf_enum_value("TASK_DEAD", TASK_DEAD)
+               ctf_enum_value("TASK_WAKEKILL", TASK_WAKEKILL)
+               ctf_enum_value("TASK_WAKING", TASK_WAKING)
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,2,0))
+               ctf_enum_value("TASK_NOLOAD", TASK_NOLOAD)
+#endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,2,0)) */
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,8,0))
+               ctf_enum_value("TASK_NEW", TASK_NEW)
+#endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,8,0)) */
+
+               ctf_enum_value("TASK_STATE_MAX", TASK_STATE_MAX)
+       )
+)
+#endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
+
 /*
  * Tracepoint for calling kthread_stop, performed to end a kthread:
  */
@@ -197,7 +264,7 @@ LTTNG_TRACEPOINT_EVENT(sched_kthread_stop_ret,
 /*
  * Tracepoint for waking up a task:
  */
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0) || \
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,3,0) || \
        LTTNG_RT_KERNEL_RANGE(4,1,10,11, 4,2,0,0) || \
        LTTNG_RT_KERNEL_RANGE(3,18,27,26, 3,19,0,0) || \
        LTTNG_RT_KERNEL_RANGE(3,14,61,63, 3,15,0,0) || \
@@ -218,7 +285,7 @@ LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template,
                ctf_integer(int, target_cpu, task_cpu(p))
        )
 )
-#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
+#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,3,0)) */
 LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template,
 
        TP_PROTO(struct task_struct *p, int success),
@@ -233,9 +300,9 @@ LTTNG_TRACEPOINT_EVENT_CLASS(sched_wakeup_template,
                ctf_integer(int, target_cpu, task_cpu(p))
        )
 )
-#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
+#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,3,0)) */
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0) || \
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,3,0) || \
        LTTNG_RT_KERNEL_RANGE(4,1,10,11, 4,2,0,0) || \
        LTTNG_RT_KERNEL_RANGE(3,18,27,26, 3,19,0,0) || \
        LTTNG_RT_KERNEL_RANGE(3,14,61,63, 3,15,0,0) || \
@@ -280,32 +347,78 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_wakeup_template, sched_wakeup_new,
             TP_PROTO(struct task_struct *p, int success),
             TP_ARGS(p, success))
 
-#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,3,0)) */
+#endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,3,0)) */
 
 /*
  * Tracepoint for task switches, performed by the scheduler:
  */
+
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,18,0) \
+       || LTTNG_RHEL_KERNEL_RANGE(5,14,0,162,0,0, 5,15,0,0,0,0))
+LTTNG_TRACEPOINT_EVENT(sched_switch,
+
+       TP_PROTO(bool preempt,
+               struct task_struct *prev,
+               struct task_struct *next,
+               unsigned int prev_state),
+
+       TP_ARGS(preempt, prev, next, prev_state),
+
+       TP_FIELDS(
+               ctf_array_text(char, prev_comm, prev->comm, TASK_COMM_LEN)
+               ctf_integer(pid_t, prev_tid, prev->pid)
+               ctf_integer(int, prev_prio, prev->prio - MAX_RT_PRIO)
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
+               ctf_enum(task_state, long, prev_state, __trace_sched_switch_state(preempt, prev_state, prev))
+#else
+               ctf_integer(long, prev_state, __trace_sched_switch_state(preempt, prev_state, prev))
+#endif
+               ctf_array_text(char, next_comm, next->comm, TASK_COMM_LEN)
+               ctf_integer(pid_t, next_tid, next->pid)
+               ctf_integer(int, next_prio, next->prio - MAX_RT_PRIO)
+       )
+)
+
+#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,4,0))
+
 LTTNG_TRACEPOINT_EVENT(sched_switch,
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
        TP_PROTO(bool preempt,
                 struct task_struct *prev,
                 struct task_struct *next),
 
        TP_ARGS(preempt, prev, next),
+
+       TP_FIELDS(
+               ctf_array_text(char, prev_comm, prev->comm, TASK_COMM_LEN)
+               ctf_integer(pid_t, prev_tid, prev->pid)
+               ctf_integer(int, prev_prio, prev->prio - MAX_RT_PRIO)
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
+               ctf_enum(task_state, long, prev_state, __trace_sched_switch_state(preempt, prev))
 #else
+               ctf_integer(long, prev_state, __trace_sched_switch_state(preempt, prev))
+#endif
+               ctf_array_text(char, next_comm, next->comm, TASK_COMM_LEN)
+               ctf_integer(pid_t, next_tid, next->pid)
+               ctf_integer(int, next_prio, next->prio - MAX_RT_PRIO)
+       )
+)
+
+#else
+
+LTTNG_TRACEPOINT_EVENT(sched_switch,
+
        TP_PROTO(struct task_struct *prev,
                 struct task_struct *next),
 
        TP_ARGS(prev, next),
-#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0)) */
 
        TP_FIELDS(
                ctf_array_text(char, prev_comm, prev->comm, TASK_COMM_LEN)
                ctf_integer(pid_t, prev_tid, prev->pid)
                ctf_integer(int, prev_prio, prev->prio - MAX_RT_PRIO)
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0))
-               ctf_integer(long, prev_state, __trace_sched_switch_state(preempt, prev))
+#ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
+               ctf_enum(task_state, long, prev_state, __trace_sched_switch_state(prev))
 #else
                ctf_integer(long, prev_state, __trace_sched_switch_state(prev))
 #endif
@@ -314,6 +427,7 @@ LTTNG_TRACEPOINT_EVENT(sched_switch,
                ctf_integer(int, next_prio, next->prio - MAX_RT_PRIO)
        )
 )
+#endif
 
 /*
  * Tracepoint for a task being migrated:
@@ -421,7 +535,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork,
                ctf_array_text(char, parent_comm, parent->comm, TASK_COMM_LEN)
                ctf_integer(pid_t, parent_tid, parent->pid)
                ctf_integer(pid_t, parent_pid, parent->tgid)
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
                ctf_integer(unsigned int, parent_ns_inum,
                        ({
                                unsigned int parent_ns_inum = 0;
@@ -441,7 +555,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork,
                ctf_integer(pid_t, child_tid, child->pid)
                ctf_sequence(pid_t, vtids, tp_locvar->vtids, u8, tp_locvar->ns_level)
                ctf_integer(pid_t, child_pid, child->tgid)
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,8,0))
                ctf_integer(unsigned int, child_ns_inum,
                        ({
                                unsigned int child_ns_inum = 0;
@@ -462,7 +576,7 @@ LTTNG_TRACEPOINT_EVENT_CODE(sched_process_fork,
        TP_code_post()
 )
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
 /*
  * Tracepoint for exec:
  */
@@ -523,7 +637,7 @@ LTTNG_TRACEPOINT_EVENT_INSTANCE(sched_stat_template, sched_stat_iowait,
             TP_PROTO(struct task_struct *tsk, u64 delay),
             TP_ARGS(tsk, delay))
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,3,0))
 /*
  * Tracepoint for accounting blocked time (time the task is in uninterruptible).
  */
@@ -550,7 +664,7 @@ LTTNG_TRACEPOINT_EVENT(sched_stat_runtime,
        )
 )
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0) || \
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,12,0) || \
        LTTNG_RT_KERNEL_RANGE(4,9,27,18, 4,10,0,0) || \
        LTTNG_RT_KERNEL_RANGE(4,11,5,1, 4,12,0,0))
 /*