sys_wait_for_zone_exit system call has been implemented.

sys_wait_for_zone_exit waits on a flag which is cleared during the local
timer interrupt. Yet more race conditions have been avoided by performing
zone checks before waiting for the flag, and by setting the flag *before*
performing the zone check, so that if we enter the loop immediately after
leaving the blocking zone, we are still okay.

1 files changed, 24 insertions, 21 deletions

diff --git a/kernel/litmus.c b/kernel/litmus.c
index 6de1dbe060..dbeca929a7 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -297,11 +297,9 @@ asmlinkage int sys_in_blocking_zone(void)
         int quantum_start_time;
                 /* quantum_start_time =
                 * Time of last quantum boundary = Time of last local timer intr */
-        int zone_size;
-                /* zone_size =  
-                 *
-                 *          * Size of blocking zone */
-        /* Assuming us granularity... */
+        int zone_size = ZONE_SIZE;
+        
+        /* Assuming us granularity... */
         int quantum_length = jiffies_to_usecs(1);
         do_gettimeofday(&current_time);
         /* Is current_time > quantum_start_time+quantum_length-zone_size? */
@@ -319,24 +317,29 @@ asmlinkage int sys_in_blocking_zone(void)
  */
 asmlinkage int sys_wait_for_zone_exit(void)
 {
-        /*
-         * Set flag. FIX: race condition, what if we enter this
-         * function and interrupt handler clears flags before
-         * this function sets the flag? Similar problems could occur
-         * if we slept instead.
-         * CURRENT FIX: If the interrupt handler ran, then we would not
-         * be in the zone anymore, and could return immediately. Otherwise
-         * we would still be in the zone, and would have to wait.
-         */
+        /* Get task struct for current task. */
+        struct task_struct *p = current;
+
+        /* Set flag. */
+        p->rt_param.waiting_to_exit_zone = 1;
         flag = 1;
 
-        while (flag) {
-                /*
-                 * Delay, otherwise loop is too tight and flag cannot
-                 * be cleared.
-                 */
-                udelay(1);
-        }
+        /*
+         * To avoid race condition, perform one final check if we are
+         * in the zone before spinning on the flag. If we are not in
+         * the zone, then the local timer interrupt has already occured,
+         * and we should clear the flag and immediately return.
+         */
+        if (sys_in_blocking_zone()) {
+                while (p->rt_param.waiting_to_exit_zone)
+                        udelay(1); /* delay, otherwise tight loop
+                                    * causes problems. if we want this
+                                    * to work for EDF, maybe change this
+                                    * to sched_yield()?
+                                    */
+        } else {
+                p->rt_param.waiting_to_exit_zone = 0;
+        }       
 
         return 0; // everything went okay
 }