1 files changed, 61 insertions, 33 deletions

diff --git a/include/litmus/locking.h b/include/litmus/locking.h
index 972cbdb7fdd5..c2324c4ccb8a 100644
--- a/include/litmus/locking.h
+++ b/include/litmus/locking.h
@@ -13,6 +13,15 @@ struct nested_info
         struct task_struct **hp_waiter_ptr;
     struct binheap_node hp_binheap_node;        
 };
+
+static inline struct task_struct* top_priority(struct binheap_handle* handle) {
+        if(!binheap_empty(handle)) {
+                return (struct task_struct*)(binheap_top_entry(handle, struct nested_info, hp_binheap_node)->hp_waiter_eff_prio);
+        }
+        return NULL;
+}
+
+void print_hp_waiters(struct binheap_node* n, int depth);
 #endif
 
 
@@ -23,16 +32,14 @@ struct litmus_lock {
         struct litmus_lock_ops *ops;
         int type;
     
-#ifdef CONFIG_LITMUS_NESTED_LOCKING
         int ident;
         
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
         struct nested_info nest;
-
 //#ifdef CONFIG_DEBUG_SPINLOCK  
         char cheat_lockdep[2];
         struct lock_class_key key;
 //#endif
-
 #endif
 };
 
@@ -41,36 +48,42 @@ struct litmus_lock {
 #define MAX_DGL_SIZE CONFIG_LITMUS_MAX_DGL_SIZE
 
 typedef struct dgl_wait_state {
-        struct task_struct *task;
-        struct litmus_lock *locks[MAX_DGL_SIZE];
-        int size;
-        int nr_remaining;
-        
-        int last_primary;
-        
+        struct task_struct *task;       /* task waiting on DGL */
+        struct litmus_lock *locks[MAX_DGL_SIZE];        /* requested locks in DGL */
+        int size;                       /* size of the DGL */
+        int nr_remaining;       /* nr locks remainging before DGL is complete */
+        int last_primary;       /* index lock in locks[] that has active priority */
         wait_queue_t wq_nodes[MAX_DGL_SIZE];
 } dgl_wait_state_t;
 
 void wake_or_wait_on_next_lock(dgl_wait_state_t *dgl_wait);
-void select_next_lock(dgl_wait_state_t* dgl_wait, struct litmus_lock* prev_lock);
+void select_next_lock(dgl_wait_state_t* dgl_wait /*, struct litmus_lock* prev_lock*/);
 
 void init_dgl_waitqueue_entry(wait_queue_t *wq_node, dgl_wait_state_t* dgl_wait);
 int dgl_wake_up(wait_queue_t *wq_node, unsigned mode, int sync, void *key);
 void __waitqueue_dgl_remove_first(wait_queue_head_t *wq, dgl_wait_state_t** dgl_wait, struct task_struct **task);
 #endif
 
+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 int (*lock_open_t)(struct litmus_lock *l, void* __user arg);
+typedef void (*lock_free_t)(struct litmus_lock *l);
+
 struct litmus_lock_ops {
         /* Current task tries to obtain / drop a reference to a lock.
          * Optional methods, allowed by default. */
-        int (*open)(struct litmus_lock*, void* __user);
-        int (*close)(struct litmus_lock*);
+        lock_open_t open;
+        lock_close_t close;
 
         /* Current tries to lock/unlock this lock (mandatory methods). */
-        int (*lock)(struct litmus_lock*);
-        int (*unlock)(struct litmus_lock*);
+        lock_lock_t lock;
+        lock_unlock_t unlock;
         
         /* The lock is no longer being referenced (mandatory method). */
-        void (*deallocate)(struct litmus_lock*);
+        lock_free_t deallocate;
         
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         void (*propagate_increase_inheritance)(struct litmus_lock* l, struct task_struct* t, raw_spinlock_t* to_unlock, unsigned long irqflags);
@@ -86,7 +99,36 @@ struct litmus_lock_ops {
 };
 
 
-#ifdef CONFIG_LITMUS_DGL_SUPPORT
+/*
+ Nested inheritance can be achieved with fine-grain locking when there is
+ no need for DGL support, presuming locks are acquired in a partial order
+ (no cycles!).  However, DGLs allow locks to be acquired in any order.  This
+ makes nested inheritance very difficult (we don't yet know a solution) to
+ realize with fine-grain locks, so we use a big lock instead.
+ 
+ Code contains both fine-grain and coarse-grain methods together, side-by-side.
+ Each lock operation *IS NOT* surrounded by ifdef/endif to help make code more
+ readable.  However, this leads to the odd situation where both code paths
+ appear together in code as if they were both active together.
+ 
+ THIS IS NOT REALLY THE CASE!  ONLY ONE CODE PATH IS ACTUALLY ACTIVE!
+ 
+ Example:
+        lock_global_irqsave(coarseLock, flags);
+        lock_fine_irqsave(fineLock, flags);
+ 
+ Reality (coarse):
+        lock_global_irqsave(coarseLock, flags);
+        //lock_fine_irqsave(fineLock, flags);   
+ 
+ Reality (fine):
+        //lock_global_irqsave(coarseLock, flags);
+        lock_fine_irqsave(fineLock, flags);      
+ 
+ Be careful when you read code involving nested inheritance.
+ */
+#if defined(CONFIG_LITMUS_DGL_SUPPORT)
+/* DGL requires a big lock to implement nested inheritance */
 #define lock_global_irqsave(lock, flags)                raw_spin_lock_irqsave((lock), (flags))
 #define lock_global(lock)                                               raw_spin_lock((lock))
 #define unlock_global_irqrestore(lock, flags)   raw_spin_unlock_irqrestore((lock), (flags))
@@ -98,8 +140,8 @@ struct litmus_lock_ops {
 #define unlock_fine_irqrestore(lock, flags)
 #define unlock_fine(lock)
 
-#elif CONFIG_LITMUS_NESTED_LOCKING
-
+#elif defined(CONFIG_LITMUS_NESTED_LOCKING)
+/* Use fine-grain locking when DGLs are disabled. */
 /* global locking are no-ops without DGL support */
 #define lock_global_irqsave(lock, flags)
 #define lock_global(lock)
@@ -116,17 +158,3 @@ struct litmus_lock_ops {
 
 #endif
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-