Merge remote-tracking branch 'github/prop/litmus-signals' into wip-gpu-rtas12

Conflicts:
	Makefile

3 files changed, 118 insertions, 6 deletions

diff --git a/src/litmus.c b/src/litmus.c
index 4f404e2..3bab483 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -26,7 +26,7 @@ task_class_t str2class(const char* str)
         else if (!strcmp(str, "be"))
                 return RT_CLASS_BEST_EFFORT;
         else
-                return -1;
+                return (task_class_t)(-1);
 }
 
 #define NS_PER_MS 1000000
@@ -43,15 +43,19 @@ int be_migrate_to(int target_cpu)
 
 int sporadic_task(lt_t e, lt_t p, lt_t phase,
                   int cpu, task_class_t cls,
-                  budget_policy_t budget_policy, int set_cpu_set)
+                  budget_policy_t budget_policy,
+                  budget_signal_policy_t budget_signal_policy,
+                  int set_cpu_set)
 {
         return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS, phase * NS_PER_MS,
-                                cpu, cls, budget_policy, set_cpu_set);
+                                cpu, cls, budget_policy, budget_signal_policy, set_cpu_set);
 }
 
 int sporadic_task_ns(lt_t e, lt_t p, lt_t phase,
                         int cpu, task_class_t cls,
-                        budget_policy_t budget_policy, int set_cpu_set)
+                        budget_policy_t budget_policy,
+                        budget_signal_policy_t budget_signal_policy,
+                        int set_cpu_set)
 {
         struct rt_task param;
         int ret;
@@ -67,6 +71,7 @@ int sporadic_task_ns(lt_t e, lt_t p, lt_t phase,
         param.cls       = cls;
         param.phase     = phase;
         param.budget_policy = budget_policy;
+        param.budget_signal_policy = budget_signal_policy;
 
         if (set_cpu_set) {
                 ret = be_migrate_to(cpu);
diff --git a/src/signal.c b/src/signal.c
new file mode 100644
index 0000000..bfe18b9
--- /dev/null
+++ b/src/signal.c
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "litmus.h"
+#include "internal.h"
+
+/* setjmp calls are stored on a singlely link list,
+ * one stack per thread.
+ */
+static __thread litmus_sigjmp_t *g_sigjmp_tail = 0;
+
+void push_sigjmp(litmus_sigjmp_t *buf)
+{
+        buf->prev = g_sigjmp_tail;
+        g_sigjmp_tail = buf;
+}
+
+litmus_sigjmp_t* pop_sigjmp(void)
+{
+        litmus_sigjmp_t* ret;
+        ret = g_sigjmp_tail;
+        g_sigjmp_tail = (ret) ? ret->prev : NULL;
+        return ret;
+}
+
+static void reg_litmus_signals(unsigned long litmus_sig_mask,
+                struct sigaction *pAction)
+{
+        int ret;
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) { 
+                ret = sigaction(SIG_BUDGET, pAction, NULL);
+                check("SIG_BUDGET");
+        }
+        /* more signals ... */
+}
+
+void ignore_litmus_signals(unsigned long litmus_sig_mask)
+{
+        activate_litmus_signals(litmus_sig_mask, SIG_IGN);
+}
+
+void activate_litmus_signals(unsigned long litmus_sig_mask,
+        litmus_sig_handler_t handle)
+{
+        struct sigaction action;
+        memset(&action, 0, sizeof(action));
+        action.sa_handler = handle;
+
+        reg_litmus_signals(litmus_sig_mask, &action);
+}
+
+void activate_litmus_signal_actions(unsigned long litmus_sig_mask,
+                litmus_sig_actions_t handle)
+{
+        struct sigaction action;
+        memset(&action, 0, sizeof(action));
+        action.sa_sigaction = handle;
+        action.sa_flags = SA_SIGINFO;
+
+        reg_litmus_signals(litmus_sig_mask, &action);
+}
+
+void block_litmus_signals(unsigned long litmus_sig_mask)
+{
+        int ret;
+        sigset_t sigs;
+        sigemptyset(&sigs);
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) {
+                sigaddset(&sigs, SIG_BUDGET);
+        }
+        /* more signals ... */
+
+        ret = sigprocmask(SIG_BLOCK, &sigs, NULL);
+        check("SIG_BLOCK litmus signals");
+}
+
+void unblock_litmus_signals(unsigned long litmus_sig_mask)
+{
+        int ret;
+        sigset_t sigs;
+        sigemptyset(&sigs);
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) {
+                sigaddset(&sigs, SIG_BUDGET);
+        }
+        /* more ... */
+
+        ret = sigprocmask(SIG_UNBLOCK, &sigs, NULL);
+        check("SIG_UNBLOCK litmus signals");
+}
+
+
+void longjmp_on_litmus_signal(int signum)
+{
+        /* We get signal!  Main screen turn on! */
+        litmus_sigjmp_t *lit_env;
+        lit_env = pop_sigjmp();
+        if (lit_env) {
+                /* What you say?! */
+                siglongjmp(lit_env->env, signum); /* restores signal mask */
+        }
+        else {
+                /* silently ignore the signal */
+        }
+}
diff --git a/src/task.c b/src/task.c
index 4d237bd..26fc15a 100644
--- a/src/task.c
+++ b/src/task.c
@@ -41,13 +41,13 @@ int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, rt_setup_fn_t setup,
 }
 
 int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
-                     task_class_t class)
+                     task_class_t rt_class)
 {
         struct rt_task params;
         params.cpu       = cpu;
         params.period    = period;
         params.exec_cost = wcet;
-        params.cls       = class;
+        params.cls       = rt_class;
         params.phase     = 0;
         /* enforce budget for tasks that might not use sleep_next_period() */
         params.budget_policy = QUANTUM_ENFORCEMENT;