Infrastructure for Litmus signals.prop/litmus-signals

Added signals to Litmus. Specifcally, SIG_BUDGET signals
are delivered (when requested by real-time tasks) when
a budget is exceeded.

Note: pfair not currently supported (but it probably could be).

10 files changed, 227 insertions, 66 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index 33344ee8d5f9..763b31c0e9f6 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -5,6 +5,9 @@
  * the next task. */
 void update_enforcement_timer(struct task_struct* t);
 
+/* Send SIG_BUDGET to a real-time task. */
+void send_sigbudget(struct task_struct* t);
+
 inline static int budget_exhausted(struct task_struct* t)
 {
         return get_exec_time(t) >= get_exec_cost(t);
@@ -19,10 +22,21 @@ inline static lt_t budget_remaining(struct task_struct* t)
                 return 0;
 }
 
-#define budget_enforced(t) (tsk_rt(t)->task_params.budget_policy != NO_ENFORCEMENT)
+#define budget_enforced(t) (\
+        tsk_rt(t)->task_params.budget_policy != NO_ENFORCEMENT)
+
+#define budget_precisely_tracked(t) (\
+        tsk_rt(t)->task_params.budget_policy == PRECISE_ENFORCEMENT || \
+        tsk_rt(t)->task_params.budget_signal_policy == PRECISE_SIGNALS)
+
+#define budget_signalled(t) (\
+        tsk_rt(t)->task_params.budget_signal_policy != NO_SIGNALS)
+
+#define budget_precisely_signalled(t) (\
+        tsk_rt(t)->task_params.budget_policy == PRECISE_SIGNALS)
 
-#define budget_precisely_enforced(t) (tsk_rt(t)->task_params.budget_policy \
-                                      == PRECISE_ENFORCEMENT)
+#define sigbudget_sent(t) (\
+        test_bit(RT_JOB_SIG_BUDGET_SENT, &tsk_rt(t)->job_params.flags))
 
 static inline int requeue_preempted_job(struct task_struct* t)
 {
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 89ac0dda7d3d..637fe6b84f9d 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -30,9 +30,15 @@ typedef enum {
 typedef enum {
         NO_ENFORCEMENT,      /* job may overrun unhindered */
         QUANTUM_ENFORCEMENT, /* budgets are only checked on quantum boundaries */
-        PRECISE_ENFORCEMENT  /* budgets are enforced with hrtimers */
+        PRECISE_ENFORCEMENT, /* budgets are enforced with hrtimers */
 } budget_policy_t;
 
+typedef enum {
+        NO_SIGNALS,                     /* job receives no signals when it exhausts its budget */
+        QUANTUM_SIGNALS,        /* budget signals are only sent on quantum boundaries */
+        PRECISE_SIGNALS,        /* budget signals are triggered with hrtimers */
+} budget_signal_policy_t;
+
 /* We use the common priority interpretation "lower index == higher priority",
  * which is commonly used in fixed-priority schedulability analysis papers.
  * So, a numerically lower priority value implies higher scheduling priority,
@@ -62,6 +68,7 @@ struct rt_task {
         unsigned int    priority;
         task_class_t    cls;
         budget_policy_t budget_policy; /* ignored by pfair */
+        budget_signal_policy_t budget_signal_policy; /* currently ignored by pfair */
 };
 
 union np_flag {
@@ -118,8 +125,15 @@ struct rt_job {
          * Increase this sequence number when a job is released.
          */
         unsigned int    job_no;
+
+        /* bits:
+         * 0th: Set if a budget exhaustion signal has already been sent for
+         *      the current job. */
+        unsigned long   flags;
 };
 
+#define RT_JOB_SIG_BUDGET_SENT  0
+
 struct pfair_param;
 
 /*      RT task parameters for scheduling extensions
diff --git a/include/litmus/signal.h b/include/litmus/signal.h
new file mode 100644
index 000000000000..b3d82b294984
--- /dev/null
+++ b/include/litmus/signal.h
@@ -0,0 +1,47 @@
+#ifndef LITMUS_SIGNAL_H
+#define LITMUS_SIGNAL_H
+
+#ifdef __KERNEL__
+#include <linux/signal.h>
+#else
+#include <signal.h>
+#endif
+
+/* Signals used by Litmus to asynchronously communicate events
+ * to real-time tasks.
+ * 
+ * Signal values overlap with [SIGRTMIN, SIGRTMAX], so beware of
+ * application-level conflicts when dealing with COTS user-level
+ * code.
+ */
+
+/* Sent to a Litmus task when all of the following conditions are true:
+ * (1) The task has exhausted its budget.
+ * (2) budget_signal_policy is QUANTUM_SIGNALS or PRECISE_SIGNALS.
+ *
+ * Note: If a task does not have a registered handler for SIG_BUDGET,
+ * the signal will cause the task to terminate (default action).
+ */
+
+/* Assigned values start at SIGRTMAX and decrease, hopefully reducing
+ * likelihood of user-level conflicts.
+ */
+#define SIG_BUDGET                                      (SIGRTMAX - 0)
+
+/*
+Future signals could include:
+
+#define SIG_DEADLINE_MISS                       (SIGRTMAX - 1)
+#define SIG_CRIT_LEVEL_CHANGE           (SIGRTMAX - 2)
+*/
+
+#define SIGLITMUSMIN                            SIG_BUDGET
+
+#ifdef __KERNEL__
+#if (SIGLITMUSMIN < SIGRTMIN)
+/* no compile-time check in user-space since SIGRTMIN may be a variable. */
+#error "Too many LITMUS^RT signals!"
+#endif
+#endif
+
+#endif
diff --git a/litmus/budget.c b/litmus/budget.c
index f7712be29adb..518174a37a3b 100644
--- a/litmus/budget.c
+++ b/litmus/budget.c
@@ -1,11 +1,13 @@
 #include <linux/sched.h>
 #include <linux/percpu.h>
 #include <linux/hrtimer.h>
+#include <linux/signal.h>
 
 #include <litmus/litmus.h>
 #include <litmus/preempt.h>
 
 #include <litmus/budget.h>
+#include <litmus/signal.h>
 
 struct enforcement_timer {
         /* The enforcement timer is used to accurately police
@@ -64,7 +66,7 @@ static void arm_enforcement_timer(struct enforcement_timer* et,
 
         /* Calling this when there is no budget left for the task
          * makes no sense, unless the task is non-preemptive. */
-        BUG_ON(budget_exhausted(t) && (!is_np(t)));
+        BUG_ON(budget_exhausted(t) && !is_np(t));
 
         /* __hrtimer_start_range_ns() cancels the timer
          * anyway, so we don't have to check whether it is still armed */
@@ -86,7 +88,7 @@ void update_enforcement_timer(struct task_struct* t)
 {
         struct enforcement_timer* et = &__get_cpu_var(budget_timer);
 
-        if (t && budget_precisely_enforced(t)) {
+        if (t && budget_precisely_tracked(t) && !sigbudget_sent(t)) {
                 /* Make sure we call into the scheduler when this budget
                  * expires. */
                 arm_enforcement_timer(et, t);
@@ -96,6 +98,16 @@ void update_enforcement_timer(struct task_struct* t)
         }
 }
 
+void send_sigbudget(struct task_struct* t)
+{
+        if (!test_and_set_bit(RT_JOB_SIG_BUDGET_SENT, &tsk_rt(t)->job_params.flags)) {
+                /* signal has not yet been sent and we are responsible for sending
+                 * since we just set the sent-bit when it was previously 0. */
+
+                TRACE_TASK(t, "SIG_BUDGET being sent!\n");
+                send_sig(SIG_BUDGET, t, 1); /* '1' denotes signal sent from kernel */
+        }
+}
 
 static int __init init_budget_enforcement(void)
 {
diff --git a/litmus/jobs.c b/litmus/jobs.c
index bc8246572e54..4981665a37bf 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -13,6 +13,8 @@ static inline void setup_release(struct task_struct *t, lt_t release)
         t->rt_param.job_params.deadline = release + get_rt_relative_deadline(t);
         t->rt_param.job_params.exec_time = 0;
 
+        clear_bit(RT_JOB_SIG_BUDGET_SENT, &t->rt_param.job_params.flags);
+
         /* update job sequence number */
         t->rt_param.job_params.job_no++;
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 81384327e850..3526749852aa 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -136,6 +136,16 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
                        pid, tp.budget_policy);
                 goto out_unlock;
         }
+        if (tp.budget_signal_policy != NO_SIGNALS &&
+            tp.budget_signal_policy != QUANTUM_SIGNALS &&
+            tp.budget_signal_policy != PRECISE_SIGNALS)
+        {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                       "because unsupported budget signalling policy "
+                       "specified (%d)\n",
+                       pid, tp.budget_signal_policy);
+                goto out_unlock;
+        }
 
         target->rt_param.task_params = tp;
 
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index b0c16e34d2c5..208f067934fc 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -371,21 +371,29 @@ static noinline void job_completion(struct task_struct *t, int forced)
  */
 static void cedf_tick(struct task_struct* t)
 {
-        if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
-                if (!is_np(t)) {
-                        /* np tasks will be preempted when they become
-                         * preemptable again
-                         */
-                        litmus_reschedule_local();
-                        set_will_schedule();
-                        TRACE("cedf_scheduler_tick: "
-                              "%d is preemptable "
-                              " => FORCE_RESCHED\n", t->pid);
-                } else if (is_user_np(t)) {
-                        TRACE("cedf_scheduler_tick: "
-                              "%d is non-preemptable, "
-                              "preemption delayed.\n", t->pid);
-                        request_exit_np(t);
+        if (is_realtime(t) && budget_exhausted(t))
+        {
+                if (budget_signalled(t) && !sigbudget_sent(t)) {
+                        /* signal exhaustion */
+                        send_sigbudget(t);
+                }
+
+                if (budget_enforced(t)) {
+                        if (!is_np(t)) {
+                                /* np tasks will be preempted when they become
+                                 * preemptable again
+                                 */
+                                litmus_reschedule_local();
+                                set_will_schedule();
+                                TRACE("cedf_scheduler_tick: "
+                                          "%d is preemptable "
+                                          " => FORCE_RESCHED\n", t->pid);
+                        } else if (is_user_np(t)) {
+                                TRACE("cedf_scheduler_tick: "
+                                          "%d is non-preemptable, "
+                                          "preemption delayed.\n", t->pid);
+                                request_exit_np(t);
+                        }
                 }
         }
 }
@@ -415,7 +423,7 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
 {
         cpu_entry_t* entry = &__get_cpu_var(cedf_cpu_entries);
         cedf_domain_t *cluster = entry->cluster;
-        int out_of_time, sleep, preempt, np, exists, blocks;
+        int out_of_time, signal_budget, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
 #ifdef CONFIG_RELEASE_MASTER
@@ -442,6 +450,10 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         out_of_time = exists &&
                                   budget_enforced(entry->scheduled) &&
                                   budget_exhausted(entry->scheduled);
+        signal_budget = exists &&
+                                        budget_signalled(entry->scheduled) &&
+                                        budget_exhausted(entry->scheduled) &&
+                                        !sigbudget_sent(entry->scheduled);
         np          = exists && is_np(entry->scheduled);
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
@@ -460,6 +472,9 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
+        /* Send the signal that the budget has been exhausted */
+        if (signal_budget)
+                send_sigbudget(entry->scheduled);
 
         /* If a task blocks we have no choice but to reschedule.
          */
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c3344b9d288f..c1f25b56e51e 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -362,20 +362,28 @@ static noinline void job_completion(struct task_struct *t, int forced)
  */
 static void gsnedf_tick(struct task_struct* t)
 {
-        if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
-                if (!is_np(t)) {
-                        /* np tasks will be preempted when they become
-                         * preemptable again
-                         */
-                        litmus_reschedule_local();
-                        TRACE("gsnedf_scheduler_tick: "
-                              "%d is preemptable "
-                              " => FORCE_RESCHED\n", t->pid);
-                } else if (is_user_np(t)) {
-                        TRACE("gsnedf_scheduler_tick: "
-                              "%d is non-preemptable, "
-                              "preemption delayed.\n", t->pid);
-                        request_exit_np(t);
+        if (is_realtime(t) && budget_exhausted(t))
+        {
+                if (budget_signalled(t) && !sigbudget_sent(t)) {
+                        /* signal exhaustion */
+                        send_sigbudget(t);
+                }
+
+                if (budget_enforced(t)) {
+                        if (!is_np(t)) {
+                                /* np tasks will be preempted when they become
+                                 * preemptable again
+                                 */
+                                litmus_reschedule_local();
+                                TRACE("gsnedf_scheduler_tick: "
+                                          "%d is preemptable "
+                                          " => FORCE_RESCHED\n", t->pid);
+                        } else if (is_user_np(t)) {
+                                TRACE("gsnedf_scheduler_tick: "
+                                          "%d is non-preemptable, "
+                                          "preemption delayed.\n", t->pid);
+                                request_exit_np(t);
+                        }
                 }
         }
 }
@@ -404,7 +412,7 @@ static void gsnedf_tick(struct task_struct* t)
 static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 {
         cpu_entry_t* entry = &__get_cpu_var(gsnedf_cpu_entries);
-        int out_of_time, sleep, preempt, np, exists, blocks;
+        int out_of_time, signal_budget, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
 #ifdef CONFIG_RELEASE_MASTER
@@ -427,8 +435,13 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         /* (0) Determine state */
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
-        out_of_time = exists && budget_enforced(entry->scheduled)
-                && budget_exhausted(entry->scheduled);
+        out_of_time = exists &&
+                budget_enforced(entry->scheduled) &&
+                budget_exhausted(entry->scheduled);
+        signal_budget = exists &&
+                budget_signalled(entry->scheduled) &&
+                budget_exhausted(entry->scheduled) &&
+                !sigbudget_sent(entry->scheduled);
         np          = exists && is_np(entry->scheduled);
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
@@ -439,14 +452,17 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 
         if (exists)
                 TRACE_TASK(prev,
-                           "blocks:%d out_of_time:%d np:%d sleep:%d preempt:%d "
+                           "blocks:%d out_of_time:%d signal_budget: %d np:%d sleep:%d preempt:%d "
                            "state:%d sig:%d\n",
-                           blocks, out_of_time, np, sleep, preempt,
+                           blocks, out_of_time, signal_budget, np, sleep, preempt,
                            prev->state, signal_pending(prev));
         if (entry->linked && preempt)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
+        /* Send the signal that the budget has been exhausted */
+        if (signal_budget)
+                send_sigbudget(entry->scheduled);
 
         /* If a task blocks we have no choice but to reschedule.
          */
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index 62be699629b1..6129eb94d3ea 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -135,17 +135,25 @@ static void pfp_tick(struct task_struct *t)
          */
         BUG_ON(is_realtime(t) && t != pfp->scheduled);
 
-        if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
-                if (!is_np(t)) {
-                        litmus_reschedule_local();
-                        TRACE("pfp_scheduler_tick: "
-                              "%d is preemptable "
-                              " => FORCE_RESCHED\n", t->pid);
-                } else if (is_user_np(t)) {
-                        TRACE("pfp_scheduler_tick: "
-                              "%d is non-preemptable, "
-                              "preemption delayed.\n", t->pid);
-                        request_exit_np(t);
+        if (is_realtime(t) && budget_exhausted(t))
+        {
+                if (budget_signalled(t) && !sigbudget_sent(t)) {
+                        /* signal exhaustion */
+                        send_sigbudget(t);
+                }
+
+                if (budget_enforced(t)) {
+                        if (!is_np(t)) {
+                                litmus_reschedule_local();
+                                TRACE("pfp_scheduler_tick: "
+                                          "%d is preemptable "
+                                          " => FORCE_RESCHED\n", t->pid);
+                        } else if (is_user_np(t)) {
+                                TRACE("pfp_scheduler_tick: "
+                                          "%d is non-preemptable, "
+                                          "preemption delayed.\n", t->pid);
+                                request_exit_np(t);
+                        }
                 }
         }
 }
@@ -155,7 +163,7 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
         pfp_domain_t*   pfp = local_pfp;
         struct task_struct*     next;
 
-        int out_of_time, sleep, preempt, np, exists, blocks, resched, migrate;
+        int out_of_time, signal_budget, sleep, preempt, np, exists, blocks, resched, migrate;
 
         raw_spin_lock(&pfp->slock);
 
@@ -172,6 +180,10 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
         out_of_time = exists &&
                                   budget_enforced(pfp->scheduled) &&
                                   budget_exhausted(pfp->scheduled);
+        signal_budget = exists &&
+                                        budget_signalled(pfp->scheduled) &&
+                                        budget_exhausted(pfp->scheduled) &&
+                                        !sigbudget_sent(pfp->scheduled);
         np          = exists && is_np(pfp->scheduled);
         sleep       = exists && get_rt_flags(pfp->scheduled) == RT_F_SLEEP;
         migrate     = exists && get_partition(pfp->scheduled) != pfp->cpu;
@@ -183,6 +195,10 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
          */
         resched = preempt;
 
+        /* Send the signal that the budget has been exhausted */
+        if (signal_budget)
+                send_sigbudget(pfp->scheduled);
+
         /* If a task blocks we have no choice but to reschedule.
          */
         if (blocks)
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index b0c8126bd44a..a5fda133bad9 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -169,17 +169,25 @@ static void psnedf_tick(struct task_struct *t)
          */
         BUG_ON(is_realtime(t) && t != pedf->scheduled);
 
-        if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
-                if (!is_np(t)) {
-                        litmus_reschedule_local();
-                        TRACE("psnedf_scheduler_tick: "
-                              "%d is preemptable "
-                              " => FORCE_RESCHED\n", t->pid);
-                } else if (is_user_np(t)) {
-                        TRACE("psnedf_scheduler_tick: "
-                              "%d is non-preemptable, "
-                              "preemption delayed.\n", t->pid);
-                        request_exit_np(t);
+        if (is_realtime(t) && budget_exhausted(t))
+        {
+                if (budget_signalled(t) && !sigbudget_sent(t)) {
+                        /* signal exhaustion */
+                        send_sigbudget(t);
+                }
+
+                if (budget_enforced(t)) {
+                        if (!is_np(t)) {
+                                litmus_reschedule_local();
+                                TRACE("psnedf_scheduler_tick: "
+                                          "%d is preemptable "
+                                          " => FORCE_RESCHED\n", t->pid);
+                        } else if (is_user_np(t)) {
+                                TRACE("psnedf_scheduler_tick: "
+                                          "%d is non-preemptable, "
+                                          "preemption delayed.\n", t->pid);
+                                request_exit_np(t);
+                        }
                 }
         }
 }
@@ -190,8 +198,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         rt_domain_t*            edf  = &pedf->domain;
         struct task_struct*     next;
 
-        int                     out_of_time, sleep, preempt,
-                                np, exists, blocks, resched;
+        int out_of_time, signal_budget, sleep, preempt, np, exists, blocks, resched;
 
         raw_spin_lock(&pedf->slock);
 
@@ -208,6 +215,10 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         out_of_time = exists &&
                                   budget_enforced(pedf->scheduled) &&
                                   budget_exhausted(pedf->scheduled);
+        signal_budget = exists &&
+                                        budget_signalled(pedf->scheduled) &&
+                                        budget_exhausted(pedf->scheduled) &&
+                                        !sigbudget_sent(pedf->scheduled);
         np          = exists && is_np(pedf->scheduled);
         sleep       = exists && get_rt_flags(pedf->scheduled) == RT_F_SLEEP;
         preempt     = edf_preemption_needed(edf, prev);
@@ -218,6 +229,10 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
          */
         resched = preempt;
 
+        /* Send the signal that the budget has been exhausted */
+        if (signal_budget)
+                send_sigbudget(pedf->scheduled);
+
         /* If a task blocks we have no choice but to reschedule.
          */
         if (blocks)