4 files changed, 98 insertions, 25 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index a1f3613ebeed..02b750a9570b 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -284,6 +284,12 @@ struct rt_param {
         struct litmus_lock* blocked_lock;
 #endif
 
+        
+         struct task_struct*    hp_group;
+         unsigned int                   is_slave:1;
+         unsigned int                   has_slaves:1;
+
+
 #ifdef CONFIG_NP_SECTION
         /* For the FMLP under PSN-EDF, it is required to make the task
          * non-preemptive from kernel space. In order not to interfere with
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index 4fa514c89605..4fd92956d13f 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -21,4 +21,6 @@
 #define __NR_litmus_dgl_unlock  __LSC(13)
 #define __NR_register_nv_device                 __LSC(14)
 
-#define NR_litmus_syscalls 15
+#define __NR_slave_non_rt_threads       _LSC(15)
+
+#define NR_litmus_syscalls 16
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index f80dc45dc185..abb45c181e8e 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -36,5 +36,7 @@ __SYSCALL(__NR_litmus_dgl_unlock, sys_litmus_dgl_unlock)
 #define __NR_register_nv_device                 __LSC(14)
 __SYSCALL(__NR_register_nv_device, sys_register_nv_device)
 
+#define __NR_slave_non_rt_threads       __LSC(15)
+__SYSCALL(__NR_slave_non_rt_threads, sys_slave_non_rt_threads)
 
-#define NR_litmus_syscalls 15
+#define NR_litmus_syscalls 16
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 53727d699915..83e8ef3f42af 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -328,6 +328,59 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
 }
 
 
+long __litmus_admit_task(struct task_struct* tsk);
+
+asmlinkage long sys_slave_non_rt_threads(void)
+{
+        long retval = 0;
+        struct task_struct *leader = current->group_leader;
+        struct task_struct *t;
+        struct task_struct *hp = NULL;
+
+        read_lock_irq(&tasklist_lock);
+
+        t = leader;
+        do {
+                TRACE_CUR("threads in %s/%d: %s/%d:\n", leader->comm, leader->pid, t->comm, t->pid);
+
+                if (tsk_rt(t)->heap_node == NULL) {
+                        retval = __litmus_admit_task(t);
+
+                        if (retval != 0) break;
+
+                        /* hasn't been admitted into rt. make it a slave. */
+                        tsk_rt(t)->slave = 1;
+                }
+                else {
+                        tsk_rt(t)->has_slaves = 1;
+
+                        if (is_realtime(t) && litmus->compare(t, hp)) {
+                                hp = t;
+                        }
+                }
+
+                t = next_thread(t);
+        } while(t != leader);
+
+        if (hp) {
+                TRACE_CUR("found hp in group: %s/%d\n", hp->comm, hp->pid);
+
+                /* set up inheritance */
+                leader->hp_group = hp;
+
+                t = leader;
+                do {
+                        if (tsk_rt(t)->slave) {
+                                litmus->increase_prio(t);
+                        }
+                } while(t != leader);
+        }
+
+        read_unlock_irq(&tasklist_lock);
+
+        return 0;
+}
+
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
 void init_gpu_affinity_state(struct task_struct* p)
 {
@@ -422,32 +475,11 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 #endif
 }
 
-long litmus_admit_task(struct task_struct* tsk)
+long __litmus_admit_task(struct task_struct* tsk)
 {
         long retval = 0;
         unsigned long flags;
 
-        BUG_ON(is_realtime(tsk));
-
-        if (get_rt_relative_deadline(tsk) == 0 ||
-            get_exec_cost(tsk) >
-                        min(get_rt_relative_deadline(tsk), get_rt_period(tsk)) ) {
-                TRACE_TASK(tsk,
-                        "litmus admit: invalid task parameters "
-                        "(e = %lu, p = %lu, d = %lu)\n",
-                        get_exec_cost(tsk), get_rt_period(tsk),
-                        get_rt_relative_deadline(tsk));
-                retval = -EINVAL;
-                goto out;
-        }
-
-        if (!cpu_online(get_partition(tsk))) {
-                TRACE_TASK(tsk, "litmus admit: cpu %d is not online\n",
-                           get_partition(tsk));
-                retval = -EINVAL;
-                goto out;
-        }
-
         INIT_LIST_HEAD(&tsk_rt(tsk)->list);
 
         /* avoid scheduler plugin changing underneath us */
@@ -469,7 +501,6 @@ long litmus_admit_task(struct task_struct* tsk)
                 bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
 
-
 #ifdef CONFIG_LITMUS_NVIDIA
         atomic_set(&tsk_rt(tsk)->nv_int_count, 0);
 #endif
@@ -499,6 +530,38 @@ long litmus_admit_task(struct task_struct* tsk)
 
 out_unlock:
         raw_spin_unlock_irqrestore(&task_transition_lock, flags);
+
+        return retval;
+}
+
+long litmus_admit_task(struct task_struct* tsk)
+{
+        long retval = 0;
+        unsigned long flags;
+
+        BUG_ON(is_realtime(tsk));
+
+        if (get_rt_relative_deadline(tsk) == 0 ||
+            get_exec_cost(tsk) >
+                        min(get_rt_relative_deadline(tsk), get_rt_period(tsk)) ) {
+                TRACE_TASK(tsk,
+                        "litmus admit: invalid task parameters "
+                        "(e = %lu, p = %lu, d = %lu)\n",
+                        get_exec_cost(tsk), get_rt_period(tsk),
+                        get_rt_relative_deadline(tsk));
+                retval = -EINVAL;
+                goto out;
+        }
+
+        if (!cpu_online(get_partition(tsk))) {
+                TRACE_TASK(tsk, "litmus admit: cpu %d is not online\n",
+                           get_partition(tsk));
+                retval = -EINVAL;
+                goto out;
+        }
+
+        retval = __litmus_admit_task(tsk);
+
 out:
         return retval;
 }