paranoid android

7 files changed, 120 insertions, 42 deletions

diff --git a/include/litmus/budget.h b/include/litmus/budget.h
index 559cfcdda61a..062df818de45 100644
--- a/include/litmus/budget.h
+++ b/include/litmus/budget.h
@@ -7,6 +7,9 @@ void update_enforcement_timer(struct task_struct* t);
 
 void prepare_for_next_server(struct task_struct* t,int forced);
 
-#define job_behind(t) (lt_before_eq((t)->rt_param.job_params.deadline, \
-                                    (t)->rt_param.job_params.release))
+#define job_behind(t)\
+        (lt_before((t)->rt_param.job_params.real_release, get_release(t)))
+
+void server_release(struct task_struct *t);
+void task_release(struct task_struct *t);
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 221edad83d77..f15b1ad5fa3c 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -83,6 +83,9 @@ struct rt_job {
         /* What is the current deadline? */
         lt_t    deadline;
 
+        lt_t    real_release;
+        lt_t    real_deadline;
+
         /* How much service has this job received so far? */
         lt_t    exec_time;
 
@@ -209,6 +212,8 @@ struct rt_param {
 
         /* Pointer to the page shared between userspace and kernel. */
         struct control_page * ctrl_page;
+
+        /* int go; */
 };
 
 /*      Possible RT flags       */
diff --git a/litmus/budget.c b/litmus/budget.c
index 75f4b5156947..7d94f7e61b27 100644
--- a/litmus/budget.c
+++ b/litmus/budget.c
@@ -5,6 +5,7 @@
 #include <litmus/litmus.h>
 #include <litmus/preempt.h>
 #include <litmus/budget.h>
+#include <litmus/sched_trace.h>
 
 struct enforcement_timer {
         /* The enforcement timer is used to accurately police
@@ -63,7 +64,7 @@ static void arm_enforcement_timer(struct enforcement_timer* et,
 
         /* Calling this when there is no budget left for the task
          * makes no sense, unless the task is non-preemptive. */
-        BUG_ON(budget_exhausted(t) && (!is_np(t)));
+        /* BUG_ON(budget_exhausted(t) && (!is_np(t))); */
 
         /* __hrtimer_start_range_ns() cancels the timer
          * anyway, so we don't have to check whether it is still armed */
@@ -109,20 +110,38 @@ static int __init init_budget_enforcement(void)
         return 0;
 }
 
+void task_release(struct task_struct *t)
+{
+        t->rt_param.job_params.real_release = t->rt_param.job_params.deadline;
+        t->rt_param.job_params.real_deadline += get_rt_period(t);
+        t->rt_param.job_params.job_no++;
+        TRACE_TASK(t, "Releasing task, rr=%llu rd=%llu\n",
+                   t->rt_param.job_params.real_release,
+                   t->rt_param.job_params.real_deadline);
+        sched_trace_task_release(t);
+}
+
+void server_release(struct task_struct *t)
+{
+        lt_t now = litmus_clock();
+        t->rt_param.job_params.exec_time = 0;
+        t->rt_param.job_params.release = t->rt_param.job_params.deadline;
+        t->rt_param.job_params.deadline +=  get_rt_period(t);
+        TRACE_TASK(t, "Releasing server, r=%llu d=%llu\n",
+                   t->rt_param.job_params.release,
+                   t->rt_param.job_params.deadline);
+        /* don't confuse linux */
+        t->rt.time_slice = 1;
+}
+
 void prepare_for_next_server(struct task_struct *t, int forced)
 {
-        if (!job_behind(t)) {
-                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.exec_time = 0;
-                /* update job sequence number */
-                t->rt_param.job_params.job_no++;
-        } else if (forced) {
-                t->rt_param.job_params.release = t->rt_param.job_params.deadline;
-                t->rt_param.job_params.exec_time = 0;
-        } else /* behind */{
-                t->rt_param.job_params.deadline += get_rt_period(t);
-                t->rt_param.job_params.job_no++;
+        if (forced || job_behind(t)) {
+                server_release(t);
+        }
+
+        if (!forced) {
+                task_release(t);
         }
 }
 
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 669a3df5fcc1..10a42db1165e 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -12,7 +12,9 @@ void prepare_for_next_period(struct task_struct *t)
         /* prepare next release */
 
         t->rt_param.job_params.release   = t->rt_param.job_params.deadline;
+        t->rt_param.job_params.real_release =  t->rt_param.job_params.release;
         t->rt_param.job_params.deadline += get_rt_period(t);
+        t->rt_param.job_params.real_deadline = t->rt_param.job_params.deadline;
         t->rt_param.job_params.exec_time = 0;
         /* update job sequence number */
         t->rt_param.job_params.job_no++;
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 09123eeadf2c..5264d2546a7f 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -254,7 +254,7 @@ static void setup_release(rt_domain_t *_rt)
         list_for_each_safe(pos, safe, &list) {
                 /* pick task of work list */
                 t = list_entry(pos, struct task_struct, rt_param.list);
-                sched_trace_task_release(t);
+                /* sched_trace_task_release(t); */
                 list_del_init(pos);
 
                 /* put into release heap while holding release_lock */
@@ -410,14 +410,21 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
         BUG_ON(is_queued(task));
         BUG_ON(get_task_domain(task) != dom);
 
+        if (is_queued(task)) {
+                VTRACE_TASK(task, "Queued, skipping\n");
+                return;
+        }
+
         if (is_released(task, litmus_clock())) {
                 __add_ready(domain, task);
-                VTRACE("rt: adding %s/%d (%llu, %llu) rel=%llu to ready queue at %llu\n",
+                /* tsk_rt(task)->go = 1; */
+                VTRACE("going, rt: adding %s/%d (%llu, %llu) rel=%llu to ready queue at %llu\n",
                       task->comm, task->pid, get_exec_cost(task), get_rt_period(task),
                       get_release(task), litmus_clock());
         } else {
                 /* task has to wait for next release */
-                VTRACE_TASK(task, "add release(), rel=%llu\n", get_release(task));
+                VTRACE_TASK(task, "not going, add release(), rel=%llu\n", get_release(task));
+                /* tsk_rt(task)->go = 0; */
                 add_release(domain, task);
         }
 
@@ -429,7 +436,12 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
  */
 static struct task_struct* pd_take_ready(domain_t *dom)
 {
-        return __take_ready((rt_domain_t*)dom->data);
+        struct task_struct *t = __take_ready((rt_domain_t*)dom->data);
+        if (t) {
+                /* TRACE_TASK(t, "going\n"); */
+                /* tsk_rt(t)->go = 1; */
+        }
+        return t;
 }
 
 /* pd_peek_ready - returns the head of the rt_domain ready queue
@@ -438,14 +450,23 @@ static struct task_struct* pd_take_ready(domain_t *dom)
  */
 static struct task_struct* pd_peek_ready(domain_t *dom)
 {
-        return __next_ready((rt_domain_t*)dom->data);
+        struct task_struct *t = __peek_ready((rt_domain_t*)dom->data);
+        /* if (t) { */
+        /*      TRACE_TASK(t, "going\n"); */
+        /*      tsk_rt(t)->go = 1; */
+        /* } */
+        return t;
 }
 
 static void pd_remove(domain_t *dom, struct task_struct *task)
 {
-        if (is_queued(task)) {
+        if (is_queued(task))
                 remove((rt_domain_t*)dom->data, task);
-        }
+        /* if (is_queued(task) && tsk_rt(task)->go) { */
+        /*      remove((rt_domain_t*)dom->data, task); */
+        /* } else if (is_queued(task)) { */
+        /*      VTRACE_TASK(task, "Did not remove cause of nogo\n"); */
+        /* } */
 }
 
 /* pd_domain_init - create a generic domain wrapper for an rt_domain
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index baded0d58cb9..da8a82119612 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -477,6 +477,22 @@ static void update_crit_levels(struct cpu_entry *entry)
         }
 }
 
+static inline int cache_next(struct domain *dom)
+{
+        struct task_struct *t;
+        t = dom->peek_ready(dom);
+        return 1;
+        /* if (t && tsk_mc_crit(t) != CRIT_LEVEL_A && budget_exhausted(t)) { */
+        /*      TRACE_TASK(t, "Cached and moved to release\n"); */
+        /*      prepare_for_next_server(t, 1); */
+        /*      dom->take_ready(dom); */
+        /*      dom->requeue(dom, t); */
+        /*      return 0; */
+        /* } else { */
+        /*      return 1; */
+        /* } */
+}
+
 /**
  * check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
  * Caller must hold domain lock.
@@ -495,8 +511,10 @@ static void check_for_preempt(struct domain *dom)
                         entry = crit_cpu(ce);
                         recheck = 1;
 
-                        /* Cache ready task */
-                        dom->peek_ready(dom);
+                        /* Dodge exhausted tasks */
+                        if (!cache_next(dom)) {
+                                continue;
+                        }
 
                         raw_spin_lock(&entry->lock);
                         if (!can_use(ce))
@@ -516,6 +534,7 @@ static void check_for_preempt(struct domain *dom)
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
                 raw_spin_lock(&entry->lock);
+                while (!cache_next(dom));
                 if (can_use(ce) && dom->preempt_needed(dom, ce->linked)) {
                         preempt(dom, ce);
                         update_crit_levels(entry);
@@ -570,7 +589,6 @@ static void remove_from_all(struct task_struct* task)
         /* Ensure the task isn't returned by its domain */
         dom->remove(dom, task);
 
-        BUG_ON(is_queued(task));
         raw_spin_unlock(dom->lock);
 }
 
@@ -582,8 +600,15 @@ static void remove_from_all(struct task_struct* task)
 static void job_completion(struct task_struct *task, int forced)
 {
         lt_t now;
-        TRACE_MC_TASK(task, "Completed\n");
-        sched_trace_task_completion(task, forced);
+        int ghost = is_ghost(task);
+        int behind = tsk_mc_crit(task) != CRIT_LEVEL_A && job_behind(task);
+        TRACE_MC_TASK(task, "Completed, ghost %d, forced %d, behind %d\n",
+                      ghost, forced, behind);
+
+        /* if (!is_ghost(task)) { */
+        /* and no more forced!!! */
+                sched_trace_task_completion(task, forced);
+        /* } */
         BUG_ON(!task);
 
         /* Logically stop the task execution */
@@ -592,23 +617,25 @@ static void job_completion(struct task_struct *task, int forced)
 
         now = litmus_clock();
 
-        /* If it's not a ghost job, do ghost job conversion */
-        if (!is_ghost(task) && !job_behind(task)) {
-                TRACE_MC_TASK(task, "is not a ghost task\n");
-                tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
+
+        if (!forced && !ghost) {
+                task_release(task);
+        }
+
+        if (!forced && !ghost) {
+                tsk_mc_data(task)->mc_job.ghost_budget =
+                        budget_remaining(task);
                 tsk_mc_data(task)->mc_job.is_ghost = 1;
         }
 
-        /* If the task is a ghost job with no budget, it either exhausted
-         * its ghost budget or there was no ghost budget after the job
-         * conversion. Revert back to a normal task and complete the period.
-         */
-        if (tsk_mc_data(task)->mc_job.ghost_budget == 0) {
-                TRACE_MC_TASK(task, "has zero ghost budget\n");
+        if (forced || behind || tsk_mc_data(task)->mc_job.ghost_budget == 0) {
+                TRACE_MC_TASK(task, "making not a ghost\n");
                 tsk_mc_data(task)->mc_job.is_ghost = 0;
-                prepare_for_next_server(task, forced);
-                if (is_released(task, litmus_clock()))
-                        sched_trace_task_release(task);
+                tsk_mc_data(task)->mc_job.ghost_budget = 0;
+        }
+
+        if (forced || (!behind && !is_ghost(task))) {
+                server_release(task);
         }
 
         /* Requeue non-blocking tasks */
@@ -967,6 +994,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                 raw_spin_lock(dom->lock);
 
                 /* Peek at task here to avoid lock use */
+                while (!cache_next(dom));
                 dtask = dom->peek_ready(dom);
 
                 raw_spin_lock(&entry->lock);
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 768a2a0f9d2f..f923280b3146 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -146,8 +146,8 @@ feather_callback void do_sched_trace_task_release(unsigned long id, unsigned lon
         struct task_struct *t = (struct task_struct*) _task;
         struct st_event_record* rec = get_record(ST_RELEASE, t);
         if (rec) {
-                rec->data.release.release  = get_release(t);
-                rec->data.release.deadline = get_deadline(t);
+                rec->data.release.release  = tsk_rt(t)->job_params.real_release;
+                rec->data.release.deadline = tsk_rt(t)->job_params.real_deadline;
                 put_record(rec);
         }
 }