Still working on global FZs (hard-coded at 100ms), waking up not always working.

1 files changed, 35 insertions, 44 deletions

diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 31142253783c..11d1e295b974 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -586,23 +586,22 @@ static void gedf_env_resume(
 #ifdef CONFIG_LITMUS_LOCKING
         // Only the first cpu to resume should wake up forbidden-zone waiters
         if (!tmp_cpus) {
-                // printk("[%u] About to check for waiters.\n", gedf_env->env.res->id);
+                // if (gedf_env->env.res->id == 1)
+                //      printk("[%u] About to check for waiters.\n", gedf_env->env.res->id);
 
-                // // Wake up any forbidden-zone waiters
-                // spin_lock_irqsave(&gedf_env->fz_waiters.lock, flags);
+                // Wake up any forbidden-zone waiters
+                spin_lock_irqsave(&gedf_env->fz_waiters.lock, flags);
 
-                // struct task_struct *next;
-                // while ((next) = __waitqueue_remove_first(&gedf_env->fz_waiters)) {
-                //      printk("[%u] Waking up process %d.\n", gedf_env->env.res->id, next->pid);
-                //      wake_up_process(next);
-                // }
-
-                // // if (waitqueue_active(&gedf_env->fz_waiters)) {
-                // //   printk("About to wake up fz waiters\n");
-                // //   __wake_up(&gedf_env->fz_waiters, TASK_NORMAL, 0, NULL); // 0: all
-                // // }
+                struct task_struct *next;
+                while ((next) = __waitqueue_remove_first(&gedf_env->fz_waiters)) {
+                        printk("[%u] Waking up process %d, state=%d.\n", gedf_env->env.res->id, next->pid, next->state);
+                        if (wake_up_process(next))
+                                printk("[%u] Success waking up %d.\n", gedf_env->env.res->id, next->pid);
+                        else
+                                printk("[%u] Failed to wake up %d.\n", gedf_env->env.res->id, next->pid);
+                }
 
-                // spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
         }
 #endif
 }
@@ -1033,53 +1032,45 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
         tsk_rt(t)->num_locks_held++;
 
         /* if in a forbidden zone, wait until the next time slice */
-        // remaining_component_budget = t_res->par_env->res->cur_budget;
-
-        // LOCK STUFFZ
-
-        unsigned int cpu = smp_processor_id();
-        struct reservation *comp_res = t_res->par_env->res;
-        struct mtd_reservation *mtd_res = container_of(comp_res, struct mtd_reservation, res[cpu]);
-        BUG_ON(&(mtd_res->res[cpu]) != comp_res);
+        /* note that we can't use t_res->par_env->res->cur_budget
+         * because it is only updated on a call to schedule(), and
+         * thus might not reflect the current remaining budget
+         * for the component */
         gedf_env = container_of(t_res->par_env, struct gedf_reservation_environment, env);
-        printk("%d Getting interval end for component %u on CPU %u (mtd=%p, comp_res=%p)\n",
-                t->pid, gedf_env->env.res->id, cpu, mtd_res, comp_res);
+        spin_lock_irqsave(&gedf_env->fz_waiters.lock, flags);
 
-        lt_t interval_end = mtd_res->cur_interval[cpu].end;
-        lt_t major_cycle_start = mtd_res->major_cycle_start[cpu];
-        lt_t timeslice_end = interval_end + major_cycle_start;
-        lt_t current_time = litmus_clock();
-        remaining_component_budget = timeslice_end - current_time;
-        printk("%d Interval end=%llu, major cycle start=%llu, timeslice end=%llu, current time=%llu, budget=%llu\n",
-                t->pid, interval_end, major_cycle_start, timeslice_end, current_time, remaining_component_budget);
+        unsigned int cpu = smp_processor_id();
+        struct mtd_reservation *mtd_res = (struct mtd_reservation*)t_res->par_env->res;
+        lt_t timeslice_end = mtd_res->cur_interval[cpu].end + mtd_res->major_cycle_start[cpu];
+        remaining_component_budget = timeslice_end - litmus_clock();
 
         fz_length = 100 * 1000000LL; // for now, hard-coded at 100ms
         if (remaining_component_budget < fz_length) {
-                // gedf_env = container_of(t_res->par_env, struct gedf_reservation_environment, env);
-
                 /* go on a wait queue to be woken up when the parent reservation
                 * is next scheduled */
-                // spin_lock_irqrestore(&gedf_env->fz_waiters.lock, flags);
-
                 printk("%d in the forbidden zone, going on wait queue (budget left: %llu)\n",
                         t->pid, remaining_component_budget);
 
-                // init_waitqueue_entry(&fz_wait, t);
-                // set_task_state(t, TASK_UNINTERRUPTIBLE);
-                // __add_wait_queue_tail_exclusive(&gedf_env->fz_waiters, &fz_wait);
-                // // add_wait_queue(&gedf_env->fz_waiters, &fz_wait);
-                // // // __add_wait_queue_tail(&gedf_env->fz_waiters, &fz_wait);
+                init_waitqueue_entry(&fz_wait, t);
+                set_task_state(t, TASK_UNINTERRUPTIBLE);
+                __add_wait_queue_tail_exclusive(&gedf_env->fz_waiters, &fz_wait);
+
+                TS_LOCK_SUSPEND;
+
+                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+
+                BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
 
-                // // // spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+                schedule();
 
-                // schedule();
+                TS_LOCK_RESUME;
 
-                // printk("%d awake!\n", t->pid);
+                printk("%d awake!\n", t->pid);
         } else {
                 printk("%d is not in the FZ, budget remaining is %llu\n",
                         t->pid, remaining_component_budget);
+                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
         }
-        
 
         return 0;
 }