Checkpoint1 modified to support Checkpoint2 work.

Works under preliminary tests

6 files changed, 88 insertions, 60 deletions

diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index 235591a0897b..e2a4a3dc5968 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -54,7 +54,8 @@ struct gedf_reservation_environment {
 };
 
 long alloc_gedf_reservation_environment(
-        struct gedf_reservation_environment** _env
+        struct gedf_reservation_environment** _env,
+        int num_cpus
 );
 
 #endif
diff --git a/litmus/reservations/ext_reservation.c b/litmus/reservations/ext_reservation.c
index 7d80491fd7b2..9623ec520e98 100644
--- a/litmus/reservations/ext_reservation.c
+++ b/litmus/reservations/ext_reservation.c
@@ -2,8 +2,8 @@
 #include <litmus/reservations/ext_reservation.h>
 
 /* allocated in litmus.c */
-struct kmem_cache* bheap_node_cache;
-struct kmem_cache* release_heap_cache;
+extern struct kmem_cache* bheap_node_cache;
+extern struct kmem_cache* release_heap_cache;
 
 void init_ext_reservation(struct reservation* res)
 {
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index b813544cc1bf..aa1878e208b8 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -1,3 +1,4 @@
+#include <linux/list.h>
 #include <linux/sched.h>
 #include <linux/smp.h>
 #include <linux/slab.h>
@@ -39,7 +40,7 @@ static int higher_prio(struct reservation* first,
 }
 
 /* returns 1 if res of a has earlier deadline than res of b */
-static int edf_ready_order(struct bheap_node* a, bheap_node* b)
+static int edf_ready_order(struct bheap_node* a, struct bheap_node* b)
 {
         return higher_prio(bheap2res(b), bheap2res(a));
 }
@@ -74,7 +75,7 @@ static struct cpu_entry* lowest_prio_cpu(struct bheap* cpu_heap)
         return hn->value;
 }
 
-int edf_preemption_needed(rt_domain_t* rt, struct gedf_reservation* res)
+static int edf_preemption_needed(rt_domain_t* rt, struct reservation* res)
 {
         /* we need the read lock for edf_ready_queue */
         /* no need to preempt if there is nothing pending */
@@ -89,7 +90,7 @@ int edf_preemption_needed(rt_domain_t* rt, struct gedf_reservation* res)
          */
 
         /* reversed */
-        return higher_prio(&res->res, __next_ready_res(rt));
+        return higher_prio(res, __next_ready_res(rt));
 }
 
 /* ******************************************************************************** */
@@ -103,9 +104,10 @@ static void preempt(struct cpu_entry* entry)
         }
 }
 
-static void timer_callback(struct hrtimer* timer)
+static enum hrtimer_restart timer_callback(struct hrtimer* timer)
 {
         litmus_reschedule_local();
+        return HRTIMER_NORESTART;
 }
 
 static void requeue(rt_domain_t* domain, struct reservation* res) {
@@ -158,7 +160,7 @@ static void unlink(struct gedf_reservation* res)
         if (res->linked_on) {
                 link_task_to_cpu(NULL, res->linked_on);
                 res->linked_on = NULL;
-        } else if (is_queued_res(res)) {
+        } else if (is_queued_res(&res->res)) {
                 remove_res(&gedf_env->domain, &res->res);
         }
 }
@@ -203,7 +205,7 @@ static void gedf_on_schedule(
         res->env->ops->resume(res->env, now, cpu);
 }
 
-static void replenish_budget(
+static void gedf_replenish_budget(
         struct reservation* res,
         int cpu)
 {
@@ -230,7 +232,7 @@ static void gedf_drain_budget(
         res->env->ops->update_time(res->env, how_much, cpu);
 }
 
-static struct gedf_reservation_ops gedf_ops =
+static struct reservation_ops gedf_ops =
 {
         .drain_budget = gedf_drain_budget,
         .replenish_budget = gedf_replenish_budget,
@@ -251,8 +253,9 @@ long alloc_gedf_reservation(
         if (!gedf_res)
                 return -ENOMEM;
 
-        init_ext_reservation(&gedf_res.res);
+        init_ext_reservation(&gedf_res->res);
         gedf_res->res.id = id;
+        gedf_res->res.ops = &gedf_ops;
         *_res = gedf_res;
 
         gedf_res->linked_on = NULL;
@@ -271,21 +274,23 @@ static void gedf_env_shutdown(
         struct reservation_environment* env)
 {
         struct gedf_reservation_environment* gedf_env;
+        struct reservation* res;
         int i;
-        struct gedf_reservation gedf_res;
-        gedf_env = container_of(env, struct gedf_reservation_environment* gedf_env);
+        unsigned long flags;
+
+        gedf_env = container_of(env, struct gedf_reservation_environment, env);
         suspend_releases(&gedf_env->domain);
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         for_each_online_cpu(i) {
-                hrtimer_cancel(&cpu_entries[i]);
+                hrtimer_cancel(&gedf_env->cpu_entries[i].timer);
         }
         while (!list_empty(&gedf_env->all_reservations)) {
-                gedf_res = list_first_entry(&gedf_env->all_reservations,
-                                        struct gedf_reservation, all_list);
-                list_del(&gedf_res->res.all_list);
+                res = list_first_entry(&gedf_env->all_reservations,
+                                        struct reservation, all_list);
+                list_del(&res->all_list);
                 res->ops->shutdown(res);
         }
-        raw_spin_unlock_irqsave(&gedf_env->domain.ready_lock, flags);
+        raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
         kfree(env);
 }
 
@@ -298,15 +303,16 @@ static void gedf_env_remove_res(
         int complete)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct gedf_reservation gedf_res;
+        struct gedf_reservation* gedf_res;
         unsigned long flags;
+
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         gedf_res = container_of(res, struct gedf_reservation, res);
         gedf_res->will_remove = complete;
         gedf_res->blocked = !complete;
         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
-        list_del_init(&gedf_res->res.all_list, &gedf_env->all_reservations);
-        unlink(res);
+        list_del_init(&gedf_res->res.all_list);
+        unlink(gedf_res);
         preempt(gedf_res->scheduled_on);
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
         /* After preempt is called, schedule will update budget tracking.
@@ -324,7 +330,7 @@ static void gedf_env_add_res(
         struct reservation* res)
 {
         struct gedf_reservation_environment* gedf_env;
-        struct gedf_reservation gedf_res;
+        struct gedf_reservation* gedf_res;
         unsigned long flags;
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         gedf_res = container_of(res, struct gedf_reservation, res);
@@ -339,7 +345,7 @@ static void gedf_env_add_res(
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 }
 
-static gedf_env_suspend(
+static void gedf_env_suspend(
         struct reservation_environment* env,
         int cpu)
 {
@@ -350,9 +356,9 @@ static gedf_env_suspend(
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = gedf_env->cpu_entries[env_cpu];
+        entry = &gedf_env->cpu_entries[env_cpu];
 
-        if (res_cpu == 0)
+        if (env_cpu == 0)
                 suspend_releases(&gedf_env->domain);
 
         /* this essentially removes the cpu from scheduling consideration */
@@ -369,7 +375,7 @@ static gedf_env_suspend(
         hrtimer_try_to_cancel(&entry->timer);
 }
 
-static gedf_env_resume(
+static void gedf_env_resume(
         struct reservation_environment* env,
         lt_t now,
         int cpu)
@@ -381,7 +387,7 @@ static gedf_env_resume(
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         env_cpu = gedf_env->cpu_mapping[cpu];
-        entry = gedf_env->cpu_entries[env_cpu];
+        entry = &gedf_env->cpu_entries[env_cpu];
 
         if (env_cpu == 0)
                 resume_releases(&gedf_env->domain);
@@ -394,7 +400,10 @@ static gedf_env_resume(
         */
 
         if (entry->scheduled)
-                hrtimer_start(&entry->timer, ns_to_ktime(now + entry->scheduled->cur_budget));
+                hrtimer_start(
+                        &entry->timer,
+                        ns_to_ktime(now + entry->scheduled->cur_budget),
+                        HRTIMER_MODE_ABS_PINNED);
 }
 
 static struct task_struct* gedf_env_dispatch(
@@ -405,7 +414,7 @@ static struct task_struct* gedf_env_dispatch(
         struct gedf_reservation_environment* gedf_env;
         struct cpu_entry* entry;
         int env_cpu;
-        struct task_struct* next;
+        struct task_struct* next = NULL;
         unsigned long flags;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
@@ -417,16 +426,21 @@ static struct task_struct* gedf_env_dispatch(
         check_for_preemptions(gedf_env);
         if (entry->scheduled != entry->linked) {
                 if (entry->scheduled)
-                        entry->scheduled->op->on_preempt(entry->scheduled, cpu);
+                        entry->scheduled->ops->on_preempt(entry->scheduled, cpu);
                 if (entry->linked)
-                        entry->linked->op->on_schedule(entry->linked, now, cpu);
+                        entry->linked->ops->on_schedule(entry->linked, now, cpu);
                 entry->scheduled = entry->linked;
         }
         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
 
-        next = entry->scheduled->env->op->dispatch(next, time_slice, cpu);
+        //TODO: Think about possible problems with entry->scheduled being changed
+        if (entry->scheduled) {
+                next = entry->scheduled->env->ops->dispatch(entry->scheduled->env, now, cpu);
 
-        hrtimer_start(&entry->timer, ns_to_ktime(now + entry->scheduled->cur_budget);
+                hrtimer_start(&entry->timer,
+                        ns_to_ktime(now + entry->scheduled->cur_budget),
+                        HRTIMER_MODE_ABS_PINNED);
+        }
 
         return next;
 }
@@ -445,6 +459,10 @@ static void gedf_env_update_time(
         entry = &gedf_env->cpu_entries[env_cpu];
 
         BUG_ON(entry->id != cpu);
+
+        if (!entry->scheduled)
+                return;
+
         entry->scheduled->ops->drain_budget(entry->scheduled, how_much, cpu);
         gedf_res = container_of(entry->scheduled, struct gedf_reservation, res);
         /* if flagged for removal from environment, invoke shutdown callback */
@@ -453,13 +471,13 @@ static void gedf_env_update_time(
                 entry->scheduled->ops->shutdown(entry->scheduled);
                 entry->scheduled = NULL;
         } else if (!entry->scheduled->cur_budget) {
-                entry->scheduled->ops->replenish(entry->scheduled, cpu);
+                entry->scheduled->ops->replenish_budget(entry->scheduled, cpu);
                 /* unlink and requeue if not blocked */
                 if (!gedf_res->blocked) {
                         raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
-                        unlink(entry->scheduled);
+                        unlink((struct gedf_reservation*)entry->scheduled);
                         requeue(&gedf_env->domain, entry->scheduled);
-                        check_for_preemption();
+                        check_for_preemptions(gedf_env);
                         raw_spin_unlock_irqrestore(&gedf_env->domain.ready_lock, flags);
                 }
         }
@@ -468,16 +486,16 @@ static void gedf_env_update_time(
 static void gedf_env_release_jobs(rt_domain_t* rt, struct bheap* res)
 {
         unsigned long flags;
-        struct gedf_reservation_environment gedf_env
+        struct gedf_reservation_environment* gedf_env
                 = container_of(rt, struct gedf_reservation_environment, domain);
 
-        raw_spin_lock_irqsave(&rt->ready_lock);
-        __merge_ready_res(rt, tasks);
+        raw_spin_lock_irqsave(&rt->ready_lock, flags);
+        __merge_ready_res(rt, res);
         check_for_preemptions(gedf_env);
-        raw_spin_unlock_irqrestore(&rt->ready_lock);
+        raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
 }
 
-static struct gedf_reservation_environment_ops gedf_env_ops {
+static struct reservation_environment_ops gedf_env_ops = {
         .update_time = gedf_env_update_time,
         .dispatch = gedf_env_dispatch,
         .resume = gedf_env_resume,
@@ -488,9 +506,12 @@ static struct gedf_reservation_environment_ops gedf_env_ops {
 };
 
 long alloc_gedf_reservation_environment(
-        struct gedf_reservation_environment** _env)
+        struct gedf_reservation_environment** _env,
+        int num_cpus)
 {
         struct gedf_reservation_environment* gedf_env;
+        int i;
+
         gedf_env = kzalloc(sizeof(struct gedf_reservation_environment), GFP_KERNEL);
         if (!gedf_env)
                 return -ENOMEM;
@@ -500,11 +521,12 @@ long alloc_gedf_reservation_environment(
         INIT_LIST_HEAD(&gedf_env->all_reservations);
         gedf_env->num_cpus = 0;
         bheap_init(&gedf_env->cpu_heap);
-        for_each_online_cpu(i) {
+        for (i = 0; i < num_cpus; i++) {
                 gedf_env->cpu_entries[i].hn = &gedf_env->cpu_node[i];
                 hrtimer_init(&gedf_env->cpu_entries[i].timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
-                gedf_env->cpu_entires[i].timer.function = timer_callback;
+                gedf_env->cpu_entries[i].timer.function = timer_callback;
                 bheap_node_init(&gedf_env->cpu_entries[i].hn, &gedf_env->cpu_entries[i]);
+                bheap_insert(cpu_lower_prio, &gedf_env->cpu_heap, gedf_env->cpu_entries[i].hn);
         }
         rt_domain_init(&gedf_env->domain, edf_ready_order, NULL, gedf_env_release_jobs);
 
diff --git a/litmus/reservations/task_reservation.c b/litmus/reservations/task_reservation.c
index 8a8fe4237882..ee4bbbc5ed07 100644
--- a/litmus/reservations/task_reservation.c
+++ b/litmus/reservations/task_reservation.c
@@ -1,10 +1,11 @@
 #include <linux/slab.h>
+
+#include <litmus/litmus.h>
 #include <litmus/reservations/ext_reservation.h>
 #include <litmus/reservations/task_reservation.h>
 
 static void task_env_shutdown(
-        struct reservation_environment* env,
-        int cpu)
+        struct reservation_environment* env)
 {
         struct task_reservation_environment* task_env =
                 container_of(env, struct task_reservation_environment, env);
@@ -16,15 +17,14 @@ static void task_env_shutdown(
 static void task_env_remove_res(
         struct reservation_environment* env,
         struct reservation* res,
-        int cpu)
+        int complete)
 {
         return;
 }
 
 static void task_env_add_res(
         struct reservation_environment* env,
-        struct reservation* res,
-        int cpu)
+        struct reservation* res)
 {
         return;
 }
@@ -53,7 +53,7 @@ static struct task_struct* task_env_dispatch(
         return task_env->task;
 }
 
-static void task_env_advance_time(
+static void task_env_update_time(
         struct reservation_environment* env,
         lt_t how_much,
         int cpu)
@@ -61,14 +61,14 @@ static void task_env_advance_time(
         return;
 }
 
-static struct task_reservation_environment_ops task_env_ops {
-        .advance_time = gedf_env_advance_time,
-        .dispatch = gedf_env_dispatch,
-        .resume = gedf_env_resume,
-        .suspend = gedf_env_suspend,
-        .add_res = gedf_env_add_res,
-        .remove_res = gedf_env_remove_res,
-        .shutdown = gedf_env_shutdown
+static struct reservation_environment_ops task_env_ops = {
+        .update_time = task_env_update_time,
+        .dispatch = task_env_dispatch,
+        .resume = task_env_resume,
+        .suspend = task_env_suspend,
+        .add_res = task_env_add_res,
+        .remove_res = task_env_remove_res,
+        .shutdown = task_env_shutdown
 };
 
 long alloc_task_reservation_environment(
@@ -81,7 +81,9 @@ long alloc_task_reservation_environment(
                 return -ENOMEM;
 
         task_env->task = task;
+        task_env->env.ops = &task_env_ops;
         tsk_rt(task)->plugin_state = task_env;
 
         *_env = task_env;
+        return 0;
 }
diff --git a/litmus/sched_ext_res.c b/litmus/sched_ext_res.c
index 60f3c4bdd7df..3c34985bba85 100644
--- a/litmus/sched_ext_res.c
+++ b/litmus/sched_ext_res.c
@@ -325,15 +325,16 @@ static void ext_res_setup_domain_proc(void)
 static long ext_res_activate_plugin(void)
 {
         int cpu;
+        int num_cpus = num_online_cpus();
 
-        alloc_gedf_reservation_environment(&gedf_env);
+        alloc_gedf_reservation_environment(&gedf_env, num_cpus);
 
         for_each_online_cpu(cpu) {
                 TRACE("Initializing CPU%d...\n", cpu);
                 gedf_env->cpu_mapping[cpu] = cpu;
                 gedf_env->cpu_entries[cpu].id = cpu;
         }
-        gedf_env->num_cpus = cpu;
+        gedf_env->num_cpus = num_cpus;
 
         ext_res_setup_domain_proc();
 
diff --git a/run_vm1 b/run_vm1
new file mode 100755
index 000000000000..514834a993cb
--- /dev/null
+++ b/run_vm1
@@ -0,0 +1,2 @@
+#!/bin/sh
+qemu-system-x86_64 -kernel arch/x86/boot/bzImage -serial mon:stdio -display none -append "root=/dev/mapper/virtualboy--vg-root console=ttyS0 nokalsr kgdboc=ttyS1,115200" -m 24576 --enable-kvm -cpu host -smp 8 -hda /home/ztong/ubuntu.qcow2.img -initrd arch/x86/boot/initrd.img -net nic,model=e1000 -net user,hostfwd=tcp::22223-:22 -serial tcp::22224,server,nowait -rtc base=localtime,clock=vm,driftfix=none -s