Support for chains of blocking tasks.

2 files changed, 173 insertions, 108 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 26da5f578a6c..d40fdadba62c 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -201,6 +201,7 @@ struct rt_param {
 #define RT_F_RUNNING            0x00000000
 #define RT_F_SLEEP              0x00000001
 #define RT_F_EXIT_SEM           0x00000008
+#define RT_F_BLOCK              0x00000010
 
 #endif
 
diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index 70e254981861..70549de38f62 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -16,7 +16,7 @@
  * admit_[hrt|be]_server
  *
  * TODO system for removing tasks from their release queues
- * TODO clean up link_task_to_cpu and check_slack args
+ * TODO clean up link_to_cpu and check_slack args
  * TODO move slack completion into release
  * TODO fix concurrent arms
  * TODO slack and BE servers, include slack higher prio
@@ -56,11 +56,11 @@ atomic_t servers_running = ATOMIC_INIT(0); /* TODO should be unnecessary */
 
 #define TIME(x)                                 \
         (x)
-        /* ({lt_t y = x;                                \ */
-        /* do_div(y, NSEC_PER_MSEC);               \ */
-        /* y;}) */
-#define TRACE_TIMER(fmt, args...)                                      \
-        sched_trace_log_message("%d P%d*[%s@%s:%d]: " fmt " at %d\n",  \
+/* ({lt_t y = x;                                \ */
+/* do_div(y, NSEC_PER_MSEC);               \ */
+/* y;}) */
+#define TRACE_TIMER(fmt, args...)                                       \
+        sched_trace_log_message("%d P%d*[%s@%s:%d]: " fmt " at %d\n",   \
                                 TRACE_ARGS,  ## args, TIME(litmus_clock()))
 #define TRACE_TASK_TIMER(t, fmt, args...)                       \
         TRACE_TIMER("(%s/%d:%d) " fmt, (t)->comm, (t)->pid,     \
@@ -72,14 +72,14 @@ atomic_t servers_running = ATOMIC_INIT(0); /* TODO should be unnecessary */
  */
 #ifdef DEBUG_EDF_HSB
 
-#define TRACE_SUB(fmt, args...)                                      \
-        sched_trace_log_message("%d P%d      [%s@%s:%d]: " fmt "\n", \
+#define TRACE_SUB(fmt, args...)                                         \
+        sched_trace_log_message("%d P%d      [%s@%s:%d]: " fmt "\n",    \
                                 TRACE_ARGS,  ## args)
-#define TRACE_TASK_SUB(t, fmt, args...) \
+#define TRACE_TASK_SUB(t, fmt, args...)                         \
         TRACE_SUB(TASK_FMT " " fmt, TASK_ARGS(t), ##args)
-#define TRACE_SERVER_SUB(s, fmt, args...)       \
+#define TRACE_SERVER_SUB(s, fmt, args...)                       \
         TRACE_SUB(SERVER_FMT " " fmt, SERVER_ARGS(s), ##args)
-#define TRACE_TASK_SERVER_SUB(t, s, fmt, args...)               \
+#define TRACE_TASK_SERVER_SUB(t, s, fmt, args...)                       \
         TRACE_TASK_SUB(t, SERVER_FMT " " fmt, SERVER_ARGS(s), ##args)
 #else
 #define TRACE_SUB(fmt, args...)
@@ -165,7 +165,7 @@ static struct sched_plugin edf_hsb_plugin __cacheline_aligned_in_smp;
 #define task_data(task)         ((task_data_t*)tsk_rt(task)->plugin_data)
 #define task_srt_server(task)   ((server_t*)task_data(task)->srt_server)
 #define server_slack(s)         ((server_t*)s->data)
-#define server_has_slack(s)     ((server_t*)(s)->deadline != 0)
+#define server_has_slack(s)     (server_slack(s)->deadline != 0)
 #define local_cpu_entry         (&__get_cpu_var(cpu_entries))
 #define global_lock             (&srt_domain.ready_lock)
 #define is_active_plugin        (litmus == &edf_hsb_plugin)
@@ -329,13 +329,21 @@ static void check_donate_slack(server_t *donator, struct task_struct *was_schedu
         if (donator->budget < SLACK_MIN)
                 return;
 
+        if (server_has_slack(donator)) {
+                server_t *slack = server_slack(donator);
+                TRACE_SERVER_SUB(donator, "dead: %d, rel: %d, job: %d already donated",
+                                 slack->deadline, slack->release, slack->job_no);
+                return;
+        }
+
         if (donator->type == S_HRT)
                 hrt_server = container_of(donator, hrt_server_t, server);
 
         /* Donate if the server is waiting for a task release */
         if ((donator->type == S_SRT &&
              donator->job_no <= task_job_no(was_scheduled)) ||
-            (donator->type == S_HRT && hrt_server->no_slack &&
+            (donator->type == S_HRT &&
+             hrt_server->no_slack && hrt_server->ready &&
              !__jobs_pending(&hrt_server->hrt_domain)) ||
             (donator->type == S_BE  &&
              !__jobs_pending(&be_domain))) {
@@ -368,7 +376,6 @@ static void check_slack_candidate(struct task_struct *task)
             !head_in_list(&task_data(task)->candidate_list)) {
 
                 add_slack_candidate(task);
-                sched_trace_action(task, 8);
         }
 }
 
@@ -458,7 +465,7 @@ static inline int check_hrt_server_initialized(hrt_server_t *hrt_server)
  */
 static void slack_timer_arm(hrt_server_t *hrt_server)
 {
-        int cpu;
+        int cpu, err;
         cpu_entry_t *entry;
         struct hrtimer *timer;
         lt_t when_to_fire;
@@ -502,19 +509,19 @@ static void slack_timer_arm(hrt_server_t *hrt_server)
                 TRACE("immediate: %llu", when_to_fire);
                 hrt_server->no_slack = 1;
         } else if (cpu != smp_processor_id()) {
-                atomic_set(&hrt_server->slack_timer_info.state,
-                           HRTIMER_START_ON_INACTIVE);
-                hrtimer_start_on(cpu,
-                                 &hrt_server->slack_timer_info,
-                                 &hrt_server->slack_timer,
-                                 ns_to_ktime(when_to_fire),
-                                 HRTIMER_MODE_ABS_PINNED);
+                err = hrtimer_start_on(cpu,
+                                       &hrt_server->slack_timer_info,
+                                       &hrt_server->slack_timer,
+                                       ns_to_ktime(when_to_fire),
+                                       HRTIMER_MODE_ABS_PINNED);
+                if (err)
+                        TRACE_SERVER_SUB(&hrt_server->server, "failed to arm slack");
         } else {
                 __hrtimer_start_range_ns(timer, ns_to_ktime(when_to_fire),
                                          0, HRTIMER_MODE_ABS_PINNED, 0);
         }
 
-        TRACE_SUB("slack timer armed to fire at %llu on P%d",
+        TRACE_SUB("slack timer 0x%x armed to fire at %llu on P%d",
                   TIME(when_to_fire), entry->cpu);
 }
 
@@ -584,14 +591,10 @@ static void requeue_server(server_t *server)
 static void reclaim_slack(server_t *slack)
 {
         lt_t exec;
-        hrt_server_t *hrt_server;
         server_t *donator = server_slack(slack);
 
         /* SRT servers do not ever reclaim slack */
-        if (donator->type == S_SRT)
-                return;
-        else if (donator->type == S_HRT)
-                sched_trace_action(NULL, 5);
+        sched_trace_action(NULL, 5);
 
         exec = slack->wcet - slack->budget;
         TRACE_SERVER_SUB(donator, "reclaiming %llu slack", TIME(exec));
@@ -606,27 +609,6 @@ static void reclaim_slack(server_t *slack)
         /* If budget exhausted, server needs to wait for next release */
         if (!donator->budget) {
                 TRACE_SERVER_SUB(donator, "exhausted by slack");
-                /* if (donator->type == S_HRT) { */
-                /*      hrt_server = container_of(donator, */
-                /*                                hrt_server_t, */
-                /*                                server); */
-                /*      /\* BUG_ON(!hrt_server->ready); *\/ */
-                /*      /\* TRACE_SERVER_SUB(donator, "exhausted"); *\/ */
-                /*      /\* hrt_server->ready = 0; *\/ */
-                /*      /\* slack_timer_cancel(hrt_server); *\/ */
-                /* } else if (donator->type == S_BE) { */
-                /*      TRACE_SERVER_SUB(donator, "BE removed from ready"); */
-                /*      /\* bheap_delete(server_order, &be_ready_servers, *\/ */
-                /*      /\*          donator->hn); *\/ */
-                /* } */
-
-                /* /\* Prepare servers for their next period. SRT servers are */
-                /*  * handled with their SRT tasks and don't need assistance. */
-                /*  *\/ */
-                /* if (donator->type != S_SRT) { */
-                /*      /\* server_release(donator); *\/ */
-                /*      /\* requeue_server(donator); *\/ */
-                /* } */
         }
 }
 
@@ -651,6 +633,7 @@ static noinline void link_server(cpu_entry_t *entry,
                 } else if (next_server->type == S_SLACK) {
                         /* Should have already been removed from slack list */
                         BUG_ON(head_in_list(&task_data(entry->linked)->candidate_list));
+                        sched_trace_action(entry->linked, 4);
                 } else { /* BE */
                         /* Should have already been removed from ready heap */
                         BUG_ON(bheap_node_in_heap(next_server->hn));
@@ -692,7 +675,7 @@ static noinline void unlink_server(cpu_entry_t *entry, int requeue)
 
         if (server->type == S_SLACK && server->deadline) {
                 add_slack(server);
-                //sched_trace_action(entry->linked, 6);
+                sched_trace_action(entry->linked, 6);
 
                 /* Donator needs to absorb slack execution time */
                 reclaim_slack(server);
@@ -711,10 +694,9 @@ static noinline void unlink_server(cpu_entry_t *entry, int requeue)
  * scheduled on a different CPU. The last argument is only needed
  * for BE tasks as their servers can't be determined here.
  */
-static noinline void link_task_to_cpu(cpu_entry_t *entry,
+static noinline void link_to_cpu(cpu_entry_t *entry,
                                       struct task_struct* linked,
-                                      server_t* next_server,
-                                      int swap_on_sched)
+                                      server_t* next_server)
 {
         cpu_entry_t *sched;
         server_t *tmp_server;
@@ -723,7 +705,7 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
 
         BUG_ON(linked && !is_realtime(linked));
         BUG_ON(linked && is_hrt(linked) && entry->cpu != task_cpu(linked));
-        BUG_ON(entry->cpu == edf_hsb_release_master); 
+        BUG_ON(entry->cpu == edf_hsb_release_master);
 
         if (linked)
                 TRACE_TASK_SERVER_SUB(linked, next_server, "linking to P%d",
@@ -748,7 +730,6 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
 
                         /* Swap link with entry on which linked is scheduled */
                         if (entry != sched && !is_hrt(linked) &&
-                            swap_on_sched &&
                             (!sched->linked || !is_hrt(sched->linked))) {
                                 TRACE_TASK_SUB(linked, "already scheduled on P%d",
                                                sched->cpu);
@@ -811,7 +792,7 @@ static noinline void unlink(struct task_struct* t)
         if (t->rt_param.linked_on != NO_CPU) {
                 /* Unlink */
                 entry = task_linked_entry(t);
-                link_task_to_cpu(entry, NULL, NULL, 0);
+                link_to_cpu(entry, NULL, NULL);
         } else if (is_queued(t)) {
 
                 if (is_released(t, litmus_clock())) {
@@ -861,6 +842,47 @@ static inline void catchup_server(server_t *server, lt_t time)
         TRACE_SERVER_SUB(server, "catching up to %llu", time);
 }
 
+static int catchup_srt_server(struct task_struct *task)
+{
+        int jobs, rv = 0;
+        lt_t release;
+        lt_t now = litmus_clock();
+        server_t *srt_server = task_srt_server(task);
+
+        if (lt_before(srt_server->deadline, now) &&
+            srt_server->job_no > 1) {
+                /* Calculate the number of jobs behind the server is */
+                jobs = lt_subtract(now, srt_server->deadline) /
+                        srt_server->period + 1;
+
+                /* Get the new release */
+                release = srt_server->release + jobs * srt_server->period;
+
+                TRACE_SERVER_SUB(srt_server, "catching up to %llu, job %d",
+                                 release, srt_server->job_no + jobs);
+
+                /* Update server state */
+                server_release_at(srt_server, release);
+                srt_server->job_no += jobs - 1;
+
+                /* Force task to take characteristics of server */
+                tsk_rt(task)->job_params.release  = srt_server->deadline;
+                tsk_rt(task)->job_params.deadline = srt_server->release;
+
+                rv = 1;
+
+                sched_trace_action(task, 2);
+
+        } else if (lt_before(srt_server->deadline, now) &&
+                   srt_server->job_no <= 1) {
+
+                server_release_at(srt_server, get_release(task));
+                srt_server->job_no = task_job_no(task);
+        }
+
+        return rv;
+}
+
 /*
  * Returns the next eligible slack server. This will remove any expired
  * slack servers still present in the list.
@@ -922,20 +944,34 @@ static struct task_struct* next_eligible_slack(void)
 static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
 {
         lt_t now = litmus_clock();
+        lt_t dead, slack, budget;
         struct task_struct *task = __peek_ready(&hrt_server->hrt_domain);
 
         /* Catch up server if it is initialized, not running, and late */
         if (task &&
             check_hrt_server_initialized(hrt_server) &&
-            !is_server_linked(&hrt_server->server) &&
-            lt_before_eq(hrt_server->server.deadline, now)) {
+            !is_server_linked(&hrt_server->server)) {
+
+                dead = hrt_server->server.deadline;
+                budget = hrt_server->server.budget;
+                slack = lt_subtract(dead, budget);
+
+                TRACE_SUB("%llu", now);
+
+                if (lt_before_eq(dead, now)) {
+                        /* The server missed a release */
+                        catchup_server(&hrt_server->server, now);
+                        slack_timer_arm(hrt_server);
+                        TRACE_SERVER_SUB(&hrt_server->server, "now ready");
+                        hrt_server->ready = 1;
+                        hrt_server->no_slack = 0;
+                        sched_trace_action(NULL, 2); /* Release */
+                } else if (lt_before_eq(slack, now) && !hrt_server->no_slack) {
+                        /* The server missed the shift to no slack */
+                        hrt_server->no_slack = 1;
+                        sched_trace_action(NULL, 3);
+                }
 
-                catchup_server(&hrt_server->server, now);
-                slack_timer_arm(hrt_server);
-                TRACE_SERVER_SUB(&hrt_server->server, "now ready");
-                hrt_server->ready = 1;
-                hrt_server->no_slack = 0;
-                sched_trace_action(NULL, 2); /* Release */
         } else {
                 TRACE_SERVER_SUB(&hrt_server->server, "%llu %d %llu",
                                  hrt_server->server.deadline,
@@ -945,9 +981,14 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
 
         if (!hrt_server->server.budget ||
             (task && !is_eligible(task, hrt_server))) {
-                    if (task)
+                if (task)
                         TRACE_TASK_SUB(task, "not eligible");
-                    task = NULL;
+                task = NULL;
+
+                /* Donate slack if we have nothing to schedule */
+                if (hrt_server->ready && hrt_server->no_slack) {
+                        check_donate_slack(&hrt_server->server, NULL);
+                }
         }
 
         return task;
@@ -958,29 +999,36 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
  */
 static struct task_struct* next_eligible_srt(void)
 {
-        struct task_struct *next_srt = __peek_ready(&srt_domain);
-        server_t *srt_server;
+        int done = 0;
+        struct task_struct *next_srt;
 
-        /* A blocking task might pollute the SRT domain if the
-         * task blocked while it was being run by a slack server.
-         * Remove and ignore this task.
-         */
-        while (next_srt && (!is_running(next_srt) ||
-                            unlikely(!is_realtime(next_srt)))) {
-                TRACE_TASK_SUB(next_srt, "removing blocking task");
-                remove(&srt_domain, next_srt);
+        while (!done) {
                 next_srt = __peek_ready(&srt_domain);
-        }
 
-        /* Catch up srt server. This happens when the job is tardy due
-         * to overutilization of the system.
-         */
-        if (next_srt) {
-                srt_server = task_srt_server(next_srt);
+                /* A blocking task might pollute the SRT domain if the
+                 * task blocked while it was being run by a slack server.
+                 * Remove and ignore this task.
+                 */
+                while (next_srt && (get_rt_flags(next_srt) == RT_F_BLOCK ||
+                                    unlikely(!is_realtime(next_srt)))) {
+                        TRACE_TASK_SUB(next_srt, "removing finished task");
+                        remove(&srt_domain, next_srt);
+                        next_srt = __peek_ready(&srt_domain);
+                }
+
+                /* If the task blocked for awhile or has otherwise not been
+                 * accessed, its server could have fallen behind.
+                 */
+                if (next_srt) {
+                        done = !catchup_srt_server(next_srt);
 
-                if (lt_before(srt_server->deadline, get_deadline(next_srt))) {
-                        server_release_at(srt_server, get_release(next_srt));
-                        srt_server->job_no = task_job_no(next_srt);
+                        /* The parameters were modified. Re-insert the task. */
+                        if (!done) {
+                                remove(&srt_domain, next_srt);
+                                __add_ready(&srt_domain, next_srt);
+                        }
+                } else {
+                        done = 1;
                 }
         }
 
@@ -1007,6 +1055,7 @@ static server_t* next_eligible_be_server(void)
                 catchup_server(be_server, now);
                 bheap_insert(server_order, &be_ready_servers,
                              be_server->hn);
+
                 be_server = next_be_server();
                 sched_trace_action(NULL, 2); /* Release */
         }
@@ -1214,7 +1263,7 @@ static void edf_hsb_pick_next(cpu_entry_t *entry)
                                       "removing and picked");
 
                 /* A slack preemption could cause something that was already
-                 * running to be 'swapped' to this CPU in link_task_to_cpu.
+                 * running to be 'swapped' to this CPU in link_to_cpu.
                  */
                 if (entry->linked) {
                         linked = entry->linked;
@@ -1222,7 +1271,7 @@ static void edf_hsb_pick_next(cpu_entry_t *entry)
                         requeue(linked, get_rt_domain(entry, linked));
                         TRACE_TASK_SUB(linked, "preempted next pick");
                 }
-                link_task_to_cpu(entry, next_task, next_server, 1);
+                link_to_cpu(entry, next_task, next_server);
         }
 }
 
@@ -1243,7 +1292,7 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
 
         check_for_slack_preempt(next, next_server, entry, slack_resched);
         linked = entry->linked;
-        link_task_to_cpu(entry, next, next_server, 1);
+        link_to_cpu(entry, next, next_server);
 
         /* No need for this if only the server was preempted */
         if (!linked || linked != entry->linked) {
@@ -1261,9 +1310,9 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
  * 2. slack donated by server is running a task on a different CPU
  */
 static void check_for_slack_preempt(struct task_struct *task,
-                                   server_t *server,
-                                   cpu_entry_t *next_entry,
-                                   int resched)
+                                    server_t *server,
+                                    cpu_entry_t *next_entry,
+                                    int resched)
 {
         cpu_entry_t *entry = NULL;
         server_t *slack = server_slack(server);
@@ -1333,7 +1382,7 @@ static void check_for_global_preempt(void)
 #else
                                 if (!pref->linked)
 #endif
-                                entry = pref;
+                                        entry = pref;
                 }
 
                 /* Preempt only if we have an earlier deadline */
@@ -1499,7 +1548,7 @@ static enum hrtimer_restart slack_timer_fire(struct hrtimer *timer)
 
         /* Donate slack if there is nothing to do */
         if (!entry->linked || !is_hrt(entry->linked)) {
-                donate_slack(&server->server);
+                check_donate_slack(&server->server, NULL);
                 check_for_global_preempt();
         }
 
@@ -1907,7 +1956,7 @@ static long edf_hsb_admit_task(struct task_struct *task)
         if (is_hrt(task)) {
                 return check_hrt_server_initialized(&entry->hrt_server) &&
                         ((task_cpu(task) == task->rt_param.task_params.cpu) &&
-                        (task_cpu(task) == entry->cpu)) ? 0 : -EINVAL;
+                         (task_cpu(task) == entry->cpu)) ? 0 : -EINVAL;
         } else {
                 /* If the task is not HRT, we don't want to force the user
                  * to specify a CPU.
@@ -1945,11 +1994,24 @@ static long edf_hsb_deactivate_plugin(void)
 static void edf_hsb_task_block(struct task_struct *task)
 {
         unsigned long flags;
+        cpu_entry_t *entry = task_sched_entry(task);
+        server_t *linked, *srt;
 
         TRACE_TASK(task, "block at %llu\n", litmus_clock());
 
         raw_spin_lock_irqsave(global_lock, flags);
+
+        set_rt_flags(task, RT_F_BLOCK);
+
+        linked = entry->linked_server;
+        srt = task_srt_server(task);
+
         unlink(task);
+
+        if (is_srt(task) && srt == linked) {
+                check_donate_slack(task_srt_server(task), task);
+        }
+
         raw_spin_unlock_irqrestore(global_lock, flags);
 }
 
@@ -1989,7 +2051,7 @@ static void edf_hsb_task_exit(struct task_struct *task)
 static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
 {
         unsigned long flags;
-        int blocks, out_of_time, preempted, sleep, was_slack;
+        int blocks, preempted, sleep, was_slack;
         struct task_struct *curr;
         cpu_entry_t *entry = local_cpu_entry;
 
@@ -2007,11 +2069,6 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
 
         curr = entry->scheduled;
 
-        if (curr != prev && prev->pid == 0) {
-                TRACE_SUB("should bug");
-        } else {
-                BUG_ON(curr && !is_realtime(prev));
-        }
         TRACE("server_budget: %llu, server_deadline: %llu, "
               "curr_time: %llu, no_slack: %d, ready: %d\n",
               TIME(entry->hrt_server.server.budget),
@@ -2019,23 +2076,27 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
               TIME(litmus_clock()), entry->hrt_server.no_slack,
               entry->hrt_server.ready);
 
+        if (curr != prev && prev->pid == 0) {
+                TRACE_SUB("should bug");
+        } else {
+                BUG_ON(curr && !is_realtime(prev));
+        }
+
         /* Determine state */
         blocks      = curr && !is_running(curr);
         preempted   = entry->scheduled != entry->linked;
         sleep       = curr && get_rt_flags(curr) == RT_F_SLEEP;
-        out_of_time = curr && budget_enforced(curr) &&
-                              budget_exhausted(curr);
         was_slack   = !list_empty(&slack_queue);
 
-        TRACE("blocks: %d, preempted: %d, sleep: %d, oot: %d\n",
-              blocks, preempted, sleep, out_of_time);
+        TRACE("blocks: %d, preempted: %d, sleep: %d\n",
+              blocks, preempted, sleep);
         if (blocks)
                 unlink(entry->scheduled);
 
         /* If the task has gone to sleep or exhausted its budget, it
          * must complete its current job.
          */
-        if ((out_of_time || sleep) && !blocks && !preempted)
+        if (sleep && !blocks && !preempted)
                 job_completion(entry, entry->scheduled);
 
         /* Pick the next task if there isn't one currently */
@@ -2154,9 +2215,12 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
                               get_rt_phase(task));
 
         if (!is_be(task)) {
+                if (is_srt(task)) {
+                        catchup_srt_server(task);
+                }
+
                 /* Non-BE tasks are not sporadic in this model */
                 set_rt_flags(task, RT_F_RUNNING);
-
                 /* The job blocked while it was being run by a slack server */
                 if (is_queued(task)) {
                         check_slack_candidate(task);
@@ -2225,14 +2289,14 @@ static int __init init_edf_hsb(void)
         rv = register_sched_plugin(&edf_hsb_plugin);
         if (rv) {
                 printk(KERN_ERR "Could not register plugin %s.\n",
-                                edf_hsb_plugin.plugin_name);
+                       edf_hsb_plugin.plugin_name);
                 goto out;
         }
 
         rv = make_plugin_proc_dir(&edf_hsb_plugin, &edf_hsb_proc_dir);
         if (rv) {
                 printk(KERN_ERR "Could not create %s procfs dir.\n",
-                                edf_hsb_plugin.plugin_name);
+                       edf_hsb_plugin.plugin_name);
                 goto out;
         }