Turn color_ctrl_page into a system call.

Conflicts:

	include/litmus/color.h

Signed-off-by: Christopher Kenna <cjk@cs.unc.edu>

14 files changed, 104 insertions, 196 deletions

diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index ed2ae934127..09595644f8f 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -397,6 +397,8 @@
 /* 385 */       CALL(sys_wait_for_ts_release)
                 CALL(sys_release_ts)
                 CALL(sys_null_call)
+                CALL(sys_set_rt_task_mc_param)
+                CALL(sys_set_color_page_info)
 #ifndef syscalls_counted
 .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls
 #define syscalls_counted
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index a40c1597042..21791aa0779 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -359,3 +359,4 @@ ENTRY(sys_call_table)
         .long sys_release_ts            /* +10 */
         .long sys_null_call
         .long sys_set_rt_task_mc_param
+        .long sys_set_color_page_info
diff --git a/include/litmus/color.h b/include/litmus/color.h
index d6d04f082ac..525e5c1c7d1 100644
--- a/include/litmus/color.h
+++ b/include/litmus/color.h
@@ -3,6 +3,7 @@
 
 #ifdef __KERNEL__
 
+#include <asm/page.h>
 #include <litmus/color_queue.h>
 
 #define ONE_COLOR_LEN 11
@@ -41,6 +42,10 @@ struct color_page_info {
         /* changes from job to job */
 };
 
+/* Pre-declare */
+struct ctl_table;
+struct vm_area_struct;
+
 #ifdef CONFIG_CPU_V7
 int litmus_test_prefetch_proc_handler(struct ctl_table *, int,
                 void __user *, size_t *, loff_t *);
@@ -64,9 +69,6 @@ extern int lock_cache;
 
 void litmus_setup_lockdown(void __iomem*, u32);
 
-struct vm_area_struct;
-struct ctl_table;
-
 struct page* get_colored_page(unsigned long);
 void add_page_to_color_list(struct page*);
 void add_page_to_alloced_list(struct page*, struct vm_area_struct*);
diff --git a/include/litmus/color_queue.h b/include/litmus/color_queue.h
index 969095f8ff3..80976c539b1 100644
--- a/include/litmus/color_queue.h
+++ b/include/litmus/color_queue.h
@@ -78,4 +78,6 @@ int setup_flusher_array(void);
 void color_queue_enqueue_read(struct task_struct *ts);
 void color_queue_enqueue_flush(struct task_struct *ts);
 
+void cleanup_color_page_infos(struct list_head *head);
+
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index c13ca2c8ae9..103b03f4e67 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -279,10 +279,7 @@ struct rt_param {
         lt_t tot_exec_time;
         lt_t last_exec_time;
         lt_t orig_cost;
-        struct color_ctrl_page *color_ctrl_page;
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-        void *color_ctrl_page_orig;
-#endif
+        struct color_ctrl_page color_ctrl_page;
         struct dgl_group_req *req;
         enum server_state state;
         struct list_head color_page_info_list;
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index 71be3cd8d46..eab81ab4200 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -18,5 +18,6 @@
 #define __NR_release_ts         __LSC(10)
 #define __NR_null_call          __LSC(11)
 #define __NR_set_rt_task_mc_param __LSC(12)
+#define __NR_set_color_page_info __LSC(13)
 
-#define NR_litmus_syscalls 13
+#define NR_litmus_syscalls 14
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index 95cb7449510..4c1695a5b80 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -31,5 +31,7 @@ __SYSCALL(__NR_release_ts, sys_release_ts)
 __SYSCALL(__NR_null_call, sys_null_call)
 #define __NR_set_rt_task_mc_param               __LSC(12)
 __SYSCALL(__NR_set_rt_task_mc_param, sys_set_rt_task_mc_param)
+#define __NR_set_color_page_info                __LSC(13)
+__SYSCALL(__NR_set_color_page_info, sys_set_color_page_info)
 
-#define NR_litmus_syscalls 13
+#define NR_litmus_syscalls 14
diff --git a/litmus/color.c b/litmus/color.c
index 9888c3f1599..5cbaada233e 100644
--- a/litmus/color.c
+++ b/litmus/color.c
@@ -5,6 +5,7 @@
 #include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/lockdep.h>
+#include <linux/uaccess.h>
 #include <linux/sched.h> /* required by litmus.h */
 #include <asm/io.h> /* page_to_phys on SPARC */
 
@@ -213,6 +214,38 @@ void reclaim_pages(struct vm_area_struct *vma)
         TRACE_CUR("Reclaimed %lu pages.\n", nr_reclaimed);
 }
 
+asmlinkage long sys_set_color_page_info(struct color_ctrl_page __user *user_color_ctrl)
+{
+        struct color_ctrl_page *color_page = &tsk_rt(current)->color_ctrl_page;
+        color_t color_val, page_val;
+        long err = 0;
+        int i;
+
+        BUILD_BUG_ON(PAGE_SIZE < sizeof(struct color_ctrl_page));
+
+        if (0 == user_color_ctrl) {
+                err = -EINVAL;
+                TRACE_CUR("User color ctrl page was null.\n");
+                goto out;
+        }
+
+        if (copy_from_user(color_page, user_color_ctrl, sizeof(*color_page)))
+        {
+                err = -EINVAL;
+                TRACE_CUR("Couln't copy color control page from user space.\n");
+                goto out;
+        }
+
+        TRACE_CUR("Printing first ten values (for checking):\n");
+        for (i = 0; i < 10; i++) {
+                color_val = color_page->colors[i];
+                page_val = color_page->pages[i];
+                TRACE_CUR("for i:%d  color:%hu  page:%hu\n", i, color_val, page_val);
+        }
+out:
+        return err;
+}
+
 /***********************************************************
  * Proc
 ***********************************************************/
diff --git a/litmus/color_dev.c b/litmus/color_dev.c
index 0efaa7f2b62..96e0edc54b2 100644
--- a/litmus/color_dev.c
+++ b/litmus/color_dev.c
@@ -15,7 +15,6 @@
 #include <litmus/color_queue.h>
 
 #define ALLOC_NAME      "litmus/color_alloc"
-#define CTRL_NAME       "litmus/color_ctrl"
 
 extern unsigned long nr_colors;
 
@@ -53,137 +52,6 @@ static void mmap_common_vma_flags(struct vm_area_struct *vma)
 }
 
 /***********************************************************
- * Control device
-***********************************************************/
-
-static void litmus_color_ctrl_vm_close(struct vm_area_struct *vma)
-{
-        TRACE_CUR("flags=0x%lx prot=0x%lx\n",
-                        vma->vm_flags, pgprot_val(vma->vm_page_prot));
-
-        TRACE_CUR("%p:%p vma:%p vma->vm_private_data:%p closed.\n",
-                        (void*) vma->vm_start, (void*) vma->vm_end, vma,
-                        vma->vm_private_data);
-}
-
-static int litmus_color_ctrl_vm_fault(struct vm_area_struct *vma,
-                struct vm_fault *vmf)
-{
-        /* This function should never be called, since
-         * all pages should have been mapped by mmap()
-         * already. */
-        TRACE_CUR("flags=0x%lx (off:%ld)\n", vma->vm_flags, vmf->pgoff);
-
-        WARN(1, "Page fault in color ctrl page! flags=0x%lx\n", vma->vm_flags);
-
-        return VM_FAULT_SIGBUS;
-}
-
-static struct vm_operations_struct litmus_color_ctrl_vm_ops = {
-        .close  = litmus_color_ctrl_vm_close,
-        .fault  = litmus_color_ctrl_vm_fault,
-};
-
-static int alloc_color_ctrl_page(void)
-{
-        void *mem;
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-        void *mem_remap;
-#endif
-        struct task_struct *t = current;
-        int err = 0;
-
-        /* only allocate if the task doesn't have one yet */
-        if (!tsk_rt(t)->color_ctrl_page) {
-                mem = (void*) get_zeroed_page(GFP_KERNEL);
-                if (!mem) {
-                        TRACE_TASK(t, "cannot allocate color control page\n");
-                        err = -ENOMEM;
-                        goto out;
-                }
-
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-                mem_remap = remap_noncached(mem, PAGE_SIZE);
-                if (IS_ERR(mem_remap)) {
-                        err = PTR_ERR(mem_remap);
-                        free_page((unsigned long) mem);
-                        goto out;
-                }
-                tsk_rt(t)->color_ctrl_page_orig = mem;
-                tsk_rt(t)->color_ctrl_page = mem_remap;
-#else
-                tsk_rt(t)->color_ctrl_page = mem;
-#endif
-
-                /* will get de-allocated in task teardown */
-                TRACE_TASK(t, "color_ctrl_page = %p\n",
-                           tsk_rt(t)->color_ctrl_page);
-        }
-out:
-        return err;
-}
-
-static int map_color_ctrl_page(struct vm_area_struct *vma)
-{
-        int err = 0;
-        struct task_struct *t = current;
-        struct page *color_ctrl;
-
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-        /* vm_insert_page() using the "real" vaddr, not the shadow mapping. */
-        color_ctrl = virt_to_page(tsk_rt(t)->color_ctrl_page_orig);
-#else
-        color_ctrl = virt_to_page(tsk_rt(t)->color_ctrl_page);
-#endif
-
-        TRACE_CUR("mapping %p (pfn:%lx) to 0x%lx (flags:%lx prot:%lx)\n",
-                  tsk_rt(t)->color_ctrl_page, page_to_pfn(color_ctrl),
-                  vma->vm_start, vma->vm_flags, pgprot_val(vma->vm_page_prot));
-
-        /* Map it into the vma. */
-        err = vm_insert_page(vma, vma->vm_start, color_ctrl);
-        if (err)
-                TRACE_CUR("vm_insert_page() failed (%d)\n", err);
-
-        return err;
-}
-
-static int litmus_color_ctrl_mmap(struct file *filp, struct vm_area_struct *vma)
-{
-        int err = 0;
-
-        /* you can only get one page */
-        if (vma->vm_end - vma->vm_start != PAGE_SIZE) {
-                TRACE_CUR("must allocate a multiple of PAGE_SIZE\n");
-                err = -EINVAL;
-                goto out;
-        }
-
-        err = mmap_common_checks(vma);
-        if (err) {
-                TRACE_CUR("failed common mmap checks.\n");
-                goto out;
-        }
-
-        vma->vm_ops = &litmus_color_ctrl_vm_ops;
-        mmap_common_vma_flags(vma);
-
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-#endif
-
-        err = alloc_color_ctrl_page();
-        if (!err)
-                err = map_color_ctrl_page(vma);
-
-        TRACE_CUR("flags=0x%lx prot=0x%lx\n", vma->vm_flags,
-                        pgprot_val(vma->vm_page_prot));
-out:
-        return err;
-}
-
-
-/***********************************************************
  * Allocation device
 ***********************************************************/
 
@@ -218,7 +86,15 @@ static int create_color_page_info(int color, struct page *page)
                 req->request_type = COLOR_QUEUE_IDLE;
         }
 
+        if (NULL == tsk_rt(current)->color_page_info_list.next ||
+                        NULL == tsk_rt(current)->color_page_info_list.prev) {
+                INIT_LIST_HEAD(&tsk_rt(current)->color_page_info_list);
+                TRACE_CUR("Initialized the color_page_info_list\n");
+        }
+
         list_add_tail(&info->list, &tsk_rt(current)->color_page_info_list);
+        TRACE_CUR("Added color_page_info %p to list.\n", info);
+
 out:
         return err;
 }
@@ -278,7 +154,7 @@ 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;
+        struct color_ctrl_page *color_ctrl = &tsk_rt(current)->color_ctrl_page;
         unsigned long nr_mapped;
         int i, err = 0;
 
@@ -329,12 +205,6 @@ static int map_colored_pages(struct vm_area_struct *vma)
 {
         int err = 0;
 
-        if (!tsk_rt(current)->color_ctrl_page) {
-                TRACE_CUR("Process has no color control page.\n");
-                err = -EINVAL;
-                goto out;
-        }
-
         if (COLORS_PER_CONTROL_PAGE < vma_nr_pages(vma)) {
                 TRACE_CUR("Max page request %lu but want %lu.\n",
                                 COLORS_PER_CONTROL_PAGE, vma_nr_pages(vma));
@@ -348,7 +218,6 @@ out:
 
 static void litmus_color_alloc_vm_close(struct vm_area_struct *vma)
 {
-        struct color_page_info *cur, *tmp;
 
         TRACE_CUR("flags=0x%lx prot=0x%lx\n",
                         vma->vm_flags, pgprot_val(vma->vm_page_prot));
@@ -357,14 +226,12 @@ static void litmus_color_alloc_vm_close(struct vm_area_struct *vma)
                         (void*) vma->vm_start, (void*) vma->vm_end, vma,
                         vma->vm_private_data);
 
-        /* clean up the color_page_infos */
-        list_for_each_entry_safe(cur, tmp,
+        TRACE_CUR("color_page_info_list head: %p, next: %p, prev: %p\n",
                         &tsk_rt(current)->color_page_info_list,
-                        list)
-        {
-                kfree(cur);
-        }
+                        tsk_rt(current)->color_page_info_list.next,
+                        tsk_rt(current)->color_page_info_list.prev);
 
+        cleanup_color_page_infos(&tsk_rt(current)->color_page_info_list);
         reclaim_pages(vma);
 }
 
@@ -417,17 +284,6 @@ out:
  * Initilization
 ***********************************************************/
 
-static struct file_operations litmus_color_ctrl_fops = {
-        .owner  = THIS_MODULE,
-        .mmap   = litmus_color_ctrl_mmap,
-};
-
-static struct miscdevice litmus_color_ctrl_dev = {
-        .name   = CTRL_NAME,
-        .minor  = MISC_DYNAMIC_MINOR,
-        .fops   = &litmus_color_ctrl_fops,
-};
-
 static struct file_operations litmus_color_alloc_fops = {
         .owner  = THIS_MODULE,
         .mmap   = litmus_color_alloc_mmap,
@@ -457,7 +313,6 @@ static int __init init_color_devices(void)
         err = init_dev(ALLOC_NAME, &litmus_color_alloc_dev);
         if (err)
                 goto out;
-        err = init_dev(CTRL_NAME, &litmus_color_ctrl_dev);
 out:
         return err;
 }
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index a5a702332da..c266e3aa0da 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -41,7 +41,7 @@ static u32 lockdown_value_idle = UNLOCK_ALL;
  * if we choose to.
  */
 
-static void ***flusher_pages;
+static void ***flusher_pages = NULL;
 /* One page per [way, color] pair used for flushing. */
 
 /*
@@ -63,8 +63,7 @@ static void cpu_add_work(struct color_queue_request *req)
  *
  * @vaddr_start changes depending upon if this is a read-in or a "flush".
  */
-static void color_page_info_add_work(struct color_page_info *info,
-                void *vaddr_start)
+static void color_page_info_add_work(struct color_page_info *info, void *vaddr_start)
 {
         int i;
 
@@ -278,6 +277,27 @@ static void color_queue_submit_work(void)
         color_queue_loop();
 }
 
+void cleanup_color_page_infos(struct list_head *head)
+{
+        struct color_page_info *cur, *tmp;
+
+        if (NULL == head) {
+                TRACE("Head was null.\n");
+                return;
+        }
+
+        if (NULL == head->next || NULL == head->prev) {
+                TRACE_CUR("next or prev was null\n");
+                return;
+        }
+
+        list_for_each_entry_safe(cur, tmp, head, list) {
+                TRACE_CUR("cleanup color_queue_info %p\n", cur);
+                list_del(cur);
+                kfree(cur);
+        }
+}
+
 /* called when user does add_pages proc handler */
 int setup_flusher_array(void)
 {
@@ -290,6 +310,9 @@ int setup_flusher_array(void)
                 goto out;
         }
 
+        if (flusher_pages != NULL)
+                goto out;
+
         flusher_pages = (void***) kmalloc(color_cache_info.ways
                         * sizeof(*flusher_pages), GFP_KERNEL);
         if (!flusher_pages) {
@@ -335,6 +358,7 @@ out_free:
                 kfree(flusher_pages[way]);
         }
         kfree(flusher_pages);
+        flusher_pages = NULL;
         return ret;
 }
 
diff --git a/litmus/ctrldev.c b/litmus/ctrldev.c
index 87c21609964..1d19e208ecd 100644
--- a/litmus/ctrldev.c
+++ b/litmus/ctrldev.c
@@ -19,10 +19,8 @@ static struct workqueue_struct *wq_litmus_dealloc;
 struct litmus_dealloc_work {
         struct work_struct work_struct;
         void *ctrl_page_mem;
-        void *color_ctrl_page_mem;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
         void *ctrl_page_unmap;
-        void *color_ctrl_page_unmap;
 #endif
 };
 
@@ -34,15 +32,10 @@ static void litmus_dealloc(struct work_struct *work_in)
         TRACE("vunmap() control page %p.\n", work->ctrl_page_unmap);
         vunmap(work->ctrl_page_unmap);
 
-        TRACE("vunmap() color control page %p.\n", work->color_ctrl_page_unmap);
-        vunmap(work->color_ctrl_page_unmap);
 #endif
         TRACE("freeing ctrl_page %p\n", work->ctrl_page_mem);
         free_page((unsigned long) work->ctrl_page_mem);
 
-        TRACE("freeing color_ctrl_page %p\n", work->color_ctrl_page_mem);
-        free_page((unsigned long) work->color_ctrl_page_mem);
-
         kfree((void*) work);
 }
 
@@ -50,7 +43,7 @@ void litmus_schedule_deallocation(struct task_struct *t)
 {
         struct litmus_dealloc_work *work;
 
-        if (NULL == tsk_rt(t)->ctrl_page && NULL == tsk_rt(t)->color_ctrl_page)
+        if (NULL == tsk_rt(t)->ctrl_page)
                 return;
 
         work = kmalloc(sizeof(*work), GFP_ATOMIC);
@@ -64,11 +57,8 @@ void litmus_schedule_deallocation(struct task_struct *t)
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
         work->ctrl_page_mem = tsk_rt(t)->ctrl_page_orig;
         work->ctrl_page_unmap = tsk_rt(t)->ctrl_page;
-        work->color_ctrl_page_mem = tsk_rt(t)->color_ctrl_page_orig;
-        work->color_ctrl_page_unmap = tsk_rt(t)->color_ctrl_page;
 #else
         work->ctrl_page_mem = tsk_rt(t)->ctrl_page;
-        work->color_ctrl_page_mem = tsk_rt(t)->color_ctrl_page;
 #endif
         queue_work(wq_litmus_dealloc, &work->work_struct);
 }
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 74e798992fa..070ecefaeac 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -35,6 +35,8 @@ struct mc_task;
 #include <litmus/affinity.h>
 #endif
 
+#include <litmus/color_queue.h>
+
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
 static DEFINE_RAW_SPINLOCK(task_transition_lock);
@@ -390,25 +392,23 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 {
         struct rt_task  user_config = {};
         void*  ctrl_page     = NULL;
+        struct list_head color_page_info_list;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
         void * ctrl_page_orig = NULL;
 #endif
 
-        void *color_ctrl_page = NULL;
-#ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
-        void *color_ctrl_page_orig = NULL;
-#endif
-
         if (restore) {
                 /* Safe user-space provided configuration data.
                  * and allocated page. */
                 user_config     = p->rt_param.task_params;
                 ctrl_page       = p->rt_param.ctrl_page;
-                color_ctrl_page = p->rt_param.color_ctrl_page;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
                 ctrl_page_orig = p->rt_param.ctrl_page_orig;
-                color_ctrl_page_orig = p->rt_param.color_ctrl_page_orig;
 #endif
+                color_page_info_list.next =
+                        p->rt_param.color_page_info_list.next;
+                color_page_info_list.prev =
+                        p->rt_param.color_page_info_list.prev;
         }
 
         /* We probably should not be inheriting any task's priority
@@ -418,16 +418,19 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 
         /* Cleanup everything else. */
         memset(&p->rt_param, 0, sizeof(p->rt_param));
+        INIT_LIST_HEAD(&p->rt_param.color_page_info_list);
 
         /* Restore preserved fields. */
         if (restore) {
                 p->rt_param.task_params         = user_config;
                 p->rt_param.ctrl_page           = ctrl_page;
-                p->rt_param.color_ctrl_page     = color_ctrl_page;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
                 p->rt_param.ctrl_page_orig = ctrl_page_orig;
-                p->rt_param.color_ctrl_page_orig = color_ctrl_page_orig;
 #endif
+                p->rt_param.color_page_info_list.next =
+                        color_page_info_list.next;
+                p->rt_param.color_page_info_list.prev =
+                        color_page_info_list.prev;
         }
 }
 
@@ -578,10 +581,8 @@ void litmus_fork(struct task_struct* p)
         } else {
                 /* non-rt tasks might have ctrl_page set */
                 tsk_rt(p)->ctrl_page = NULL;
-                tsk_rt(p)->color_ctrl_page = NULL;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
                 tsk_rt(p)->ctrl_page_orig = NULL;
-                tsk_rt(p)->color_ctrl_page_orig = NULL;
 #endif
         }
 
@@ -601,10 +602,8 @@ void litmus_exec(void)
                 WARN_ON(p->rt_param.inh_task);
                 litmus_schedule_deallocation(p);
                 tsk_rt(p)->ctrl_page = NULL;
-                tsk_rt(p)->color_ctrl_page = NULL;
 #ifdef CONFIG_ARCH_NEEDS_UNCACHED_CONTROL_PAGE
                 tsk_rt(p)->ctrl_page_orig = NULL;
-                tsk_rt(p)->color_ctrl_page_orig = NULL;
 #endif
         }
 }
diff --git a/litmus/sched_color.c b/litmus/sched_color.c
index f7e4be70054..0fef8b5f21a 100644
--- a/litmus/sched_color.c
+++ b/litmus/sched_color.c
@@ -553,7 +553,7 @@ static void color_task_new(struct task_struct *t, int on_rq, int running)
         struct cpu_entry *entry;
         struct dgl_group_req *req;
         struct control_page  *cp = tsk_rt(t)->ctrl_page;
-        struct color_ctrl_page *ccp = tsk_rt(t)->color_ctrl_page;
+        struct color_ctrl_page *ccp = &tsk_rt(t)->color_ctrl_page;
 
 
         TRACE_TASK(t, "New colored task\n");
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 288578767d2..0394618dbc9 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -959,7 +959,7 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         enum crit_level level = tsk_mc_crit(t);
         struct dgl_group_req *req;
         struct control_page  *cp = tsk_rt(t)->ctrl_page;
-        struct color_ctrl_page *ccp = tsk_rt(t)->color_ctrl_page;
+        struct color_ctrl_page *ccp = &tsk_rt(t)->color_ctrl_page;
 
         local_irq_save(flags);
         TRACE("New mixed criticality task %d\n", t->pid);