Merge branch 'gh/staging' into temp

Conflicts:
	include/litmus/litmus.h
	include/litmus/rt_param.h
	litmus/Makefile
	litmus/sched_cedf.c
	litmus/sched_gsn_edf.c

13 files changed, 186 insertions, 50 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 17d30326034c..70b421d59d34 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -61,6 +61,7 @@ void litmus_exit_task(struct task_struct *tsk);
 #define get_partition(t)        (tsk_rt(t)->task_params.cpu)
 #define get_priority(t)         (tsk_rt(t)->task_params.priority)
 #define get_class(t)        (tsk_rt(t)->task_params.cls)
+#define get_release_policy(t) (tsk_rt(t)->task_params.release_policy)
 
 /* job_param macros */
 #define get_exec_time(t)    (tsk_rt(t)->job_params.exec_time)
@@ -72,6 +73,15 @@ void litmus_exit_task(struct task_struct *tsk);
 #define effective_priority(t) ((!(tsk_rt(t)->inh_task)) ? t : tsk_rt(t)->inh_task)
 #define base_priority(t) (t)
 
+/* release policy macros */
+#define is_periodic(t)          (get_release_policy(t) == PERIODIC)
+#define is_sporadic(t)          (get_release_policy(t) == SPORADIC)
+#ifdef CONFIG_ALLOW_EARLY_RELEASE
+#define is_early_releasing(t)   (get_release_policy(t) == EARLY)
+#else
+#define is_early_releasing(t)   (0)
+#endif
+
 #define is_hrt(t)               \
         (tsk_rt(t)->task_params.cls == RT_CLASS_HARD)
 #define is_srt(t)               \
@@ -85,19 +95,6 @@ static inline lt_t litmus_clock(void)
         return ktime_to_ns(ktime_get());
 }
 
-static inline int is_persistent(struct task_struct* t)
-{
-        int is_per = ( 0
-                #ifdef CONFIG_REALTIME_AUX_TASKS
-                        || t->rt_param.is_aux_task
-                #endif
-                #ifdef CONFIG_LITMUS_SOFTIRQD
-                        || t->rt_param.is_interrupt_thread
-                #endif
-                        );
-        return is_per;
-}
-
 /* A macro to convert from nanoseconds to ktime_t. */
 #define ns_to_ktime(t)          ktime_add_ns(ktime_set(0, 0), t)
 
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index d9b0fa329b67..bf0ee8dbae6e 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -41,6 +41,24 @@ typedef enum {
         PRECISE_SIGNALS,        /* budget signals are triggered with hrtimers */
 } budget_signal_policy_t;
 
+/* Release behaviors for jobs. PERIODIC and EARLY jobs
+   must end by calling sys_complete_job() (or equivalent)
+   to set up their next release and deadline. */
+typedef enum {
+        /* Jobs are released sporadically (provided job precedence
+           constraints are met). */
+        SPORADIC,
+
+        /* Jobs are released periodically (provided job precedence
+           constraints are met). */
+        PERIODIC,
+
+    /* Jobs are released immediately after meeting precedence
+           constraints. Beware this can peg your CPUs if used in
+           the wrong applications. Only supported by EDF schedulers. */
+        EARLY
+} release_policy_t;
+
 typedef enum {
         AUX_ENABLE      = 0x1,
         AUX_CURRENT = (AUX_ENABLE<<1),
@@ -115,6 +133,7 @@ struct rt_task {
         task_class_t    cls;
         budget_policy_t budget_policy; /* ignored by pfair */
         budget_signal_policy_t budget_signal_policy; /* currently ignored by pfair */
+        release_policy_t release_policy;
 };
 
 union np_flag {
diff --git a/litmus/Kconfig b/litmus/Kconfig
index 9e8ef804b499..437ce82f97e9 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -180,6 +180,27 @@ config SCHED_CPU_AFFINITY
 
           Say Yes if unsure.
 
+config ALLOW_EARLY_RELEASE
+        bool "Allow Early Releasing"
+        default y
+        help
+          Allow tasks to release jobs early (while still maintaining job
+          precedence constraints). Only supported by EDF schedulers. Early
+          releasing must be explicitly requested by real-time tasks via
+          the task_params passed to sys_set_task_rt_param().
+
+          Early releasing can improve job response times while maintaining
+          real-time correctness. However, it can easily peg your CPUs
+          since tasks never suspend to wait for their next job. As such, early
+          releasing is really only useful in the context of implementing
+          bandwidth servers, interrupt handling threads, or short-lived
+          computations.
+
+          Beware that early releasing may affect real-time analysis
+          if using locking protocols or I/O.
+
+          Say Yes if unsure.
+
 choice
         prompt "EDF Tie-Break Behavior"
         default EDF_TIE_BREAK_LATENESS_NORM
diff --git a/litmus/Makefile b/litmus/Makefile
index 6b7acf0bbf2c..642a03617d4a 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -18,7 +18,8 @@ obj-y     = sched_plugin.o litmus.o \
             bheap.o \
             binheap.o \
             ctrldev.o \
-                aux_tasks.o \
+            aux_tasks.o \
+            uncachedev.o \
             sched_gsn_edf.o \
             sched_psn_edf.o \
             sched_pfp.o
diff --git a/litmus/aux_tasks.c b/litmus/aux_tasks.c
index a9fa9df5ef8b..db6523a3dcf7 100644
--- a/litmus/aux_tasks.c
+++ b/litmus/aux_tasks.c
@@ -27,14 +27,17 @@ static int admit_aux_task(struct task_struct *t)
          * fail-safe.
          */
         struct rt_task tp = {
+                .exec_cost = AUX_SLICE_NS,
                 .period = AUX_SLICE_NS,
                 .relative_deadline = AUX_SLICE_NS,
-                .exec_cost = AUX_SLICE_NS, /* allow full utilization with buget tracking */
                 .phase = 0,
                 .cpu = task_cpu(leader),  /* take CPU of group leader */
+                .priority = LITMUS_LOWEST_PRIORITY,
+                .cls = RT_CLASS_BEST_EFFORT,
                 .budget_policy = QUANTUM_ENFORCEMENT,
                 .budget_signal_policy = NO_SIGNALS,
-                .cls = RT_CLASS_BEST_EFFORT
+                /* use SPORADIC instead of EARLY since util = 1.0 */
+                .release_policy = SPORADIC,
         };
 
         struct sched_param param = { .sched_priority = 0};
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 659625433867..991c6e60be74 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -8,14 +8,6 @@
 
 static inline void setup_release(struct task_struct *t, lt_t release)
 {
-        /* Shift all tasks that are actually daemons that inherit
-         * priority to be released immediatly. They need to be ready to run
-         * at _all_ times.
-         */
-        if (unlikely(is_persistent(t))) {
-                release = litmus_clock();
-        }
-
         /* prepare next release */
         t->rt_param.job_params.release = release;
         t->rt_param.job_params.deadline = release + get_rt_relative_deadline(t);
diff --git a/litmus/litmus_softirq.c b/litmus/litmus_softirq.c
index aa83b363be7c..6ecea650673b 100644
--- a/litmus/litmus_softirq.c
+++ b/litmus/litmus_softirq.c
@@ -263,14 +263,17 @@ static int become_litmus_daemon(struct task_struct* tsk)
     int ret = 0;
 
         struct rt_task tp = {
+                .exec_cost = KLMIRQD_SLICE_NS,
                 .period = KLMIRQD_SLICE_NS,
                 .relative_deadline = KLMIRQD_SLICE_NS,
-                .exec_cost = KLMIRQD_SLICE_NS,
                 .phase = 0,
                 .cpu = task_cpu(current),
+                .priority = LITMUS_LOWEST_PRIORITY,
+                .cls = RT_CLASS_BEST_EFFORT,
                 .budget_policy = NO_ENFORCEMENT,
                 .budget_signal_policy = NO_SIGNALS,
-                .cls = RT_CLASS_BEST_EFFORT
+                /* use SPORADIC instead of EARLY since util = 1.0 */
+                .release_policy = SPORADIC,
         };
 
         struct sched_param param = { .sched_priority = 0};
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index efb11bb8c656..78ae5a080138 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -315,7 +315,7 @@ static noinline void requeue(struct task_struct* task)
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
-        if (is_released(task, litmus_clock()))
+        if (is_early_releasing(task) || is_released(task, litmus_clock())) {
 #ifdef CONFIG_REALTIME_AUX_TASKS
                 if (unlikely(tsk_rt(task)->is_aux_task && task->state != TASK_RUNNING && !tsk_rt(task)->aux_ready)) {
                         /* aux_task probably transitioned to real-time while it was blocked */
@@ -325,6 +325,7 @@ static noinline void requeue(struct task_struct* task)
                 else
 #endif
                         __add_ready(&cluster->domain, task);
+        }
         else {
                 TRACE_TASK(task, "not requeueing non-yet-released job\n");
         }
@@ -411,24 +412,22 @@ static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 /* caller holds cluster_lock */
 static noinline void job_completion(struct task_struct *t, int forced)
 {
+        int do_release = 0;
         lt_t now;
         BUG_ON(!t);
 
         sched_trace_task_completion(t, forced);
 
-        TRACE_TASK(t, "job_completion() at %llu.\n", litmus_clock());
-
-#ifdef CONFIG_LITMUS_LOCKING
-        BUG_ON(!is_persistent(t) && tsk_rt(t)->inh_task);
-#endif
+        now = litmus_clock();
+        TRACE_TASK(t, "job_completion() at %llu.\n", now);
 
         /* set flags */
         tsk_rt(t)->completed = 1;
         /* prepare for next period */
         prepare_for_next_period(t);
 
-        now = litmus_clock();
-        if (is_released(t, now)) {
+        do_release = (is_early_releasing(t) || is_released(t, now));
+        if (do_release) {
                 /* log here to capture overheads */
                 sched_trace_task_release(t);
         }
@@ -438,7 +437,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         /* release or arm next job */
         tsk_rt(t)->completed = 0;
         if (is_running(t)) {
-                if (!is_released(t, now))
+                if (!do_release)
                         add_release(&task_cpu_cluster(t)->domain, t);
                 else
                         cedf_job_arrival(t);
@@ -1027,17 +1026,16 @@ static void cedf_task_wake_up(struct task_struct *task)
 {
         unsigned long flags;
         cedf_domain_t *cluster;
-        lt_t now = litmus_clock();
-
-        TRACE_TASK(task, "wake_up at %llu\n", now);
+        lt_t now;
 
         cluster = task_cpu_cluster(task);
 
         raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
 
-        if (unlikely(is_persistent(task) && is_tardy(task, now))) {
-                /* treat tardy perisistent tasks as if they were sporadic
-                   tasks by releasing a new job if they're tardy. */
+        now = litmus_clock();
+        TRACE_TASK(task, "wake_up at %llu\n", now);
+
+        if (is_sporadic(task) && is_tardy(task, now)) {
                 release_at(task, now);
                 sched_trace_task_release(task);
         }
@@ -1150,7 +1148,8 @@ static long cedf_admit_task(struct task_struct* tsk)
                                                 edf_max_heap_base_priority_order);
 #endif
 
-        return (task_cpu(tsk) == tsk->rt_param.task_params.cpu) ? 0 : -EINVAL;
+        return (remote_cluster(task_cpu(tsk)) == task_cpu_cluster(tsk)) ?
+                                0 : -EINVAL;
 }
 
 
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 46a10fa17044..08cdf5c0e492 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -308,7 +308,7 @@ static noinline void requeue(struct task_struct* task)
         /* sanity check before insertion */
         BUG_ON(is_queued(task));
 
-        if (is_released(task, litmus_clock())) {
+        if (is_early_releasing(task) || is_released(task, litmus_clock())) {
 #ifdef CONFIG_REALTIME_AUX_TASKS
                 if (unlikely(tsk_rt(task)->is_aux_task && !is_running(task))) {
                         /* aux_task probably transitioned to real-time while it was blocked */
@@ -411,8 +411,7 @@ static noinline void job_completion(struct task_struct *t, int forced)
         tsk_rt(t)->completed = 1;
         /* prepare for next period */
         prepare_for_next_period(t);
-
-        if (is_released(t, litmus_clock()))
+        if (is_early_releasing(t) || is_released(t, litmus_clock()))
                 sched_trace_task_release(t);
         /* unlink */
         unlink(t);
@@ -1008,7 +1007,7 @@ static void gsnedf_task_wake_up(struct task_struct *task)
 #if 0
         /* sporadic task model. will increment job numbers automatically */
         now = litmus_clock();
-        if (is_tardy(task, now)) {
+        if (is_sporadic(task) && is_tardy(task, now)) {
                 /* new sporadic release */
                 release_at(task, now);
                 sched_trace_task_release(task);
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index 6a89b003306c..d5fb3a832adc 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -710,7 +710,7 @@ static void pfair_task_wake_up(struct task_struct *t)
          */
         requeue = tsk_rt(t)->flags == RT_F_REQUEUE;
         now = litmus_clock();
-        if (lt_before(get_deadline(t), now)) {
+        if (is_tardy(t, now)) {
                 TRACE_TASK(t, "sporadic release!\n");
                 release_at(t, now);
                 prepare_release(t, time2quanta(now, CEIL));
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index 56d5a61c25e4..6edec830f063 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -359,7 +359,7 @@ static void pfp_task_wake_up(struct task_struct *task)
         BUG_ON(is_queued(task));
 #endif
         now = litmus_clock();
-        if (is_tardy(task, now)
+        if (is_sporadic(task) && is_tardy(task, now)
 #ifdef CONFIG_LITMUS_LOCKING
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index fabff1be9bba..d1177cab152d 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -61,7 +61,7 @@ static void requeue(struct task_struct* t, rt_domain_t *edf)
                 TRACE_TASK(t, "requeue: !TASK_RUNNING\n");
 
         tsk_rt(t)->completed = 0;
-        if (is_released(t, litmus_clock()))
+        if (is_early_releasing(t) || is_released(t, litmus_clock()))
                 __add_ready(edf, t);
         else
                 add_release(edf, t); /* it has got to wait */
@@ -335,7 +335,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         raw_spin_lock_irqsave(&pedf->slock, flags);
         BUG_ON(is_queued(task));
         now = litmus_clock();
-        if (is_tardy(task, now)
+        if (is_sporadic(task) && is_tardy(task, now)
 #ifdef CONFIG_LITMUS_LOCKING
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
diff --git a/litmus/uncachedev.c b/litmus/uncachedev.c
new file mode 100644
index 000000000000..06a6a7c17983
--- /dev/null
+++ b/litmus/uncachedev.c
@@ -0,0 +1,102 @@
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/errno.h>
+#include <linux/highmem.h>
+#include <asm/page.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+
+#include <litmus/litmus.h>
+
+/* device for allocating pages not cached by the CPU */
+
+#define UNCACHE_NAME        "litmus/uncache"
+
+void litmus_uncache_vm_open(struct vm_area_struct *vma)
+{
+}
+
+void litmus_uncache_vm_close(struct vm_area_struct *vma)
+{
+}
+
+int litmus_uncache_vm_fault(struct vm_area_struct* vma,
+                                                        struct vm_fault* vmf)
+{
+        /* modeled after SG DMA video4linux, but without DMA. */
+        /* (see drivers/media/video/videobuf-dma-sg.c) */
+        struct page *page;
+
+        page = alloc_page(GFP_USER);
+        if (!page)
+                return VM_FAULT_OOM;
+
+        clear_user_highpage(page, (unsigned long)vmf->virtual_address);
+        vmf->page = page;
+
+        return 0;
+}
+
+static struct vm_operations_struct litmus_uncache_vm_ops = {
+        .open = litmus_uncache_vm_open,
+        .close = litmus_uncache_vm_close,
+        .fault = litmus_uncache_vm_fault,
+};
+
+static int litmus_uncache_mmap(struct file* filp, struct vm_area_struct* vma)
+{
+        /* first make sure mapper knows what he's doing */
+
+        /* you can only map the "first" page */
+        if (vma->vm_pgoff != 0)
+                return -EINVAL;
+
+        /* you can't share it with anyone */
+        if (vma->vm_flags & (VM_MAYSHARE | VM_SHARED))
+                return -EINVAL;
+
+        /* cannot be expanded, and is not a "normal" page. */
+        vma->vm_flags |= VM_DONTEXPAND;
+
+        /* noncached pages are not explicitly locked in memory (for now). */
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+        vma->vm_ops = &litmus_uncache_vm_ops;
+
+        return 0;
+}
+
+static struct file_operations litmus_uncache_fops = {
+        .owner = THIS_MODULE,
+        .mmap  = litmus_uncache_mmap,
+};
+
+static struct miscdevice litmus_uncache_dev = {
+        .name  = UNCACHE_NAME,
+        .minor = MISC_DYNAMIC_MINOR,
+        .fops  = &litmus_uncache_fops,
+        /* pages are not locked, so there is no reason why
+           anyone cannot allocate an uncache pages */
+        .mode  = (S_IRUGO | S_IWUGO),
+};
+
+static int __init init_litmus_uncache_dev(void)
+{
+        int err;
+
+        printk("Initializing LITMUS^RT uncache device.\n");
+        err = misc_register(&litmus_uncache_dev);
+        if (err)
+                printk("Could not allocate %s device (%d).\n", UNCACHE_NAME, err);
+        return err;
+}
+
+static void __exit exit_litmus_uncache_dev(void)
+{
+        misc_deregister(&litmus_uncache_dev);
+}
+
+module_init(init_litmus_uncache_dev);
+module_exit(exit_litmus_uncache_dev);