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

Conflicts:
	Makefile

11 files changed, 324 insertions, 53 deletions

diff --git a/Makefile b/Makefile
index e99f0dd..e07d39c 100644
--- a/Makefile
+++ b/Makefile
@@ -19,7 +19,7 @@ LITMUS_KERNEL ?= ../litmus-rt
 # Internal configuration.
 
 # compiler flags
-flags-debug    = -g -std=c99
+flags-debug    = -Wall -Werror -Wdeclaration-after-statement -g
 flags-api      = -D_XOPEN_SOURCE=600 -D_GNU_SOURCE
 
 # architecture-specific flags
@@ -157,6 +157,7 @@ litmus-headers = \
         include/litmus/rt_param.h \
         include/litmus/fpmath.h \
         include/litmus/binheap.h \
+        include/litmus/signal.h \
         include/litmus/unistd_32.h \
         include/litmus/unistd_64.h
 
@@ -237,7 +238,7 @@ lib-measure_syscall = -lm
 
 .SECONDEXPANSION:
 ${rt-apps}: $${obj-$$@} liblitmus.a
-        $(CC) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${lib-$@} ${liblitmus-flags} ${lib-$@}
+        $(CC) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${liblitmus-flags} ${lib-$@}
 
 # ##############################################################################
 # Dependency resolution.
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 ae76941..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");
 
@@ -152,16 +152,28 @@ static void debug_delay_loop(void)
 
 static int job(double exec_time, double program_end)
 {
-        if (wctime() > program_end)
-                return 0;
+        int exit = 0;
+        if (wctime() > program_end) {
+                exit = 1;
+        }
         else {
-                loop_for(exec_time, program_end + 1);
+                LITMUS_TRY {
+                        loop_for(exec_time, program_end + 1);
+                }
+                LITMUS_CATCH(SIG_BUDGET) {
+                        fprintf(stdout, "Exhausted budget! Finishing job NOW!\n");
+                }
+                END_LITMUS_TRY;
+        }
+
+        if (!exit) {
                 sleep_next_period();
-                return 1;
         }
+
+        return !exit;
 }
 
-#define OPTSTR "p:c:wlveo:f:s:"
+#define OPTSTR "p:c:wlveio:f:s:"
 
 int main(int argc, char** argv)
 {
@@ -177,10 +189,11 @@ int main(int argc, char** argv)
         int column = 1;
         const char *file = NULL;
         int want_enforcement = 0;
+        int want_signals = 0;
         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];
@@ -195,13 +208,16 @@ 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':
                         want_enforcement = 1;
                         break;
+                case 'i':
+                        want_signals = 1;
+                        break;
                 case 'l':
                         test_loop = 1;
                         break;
@@ -274,15 +290,22 @@ 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
+                                                                : NO_SIGNALS,
                                migrate);
         if (ret < 0)
                 bail_out("could not setup rt task params");
 
         init_litmus();
 
+        if (want_signals) {
+                /* bind default longjmp signal handler to SIG_BUDGET. */
+                activate_litmus_signals(SIG_BUDGET_MASK, longjmp_on_litmus_signal);
+        }
+
         ret = task_mode(LITMUS_RT_TASK);
         if (ret != 0)
                 bail_out("could not become RT task");
@@ -304,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/dgl.c b/dgl.c
index d2317f5..3870a03 100644
--- a/dgl.c
+++ b/dgl.c
@@ -149,7 +149,7 @@ void* rt_thread(void* _ctx)
         TH_CALL( init_rt_thread() );
 
         /* Vary period a little bit. */
-        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0) );
+        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, NO_SIGNALS, 0) );
 
         ctx->ikglp = open_ikglp_sem(ctx->fd, 0, (void*)&NUM_REPLICAS);
         if(ctx->ikglp < 0)
diff --git a/ikglptest.c b/ikglptest.c
index 8c1ac0b..8e088c1 100644
--- a/ikglptest.c
+++ b/ikglptest.c
@@ -109,7 +109,7 @@ struct avg_info feedback(int _a, int _b)
         fp_t _est, _err;
 
         int base = 1000000;
-        int range = 40;
+        //int range = 40;
 
         fp_t est = _integer_to_fp(base);
         fp_t err = _fp(base/2);
@@ -117,50 +117,56 @@ struct avg_info feedback(int _a, int _b)
 #define NUM_SAMPLES 10000
 
         float samples[NUM_SAMPLES] = {0.0};
-
+        float accu_abs, accu;
+        float avg;
+        float devsum;
+        float stdev;
+        struct avg_info ret;
 
         for(i = 0; i < NUM_SAMPLES; ++i) {
-        int num = ((rand()%40)*(rand()%2 ? -1 : 1)/100.0)*base + base;
-        actual_fp = _integer_to_fp(num);
+                int num = ((rand()%40)*(rand()%2 ? -1 : 1)/100.0)*base + base;
+                float rel_err;
+
+                actual_fp = _integer_to_fp(num);
 
 //      printf("Before: est = %d\terr = %d\n", (int)_fp_to_integer(est), (int)_fp_to_integer(err));
 
-        _err = _sub(actual_fp, est);
-        _est = _add(_mul(a, _err), _mul(b, err));
+                _err = _sub(actual_fp, est);
+                _est = _add(_mul(a, _err), _mul(b, err));
 
-        float rel_err = _fp_to_integer(_mul(_div(_err, est), _integer_to_fp(10000)))/10000.0;
-        rel_err *= 100.0;
-        //printf("%6.2f\n", rel_err);
-        samples[i] = rel_err;
+                rel_err = _fp_to_integer(_mul(_div(_err, est), _integer_to_fp(10000)))/10000.0;
+                rel_err *= 100.0;
+                //printf("%6.2f\n", rel_err);
+                samples[i] = rel_err;
 
-        est = _est;
-        err = _add(err, _err);
+                est = _est;
+                err = _add(err, _err);
 
-        if((int)_fp_to_integer(est) <= 0) {
-                est = actual_fp;
-                err = _div(actual_fp, _integer_to_fp(2));
-        }
+                if((int)_fp_to_integer(est) <= 0) {
+                        est = actual_fp;
+                        err = _div(actual_fp, _integer_to_fp(2));
+                }
 
         //printf("After: est = %d\terr = %d\n", (int)_fp_to_integer(est), (int)_fp_to_integer(err));
         }
 
-        float accu_abs = 0.0, accu = 0.0;
+        accu_abs = 0.0;
+        accu = 0.0;
         for(i = 0; i < NUM_SAMPLES; ++i) {
                 accu += samples[i];
                 accu_abs += abs(samples[i]);
         }
 
-        float avg = accu_abs/NUM_SAMPLES;
-        float devsum = 0;
+        avg = accu_abs/NUM_SAMPLES;
+        devsum = 0;
         for(i = 0; i < NUM_SAMPLES; ++i) {
                 float dev = samples[i] - avg;
                 dev *= dev;
                 devsum += dev;
         }
 
-        float stdev = sqrtf(devsum/(NUM_SAMPLES-1));
+        stdev = sqrtf(devsum/(NUM_SAMPLES-1));
         
-        struct avg_info ret;
         ret.avg = avg;
         ret.stdev = stdev;
 
@@ -381,7 +387,7 @@ void* rt_thread(void* _ctx)
         TH_CALL( init_rt_thread() );
 
         /* Vary period a little bit. */
-        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 1) );
+        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, NO_SIGNALS, 1) );
 
         if(USE_KFMLP) {
                 ctx->kexclu = open_kfmlp_gpu_sem(ctx->fd,
diff --git a/include/litmus.h b/include/litmus.h
index 2e26868..c3ef941 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -7,12 +7,14 @@ extern "C" {
 
 #include <sys/types.h>
 #include <stdint.h>
+#include <setjmp.h>
 
 /* Include kernel header.
  * This is required for the rt_param
  * and control_page structures.
  */
 #include "litmus/rt_param.h"
+#include "litmus/signal.h"
 
 #include "asm/cycles.h" /* for null_call() */
 
@@ -33,19 +35,23 @@ int get_rt_task_param(pid_t pid, struct rt_task* param);
 int sporadic_task(
                 lt_t e, lt_t p, lt_t phase,
                 int partition, 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);
 
 /* times are given in ns */
 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);
 
 /* budget enforcement off by default in these macros */
 #define sporadic_global(e, p) \
-        sporadic_task(e, p, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
+        sporadic_task(e, p, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, NO_SIGNALS, 0)
 #define sporadic_partitioned(e, p, cpu) \
-        sporadic_task(e, p, 0, cpu, RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
+        sporadic_task(e, p, 0, cpu, RT_CLASS_SOFT, NO_ENFORCEMENT, NO_SIGNALS, 1)
 
 /* file descriptor attached shared objects support */
 typedef enum  {
@@ -199,7 +205,127 @@ int null_call(cycles_t *timestamp);
  */
 struct control_page* get_ctrl_page(void);
 
+
+/* Litmus signal handling */
+
+typedef struct litmus_sigjmp
+{
+        sigjmp_buf env;
+        struct litmus_sigjmp *prev;
+} litmus_sigjmp_t;
+
+void push_sigjmp(litmus_sigjmp_t* buf);
+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
+/* more ... */
+
+#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__; \
+        litmus_sigjmp_t lit_env_##__FUNCTION__##__LINE__; \
+        push_sigjmp(&lit_env_##__FUNCTION__##__LINE__); \
+        sigsetjmp_ret_##__FUNCTION__##__LINE__ = \
+                sigsetjmp(lit_env_##__FUNCTION__##__LINE__.env, 1); \
+        if (sigsetjmp_ret_##__FUNCTION__##__LINE__ == 0) {
+
+#define LITMUS_CATCH(x) \
+        } else if (sigsetjmp_ret_##__FUNCTION__##__LINE__ == (x)) {
+
+#define END_LITMUS_TRY \
+        } /* 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
 }
 #endif
+
+
+
+
+#ifdef __cplusplus
+/* Expose litmus exceptions if C++.
+ *
+ * KLUDGE: We define everything in the header since liblitmus is a C-only
+ * library, but this header could be included in C++ code.
+ */
+
+#include <exception>
+
+namespace litmus
+{
+        class litmus_exception: public std::exception
+        {
+        public:
+                litmus_exception() throw() {}
+                virtual ~litmus_exception() throw() {}
+                virtual const char* what() const throw() { return "litmus_exception";}
+        };
+
+        class sigbudget: public litmus_exception
+        {
+        public:
+                sigbudget() throw() {}
+                virtual ~sigbudget() throw() {}
+                virtual const char* what() const throw() { return "sigbudget"; }
+        };
+
+        /* Must compile your program with "non-call-exception". */
+        static __attribute__((used))
+        void throw_on_litmus_signal(int 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.
+                 */
+                if (SIG_BUDGET == signum) {
+                        unblock_litmus_signals(SIG_BUDGET_MASK);
+                        throw sigbudget();
+                }
+                /* else if (...) */
+                else {
+                        /* silently ignore */
+                }
+        }
+
+}; /* end namespace 'litmus' */
+
+#endif /* end __cplusplus */
+
 #endif
diff --git a/nested.c b/nested.c
index 045e170..39c3df6 100644
--- a/nested.c
+++ b/nested.c
@@ -147,7 +147,7 @@ void* rt_thread(void* _ctx)
         //printf("RT Thread %d active.\n", ctx->id);
 
         TH_CALL( init_rt_thread() );
-        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0) );
+        TH_CALL( sporadic_task_ns(EXEC_COST, PERIOD + 10*ctx->id, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, NO_SIGNALS, 0) );
 
         for (i = 0; i < NUM_SEMS; i++) {
                 ctx->od[i] = open_rsm_sem(ctx->fd, i);
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;
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,