Added support for suspending for per-access forbidden zones

under EXT-RES scheduling with the global OMLP.

Note that this assumes the caller already holds the lock.

3 files changed, 24 insertions, 3 deletions

diff --git a/bin/rtspin.c b/bin/rtspin.c
index fb7f13f..70b5528 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -82,6 +82,7 @@ const char *usage_msg =
         "    -X PROTOCOL       access a shared resource protected by a locking protocol\n"
         "    -L CS-LENGTH      simulate a critical section length of CS-LENGTH milliseconds\n"
         "    -Q RESOURCE-ID    access the resource identified by RESOURCE-ID\n"
+        "    -Z                enable checking for forbidden zones after locking a resource\n"
         "\n"
         "Units:\n"
         "    WCET and PERIOD are expected in milliseconds.\n"
@@ -298,7 +299,7 @@ static int generate_output(int output_fd)
         return written == len;
 }
 
-static void job(double exec_time, double program_end, int lock_od, double cs_length)
+static void job(double exec_time, double program_end, int lock_od, double cs_length, int check_fz)
 {
         double chunk1, chunk2;
 
@@ -312,6 +313,8 @@ static void job(double exec_time, double program_end, int lock_od, double cs_len
 
                 /* critical section */
                 litmus_lock(lock_od);
+                if (check_fz)
+                        litmus_access_forbidden_zone_check(lock_od, s2ns(cs_length));
                 loop_for(cs_length, program_end + 1);
                 litmus_unlock(lock_od);
 
@@ -336,7 +339,7 @@ static lt_t choose_inter_arrival_time_ns(
         return ms2ns(iat_ms);
 }
 
-#define OPTSTR "p:c:wlveo:s:m:q:r:X:L:Q:iRu:U:Bhd:C:S::O::TD:E:A:a:"
+#define OPTSTR "p:c:wlveo:s:m:q:r:X:L:Q:ZiRu:U:Bhd:C:S::O::TD:E:A:a:"
 
 int main(int argc, char** argv)
 {
@@ -402,6 +405,7 @@ int main(int argc, char** argv)
         const char *lock_namespace = "./rtspin-locks";
         int protocol = -1;
         double cs_length = 1; /* millisecond */
+        int check_fz = 0;
 
         progname = argv[0];
 
@@ -530,6 +534,9 @@ int main(int argc, char** argv)
                         resource_id = want_non_negative_int(optarg, "-Q");
 
                         break;
+                case 'Z':
+                        check_fz = 1;
+                        break;
                 case 'v':
                         verbose = 1;
                         break;
@@ -803,7 +810,7 @@ int main(int argc, char** argv)
                                 (acet * 1000 / wcet_ms) * 100);
 
                 /* burn cycles */
-                job(acet, start + duration, lock_od, cs_length * 0.001);
+                job(acet, start + duration, lock_od, cs_length * 0.001, check_fz);
 
                 if (want_output) {
                         /* generate some output at end of job */
diff --git a/include/litmus.h b/include/litmus.h
index a50f996..8ccd0b7 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -235,6 +235,12 @@ int litmus_open_lock(obj_type_t protocol, int lock_id, const char* name_space,
  */
 int litmus_lock(int od);
 /**
+ *  Access protected resource (wait if in forbidden zone)
+ * @param od Object descriptor obtained by litmus_open_lock()
+ * @return 0 iff the resource access was granted successfully
+ */
+int litmus_access_forbidden_zone_check(int od, lt_t fz_len);
+/**
  * Release lock
  * @param od Object descriptor obtained by litmus_open_lock()
  * @return 0 iff the lock was released successfully
diff --git a/src/syscalls.c b/src/syscalls.c
index 70c67dd..9a1a1c3 100644
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -67,6 +67,14 @@ int litmus_lock(int od)
         return litmus_syscall(LRT_litmus_lock, od);
 }
 
+int litmus_access_forbidden_zone_check(int od, lt_t fz_len)
+{
+        union litmus_syscall_args args;
+        args.access_forbidden_zone_check.sem_od = od;
+        args.access_forbidden_zone_check.fz_len = fz_len;
+        return litmus_syscall(LRT_access_forbidden_zone_check, (unsigned long) &args);
+}
+
 int litmus_unlock(int od)
 {
         return litmus_syscall(LRT_litmus_unlock, od);