Add add convenience wrapper and tests for the DFLP

2 files changed, 213 insertions, 0 deletions

diff --git a/tests/locks.c b/tests/locks.c
index bc35a8e..d7cfdee 100644
--- a/tests/locks.c
+++ b/tests/locks.c
@@ -110,6 +110,37 @@ TESTCASE(lock_fmlp, PSN_EDF | GSN_EDF | P_FP,
         SYSCALL( remove(".fmlp_locks") );
 }
 
+TESTCASE(lock_dflp, P_FP,
+         "DFLP acquisition and release")
+{
+        int fd, od, cpu = 1;
+
+        SYSCALL( fd = open(".dflp_locks", O_RDONLY | O_CREAT) );
+
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od = open_dflp_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(".dflp_locks") );
+}
+
 TESTCASE(srp_lock_mode_change, P_FP | PSN_EDF,
          "SRP task becomes non-RT task while holding lock")
 {
@@ -155,6 +186,50 @@ TESTCASE(srp_lock_mode_change, P_FP | PSN_EDF,
         SYSCALL( remove(".locks") );
 }
 
+TESTCASE(dflp_lock_mode_change, P_FP,
+         "DFLP task becomes non-RT task while holding lock")
+{
+        int fd, od, cpu = 0;
+
+        int child, status;
+
+        struct rt_task params;
+        init_rt_task_param(&params);
+        params.cpu        = 1;
+        params.exec_cost  =  ms2ns(10000);
+        params.period     = ms2ns(100000);
+        params.relative_deadline = params.period;
+
+        SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
+
+        child = FORK_TASK(
+                params.priority = LITMUS_LOWEST_PRIORITY;
+                SYSCALL( set_rt_task_param(gettid(), &params) );
+                SYSCALL( be_migrate_to_cpu(params.cpu) );
+                SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+                SYSCALL( od = open_dflp_sem(fd, 0, cpu) );
+
+                SYSCALL( litmus_lock(od) );
+
+                SYSCALL( task_mode(BACKGROUND_TASK) );
+
+                SYSCALL( litmus_unlock(od) );
+
+                SYSCALL( od_close(od) );
+
+                exit(0);
+                );
+
+        SYSCALL( waitpid(child, &status, 0) );
+        ASSERT( WIFEXITED(status) );
+        ASSERT( WEXITSTATUS(status) == 0 );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".locks") );
+}
+
 TESTCASE(fmlp_lock_mode_change, P_FP | PSN_EDF | GSN_EDF,
          "FMLP task becomes non-RT task while holding lock")
 {
@@ -277,3 +352,43 @@ TESTCASE(fmlp_lock_teardown, P_FP | PSN_EDF | GSN_EDF,
 
         SYSCALL( remove(".locks") );
 }
+
+TESTCASE(dflp_lock_teardown, P_FP,
+         "DFLP task exits while holding lock")
+{
+        int fd, od, cpu = 0;
+
+        int child, status;
+
+        struct rt_task params;
+        init_rt_task_param(&params);
+        params.cpu        = 1;
+        params.exec_cost  =  ms2ns(10000);
+        params.period     = ms2ns(100000);
+        params.relative_deadline = params.period;
+
+        SYSCALL( fd = open(".locks", O_RDONLY | O_CREAT, S_IRUSR) );
+
+        exit(0);
+
+        child = FORK_TASK(
+                params.priority = LITMUS_LOWEST_PRIORITY;
+                SYSCALL( set_rt_task_param(gettid(), &params) );
+                SYSCALL( be_migrate_to_cpu(params.cpu) );
+                SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+                SYSCALL( od = open_dflp_sem(fd, 0, cpu) );
+
+                SYSCALL( litmus_lock(od) );
+                exit(123);
+                );
+
+        SYSCALL( waitpid(child, &status, 0) );
+        ASSERT( WIFEXITED(status) );
+        ASSERT( WEXITSTATUS(status) == 123 );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".locks") );
+}
+
diff --git a/tests/nesting.c b/tests/nesting.c
index b294334..f8a3f1a 100644
--- a/tests/nesting.c
+++ b/tests/nesting.c
@@ -466,3 +466,101 @@ TESTCASE(dpcp_nesting, P_FP,
 
         SYSCALL( remove(".dpcp_locks") );
 }
+
+TESTCASE(dflp_nesting, P_FP,
+         "DFLP no nesting allowed")
+{
+        int od, od2;
+        int cpu = 0;
+
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od  = litmus_open_lock(DFLP_SEM, 0, ".dflp_locks", &cpu) );
+        SYSCALL( od2 = litmus_open_lock(DFLP_SEM, 1, ".dflp_locks", &cpu) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od2));
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od));
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( od_close(od) );
+        SYSCALL( od_close(od2) );
+
+        SYSCALL( remove(".dflp_locks") );
+}
+
+TESTCASE(lock_fmlp_dflp_no_nesting, P_FP,
+         "DFLP and FMLP nesting not allowed")
+{
+        int od, od2;
+        const char* namespace = ".locks";
+        int cpu = 0;
+
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od  = litmus_open_lock(DFLP_SEM, 0, namespace, &cpu) );
+        SYSCALL( od2 = litmus_open_lock(FMLP_SEM, 1, namespace, NULL) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od2));
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od));
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( od_close(od) );
+        SYSCALL( od_close(od2) );
+
+        SYSCALL( remove(namespace) );
+}
+
+TESTCASE(lock_dflp_pcp_no_nesting, P_FP,
+         "PCP and DFLP nesting not allowed")
+{
+        int od, od2;
+        int cpu = 0;
+        const char* namespace = ".locks";
+
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( task_mode(LITMUS_RT_TASK) );
+
+        SYSCALL( od  = litmus_open_lock(PCP_SEM, 0, namespace, NULL) );
+        SYSCALL( od2 = litmus_open_lock(DFLP_SEM, 1, namespace, &cpu) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( litmus_lock(od) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od2));
+        SYSCALL( litmus_unlock(od) );
+
+        SYSCALL( litmus_lock(od2) );
+        SYSCALL_FAILS(EBUSY, litmus_lock(od));
+        SYSCALL( litmus_unlock(od2) );
+
+        SYSCALL( od_close(od) );
+        SYSCALL( od_close(od2) );
+
+        SYSCALL( remove(namespace) );
+}