make klmirqd work like aux tasks. checkpoint.

this code is untested!

1 files changed, 514 insertions, 946 deletions

diff --git a/litmus/litmus_softirq.c b/litmus/litmus_softirq.c
index 73a3053e662b..44e2d38ad982 100644
--- a/litmus/litmus_softirq.c
+++ b/litmus/litmus_softirq.c
@@ -18,10 +18,6 @@
 
 /* TODO: Remove unneeded mb() and other barriers. */
 
-
-/* counts number of daemons ready to handle litmus irqs. */
-static atomic_t num_ready_klmirqds = ATOMIC_INIT(0);
-
 enum pending_flags
 {
     LIT_TASKLET_LOW = 0x1,
@@ -29,35 +25,313 @@ enum pending_flags
         LIT_WORK = LIT_TASKLET_HI<<1
 };
 
-/* only support tasklet processing for now. */
-struct tasklet_head
+struct klmirqd_registration
 {
-        struct tasklet_struct *head;
-        struct tasklet_struct **tail;
+        raw_spinlock_t lock;
+        u32 nr_threads;
+        unsigned int initialized:1;
+        unsigned int shuttingdown:1;
+        struct list_head threads;
 };
 
-struct klmirqd_info
+static atomic_t klmirqd_id_gen = ATOMIC_INIT(0);
+
+static struct klmirqd_registration klmirqd_state;
+
+
+
+void init_klmirqd(void)
+{
+        raw_spin_lock_init(&klmirqd_state.lock);
+
+        klmirqd_state.nr_threads = 0;
+        klmirqd_state.initialized = 1;
+        klmirqd_state.shuttingdown = 0;
+        INIT_LIST_HEAD(&klmirqd_state.threads);
+}
+
+static int __klmirqd_is_ready(void)
+{
+        return (klmirqd_state.initialized == 1 && klmirqd_state.shuttingdown == 0);
+}
+
+int klmirqd_is_ready(void)
+{
+        unsigned long flags;
+        int ret;
+
+        raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
+    ret = __klmirqd_is_ready();
+    raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
+
+        return ret;
+}
+
+int klmirqd_is_dead(void)
+{
+        return(!klmirqd_is_ready());
+}
+
+
+void kill_klmirqd(void)
+{
+        if(!klmirqd_is_dead())
+        {
+                unsigned long flags;
+                struct list_head *pos;
+
+                raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
+
+                TRACE("%s: Killing all klmirqd threads! (%d of them)\n", __FUNCTION__, klmirqd_state.nr_threads);
+
+                klmirqd_state.shuttingdown = 1;
+
+                list_for_each(pos, &klmirqd_state.threads) {
+                        struct klmirqd_info* info = list_entry(pos, struct klmirqd_info, klmirqd_reg);
+
+                        if(info->terminating != 1)
+                        {
+                                info->terminating = 1;
+                                mb(); /* just to be sure? */
+                                flush_pending(info->klmirqd);
+
+                                /* signal termination */
+                                kthread_stop(info->klmirqd);
+                        }
+                }
+
+                raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
+        }
+}
+
+
+
+void kill_klmirqd_thread(struct task_struct* klmirqd_thread)
 {
-        struct task_struct*             klmirqd;
-    struct task_struct*     current_owner;
-    int                                         terminating;
+        unsigned long flags;
+        struct klmirqd_info* info;
 
+        if (!tsk_rt(klmirqd_thread)->is_interrupt_thread) {
+                TRACE("%s/%d is not a klmirqd thread\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                return;
+        }
+
+        TRACE("%s: Killing klmirqd thread %s/%d\n", __FUNCTION__, klmirqd_thread->comm, klmirqd_thread->pid);
 
-        raw_spinlock_t                  lock;
+        raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
 
-        u32                                             pending;
-        atomic_t                                num_hi_pending;
-        atomic_t                                num_low_pending;
-        atomic_t                                num_work_pending;
+        info = tsk_rt(klmirqd_thread)->klmirqd_info;
+
+        if(info->terminating != 1) {
+                info->terminating = 1;
+                mb();
+
+                flush_pending(klmirqd_thread);
+                kthread_stop(klmirqd_thread);
+        }
+
+        raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
+}
 
-        /* in order of priority */
-        struct tasklet_head     pending_tasklets_hi;
-        struct tasklet_head             pending_tasklets;
-        struct list_head                worklist;
+
+
+struct klmirqd_launch_data
+{
+        int cpu_affinity;
+        klmirqd_callback_t* cb;
+        struct work_struct work;
 };
 
-/* one list for each klmirqd */
-static struct klmirqd_info klmirqds[NR_LITMUS_SOFTIRQD];
+static int run_klmirqd(void* callback);
+
+
+/* executed by a kworker from workqueues */
+static void __launch_klmirqd_thread(struct work_struct *work)
+{
+        int id;
+        struct task_struct* thread = NULL;
+        struct klmirqd_launch_data* launch_data =
+                container_of(work, struct klmirqd_launch_data, work);
+
+    TRACE("%s: Creating klmirqd thread\n", __FUNCTION__);
+
+        id = atomic_inc_return(&klmirqd_id_gen);
+
+        if (launch_data->cpu_affinity != -1) {
+                thread = kthread_create(
+                                        run_klmirqd,
+                                        /* treat the affinity as a pointer, we'll cast it back later */
+                                        (void*)launch_data->cb,
+                                        "klmirqd_th%d/%d",
+                                        id,
+                                        launch_data->cpu_affinity);
+
+                /* litmus will put is in the right cluster. */
+                kthread_bind(thread, launch_data->cpu_affinity);
+
+                TRACE("%s: Launching klmirqd_th%d/%d\n", __FUNCTION__, id, launch_data->cpu_affinity);
+        }
+        else {
+                thread = kthread_create(
+                                        run_klmirqd,
+                                        /* treat the affinity as a pointer, we'll cast it back later */
+                                        (void*)launch_data->cb,
+                                        "klmirqd_th%d",
+                                        id);
+
+                TRACE("%s: Launching klmirqd_th%d\n", __FUNCTION__, id);
+        }
+
+        if (thread) {
+                wake_up_process(thread);
+        }
+        else {
+                TRACE("Could not create klmirqd/%d thread!\n", id);
+        }
+
+        kfree(launch_data);
+}
+
+
+int launch_klmirqd_thread(int cpu, klmirqd_callback_t* cb)
+{
+    struct klmirqd_launch_data* delayed_launch;
+
+        if (!klmirqd_is_ready()) {
+                TRACE("klmirqd is not ready.  Check that it was initialized!\n");
+                return -1;
+        }
+
+    /* tell a work queue to launch the threads.  we can't make scheduling
+         calls since we're in an atomic state. */
+        delayed_launch = kmalloc(sizeof(struct klmirqd_launch_data), GFP_ATOMIC);
+        delayed_launch->cpu_affinity = cpu;
+        delayed_launch->cb = cb;
+    INIT_WORK(&delayed_launch->work, __launch_klmirqd_thread);
+    schedule_work(&delayed_launch->work);
+
+        return 0;
+}
+
+
+
+
+#define KLMIRQD_SLICE_NR_JIFFIES 1
+#define KLMIRQD_SLICE_NS ((NSEC_PER_SEC / HZ) * KLMIRQD_SLICE_NR_JIFFIES)
+
+static int set_litmus_daemon_sched(struct task_struct* tsk)
+{
+    int ret = 0;
+
+        struct rt_task tp = {
+                .period = KLMIRQD_SLICE_NS, /* dummy 1 second period */
+                .relative_deadline = KLMIRQD_SLICE_NS,
+                .exec_cost = KLMIRQD_SLICE_NS,
+                .phase = 0,
+                .cpu = task_cpu(current),
+                .budget_policy = NO_ENFORCEMENT,
+                .budget_signal_policy = NO_SIGNALS,
+                .cls = RT_CLASS_BEST_EFFORT
+        };
+
+        struct sched_param param = { .sched_priority = 0};
+
+        TRACE_CUR("Setting %s/%d as daemon thread.\n", tsk->comm, tsk->pid);
+
+        /* set task params */
+        tsk_rt(tsk)->task_params = tp;
+        tsk_rt(tsk)->is_interrupt_thread = 1;
+
+        /* inform the OS we're SCHED_LITMUS --
+         sched_setscheduler_nocheck() calls litmus_admit_task(). */
+        sched_setscheduler_nocheck(tsk, SCHED_LITMUS, &param);
+
+    return ret;
+}
+
+static int register_klmirqd(struct task_struct* tsk)
+{
+        int retval = 0;
+        unsigned long flags;
+        struct klmirqd_info *info = NULL;
+
+        if (!tsk_rt(tsk)->is_interrupt_thread) {
+                TRACE("Only proxy threads already running in Litmus may become klmirqd threads!\n");
+                WARN_ON(1);
+                retval = -1;
+                goto out;
+        }
+
+        raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
+
+        if (!__klmirqd_is_ready()) {
+                TRACE("klmirqd is not ready! Did you forget to initialize it?\n");
+                WARN_ON(1);
+                retval = -1;
+                goto out_unlock;
+        }
+
+        /* allocate and initialize klmirqd data for the thread */
+        info = kmalloc(sizeof(struct klmirqd_info), GFP_KERNEL);
+        if (!info) {
+                TRACE("Failed to allocate klmirqd_info struct!\n");
+                retval = -1; /* todo: pick better code */
+                goto out_unlock;
+        }
+        memset(info, 0, sizeof(struct klmirqd_info));
+        info->klmirqd = tsk;
+        info->pending_tasklets_hi.tail = &info->pending_tasklets_hi.head;
+        info->pending_tasklets.tail = &info->pending_tasklets.head;
+        INIT_LIST_HEAD(&info->worklist);
+        INIT_LIST_HEAD(&info->klmirqd_reg);
+        raw_spin_lock_init(&info->lock);
+
+
+        /* now register with klmirqd */
+        list_add_tail(&info->klmirqd_reg, &klmirqd_state.threads);
+        ++klmirqd_state.nr_threads;
+
+        /* update the task struct to point to klmirqd info */
+        tsk_rt(tsk)->klmirqd_info = info;
+
+out_unlock:
+        raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
+
+out:
+        return retval;
+}
+
+static int unregister_klmirqd(struct task_struct* tsk)
+{
+        int retval = 0;
+        unsigned long flags;
+        struct klmirqd_info *info = tsk_rt(tsk)->klmirqd_info;
+
+        if (!tsk_rt(tsk)->is_interrupt_thread || !info) {
+                TRACE("%s/%d is not a klmirqd thread!\n", tsk->comm, tsk->pid);
+                WARN_ON(1);
+                retval = -1;
+                goto out;
+        }
+
+        raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
+
+        /* remove the entry in the klmirqd thread list */
+        list_del(&info->klmirqd_reg);
+        --klmirqd_state.nr_threads;
+
+        /* remove link to klmirqd info from thread */
+        tsk_rt(tsk)->klmirqd_info = NULL;
+
+        /* clean up memory */
+        kfree(info);
+
+        raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
+
+out:
+        return retval;
+}
+
 
 
 
@@ -67,35 +341,50 @@ int proc_read_klmirqd_stats(char *page, char **start,
                                                          off_t off, int count,
                                                          int *eof, void *data)
 {
-        int len = snprintf(page, PAGE_SIZE,
-                                "num ready klmirqds: %d\n\n",
-                                atomic_read(&num_ready_klmirqds));
-
-        if(klmirqd_is_ready())
-        {
-                int i;
-                for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-                {
-                        len +=
-                                snprintf(page + len - 1, PAGE_SIZE, /* -1 to strip off \0 */
-                                                 "klmirqd_th%d: %s/%d\n"
-                                                 "\tcurrent_owner: %s/%d\n"
-                                                 "\tpending: %x\n"
-                                                 "\tnum hi: %d\n"
-                                                 "\tnum low: %d\n"
-                                                 "\tnum work: %d\n\n",
-                                                 i,
-                                                 klmirqds[i].klmirqd->comm, klmirqds[i].klmirqd->pid,
-                                                 (klmirqds[i].current_owner != NULL) ?
-                                                        klmirqds[i].current_owner->comm : "(null)",
-                                                 (klmirqds[i].current_owner != NULL) ?
-                                                        klmirqds[i].current_owner->pid : 0,
-                                                 klmirqds[i].pending,
-                                                 atomic_read(&klmirqds[i].num_hi_pending),
-                                                 atomic_read(&klmirqds[i].num_low_pending),
-                                                 atomic_read(&klmirqds[i].num_work_pending));
+        unsigned long flags;
+        int len;
+
+        raw_spin_lock_irqsave(&klmirqd_state.lock, flags);
+
+        if (klmirqd_state.initialized) {
+                if (!klmirqd_state.shuttingdown) {
+                        struct list_head *pos;
+
+                        len = snprintf(page, PAGE_SIZE,
+                                                   "num ready klmirqds: %d\n\n",
+                                                   klmirqd_state.nr_threads);
+
+                        list_for_each(pos, &klmirqd_state.threads) {
+                                struct klmirqd_info* info = list_entry(pos, struct klmirqd_info, klmirqd_reg);
+
+                                len +=
+                                        snprintf(page + len - 1, PAGE_SIZE, /* -1 to strip off \0 */
+                                                         "klmirqd_thread: %s/%d\n"
+                                                         "\tcurrent_owner: %s/%d\n"
+                                                         "\tpending: %x\n"
+                                                         "\tnum hi: %d\n"
+                                                         "\tnum low: %d\n"
+                                                         "\tnum work: %d\n\n",
+                                                         info->klmirqd->comm, info->klmirqd->pid,
+                                                         (info->current_owner != NULL) ?
+                                                                info->current_owner->comm : "(null)",
+                                                         (info->current_owner != NULL) ?
+                                                                info->current_owner->pid : 0,
+                                                         info->pending,
+                                                         atomic_read(&info->num_hi_pending),
+                                                         atomic_read(&info->num_low_pending),
+                                                         atomic_read(&info->num_work_pending));
+                        }
+                }
+                else {
+                        len = snprintf(page, PAGE_SIZE, "klmirqd is shutting down\n");
                 }
         }
+        else {
+                len = snprintf(page, PAGE_SIZE, "klmirqd is not initialized!\n");
+        }
+
+        raw_spin_unlock_irqrestore(&klmirqd_state.lock, flags);
 
         return(len);
 }
@@ -162,6 +451,15 @@ static void dump_state(struct klmirqd_info* which, const char* caller)
 #endif
 
 
+
+
+
+
+
+
+
+
+
 /* forward declarations */
 static void ___litmus_tasklet_schedule(struct tasklet_struct *t,
                                                                            struct klmirqd_info *which,
@@ -174,24 +472,6 @@ static void ___litmus_schedule_work(struct work_struct *w,
                                                                         int wakeup);
 
 
-
-inline unsigned int klmirqd_id(struct task_struct* tsk)
-{
-    int i;
-    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-    {
-        if(klmirqds[i].klmirqd == tsk)
-        {
-            return i;
-        }
-    }
-
-    BUG();
-
-    return 0;
-}
-
-
 inline static u32 litirq_pending_hi_irqoff(struct klmirqd_info* which)
 {
     return (which->pending & LIT_TASKLET_HI);
@@ -225,200 +505,11 @@ inline static u32 litirq_pending(struct klmirqd_info* which)
     return pending;
 };
 
-inline static u32 litirq_pending_with_owner(struct klmirqd_info* which, struct task_struct* owner)
-{
-        unsigned long flags;
-        u32 pending;
-
-        raw_spin_lock_irqsave(&which->lock, flags);
-        pending = litirq_pending_irqoff(which);
-        if(pending)
-        {
-                if(which->current_owner != owner)
-                {
-                        pending = 0;  // owner switch!
-                }
-        }
-        raw_spin_unlock_irqrestore(&which->lock, flags);
-
-        return pending;
-}
-
-
-inline static u32 litirq_pending_and_sem_and_owner(struct klmirqd_info* which,
-                                struct mutex** sem,
-                                struct task_struct** t)
-{
-        unsigned long flags;
-        u32 pending;
-
-        /* init values */
-        *sem = NULL;
-        *t = NULL;
-
-        raw_spin_lock_irqsave(&which->lock, flags);
-
-        pending = litirq_pending_irqoff(which);
-        if(pending)
-        {
-                if(which->current_owner != NULL)
-                {
-                        *t = which->current_owner;
-                        *sem = &tsk_rt(which->current_owner)->klmirqd_sem;
-                }
-                else
-                {
-                        BUG();
-                }
-        }
-        raw_spin_unlock_irqrestore(&which->lock, flags);
-
-        if(likely(*sem))
-        {
-                return pending;
-        }
-        else
-        {
-                return 0;
-        }
-}
-
-/* returns true if the next piece of work to do is from a different owner.
- */
-static int tasklet_ownership_change(
-                                struct klmirqd_info* which,
-                                enum pending_flags taskletQ)
-{
-        /* this function doesn't have to look at work objects since they have
-           priority below tasklets. */
-
-    unsigned long flags;
-    int ret = 0;
-
-    raw_spin_lock_irqsave(&which->lock, flags);
-
-        switch(taskletQ)
-        {
-        case LIT_TASKLET_HI:
-                if(litirq_pending_hi_irqoff(which))
-                {
-                        ret = (which->pending_tasklets_hi.head->owner !=
-                                                which->current_owner);
-                }
-                break;
-        case LIT_TASKLET_LOW:
-                if(litirq_pending_low_irqoff(which))
-                {
-                        ret = (which->pending_tasklets.head->owner !=
-                                                which->current_owner);
-                }
-                break;
-        default:
-                break;
-        }
-
-    raw_spin_unlock_irqrestore(&which->lock, flags);
-
-    TRACE_TASK(which->klmirqd, "ownership change needed: %d\n", ret);
-
-    return ret;
-}
-
-
-static void __reeval_prio(struct klmirqd_info* which)
-{
-    struct task_struct* next_owner = NULL;
-        struct task_struct* klmirqd = which->klmirqd;
-
-        /* Check in prio-order */
-        u32 pending = litirq_pending_irqoff(which);
-
-        //__dump_state(which, "__reeval_prio: before");
-
-        if(pending)
-        {
-                if(pending & LIT_TASKLET_HI)
-                {
-                        next_owner = which->pending_tasklets_hi.head->owner;
-                }
-                else if(pending & LIT_TASKLET_LOW)
-                {
-                        next_owner = which->pending_tasklets.head->owner;
-                }
-                else if(pending & LIT_WORK)
-                {
-                        struct work_struct* work =
-                                list_first_entry(&which->worklist, struct work_struct, entry);
-                        next_owner = work->owner;
-                }
-        }
-
-        if(next_owner != which->current_owner)
-        {
-                struct task_struct* old_owner = which->current_owner;
-
-                /* bind the next owner. */
-                which->current_owner = next_owner;
-                mb();
-
-        if(next_owner != NULL)
-        {
-                        if(!in_interrupt())
-                        {
-                                TRACE_CUR("%s: Ownership change: %s/%d to %s/%d\n", __FUNCTION__,
-                                                ((tsk_rt(klmirqd)->inh_task) ? tsk_rt(klmirqd)->inh_task : klmirqd)->comm,
-                                                ((tsk_rt(klmirqd)->inh_task) ? tsk_rt(klmirqd)->inh_task : klmirqd)->pid,
-                                                next_owner->comm, next_owner->pid);
-                        }
-                        else
-                        {
-                                TRACE("%s: Ownership change: %s/%d to %s/%d\n", __FUNCTION__,
-                                        ((tsk_rt(klmirqd)->inh_task) ? tsk_rt(klmirqd)->inh_task : klmirqd)->comm,
-                                        ((tsk_rt(klmirqd)->inh_task) ? tsk_rt(klmirqd)->inh_task : klmirqd)->pid,
-                                        next_owner->comm, next_owner->pid);
-                        }
-
-                        litmus->increase_prio_inheritance_klmirqd(klmirqd, old_owner, next_owner);
-        }
-        else
-        {
-                        if(likely(!in_interrupt()))
-                        {
-                                TRACE_CUR("%s: Ownership change: %s/%d to NULL (reverting)\n",
-                                                __FUNCTION__, klmirqd->comm, klmirqd->pid);
-                        }
-                        else
-                        {
-                                // is this a bug?
-                                TRACE("%s: Ownership change: %s/%d to NULL (reverting)\n",
-                                        __FUNCTION__, klmirqd->comm, klmirqd->pid);
-                        }
-
-                        BUG_ON(pending != 0);
-                        litmus->decrease_prio_inheritance_klmirqd(klmirqd, old_owner, NULL);
-        }
-    }
-
-        //__dump_state(which, "__reeval_prio: after");
-}
-
-static void reeval_prio(struct klmirqd_info* which)
-{
-    unsigned long flags;
-
-    raw_spin_lock_irqsave(&which->lock, flags);
-    __reeval_prio(which);
-    raw_spin_unlock_irqrestore(&which->lock, flags);
-}
-
-
 static void wakeup_litirqd_locked(struct klmirqd_info* which)
 {
         /* Interrupts are disabled: no need to stop preemption */
         if (which && which->klmirqd)
         {
-        __reeval_prio(which); /* configure the proper priority */
-
         if(which->klmirqd->state != TASK_RUNNING)
         {
             TRACE("%s: Waking up klmirqd: %s/%d\n", __FUNCTION__,
@@ -468,7 +559,7 @@ static void do_lit_tasklet(struct klmirqd_info* which,
                 list = list->next;
 
         /* execute tasklet if it has my priority and is free */
-                if ((t->owner == which->current_owner) && tasklet_trylock(t)) {
+                if (tasklet_trylock(t)) {
                         if (!atomic_read(&t->count)) {
 
                                 sched_trace_tasklet_begin(t->owner);
@@ -503,15 +594,14 @@ static void do_lit_tasklet(struct klmirqd_info* which,
 
 // returns 1 if priorities need to be changed to continue processing
 // pending tasklets.
-static int do_litirq(struct klmirqd_info* which)
+static void do_litirq(struct klmirqd_info* which)
 {
     u32 pending;
-    int resched = 0;
 
     if(in_interrupt())
     {
         TRACE("%s: exiting early: in interrupt context!\n", __FUNCTION__);
-        return(0);
+                return;
     }
 
         if(which->klmirqd != current)
@@ -519,59 +609,40 @@ static int do_litirq(struct klmirqd_info* which)
         TRACE_CUR("%s: exiting early: thread/info mismatch! Running %s/%d but given %s/%d.\n",
                                   __FUNCTION__, current->comm, current->pid,
                                   which->klmirqd->comm, which->klmirqd->pid);
-        return(0);
+        return;
         }
 
     if(!is_realtime(current))
     {
         TRACE_CUR("%s: exiting early: klmirqd is not real-time. Sched Policy = %d\n",
                                   __FUNCTION__, current->policy);
-        return(0);
+                return;
     }
 
 
     /* We only handle tasklets & work objects, no need for RCU triggers? */
 
     pending = litirq_pending(which);
-    if(pending)
-    {
+    if(pending) {
         /* extract the work to do and do it! */
-        if(pending & LIT_TASKLET_HI)
-        {
+        if(pending & LIT_TASKLET_HI) {
             TRACE_CUR("%s: Invoking HI tasklets.\n", __FUNCTION__);
             do_lit_tasklet(which, &which->pending_tasklets_hi);
-            resched = tasklet_ownership_change(which, LIT_TASKLET_HI);
-
-            if(resched)
-            {
-                TRACE_CUR("%s: HI tasklets of another owner remain. "
-                                                  "Skipping any LOW tasklets.\n", __FUNCTION__);
-            }
         }
 
-        if(!resched && (pending & LIT_TASKLET_LOW))
-        {
+        if(pending & LIT_TASKLET_LOW) {
             TRACE_CUR("%s: Invoking LOW tasklets.\n", __FUNCTION__);
                         do_lit_tasklet(which, &which->pending_tasklets);
-                        resched = tasklet_ownership_change(which, LIT_TASKLET_LOW);
-
-            if(resched)
-            {
-                TRACE_CUR("%s: LOW tasklets of another owner remain. "
-                                                  "Skipping any work objects.\n", __FUNCTION__);
-            }
         }
     }
-
-        return(resched);
 }
 
 
 static void do_work(struct klmirqd_info* which)
 {
         unsigned long flags;
-        work_func_t f;
         struct work_struct* work;
+        work_func_t f;
 
         // only execute one work-queue item to yield to tasklets.
         // ...is this a good idea, or should we just batch them?
@@ -594,125 +665,58 @@ static void do_work(struct klmirqd_info* which)
         raw_spin_unlock_irqrestore(&which->lock, flags);
 
 
+        TRACE_CUR("%s: Invoking work object.\n", __FUNCTION__);
+        // do the work!
+        work_clear_pending(work);
+        f = work->func;
+        f(work);  /* can't touch 'work' after this point,
+                           the user may have freed it. */
 
-        /* safe to read current_owner outside of lock since only this thread
-         may write to the pointer. */
-        if(work->owner == which->current_owner)
-        {
-                TRACE_CUR("%s: Invoking work object.\n", __FUNCTION__);
-                // do the work!
-                work_clear_pending(work);
-                f = work->func;
-                f(work);  /* can't touch 'work' after this point,
-                                   the user may have freed it. */
-
-                atomic_dec(&which->num_work_pending);
-        }
-        else
-        {
-                TRACE_CUR("%s: Could not invoke work object.  Requeuing.\n",
-                                  __FUNCTION__);
-                ___litmus_schedule_work(work, which, 0);
-        }
+        atomic_dec(&which->num_work_pending);
 
 no_work:
         return;
 }
 
 
-static int set_litmus_daemon_sched(void)
-{
-    /* set up a daemon job that will never complete.
-       it should only ever run on behalf of another
-       real-time task.
-
-       TODO: Transition to a new job whenever a
-       new tasklet is handled */
-
-    int ret = 0;
-
-        struct rt_task tp = {
-                .exec_cost = 0,
-                .period = 1000000000, /* dummy 1 second period */
-                .phase = 0,
-                .cpu = task_cpu(current),
-                .budget_policy = NO_ENFORCEMENT,
-                .cls = RT_CLASS_BEST_EFFORT
-        };
-
-        struct sched_param param = { .sched_priority = 0};
-
-
-        /* set task params, mark as proxy thread, and init other data */
-        tsk_rt(current)->task_params = tp;
-        tsk_rt(current)->is_proxy_thread = 1;
-        tsk_rt(current)->cur_klmirqd = NULL;
-        mutex_init(&tsk_rt(current)->klmirqd_sem);
-        atomic_set(&tsk_rt(current)->klmirqd_sem_stat, NOT_HELD);
-
-        /* inform the OS we're SCHED_LITMUS --
-           sched_setscheduler_nocheck() calls litmus_admit_task(). */
-        sched_setscheduler_nocheck(current, SCHED_LITMUS, &param);
-
-    return ret;
-}
-
-static void enter_execution_phase(struct klmirqd_info* which,
-                                                                  struct mutex* sem,
-                                                                  struct task_struct* t)
-{
-        TRACE_CUR("%s: Trying to enter execution phase. "
-                          "Acquiring semaphore of %s/%d\n", __FUNCTION__,
-                          t->comm, t->pid);
-        down_and_set_stat(current, HELD, sem);
-        TRACE_CUR("%s: Execution phase entered! "
-                          "Acquired semaphore of %s/%d\n", __FUNCTION__,
-                          t->comm, t->pid);
-}
-
-static void exit_execution_phase(struct klmirqd_info* which,
-                                                                 struct mutex* sem,
-                                                                 struct task_struct* t)
-{
-        TRACE_CUR("%s: Exiting execution phase. "
-                          "Releasing semaphore of %s/%d\n", __FUNCTION__,
-                          t->comm, t->pid);
-        if(atomic_read(&tsk_rt(current)->klmirqd_sem_stat) == HELD)
-        {
-                up_and_set_stat(current, NOT_HELD, sem);
-                TRACE_CUR("%s: Execution phase exited! "
-                                  "Released semaphore of %s/%d\n", __FUNCTION__,
-                                  t->comm, t->pid);
-        }
-        else
-        {
-                TRACE_CUR("%s: COULDN'T RELEASE SEMAPHORE BECAUSE ONE IS NOT HELD!\n", __FUNCTION__);
-        }
-}
 
 /* main loop for klitsoftirqd */
-static int run_klmirqd(void* unused)
+static int run_klmirqd(void* callback)
 {
-        struct klmirqd_info* which = &klmirqds[klmirqd_id(current)];
-        struct mutex* sem;
-        struct task_struct* owner;
+    int retval = 0;
+        struct klmirqd_info* info = NULL;
+        klmirqd_callback_t* cb = (klmirqd_callback_t*)(callback);
 
-    int rt_status = set_litmus_daemon_sched();
-
-    if(rt_status != 0)
-    {
+        retval = set_litmus_daemon_sched(current);
+    if (retval != 0) {
         TRACE_CUR("%s: Failed to transition to rt-task.\n", __FUNCTION__);
-        goto rt_failed;
+        goto failed;
     }
 
-        atomic_inc(&num_ready_klmirqds);
+        retval = register_klmirqd(current);
+        if (retval != 0) {
+                TRACE_CUR("%s: Failed to become a klmirqd thread.\n", __FUNCTION__);
+                goto failed;
+        }
+
+        if (cb && cb->func) {
+                retval = cb->func(cb->arg);
+                if (retval != 0) {
+                        TRACE_CUR("%s: klmirqd callback reported failure. retval = %d\n", __FUNCTION__, retval);
+                        goto failed_unregister;
+                }
+        }
+
+        /* enter the interrupt handling workloop */
+
+        info = tsk_rt(current)->klmirqd_info;
 
         set_current_state(TASK_INTERRUPTIBLE);
 
         while (!kthread_should_stop())
         {
                 preempt_disable();
-                if (!litirq_pending(which))
+                if (!litirq_pending(info))
                 {
             /* sleep for work */
             TRACE_CUR("%s: No more tasklets or work objects. Going to sleep.\n",
@@ -731,17 +735,10 @@ static int run_klmirqd(void* unused)
 
                 __set_current_state(TASK_RUNNING);
 
-                while (litirq_pending_and_sem_and_owner(which, &sem, &owner))
+                while (litirq_pending(info))
                 {
-                        int needs_resched = 0;
-
                         preempt_enable_no_resched();
 
-                        BUG_ON(sem == NULL);
-
-                        // wait to enter execution phase; wait for 'current_owner' to block.
-                        enter_execution_phase(which, sem, owner);
-
                         if(kthread_should_stop())
                         {
                                 TRACE_CUR("%s:%d: Signaled to terminate.\n", __FUNCTION__, __LINE__);
@@ -753,36 +750,23 @@ static int run_klmirqd(void* unused)
                         /* Double check that there's still pending work and the owner hasn't
                          * changed. Pending items may have been flushed while we were sleeping.
                          */
-                        if(litirq_pending_with_owner(which, owner))
+                        if(litirq_pending(info))
                         {
                                 TRACE_CUR("%s: Executing tasklets and/or work objects.\n",
                                                   __FUNCTION__);
 
-                                needs_resched = do_litirq(which);
+                                do_litirq(info);
 
                                 preempt_enable_no_resched();
 
                                 // work objects are preemptible.
-                                if(!needs_resched)
-                                {
-                                        do_work(which);
-                                }
-
-                                // exit execution phase.
-                                exit_execution_phase(which, sem, owner);
-
-                                TRACE_CUR("%s: Setting up next priority.\n", __FUNCTION__);
-                                reeval_prio(which); /* check if we need to change priority here */
+                                do_work(info);
                         }
                         else
                         {
-                                TRACE_CUR("%s: Pending work was flushed!  Prev owner was %s/%d\n",
-                                                                __FUNCTION__,
-                                                                owner->comm, owner->pid);
-                                preempt_enable_no_resched();
+                                TRACE_CUR("%s: Pending work was flushed!\n", __FUNCTION__);
 
-                                // exit execution phase.
-                                exit_execution_phase(which, sem, owner);
+                                preempt_enable_no_resched();
                         }
 
                         cond_resched();
@@ -793,183 +777,39 @@ static int run_klmirqd(void* unused)
         }
         __set_current_state(TASK_RUNNING);
 
-        atomic_dec(&num_ready_klmirqds);
+failed_unregister:
+        /* remove our registration from klmirqd */
+        unregister_klmirqd(current);
 
-rt_failed:
+failed:
     litmus_exit_task(current);
 
-        return rt_status;
+        return retval;
 }
 
 
-struct klmirqd_launch_data
-{
-        int* cpu_affinity;
-        struct work_struct work;
-};
-
-/* executed by a kworker from workqueues */
-static void launch_klmirqd(struct work_struct *work)
+void flush_pending(struct task_struct* tsk)
 {
-    int i;
-
-        struct klmirqd_launch_data* launch_data =
-                container_of(work, struct klmirqd_launch_data, work);
-
-    TRACE("%s: Creating %d klmirqds\n", __FUNCTION__, NR_LITMUS_SOFTIRQD);
-
-    /* create the daemon threads */
-    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-    {
-                if(launch_data->cpu_affinity)
-                {
-                        klmirqds[i].klmirqd =
-                                kthread_create(
-                                   run_klmirqd,
-                                   /* treat the affinity as a pointer, we'll cast it back later */
-                                   (void*)(long long)launch_data->cpu_affinity[i],
-                                   "klmirqd_th%d/%d",
-                                   i,
-                                   launch_data->cpu_affinity[i]);
-
-                        /* litmus will put is in the right cluster. */
-                        kthread_bind(klmirqds[i].klmirqd, launch_data->cpu_affinity[i]);
-                }
-                else
-                {
-                        klmirqds[i].klmirqd =
-                                kthread_create(
-                                   run_klmirqd,
-                                   /* treat the affinity as a pointer, we'll cast it back later */
-                                   (void*)(long long)(-1),
-                                   "klmirqd_th%d",
-                                   i);
-                }
-    }
-
-    TRACE("%s: Launching %d klmirqds\n", __FUNCTION__, NR_LITMUS_SOFTIRQD);
-
-    /* unleash the daemons */
-    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-    {
-        wake_up_process(klmirqds[i].klmirqd);
-    }
-
-        if(launch_data->cpu_affinity)
-                kfree(launch_data->cpu_affinity);
-        kfree(launch_data);
-}
+        unsigned long flags;
+        struct tasklet_struct *list;
+        u32 work_flushed = 0;
 
+        struct klmirqd_info *which;
 
-void spawn_klmirqd(int* affinity)
-{
-    int i;
-    struct klmirqd_launch_data* delayed_launch;
-
-        if(atomic_read(&num_ready_klmirqds) != 0)
-        {
-                TRACE("%s: At least one klmirqd is already running! Need to call kill_klmirqd()?\n");
+        if (!tsk_rt(tsk)->is_interrupt_thread) {
+                TRACE("%s/%d is not a proxy thread\n", tsk->comm, tsk->pid);
+                WARN_ON(1);
                 return;
         }
 
-    /* init the tasklet & work queues */
-    for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-    {
-                klmirqds[i].terminating = 0;
-                klmirqds[i].pending = 0;
-
-                klmirqds[i].num_hi_pending.counter = 0;
-                klmirqds[i].num_low_pending.counter = 0;
-                klmirqds[i].num_work_pending.counter = 0;
-
-        klmirqds[i].pending_tasklets_hi.head = NULL;
-        klmirqds[i].pending_tasklets_hi.tail = &klmirqds[i].pending_tasklets_hi.head;
-
-        klmirqds[i].pending_tasklets.head = NULL;
-        klmirqds[i].pending_tasklets.tail = &klmirqds[i].pending_tasklets.head;
-
-                INIT_LIST_HEAD(&klmirqds[i].worklist);
-
-                raw_spin_lock_init(&klmirqds[i].lock);
-    }
-
-    /* wait to flush the initializations to memory since other threads
-       will access it. */
-    mb();
-
-    /* tell a work queue to launch the threads.  we can't make scheduling
-       calls since we're in an atomic state. */
-    TRACE("%s: Setting callback up to launch klmirqds\n", __FUNCTION__);
-        delayed_launch = kmalloc(sizeof(struct klmirqd_launch_data), GFP_ATOMIC);
-        if(affinity)
-        {
-                delayed_launch->cpu_affinity =
-                        kmalloc(sizeof(int)*NR_LITMUS_SOFTIRQD, GFP_ATOMIC);
-
-                memcpy(delayed_launch->cpu_affinity, affinity,
-                        sizeof(int)*NR_LITMUS_SOFTIRQD);
-        }
-        else
-        {
-                delayed_launch->cpu_affinity = NULL;
-        }
-    INIT_WORK(&delayed_launch->work, launch_klmirqd);
-    schedule_work(&delayed_launch->work);
-}
-
-
-void kill_klmirqd(void)
-{
-        if(!klmirqd_is_dead())
-        {
-        int i;
-
-        TRACE("%s: Killing %d klmirqds\n", __FUNCTION__, NR_LITMUS_SOFTIRQD);
-
-        for(i = 0; i < NR_LITMUS_SOFTIRQD; ++i)
-        {
-                        if(klmirqds[i].terminating != 1)
-                        {
-                                klmirqds[i].terminating = 1;
-                                mb(); /* just to be sure? */
-                                flush_pending(klmirqds[i].klmirqd, NULL);
-
-                                /* signal termination */
-                                kthread_stop(klmirqds[i].klmirqd);
-                        }
-        }
+        which = tsk_rt(tsk)->klmirqd_info;
+        if (!which) {
+                TRACE("%s/%d is not a klmirqd thread!\n", tsk->comm, tsk->pid);
+                WARN_ON(1);
+                return;
         }
-}
 
 
-int klmirqd_is_ready(void)
-{
-        return(atomic_read(&num_ready_klmirqds) == NR_LITMUS_SOFTIRQD);
-}
-
-int klmirqd_is_dead(void)
-{
-        return(atomic_read(&num_ready_klmirqds) == 0);
-}
-
-
-struct task_struct* get_klmirqd(unsigned int k_id)
-{
-        return(klmirqds[k_id].klmirqd);
-}
-
-
-void flush_pending(struct task_struct* klmirqd_thread,
-                                   struct task_struct* owner)
-{
-        unsigned int k_id = klmirqd_id(klmirqd_thread);
-        struct klmirqd_info *which = &klmirqds[k_id];
-
-        unsigned long flags;
-        struct tasklet_struct *list;
-
-        u32 work_flushed = 0;
-
         raw_spin_lock_irqsave(&which->lock, flags);
 
         //__dump_state(which, "flush_pending: before");
@@ -990,35 +830,27 @@ void flush_pending(struct task_struct* klmirqd_thread,
                         struct tasklet_struct *t = list;
                         list = list->next;
 
-                        if(likely((t->owner == owner) || (owner == NULL)))
+                        if(unlikely(!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)))
                         {
-                                if(unlikely(!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)))
-                                {
-                                        BUG();
-                                }
+                                BUG();
+                        }
 
-                                work_flushed |= LIT_TASKLET_HI;
+                        work_flushed |= LIT_TASKLET_HI;
 
-                                t->owner = NULL;
+                        t->owner = NULL;
 
-                                // WTF?
-                                if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
-                                {
-                                        atomic_dec(&which->num_hi_pending);
-                                        ___tasklet_hi_schedule(t);
-                                }
-                                else
-                                {
-                                        TRACE("%s: dropped hi tasklet??\n", __FUNCTION__);
-                                        BUG();
-                                }
+                        // WTF?
+                        if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
+                        {
+                                atomic_dec(&which->num_hi_pending);
+                                ___tasklet_hi_schedule(t);
                         }
                         else
                         {
-                                TRACE("%s: Could not flush a HI tasklet.\n", __FUNCTION__);
-                                // put back on queue.
-                                ___litmus_tasklet_hi_schedule(t, which, 0);
+                                TRACE("%s: dropped hi tasklet??\n", __FUNCTION__);
+                                BUG();
                         }
+
                 }
         }
 
@@ -1038,34 +870,25 @@ void flush_pending(struct task_struct* klmirqd_thread,
                         struct tasklet_struct *t = list;
                         list = list->next;
 
-                        if(likely((t->owner == owner) || (owner == NULL)))
+                        if(unlikely(!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)))
                         {
-                                if(unlikely(!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)))
-                                {
-                                        BUG();
-                                }
+                                BUG();
+                        }
 
-                                work_flushed |= LIT_TASKLET_LOW;
+                        work_flushed |= LIT_TASKLET_LOW;
 
-                                t->owner = NULL;
-                                sched_trace_tasklet_end(owner, 1ul);
+                        t->owner = NULL;
+//                      sched_trace_tasklet_end(owner, 1ul);
 
-                                if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
-                                {
-                                        atomic_dec(&which->num_low_pending);
-                                        ___tasklet_schedule(t);
-                                }
-                                else
-                                {
-                                        TRACE("%s: dropped tasklet??\n", __FUNCTION__);
-                                        BUG();
-                                }
+                        if(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
+                        {
+                                atomic_dec(&which->num_low_pending);
+                                ___tasklet_schedule(t);
                         }
                         else
                         {
-                                TRACE("%s: Could not flush a LOW tasklet.\n", __FUNCTION__);
-                                // put back on queue
-                                ___litmus_tasklet_schedule(t, which, 0);
+                                TRACE("%s: dropped tasklet??\n", __FUNCTION__);
+                                BUG();
                         }
                 }
         }
@@ -1083,21 +906,12 @@ void flush_pending(struct task_struct* klmirqd_thread,
                                 list_first_entry(&which->worklist, struct work_struct, entry);
                         list_del_init(&work->entry);
 
-                        if(likely((work->owner == owner) || (owner == NULL)))
-                        {
-                                work_flushed |= LIT_WORK;
-                                atomic_dec(&which->num_work_pending);
+                        work_flushed |= LIT_WORK;
+                        atomic_dec(&which->num_work_pending);
 
-                                work->owner = NULL;
-                                sched_trace_work_end(owner, current, 1ul);
-                                __schedule_work(work);
-                        }
-                        else
-                        {
-                                TRACE("%s: Could not flush a work object.\n", __FUNCTION__);
-                                // put back on queue
-                                ___litmus_schedule_work(work, which, 0);
-                        }
+                        work->owner = NULL;
+//                      sched_trace_work_end(owner, current, 1ul);
+                        __schedule_work(work);
                 }
         }
 
@@ -1106,22 +920,6 @@ void flush_pending(struct task_struct* klmirqd_thread,
 
         mb(); /* commit changes to pending flags */
 
-        /* reset the scheduling priority */
-        if(work_flushed)
-        {
-                __reeval_prio(which);
-
-                /* Try to offload flushed tasklets to Linux's ksoftirqd. */
-                if(work_flushed & (LIT_TASKLET_LOW | LIT_TASKLET_HI))
-                {
-                        wakeup_softirqd();
-                }
-        }
-        else
-        {
-                TRACE_CUR("%s: no work flushed, so __reeval_prio() skipped\n", __FUNCTION__);
-        }
-
         raw_spin_unlock_irqrestore(&which->lock, flags);
 }
 
@@ -1161,39 +959,27 @@ static void ___litmus_tasklet_schedule(struct tasklet_struct *t,
     raw_spin_unlock_irqrestore(&which->lock, flags);
 }
 
-int __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
+
+int __litmus_tasklet_schedule(struct tasklet_struct *t, struct task_struct* klmirqd_thread)
 {
         int ret = 0; /* assume failure */
-    if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
-    {
-        TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
-        BUG();
-    }
+        struct klmirqd_info* info;
 
-    if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
-    {
-        TRACE("%s: No klmirqd_th%d!\n", __FUNCTION__, k_id);
-        BUG();
-    }
+        if (unlikely(!is_realtime(klmirqd_thread) ||
+                !tsk_rt(klmirqd_thread)->is_interrupt_thread ||
+                !tsk_rt(klmirqd_thread)->klmirqd_info)) {
+                TRACE("%s: %s/%d can't handle tasklets\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                return ret;
+        }
 
-        if(likely(!klmirqds[k_id].terminating))
-        {
-                /* Can't accept tasklets while we're processing a workqueue
-                   because they're handled by the same thread. This case is
-                   very RARE.
+        info = tsk_rt(klmirqd_thread)->klmirqd_info;
 
-                   TODO: Use a separate thread for work objects!!!!!!
-         */
-                if(likely(atomic_read(&klmirqds[k_id].num_work_pending) == 0))
-                {
-                        ret = 1;
-                        ___litmus_tasklet_schedule(t, &klmirqds[k_id], 1);
-                }
-                else
-                {
-                        TRACE("%s: rejected tasklet because of pending work.\n",
-                                                __FUNCTION__);
-                }
+        if (likely(!info->terminating)) {
+                ret = 1;
+                ___litmus_tasklet_schedule(t, info, 1);
+        }
+        else {
+                TRACE("%s: Tasklet rejected because %s/%d is terminating\n", klmirqd_thread->comm, klmirqd_thread->pid);
         }
         return(ret);
 }
@@ -1230,100 +1016,77 @@ static void ___litmus_tasklet_hi_schedule(struct tasklet_struct *t,
     raw_spin_unlock_irqrestore(&which->lock, flags);
 }
 
-int __litmus_tasklet_hi_schedule(struct tasklet_struct *t, unsigned int k_id)
+int __litmus_tasklet_hi_schedule(struct tasklet_struct *t, struct task_struct* klmirqd_thread)
 {
         int ret = 0; /* assume failure */
-    if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
-    {
-        TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
-        BUG();
-    }
+        struct klmirqd_info* info;
 
-    if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
-    {
-        TRACE("%s: No klmirqd_th%d!\n", __FUNCTION__, k_id);
-        BUG();
-    }
+        if (unlikely(!is_realtime(klmirqd_thread) ||
+                !tsk_rt(klmirqd_thread)->is_interrupt_thread ||
+                !tsk_rt(klmirqd_thread)->klmirqd_info)) {
+                TRACE("%s: %s/%d can't handle tasklets\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                return ret;
+        }
 
-    if(unlikely(!klmirqd_is_ready()))
-    {
-        TRACE("%s: klmirqd is not ready!\n", __FUNCTION__, k_id);
-        BUG();
-    }
+        info = tsk_rt(klmirqd_thread)->klmirqd_info;
 
-        if(likely(!klmirqds[k_id].terminating))
-        {
-                if(likely(atomic_read(&klmirqds[k_id].num_work_pending) == 0))
-                {
-                        ret = 1;
-                        ___litmus_tasklet_hi_schedule(t, &klmirqds[k_id], 1);
-                }
-                else
-                {
-                        TRACE("%s: rejected tasklet because of pending work.\n",
-                                                __FUNCTION__);
-                }
+        if (likely(!info->terminating)) {
+                ret = 1;
+                ___litmus_tasklet_hi_schedule(t, info, 1);
         }
+        else {
+                TRACE("%s: Tasklet rejected because %s/%d is terminating\n", klmirqd_thread->comm, klmirqd_thread->pid);
+        }
+
         return(ret);
 }
 
 EXPORT_SYMBOL(__litmus_tasklet_hi_schedule);
 
 
-int __litmus_tasklet_hi_schedule_first(struct tasklet_struct *t, unsigned int k_id)
+int __litmus_tasklet_hi_schedule_first(struct tasklet_struct *t, struct task_struct* klmirqd_thread)
 {
         int ret = 0; /* assume failure */
         u32 old_pending;
+        struct klmirqd_info* info;
 
         BUG_ON(!irqs_disabled());
 
-    if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
-    {
-        TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
-        BUG();
-    }
+        if (unlikely(!is_realtime(klmirqd_thread) ||
+                                 !tsk_rt(klmirqd_thread)->is_interrupt_thread ||
+                                 !tsk_rt(klmirqd_thread)->klmirqd_info)) {
+                TRACE("%s: %s/%d can't handle tasklets\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                return ret;
+        }
 
-    if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
-    {
-        TRACE("%s: No klmirqd_th%u!\n", __FUNCTION__, k_id);
-        BUG();
-    }
+        info = tsk_rt(klmirqd_thread)->klmirqd_info;
 
-    if(unlikely(!klmirqd_is_ready()))
-    {
-        TRACE("%s: klmirqd is not ready!\n", __FUNCTION__, k_id);
-        BUG();
-    }
+        if (likely(!info->terminating)) {
 
-        if(likely(!klmirqds[k_id].terminating))
-        {
-        raw_spin_lock(&klmirqds[k_id].lock);
+        raw_spin_lock(&info->lock);
 
-                if(likely(atomic_read(&klmirqds[k_id].num_work_pending) == 0))
-                {
-                        ret = 1;  // success!
+                ret = 1;  // success!
 
-                        t->next = klmirqds[k_id].pending_tasklets_hi.head;
-            klmirqds[k_id].pending_tasklets_hi.head = t;
+                t->next = info->pending_tasklets_hi.head;
+        info->pending_tasklets_hi.head = t;
 
-                        old_pending = klmirqds[k_id].pending;
-                        klmirqds[k_id].pending |= LIT_TASKLET_HI;
+                old_pending = info->pending;
+                info->pending |= LIT_TASKLET_HI;
 
-                        atomic_inc(&klmirqds[k_id].num_hi_pending);
+                atomic_inc(&info->num_hi_pending);
 
-                        mb();
+                mb();
 
-                        if(!old_pending)
-                wakeup_litirqd_locked(&klmirqds[k_id]); /* wake up the klmirqd */
-                }
-                else
-                {
-                        TRACE("%s: rejected tasklet because of pending work.\n",
-                                        __FUNCTION__);
+                if(!old_pending) {
+                        wakeup_litirqd_locked(info); /* wake up the klmirqd */
                 }
 
-        raw_spin_unlock(&klmirqds[k_id].lock);
+                raw_spin_unlock(&info->lock);
         }
+        else {
+                TRACE("%s: Tasklet rejected because %s/%d is terminating\n", klmirqd_thread->comm, klmirqd_thread->pid);
+        }
+
         return(ret);
 }
 
@@ -1358,225 +1121,30 @@ static void ___litmus_schedule_work(struct work_struct *w,
         raw_spin_unlock_irqrestore(&which->lock, flags);
 }
 
-int __litmus_schedule_work(struct work_struct *w, unsigned int k_id)
+int __litmus_schedule_work(struct work_struct *w, struct task_struct* klmirqd_thread)
 {
         int ret = 1; /* assume success */
-        if(unlikely(w->owner == NULL) || !is_realtime(w->owner))
-        {
-                TRACE("%s: No owner associated with this work object!\n", __FUNCTION__);
-                BUG();
-        }
-
-        if(unlikely(k_id >= NR_LITMUS_SOFTIRQD))
-        {
-                TRACE("%s: No klmirqd_th%u!\n", k_id);
-                BUG();
-        }
-
-    if(unlikely(!klmirqd_is_ready()))
-    {
-        TRACE("%s: klmirqd is not ready!\n", __FUNCTION__, k_id);
-        BUG();
-    }
-
-        if(likely(!klmirqds[k_id].terminating))
-                ___litmus_schedule_work(w, &klmirqds[k_id], 1);
-        else
-                ret = 0;
-        return(ret);
-}
-EXPORT_SYMBOL(__litmus_schedule_work);
-
-
-static int set_klmirqd_sem_status(unsigned long stat)
-{
-        TRACE_CUR("SETTING STATUS FROM %d TO %d\n",
-                                        atomic_read(&tsk_rt(current)->klmirqd_sem_stat),
-                                        stat);
-        atomic_set(&tsk_rt(current)->klmirqd_sem_stat, stat);
-        //mb();
-
-        return(0);
-}
-
-static int set_klmirqd_sem_status_if_not_held(unsigned long stat)
-{
-        if(atomic_read(&tsk_rt(current)->klmirqd_sem_stat) != HELD)
-        {
-                return(set_klmirqd_sem_status(stat));
-        }
-        return(-1);
-}
-
-
-void __down_and_reset_and_set_stat(struct task_struct* t,
-                                           enum klmirqd_sem_status to_reset,
-                                           enum klmirqd_sem_status to_set,
-                                           struct mutex* sem)
-{
-#if 0
-        struct rt_param* param = container_of(sem, struct rt_param, klmirqd_sem);
-        struct task_struct* task = container_of(param, struct task_struct, rt_param);
-
-        TRACE_CUR("%s: entered.  Locking semaphore of %s/%d\n",
-                                        __FUNCTION__, task->comm, task->pid);
-#endif
-
-        mutex_lock_sfx(sem,
-                                   set_klmirqd_sem_status_if_not_held, to_reset,
-                                   set_klmirqd_sem_status, to_set);
-#if 0
-        TRACE_CUR("%s: exiting.  Have semaphore of %s/%d\n",
-                                        __FUNCTION__, task->comm, task->pid);
-#endif
-}
-
-void down_and_set_stat(struct task_struct* t,
-                                           enum klmirqd_sem_status to_set,
-                                           struct mutex* sem)
-{
-#if 0
-        struct rt_param* param = container_of(sem, struct rt_param, klmirqd_sem);
-        struct task_struct* task = container_of(param, struct task_struct, rt_param);
-
-        TRACE_CUR("%s: entered.  Locking semaphore of %s/%d\n",
-                                        __FUNCTION__, task->comm, task->pid);
-#endif
-
-        mutex_lock_sfx(sem,
-                                   NULL, 0,
-                                   set_klmirqd_sem_status, to_set);
-
-#if 0
-        TRACE_CUR("%s: exiting.  Have semaphore of %s/%d\n",
-                                        __FUNCTION__, task->comm, task->pid);
-#endif
-}
-
-
-void up_and_set_stat(struct task_struct* t,
-                                         enum klmirqd_sem_status to_set,
-                                         struct mutex* sem)
-{
-#if 0
-        struct rt_param* param = container_of(sem, struct rt_param, klmirqd_sem);
-        struct task_struct* task = container_of(param, struct task_struct, rt_param);
-
-        TRACE_CUR("%s: entered.  Unlocking semaphore of %s/%d\n",
-                                        __FUNCTION__,
-                                        task->comm, task->pid);
-#endif
-
-        mutex_unlock_sfx(sem, NULL, 0,
-                                         set_klmirqd_sem_status, to_set);
-
-#if 0
-        TRACE_CUR("%s: exiting.  Unlocked semaphore of %s/%d\n",
-                                        __FUNCTION__,
-                                        task->comm, task->pid);
-#endif
-}
-
-
-
-void release_klmirqd_lock(struct task_struct* t)
-{
-        if(is_realtime(t) && (atomic_read(&tsk_rt(t)->klmirqd_sem_stat) == HELD))
-        {
-                struct mutex* sem;
-                struct task_struct* owner = t;
-
-                if(t->state == TASK_RUNNING)
-                {
-                        TRACE_TASK(t, "NOT giving up klmirqd_sem because we're not blocked!\n");
-                        return;
-                }
+        struct klmirqd_info* info;
 
-                if(likely(!tsk_rt(t)->is_proxy_thread))
-                {
-                        sem = &tsk_rt(t)->klmirqd_sem;
-                }
-                else
-                {
-                        unsigned int k_id = klmirqd_id(t);
-                        owner = klmirqds[k_id].current_owner;
-
-                        BUG_ON(t != klmirqds[k_id].klmirqd);
-
-                        if(likely(owner))
-                        {
-                                sem = &tsk_rt(owner)->klmirqd_sem;
-                        }
-                        else
-                        {
-                                BUG();
-
-                                // We had the rug pulled out from under us.  Abort attempt
-                                // to reacquire the lock since our client no longer needs us.
-                                TRACE_CUR("HUH?!  How did this happen?\n");
-                                atomic_set(&tsk_rt(t)->klmirqd_sem_stat, NOT_HELD);
-                                return;
-                        }
-                }
-
-                //TRACE_CUR("Releasing semaphore of %s/%d...\n", owner->comm, owner->pid);
-                up_and_set_stat(t, NEED_TO_REACQUIRE, sem);
-                //TRACE_CUR("Semaphore of %s/%d released!\n", owner->comm, owner->pid);
-        }
-        /*
-        else if(is_realtime(t))
-        {
-                TRACE_CUR("%s: Nothing to do.  Stat = %d\n", __FUNCTION__, tsk_rt(t)->klmirqd_sem_stat);
+        if (unlikely(!is_realtime(klmirqd_thread) ||
+                                 !tsk_rt(klmirqd_thread)->is_interrupt_thread ||
+                                 !tsk_rt(klmirqd_thread)->klmirqd_info)) {
+                TRACE("%s: %s/%d can't handle work items\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                return ret;
         }
-        */
-}
 
-int reacquire_klmirqd_lock(struct task_struct* t)
-{
-        int ret = 0;
-
-        if(is_realtime(t) && (atomic_read(&tsk_rt(t)->klmirqd_sem_stat) == NEED_TO_REACQUIRE))
-        {
-                struct mutex* sem;
-                struct task_struct* owner = t;
-
-                if(likely(!tsk_rt(t)->is_proxy_thread))
-                {
-                        sem = &tsk_rt(t)->klmirqd_sem;
-                }
-                else
-                {
-                        unsigned int k_id = klmirqd_id(t);
-                        //struct task_struct* owner = klmirqds[k_id].current_owner;
-                        owner = klmirqds[k_id].current_owner;
-
-                        BUG_ON(t != klmirqds[k_id].klmirqd);
+        info = tsk_rt(klmirqd_thread)->klmirqd_info;
 
-                        if(likely(owner))
-                        {
-                                sem = &tsk_rt(owner)->klmirqd_sem;
-                        }
-                        else
-                        {
-                                // We had the rug pulled out from under us.  Abort attempt
-                                // to reacquire the lock since our client no longer needs us.
-                                TRACE_CUR("No longer needs to reacquire klmirqd_sem!\n");
-                                atomic_set(&tsk_rt(t)->klmirqd_sem_stat, NOT_HELD);
-                                return(0);
-                        }
-                }
 
-                //TRACE_CUR("Trying to reacquire semaphore of %s/%d\n", owner->comm, owner->pid);
-                __down_and_reset_and_set_stat(t, REACQUIRING, HELD, sem);
-                //TRACE_CUR("Reacquired semaphore %s/%d\n", owner->comm, owner->pid);
+        if (likely(!info->terminating)) {
+                ___litmus_schedule_work(w, info, 1);
         }
-        /*
-        else if(is_realtime(t))
-        {
-                TRACE_CUR("%s: Nothing to do.  Stat = %d\n", __FUNCTION__, tsk_rt(t)->klmirqd_sem_stat);
+        else {
+                TRACE("%s: Work rejected because %s/%d is terminating\n", klmirqd_thread->comm, klmirqd_thread->pid);
+                ret = 0;
         }
-        */
 
         return(ret);
 }
+EXPORT_SYMBOL(__litmus_schedule_work);