MC2 levels A, B

6 files changed, 288 insertions, 230 deletions

diff --git a/include/litmus/mc2_common.h b/include/litmus/mc2_common.h
index a1d571f0280f..bdc3a6d82a56 100644
--- a/include/litmus/mc2_common.h
+++ b/include/litmus/mc2_common.h
@@ -14,24 +14,14 @@ enum crit_level {
 
 struct mc2_task {
         enum crit_level crit;
-        pid_t pid;
-        lt_t hyperperiod;
+        unsigned int res_id;
 };
 
 #ifdef __KERNEL__
 
 #include <litmus/reservation.h>
 
-struct mc2_param{
-        struct mc2_task mc2_task;
-};
-
-struct mc2_task_client {
-        struct task_client tc;
-        struct mc2_param mc2;
-};
-
-long mc2_task_client_init(struct mc2_task_client *mtc, struct task_struct *tsk,
+long mc2_task_client_init(struct task_client *tc, struct mc2_task *mc2_param, struct task_struct *tsk,
                                                         struct reservation *res);
         
 #endif /* __KERNEL__ */
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 88cc3e043b0b..6034ff8731af 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -402,10 +402,12 @@ asmlinkage long sys_set_page_color(int cpu)
         long ret = 0;
         //struct task_page *task_page_itr = NULL;
         //struct task_page *task_page_itr_next = NULL;
+        struct page *page_itr = NULL;
         struct vm_area_struct *vma_itr = NULL;
         //struct task_page *entry = NULL;
-        int nr_pages = 0;
+        int nr_pages = 0, nr_shared_pages = 0;
         LIST_HEAD(pagelist);
+        LIST_HEAD(shared_pagelist);
         
         down_read(&current->mm->mmap_sem);
         printk(KERN_INFO "SYSCALL set_page_color\n");
@@ -423,8 +425,8 @@ asmlinkage long sys_set_page_color(int cpu)
                 */
                 num_pages = (vma_itr->vm_end - vma_itr->vm_start) / PAGE_SIZE;
                 // print vma flags
-                //printk(KERN_INFO "flags: 0x%lx\n", vma_itr->vm_flags);
-                //printk(KERN_INFO "start - end: 0x%lx - 0x%lx (%lu)\n", vma_itr->vm_start, vma_itr->vm_end, (vma_itr->vm_end - vma_itr->vm_start)/PAGE_SIZE);
+                printk(KERN_INFO "flags: 0x%lx\n", vma_itr->vm_flags);
+                printk(KERN_INFO "start - end: 0x%lx - 0x%lx (%lu)\n", vma_itr->vm_start, vma_itr->vm_end, (vma_itr->vm_end - vma_itr->vm_start)/PAGE_SIZE);
                 
                 for (i = 0; i < num_pages; i++) {
 /*
@@ -440,20 +442,32 @@ asmlinkage long sys_set_page_color(int cpu)
                                 continue;
                         if (!old_page)
                                 continue;
-                        if (PageReserved(old_page))
-                                goto put_and_next;
-                                
-                        ret = isolate_lru_page(old_page);
-                        //if (pfn_valid(__page_to_pfn(old_page)))
-                        if (!ret) {
-                                //printk(KERN_INFO "page_mapcount = %d\n", page_mapcount(old_page));
-                                printk(KERN_INFO "addr: %lu, pfn: %lu mapcount: %d\n", vma_itr->vm_start + PAGE_SIZE*i, __page_to_pfn(old_page), page_mapcount(old_page));
-                                list_add_tail(&old_page->lru, &pagelist);
-                                inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
-                                nr_pages++;
+                        if (PageReserved(old_page)) {
+                                put_page(old_page);
+                                continue;
+                        }
+                        
+                        printk(KERN_INFO "addr: %lu, pfn: %lu, _mapcount: %d, _count: %d\n", vma_itr->vm_start + PAGE_SIZE*i, __page_to_pfn(old_page), page_mapcount(old_page), page_count(old_page));
+                        
+                        if (page_mapcount(old_page) == 1) {
+                                ret = isolate_lru_page(old_page);
+                                //if (pfn_valid(__page_to_pfn(old_page)))
+                                if (!ret) {
+                                        list_add_tail(&old_page->lru, &pagelist);
+                                        inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
+                                        nr_pages++;
+                                }
+                                put_page(old_page);
                         }
-put_and_next:                           
+                        else {
+                                ret = isolate_lru_page(old_page);
+                                if (!ret) {
+                                        list_add_tail(&old_page->lru, &shared_pagelist);
+                                        inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
+                                        nr_shared_pages++;
+                                }                                       
                                 put_page(old_page);
+                        }
                 }
                 
                 //INIT_LIST_HEAD(&entry->list);
@@ -462,6 +476,10 @@ put_and_next:
                 vma_itr = vma_itr->vm_next;
         }
 
+        //list_for_each_entry(page_itr, &pagelist, lru) {
+//              printk(KERN_INFO "B _mapcount = %d, _count = %d\n", page_mapcount(page_itr), page_count(page_itr));
+//      }
+        
         ret = 0;
         if (!list_empty(&pagelist)) {
                 ret = migrate_pages(&pagelist, new_alloc_page, 0, MIGRATE_ASYNC, MR_SYSCALL);
@@ -471,8 +489,23 @@ put_and_next:
                 }
         }
         
+        /* copy shared pages HERE */
+/*      
+        ret = 0;
+        if (!list_empty(&shared_pagelist)) {
+                ret = migrate_shared_pages(&shared_pagelist, new_alloc_page, 0, MIGRATE_ASYNC, MR_SYSCALL);
+                if (ret) {
+                        printk(KERN_INFO "%ld shared pages not migrated.\n", ret);
+                        putback_lru_pages(&shared_pagelist);
+                }
+        }
+*/
         up_read(&current->mm->mmap_sem);
 
+        list_for_each_entry(page_itr, &shared_pagelist, lru) {
+                printk(KERN_INFO "S Anon=%d, pfn = %lu, _mapcount = %d, _count = %d\n", PageAnon(page_itr), __page_to_pfn(page_itr), page_mapcount(page_itr), page_count(page_itr));
+        }
+        
 /*      
         list_for_each_entry_safe(task_page_itr, task_page_itr_next, &task_page_list, list) {
                 //printk(KERN_INFO "start - end: 0x%lx - 0x%lx (%lu)\n", task_page_itr->vm_start, task_page_itr->vm_end, (task_page_itr->vm_end - task_page_itr->vm_start)/PAGE_SIZE);
diff --git a/litmus/mc2_common.c b/litmus/mc2_common.c
index 56ef6b506a86..d0a42c69d65c 100644
--- a/litmus/mc2_common.c
+++ b/litmus/mc2_common.c
@@ -7,6 +7,8 @@
 #include <linux/percpu.h>
 #include <linux/sched.h>
 #include <linux/list.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
 
 #include <litmus/litmus.h>
 #include <litmus/sched_plugin.h>
@@ -14,17 +16,62 @@
 
 #include <litmus/mc2_common.h>
 
-long mc2_task_client_init(
-        struct mc2_task_client *mtc,
-        struct task_struct *tsk,
-        struct reservation *res
-)
+long mc2_task_client_init(struct task_client *tc, struct mc2_task *mc2_param, struct task_struct *tsk, struct reservation *res)
 {
-        task_client_init(&mtc->tc, tsk, res);
-        if ((mtc->mc2.mc2_task.crit < CRIT_LEVEL_A) ||
-                (mtc->mc2.mc2_task.crit > CRIT_LEVEL_C))
+        task_client_init(tc, tsk, res);
+        if ((mc2_param->crit < CRIT_LEVEL_A) ||
+                (mc2_param->crit > CRIT_LEVEL_C))
                 return -EINVAL;
         
-        TRACE_TASK(tsk, "mc2_task_client_init: crit_level = %d\n", mtc->mc2.mc2_task.crit);
+        TRACE_TASK(tsk, "mc2_task_client_init: crit_level = %d\n", mc2_param->crit);
+        
         return 0;
+}
+
+asmlinkage long sys_set_mc2_task_param(pid_t pid, struct mc2_task __user * param)
+{
+        struct task_struct *target;
+        int retval = -EINVAL;
+        struct mc2_task *mp = kzalloc(sizeof(*mp), GFP_KERNEL);
+        
+        if (!mp)
+                return -ENOMEM;
+
+        printk("Setting up mc^2 task parameters for process %d.\n", pid);
+
+        if (pid < 0 || param == 0) {
+                goto out;
+        }
+        if (copy_from_user(mp, param, sizeof(*mp))) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        /* Task search and manipulation must be protected */
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_vpid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+
+        if (is_realtime(target)) {
+                /* The task is already a real-time task.
+                 * We cannot not allow parameter changes at this point.
+                 */
+                retval = -EBUSY;
+                goto out_unlock;
+        }
+        if (mp->crit < CRIT_LEVEL_A || mp->crit >= NUM_CRIT_LEVELS) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                        "because of invalid criticality level\n", pid);
+                goto out_unlock;
+        }
+        
+        target->rt_param.plugin_state = mp;
+
+        retval = 0;
+out_unlock:
+        read_unlock_irq(&tasklist_lock);
+out:
+        return retval;
 }
\ No newline at end of file
diff --git a/litmus/polling_reservations.c b/litmus/polling_reservations.c
index 86a32068a3a8..4c07ee74bf39 100644
--- a/litmus/polling_reservations.c
+++ b/litmus/polling_reservations.c
@@ -452,7 +452,10 @@ static void td_drain_budget(
          * how much time is left in this allocation interval. */
 
         /* sanity check: we should never try to drain from future slots */
-        BUG_ON(tdres->cur_interval.start > res->env->current_time);
+        TRACE("TD_DRAIN STATE(%d) [%llu,%llu]  %llu ?\n", res->state, tdres->cur_interval.start, tdres->cur_interval.end, res->env->current_time);
+        //BUG_ON(tdres->cur_interval.start > res->env->current_time);
+        if (tdres->cur_interval.start > res->env->current_time)
+                TRACE("TD_DRAIN BUG!!!!!!!!!!\n");
 
         switch (res->state) {
                 case RESERVATION_DEPLETED:
@@ -470,8 +473,8 @@ static void td_drain_budget(
                                         RESERVATION_DEPLETED);
                         } else {
                                 /* sanity check budget calculation */
-                                BUG_ON(res->env->current_time >= tdres->cur_interval.end);
-                                BUG_ON(res->env->current_time < tdres->cur_interval.start);
+                                //BUG_ON(res->env->current_time >= tdres->cur_interval.end);
+                                //BUG_ON(res->env->current_time < tdres->cur_interval.start);
                         }
 
                         break;
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 1e5b28ba0ac3..b9f05238461b 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -16,9 +16,10 @@
 #include <litmus/polling_reservations.h>
 
 struct mc2_task_state {
-        struct mc2_task_client res_info;
+        struct task_client res_info;
         int cpu;
         bool has_departed;
+        struct mc2_task mc2_param;
 };
 
 struct mc2_cpu_state {
@@ -29,12 +30,7 @@ struct mc2_cpu_state {
 
         int cpu;
         struct task_struct* scheduled;
-
-#ifdef CONFIG_RELEASE_MASTER
-        int release_master;
-        /* used to delegate releases */
-        struct hrtimer_start_on_info info;
-#endif
+        enum crit_level run_level;
 };
 
 static DEFINE_PER_CPU(struct mc2_cpu_state, mc2_cpu_state);
@@ -53,8 +49,8 @@ static void task_departs(struct task_struct *tsk, int job_complete)
         struct reservation* res;
         struct reservation_client *client;
 
-        res    = state->res_info.tc.client.reservation;
-        client = &state->res_info.tc.client;
+        res    = state->res_info.client.reservation;
+        client = &state->res_info.client;
 
         res->ops->client_departs(res, client, job_complete);
         state->has_departed = true;
@@ -66,8 +62,8 @@ static void task_arrives(struct task_struct *tsk)
         struct reservation* res;
         struct reservation_client *client;
 
-        res    = state->res_info.tc.client.reservation;
-        client = &state->res_info.tc.client;
+        res    = state->res_info.client.reservation;
+        client = &state->res_info.client;
 
         state->has_departed = false;
         res->ops->client_arrives(res, client);
@@ -81,13 +77,13 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
 
         update = state->sup_env.next_scheduler_update;
         now = state->sup_env.env.current_time;
-        
+
         /* Be sure we're actually running on the right core,
-         * as mc2_update_timer() is also called from mc2_task_resume(),
+         * as pres_update_timer() is also called from pres_task_resume(),
          * which might be called on any CPU when a thread resumes.
          */
         local = local_cpu_state() == state;
-        
+
         /* Must drop state lock before calling into hrtimer_start(), which
          * may raise a softirq, which in turn may wake ksoftirqd. */
         raw_spin_unlock(&state->lock);
@@ -169,36 +165,10 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
         return restart;
 }
 
-static long mc2_complete_job(void)
-{
-        ktime_t next_release;
-        long err;
-
-        TRACE_CUR("mc2_complete_job at %llu (deadline: %llu)\n", litmus_clock(),
-                                        get_deadline(current));
-
-        tsk_rt(current)->completed = 1;
-        prepare_for_next_period(current);
-        next_release = ns_to_ktime(get_release(current));
-        preempt_disable();
-        TRACE_CUR("next_release=%llu\n", get_release(current));
-        if (get_release(current) > litmus_clock()) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                preempt_enable_no_resched();
-                err = schedule_hrtimeout(&next_release, HRTIMER_MODE_ABS);
-        } else {
-                err = 0;
-                TRACE_CUR("TARDY: release=%llu now=%llu\n", get_release(current), litmus_clock());
-                preempt_enable();
-        }
-
-        TRACE_CUR("mc2_complete_job returns [%d] at %llu\n", err, litmus_clock());
-        return err;
-}
-
 static struct task_struct* mc2_schedule(struct task_struct * prev)
 {
         /* next == NULL means "schedule background work". */
+        struct mc2_task_state *tinfo;
         struct mc2_cpu_state *state = local_cpu_state();
 
         raw_spin_lock(&state->lock);
@@ -210,16 +180,6 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         state->sup_env.will_schedule = true;
         sup_update_time(&state->sup_env, litmus_clock());
 
-        /* check if prev task complete */
-        if (is_realtime(prev)) {
-                TRACE_TASK(prev, "EXEC_TIME = %llu, EXEC_COST = %llu, REMAINED = %llu\n",
-                        get_exec_time(prev), get_exec_cost(prev), get_exec_cost(prev)-get_exec_time(prev)); 
-        }
-        if (is_realtime(prev) && (get_exec_time(prev) >= get_exec_cost(prev))) {
-                TRACE_TASK(prev, "JOB COMPLETED! but is_completed = %d\n", is_completed(prev));
-//              mc2_complete_job(prev);
-        }
-
         /* remove task from reservation if it blocks */
         if (is_realtime(prev) && !is_running(prev))
                 task_departs(prev, is_completed(prev));
@@ -234,12 +194,17 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         state->sup_env.will_schedule = false;
         /* NOTE: drops state->lock */
         mc2_update_timer_and_unlock(state);
-        
-        if (prev != state->scheduled && is_realtime(prev))
+
+        if (prev != state->scheduled && is_realtime(prev)) {
                 TRACE_TASK(prev, "descheduled.\n");
-        if (state->scheduled)
+                state->run_level = NUM_CRIT_LEVELS;
+        }
+        if (state->scheduled) {
                 TRACE_TASK(state->scheduled, "scheduled.\n");
-
+                //tinfo = get_mc2_state(state->scheduled);
+                //state->run_level = tinfo->mc2_param.crit;
+        }
+        
         return state->scheduled;
 }
 
@@ -279,6 +244,7 @@ static void mc2_task_resume(struct task_struct  *tsk)
                 sup_update_time(&state->sup_env, litmus_clock());
                 task_arrives(tsk);
                 /* NOTE: drops state->lock */
+                TRACE("mc2_resume()\n");
                 mc2_update_timer_and_unlock(state);
                 local_irq_restore(flags);
         } else {
@@ -289,6 +255,60 @@ static void mc2_task_resume(struct task_struct  *tsk)
         resume_legacy_task_model_updates(tsk);
 }
 
+/* syscall backend for job completions */
+static long mc2_complete_job(void)
+{
+        ktime_t next_release;
+        long err;
+        struct mc2_cpu_state *state = local_cpu_state();
+        struct reservation_environment *env = &(state->sup_env.env);
+        struct mc2_task_state *tinfo = get_mc2_state(current);
+        
+        
+        TRACE_CUR("mc2_complete_job at %llu (deadline: %llu)\n", litmus_clock(),
+                get_deadline(current));
+
+        tsk_rt(current)->completed = 1;
+        
+        if (tsk_rt(current)->sporadic_release) {
+                env->time_zero = tsk_rt(current)->sporadic_release_time;
+        
+                if (tinfo->mc2_param.crit == CRIT_LEVEL_A) {
+                        struct reservation *res;
+                        struct table_driven_reservation *tdres;
+                        
+                        sup_update_time(&state->sup_env, litmus_clock());
+                        res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                        tdres = container_of(res, struct table_driven_reservation, res);
+                        tdres->next_interval = 0;
+                        tdres->major_cycle_start = tsk_rt(current)->sporadic_release_time;
+                        res->next_replenishment = tsk_rt(current)->sporadic_release_time;
+                        res->next_replenishment += tdres->intervals[0].start;
+                        res->env->change_state(res->env, res, RESERVATION_DEPLETED);
+                                                
+                        TRACE_CUR("CHANGE NEXT_REP = %llu\n NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env.next_scheduler_update);
+                }
+                
+        }
+                
+        prepare_for_next_period(current);
+        next_release = ns_to_ktime(get_release(current));
+        preempt_disable();
+        TRACE_CUR("next_release=%llu\n", get_release(current));
+        if (get_release(current) > litmus_clock()) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                preempt_enable_no_resched();
+                err = schedule_hrtimeout(&next_release, HRTIMER_MODE_ABS);
+        } else {
+                err = 0;
+                TRACE_CUR("TARDY: release=%llu now=%llu\n", get_release(current), litmus_clock());
+                preempt_enable();
+        }
+
+        TRACE_CUR("mc2_complete_job returns at %llu\n", litmus_clock());
+        return err;
+}
+
 static long mc2_admit_task(struct task_struct *tsk)
 {
         long err = -ESRCH;
@@ -297,10 +317,10 @@ static long mc2_admit_task(struct task_struct *tsk)
         struct mc2_cpu_state *state;
         struct mc2_task_state *tinfo = kzalloc(sizeof(*tinfo), GFP_ATOMIC);
         struct mc2_task *mp = tsk_rt(tsk)->plugin_state;
-        
+
         if (!tinfo)
                 return -ENOMEM;
-        
+
         if (!mp) {
                 printk(KERN_ERR "mc2_admit_task: criticality level has not been set\n");
                 return err;
@@ -311,21 +331,22 @@ static long mc2_admit_task(struct task_struct *tsk)
         state = cpu_state_for(task_cpu(tsk));
         raw_spin_lock_irqsave(&state->lock, flags);
 
-        res = sup_find_by_id(&state->sup_env, mp->pid);
+        res = sup_find_by_id(&state->sup_env, mp->res_id);
 
         /* found the appropriate reservation (or vCPU) */
         if (res) {
-                TRACE_TASK(tsk, "FOUND RES\n");
-                tinfo->res_info.mc2.mc2_task.crit = mp->crit;
+                TRACE_TASK(tsk, "FOUND RES ID\n");
+                tinfo->mc2_param.crit = mp->crit;
+                tinfo->mc2_param.res_id = mp->res_id;
                 
                 kfree(tsk_rt(tsk)->plugin_state);
                 tsk_rt(tsk)->plugin_state = NULL;
-        
-                err = mc2_task_client_init(&tinfo->res_info, tsk, res);
+                
+                err = mc2_task_client_init(&tinfo->res_info, &tinfo->mc2_param, tsk, res);
                 tinfo->cpu = task_cpu(tsk);
                 tinfo->has_departed = true;
                 tsk_rt(tsk)->plugin_state = tinfo;
-                
+
                 /* disable LITMUS^RT's per-thread budget enforcement */
                 tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
         }
@@ -340,21 +361,14 @@ static long mc2_admit_task(struct task_struct *tsk)
         return err;
 }
 
-static void task_new_legacy_task_model_updates(struct task_struct *tsk)
-{
-        lt_t now = litmus_clock();
-
-        /* the first job exists starting as of right now */
-        release_at(tsk, now);
-}
-
 static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                           int is_running)
 {
         unsigned long flags;
         struct mc2_task_state* tinfo = get_mc2_state(tsk);
         struct mc2_cpu_state *state = cpu_state_for(tinfo->cpu);
-
+        struct reservation *res;
+        
         TRACE_TASK(tsk, "new RT task %llu (on_rq:%d, running:%d)\n",
                    litmus_clock(), on_runqueue, is_running);
 
@@ -373,15 +387,69 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 sup_update_time(&state->sup_env, litmus_clock());
                 task_arrives(tsk);
                 /* NOTE: drops state->lock */
+                TRACE("mc2_new()\n");
                 mc2_update_timer_and_unlock(state);
                 local_irq_restore(flags);
         } else
                 raw_spin_unlock_irqrestore(&state->lock, flags);
 
-        task_new_legacy_task_model_updates(tsk);
+        res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+        release_at(tsk, res->next_replenishment);
+        if (res)
+                TRACE_TASK(tsk, "next_replenishment = %llu\n", res->next_replenishment);
+        else
+                TRACE_TASK(tsk, "next_replenishment = NULL\n");
 }
 
-static long mc2_reservation_destroy(unsigned int reservation_id, int cpu);
+static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
+{
+        long ret = -EINVAL;
+        struct mc2_cpu_state *state;
+        struct reservation *res = NULL, *next;
+        struct sup_reservation_environment *sup_env;
+        int found = 0;
+                
+        state = cpu_state_for(cpu);
+        raw_spin_lock(&state->lock);
+        
+//      res = sup_find_by_id(&state->sup_env, reservation_id);
+        sup_env = &state->sup_env;
+        //if (!res) {
+        list_for_each_entry_safe(res, next, &sup_env->depleted_reservations, list) {
+                if (res->id == reservation_id) {
+                        list_del(&res->list);
+                        //kfree(res);
+                        found = 1;
+                        ret = 0;
+                }
+        }
+        if (!found) {
+                list_for_each_entry_safe(res, next, &sup_env->inactive_reservations, list) {
+                        if (res->id == reservation_id) {
+                                list_del(&res->list);
+                                //kfree(res);
+                                found = 1;
+                                ret = 0;
+                        }
+                }
+        }
+        if (!found) {
+                list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
+                        if (res->id == reservation_id) {
+                                list_del(&res->list);
+                                //kfree(res);
+                                found = 1;
+                                ret = 0;
+                        }
+                }
+        }
+        //}
+
+        raw_spin_unlock(&state->lock);
+        
+        TRACE("RESERVATION_DESTROY ret = %d\n", ret);
+        return ret;
+}
 
 static void mc2_task_exit(struct task_struct *tsk)
 {
@@ -401,65 +469,31 @@ static void mc2_task_exit(struct task_struct *tsk)
                 sup_update_time(&state->sup_env, litmus_clock());
                 task_departs(tsk, 0);
                 /* NOTE: drops state->lock */
+                TRACE("mc2_exit()\n");
                 mc2_update_timer_and_unlock(state);
                 local_irq_restore(flags);
         } else
                 raw_spin_unlock_irqrestore(&state->lock, flags);
-
-        mc2_reservation_destroy(tsk->pid, tinfo->cpu);
-        
+/*
+        if (tinfo->mc2_param.crit == CRIT_LEVEL_A) {
+                struct table_driven_reservation *td_res;
+                struct reservation *res;
+                res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                td_res = container_of(res, struct table_driven_reservation, res);
+                kfree(td_res->intervals);
+                //kfree(td_res);
+        } else if (tinfo->mc2_param.crit == CRIT_LEVEL_B) {
+                struct polling_reservation *pres;
+                struct reservation *res;
+                res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                pres = container_of(res, struct polling_reservation, res);
+                kfree(pres);
+        }
+*/
         kfree(tsk_rt(tsk)->plugin_state);
         tsk_rt(tsk)->plugin_state = NULL;
 }
 
-asmlinkage long sys_set_mc2_task_param(pid_t pid, struct mc2_task __user * param)
-{
-        struct task_struct *target;
-        int retval = -EINVAL;
-        struct mc2_task *mp = kzalloc(sizeof(*mp), GFP_KERNEL);
-        
-        if (!mp)
-                return -ENOMEM;
-
-        printk("Setting up mc^2 task parameters for process %d.\n", pid);
-
-        if (pid < 0 || param == 0) {
-                goto out;
-        }
-        if (copy_from_user(mp, param, sizeof(*mp))) {
-                retval = -EFAULT;
-                goto out;
-        }
-
-        /* Task search and manipulation must be protected */
-        read_lock_irq(&tasklist_lock);
-        if (!(target = find_task_by_vpid(pid))) {
-                retval = -ESRCH;
-                goto out_unlock;
-        }
-
-        if (is_realtime(target)) {
-                /* The task is already a real-time task.
-                 * We cannot not allow parameter changes at this point.
-                 */
-                retval = -EBUSY;
-                goto out_unlock;
-        }
-        if (mp->crit < CRIT_LEVEL_A || mp->crit >= NUM_CRIT_LEVELS) {
-                printk(KERN_INFO "litmus: real-time task %d rejected "
-                        "because of invalid criticality level\n", pid);
-                goto out_unlock;
-        }
-        
-        target->rt_param.plugin_state = mp;
-
-        retval = 0;
-      out_unlock:
-        read_unlock_irq(&tasklist_lock);
-      out:
-        return retval;
-}
-
 static long create_polling_reservation(
         int res_type,
         struct reservation_config *config)
@@ -566,10 +600,6 @@ static long create_table_driven_reservation(
                 err = copy_from_user(slots,
                         config->table_driven_params.intervals, slots_size);
 
-        for (i=0; i<num_slots;i++) {
-                TRACE("###### [%llu, %llu]\n", slots[i].start, slots[i].end);
-        }
-        
         if (!err) {
                 /* sanity checks */
                 for (i = 0; !err && i < num_slots; i++)
@@ -628,7 +658,6 @@ static long create_table_driven_reservation(
                 kfree(td_res);
         }
 
-        TRACE("CREATE_TABLE_DRIVEN_RES = %d\n", err);
         return err;
 }
 
@@ -665,54 +694,6 @@ static long mc2_reservation_create(int res_type, void* __user _config)
         return ret;
 }
 
-static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
-{
-        long ret = -EINVAL;
-        struct mc2_cpu_state *state;
-        struct reservation *res, *next;
-        struct sup_reservation_environment *sup_env;
-        unsigned long flags;
-        int found = 0;
-        
-        state = cpu_state_for(cpu);
-        raw_spin_lock_irqsave(&state->lock, flags);
-        
-        //res = sup_find_by_id(&state->sup_env, reservation_id);
-        sup_env = &state->sup_env;
-        //if (!res) {
-        list_for_each_entry_safe(res, next, &sup_env->depleted_reservations, list) {
-                if (res->id == reservation_id) {
-                        list_del(&res->list);
-                        found = 1;
-                        ret = 0;
-                }
-        }
-        if (!found) {
-                list_for_each_entry_safe(res, next, &sup_env->inactive_reservations, list) {
-                        if (res->id == reservation_id) {
-                                list_del(&res->list);
-                                found = 1;
-                                ret = 0;
-                        }
-                }
-        }
-        if (!found) {
-                list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
-                        if (res->id == reservation_id) {
-                                list_del(&res->list);
-                                found = 1;
-                                ret = 0;
-                        }
-                }
-        }
-        //}
-
-        raw_spin_unlock_irqrestore(&state->lock, flags);
-        
-        TRACE("RESERVATION_DESTROY ret = %d\n", ret);
-        return ret;
-}
-
 static struct domain_proc_info mc2_domain_proc_info;
 
 static long mc2_get_domain_proc_info(struct domain_proc_info **ret)
@@ -756,11 +737,6 @@ static long mc2_activate_plugin(void)
 
                 state = cpu_state_for(cpu);
 
-#ifdef CONFIG_RELEASE_MASTER
-                state->release_master = atomic_read(&release_master_cpu);
-                hrtimer_start_on_info_init(&state->info);
-#endif
-                
                 raw_spin_lock_init(&state->lock);
                 state->cpu = cpu;
                 state->scheduled = NULL;
@@ -823,15 +799,15 @@ static long mc2_deactivate_plugin(void)
 }
 
 static struct sched_plugin mc2_plugin = {
-        .plugin_name            = "MC2",
-        .schedule               = mc2_schedule,
-        .task_wake_up           = mc2_task_resume,
-        .admit_task             = mc2_admit_task,
-        .task_new               = mc2_task_new,
-        .task_exit              = mc2_task_exit,
+        .plugin_name                    = "MC2",
+        .schedule                               = mc2_schedule,
+        .task_wake_up                   = mc2_task_resume,
+        .admit_task                             = mc2_admit_task,
+        .task_new                               = mc2_task_new,
+        .task_exit                              = mc2_task_exit,
         .complete_job           = mc2_complete_job,
         .get_domain_proc_info   = mc2_get_domain_proc_info,
-        .activate_plugin        = mc2_activate_plugin,
+        .activate_plugin                = mc2_activate_plugin,
         .deactivate_plugin      = mc2_deactivate_plugin,
         .reservation_create     = mc2_reservation_create,
         .reservation_destroy    = mc2_reservation_destroy,
@@ -843,4 +819,3 @@ static int __init init_mc2(void)
 }
 
 module_init(init_mc2);
-
diff --git a/litmus/sched_pres.c b/litmus/sched_pres.c
index e2d48101c890..6c636cce07fb 100644
--- a/litmus/sched_pres.c
+++ b/litmus/sched_pres.c
@@ -14,6 +14,8 @@
 #include <litmus/reservation.h>
 #include <litmus/polling_reservations.h>
 
+//static int testval = 0;
+
 struct pres_task_state {
         struct task_client res_info;
         int cpu;
@@ -172,6 +174,11 @@ static struct task_struct* pres_schedule(struct task_struct * prev)
         BUG_ON(state->scheduled && state->scheduled != prev);
         BUG_ON(state->scheduled && !is_realtime(prev));
 
+//if (testval == 1) {
+//      testval = 0;
+//      printk(KERN_INFO "TESTVAL = 1 at %llu\n", litmus_clock());
+//}
+        
         /* update time */
         state->sup_env.will_schedule = true;
         sup_update_time(&state->sup_env, litmus_clock());
@@ -250,6 +257,8 @@ static long pres_complete_job(void)
 {
         ktime_t next_release;
         long err;
+//testval = 1;
+//printk(KERN_INFO "pres_complete_job at %llu (deadline: %llu)\n", litmus_clock(), get_deadline(current));
 
         TRACE_CUR("pres_complete_job at %llu (deadline: %llu)\n", litmus_clock(),
                 get_deadline(current));
@@ -270,6 +279,7 @@ static long pres_complete_job(void)
         }
 
         TRACE_CUR("pres_complete_job returns at %llu\n", litmus_clock());
+//printk(KERN_INFO "pres_complete_job returns at %llu\n", litmus_clock());      
         return err;
 }