Added signal-related comments. Made g++ friendly.prop/litmus-signals

8 files changed, 59 insertions, 47 deletions

diff --git a/Makefile b/Makefile
index d37f076..5760440 100644
--- a/Makefile
+++ b/Makefile
@@ -19,7 +19,7 @@ LITMUS_KERNEL ?= ../litmus-rt
 # Internal configuration.
 
 # compiler flags
-flags-debug    = -Wall -Werror -g -Wdeclaration-after-statement
+flags-debug    = -Wall -Werror -Wdeclaration-after-statement -g
 flags-api      = -D_XOPEN_SOURCE=600 -D_GNU_SOURCE
 
 # architecture-specific flags
diff --git a/bin/rt_launch.c b/bin/rt_launch.c
index 3863031..84a5e6c 100644
--- a/bin/rt_launch.c
+++ b/bin/rt_launch.c
@@ -54,7 +54,7 @@ int main(int argc, char** argv)
         int verbose = 0;
         int wait = 0;
         startup_info_t info;
-        task_class_t class = RT_CLASS_HARD;
+        task_class_t rt_class = RT_CLASS_HARD;
 
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
                 switch (opt) {
@@ -69,8 +69,8 @@ int main(int argc, char** argv)
                         migrate = 1;
                         break;
                 case 'c':
-                        class = str2class(optarg);
-                        if (class == -1)
+                        rt_class = str2class(optarg);
+                        if (rt_class == -1)
                                 usage("Unknown task class.");
                         break;
 
@@ -107,7 +107,7 @@ int main(int argc, char** argv)
                 if (ret < 0)
                         bail_out("could not migrate to target partition");
         }
-        ret = __create_rt_task(launch, &info, cpu, wcet, period, class);
+        ret = __create_rt_task(launch, &info, cpu, wcet, period, rt_class);
 
         
         if (ret < 0)
diff --git a/bin/rtspin.c b/bin/rtspin.c
index 1daed82..8ee26d5 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -67,7 +67,7 @@ static void get_exec_times(const char *file, const int column,
                 bail_out("rewinding file failed");
 
         /* allocate space for exec times */
-        *exec_times = calloc(*num_jobs, sizeof(*exec_times));
+        *exec_times = (double*)calloc(*num_jobs, sizeof(*exec_times));
         if (!*exec_times)
                 bail_out("couldn't allocate memory");
 
@@ -161,7 +161,7 @@ static int job(double exec_time, double program_end)
                         loop_for(exec_time, program_end + 1);
                 }
                 LITMUS_CATCH(SIG_BUDGET) {
-                        printf("Exhausted budget! Finishing job NOW!\n");
+                        fprintf(stdout, "Exhausted budget! Finishing job NOW!\n");
                 }
                 END_LITMUS_TRY;
         }
@@ -193,7 +193,7 @@ int main(int argc, char** argv)
         double duration = 0, start;
         double *exec_times = NULL;
         double scale = 1.0;
-        task_class_t class = RT_CLASS_HARD;
+        task_class_t rt_class = RT_CLASS_HARD;
         int cur_job, num_jobs;
 
         progname = argv[0];
@@ -208,8 +208,8 @@ int main(int argc, char** argv)
                         migrate = 1;
                         break;
                 case 'c':
-                        class = str2class(optarg);
-                        if (class == -1)
+                        rt_class = str2class(optarg);
+                        if (rt_class == -1)
                                 usage("Unknown task class.");
                         break;
                 case 'e':
@@ -290,7 +290,7 @@ int main(int argc, char** argv)
                         bail_out("could not migrate to target partition");
         }
 
-        ret = sporadic_task_ns(wcet, period, 0, cpu, class,
+        ret = sporadic_task_ns(wcet, period, 0, cpu, rt_class,
                                want_enforcement ? PRECISE_ENFORCEMENT
                                                 : NO_ENFORCEMENT,
                                    want_signals ? PRECISE_SIGNALS
@@ -303,7 +303,7 @@ int main(int argc, char** argv)
 
         if (want_signals) {
                 /* bind default longjmp signal handler to SIG_BUDGET. */
-                activate_litmus_signals(SIG_BUDGET_MASK, longjmp_on_litmus_signal); 
+                activate_litmus_signals(SIG_BUDGET_MASK, longjmp_on_litmus_signal);
         }
 
         ret = task_mode(LITMUS_RT_TASK);
@@ -327,7 +327,10 @@ int main(int argc, char** argv)
                 }
         } else {
                 /* conver to seconds and scale */
-                while (job(wcet_ms * 0.001 * scale, start + duration));
+                int run = 1;
+                while (run) {
+                        run = job(wcet_ms * 0.001 * scale, start + duration);
+                }
         }
 
         ret = task_mode(BACKGROUND_TASK);
diff --git a/include/litmus.h b/include/litmus.h
index c284870..ca8328f 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -144,6 +144,9 @@ int null_call(cycles_t *timestamp);
  */
 struct control_page* get_ctrl_page(void);
 
+
+/* Litmus signal handling */
+
 typedef struct litmus_sigjmp
 {
         sigjmp_buf env;
@@ -156,12 +159,26 @@ litmus_sigjmp_t* pop_sigjmp(void);
 typedef void (*litmus_sig_handler_t)(int);
 typedef void (*litmus_sig_actions_t)(int, siginfo_t *, void *);
 
+/* ignore specified signals. all signals raised while ignored are dropped */
 void ignore_litmus_signals(unsigned long litmus_sig_mask);
+
+/* register a handler for the given set of litmus signals */
 void activate_litmus_signals(unsigned long litmus_sig_mask,
                                 litmus_sig_handler_t handler);
+
+/* register an action signal handler for a given set of signals */
 void activate_litmus_signal_actions(unsigned long litmus_sig_mask,
                                 litmus_sig_actions_t handler);
+
+/* Block a given set of litmus signals. Any signals raised while blocked
+ * are queued and delivered after unblocking. Call ignore_litmus_signals()
+ * before unblocking if you wish to discard these. Blocking may be
+ * useful to protect COTS code in Litmus that may not be able to deal
+ * with exception-raising signals.
+ */
 void block_litmus_signals(unsigned long litmus_sig_mask);
+
+/* Unblock a given set of litmus signals. */
 void unblock_litmus_signals(unsigned long litmus_sig_mask);
 
 #define SIG_BUDGET_MASK                 0x00000001
@@ -169,7 +186,9 @@ void unblock_litmus_signals(unsigned long litmus_sig_mask);
 
 #define ALL_LITMUS_SIG_MASKS    (SIG_BUDGET_MASK)
 
-
+/* Try/Catch structures useful for implementing abortable jobs.
+ * Should only be used in legitimate cases. ;)
+ */
 #define LITMUS_TRY \
 do { \
         int sigsetjmp_ret_##__FUNCTION__##__LINE__; \
@@ -186,6 +205,10 @@ do { \
         } /* end if-else-if chain */ \
 } while(0); /* end do from 'LITMUS_TRY' */
 
+/* Calls siglongjmp(signum). Use with TRY/CATCH.
+ * Example:
+ *  activate_litmus_signals(SIG_BUDGET_MASK, longjmp_on_litmus_signal);
+ */
 void longjmp_on_litmus_signal(int signum);
 
 #ifdef __cplusplus
@@ -223,20 +246,20 @@ namespace litmus
         };
 
         /* Must compile your program with "non-call-exception". */
-        static void throw_on_litmus_signal(int signum) __used__
+        static __attribute__((used))
+        void throw_on_litmus_signal(int signum)
         {
-                printf("WE GET SIGNAL! %d\n", signum);
                 /* We have to unblock the received signal to get more in the future
                  * because we are not calling siglongjmp(), which normally restores
                  * the mask for us.
                  */
-                switch(signum)
-                {
-                case SIG_BUDGET:
+                if (SIG_BUDGET == signum) {
                         unblock_litmus_signals(SIG_BUDGET_MASK);
                         throw sigbudget();
-                default:
-                        ; /* silently ignore */
+                }
+                /* else if (...) */
+                else {
+                        /* silently ignore */
                 }
         }
 
diff --git a/src/litmus.c b/src/litmus.c
index aaaeee3..0b7c561 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
diff --git a/src/signal.c b/src/signal.c
index a98ed78..bfe18b9 100644
--- a/src/signal.c
+++ b/src/signal.c
@@ -4,26 +4,13 @@
 #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 throw_litmus_signal(int signum)
-{
-        litmus_sigjmp_t *lit_env;
-
-        printf("WE GET SIGNAL!\n");
-        lit_env = pop_sigjmp();
-        if (lit_env) {
-                printf("received signal %d!\n", signum);
-                siglongjmp(lit_env->env, signum);
-        }
-        else {
-                /* silently ignore the signal. */
-        }
-}
-
 void push_sigjmp(litmus_sigjmp_t *buf)
 {
-        printf("push\n");
         buf->prev = g_sigjmp_tail;
         g_sigjmp_tail = buf;
 }
@@ -31,7 +18,6 @@ void push_sigjmp(litmus_sigjmp_t *buf)
 litmus_sigjmp_t* pop_sigjmp(void)
 {
         litmus_sigjmp_t* ret;
-        printf("pop\n");
         ret = g_sigjmp_tail;
         g_sigjmp_tail = (ret) ? ret->prev : NULL;
         return ret;
@@ -46,7 +32,7 @@ static void reg_litmus_signals(unsigned long litmus_sig_mask,
                 ret = sigaction(SIG_BUDGET, pAction, NULL);
                 check("SIG_BUDGET");
         }
-        /* more ... */
+        /* more signals ... */
 }
 
 void ignore_litmus_signals(unsigned long litmus_sig_mask)
@@ -84,7 +70,7 @@ void block_litmus_signals(unsigned long litmus_sig_mask)
         if (litmus_sig_mask | SIG_BUDGET_MASK) {
                 sigaddset(&sigs, SIG_BUDGET);
         }
-        /* more ... */
+        /* more signals ... */
 
         ret = sigprocmask(SIG_BLOCK, &sigs, NULL);
         check("SIG_BLOCK litmus signals");
@@ -108,11 +94,11 @@ void unblock_litmus_signals(unsigned long litmus_sig_mask)
 
 void longjmp_on_litmus_signal(int signum)
 {
+        /* We get signal!  Main screen turn on! */
         litmus_sigjmp_t *lit_env;
-        printf("WE GET SIGNAL!\n");
         lit_env = pop_sigjmp();
         if (lit_env) {
-                printf("received signal %d\n", signum);
+                /* What you say?! */
                 siglongjmp(lit_env->env, signum); /* restores signal mask */
         }
         else {
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;
diff --git a/tests/fdso.c b/tests/fdso.c
index 8a2a0d0..8e320cf 100644
--- a/tests/fdso.c
+++ b/tests/fdso.c
@@ -48,8 +48,8 @@ TESTCASE(invalid_od, ALL,
 TESTCASE(invalid_obj_type, ALL,
          "reject invalid object types")
 {
-        SYSCALL_FAILS( EINVAL, od_open(0, -1, 0) );
-        SYSCALL_FAILS( EINVAL, od_open(0, 10, 0) );
+        SYSCALL_FAILS( EINVAL, od_open(0, (obj_type_t)-1, 0) );
+        SYSCALL_FAILS( EINVAL, od_open(0, (obj_type_t)10, 0) );
 }
 
 TESTCASE(not_inherit_od, GSN_EDF | PSN_EDF,