6 files changed, 186 insertions, 25 deletions

diff --git a/include/litmus/ctrlpage.h b/include/litmus/ctrlpage.h
index f7b03e1aedd6..445857d2f38b 100644
--- a/include/litmus/ctrlpage.h
+++ b/include/litmus/ctrlpage.h
@@ -74,6 +74,7 @@ typedef enum {
         LRT_wait_for_ts_release,
         LRT_release_ts,
         LRT_get_current_budget,
+        LRT_access_forbidden_zone_check,
 } litmus_syscall_id_t;
 
 union litmus_syscall_args {
@@ -98,6 +99,11 @@ union litmus_syscall_args {
                 lt_t __user *expended;
                 lt_t __user *remaining;
         } get_current_budget;
+
+        struct {
+                uint32_t sem_od;
+                lt_t fz_len;
+        } access_forbidden_zone_check;
 };
 
 
diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 4d7b870cb443..0dae82711717 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -1,6 +1,8 @@
 #ifndef LITMUS_LOCKING_H
 #define LITMUS_LOCKING_H
 
+#include <litmus/rt_param.h>
+
 struct litmus_lock_ops;
 
 /* Generic base struct for LITMUS^RT userspace semaphores.
@@ -21,6 +23,9 @@ struct litmus_lock_ops {
         int (*lock)(struct litmus_lock*);
         int (*unlock)(struct litmus_lock*);
 
+        /* Current tries to access protected resource (mandatory methods if supported). */
+        int (*access_forbidden_zone_check)(struct litmus_lock*, lt_t fz_len);
+
         /* The lock is no longer being referenced (mandatory method). */
         void (*deallocate)(struct litmus_lock*);
 };
diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index 08961e7931a2..d9694fa3ac64 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -66,6 +66,12 @@ struct gedf_reservation_environment {
         struct bheap_node* cpu_node;
 
         rt_domain_t domain;
+
+#ifdef CONFIG_LITMUS_LOCKING
+        /* reservations sleeping due to forbidden zones */
+        int num_waiter_queues;
+        wait_queue_head_t* fz_waiters;
+#endif
 };
 
 long alloc_gedf_reservation_environment(
diff --git a/litmus/ctrldev.c b/litmus/ctrldev.c
index cc74c5afa5c6..7090f9bc67ad 100644
--- a/litmus/ctrldev.c
+++ b/litmus/ctrldev.c
@@ -130,6 +130,7 @@ asmlinkage long sys_od_open(int fd, int type, int obj_id, void* __user config);
 asmlinkage long sys_od_close(int od);
 asmlinkage long sys_complete_job(void);
 asmlinkage long sys_litmus_lock(int lock_od);
+asmlinkage long sys_access_forbidden_zone_check(int lock_od, lt_t fz_len);
 asmlinkage long sys_litmus_unlock(int lock_od);
 asmlinkage long sys_wait_for_job_release(unsigned int job);
 asmlinkage long sys_wait_for_ts_release(void);
@@ -155,6 +156,7 @@ static long litmus_ctrl_ioctl(struct file *filp,
         case LRT_reservation_create:
         case LRT_get_current_budget:
         case LRT_od_open:
+        case LRT_access_forbidden_zone_check:
                 /* multiple arguments => need to get args via pointer */
                 /* get syscall parameters */
                 if (copy_from_user(&syscall_args, (void*) arg,
@@ -185,6 +187,10 @@ static long litmus_ctrl_ioctl(struct file *filp,
                                 syscall_args.od_open.obj_type,
                                 syscall_args.od_open.obj_id,
                                 syscall_args.od_open.config);
+                case LRT_access_forbidden_zone_check:
+                        return sys_access_forbidden_zone_check(
+                                syscall_args.access_forbidden_zone_check.sem_od,
+                                syscall_args.access_forbidden_zone_check.fz_len);
                 }
 
 
diff --git a/litmus/locking.c b/litmus/locking.c
index a1d0515c5613..eb228e6b01af 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -97,6 +97,28 @@ asmlinkage long sys_litmus_lock(int lock_od)
         return err;
 }
 
+asmlinkage long sys_access_forbidden_zone_check(int lock_od, lt_t fz_len)
+{
+        long err = -EINVAL;
+        struct od_table_entry* entry;
+        struct litmus_lock* l;
+
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_IN_END;
+
+        entry = get_entry_for_od(lock_od);
+        if (entry && is_lock(entry)) {
+                l = get_lock(entry);
+                TRACE_CUR("attempts to check forbidden zone 0x%p\n", l);
+                err = l->ops->access_forbidden_zone_check(l, fz_len);
+        }
+
+        TS_SYSCALL_OUT_START;
+
+        return err;
+}
+
 asmlinkage long sys_litmus_unlock(int lock_od)
 {
         long err = -EINVAL;
@@ -181,6 +203,11 @@ asmlinkage long sys_litmus_lock(int sem_od)
         return -ENOSYS;
 }
 
+asmlinkage long sys_forbidden_zone_start(int lock_od, int fz_len)
+{
+        return -ENOSYS;
+}
+
 asmlinkage long sys_litmus_unlock(int sem_od)
 {
         return -ENOSYS;
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 8b39518f4a1a..e5a19e6de663 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -13,6 +13,7 @@
 #include <litmus/debug_trace.h>
 #include <litmus/trace.h>
 #include <litmus/reservations/gedf_reservation.h>
+#include <litmus/reservations/table_driven_ext_reservation.h>
 
 // Needed to store context during cross-CPU function calls
 struct csd_wrapper {
@@ -554,6 +555,10 @@ static void gedf_env_resume(
         unsigned long flags;
         // Needs to be volatile or it may be optimized to gedf_env->num_cpus
         volatile int tmp_cpus;
+        // For waking up forbidden-zone waiters
+        int i;
+        struct task_struct *next;
+        struct reservation *next_res;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         entry = &gedf_env->cpu_entries[cpu];
@@ -581,6 +586,22 @@ static void gedf_env_resume(
         // Keep this outside the lock. Resuming the timer may have side-effects.
         if (!tmp_cpus)
                 domain_resume_releases(&gedf_env->domain);
+
+#ifdef CONFIG_LITMUS_LOCKING
+        // Wake up any forbidden-zone waiters
+        for (i = 0; i < gedf_env->num_waiter_queues; i++) {
+                if (i == cpu)
+                        continue;
+
+                spin_lock_irqsave(&gedf_env->fz_waiters[i].lock, flags);
+                while ( (next = __waitqueue_remove_first(&gedf_env->fz_waiters[i])) ) {
+                        next_res = (struct reservation *) tsk_rt(next)->plugin_state;
+                        wake_up_process(next);
+                }
+
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[i].lock, flags);
+        }
+#endif
 }
 
 static struct task_struct* gedf_env_dispatch(
@@ -716,17 +737,17 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
         struct gedf_cpu_entry* linked_on;
         int check_preempt = 0;
 
-        struct reservation *t_res = (struct reservation *) tsk_rt(t)->plugin_state;
-        struct reservation *prio_inh_res = (struct reservation *) tsk_rt(prio_inh)->plugin_state;
-
-        struct reservation_environment *env = t_res->par_env;
-
+        struct reservation *t_res, *prio_inh_res;
         struct gedf_reservation_environment *gedf_env;
-        gedf_env = container_of(env, struct gedf_reservation_environment, env);
-
         struct gedf_reservation *gedf_res;
+
+        t_res = (struct reservation *) tsk_rt(t)->plugin_state;
         gedf_res = container_of(t_res, struct gedf_reservation, res);
 
+        prio_inh_res = (struct reservation *) tsk_rt(prio_inh)->plugin_state;
+
+        gedf_env = container_of(t_res->par_env, struct gedf_reservation_environment, env);
+
         raw_spin_lock(&gedf_env->domain.ready_lock);
 
         TRACE_TASK(t, "inherits priority from %s/%d\n", prio_inh->comm, prio_inh->pid);
@@ -785,22 +806,23 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
 /* called with IRQs off */
 static void clear_priority_inheritance(struct task_struct* t)
 {
-        struct reservation *t_res = (struct reservation *) tsk_rt(t)->plugin_state;
-
-        struct reservation_environment *env = t_res->par_env;
-
+        struct reservation *t_res;
+        struct gedf_reservation *gedf_res;
+        struct reservation_environment *env;
         struct gedf_reservation_environment *gedf_env;
-        gedf_env = container_of(env, struct gedf_reservation_environment, env);
+        struct gedf_cpu_entry *entry;
 
-        struct gedf_reservation *gedf_res;
+        t_res = (struct reservation *) tsk_rt(t)->plugin_state;
         gedf_res = container_of(t_res, struct gedf_reservation, res);
 
+        env = t_res->par_env;
+        gedf_env = container_of(env, struct gedf_reservation_environment, env);
+
         raw_spin_lock(&gedf_env->domain.ready_lock);
 
         /* A job only stops inheriting a priority when it releases a
          * resource. Thus we can make the following assumption.*/
-        int cpu = smp_processor_id();
-        struct gedf_cpu_entry *entry = &gedf_env->cpu_entries[cpu];
+        entry = &gedf_env->cpu_entries[smp_processor_id()];
         BUG_ON(entry->scheduled != gedf_res);
 
         TRACE_TASK(t, "priority restored\n");
@@ -938,10 +960,15 @@ static struct task_struct* omlp_find_hp_waiter(struct omlp_semaphore *sem,
 
 int gedf_env_omlp_lock(struct litmus_lock* l)
 {
+        // The task and the semaphore
         struct task_struct* t = current;
         struct omlp_semaphore *sem = omlp_from_lock(l);
-        prio_wait_queue_t wait;
+        // Various scheduler entities
+        struct reservation *t_res, *o_res;
+        struct gedf_reservation *gedf_res;
+        // Waiting
         unsigned long flags;
+        prio_wait_queue_t wait;
 
         if (!is_realtime(t))
                 return -EPERM;
@@ -951,9 +978,8 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
         if (tsk_rt(t)->num_locks_held)
                 return -EBUSY;
 
-        struct reservation *t_res = (struct reservation *) tsk_rt(t)->plugin_state;
-
-        struct gedf_reservation *gedf_res = container_of(t_res, struct gedf_reservation, res);
+        t_res = (struct reservation *) tsk_rt(t)->plugin_state;
+        gedf_res = container_of(t_res, struct gedf_reservation, res);
 
         spin_lock_irqsave(&sem->fifo_wait.lock, flags);
 
@@ -971,7 +997,7 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
                 if (higher_res_prio(t_res, sem->hp_waiter_res)) {
                         sem->hp_waiter = t;
                         sem->hp_waiter_res = t_res;
-                        struct reservation *o_res = (struct reservation *) tsk_rt(sem->owner)->plugin_state;
+                        o_res = (struct reservation *) tsk_rt(sem->owner)->plugin_state;
                         if (higher_res_prio(t_res, o_res)) {
                                 set_priority_inheritance(sem->owner, sem->hp_waiter);
                         }
@@ -1005,12 +1031,80 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
         return 0;
 }
 
+static int gedf_env_omlp_access_fz_check(struct litmus_lock* l, lt_t fz_len)
+{
+        // The task and the semaphore
+        struct task_struct* t = current;
+        struct omlp_semaphore *sem = omlp_from_lock(l);
+        // Various scheduler entities
+        struct reservation *t_res;
+        struct gedf_reservation_environment *gedf_env;
+        struct gedf_reservation *gedf_res;
+        // Forbidden zones
+        unsigned int cpu;
+        lt_t timeslice_end, remaining_component_budget;
+        struct mtd_reservation *mtd_res;
+        // Waiting
+        unsigned long flags;
+        wait_queue_t wait;
+
+        if (!is_realtime(t))
+                return -EPERM;
+
+        if (sem->owner != t) { // does this need a lock around it?
+                return -EINVAL;
+        }
+
+        t_res = (struct reservation *) tsk_rt(t)->plugin_state;
+        gedf_res = container_of(t_res, struct gedf_reservation, res);
+
+        /* if in a forbidden zone, wait until the next time slice */
+        /* 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);
+        spin_lock_irqsave(&gedf_env->fz_waiters[0].lock, flags);
+
+        cpu = smp_processor_id();
+
+        spin_unlock_irqrestore(&gedf_env->fz_waiters[0].lock, flags);
+        spin_lock_irqsave(&gedf_env->fz_waiters[cpu].lock, flags);
+
+        mtd_res = (struct mtd_reservation*)t_res->par_env->res;
+        timeslice_end = mtd_res->cur_interval[cpu].end + mtd_res->major_cycle_start[cpu];
+        remaining_component_budget = timeslice_end - litmus_clock();
+
+        if (remaining_component_budget < fz_len) {
+                /* go on a wait queue to be woken up when the parent reservation
+                * is next scheduled */
+                init_waitqueue_entry(&wait, t);
+                set_task_state(t, TASK_UNINTERRUPTIBLE);
+                __add_wait_queue_tail_exclusive(&gedf_env->fz_waiters[cpu], &wait);
+
+                TS_LOCK_SUSPEND;
+
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[cpu].lock, flags);
+
+                BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
+
+                schedule();
+
+                TS_LOCK_RESUME;
+        } else {
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[cpu].lock, flags);
+        }
+
+        return 0;
+}
+
 static int gedf_env_omlp_unlock(struct litmus_lock* l)
 {
         struct task_struct *t = current, *next;
         struct omlp_semaphore *sem = omlp_from_lock(l);
         unsigned long flags;
         int err = 0;
+        struct reservation *n_res;
 
         spin_lock_irqsave(&sem->fifo_wait.lock, flags);
 
@@ -1028,7 +1122,7 @@ static int gedf_env_omlp_unlock(struct litmus_lock* l)
                 sem->owner = next;
                 TRACE_CUR("lock ownership passed to %s/%d\n", next->comm, next->pid);
 
-                struct reservation *n_res = (struct reservation *) tsk_rt(next)->plugin_state;
+                n_res = (struct reservation *) tsk_rt(next)->plugin_state;
 
                 /* determine new hp_waiter if necessary */
                 if (next == sem->hp_waiter) {
@@ -1095,10 +1189,11 @@ static void gedf_env_omlp_free(struct litmus_lock* lock)
 }
 
 static struct litmus_lock_ops gedf_env_omlp_lock_ops = {
-        .close  = gedf_env_omlp_close,
-        .lock   = gedf_env_omlp_lock,
-        .unlock = gedf_env_omlp_unlock,
-        .deallocate = gedf_env_omlp_free,
+        .close                       = gedf_env_omlp_close,
+        .lock                        = gedf_env_omlp_lock,
+        .access_forbidden_zone_check = gedf_env_omlp_access_fz_check,
+        .unlock                      = gedf_env_omlp_unlock,
+        .deallocate                  = gedf_env_omlp_free,
 };
 
 static struct litmus_lock* gedf_env_new_omlp(void)
@@ -1195,6 +1290,15 @@ long alloc_gedf_reservation_environment(
                 kfree(gedf_env);
                 return -ENOMEM;
         }
+#ifdef CONFIG_LITMUS_LOCKING
+        gedf_env->fz_waiters = kzalloc(sizeof(wait_queue_head_t)*total_cpus, GFP_ATOMIC);
+        if (!gedf_env->fz_waiters) {
+                kfree(gedf_env->cpu_entries);
+                kfree(gedf_env->cpu_node);
+                kfree(gedf_env);
+                return -ENOMEM;
+        }
+#endif
 
         /* set environment callback actions */
         gedf_env->env.ops = &gedf_env_ops;
@@ -1213,6 +1317,13 @@ long alloc_gedf_reservation_environment(
         /* initialize environment domain */
         rt_domain_init(&gedf_env->domain, edf_ready_order, NULL, gedf_env_release_jobs);
 
+#ifdef CONFIG_LITMUS_LOCKING
+        gedf_env->num_waiter_queues = max_cpus;
+        for (i = 0; i < max_cpus; i++) {
+                init_waitqueue_head(&gedf_env->fz_waiters[i]);
+        }
+#endif
+
         *_env = gedf_env;
         return 0;
 }