2 files changed, 62 insertions, 36 deletions

diff --git a/include/linux/rt_param.h b/include/linux/rt_param.h
index 8936d2c22f..426a929187 100644
--- a/include/linux/rt_param.h
+++ b/include/linux/rt_param.h
@@ -101,14 +101,6 @@ typedef struct task_rt_param {
          */
         unsigned int            subject_to_srp:1;
         
-        /* Ready to receive scheduler  signals? */
-        unsigned int            signal_ready:1;
-
-        /* scheduler signal list head */
-        unsigned int            in_sig_list:1;
-        unsigned int            signal:8;
-        struct list_head        sig_list;
-  
         /* user controlled parameters */
         rt_param_t              basic_params;
 
diff --git a/kernel/litmus.c b/kernel/litmus.c
index 438b2e7942..ee1e09a627 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -499,62 +499,96 @@ asmlinkage int sys_scheduler_setup(int cmd, void __user *parameter)
 {
         int ret = -EINVAL;
 
-        switch (cmd) {          
-        case ENABLE_WEIGHT_CHANGE_SIGNAL:
-                current->rt_param.signal_ready = 1;
-                ret = 0;
-                break;
-        default:
-                ret = curr_sched_plugin->scheduler_setup(cmd, parameter);               
-        };
+        ret = curr_sched_plugin->scheduler_setup(cmd, parameter);                       
 
         return ret;
 }
 
-/* only call with interrupts disabled! */
-void scheduler_signal(struct task_struct *t, unsigned int signo)
+struct sched_sig {
+        struct list_head        list;
+        struct task_struct*     task;
+        unsigned int            signal:31;
+        int                     force:1;
+};
+
+static void __scheduler_signal(struct task_struct *t, unsigned int signo, 
+                               int force)
 {       
+        struct sched_sig* sig;
+        
+        sig = kmalloc(GFP_ATOMIC, sizeof(struct sched_sig));
+        if (!sig) {
+                TRACE_TASK(t, "dropping signal: %u\n", t);
+                return;
+        }
+
         spin_lock(&sched_sig_list_lock);
 
-        if (!t->rt_param.in_sig_list) {
-                get_task_struct(t);
-                t->rt_param.signal = signo;
-                t->rt_param.in_sig_list = 1;
-                list_add(&t->rt_param.sig_list, &sched_sig_list);
-        } else
-                TRACE_TASK(t, "dropping signal: %u\n", t);
+        sig->signal = signo;
+        sig->force  = force;
+        sig->task   = t;
+        get_task_struct(t);
+        list_add(&sig->list, &sched_sig_list);                  
 
         spin_unlock(&sched_sig_list_lock);
 }
 
+void scheduler_signal(struct task_struct *t, unsigned int signo)
+{
+        __scheduler_signal(t, signo, 0);
+}
+
+void force_scheduler_signal(struct task_struct *t, unsigned int signo)
+{
+        __scheduler_signal(t, signo, 1);
+}
+
 void send_scheduler_signals(void)
 {
         unsigned long flags;
         struct list_head *p, *extra;
         struct siginfo info;
+        struct sched_sig* sig;
         struct task_struct* t;
-/*
+        struct list_head claimed;
+        
         if (spin_trylock_irqsave(&sched_sig_list_lock, flags)) {
+                if (list_empty(&sched_sig_list))
+                        p = NULL;
+                else {
+                        p = sched_sig_list.next;
+                        list_del(&sched_sig_list);
+                        INIT_LIST_HEAD(&sched_sig_list);
+                }
+                spin_unlock_irqrestore(&sched_sig_list_lock, flags);
+
+                /* abort if there are no signals */
+                if (!p)
+                        return;
 
-                list_for_each_safe(p, extra, &sched_sig_list) {
+                /* take signal list we just obtained */
+                list_add(&claimed, p);
+
+                list_for_each_safe(p, extra, &claimed) {
                         list_del(p);
-                        t = list_entry(p, struct task_struct, 
-                                       rt_param.sig_list);
-                        t->rt_param.in_sig_list = 0;
-                        info.si_signo = t->rt_param.signal;
+                        sig = list_entry(p, struct sched_sig, list);
+                        t = sig->task;
+                        info.si_signo = sig->signal;
                         info.si_errno = 0;
                         info.si_code  = SI_KERNEL;
                         info.si_pid   = 1;
                         info.si_uid   = 0;
                         TRACE("sending signal %d to %d\n", info.si_signo, 
                               t->pid);
-                        force_sig_info(t->rt_param.signal, &info, t);
+                        if (sig->force)
+                                force_sig_info(sig->signal, &info, t);
+                        else
+                                send_sig_info(sig->signal, &info, t);
                         put_task_struct(t);
+                        kfree(sig);
                 }
-                
-                spin_unlock_irqrestore(&sched_sig_list_lock, flags);
         }
-*/
+
 }
 
 static inline void np_mem_error(struct task_struct* t, const char* reason)
@@ -562,7 +596,7 @@ static inline void np_mem_error(struct task_struct* t, const char* reason)
         if (t->state != TASK_DEAD && !(t->flags & PF_EXITING)) {
                 TRACE("np section: %s => %s/%d killed\n", 
                       reason, t->comm, t->pid);
-                scheduler_signal(t, SIGKILL);
+                force_scheduler_signal(t, SIGKILL);
         }
 }