Added code to handle HRT and SRT tasks. Fixed define in litmus.H

1 files changed, 423 insertions, 141 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index a539c8426e97..19c8f9cd2501 100755
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -8,17 +8,23 @@
 #include <linux/time.h>
 #include <linux/string.h>
 #include <linux/sched.h>
+#include <linux/hrtimer.h>
 
 #include <litmus/litmus.h>
-#include <litmus/jobs.h>
 #include <litmus/bheap.h>
-#include <litmus/sched_plugin.h>
+#include <litmus/jobs.h>
 #include <litmus/litmus_proc.h>
+#include <litmus/sched_plugin.h>
 #include <litmus/edf_common.h>
 #include <litmus/preempt.h>
 #include <litmus/sched_trace.h>
 
-/* forward declaration so the below macro works */
+
+static noinline void requeue(struct task_struct*, rt_domain_t*);
+static noinline void unlink(struct task_struct*, rt_domain_t*);
+static enum hrtimer_restart budget_timer_fire(struct hrtimer*);
+static enum hrtimer_restart refill_timer_fire(struct hrtimer*);
+static void edf_hsb_release_jobs(rt_domain_t*, struct bheap*);
 static struct sched_plugin edf_hsb_plugin __cacheline_aligned_in_smp;
 #define is_active_plugin (litmus == &edf_hsb_plugin)
 
@@ -29,11 +35,23 @@ struct hrt_server {
         lt_t            wcet;
         lt_t            budget;
         lt_t            period;
+        lt_t            deadline;
 
         rt_domain_t     domain;
 
         /* lock for setting wcet and period */
         rwlock_t        param_lock;
+
+        /* timer for refilling the budget */
+        struct hrtimer  refill_timer;
+        int             refill_armed;
+
+        /* timer for decrementing the budget */
+        struct hrtimer  budget_timer;
+        int             budget_armed;
+
+        /* stores a task's initial remaining budget */
+        lt_t            task_budget_rem;
 };
 
 struct cpu_entry {
@@ -43,7 +61,7 @@ struct cpu_entry {
 };
 
 DEFINE_PER_CPU_SHARED_ALIGNED(struct hrt_server, hrt_servers);
-DEFINE_PER_CPU_SHARED_ALIGNED(struct cpu_entry, cpu_entries);
+DEFINE_PER_CPU_SHARED_ALIGNED(struct cpu_entry,  cpu_entries);
 static rt_domain_t srt_domain;
 
 /*
@@ -70,9 +88,10 @@ static int check_hrt_servers_initialized(void)
         return !all_init;
 }
 
-/* link_task_to_cpu - Update the link of a CPU.
- *                    Handles the case where the to-be-linked task is already
- *                    scheduled on a different CPU.
+/*
+ * Update the link of a CPU.
+ * Handles the case where the to-be-linked task is already scheduled on
+ * a different CPU.
  */
 static noinline void link_task_to_cpu(struct task_struct *linked,
                                       struct cpu_entry *entry)
@@ -83,12 +102,12 @@ static noinline void link_task_to_cpu(struct task_struct *linked,
 
         BUG_ON(linked && !is_realtime(linked));
 
-        /* Currently linked task is set to be unlinked. */
+        /* Currently linked task is set to be unlinked */
         if (entry->linked) {
                 entry->linked->rt_param.linked_on = NO_CPU;
         }
 
-        /* Link new task to CPU. */
+        /* Link new task to CPU */
         if (linked) {
                 set_rt_flags(linked, RT_F_RUNNING);
                 /* Handle task is already scheduled somewhere! */
@@ -123,33 +142,102 @@ static noinline void link_task_to_cpu(struct task_struct *linked,
 #endif
 }
 
-static noinline void requeue_srt(struct task_struct* task)
+/*
+ * Updates task properties and requeues it, if necessary.
+ */
+static noinline void job_completion(struct task_struct *task,
+                                    int forced, rt_domain_t *domain)
+{
+        sched_trace_task_completion(task, forced);
+        TRACE_TASK(task, "job_completion(),\n");
+
+        BUG_ON(task == NULL);
+
+        set_rt_flags(task, RT_F_SLEEP);
+        prepare_for_next_period(task);
+
+        if (is_released(task, litmus_clock()))
+                sched_trace_task_release(task);
+
+        unlink(task, domain);
+
+        /* Requeue the task if it is not blocking */
+        if (is_running(task))
+                requeue(task, domain);
+}
+
+/* If the server is eligible, return the next eligible task. If
+ * the server is ineligible or there are no eligible tasks,
+ * returns NULL.
+ */
+static struct task_struct* next_eligible_task(struct hrt_server *server)
+{
+        struct task_struct *task;
+
+        write_lock_irq(&server->param_lock);
+
+        task = NULL;
+        if (server->budget > 0)
+                task = __peek_ready(&server->domain);
+
+        if (task) {
+                if (get_deadline(task) >= server->deadline)
+                        task = NULL;
+                else
+                        remove(&server->domain, task);
+        }
+
+        write_unlock_irq(&server->param_lock);
+
+        return task;
+}
+
+/*
+ * Adds a task to the appropriate queue (ready / release) in a domain.
+ */
+static noinline void requeue(struct task_struct *task, rt_domain_t *domain)
 {
         BUG_ON(!task);
         BUG_ON(is_queued(task));
 
         if (is_released(task, litmus_clock())) {
-                __add_ready(&srt_domain, task);
+                __add_ready(domain, task);
         } else {
                 /* Task needs to wait until it is released */
-                add_release(&srt_domain, task);
+                add_release(domain, task);
         }
 }
 
 void reset_hrt_servers(void)
 {
-        int cpu;
+        printk("Resetting hrt servers");
         struct hrt_server *hrt_server;
+        struct hrtimer    *budget_timer, *refill_timer;
+        int cpu;
 
         for_each_online_cpu(cpu) {
                 hrt_server = &per_cpu(hrt_servers, cpu);
+                budget_timer = &hrt_server->budget_timer;
+                refill_timer = &hrt_server->refill_timer;
                 rwlock_init(&hrt_server->param_lock);
 
                 hrt_server->cpu = cpu;
                 hrt_server->wcet = hrt_server->period = hrt_server->budget = 0;
 
-                /* TODO correctly */
-                edf_domain_init(&hrt_server->domain, NULL, NULL);
+                edf_domain_init(&hrt_server->domain, NULL,
+                                edf_hsb_release_jobs);
+
+                hrtimer_init(budget_timer,
+                             CLOCK_MONOTONIC,
+                             HRTIMER_MODE_ABS);
+                budget_timer->function = budget_timer_fire;
+
+                hrtimer_init(refill_timer,
+                             CLOCK_MONOTONIC,
+                             HRTIMER_MODE_ABS);
+                refill_timer->function = refill_timer_fire;
+
+
         }
 }
 
@@ -195,6 +283,7 @@ int set_hrt_params(unsigned long long cpu, unsigned long long wcet,
         hrt_server->wcet = wcet * NSEC_PER_MSEC;
         hrt_server->period = period * NSEC_PER_MSEC;
 
+
         /*
          * TODO probably need a function to reset hrtimers and stuff here
          */
@@ -204,9 +293,9 @@ out:
         return rv;
 }
 
-static noinline void unlink(struct task_struct *task)
+static noinline void unlink(struct task_struct *task, rt_domain_t *domain)
 {
-        struct cpu_entry *entry;
+        struct cpu_entry  *entry;
 
         BUG_ON(task == NULL);
 
@@ -222,74 +311,219 @@ static noinline void unlink(struct task_struct *task)
                 task->rt_param.linked_on = NO_CPU;
                 link_task_to_cpu(NULL, entry);
         } else if (is_queued(task)) {
-                // if (srt_domain.ready_queue.head != NULL)
-                remove(&srt_domain, task);
+                /* This is an interesting situation: t is scheduled,
+                 * but was just recently unlinked.  It cannot be
+                 * linked anywhere else (because then it would have
+                 * been relinked to this CPU), thus it must be in some
+                 * queue. We must remove it from the list in this
+                 * case.
+                 */
+                remove(domain, task);
         }
 }
 
-static noinline void job_completion(struct task_struct *task, int forced)
+
+/******************************************************************************
+ * Timer methods
+ ******************************************************************************/
+
+/*
+ * Arms a timer to go off when a task will exhaust its budget or its server
+ * can no longer execute.
+ */
+static inline void budget_timer_arm(struct hrt_server *server,
+                                    struct cpu_entry *entry)
 {
-        sched_trace_task_completion(task, forced);
-        TRACE_TASK(task, "job_completion(),\n");
+        lt_t deadline, remaining;
 
-        BUG_ON(task == NULL);
+        BUG_ON(server->budget_armed);
 
-        set_rt_flags(task, RT_F_SLEEP);
-        prepare_for_next_period(task);
+        remaining = budget_remaining(entry->scheduled);
+        deadline  = litmus_clock() + deadline;
+        if (deadline > server->deadline || remaining > server->budget) {
+                remaining = server->deadline - deadline;
+                deadline  = server->deadline;
+        }
 
-        if (is_released(task, litmus_clock()))
-                sched_trace_task_release(task);
+        TRACE_TASK(entry->scheduled,
+                   "budget arm, deadline: %llu, remaining: %llu",
+                   deadline, remaining);
+
+        server->task_budget_rem = remaining;
+        server->budget_armed = 1;
+        __hrtimer_start_range_ns(&server->budget_timer,
+                                 ns_to_ktime(deadline),
+                                 0 /* delta */,
+                                 HRTIMER_MODE_ABS_PINNED,
+                                 0 /* no wakeup */);
+}
 
-        unlink(task);
+/*
+ * Decrements a server's budget by the time just consumed by a task.
+ * Do locks need to be involved here?
+ */
+static enum hrtimer_restart budget_timer_fire(struct hrtimer *timer)
+{
+        struct cpu_entry   *entry;
+        struct hrt_server  *server;
+        struct task_struct *curr;
 
-        /* Requeue the task if it is not blocking */
-        if (is_running(task)) 
-                requeue_srt(task);
+        server = &__get_cpu_var(hrt_servers);
+        entry  = &__get_cpu_var(cpu_entries);
+        curr = entry->scheduled;
+
+        if (curr) {
+                server->budget -= server->task_budget_rem -
+                                  budget_remaining(curr);
+
+                TRACE_TASK(curr, "server budget: %llu", server->budget);
+        }
+
+        server->task_budget_rem = 0;
+        server->budget_armed = 0;
+        return HRTIMER_NORESTART;
 }
 
+/*
+ * Starts a periodic timer to replenish a server's budget.
+ */
+static inline void refill_timer_arm(struct hrt_server *server)
+{
+        lt_t deadline;
 
+        if (!check_hrt_servers_initialized())
+                return;
+
+        BUG_ON(server->refill_armed);
+
+        server->refill_armed = 1;
+        deadline = litmus_clock() + server->period;
+        __hrtimer_start_range_ns(&server->refill_timer,
+                                 ns_to_ktime(deadline),
+                                 0 /* delta */,
+                                 HRTIMER_MODE_ABS_PINNED,
+                                 0 /* no wakeup */);
+}
+
+/*
+ * Refills a server's budget and rearms the timer.
+ */
+static enum hrtimer_restart refill_timer_fire(struct hrtimer *timer)
+{
+        struct hrt_server *server;
+
+        server = &__get_cpu_var(hrt_servers);
+        server->budget = server->wcet;
+        server->deadline += server->period;
+
+        __hrtimer_start_range_ns(timer,
+                                 ns_to_ktime(server->deadline),
+                                 0 /* delta */,
+                                 HRTIMER_MODE_ABS_PINNED,
+                                0 /* no wakeup */);
+        return HRTIMER_NORESTART;
+}
 
 /******************************************************************************
  * Plugin methods
  ******************************************************************************/
 
+/*
+ * There is a small race condition in checking that all the server parameters
+ * are valid, then having one of them change before setting the active plugin,
+ * but oh well.
+ */
+static long edf_hsb_activate_plugin(void)
+{
+        struct cpu_entry*  entry;
+        struct hrt_server* server;
+        int  cpu;
+        long rv = 0;
+
+        if (check_hrt_servers_initialized()) {
+                rv = -EINVAL;
+
+                for (cpu = 0; cpu < num_online_cpus(); cpu++) {
+                        entry = &per_cpu(cpu_entries, cpu);
+                        entry->cpu = cpu;
+
+                        server = &per_cpu(hrt_servers, cpu);
+                        //refill_timer_arm(server);
+                }
+
+                edf_domain_init(&srt_domain, NULL, edf_hsb_release_jobs);
+        }
+
+        return rv;
+}
 
 static long edf_hsb_admit_task(struct task_struct *task)
 {
         return 0;
 }
 
-static void edf_hsb_release_jobs(rt_domain_t *rt, struct bheap *tasks)
+static long edf_hsb_deactivate_plugin(void)
+{
+        reset_hrt_servers();
+        return 0;
+}
+
+/*
+ * Simply merges a heap of tasks into a domain's ready queue.
+ * This is used by the edf domains.
+ */
+static void edf_hsb_release_jobs(rt_domain_t *domain, struct bheap *tasks)
 {
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&srt_domain.ready_lock, flags);
-        __merge_ready(rt, tasks);
+        raw_spin_lock_irqsave(&domain->ready_lock, flags);
+        __merge_ready(domain, tasks);
         /* check_for_preemptions(); */
-        raw_spin_unlock_irqrestore(&srt_domain.ready_lock, flags);
+        raw_spin_unlock_irqrestore(&domain->ready_lock, flags);
 }
 
+/*
+ * If the last task was HRT and so is the next, this should never touch the
+ * SRT domain lock.
+ */
 static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
 {
-        struct task_struct *next, *curr_srt;
         struct cpu_entry   *entry;
-        int                 blocks, exists, out_of_time, sleep;
-
-        entry    = &__get_cpu_var(cpu_entries);
-        curr_srt = entry->scheduled;
-
-        raw_spin_lock(&srt_domain.ready_lock);
-
-        BUG_ON(curr_srt && curr_srt != prev);
-        BUG_ON(curr_srt && !is_realtime(prev));
-        BUG_ON(is_realtime(prev) && !entry->scheduled);
+        struct hrt_server  *server;
+        struct task_struct *next, *curr, *next_ready;
+        rt_domain_t        *hrt_domain, *domain;
+        int                 blocks, exists, sleep,
+                            need_srt_unlock, out_of_time;
+
+        entry  = &__get_cpu_var(cpu_entries);
+        server = &__get_cpu_var(hrt_servers);
+        curr   = entry->scheduled;
+        domain = NULL;
+        hrt_domain = &server->domain;
+
+        BUG_ON(curr  && curr != prev);
+        BUG_ON(curr  && !is_realtime(prev));
+        BUG_ON(is_realtime(prev) && !curr);
+        exists = curr != NULL;
+
+        /* Lock the currently executing task's domain */
+        if (exists) {
+                if (is_hrt(curr))
+                        domain = hrt_domain;
+                else if (is_srt(curr)){
+                        domain = &srt_domain;
+                        need_srt_unlock = 1;
+                }
+                raw_spin_lock(&domain->ready_lock);
+        }
 
         /* Determine state */
-        exists      = curr_srt != NULL;
-        blocks      = exists && !is_running(curr_srt);
-        sleep       = exists && get_rt_flags(curr_srt) == RT_F_SLEEP;
-        out_of_time = exists && budget_enforced(curr_srt) &&
-                                budget_exhausted(curr_srt);
+        sleep       = exists && get_rt_flags(curr) == RT_F_SLEEP;
+        out_of_time = exists && budget_enforced(curr) &&
+                                budget_exhausted(curr);
+        blocks      = exists && !is_running(curr);
+        if (exists && is_hrt(curr))
+                blocks = out_of_time && server->budget > 0;
 
         if (exists)
                 TRACE_TASK(prev,
@@ -300,39 +534,50 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
 
         /* Must reschedule blocked task */
         if (blocks)
-                //              resched = 1;
-                unlink(entry->scheduled);
+                unlink(curr, domain);
 
         if ((out_of_time || sleep) && !blocks)
-                job_completion(curr_srt, !sleep);
+                job_completion(curr, !sleep, domain);
+
+        /* If we weren't already in hrt mode, take the lock */
+        if (!exists || is_srt(curr))
+                raw_spin_lock(&hrt_domain->ready_lock);
 
         /* If the cpu entry has no linked task, select the next ready task */
-        if (!entry->linked)
-                link_task_to_cpu(__take_ready(&srt_domain), entry);
+        if (!entry->linked) {
+                next_ready = next_eligible_task(server);
+
+                /* Select an SRT task if the server was ineligible */
+                if (!next_ready) {
+                        if (!need_srt_unlock) {
+                                raw_spin_lock(&srt_domain.ready_lock);
+                                need_srt_unlock = 1;
+                        }
+                        next_ready = __take_ready(&srt_domain);
+                }
+                link_task_to_cpu(next_ready, entry);
+        }
 
         /* Switch current task if we are in RT mode and have no task
          * or if linked is different from scheduled */
         next = NULL;
-        if (curr_srt != entry->linked) {
-                /* Schedule an unscheduled linked job */
-                if (entry->linked) {
-                        entry->linked->rt_param.scheduled_on = entry->cpu;
-                        next = entry->linked;
-                }
-                /* Last scheduled task will not be scheduled soon */
-                if (curr_srt) {
-                        curr_srt->rt_param.scheduled_on = NO_CPU;
-                }
-        } else {
-                if (exists)
-                        next = prev;
+        if (curr != entry->linked && entry->linked) {
+                entry->linked->rt_param.scheduled_on = entry->cpu;
+                next = entry->linked;
+        } else if (exists) {
+                next = prev;
         }
 
-        /* GSN-EDF does not do this, but it sesems like it would make sense */
         entry->scheduled = next;
-
         sched_state_task_picked();
-        raw_spin_unlock(&srt_domain.ready_lock);
+
+        /* Timer to decrement server budget */
+        if (exists && is_hrt(next))
+                budget_timer_arm(server, entry);
+
+        raw_spin_unlock(&hrt_domain->ready_lock);
+        if (need_srt_unlock)
+                raw_spin_unlock(&srt_domain.ready_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
         if (next)
@@ -344,32 +589,68 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
         return next;
 }
 
+/*
+ * If the blocked task was HRT, cancels the budget update timer
+ * and decrements the task's server's budget.
+ */
 static void edf_hsb_task_block(struct task_struct *task)
 {
-        unsigned long flags;
+        struct hrt_server *server;
+        rt_domain_t       *domain;
+        unsigned long      flags;
+        int ret;
 
         TRACE_TASK(task, "block at %llu\n", litmus_clock());
         BUG_ON(!is_realtime(task));
 
+        if (is_hrt(task)) {
+                server = &per_cpu(hrt_servers, task_cpu(task));
+                domain = &server->domain;
+
+                /* If an hrt task is blocked, we must do the work of the
+                 * budget timer ourselves
+                 */
+                server->budget -= server->task_budget_rem -
+                                  budget_remaining(task);
+                server->task_budget_rem = 0;
+
+                ret = hrtimer_try_to_cancel(&server->budget_timer);
+                BUG_ON(ret ==  0); /* inactive */
+                BUG_ON(ret == -1); /* running concurrently */
+
+        } else {
+                domain = &srt_domain;
+        }
+
         /* Unlink if the task is linked to a CPU */
-        raw_spin_lock_irqsave(&srt_domain.ready_lock, flags);
-        unlink(task);
-        raw_spin_unlock_irqrestore(&srt_domain.ready_lock, flags);
+        raw_spin_lock_irqsave(&domain->ready_lock, flags);
+        unlink(task, domain);
+        raw_spin_unlock_irqrestore(&domain->ready_lock, flags);
 }
 
 static void edf_hsb_task_exit(struct task_struct *task)
 {
-        unsigned long flags;
+        struct hrt_server *server;
+        rt_domain_t       *domain;
+        unsigned long      flags;
 
         TRACE_TASK(task, "RIP at %llu\n", litmus_clock());
         BUG_ON(!is_realtime(task));
 
+        if (is_hrt(task)) {
+                server = &per_cpu(hrt_servers, task_cpu(task));
+                domain = &server->domain;
+        } else {
+                domain = &srt_domain;
+        }
+
         /* Unlink if the task is linked to a CPU */
-        raw_spin_lock_irqsave(&srt_domain.ready_lock, flags);
-        unlink(task);
-        raw_spin_unlock_irqrestore(&srt_domain.ready_lock, flags);
+        raw_spin_lock_irqsave(&domain->ready_lock, flags);
+        unlink(task, domain);
+        raw_spin_unlock_irqrestore(&domain->ready_lock, flags);
 
         /* Necessary to set the current entry scheduled to NULL ? */
+        // entry->scheduled = NULL;
 }
 
 /*
@@ -377,17 +658,27 @@ static void edf_hsb_task_exit(struct task_struct *task)
  */
 static void edf_hsb_task_new(struct task_struct *task, int on_rq,  int running)
 {
-        unsigned long      flags;
         struct cpu_entry  *entry;
+        struct hrt_server *server;
+        rt_domain_t       *domain;
+        unsigned long      flags;
 
         TRACE_TASK(task, "edf_hsb: task new, cpu = %d\n",
                    task->rt_param.task_params.cpu);
 
-        raw_spin_lock_irqsave(&srt_domain.ready_lock, flags);
+        if (is_hrt(task)) {
+                server = &__get_cpu_var(hrt_servers);
+                domain = &server->domain;
+        } else if (is_srt(task)){
+                domain = &srt_domain;
+        } else {
+                return;
+        }
+
+        raw_spin_lock_irqsave(&domain->ready_lock, flags);
 
         /* Setup job parameters */
         release_at(task, litmus_clock());
-
         if (running) {
                 entry = &per_cpu(cpu_entries, task_cpu(task));
                 BUG_ON(entry->scheduled);
@@ -400,19 +691,28 @@ static void edf_hsb_task_new(struct task_struct *task, int on_rq,  int running)
 
         task->rt_param.linked_on = NO_CPU;
 
-        requeue_srt(task);
+        requeue(task, domain);
 
-        raw_spin_unlock_irqrestore(&srt_domain.ready_lock, flags);
+        raw_spin_unlock_irqrestore(&domain->ready_lock, flags);
 }
 
 static void edf_hsb_task_wake_up(struct task_struct *task)
 {
-        unsigned long flags;
-        lt_t          now;
+        struct hrt_server *server;
+        rt_domain_t       *domain;
+        unsigned long      flags;
+        lt_t               now;
 
         TRACE_TASK(task, "wake_up at %llu\n", litmus_clock());
 
-        raw_spin_lock_irqsave(&srt_domain.ready_lock, flags);
+        if (is_hrt(task)) {
+                server = &per_cpu(hrt_servers, task_cpu(task));
+                domain = &server->domain;
+        } else {
+                domain = &srt_domain;
+        }
+
+        raw_spin_lock_irqsave(&domain->ready_lock, flags);
 
         /* If job resumes after being suspended due to acquiring a semaphore,
          * it should never be treated as a job release */
@@ -423,6 +723,7 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
 
                 if (is_tardy(task, now)) {
                         /* Re-release the task */
+                        /* Is this a preemption?? */
                         release_at(task, now);
                         sched_trace_task_release(task);
                 } else {
@@ -433,17 +734,18 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
                 }
         }
 
-        requeue_srt(task);
+        requeue(task, domain);
 
-        raw_spin_unlock_irqrestore(&srt_domain.ready_lock, flags);
+        raw_spin_unlock_irqrestore(&domain->ready_lock, flags);
 }
 
 /*
- * Checks if the current task has experiened and whether or not it needs to
+ * Checks if the current task has expered and whether or not it needs to
  * be preempted.
  */
 static void edf_hsb_tick(struct task_struct *t)
 {
+        /* Reschedule the task if it has run out of time */
         if (is_realtime(t) && budget_enforced(t) && budget_exhausted(t)) {
                 if (!is_np(t)) {
                         /* Non-preemptable tasks will be preempted when they
@@ -462,37 +764,6 @@ static void edf_hsb_tick(struct task_struct *t)
 }
 
 
-/*
- * There is a small race condition in checking that all the server parameters
- * are valid, then having one of them change before setting the active plugin,
- * but oh well.
- */
-static long edf_hsb_activate_plugin(void)
-{
-        struct cpu_entry* entry;
-        int  cpu;
-        long rv = 0;
-
-        if (check_hrt_servers_initialized())
-          rv = -EINVAL;
-
-        for (cpu = 0; cpu < num_online_cpus(); cpu++) {
-                entry = &per_cpu(cpu_entries, cpu);
-                entry->cpu = cpu;
-        }
-
-
-        edf_domain_init(&srt_domain, NULL, edf_hsb_release_jobs);
-
-        return rv;
-}
-
-static long edf_hsb_deactivate_plugin(void)
-{
-        //reset_hrt_servers();
-        return 0;
-}
-
 /******************************************************************************
  * Proc methods
  ******************************************************************************/
@@ -502,7 +773,8 @@ static struct proc_dir_entry *edf_hsb_proc_dir = NULL, *hrt_server_proc = NULL;
 static int hrt_proc_read(char* page, char **start, off_t off, int count,
                 int *eof, void *data)
 {
-        int cpu, wcet, period, len = 0;
+        lt_t wcet, period;
+        int cpu, len = 0;
         struct hrt_server *hrt_server;
 
         for_each_online_cpu(cpu) {
@@ -510,8 +782,14 @@ static int hrt_proc_read(char* page, char **start, off_t off, int count,
                 hrt_server = &per_cpu(hrt_servers, cpu);
 
                 read_lock_irq(&hrt_server->param_lock);
-                wcet = do_div(hrt_server->wcet, NSEC_PER_MSEC);
-                period = do_div(hrt_server->period,  NSEC_PER_MSEC);
+
+                wcet = hrt_server->wcet;
+                period = hrt_server->period;
+
+                /* do_div(x, y) stores the result in x */
+                do_div(wcet, NSEC_PER_MSEC);
+                do_div(period, NSEC_PER_MSEC);
+
                 read_unlock_irq(&hrt_server->param_lock);
 
                 len += snprintf(page + len, PAGE_SIZE - len,
@@ -599,7 +877,26 @@ loop_end:
         return count;
 }
 
-/* actual plugin object */
+#define HRT_SERVER_PROC_NAME "hrt_server"
+
+static void exit_proc(void)
+{
+        if (hrt_server_proc) {
+                remove_proc_entry(HRT_SERVER_PROC_NAME, edf_hsb_proc_dir);
+                hrt_server_proc = NULL;
+        }
+
+        if (edf_hsb_proc_dir) {
+                remove_plugin_proc_dir(&edf_hsb_plugin);
+                edf_hsb_proc_dir = NULL;
+        }
+}
+
+
+/******************************************************************************
+ * Plugin
+ ******************************************************************************/
+
 /* static struct sched_plugin edf_hsb_plugin = { */
 static struct sched_plugin edf_hsb_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "EDF-HSB",
@@ -629,21 +926,6 @@ static struct sched_plugin edf_hsb_plugin __cacheline_aligned_in_smp = {
 #endif
 };
 
-#define HRT_SERVER_PROC_NAME "hrt_server"
-
-static void exit_proc(void)
-{
-        if (hrt_server_proc) {
-                remove_proc_entry(HRT_SERVER_PROC_NAME, edf_hsb_proc_dir);
-                hrt_server_proc = NULL;
-        }
-
-        if (edf_hsb_proc_dir) {
-                remove_plugin_proc_dir(&edf_hsb_plugin);
-                edf_hsb_proc_dir = NULL;
-        }
-}
-
 static int __init init_edf_hsb(void)
 {
         int rv;