New Feature: Arbitrary deadlines.

Added support for arbitrary deadlines.

Constraint: Relative deadline must be >= exec cost.

Use: Set relative deadline in rt_task::rdeadline. Set value to 0
     to default to implicit deadlines.

Limitations: PFAIR not supported by this patch. PFAIR updated to
     reject tasks that do not have implicit deadlines.

6 files changed, 45 insertions, 17 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 0b071fd359f9..00b434f83c75 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -50,6 +50,7 @@ void litmus_exit_task(struct task_struct *tsk);
 #define get_exec_cost(t)        (tsk_rt(t)->task_params.exec_cost)
 #define get_exec_time(t)        (tsk_rt(t)->job_params.exec_time)
 #define get_rt_period(t)        (tsk_rt(t)->task_params.period)
+#define get_rt_rdeadline(t)     (tsk_rt(t)->task_params.rdeadline)
 #define get_rt_phase(t)         (tsk_rt(t)->task_params.phase)
 #define get_partition(t)        (tsk_rt(t)->task_params.cpu)
 #define get_deadline(t)         (tsk_rt(t)->job_params.deadline)
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index d6d799174160..0ddd8c134533 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -36,6 +36,7 @@ typedef enum {
 struct rt_task {
         lt_t            exec_cost;
         lt_t            period;
+        lt_t            rdeadline;
         lt_t            phase;
         unsigned int    cpu;
         task_class_t    cls;
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 36e314625d86..44dd133a295a 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -6,12 +6,14 @@
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
 
+
 void prepare_for_next_period(struct task_struct *t)
 {
         BUG_ON(!t);
         /* prepare next release */
-        t->rt_param.job_params.release   = t->rt_param.job_params.deadline;
-        t->rt_param.job_params.deadline += get_rt_period(t);
+        t->rt_param.job_params.release  += get_rt_period(t);
+        t->rt_param.job_params.deadline  = t->rt_param.job_params.release
+                + get_rt_rdeadline(t);
         t->rt_param.job_params.exec_time = 0;
         /* update job sequence number */
         t->rt_param.job_params.job_no++;
@@ -22,8 +24,19 @@ void prepare_for_next_period(struct task_struct *t)
 
 void release_at(struct task_struct *t, lt_t start)
 {
-        t->rt_param.job_params.deadline = start;
-        prepare_for_next_period(t);
+        BUG_ON(!t);
+
+        /* prepare next release */
+        t->rt_param.job_params.release = start;
+        t->rt_param.job_params.deadline  = start + get_rt_rdeadline(t);
+        t->rt_param.job_params.exec_time = 0;
+
+        /* update job sequence number */
+        t->rt_param.job_params.job_no++;
+
+        /* don't confuse Linux */
+        t->rt.time_slice = 1;
+
         set_rt_flags(t, RT_F_RUNNING);
 }
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 301390148d02..0ee0926f37d3 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -102,21 +102,25 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
                 goto out_unlock;
         }
 
+        /* set relative deadline to be implicit if left unspecified */
+        if (tp.rdeadline == 0)
+                tp.rdeadline = tp.period;
+
         if (tp.exec_cost <= 0)
                 goto out_unlock;
         if (tp.period <= 0)
                 goto out_unlock;
         if (!cpu_online(tp.cpu))
                 goto out_unlock;
-        if (tp.period < tp.exec_cost)
+        if (tp.rdeadline < tp.exec_cost)
         {
                 printk(KERN_INFO "litmus: real-time task %d rejected "
-                       "because wcet > period\n", pid);
+                       "because wcet greater than relative deadline\n", pid);
                 goto out_unlock;
         }
-        if (    tp.cls != RT_CLASS_HARD &&
-                tp.cls != RT_CLASS_SOFT &&
-                tp.cls != RT_CLASS_BEST_EFFORT)
+        if (tp.cls != RT_CLASS_HARD &&
+            tp.cls != RT_CLASS_SOFT &&
+            tp.cls != RT_CLASS_BEST_EFFORT)
         {
                 printk(KERN_INFO "litmus: real-time task %d rejected "
                                  "because its class is invalid\n", pid);
@@ -321,11 +325,12 @@ long litmus_admit_task(struct task_struct* tsk)
 
         BUG_ON(is_realtime(tsk));
 
-        if (get_rt_period(tsk) == 0 ||
-            get_exec_cost(tsk) > get_rt_period(tsk)) {
-                TRACE_TASK(tsk, "litmus admit: invalid task parameters "
-                           "(%lu, %lu)\n",
-                           get_exec_cost(tsk), get_rt_period(tsk));
+        if (get_rt_rdeadline(tsk) == 0 ||
+            get_exec_cost(tsk) > get_rt_rdeadline(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_rdeadline(tsk));
                 retval = -EINVAL;
                 goto out;
         }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index d405854cd39c..d4db03ab5f95 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -300,9 +300,10 @@ void rt_domain_init(rt_domain_t *rt,
  */
 void __add_ready(rt_domain_t* rt, struct task_struct *new)
 {
-        TRACE("rt: adding %s/%d (%llu, %llu) rel=%llu to ready queue at %llu\n",
-              new->comm, new->pid, get_exec_cost(new), get_rt_period(new),
-              get_release(new), litmus_clock());
+        TRACE("rt: adding %s/%d (%llu, %llu, %llu) rel=%llu to ready queue at %llu\n",
+                new->comm, new->pid,
+                get_exec_cost(new), get_rt_period(new), get_rt_rdeadline(new),
+                get_release(new), litmus_clock());
 
         BUG_ON(bheap_node_in_heap(tsk_rt(new)->heap_node));
 
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index 16f1065bbdca..6cf764ec26d4 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -850,6 +850,13 @@ static long pfair_admit_task(struct task_struct* t)
             cpu_cluster(pstate[task_cpu(t)]))
                 return -EINVAL;
 
+        if (get_rt_period(t) != get_rt_rdeadline(t)) {
+                printk(KERN_INFO "%s: Admission rejected. "
+                        "Only implicit deadlines are currently supported.\n",
+                        litmus->plugin_name);
+                return -EINVAL;
+        }
+
         /* Pfair is a tick-based method, so the time
          * of interest is jiffies. Calculate tick-based
          * times for everything.