EXT-RES Checkpoint 2 - Hardly Tested.

2 files changed, 32 insertions, 19 deletions

diff --git a/include/litmus/reservations/table_driven_ext_reservation.h b/include/litmus/reservations/table_driven_ext_reservation.h
index 15ba8b968fd7..706aa07be8be 100644
--- a/include/litmus/reservations/table_driven_ext_reservation.h
+++ b/include/litmus/reservations/table_driven_ext_reservation.h
@@ -31,7 +31,7 @@ long alloc_mtd_reservation(
 
 struct mtd_cpu_entry {
         int id;
-        struct mtd_reservation* scheduled;
+        struct reservation* scheduled;
         rt_domain_t domain;
 };
 
diff --git a/litmus/reservations/table_driven_ext_reservation.c b/litmus/reservations/table_driven_ext_reservation.c
index 16ce74c6a6f3..71b01b7090c1 100644
--- a/litmus/reservations/table_driven_ext_reservation.c
+++ b/litmus/reservations/table_driven_ext_reservation.c
@@ -71,8 +71,12 @@ static void mtd_replenish_budget(
 
         BUG_ON(res != &mtd_res->res[cpu]);
 
+        /* calculate next interval index */
         mtd_res->interval_index[cpu] =
                 (mtd_res->interval_index[cpu] + 1) % mtd_res->num_intervals[cpu];
+        /* if wrap around, then increment major cycle */
+        if (!mtd_res->interval_index[cpu])
+                mtd_res->major_cycle_start += mtd_res->major_cycle;
 
         mtd_res->cur_interval[cpu].start = mtd_res->intervals[cpu][mtd_res->interval_index[cpu]].start;
         mtd_res->cur_interval[cpu].end = mtd_res->intervals[cpu][mtd_res->interval_index[cpu]].end;
@@ -110,6 +114,8 @@ static struct reservation_ops mtd_ops = {
         .dispatch_client = mtd_dispatch_client,
         .on_schedule = mtd_on_schedule,
         .on_preempt = mtd_on_preempt,
+        .is_np = mtd_is_np,
+        .shutdown = mtd_shutdown
 };
 
 /* cannot handle installing table of same core from different threads simultaneously.
@@ -130,11 +136,13 @@ long mtd_res_install_table(
         mtd_res->major_cycle = major_cycle;
         mtd_res->num_intervals[cpu] = num_intervals;
 
+        /* allocated kernel memory for intervals */
         if (mtd_res->num_intervals[cpu])
                 kfree(&mtd_res->intervals[cpu]);
-        kzalloc
+        if (!kzalloc(sizeof(struct lt_interval) * num_intervals, GFP_KERNEL))
+                return ENOMEM;
         /* copy from user space to kernel space */
-        err = copy_from_user(mtd_res->intervals[cpu], intervals);
+        err = copy_from_user(mtd_res->intervals[cpu], intervals, sizeof(struct lt_interval) * num_intervals);
         if (err)
                 return err;
 
@@ -161,6 +169,8 @@ long alloc_mtd_reservation(
                 init_ext_reservation(&mtd_res->res[i], id, &mtd_ops);
         }
         mtd_res->major_cycle = major_cycle;
+
+        return 0;
 }
 
 /* ***************************************************************** */
@@ -195,7 +205,7 @@ static void mtd_env_shutdown(
         mtd_env = container_of(env, struct mtd_reservation_environment, env);
 
         for_each_online_cpu(cpu) {
-                domain_suspend_releases(&mtd_env->cpu_entry[cpu]->domain);
+                domain_suspend_releases(&mtd_env->cpu_entries[cpu].domain);
         }
 
         raw_spin_lock_irqsave(&mtd_env->insert_lock, flags);
@@ -227,7 +237,7 @@ static struct reservation* mtd_find_res_by_id(
         struct reservation* res;
         unsigned long flags;
         struct mtd_reservation_environment* mtd_env =
-                container_of(res, struct mtd_reservation_environment, res);
+                container_of(env, struct mtd_reservation_environment, env);
 
         raw_spin_lock_irqsave(&mtd_env->insert_lock, flags);
         list_for_each_entry(res, &env->all_reservations, all_list) {
@@ -259,13 +269,18 @@ static void mtd_env_add_res(
         lt_t tmp;
         unsigned long flags;
 
+        mtd_env = container_of(env, struct mtd_reservation_environment, env);
+        mtd_res = container_of(res, struct mtd_reservation, res[cpu]);
+
+        BUG_ON(&mtd_res->res[cpu] != res);
+
         /* only add to list in reservation if is first core of res to be added */
         raw_spin_lock_irqsave(&mtd_env->insert_lock, flags);
-        if (!mtd_res->num_cpus) {
+        if (!mtd_env->num_cpus) {
                 mtd_res->res[0].par_env = env;
                 list_add_tail(&mtd_res->res[0].all_list, &env->all_reservations);
         }
-        mtd_res->num_cpus++;
+        mtd_env->num_cpus++;
         raw_spin_unlock_irqrestore(&mtd_env->insert_lock, flags);
 
         tmp = div64_u64(litmus_clock(), mtd_res->major_cycle);
@@ -274,13 +289,13 @@ static void mtd_env_add_res(
         res->par_env = env;
         if (mtd_res->num_intervals[cpu]) {
                 tmp = mtd_res->major_cycle_start;
-                res->replenishment_time = tmp + mtd_res->cur_interval.start;
+                res->replenishment_time = tmp + mtd_res->cur_interval[cpu].start;
 
-                raw_spin_lock_irqsave(&mtd_env->cpu_entries[cpu]->timer, flags);
+                raw_spin_lock_irqsave(&mtd_env->cpu_entries[cpu].domain.ready_lock, flags);
                 requeue(&mtd_env->cpu_entries[cpu], &mtd_res->res[cpu]);
-                if (mtd_res->res[cpu].replenish_time <= litmus_clock())
+                if (mtd_res->res[cpu].replenishment_time <= litmus_clock())
                         litmus_reschedule_local();
-                raw_spin_unlock_irqrestore(&mtd_env->cpu_entries[cpu]->timer, flags);
+                raw_spin_unlock_irqrestore(&mtd_env->cpu_entries[cpu].domain.ready_lock, flags);
         }
 }
 
@@ -310,10 +325,9 @@ static struct task_struct* mtd_env_dispatch(
 {
         struct mtd_reservation_environment* mtd_env;
         struct mtd_cpu_entry* entry;
-        struct mtd_reservation* linked;
-        struct task_struct* next;
+        struct reservation* linked;
+        struct task_struct* next = NULL;
         unsigned long flags;
-        lt_t budget;
 
         mtd_env = container_of(env, struct mtd_reservation_environment, env);
         entry = &mtd_env->cpu_entries[cpu];
@@ -337,12 +351,13 @@ static struct task_struct* mtd_env_dispatch(
 
         if (entry->scheduled) {
                 /* let scheduled reservation decide what runs next */
-                next = entry->scheduled->ops->dispatch_client(entry->scheduled, cpu);
+                next = entry->scheduled->ops->dispatch_client(entry->scheduled, time_slice, cpu);
                 *time_slice = (*time_slice > entry->scheduled->cur_budget) ?
                         entry->scheduled->cur_budget : *time_slice;
         } else
                 *time_slice = ULLONG_MAX;
 
+        return next;
 }
 
 static void mtd_env_update_time(
@@ -352,7 +367,6 @@ static void mtd_env_update_time(
 {
         struct mtd_reservation_environment* mtd_env;
         struct mtd_cpu_entry* entry;
-        struct reservation* res;
         unsigned long flags;
 
         mtd_env = container_of(env, struct mtd_reservation_environment, env);
@@ -420,13 +434,12 @@ long alloc_mtd_reservation_environment(
         INIT_LIST_HEAD(&mtd_env->env.all_reservations);
 
         mtd_env->num_cpus = num_cpus;
-        bheap_init(&mtd_env->cpu_heap);
         for (i = 0; i < num_cpus; i++) {
                 mtd_env->cpu_entries[i].id = i;
                 /* initialize per cpu domain */
-                rt_domain_init(&gedf_env->domain, mtd_ready_order, NULL, mtd_env_release_jobs);
+                rt_domain_init(&mtd_env->cpu_entries[i].domain, mtd_ready_order, NULL, mtd_env_release_jobs);
         }
 
-        *_env = gedf_env;
+        *_env = mtd_env;
         return 0;
 }