Tasks specify colors and pages when allocating pages

4 files changed, 85 insertions, 63 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index 1b9b75aa38c9..d490cedbd7bb 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -22,6 +22,7 @@ obj-y     = sched_plugin.o litmus.o \
             rt_server.o \
             dgl.o \
             fifo_common.o \
+            rm_common.o \
             sched_psn_edf.o \
             sched_gsn_edf.o
 
diff --git a/litmus/color_dev.c b/litmus/color_dev.c
index 7ccdaf03740b..d8480d7fd543 100644
--- a/litmus/color_dev.c
+++ b/litmus/color_dev.c
@@ -152,53 +152,65 @@ out:
 static int do_map_colored_pages(struct vm_area_struct *vma)
 {
         const unsigned long nr_pages = vma_nr_pages(vma);
+        struct color_ctrl_page *color_ctrl = tsk_rt(current)->color_ctrl_page;
         unsigned long nr_mapped;
-        color_t *cur_color;
-        int err;
+        int i, err = 0;
 
         TRACE_CUR(ALLOC_NAME ": allocating %lu pages (flags:%lx prot:%lx)\n",
                         nr_pages, vma->vm_flags, pgprot_val(vma->vm_page_prot));
 
-        for (   nr_mapped = 0,
-                cur_color = tsk_rt(current)->color_ctrl_page->colors;
-                nr_mapped < nr_pages;
-                nr_mapped++, cur_color++)
-        {
-                const unsigned long this_color = *cur_color;
-                const unsigned long addr = vma->vm_start + (nr_mapped << PAGE_SHIFT);
-                struct page *page = get_colored_page(this_color);
-
-                if (!page) {
-                        TRACE_CUR(ALLOC_NAME ": Could not get page with "
-                                        " color %lu.\n", this_color);
-                        /* TODO unmap mapped pages */
-                        err = -ENOMEM;
-                        break;
-                }
+        for (i = 0, nr_mapped = 0; nr_mapped < nr_pages; ++i) {
+                const unsigned long color_no = color_ctrl->colors[i];
+                unsigned int page_no = 0;
+
+                for (; page_no < color_ctrl->pages[i]; ++page_no, ++nr_mapped) {
+                        const unsigned long addr = vma->vm_start +
+                                (nr_mapped << PAGE_SHIFT);
+                        struct page *page = get_colored_page(color_no);
+
+                        if (!page) {
+                                TRACE_CUR(ALLOC_NAME ": Could not get page with"
+                                          " color %lu.\n", color_no);
+                                /* TODO unmap mapped pages */
+                                err = -ENOMEM;
+                                goto out;
+                        }
+
 #ifdef CONFIG_SPARC
-                clear_user_highpage(page, addr);
+                        clear_user_highpage(page, addr);
 #endif
-                TRACE_CUR(ALLOC_NAME ": insert page (pa:0x%10llx, pfn:%8lu, "
-                                "color:%3lu) at 0x%lx (flags:%16lx prot:%16lx) "
-                                "PAGE_SHARED:0x%16lx\n",
-                                page_to_phys(page),
-                                page_to_pfn(page), this_color, addr,
-                                vma->vm_flags, pgprot_val(vma->vm_page_prot),
-                                PAGE_SHARED);
-                //err = vm_insert_page(vma, addr, page);
-                err = remap_pfn_range(vma, addr, page_to_pfn(page),
-                                PAGE_SIZE, PAGE_SHARED);
-                if (err) {
-                        TRACE_CUR(ALLOC_NAME ": remap_pfn_range() failed "
-                                        "(%d) (flags:%lx prot:%lx)\n", err,
-                                        vma->vm_flags,
-                                        pgprot_val(vma->vm_page_prot));
-                        /* TODO unmap mapped pages */
+
+                        TRACE_CUR(ALLOC_NAME ": insert page (pa:0x%10llx, "
+                                  "pfn:%8lu, color:%3lu) at 0x%lx (flags:%16lx "
+                                  "prot:%16lx) PAGE_SHARED:0x%16lx\n",
+                                  page_to_phys(page),
+                                  page_to_pfn(page), color_no, addr,
+                                  vma->vm_flags, pgprot_val(vma->vm_page_prot),
+                                  PAGE_SHARED);
+
+                        err = remap_pfn_range(vma, addr, page_to_pfn(page),
+                                              PAGE_SIZE, PAGE_SHARED);
+
+                        if (err) {
+                                TRACE_CUR(ALLOC_NAME ": remap_pfn_range() fail "
+                                          "(%d) (flags:%lx prot:%lx)\n", err,
+                                          vma->vm_flags,
+                                          pgprot_val(vma->vm_page_prot));
+                                /* TODO unmap mapped pages */
+                                err = -EINVAL;
+                                goto out;
+                        }
+                        add_page_to_alloced_list(page, vma);
+                }
+
+                if (!page_no) {
+                        TRACE_CUR(ALLOC_NAME ": 0 pages given for color %lu\n",
+                                  color_no);
                         err = -EINVAL;
-                        break;
+                        goto out;
                 }
-                add_page_to_alloced_list(page, vma);
         }
+ out:
         return err;
 }
 
diff --git a/litmus/dgl.c b/litmus/dgl.c
index af710e72b5ef..6c1267839123 100644
--- a/litmus/dgl.c
+++ b/litmus/dgl.c
@@ -129,6 +129,8 @@ void set_req(struct dgl *dgl, struct dgl_group_req *greq,
         mask_idx(resource, &word, &bit);
         __set_bit(bit, &greq->requested[word]);
 
+        TRACE("0x%p requesting %d of %d\n", greq, replicas, resource);
+
         req = &greq->requests[resource];
         req->greq = greq;
         INIT_LIST_HEAD(&req->list);
diff --git a/litmus/sched_color.c b/litmus/sched_color.c
index b0a92caeae91..f6115e552cf8 100644
--- a/litmus/sched_color.c
+++ b/litmus/sched_color.c
@@ -9,7 +9,7 @@
 #include <litmus/jobs.h>
 #include <litmus/preempt.h>
 #include <litmus/sched_plugin.h>
-#include <litmus/edf_common.h>
+#include <litmus/rm_common.h>
 #include <litmus/sched_trace.h>
 #include <litmus/color.h>
 #include <litmus/fifo_common.h>
@@ -32,13 +32,13 @@ struct fifo_server {
 
 /**
  * @server        Common server functionality.
- * @edf_domain    PEDF domain.
+ * @rm_domain    PRM domain.
  * @scheduled     Task physically running on CPU.
  * @fifo_server   Server partitioned to this CPU.
  */
 struct cpu_entry {
         struct rt_server        server;
-        rt_domain_t             edf_domain;
+        rt_domain_t             rm_domain;
         struct task_struct*     scheduled;
         struct fifo_server      fifo_server;
 };
@@ -55,10 +55,10 @@ static raw_spinlock_t dgl_lock;
 #define remote_entry(cpu)      (&per_cpu(color_cpus, cpu))
 #define task_entry(task)       remote_entry(get_partition(task))
 #define task_fserver(task)     (&task_entry(task)->fifo_server.server)
-#define entry_lock(entry)      (&entry->edf_domain.ready_lock)
+#define entry_lock(entry)      (&entry->rm_domain.ready_lock)
 
 #define has_resources(t, c)    (tsk_rt(t)->req == group_lock.acquired[c])
-#define task_dom(entry, task)  (is_be(task) ? &fifo_domain : &entry->edf_domain)
+#define task_dom(entry, task)  (is_be(task) ? &fifo_domain : &entry->rm_domain)
 #define task_lock(entry, task) (is_be(task) ? &fifo_lock   : entry_lock(entry))
 
 /*
@@ -283,9 +283,9 @@ static struct task_struct* schedule_server(struct rt_server *server)
 }
 
 /*
- * Dumb requeue for PEDF (CPU) servers.
+ * Dumb requeue for PRM (CPU) servers.
  */
-static void edf_requeue(struct rt_server *server, struct task_struct *t)
+static void rm_requeue(struct rt_server *server, struct task_struct *t)
 {
         BUG_ON(is_be(t));
         requeue(server->domain, t);
@@ -346,7 +346,9 @@ static void fifo_update(struct rt_server *server)
                 }
 
                 /* Calculate next task */
+                raw_spin_lock(&fifo_lock);
                 schedule_server(&fserver->server);
+                raw_spin_unlock(&fifo_lock);
 
                 /* Reserve needed resources */
                 raw_spin_lock(&dgl_lock);
@@ -356,22 +358,22 @@ static void fifo_update(struct rt_server *server)
 }
 
 /*
- * Triggers preemption on edf-scheduled "linked" field only.
+ * Triggers preemption on rm-scheduled "linked" field only.
  */
-static void color_edf_release(rt_domain_t *edf, struct bheap *tasks)
+static void color_rm_release(rt_domain_t *rm, struct bheap *tasks)
 {
         unsigned long flags;
         struct cpu_entry *entry;
 
-        TRACE_TASK(bheap2task(bheap_peek(edf->order, tasks)),
-                   "Released set of EDF tasks\n");
+        TRACE_TASK(bheap2task(bheap_peek(rm->order, tasks)),
+                   "Released set of RM tasks\n");
 
-        entry = container_of(edf, struct cpu_entry, edf_domain);
+        entry = container_of(rm, struct cpu_entry, rm_domain);
         raw_spin_lock_irqsave(entry_lock(entry), flags);
 
-        __merge_ready(edf, tasks);
+        __merge_ready(rm, tasks);
 
-        if (edf_preemption_needed(edf, entry->server.linked) &&
+        if (rm_preemption_needed(rm, entry->server.linked) &&
             (!entry->server.linked || !is_kernel_np(entry->server.linked))) {
                 litmus_reschedule(entry->server.cpu);
         }
@@ -501,10 +503,11 @@ static struct task_struct* color_schedule(struct task_struct *prev)
 static void color_task_new(struct task_struct *t, int on_rq, int running)
 {
         unsigned long flags;
-        int i, replicas;
+        int i;
         raw_spinlock_t *lock;
         struct cpu_entry *entry;
         struct dgl_group_req *req;
+        color_t *colors, *pages;
 
         TRACE_TASK(t, "New colored task\n");
         local_irq_save(flags);
@@ -514,16 +517,18 @@ static void color_task_new(struct task_struct *t, int on_rq, int running)
 
         release_at(t, litmus_clock());
 
-        /* Create request for dynamic group locks */
         req = kmalloc(sizeof(*req), GFP_ATOMIC);
         dgl_group_req_init(&group_lock, req);
-        for (i = 0; i < group_lock.num_resources; i++) {
-                replicas = get_control_page(t)->requests[i];
-                if (replicas)
-                        set_req(&group_lock, req, i, replicas);
-        }
         tsk_rt(t)->req = req;
 
+        /* Fill request */
+        if (tsk_rt(t)->color_ctrl_page) {
+                colors = tsk_rt(t)->color_ctrl_page->colors;
+                pages  = tsk_rt(t)->color_ctrl_page->pages;
+                for (i = 0; pages[i]; i++)
+                        set_req(&group_lock, req, colors[i], pages[i]);
+        }
+
         /* Join system */
         raw_spin_lock(lock);
         if (running) {
@@ -535,7 +540,7 @@ static void color_task_new(struct task_struct *t, int on_rq, int running)
                 requeue(task_dom(entry, t), t);
         raw_spin_unlock(lock);
 
-        /* Trigger preemptions */
+        /* Trigger necessary preemptions */
         if (is_be(t))
                 check_for_fifo_preempt();
         else
@@ -683,8 +688,10 @@ static long color_activate_plugin(void)
                 entry->fifo_server.start_time = 0;
                 entry->scheduled = NULL;
 
+                cancel_enforcement_timer(&entry->fifo_server.timer);
+
                 if (!is_queued(server_task))
-                        requeue(&entry->edf_domain, server_task);
+                        requeue(&entry->rm_domain, server_task);
 
                 TRACE_TASK(server_task, "Created server with wcet: %llu, "
                            "period: %llu\n", tp.exec_cost, tp.period);
@@ -766,7 +773,7 @@ static int __init init_color(void)
 
         for_each_online_cpu(cpu) {
                 entry = remote_entry(cpu);
-                edf_domain_init(&entry->edf_domain, NULL, color_edf_release);
+                rm_domain_init(&entry->rm_domain, NULL, color_rm_release);
 
                 entry->scheduled = NULL;
 
@@ -797,8 +804,8 @@ static int __init init_color(void)
                 /* Create CPU server */
                 cpu_server = &entry->server;
                 init_rt_server(cpu_server, cpu + 1, cpu,
-                               &entry->edf_domain, edf_preemption_needed,
-                               edf_requeue, NULL, NULL);
+                               &entry->rm_domain, rm_preemption_needed,
+                               rm_requeue, NULL, NULL);
                 cpu_server->running = 1;
 
                 init_enforcement_timer(&fifo_server->timer);