added should_yield_lock() syscall for engine locks

10 files changed, 147 insertions, 2 deletions

diff --git a/include/litmus/fifo_lock.h b/include/litmus/fifo_lock.h
index fcf53c10ca92..cff2cc663fb7 100644
--- a/include/litmus/fifo_lock.h
+++ b/include/litmus/fifo_lock.h
@@ -51,6 +51,7 @@ void fifo_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
 
 int fifo_mutex_lock(struct litmus_lock* l);
 int fifo_mutex_unlock(struct litmus_lock* l);
+int fifo_mutex_should_yield_lock(struct litmus_lock* l);
 int fifo_mutex_close(struct litmus_lock* l);
 void fifo_mutex_free(struct litmus_lock* l);
 struct litmus_lock* fifo_mutex_new(struct litmus_lock_ops*);
diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 4dd8c66868e6..39e32d3f48c7 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -116,6 +116,7 @@ typedef int (*lock_op_t)(struct litmus_lock *l);
 typedef lock_op_t lock_close_t;
 typedef lock_op_t lock_lock_t;
 typedef lock_op_t lock_unlock_t;
+typedef lock_op_t lock_should_yield_lock_t;
 
 typedef int (*lock_open_t)(struct litmus_lock *l, void* __user arg);
 typedef void (*lock_free_t)(struct litmus_lock *l);
@@ -135,6 +136,7 @@ struct litmus_lock_ops {
         /* Current tries to lock/unlock this lock (mandatory methods). */
         lock_lock_t lock;
         lock_unlock_t unlock;
+        lock_should_yield_lock_t should_yield_lock;
 
         /* The lock is no longer being referenced (mandatory method). */
         lock_free_t deallocate;
diff --git a/include/litmus/prioq_lock.h b/include/litmus/prioq_lock.h
index 1128e3aab077..73d1e0dbc9a2 100644
--- a/include/litmus/prioq_lock.h
+++ b/include/litmus/prioq_lock.h
@@ -57,6 +57,7 @@ void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
 
 int prioq_mutex_lock(struct litmus_lock* l);
 int prioq_mutex_unlock(struct litmus_lock* l);
+int prioq_mutex_should_yield_lock(struct litmus_lock* l);
 int prioq_mutex_close(struct litmus_lock* l);
 void prioq_mutex_free(struct litmus_lock* l);
 struct litmus_lock* prioq_mutex_new(struct litmus_lock_ops*);
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index d1fe84a5d574..4ba93c095c0a 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -24,4 +24,7 @@
 
 #define __NR_sched_trace_event  __LSC(15)
 
-#define NR_litmus_syscalls 16
+#define __NR_litmus_should_unlock __LSC(16)
+#define __NR_litmus_dgl_should_unlock __LSC(17)
+
+#define NR_litmus_syscalls 18
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index 75f9fcb897f5..ec732f99748f 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -40,4 +40,11 @@ __SYSCALL(__NR_set_aux_tasks, sys_set_aux_tasks)
 #define __NR_sched_trace_event          __LSC(15)
 __SYSCALL(__NR_sched_trace_event, sys_sched_trace_event)
 
-#define NR_litmus_syscalls 16
+
+#define __NR_litmus_should_yield_lock   __LSC(16)
+__SYSCALL(__NR_litmus_should_yield_lock, sys_litmus_should_yield_lock)
+#define __NR_litmus_dgl_should_yield_lock       __LSC(17)
+__SYSCALL(__NR_litmus_dgl_should_yield_lock, sys_litmus_dgl_should_yield_lock)
+
+
+#define NR_litmus_syscalls 18
diff --git a/litmus/fifo_lock.c b/litmus/fifo_lock.c
index 4598cddbdb79..ebb915621e9c 100644
--- a/litmus/fifo_lock.c
+++ b/litmus/fifo_lock.c
@@ -510,6 +510,26 @@ out:
         return err;
 }
 
+int fifo_mutex_should_yield_lock(struct litmus_lock* l)
+{
+        int should_yield;
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
+        struct task_struct *t = current;
+        unsigned long flags;
+        
+        if (unlikely(mutex->owner != t))
+                return -EINVAL;
+
+        local_irq_save(flags);
+        
+        /* Yield if someone is waiting. Check does not need to be atomic. */
+        should_yield = waitqueue_active(&mutex->wait);
+        
+        local_irq_restore(flags);
+        
+        return should_yield;
+}
+
 
 void fifo_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                                                 struct task_struct* t,
diff --git a/litmus/locking.c b/litmus/locking.c
index 67f5fda590c0..37aaab5fb7e8 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -184,6 +184,30 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         return err;
 }
 
+asmlinkage long sys_litmus_should_yield_lock(int lock_od)
+{
+        long err = -EINVAL;
+        struct od_table_entry* entry;
+        struct litmus_lock* l;
+
+        entry = get_entry_for_od(lock_od);
+        if (entry && is_lock(entry)) {
+                l = get_lock(entry);
+                
+                if (l->ops->should_yield_lock) {
+                        TRACE_CUR("Checking to see if should yield lock %d\n", l->ident);
+                        err = l->ops->should_yield_lock(l);
+                }
+                else {
+                        TRACE_CUR("Lock %d does not support yielding.\n", l->ident);
+                        err = 0; /* report back "no, don't unlock" */
+                }
+        }
+        
+        return err;
+}
+
+
 struct task_struct* __waitqueue_remove_first(wait_queue_head_t *wq)
 {
         wait_queue_t* q;
@@ -718,6 +742,60 @@ out:
         return err;
 }
 
+
+asmlinkage long sys_litmus_dgl_should_yield_lock(void* __user usr_dgl_ods, int dgl_size)
+{
+        long err = -EINVAL;
+        int dgl_ods[MAX_DGL_SIZE];
+        
+        if(dgl_size > MAX_DGL_SIZE || dgl_size < 1)
+                goto out;
+        
+        if(!access_ok(VERIFY_READ, usr_dgl_ods, dgl_size*(sizeof(*dgl_ods))))
+                goto out;
+        
+        if(__copy_from_user(&dgl_ods, usr_dgl_ods, dgl_size*(sizeof(*dgl_ods))))
+                goto out;
+        
+        
+        if (dgl_size == 1) {
+                /* DGL size of 1. Just call regular singular lock. */
+                TRACE_CUR("Treating as regular lock.\n");
+                err = sys_litmus_should_yield_lock(dgl_ods[0]);
+        }
+        else {
+                unsigned long flags;
+                int i;
+                err = 0;
+                
+                local_irq_save(flags);
+                
+                for(i = 0; (i < dgl_size) && (0 == err); ++i) {
+                        struct od_table_entry *entry = get_entry_for_od(dgl_ods[i]);
+                        if (entry && is_lock(entry)) {
+                                struct litmus_lock *l = get_lock(entry);
+                                if (l->ops->should_yield_lock) {
+                                        TRACE_CUR("Checking to see if should yield lock %d\n", l->ident);
+                                        err = l->ops->should_yield_lock(l);
+                                }
+                                else {
+                                        TRACE_CUR("Lock %d does not support yielding.\n", l->ident);
+                                }
+                        }
+                        else {
+                                TRACE_CUR("Invalid lock identifier\n");
+                                err = -EINVAL;
+                        }
+                }
+                
+                local_irq_restore(flags);
+        }
+        
+out:
+        return err;
+}
+
+
 #else  // CONFIG_LITMUS_DGL_SUPPORT
 
 asmlinkage long sys_litmus_dgl_lock(void* __user usr_dgl_ods, int dgl_size)
@@ -730,6 +808,11 @@ asmlinkage long sys_litmus_dgl_unlock(void* __user usr_dgl_ods, int dgl_size)
         return -ENOSYS;
 }
 
+asmlinkage long sys_litmus_dgl_should_yield_lock(void* __user usr_dgl_ods, int dgl_size)
+{
+        return -ENOSYS;
+}
+
 #endif
 
 unsigned int __add_wait_queue_prio_exclusive(
diff --git a/litmus/prioq_lock.c b/litmus/prioq_lock.c
index 61682d20da51..2d363cffd482 100644
--- a/litmus/prioq_lock.c
+++ b/litmus/prioq_lock.c
@@ -1031,6 +1031,26 @@ out:
         return err;
 }
 
+int prioq_mutex_should_yield_lock(struct litmus_lock* l)
+{
+        int should_yield;       
+        struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
+        struct task_struct *t = current;
+        unsigned long flags;
+        
+        if (unlikely(mutex->owner != t))
+                return -EINVAL;
+
+        local_irq_save(flags);
+        
+        /* if hp_waiter can preempt 't', then 't' should be inheriting from hp_waiter */
+        should_yield = (NULL != mutex->hp_waiter) &&
+                (effective_priority(t) == effective_priority(mutex->hp_waiter));
+        
+        local_irq_restore(flags);
+        
+        return should_yield;
+}
 
 void prioq_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                                                                                         struct task_struct* t,
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index b931c83579bc..024470a7fb58 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -2380,6 +2380,7 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
 static struct litmus_lock_ops cedf_fifo_mutex_lock_ops = {
         .lock   = fifo_mutex_lock,
         .unlock = fifo_mutex_unlock,
+        .should_yield_lock = fifo_mutex_should_yield_lock,
         .close  = fifo_mutex_close,
         .deallocate = fifo_mutex_free,
 
@@ -2414,6 +2415,7 @@ static struct litmus_lock* cedf_new_fifo_mutex(void)
 static struct litmus_lock_ops cedf_prioq_mutex_lock_ops = {
         .lock   = prioq_mutex_lock,
         .unlock = prioq_mutex_unlock,
+        .should_yield_lock = prioq_mutex_should_yield_lock,
         .close  = prioq_mutex_close,
         .deallocate = prioq_mutex_free,
 
@@ -2448,6 +2450,7 @@ static struct litmus_lock* cedf_new_prioq_mutex(void)
 static struct litmus_lock_ops cedf_ikglp_lock_ops = {
         .lock   = ikglp_lock,
         .unlock = ikglp_unlock,
+        .should_yield_lock = NULL,
         .close  = ikglp_close,
         .deallocate = ikglp_free,
 
@@ -2479,6 +2482,7 @@ static struct litmus_lock* cedf_new_ikglp(void* __user arg)
 static struct litmus_lock_ops cedf_kfmlp_lock_ops = {
         .lock   = kfmlp_lock,
         .unlock = kfmlp_unlock,
+        .should_yield_lock = NULL,
         .close  = kfmlp_close,
         .deallocate = kfmlp_free,
 
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 4aeb7a0db3bd..c652048f8df1 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -1495,6 +1495,7 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
 static struct litmus_lock_ops gsnedf_fifo_mutex_lock_ops = {
         .lock   = fifo_mutex_lock,
         .unlock = fifo_mutex_unlock,
+        .should_yield_lock = fifo_mutex_should_yield_lock,
         .close  = fifo_mutex_close,
         .deallocate = fifo_mutex_free,
 
@@ -1518,6 +1519,7 @@ static struct litmus_lock* gsnedf_new_fifo_mutex(void)
 static struct litmus_lock_ops gsnedf_ikglp_lock_ops = {
         .lock   = ikglp_lock,
         .unlock = ikglp_unlock,
+        .should_yield_lock = NULL,
         .close  = ikglp_close,
         .deallocate = ikglp_free,
 
@@ -1539,6 +1541,7 @@ static struct litmus_lock* gsnedf_new_ikglp(void* __user arg)
 static struct litmus_lock_ops gsnedf_kfmlp_lock_ops = {
         .lock   = kfmlp_lock,
         .unlock = kfmlp_unlock,
+        .should_yield_lock = NULL,
         .close  = kfmlp_close,
         .deallocate = kfmlp_free,
 
@@ -1741,6 +1744,7 @@ void gsnedf_fmlp_free(struct litmus_lock* lock)
 static struct litmus_lock_ops gsnedf_fmlp_lock_ops = {
         .close  = gsnedf_fmlp_close,
         .lock   = gsnedf_fmlp_lock,
+        .should_yield_lock = NULL,      
         .unlock = gsnedf_fmlp_unlock,
         .deallocate = gsnedf_fmlp_free,