Merge branch 'mpi-master' into wip-2012.3-gpu

Conflicts:
	Makefile
	bin/rtspin.c
	include/litmus.h
	src/litmus.c

5 files changed, 328 insertions, 11 deletions

diff --git a/tests/core_api.c b/tests/core_api.c
index 7f7a099..c0b291e 100644
--- a/tests/core_api.c
+++ b/tests/core_api.c
@@ -20,7 +20,9 @@ TESTCASE(set_rt_task_param_invalid_params, ALL,
         struct rt_task params;
         params.cpu        = 0;
         params.period     = 100;
+        params.relative_deadline = params.period;
         params.phase      = 0;
+        params.priority   = LITMUS_LOWEST_PRIORITY;
         params.cls        = RT_CLASS_HARD;
         params.budget_policy = NO_ENFORCEMENT;
 
@@ -33,8 +35,13 @@ TESTCASE(set_rt_task_param_invalid_params, ALL,
         params.cpu       = -1;
         SYSCALL_FAILS( EINVAL, set_rt_task_param(gettid(), &params) );
 
-        /* bad task */
+        /* infeasible density */
         params.cpu  = 0;
+        params.relative_deadline = 30;
+        SYSCALL_FAILS( EINVAL, set_rt_task_param(gettid(), &params) );
+
+        /* bad task */
+        params.relative_deadline = params.period;
         SYSCALL_FAILS( EINVAL, set_rt_task_param(-1, &params) );
 
 
@@ -42,6 +49,58 @@ TESTCASE(set_rt_task_param_invalid_params, ALL,
         SYSCALL( set_rt_task_param(gettid(), &params) );
 }
 
+TESTCASE(reject_bad_priorities, P_FP,
+         "reject invalid priorities")
+{
+        struct rt_task params;
+        params.cpu        = 0;
+        params.exec_cost  =  10;
+        params.period     = 100;
+        params.relative_deadline = params.period;
+        params.phase      = 0;
+        params.cls        = RT_CLASS_HARD;
+        params.budget_policy = NO_ENFORCEMENT;
+
+        SYSCALL( be_migrate_to(params.cpu) );
+
+        /* too high */
+        params.priority   = 0;
+        SYSCALL( set_rt_task_param(gettid(), &params) );
+        SYSCALL_FAILS( EINVAL, task_mode(LITMUS_RT_TASK) );
+
+        /* too low */
+        params.priority   = LITMUS_MAX_PRIORITY;
+        SYSCALL( set_rt_task_param(gettid(), &params) );
+        SYSCALL_FAILS( EINVAL, task_mode(LITMUS_RT_TASK) );
+
+}
+
+TESTCASE(accept_valid_priorities, P_FP,
+         "accept lowest and highest valid priorities")
+{
+        struct rt_task params;
+        params.cpu        = 0;
+        params.exec_cost  =  10;
+        params.period     = 100;
+        params.relative_deadline = params.period;
+        params.phase      = 0;
+        params.cls        = RT_CLASS_HARD;
+        params.budget_policy = NO_ENFORCEMENT;
+
+        SYSCALL( be_migrate_to(params.cpu) );
+
+        /* acceptable */
+        params.priority   = LITMUS_LOWEST_PRIORITY;
+        SYSCALL( set_rt_task_param(gettid(), &params) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+        SYSCALL( task_mode(BACKGROUND_TASK) );
+
+        params.priority   = LITMUS_HIGHEST_PRIORITY;
+        SYSCALL( set_rt_task_param(gettid(), &params) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+        SYSCALL( task_mode(BACKGROUND_TASK) );
+}
+
 TESTCASE(job_control_non_rt, ALL,
          "reject job control for non-rt tasks")
 {
@@ -80,7 +139,7 @@ TESTCASE(rt_fork_non_rt, LITMUS,
                 /* parent */
 
                 SYSCALL( sleep_next_period() );
-                SYSCALL( wait_for_job_release(20) );
+                SYSCALL( wait_for_job_release(3) );
                 SYSCALL( get_job_no(&job_no) );
 
                 SYSCALL( task_mode(BACKGROUND_TASK) );
@@ -90,3 +149,20 @@ TESTCASE(rt_fork_non_rt, LITMUS,
                 ASSERT(WEXITSTATUS(status) == 0);
         }
 }
+
+TESTCASE(ctrl_page_writable, ALL,
+         "tasks have write access to /dev/litmus/ctrl mappings")
+{
+        volatile int *ctrl_page = (volatile int*) get_ctrl_page();
+
+        /* init_litmus() should have mapped the page already  */
+        ASSERT(ctrl_page != NULL);
+
+        /* These should work without page faults. */
+        enter_np();
+        exit_np();
+
+        /* Try poking the memory directly. */
+
+        ctrl_page[32] = 0x12345678;
+}
diff --git a/tests/locks.c b/tests/locks.c
index 65b932a..d7ebfe2 100644
--- a/tests/locks.c
+++ b/tests/locks.c
@@ -6,7 +6,7 @@
 #include "litmus.h"
 
 
-TESTCASE(not_lock_fmlp_be, GSN_EDF | PSN_EDF,
+TESTCASE(not_lock_fmlp_be, GSN_EDF | PSN_EDF | P_FP,
          "don't let best-effort tasks lock FMLP semaphores")
 {
         int fd, od;
@@ -29,7 +29,7 @@ TESTCASE(not_lock_fmlp_be, GSN_EDF | PSN_EDF,
 
 }
 
-TESTCASE(not_lock_srp_be, PSN_EDF,
+TESTCASE(not_lock_srp_be, PSN_EDF | P_FP,
          "don't let best-effort tasks open SRP semaphores")
 {
         int fd, od;
@@ -46,7 +46,7 @@ TESTCASE(not_lock_srp_be, PSN_EDF,
 
 }
 
-TESTCASE(lock_srp, PSN_EDF,
+TESTCASE(lock_srp, PSN_EDF | P_FP,
          "SRP acquisition and release")
 {
         int fd, od;
@@ -78,7 +78,7 @@ TESTCASE(lock_srp, PSN_EDF,
 }
 
 
-TESTCASE(lock_fmlp, PSN_EDF | GSN_EDF,
+TESTCASE(lock_fmlp, PSN_EDF | GSN_EDF | P_FP,
          "FMLP acquisition and release")
 {
         int fd, od;
diff --git a/tests/pcp.c b/tests/pcp.c
new file mode 100644
index 0000000..88d1be3
--- /dev/null
+++ b/tests/pcp.c
@@ -0,0 +1,122 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "tests.h"
+#include "litmus.h"
+
+
+TESTCASE(lock_pcp, P_FP,
+         "PCP acquisition and release")
+{
+        int fd, od, cpu = 0;
+
+        SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT) );
+
+        SYSCALL( sporadic_partitioned(10, 100, cpu) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od = open_pcp_sem(fd, 0, cpu) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        /* tasks may not unlock resources they don't own */
+        SYSCALL_FAILS(EINVAL, litmus_unlock(od) );
+
+        SYSCALL( od_close(od) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".pcp_locks") );
+}
+
+TESTCASE(lock_dpcp, P_FP,
+         "DPCP acquisition and release")
+{
+        int fd, od, cpu = 1;
+
+        SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT) );
+
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od = open_dpcp_sem(fd, 0, cpu) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        /* tasks may not unlock resources they don't own */
+        SYSCALL_FAILS(EINVAL, litmus_unlock(od) );
+
+        SYSCALL( od_close(od) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".pcp_locks") );
+}
+
+TESTCASE(not_lock_pcp_be, P_FP,
+         "don't let best-effort tasks lock (D|M-)PCP semaphores")
+{
+        int fd, od;
+
+        SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT) );
+
+        /* BE tasks are not even allowed to open a PCP semaphore */
+        SYSCALL_FAILS(EPERM, od = open_pcp_sem(fd, 0, 1) );
+
+        /* BE tasks are not allowed to open a D-PCP semaphore */
+        SYSCALL_FAILS(EPERM, od = open_dpcp_sem(fd, 0, 1) );
+
+        /* BE tasks are not allowed to open an M-PCP semaphore */
+        SYSCALL_FAILS(EPERM, od = open_mpcp_sem(fd, 0) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".pcp_locks") );
+
+}
+
+TESTCASE(lock_mpcp, P_FP,
+         "MPCP acquisition and release")
+{
+        int fd, od;
+
+        SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT) );
+
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od = open_mpcp_sem(fd, 0) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        /* tasks may not unlock resources they don't own */
+        SYSCALL_FAILS(EINVAL, litmus_unlock(od) );
+
+        SYSCALL( od_close(od) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".pcp_locks") );
+}
diff --git a/tests/runner.c b/tests/runner.c
index ccf8d46..0fd3aa7 100644
--- a/tests/runner.c
+++ b/tests/runner.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdio.h>
 
+#define PROC_ACTIVE_PLUGIN "/proc/litmus/active_plugin"
 
 /* auto generated by Makefile */
 #include "../test_catalog.inc"
@@ -27,10 +28,13 @@ int run_test(struct testcase *tc) {
         } else {
                 /* parent: wait for completion of test */
                 SYSCALL( waitpid(pid, &status, 0) );
-                if (WEXITSTATUS(status) == 0)
+                if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
                         printf("ok.\n");
+                else if (WIFSIGNALED(status)) {
+                        printf("failed (%s)!\n", strsignal(WTERMSIG(status)));
+                }
         }
-        return WEXITSTATUS(status) == 0;
+        return WIFEXITED(status) && WEXITSTATUS(status) == 0;
 }
 
 int run_tests(int* testidx, int num_tests, const char* plugin)
@@ -46,17 +50,50 @@ int run_tests(int* testidx, int num_tests, const char* plugin)
         return ok;
 }
 
+static int get_active_plugin(char *buf, size_t buf_size)
+{
+        FILE *f;
+        size_t nread;
+
+        f = fopen(PROC_ACTIVE_PLUGIN, "r");
+        if (f) {
+                /* proc files read in one go */
+                nread = fread(buf, sizeof(char), buf_size - 1, f);
+                fclose(f);
+
+                /* remove trailing newline */
+                if (nread > 0 && buf[nread - 1] == '\n')
+                        nread--;
+
+                /* null terminate buffer */
+                if (nread > 0) {
+                        buf[nread] = '\0';
+                        return 1;
+                }
+        }
+        return 0;
+}
+
 #define streq(s1, s2) (!strcmp(s1, s2))
 
 int main(int argc, char** argv)
 {
         int ok, i;
+        char active_plugin[256];
+        char *plugin_name = NULL;
 
         printf("** LITMUS^RT test suite.\n");
 
-        if (argc == 2) {
+        if (argc == 2)
+                plugin_name = argv[1];
+        else if (get_active_plugin(active_plugin, sizeof(active_plugin))) {
+                /* run tests for currently active plugin */
+                plugin_name = active_plugin;
+        }
+
+        if (plugin_name) {
                 for (i = 0; i < NUM_PLUGINS; i++)
-                        if (streq(testsuite[i].plugin, argv[1])) {
+                        if (streq(testsuite[i].plugin, plugin_name)) {
                                 ok = run_tests(testsuite[i].testcases,
                                                testsuite[i].num_cases,
                                                testsuite[i].plugin);
@@ -64,7 +101,7 @@ int main(int argc, char** argv)
                                        ok, testsuite[i].num_cases - ok);
                                 return ok == testsuite[i].num_cases ? 0 : 3;
                         }
-                fprintf(stderr, "** Unknown plugin: '%s'\n", argv[1]);
+                fprintf(stderr, "** Unknown plugin: '%s'\n", plugin_name);
                 return 1;
         } else {
                 fprintf(stderr, "Usage: %s <plugin name>\n", argv[0]);
diff --git a/tests/sched.c b/tests/sched.c
new file mode 100644
index 0000000..ab47a91
--- /dev/null
+++ b/tests/sched.c
@@ -0,0 +1,82 @@
+#include <sys/wait.h> /* for waitpid() */
+#include <unistd.h>
+#include <stdio.h>
+
+#include "tests.h"
+#include "litmus.h"
+
+TESTCASE(preempt_on_resume, P_FP | PSN_EDF,
+         "preempt lower-priority task when a higher-priority task resumes")
+{
+        int child_hi, child_lo, status, waiters;
+        lt_t delay = ms2lt(100);
+        double start, stop;
+
+        struct rt_task params;
+        params.cpu        = 0;
+        params.exec_cost  =  ms2lt(10000);
+        params.period     = ms2lt(100000);
+        params.relative_deadline = params.period;
+        params.phase      = 0;
+        params.cls        = RT_CLASS_HARD;
+        params.budget_policy = NO_ENFORCEMENT;
+
+        child_lo = FORK_TASK(
+                params.priority = LITMUS_LOWEST_PRIORITY;
+                SYSCALL( set_rt_task_param(gettid(), &params) );
+                SYSCALL( be_migrate_to(params.cpu) );
+                SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+                SYSCALL( wait_for_ts_release() );
+
+                start = cputime();
+
+                while (cputime() - start < 10)
+                        ;
+
+                );
+
+        child_hi = FORK_TASK(
+                params.priority = LITMUS_HIGHEST_PRIORITY;
+                params.relative_deadline -= 1000000;
+                SYSCALL( set_rt_task_param(gettid(), &params) );
+                SYSCALL( be_migrate_to(params.cpu) );
+                SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+                SYSCALL( wait_for_ts_release() );
+
+                start = cputime();
+
+                while (cputime() - start < 0.1)
+                        ;
+
+                start = wctime();
+                SYSCALL( lt_sleep(ms2lt(100)) );
+                stop = wctime();
+
+                SYSCALL( kill(child_lo, SIGUSR2) );
+
+                if (stop - start >= 0.2)
+                        fprintf(stderr, "\nHi-prio delay = %fsec\n",
+                                stop - start - (ms2lt(100) / 1E9));
+
+                /* Assert we woke up 'soonish' after the sleep. */
+                ASSERT( stop - start < 0.2 );
+                );
+
+
+        do {
+                waiters = get_nr_ts_release_waiters();
+                ASSERT( waiters >= 0 );
+        } while (waiters != 2);
+
+        waiters = release_ts(&delay);
+
+        SYSCALL( waitpid(child_hi, &status, 0) );
+        ASSERT( status == 0 );
+
+        SYSCALL( waitpid(child_lo, &status, 0) );
+        ASSERT( status ==  SIGUSR2);
+}
+
+