Some random code cleanup.

- IRQs are disabled in _schedule
- use TRACE
- coding style

1 files changed, 17 insertions, 18 deletions

diff --git a/kernel/sched_part_edf.c b/kernel/sched_part_edf.c
index 792e022833..cd4dd0e621 100644
--- a/kernel/sched_part_edf.c
+++ b/kernel/sched_part_edf.c
@@ -26,7 +26,7 @@ typedef struct {
 #define local_pedf              (&__get_cpu_var(part_edf_domains))
 #define remote_edf(cpu)         (&per_cpu(part_edf_domains, cpu).domain)
 #define remote_pedf(cpu)        (&per_cpu(part_edf_domains, cpu))
-
+#define task_edf(task)          remote_edf(get_partition(task))
 
 static void part_edf_domain_init(part_edf_domain_t* pedf, 
                                  edf_check_resched_needed_t check,
@@ -71,7 +71,14 @@ static reschedule_check_t part_edf_scheduler_tick(void)
         unsigned long flags;
         struct task_struct *t = current;
         reschedule_check_t want_resched = NO_RESCHED;
-        edf_domain_t *edf = local_edf;
+        edf_domain_t *edf       = local_edf;
+        part_edf_domain_t *pedf = local_pedf;
+
+        /* Check for inconsistency. We don't need the lock for this since
+         * ->scheduled is only changed in schedule, which obviously is not 
+         *  executing in parallel on this CPU
+         */
+        BUG_ON(is_realtime(t) && t != pedf->scheduled);
 
         /* expire tasks even if not in real-time mode
          * this makes sure that at the end of real-time mode
@@ -81,7 +88,6 @@ static reschedule_check_t part_edf_scheduler_tick(void)
                 /* this task has exhausted its budget in this period */
                 set_rt_flags(t, RT_F_SLEEP);
                 want_resched = FORCE_RESCHED;
-                /*set_will_schedule();*/
         } 
         if (get_rt_mode() == MODE_RT_RUN)
         {
@@ -95,10 +101,7 @@ static reschedule_check_t part_edf_scheduler_tick(void)
                 {
                         read_lock_irqsave(&edf->ready_lock, flags);
                         if (preemption_needed(edf, t))
-                        {
                                 want_resched = FORCE_RESCHED;
-                                /*set_will_schedule();*/
-                        }
                         read_unlock_irqrestore(&edf->ready_lock, flags);
                 }
         }       
@@ -110,7 +113,6 @@ static int part_edf_schedule(struct task_struct * prev,
                              runqueue_t * rq)
 {
         int                     need_deactivate = 1;
-        unsigned long           flags;
         part_edf_domain_t*      pedf = local_pedf;
         edf_domain_t*           edf  = &pedf->domain; 
 
@@ -119,8 +121,7 @@ static int part_edf_schedule(struct task_struct * prev,
                 prepare_for_next_period(prev);  
         
         if (get_rt_mode() == MODE_RT_RUN) {
-                write_lock_irqsave(&edf->ready_lock, flags);
-                /*clear_will_schedule();*/
+                write_lock(&edf->ready_lock);
                 if (is_realtime(prev) && is_released(prev) && is_running(prev)
                     && !preemption_needed(edf, prev)) {
                         /* this really should only happen if the task has 
@@ -144,7 +145,7 @@ static int part_edf_schedule(struct task_struct * prev,
                 if (*next)
                         set_rt_flags(*next, RT_F_RUNNING);
                 
-                write_unlock_irqrestore(&edf->ready_lock, flags);
+                write_unlock(&edf->ready_lock);
         } 
 
         if (is_realtime(prev) && need_deactivate && prev->array) {
@@ -194,10 +195,10 @@ static void part_edf_finish_switch(struct task_struct *prev)
  */
 static long part_edf_prepare_task(struct task_struct * t)
 {
-        edf_domain_t*   edf = remote_edf(get_partition(t));
+        edf_domain_t*   edf = task_edf(t);
 
 
-        printk(KERN_WARNING "[%d] part edf: prepare task %d on CPU %d\n", 
+        TRACE("[%d] part edf: prepare task %d on CPU %d\n", 
                 smp_processor_id(), t->pid, get_partition(t));
         if (t->state == TASK_STOPPED) {
                 __setscheduler(t, SCHED_FIFO, MAX_RT_PRIO - 1);
@@ -221,7 +222,7 @@ static void part_edf_wake_up_task(struct task_struct *task)
 {
         edf_domain_t* edf;
 
-        edf = remote_edf(get_partition(task));
+        edf = task_edf(task);
 
         /* We must determine whether task should go into the release       
          * queue or into the ready queue. It may enter the ready queue 
@@ -265,8 +266,7 @@ static void part_edf_task_blocks(struct task_struct *t)
          *       SIGSTOP.
          */
         TRACE("task %d blocks with budget=%d\n", t->pid, t->time_slice);
-        BUG_ON(t->rt_list.next != LIST_POISON1);
-        BUG_ON(t->rt_list.prev != LIST_POISON2);
+        BUG_ON(in_list(&t->rt_list));
 }
 
 
@@ -279,15 +279,14 @@ static long part_edf_tear_down(struct task_struct * t)
         BUG_ON(!is_realtime(t));
         TRACE("part edf: tear down called for %d \n", t->pid);
         BUG_ON(t->array);
-        BUG_ON(t->rt_list.next != LIST_POISON1);
-        BUG_ON(t->rt_list.prev != LIST_POISON2);
+        BUG_ON(in_list(&t->rt_list));
         return 0;
 }
 
 
 static int part_edf_mode_change(int new_mode)
 {
-        int                     cpu;
+        int cpu;
 
         if (new_mode == MODE_RT_RUN)
                 for_each_online_cpu(cpu)