new file mode 100644
@@ -0,0 +1,34 @@
+Monitor rtapp_block
+=======================
+
+- Name: rtapp_block - real time applications are undesirably blocked
+- Type: per-task linear temporal logic monitor
+- Author: Nam Cao <namcao@linutronix.de>
+
+Introduction
+------------
+
+Real time threads could be blocked and fail to finish their execution timely. For instance, they
+need to access shared resources which are already acquired by other threads. Or they could be
+waiting for non-realtime threads to signal them to proceed: as the non-realtime threads are not
+prioritized by the scheduler, the execution of realtime threads could be delayed indefinitely.
+These scenarios are often unintentional, and cause unexpected latency to the realtime application.
+
+The rtapp_block monitor reports this type of scenario, by monitoring for:
+
+ * Realtime threads going to sleep without explicitly asking for it (namely, with nanosleep
+ syscall).
+ * Realtime threads are woken up by non-realtime threads.
+
+How to fix the monitor's warnings?
+----------------------------------
+
+There is no single answer, the solution needs to be evaluated depending on the specific cases.
+
+If the realtime thread is blocked trying to take a `pthread_mutex_t` which is already taken by a
+non-realtime thread, the solution could be enabling priority inheritance for the mutex, so that the
+blocking non-realtime thread would be priority-boosted to run at realtime priority.
+
+If realtime thread needs to wait for non-realtime thread to signal it to proceed, perhaps the design
+needs to be reconsidered to remove this dependency. Often, the work executed by the realtime thread
+needs not to be realtime at all.
@@ -138,6 +138,18 @@ TRACE_EVENT(contention_end,
TP_printk("%p (ret=%d)", __entry->lock_addr, __entry->ret)
);
+#ifdef CONFIG_TRACE_RT_MUTEX_WAKE_WAITER
+DECLARE_TRACE(rt_mutex_wake_waiter_begin,
+ TP_PROTO(struct task_struct *task),
+ TP_ARGS(task))
+DECLARE_TRACE(rt_mutex_wake_waiter_end,
+ TP_PROTO(struct task_struct *task),
+ TP_ARGS(task))
+#else
+#define trace_rt_mutex_wake_waiter_begin(...)
+#define trace_rt_mutex_wake_waiter_end(...)
+#endif /* CONFIG_TRACE_RT_MUTEX */
+
#endif /* _TRACE_LOCK_H */
/* This part must be outside protection */
@@ -561,6 +561,8 @@ static __always_inline void rt_mutex_wake_q_add(struct rt_wake_q_head *wqh,
static __always_inline void rt_mutex_wake_up_q(struct rt_wake_q_head *wqh)
{
+ trace_rt_mutex_wake_waiter_begin(current);
+
if (IS_ENABLED(CONFIG_PREEMPT_RT) && wqh->rtlock_task) {
wake_up_state(wqh->rtlock_task, TASK_RTLOCK_WAIT);
put_task_struct(wqh->rtlock_task);
@@ -572,6 +574,8 @@ static __always_inline void rt_mutex_wake_up_q(struct rt_wake_q_head *wqh)
/* Pairs with preempt_disable() in mark_wakeup_next_waiter() */
preempt_enable();
+
+ trace_rt_mutex_wake_waiter_end(current);
}
/*
@@ -13,7 +13,7 @@ config DA_MON_EVENTS_ID
menuconfig RV
bool "Runtime Verification"
- depends on TRACING
+ select TRACING
help
Enable the kernel runtime verification infrastructure. RV is a
lightweight (yet rigorous) method that complements classical
@@ -29,6 +29,16 @@ source "kernel/trace/rv/monitors/wip/Kconfig"
source "kernel/trace/rv/monitors/wwnr/Kconfig"
# Add new monitors here
+config RV_MON_RTAPP_BLOCK
+ depends on RV
+ select DA_MON_EVENTS
+ select TRACE_IRQFLAGS
+ select TRACE_RT_MUTEX_WAKE_WAITER
+ bool "rtapp_block monitor"
+ help
+ Enable rtapp_wakeup which monitors that realtime tasks are not blocked.
+ For details, see Documentation/trace/rv/monitor_rtapp_block.rst.
+
config RV_REACTORS
bool "Runtime verification reactors"
default y
@@ -5,6 +5,8 @@ ccflags-y += -I $(src) # needed for trace events
obj-$(CONFIG_RV) += rv.o
obj-$(CONFIG_RV_MON_WIP) += monitors/wip/wip.o
obj-$(CONFIG_RV_MON_WWNR) += monitors/wwnr/wwnr.o
+obj-$(CONFIG_RV_MON_RTAPP_BLOCK) += monitors/rtapp_block/ba.o \
+ monitors/rtapp_block/rtapp_block.o
# Add new monitors here
obj-$(CONFIG_RV_REACTORS) += rv_reactors.o
obj-$(CONFIG_RV_REACT_PRINTK) += reactor_printk.o
new file mode 100644
@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * This file is generated, do not edit.
+ */
+#include <linux/rv.h>
+#include <rv/instrumentation.h>
+#include <trace/events/task.h>
+#include <trace/events/sched.h>
+
+#include "ba.h"
+
+static_assert(NUM_ATOM <= RV_MAX_LTL_ATOM);
+
+enum buchi_state {
+ INIT,
+ S3,
+ DEAD,
+};
+
+int rv_rtapp_block_task_slot = RV_PER_TASK_MONITOR_INIT;
+
+static void init_monitor(struct task_struct *task)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(task);
+
+ for (int i = 0; i < NUM_ATOM; ++i)
+ mon->atoms[i] = LTL_UNDETERMINED;
+ mon->state = INIT;
+}
+
+static void handle_task_newtask(void *data, struct task_struct *task, unsigned long flags)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(task);
+
+ init_monitor(task);
+
+ rv_rtapp_block_atoms_init(task, mon);
+ rv_rtapp_block_atoms_fetch(task, mon);
+}
+
+int rv_rtapp_block_init(size_t data_size)
+{
+ struct task_struct *g, *p;
+ int ret, cpu;
+
+ if (WARN_ON(data_size > RV_MAX_DATA_SIZE))
+ return -EINVAL;
+
+ ret = rv_get_task_monitor_slot();
+ if (ret < 0)
+ return ret;
+
+ rv_rtapp_block_task_slot = ret;
+
+ rv_attach_trace_probe("rtapp_block", task_newtask, handle_task_newtask);
+
+ read_lock(&tasklist_lock);
+
+ for_each_process_thread(g, p)
+ init_monitor(p);
+
+ for_each_present_cpu(cpu)
+ init_monitor(idle_task(cpu));
+
+ read_unlock(&tasklist_lock);
+
+ return 0;
+}
+
+void rv_rtapp_block_destroy(void)
+{
+ rv_put_task_monitor_slot(rv_rtapp_block_task_slot);
+ rv_rtapp_block_task_slot = RV_PER_TASK_MONITOR_INIT;
+
+ rv_detach_trace_probe("rtapp_block", task_newtask, handle_task_newtask);
+}
+
+static void illegal_state(struct task_struct *task, struct ltl_monitor *mon)
+{
+ mon->state = INIT;
+ rv_rtapp_block_error(task, mon);
+}
+
+static void rv_rtapp_block_attempt_start(struct task_struct *task, struct ltl_monitor *mon)
+{
+ int i;
+
+ mon = rv_rtapp_block_get_monitor(task);
+
+ rv_rtapp_block_atoms_fetch(task, mon);
+
+ for (i = 0; i < NUM_ATOM; ++i) {
+ if (mon->atoms[i] == LTL_UNDETERMINED)
+ return;
+ }
+
+ if (((!mon->atoms[WAKEUP_RT_TASK] || (mon->atoms[RT] || (mon->atoms[RT_MUTEX_WAKING_WAITER]
+ || (mon->atoms[STOPPING_WOKEN_TASK] || (mon->atoms[WOKEN_TASK_IS_MIGRATION] ||
+ mon->atoms[WOKEN_TASK_IS_RCU])))))) && (((!mon->atoms[USER_TASK] || !mon->atoms[RT]) ||
+ (!mon->atoms[SLEEP] || (mon->atoms[DO_NANOSLEEP] || mon->atoms[FUTEX_LOCK_WITH_PI])))))
+ mon->state = S3;
+ else
+ illegal_state(task, mon);
+}
+
+static void rv_rtapp_block_step(struct task_struct *task, struct ltl_monitor *mon)
+{
+ switch (mon->state) {
+ case S3:
+ if (((!mon->atoms[WAKEUP_RT_TASK] || (mon->atoms[RT] ||
+ (mon->atoms[RT_MUTEX_WAKING_WAITER] || (mon->atoms[STOPPING_WOKEN_TASK] ||
+ (mon->atoms[WOKEN_TASK_IS_MIGRATION] || mon->atoms[WOKEN_TASK_IS_RCU])))))) &&
+ (((!mon->atoms[USER_TASK] || !mon->atoms[RT]) || (!mon->atoms[SLEEP] ||
+ (mon->atoms[DO_NANOSLEEP] || mon->atoms[FUTEX_LOCK_WITH_PI])))))
+ mon->state = S3;
+ else
+ illegal_state(task, mon);
+ break;
+ case DEAD:
+ case INIT:
+ break;
+ default:
+ WARN_ON_ONCE(1);
+ }
+}
+
+void rv_rtapp_block_atom_update(struct task_struct *task, unsigned int atom, bool value)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(task);
+
+ rv_rtapp_block_atom_set(mon, atom, value);
+
+ if (mon->state == DEAD)
+ return;
+
+ if (mon->state == INIT)
+ rv_rtapp_block_attempt_start(task, mon);
+ if (mon->state == INIT)
+ return;
+
+ mon->atoms[atom] = value;
+
+ rv_rtapp_block_atoms_fetch(task, mon);
+
+ rv_rtapp_block_step(task, mon);
+}
new file mode 100644
@@ -0,0 +1,166 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * This file is generated, do not edit.
+ *
+ * This file includes necessary functions to glue the Buchi automaton and the kernel together.
+ * Some of these functions must be manually implemented (look for "Must be implemented", or just
+ * let the compiler tells you).
+ *
+ * Essentially, you need to manually define the meaning of the atomic propositions in the LTL
+ * property. The primary function for that is rv_rtapp_block_atom_update(), which can be called
+ * in tracepoints' handlers for example. In some specific cases where
+ * rv_rtapp_block_atom_update() is not convenient, rv_rtapp_block_atoms_fetch() can be used.
+ *
+ * rv_rtapp_block_init()/rv_rtapp_block_destroy() must be called while enabling/disabling
+ * the monitor.
+ *
+ * If the fields in struct ltl_monitor is not enough, extra custom data can be used. See
+ * rv_rtapp_block_get_data().
+ */
+
+#include <linux/sched.h>
+
+enum rtapp_block_atom {
+ DO_NANOSLEEP,
+ FUTEX_LOCK_WITH_PI,
+ RT,
+ RT_MUTEX_WAKING_WAITER,
+ SLEEP,
+ STOPPING_WOKEN_TASK,
+ USER_TASK,
+ WAKEUP_RT_TASK,
+ WOKEN_TASK_IS_MIGRATION,
+ WOKEN_TASK_IS_RCU,
+ NUM_ATOM
+};
+
+/**
+ * rv_rtapp_block_init
+ * @data_size: required custom data size, can be zero
+ *
+ * Must be called while enabling the monitor
+ */
+int rv_rtapp_block_init(size_t data_size);
+
+/**
+ * rv_rtapp_block_destroy
+ *
+ * must be called while disabling the monitor
+ */
+void rv_rtapp_block_destroy(void);
+
+/**
+ * rv_rtapp_block_error - report violation of the LTL property
+ * @task: the task violating the LTL property
+ * @mon: the LTL monitor
+ *
+ * Must be implemented. This function should invoke the RV reactor and the monitor's tracepoints.
+ */
+void rv_rtapp_block_error(struct task_struct *task, struct ltl_monitor *mon);
+
+extern int rv_rtapp_block_task_slot;
+
+/**
+ * rv_rtapp_block_get_monitor - get the struct ltl_monitor of a task
+ */
+static inline struct ltl_monitor *rv_rtapp_block_get_monitor(struct task_struct *task)
+{
+ return &task->rv[rv_rtapp_block_task_slot].ltl_mon;
+}
+
+/**
+ * rv_rtapp_block_atoms_init - initialize the atomic propositions
+ * @task: the task
+ * @mon: the LTL monitor
+ *
+ * Must be implemented. This function is called during task creation, and should initialize all
+ * atomic propositions. rv_rtapp_block_atom_set() should be used to implement this function.
+ *
+ * This function does not have to initialize atomic propositions that are updated by
+ * rv_rtapp_block_atoms_fetch(), because the two functions are called together.
+ */
+void rv_rtapp_block_atoms_init(struct task_struct *task, struct ltl_monitor *mon);
+
+/**
+ * rv_rtapp_block_atoms_fetch - fetch the atomic propositions
+ * @task: the task
+ * @mon: the LTL monitor
+ *
+ * Must be implemented. This function is called anytime the Buchi automaton is triggered. Its
+ * intended purpose is to update the atomic propositions which are expensive to trace and can be
+ * easily read from @task. rv_rtapp_block_atom_set() should be used to implement this function.
+ *
+ * Using this function may cause incorrect verification result if it is important for the LTL that
+ * the atomic propositions must be updated at the correct time. Therefore, if it is possible,
+ * updating atomic propositions should be done with rv_rtapp_block_atom_update() instead.
+ *
+ * An example where this function is useful is with the LTL property:
+ * always (RT imply not PAGEFAULT)
+ * (a realtime task does not raise page faults)
+ *
+ * In this example, adding tracepoints to track RT is complicated, because it is changed in
+ * differrent places (mutex's priority boosting, sched_setscheduler). Furthermore, for this LTL
+ * property, we don't care exactly when RT changes, as long as we have its correct value when
+ * PAGEFAULT==true. Therefore, it is better to update RT in rv_rtapp_block_atoms_fetch(), as it
+ * can easily be retrieved from task_struct.
+ *
+ * This function can be empty.
+ */
+void rv_rtapp_block_atoms_fetch(struct task_struct *task, struct ltl_monitor *mon);
+
+/**
+ * rv_rtapp_block_atom_update - update an atomic proposition
+ * @task: the task
+ * @atom: the atomic proposition, one of enum rtapp_block_atom
+ * @value: the new value for @atom
+ *
+ * Update an atomic proposition and trigger the Buchi atomaton to check for violation of the LTL
+ * property. This function can be called in tracepoints' handler, for example.
+ */
+void rv_rtapp_block_atom_update(struct task_struct *task, unsigned int atom, bool value);
+
+/**
+ * rv_rtapp_block_atom_get - get an atomic proposition
+ * @mon: the monitor
+ * @atom: the atomic proposition, one of enum rtapp_block_atom
+ *
+ * Returns the value of an atomic proposition.
+ */
+static inline
+enum ltl_truth_value rv_rtapp_block_atom_get(struct ltl_monitor *mon, unsigned int atom)
+{
+ return mon->atoms[atom];
+}
+
+/**
+ * rv_rtapp_block_atom_set - set an atomic proposition
+ * @mon: the monitor
+ * @atom: the atomic proposition, one of enum rtapp_block_atom
+ * @value: the new value for @atom
+ *
+ * Update an atomic proposition without triggering the Buchi automaton. This can be useful to
+ * implement rv_rtapp_block_atoms_fetch() and rv_rtapp_block_atoms_init().
+ *
+ * Another use case for this function is when multiple atomic propositions change at the same time,
+ * because calling rv_rtapp_block_atom_update() (and thus triggering the Buchi automaton)
+ * multiple times may be incorrect. In that case, rv_rtapp_block_atom_set() can be used to avoid
+ * triggering the Buchi automaton, and rv_rtapp_block_atom_update() is only used for the last
+ * atomic proposition.
+ */
+static inline
+void rv_rtapp_block_atom_set(struct ltl_monitor *mon, unsigned int atom, bool value)
+{
+ mon->atoms[atom] = value;
+}
+
+/**
+ * rv_rtapp_block_get_data - get the custom data of this monitor.
+ * @mon: the monitor
+ *
+ * If this function is used, rv_rtapp_block_init() must have been called with a positive
+ * data_size.
+ */
+static inline void *rv_rtapp_block_get_data(struct ltl_monitor *mon)
+{
+ return &mon->data;
+}
new file mode 100644
@@ -0,0 +1,9 @@
+RULE = always (WAKEUP_RT_TASK imply (RT or WAKEUP_WHITELIST))
+ and always ((USER_TASK and RT) imply (SLEEP imply INTENTIONAL_SLEEP))
+
+INTENTIONAL_SLEEP = DO_NANOSLEEP or FUTEX_LOCK_WITH_PI
+
+WAKEUP_WHITELIST = RT_MUTEX_WAKING_WAITER
+ or STOPPING_WOKEN_TASK
+ or WOKEN_TASK_IS_MIGRATION
+ or WOKEN_TASK_IS_RCU
new file mode 100644
@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/ftrace.h>
+#include <linux/tracepoint.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched/rt.h>
+#include <linux/preempt.h>
+#include <linux/rv.h>
+
+#include <uapi/linux/futex.h>
+#include <trace/events/syscalls.h>
+#include <trace/events/sched.h>
+#include <trace/events/task.h>
+#include <trace/events/lock.h>
+#include <trace/events/preemptirq.h>
+
+#include <rv_trace.h>
+#include <rv/instrumentation.h>
+
+
+#include "ba.h"
+
+struct rtapp_block_data {
+ struct task_struct *woken_task;
+ struct task_struct *stopping_task;
+};
+
+static void handle_sys_enter(void *data, struct pt_regs *regs, long id)
+{
+ unsigned long args[6];
+ int op, cmd;
+
+ switch (id) {
+ case __NR_nanosleep:
+ case __NR_clock_nanosleep:
+#ifdef __NR_clock_nanosleep_time64
+ case __NR_clock_nanosleep_time64:
+#endif
+ rv_rtapp_block_atom_update(current, DO_NANOSLEEP, true);
+ break;
+
+ case __NR_futex:
+#ifdef __NR_futex_time64
+ case __NR_futex_time64:
+#endif
+ syscall_get_arguments(current, regs, args);
+ op = args[1];
+ cmd = op & FUTEX_CMD_MASK;
+
+ if (cmd == FUTEX_LOCK_PI || cmd == FUTEX_LOCK_PI2)
+ rv_rtapp_block_atom_update(current, FUTEX_LOCK_WITH_PI, true);
+ break;
+ }
+}
+
+static void handle_sys_exit(void *data, struct pt_regs *regs, long ret)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(current);
+
+ rv_rtapp_block_atom_set(mon, FUTEX_LOCK_WITH_PI, false);
+ rv_rtapp_block_atom_update(current, DO_NANOSLEEP, false);
+}
+
+static void handle_sched_switch(void *data, bool preempt, struct task_struct *prev,
+ struct task_struct *next, unsigned int prev_state)
+{
+ if (prev_state & TASK_INTERRUPTIBLE)
+ rv_rtapp_block_atom_update(prev, SLEEP, true);
+ rv_rtapp_block_atom_update(next, SLEEP, false);
+}
+
+void rv_rtapp_block_atoms_fetch(struct task_struct *task, struct ltl_monitor *mon)
+{
+ rv_rtapp_block_atom_set(mon, RT, rt_task(task));
+ rv_rtapp_block_atom_set(mon, USER_TASK, !(task->flags & PF_KTHREAD));
+}
+
+void rv_rtapp_block_atoms_init(struct task_struct *task, struct ltl_monitor *mon)
+{
+ rv_rtapp_block_atom_set(mon, SLEEP, false);
+ rv_rtapp_block_atom_set(mon, DO_NANOSLEEP, false);
+ rv_rtapp_block_atom_set(mon, FUTEX_LOCK_PI, false);
+ rv_rtapp_block_atom_set(mon, WAKEUP_RT_TASK, false);
+ rv_rtapp_block_atom_set(mon, RT_MUTEX_WAKING_WAITER, false);
+ rv_rtapp_block_atom_set(mon, STOPPING_WOKEN_TASK, false);
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_MIGRATION, false);
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_RCU, false);
+}
+
+static void handle_rt_mutex_wake_waiter_begin(void *, struct task_struct *task)
+{
+ rv_rtapp_block_atom_update(task, RT_MUTEX_WAKING_WAITER, true);
+}
+
+static void handle_rt_mutex_wake_waiter_end(void *, struct task_struct *task)
+{
+ rv_rtapp_block_atom_update(task, RT_MUTEX_WAKING_WAITER, false);
+}
+
+static void handle_sched_kthread_stop(void *, struct task_struct *task)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(current);
+ struct rtapp_block_data *data = rv_rtapp_block_get_data(mon);
+
+ data->stopping_task = task;
+}
+
+static void handle_sched_kthread_stop_ret(void *, int)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(current);
+ struct rtapp_block_data *data = rv_rtapp_block_get_data(mon);
+
+ data->stopping_task = NULL;
+}
+
+static void handle_sched_wakeup(void *, struct task_struct *task)
+{
+ struct ltl_monitor *mon = rv_rtapp_block_get_monitor(current);
+ struct rtapp_block_data *data = rv_rtapp_block_get_data(mon);
+
+ if (!in_task())
+ return;
+
+ if (this_cpu_read(hardirq_context))
+ return;
+
+ if (!rt_task(task))
+ return;
+
+ data->woken_task = task;
+
+ if (!strncmp(task->comm, "migration/", strlen("migration/")))
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_MIGRATION, true);
+ if (!strcmp(task->comm, "rcu_preempt"))
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_RCU, true);
+ if (data->stopping_task == data->woken_task)
+ rv_rtapp_block_atom_set(mon, STOPPING_WOKEN_TASK, true);
+
+ rv_rtapp_block_atom_update(current, WAKEUP_RT_TASK, true);
+
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_MIGRATION, false);
+ rv_rtapp_block_atom_set(mon, WOKEN_TASK_IS_RCU, false);
+ rv_rtapp_block_atom_set(mon, STOPPING_WOKEN_TASK, false);
+ rv_rtapp_block_atom_update(current, WAKEUP_RT_TASK, false);
+}
+
+static int enable_rtapp_block(void)
+{
+ int ret;
+
+ ret = rv_rtapp_block_init(sizeof(struct rtapp_block_data));
+
+ if (ret)
+ return ret;
+
+ rv_attach_trace_probe("rtapp_block", sched_wakeup, handle_sched_wakeup);
+ rv_attach_trace_probe("rtapp_block", rt_mutex_wake_waiter_begin,
+ handle_rt_mutex_wake_waiter_begin);
+ rv_attach_trace_probe("rtapp_block", rt_mutex_wake_waiter_end,
+ handle_rt_mutex_wake_waiter_end);
+ rv_attach_trace_probe("rtapp_block", sched_kthread_stop, handle_sched_kthread_stop);
+ rv_attach_trace_probe("rtapp_block", sched_kthread_stop_ret, handle_sched_kthread_stop_ret);
+ rv_attach_trace_probe("rtapp_block", sys_enter, handle_sys_enter);
+ rv_attach_trace_probe("rtapp_block", sys_exit, handle_sys_exit);
+ rv_attach_trace_probe("rtapp_block", sched_switch, handle_sched_switch);
+
+ return 0;
+}
+
+static void disable_rtapp_block(void)
+{
+ rv_detach_trace_probe("rtapp_block", sched_wakeup, handle_sched_wakeup);
+ rv_detach_trace_probe("rtapp_block", rt_mutex_wake_waiter_begin,
+ handle_rt_mutex_wake_waiter_begin);
+ rv_detach_trace_probe("rtapp_block", rt_mutex_wake_waiter_end,
+ handle_rt_mutex_wake_waiter_end);
+ rv_detach_trace_probe("rtapp_block", sched_kthread_stop, handle_sched_kthread_stop);
+ rv_detach_trace_probe("rtapp_block", sched_kthread_stop_ret, handle_sched_kthread_stop_ret);
+ rv_detach_trace_probe("rtapp_block", sys_enter, handle_sys_enter);
+ rv_detach_trace_probe("rtapp_block", sys_exit, handle_sys_exit);
+ rv_detach_trace_probe("rtapp_block", sched_switch, handle_sched_switch);
+
+ rv_rtapp_block_destroy();
+}
+
+static struct rv_monitor rv_rtapp_block = {
+ .name = "rtapp_block",
+ .description = "Monitor that RT tasks are not blocked by non-RT tasks",
+ .enable = enable_rtapp_block,
+ .disable = disable_rtapp_block,
+};
+
+void rv_rtapp_block_error(struct task_struct *task, struct ltl_monitor *mon)
+{
+ struct rtapp_block_data *data = rv_rtapp_block_get_data(mon);
+ struct task_struct *woken = data->woken_task;
+
+ bool sleep = rv_rtapp_block_atom_get(mon, SLEEP);
+
+ if (sleep)
+ trace_rtapp_block_sleep_error(task);
+ else
+ trace_rtapp_block_wakeup_error(task, woken);
+
+#ifdef CONFIG_RV_REACTORS
+ if (!rv_rtapp_block.react)
+ return;
+
+ if (sleep) {
+ rv_rtapp_block.react("rv: %s[%d](RT) is blocked\n", task->comm, task->pid);
+ } else {
+ rv_rtapp_block.react("rv: %s[%d](RT) was blocked %s[%d](non-RT)\n",
+ woken->comm, woken->pid,
+ task->comm, task->pid);
+ }
+#endif
+}
+
+static int __init register_rtapp_block(void)
+{
+ rv_register_monitor(&rv_rtapp_block);
+ return 0;
+}
+
+static void __exit unregister_rtapp_block(void)
+{
+ rv_unregister_monitor(&rv_rtapp_block);
+}
+
+module_init(register_rtapp_block);
+module_exit(unregister_rtapp_block);
@@ -121,6 +121,50 @@ DECLARE_EVENT_CLASS(error_da_monitor_id,
// Add new monitors based on CONFIG_DA_MON_EVENTS_ID here
#endif /* CONFIG_DA_MON_EVENTS_ID */
+#ifdef CONFIG_RV_MON_RTAPP_BLOCK
+TRACE_EVENT(rtapp_block_wakeup_error,
+
+ TP_PROTO(struct task_struct *task, struct task_struct *woken),
+
+ TP_ARGS(task, woken),
+
+ TP_STRUCT__entry(
+ __string(comm, task->comm)
+ __string(woken_comm, woken->comm)
+ __field(pid_t, pid)
+ __field(pid_t, woken_pid)
+ ),
+
+ TP_fast_assign(
+ __assign_str(comm);
+ __assign_str(woken_comm);
+ __entry->pid = task->pid;
+ __entry->woken_pid = woken->pid;
+ ),
+
+ TP_printk("rv: %s[%d](RT) was blocked by %s[%d](non-RT)\n",
+ __get_str(woken_comm), __entry->woken_pid,
+ __get_str(comm), __entry->pid)
+);
+TRACE_EVENT(rtapp_block_sleep_error,
+
+ TP_PROTO(struct task_struct *task),
+
+ TP_ARGS(task),
+
+ TP_STRUCT__entry(
+ __string(comm, task->comm)
+ __field(pid_t, pid)
+ ),
+
+ TP_fast_assign(
+ __assign_str(comm);
+ __entry->pid = task->pid;
+ ),
+
+ TP_printk("rv: %s[%d](RT) is blocked\n", __get_str(comm), __entry->pid)
+);
+#endif
#endif /* _TRACE_RV_H */
/* This part must be outside protection */
@@ -1638,6 +1638,9 @@ config TRACE_IRQFLAGS
Enables hooks to interrupt enabling and disabling for
either tracing or lock debugging.
+config TRACE_RT_MUTEX_WAKE_WAITER
+ bool
+
config TRACE_IRQFLAGS_NMI
def_bool y
depends on TRACE_IRQFLAGS
Add an RV monitor to detect realtime tasks getting blocked. For the full description, see Documentation/trace/rv/monitor_rtapp_block.rst. Signed-off-by: Nam Cao <namcao@linutronix.de> --- Cc: Peter Zijlstra <peterz@infradead.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Will Deacon <will@kernel.org> Cc: Boqun Feng <boqun.feng@gmail.com> Cc: Waiman Long <longman@redhat.com> --- .../trace/rv/monitor_rtapp_block.rst | 34 +++ include/trace/events/lock.h | 12 + kernel/locking/rtmutex.c | 4 + kernel/trace/rv/Kconfig | 12 +- kernel/trace/rv/Makefile | 2 + kernel/trace/rv/monitors/rtapp_block/ba.c | 146 +++++++++++ kernel/trace/rv/monitors/rtapp_block/ba.h | 166 +++++++++++++ kernel/trace/rv/monitors/rtapp_block/ltl | 9 + .../rv/monitors/rtapp_block/rtapp_block.c | 232 ++++++++++++++++++ kernel/trace/rv/rv_trace.h | 44 ++++ lib/Kconfig.debug | 3 + 11 files changed, 663 insertions(+), 1 deletion(-) create mode 100644 Documentation/trace/rv/monitor_rtapp_block.rst create mode 100644 kernel/trace/rv/monitors/rtapp_block/ba.c create mode 100644 kernel/trace/rv/monitors/rtapp_block/ba.h create mode 100644 kernel/trace/rv/monitors/rtapp_block/ltl create mode 100644 kernel/trace/rv/monitors/rtapp_block/rtapp_block.c