3 files changed, 138 insertions, 64 deletions

diff --git a/include/litmus/sched_mc.h b/include/litmus/sched_mc.h
index d29796298701..069198ab7e28 100644
--- a/include/litmus/sched_mc.h
+++ b/include/litmus/sched_mc.h
@@ -20,6 +20,8 @@ struct mc_task {
 struct mc_job {
         int is_ghost:1;
         lt_t ghost_budget;
+        /* which invocation of the CE is this */
+        unsigned int expected_job;
 };
 
 #ifdef __KERNEL__
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 437cdfa215ce..89fb4e9aff8c 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -288,7 +288,7 @@ asmlinkage long sys_set_rt_task_mc_param(pid_t pid, struct mc_task __user *param
         struct task_struct *target;
         int retval = -EINVAL;
 
-        printk("Setting up mixed-criicality task parameters for process %d.\n",
+        printk("Setting up mixed-criticality task parameters for process %d.\n",
                 pid);
 
         if (pid < 0 || param == 0) {
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index 0a5a18dc54ff..bda95d9fae41 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -21,6 +21,7 @@
 #include <litmus/rt_param.h>
 #include <litmus/sched_mc.h>
 #include <litmus/litmus_proc.h>
+#include <litmus/sched_trace.h>
 
 static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 
@@ -31,7 +32,6 @@ static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 static atomic_t start_time_set = ATOMIC_INIT(0);
 static atomic64_t start_time = ATOMIC64_INIT(0);
 static struct proc_dir_entry *mc_ce_dir = NULL, *ce_file = NULL;
-static DEFINE_RAW_SPINLOCK(activate_lock);
 
 /*
  * Cache the budget along with the struct PID for a task so that we don't need
@@ -40,9 +40,8 @@ static DEFINE_RAW_SPINLOCK(activate_lock);
  */
 struct ce_dom_pid_entry {
         struct pid *pid;
-        /* execution cost (sometimes called budget) */
-        lt_t exec_cost;
-        /* accumulated (summed) exec costs, including this one */
+        lt_t budget;
+        /* accumulated (summed) budgets, including this one */
         lt_t acc_time;
 };
 
@@ -65,22 +64,29 @@ DEFINE_PER_CPU(rt_domain_t, mc_ce_rts);
 DEFINE_PER_CPU(struct ce_dom_data, _mc_ce_dom_data);
 
 /*
+ * Get the offset into the cycle taking the start time into account.
+ */
+static inline lt_t get_cycle_offset(const lt_t when, const lt_t cycle_time)
+{
+        return (when - atomic64_read(&start_time)) % cycle_time;
+}
+
+/*
  * Return the index into the PID entries table of what to schedule next.
  * Don't call if the table is empty. Assumes the caller has the domain lock.
+ * The offset parameter is the offset into the cycle.
  *
  * TODO Currently O(n) in the number of tasks on the CPU. Binary search?
  */
-static int mc_ce_schedule_at(const lt_t when, const domain_t *dom)
+static int mc_ce_schedule_at(const domain_t *dom, lt_t offset)
 {
         const struct ce_dom_data *ce_data = dom->data;
         const struct ce_dom_pid_entry *pid_entry = NULL;
-        lt_t offset;
         int i;
 
         BUG_ON(ce_data->cycle_time < 1);
         BUG_ON(ce_data->num_pid_entries < 1);
 
-        offset = (when - atomic64_read(&start_time)) % ce_data->cycle_time;
         for (i = 0; i < ce_data->num_pid_entries; ++i) {
                 pid_entry = &ce_data->pid_entries[i];
                 if (offset < pid_entry->acc_time) {
@@ -90,6 +96,7 @@ static int mc_ce_schedule_at(const lt_t when, const domain_t *dom)
         }
         /* can only happen if cycle_time is not right */
         BUG_ON(pid_entry->acc_time > ce_data->cycle_time);
+        TRACE("MC-CE schedule at returned task %d for CPU %d\n", i, ce_data->cpu);
         return i;
 }
 
@@ -118,11 +125,14 @@ static struct task_struct *mc_ce_schedule(struct task_struct *prev)
                 request_exit_np(ce_data->scheduled);
                 next = prev;
         } else if (ce_data->should_schedule &&
-                        is_running(ce_data->should_schedule)) {
-                /* schedule the task for this period if it's not blocked */
-                        next = ce_data->should_schedule;
+                        is_running(ce_data->should_schedule) &&
+                        RT_F_SLEEP != get_rt_flags(ce_data->should_schedule)) {
+                /*
+                 * schedule the task that should be executing in the cyclic
+                 * schedule if it is not blocked and not sleeping
+                 */
+                next = ce_data->should_schedule;
         }
-
         sched_state_task_picked();
         raw_spin_unlock(dom->lock);
         return next;
@@ -212,11 +222,11 @@ static long mc_ce_admit_task(struct task_struct *ts)
                                 lvl_a_id, get_partition(ts));
                 goto out_put_pid_unlock;
         }
-        if (get_exec_cost(ts) != ce_data->pid_entries[lvl_a_id].exec_cost) {
-                printk(KERN_INFO "litmus: saved exec cost %llu and task exec "
-                                "cost %llu differ\n",
-                                ce_data->pid_entries[lvl_a_id].exec_cost,
-                                get_exec_cost(ts));
+        if (get_exec_cost(ts) >= ce_data->pid_entries[lvl_a_id].budget) {
+                printk(KERN_INFO "litmus: execution cost %llu is larger than "
+                                "the budget %llu\n",
+                                get_exec_cost(ts),
+                                ce_data->pid_entries[lvl_a_id].budget);
                 goto out_put_pid_unlock;
         }
         ce_data->pid_entries[lvl_a_id].pid = pid;
@@ -244,12 +254,19 @@ static void mc_ce_task_new(struct task_struct *ts, int on_rq, int running)
         struct pid *pid_should_be_running;
         unsigned long flags;
         int idx, should_be_running;
+        lt_t offset;
 
         /* have to call mc_ce_schedule_at because the task only gets a PID
          * entry after calling admit_task */
 
         raw_spin_lock_irqsave(dom->lock, flags);
-        idx = mc_ce_schedule_at(litmus_clock(), dom);
+        /* initialize some task state */
+        set_rt_flags(ts, RT_F_RUNNING);
+        tsk_rt(ts)->job_params.job_no = 0;
+        tsk_mc_data(ts)->mc_job.expected_job = 0;
+
+        offset = get_cycle_offset(litmus_clock(), ce_data->cycle_time);
+        idx = mc_ce_schedule_at(dom, offset);
         pid_should_be_running = ce_data->pid_entries[idx].pid;
         rcu_read_lock();
         should_be_running = (ts == pid_task(pid_should_be_running, PIDTYPE_PID));
@@ -302,9 +319,13 @@ static void mc_ce_task_block(struct task_struct *ts)
  */
 static long mc_ce_complete_job(void)
 {
-        /* TODO */
-        printk(KERN_EMERG "complete job called TODO\n");
-        BUG();
+        /* mark that the task wishes to sleep */
+        set_rt_flags(current, RT_F_SLEEP);
+        tsk_rt(current)->job_params.job_no++;
+        /* call schedule, this will return when a new job arrives
+         * it also takes care of preparing for the next release
+         */
+        schedule();
         return 0;
 }
 
@@ -328,6 +349,10 @@ static void mc_ce_task_exit(struct task_struct *ts)
         BUG_ON(!pid);
         put_pid(pid);
         ce_data->pid_entries[lvl_a_id].pid = NULL;
+        if (ce_data->scheduled == ts)
+                ce_data->scheduled = NULL;
+        if (ce_data->should_schedule == ts)
+                ce_data->should_schedule = NULL;
         raw_spin_unlock_irqrestore(dom->lock, flags);
 }
 
@@ -341,28 +366,64 @@ static void mc_ce_task_exit(struct task_struct *ts)
  */
 static enum hrtimer_restart timer_callback(struct hrtimer *timer)
 {
-        struct ce_dom_data *ce_data = container_of(timer,
-                        struct ce_dom_data, timer);
-        domain_t *dom = &per_cpu(mc_ce_doms, ce_data->cpu);
         /* relative and absolute times for cycles */
         lt_t now, offset_rel, cycle_start_abs, next_timer_abs;
+        struct task_struct *should_schedule;
         struct ce_dom_pid_entry *pid_entry;
+        struct ce_dom_data *ce_data;
         unsigned long flags;
+        domain_t *dom;
         int idx;
 
+        ce_data = container_of(timer, struct ce_dom_data, timer);
+        dom = &per_cpu(mc_ce_doms, ce_data->cpu);
+
         raw_spin_lock_irqsave(dom->lock, flags);
 
         now = litmus_clock();
-        offset_rel = (now - atomic64_read(&start_time)) % ce_data->cycle_time;
+        TRACE("timer callback at %llu on CPU %d\n", now, ce_data->cpu);
+        /* Based off of the current time, figure out the offset into the cycle
+         * and the cycle's start time, and determine what should be scheduled.
+         */
+        offset_rel = get_cycle_offset(now, ce_data->cycle_time);
         cycle_start_abs = now - offset_rel;
-        idx = mc_ce_schedule_at(now, dom);
+        idx = mc_ce_schedule_at(dom, offset_rel);
         pid_entry = &ce_data->pid_entries[idx];
+        /* set the timer to fire at the next cycle start */
         next_timer_abs = cycle_start_abs + pid_entry->acc_time;
         hrtimer_set_expires(timer, ns_to_ktime(next_timer_abs));
+
         /* get the task_struct (pid_task can accept a NULL) */
         rcu_read_lock();
-        ce_data->should_schedule = pid_task(pid_entry->pid, PIDTYPE_PID);
+        should_schedule = pid_task(pid_entry->pid, PIDTYPE_PID);
         rcu_read_unlock();
+        ce_data->should_schedule = should_schedule;
+
+        if (should_schedule && atomic_read(&start_time_set)) {
+                /* we only start tracking this after the job release syscall */
+                tsk_mc_data(should_schedule)->mc_job.expected_job++;
+                /*
+                 * If jobs are not overrunning their budgets, then this
+                 * should not happen.
+                 */
+                WARN(tsk_mc_data(should_schedule)->mc_job.expected_job !=
+                                tsk_rt(should_schedule)->job_params.job_no,
+                                "LITMUS MC-CE level A timer fired, "
+                                "but the task %d seems to be "
+                                "overrunning its budget\n",
+                                should_schedule->pid);
+        }
+
+        if (ce_data->should_schedule) {
+                tsk_rt(should_schedule)->job_params.deadline =
+                        cycle_start_abs + pid_entry->acc_time;
+                tsk_rt(should_schedule)->job_params.release =
+                        tsk_rt(should_schedule)->job_params.deadline -
+                        pid_entry->budget;
+                tsk_rt(should_schedule)->job_params.exec_time = 0;
+                sched_trace_task_release(should_schedule);
+                set_rt_flags(ce_data->should_schedule, RT_F_RUNNING);
+        }
         if (ce_data->scheduled != ce_data->should_schedule)
                 preempt_if_preemptable(ce_data->scheduled, ce_data->cpu);
 
@@ -378,12 +439,13 @@ static int cancel_all_timers(void)
 {
         struct ce_dom_data *ce_data;
         domain_t *dom;
-        int cpu, ret = 0;
+        int cpu, ret = 0, cancel_res;
 
         for_each_online_cpu(cpu) {
                 dom = &per_cpu(mc_ce_doms, cpu);
                 ce_data = dom->data;
-                ret = ret || hrtimer_cancel(&ce_data->timer);
+                cancel_res = hrtimer_cancel(&ce_data->timer);
+                ret = ret || cancel_res; 
         }
         return ret;
 }
@@ -411,9 +473,9 @@ static void arm_all_timers(void)
 }
 
 /*
- * There are no real releases in the CE, but the task releasing code will
+ * There are no real releases in the CE, but the task releease syscall will
  * call this. We can re-set our notion of the CE period start to make
- * the schedule line up.
+ * the schedule look pretty.
  */
 static void mc_ce_release_at(struct task_struct *ts, lt_t start)
 {
@@ -432,8 +494,6 @@ static long mc_ce_activate_plugin(void)
         domain_t *dom;
         int cpu;
 
-        raw_spin_lock(&activate_lock);
-
         for_each_online_cpu(cpu) {
                 dom = &per_cpu(mc_ce_doms, cpu);
                 ce_data = dom->data;
@@ -444,7 +504,6 @@ static long mc_ce_activate_plugin(void)
         atomic_set(&start_time_set, 0);
         atomic64_set(&start_time, litmus_clock());
         arm_all_timers();
-        raw_spin_unlock(&activate_lock);
         return 0;
 }
 
@@ -465,13 +524,12 @@ static void clear_pid_entries(void)
                                 put_pid(ce_data->pid_entries[entry].pid);
                                 ce_data->pid_entries[entry].pid = NULL;
                         }
-                        ce_data->pid_entries[entry].exec_cost = 0;
+                        ce_data->pid_entries[entry].budget = 0;
                         ce_data->pid_entries[entry].acc_time = 0;
                 }
         }
 }
 
-static void tear_down_proc(void);
 static long mc_ce_deactivate_plugin(void)
 {
         domain_t *dom;
@@ -485,8 +543,6 @@ static long mc_ce_deactivate_plugin(void)
                 atomic_set(&ce_data->timer_info.state,
                                 HRTIMER_START_ON_INACTIVE);
         }
-        clear_pid_entries();
-        tear_down_proc();
         return 0;
 }
 
@@ -515,7 +571,6 @@ static int __init init_sched_mc_ce(void)
         rt_domain_t *rt;
         int cpu, err;
 
-        clear_pid_entries();
         for_each_online_cpu(cpu) {
                 dom = &per_cpu(mc_ce_doms, cpu);
                 rt = &per_cpu(mc_ce_rts, cpu);
@@ -527,6 +582,7 @@ static int __init init_sched_mc_ce(void)
                 ce_data->cpu = cpu;
                 ce_data->timer.function = timer_callback;
         }
+        clear_pid_entries();
         err = setup_proc();
         if (!err)
                 err = register_sched_plugin(&mc_ce_plugin);
@@ -540,15 +596,18 @@ static int write_into_proc(char *proc_buf, const int proc_size, char *fmt, ...)
         int n;
         va_list args;
 
+        /* When writing to procfs, we don't care about the trailing null that
+         * is not included in the count returned by vscnprintf.
+         */
         va_start(args, fmt);
-        n = vscnprintf(buf, BUF_SIZE, fmt, args);
+        n = vsnprintf(buf, BUF_SIZE, fmt, args);
         va_end(args);
-        if (BUF_SIZE <= n || proc_size <= n - 1) {
+        if (BUF_SIZE <= n || proc_size <= n) {
                 /* too big for formatting buffer or proc (less null byte) */
                 n = -EINVAL;
                 goto out;
         }
-        memcpy(proc_buf, buf, n - 1);
+        memcpy(proc_buf, buf, n);
 out:
         return n;
 }
@@ -556,6 +615,9 @@ out:
 
 /*
  * Writes a PID entry to the procfs.
+ *
+ * @page buffer to write into.
+ * @count bytes available in the buffer
  */
 #define PID_SPACE 15
 #define TASK_INFO_BUF (PID_SPACE + TASK_COMM_LEN)
@@ -582,28 +644,28 @@ static int write_pid_entry(char *page, const int count, const int cpu,
                         *ti_b = ' '; /* nuke the null byte */
                         ti_b++;
                         get_task_comm(ti_b, ts);
-                        task_info[TASK_INFO_BUF - 1] = '\0';
                 } else {
-                        const char *msg = "pid_task() failed :(";
-                        strncpy(task_info, msg, sizeof(msg));
+                        strncpy(task_info, "pid_task() failed :(",
+                                        TASK_INFO_BUF);
                 }
 
         } else
-                strncpy(task_info, "no", 3);
+                strncpy(task_info, "no", TASK_INFO_BUF);
+        task_info[TASK_INFO_BUF - 1] = '\0'; /* just to be sure */
 
-        err = write_into_proc(page, count - n, "# task: %s\n", task_info);
+        err = write_into_proc(page + n, count - n, "# task: %s\n", task_info);
         if (err < 0) {
                 n = -ENOSPC;
                 goto out;
         }
         n += err;
-        err = write_into_proc(page, count - n, "%d, %d, %llu\n",
-                        cpu, task, pid_entry->exec_cost);
+        err = write_into_proc(page + n, count - n, "%d, %d, %llu\n",
+                        cpu, task, pid_entry->budget);
         if (err < 0) {
                 n = -ENOSPC;
                 goto out;
         }
-        n =+ err;
+        n += err;
 out:
         return n;
 }
@@ -621,15 +683,15 @@ static int proc_read_ce_file(char *page, char **start, off_t off, int count,
         domain_t *dom;
 
         if (off > 0) {
-                *eof = 1;
-                return 0;
+                printk(KERN_INFO "litmus: MC-CE called read with off > 0\n");
+                goto out;
         }
 
         for_each_online_cpu(cpu) {
                 dom = &per_cpu(mc_ce_doms, cpu);
                 ce_data = dom->data;
                 for (t = 0; t < ce_data->num_pid_entries; ++t) {
-                        err = write_pid_entry(page, count - n,
+                        err = write_pid_entry(page + n, count - n,
                                         cpu, t, &ce_data->pid_entries[t]);
                         if (err < 0) {
                                 n = -ENOSPC;
@@ -638,8 +700,8 @@ static int proc_read_ce_file(char *page, char **start, off_t off, int count,
                         n += err;
                 }
         }
-        *eof = 1;
 out:
+        *eof = 1;
         return n;
 }
 
@@ -663,8 +725,8 @@ static int skip_comment(const char *buf, const unsigned long max)
         return i;
 }
 
-/* a budget of 1 millisecond is probably reasonable */
-#define BUDGET_THRESHOLD 1000000ULL
+/* a budget of 5 milliseconds is probably reasonable */
+#define BUDGET_THRESHOLD 5000000ULL
 static int setup_pid_entry(const int cpu, const int task, const lt_t budget)
 {
         domain_t *dom = &per_cpu(mc_ce_doms, cpu);
@@ -673,9 +735,10 @@ static int setup_pid_entry(const int cpu, const int task, const lt_t budget)
         int err = 0;
 
         /* check the inputs */
-        if (cpu < 0 || cpu >= NR_CPUS || task < 1 || task > PID_MAX_DEFAULT ||
+        if (cpu < 0 || NR_CPUS <= cpu || task < 0 ||
+                        CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS <= task ||
                         budget < 1) {
-                printk(KERN_INFO "litmus: bad cpu or task ID sent to "
+                printk(KERN_INFO "litmus: bad cpu, task ID, or budget sent to "
                                 "MC-CE proc\n");
                 err = -EINVAL;
                 goto out;
@@ -695,7 +758,7 @@ static int setup_pid_entry(const int cpu, const int task, const lt_t budget)
         /* add the new entry */
         new_entry = &ce_data->pid_entries[ce_data->num_pid_entries];
         BUG_ON(NULL != new_entry->pid);
-        new_entry->exec_cost = budget;
+        new_entry->budget = budget;
         new_entry->acc_time = ce_data->cycle_time + budget;
         /* update the domain entry */
         ce_data->cycle_time += budget;
@@ -720,8 +783,6 @@ static int proc_write_ce_file(struct file *file, const char __user *buffer,
         int cpu, task, cnt = 0, chars_read, converted, err;
         lt_t budget;
 
-        raw_spin_lock(&activate_lock);
-
         if (is_active_plugin()) {
                 printk(KERN_INFO "litmus: can't edit MC-CE proc when plugin "
                                 "active\n");
@@ -730,11 +791,15 @@ static int proc_write_ce_file(struct file *file, const char __user *buffer,
         }
 
         if (count > PROCFS_MAX_SIZE) {
+                printk(KERN_INFO "litmus: MC-CE procfs got too many bytes "
+                                "from user-space.\n");
                 cnt = -EINVAL;
                 goto out;
         }
 
         if (copy_from_user(kbuf, buffer, count)) {
+                printk(KERN_INFO "litmus: couldn't copy from user %s\n",
+                                __FUNCTION__);
                 cnt = -EFAULT;
                 goto out;
         }
@@ -753,9 +818,11 @@ static int proc_write_ce_file(struct file *file, const char __user *buffer,
                         c += chars_read;
                         continue;
                 }
-                chars_read = sscanf(c, "%d, %d, %llu%n", &cpu, &task, &budget,
-                                &converted);
+                converted = sscanf(c, "%d, %d, %llu%n", &cpu, &task, &budget,
+                                &chars_read);
                 if (3 != converted) {
+                        printk(KERN_INFO "litmus: MC-CE procfs expected three "
+                                        "arguments, but got %d.\n", converted);
                         cnt = -EINVAL;
                         goto out;
                 }
@@ -768,7 +835,6 @@ static int proc_write_ce_file(struct file *file, const char __user *buffer,
                 }
         }
 out:
-        raw_spin_unlock(&activate_lock);
         return cnt;
 }
 #undef PROCFS_MAX_SIZE
@@ -806,4 +872,10 @@ out:
 }
 #undef CE_FILE_PROC_NAME
 
+static void clean_sched_mc_ce(void)
+{
+        tear_down_proc();
+}
+
 module_init(init_sched_mc_ce);
+module_exit(clean_sched_mc_ce);