re-enable klmirqd for workqueues, and grace reboot

1 files changed, 34 insertions, 53 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 6b59d59ce3cf..9eb58729e1bb 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -44,10 +44,11 @@
 
 #include "workqueue_sched.h"
 
-#ifdef CONFIG_LITMUS_NVIDIA
+#if defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON) || defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON_DEDICATED)
 #include <litmus/litmus.h>
-#include <litmus/sched_trace.h>
 #include <litmus/nvidia_info.h>
+#include <litmus/sched_trace.h>
+#include <litmus/trace.h>
 #endif
 
 
@@ -2679,6 +2680,32 @@ bool cancel_delayed_work_sync(struct delayed_work *dwork)
 }
 EXPORT_SYMBOL(cancel_delayed_work_sync);
 
+
+#if defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON) || defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON_DEDICATED)
+static int __klmirqd_nv_work_schedule(struct work_struct *work)
+{
+        /* TODO: MOVE THIS TO nvidia_info.c */
+        unsigned long flags;
+        u32 nvidia_device = get_work_nv_device_num(work);
+        struct task_struct* klmirqd_th = get_and_lock_nvklmworkqd_thread(nvidia_device, &flags);
+
+        if (likely(klmirqd_th)) {
+                TRACE("Handling NVIDIA workq for device %u (klmirqd: %s/%d) at %llu\n",
+                        nvidia_device,
+                        klmirqd_th->comm,
+                        klmirqd_th->pid,
+                        litmus_clock());
+
+                sched_trace_work_release(NULL, nvidia_device);
+                if (likely(litmus_schedule_work(work, klmirqd_th))) {
+                        unlock_nvklmworkqd_thread(nvidia_device, &flags);
+                        return 1; /* success */
+                }
+        }
+        return 0;
+}
+#endif
+
 /**
  * schedule_work - put work task in global workqueue
  * @work: job to be done
@@ -2692,60 +2719,14 @@ EXPORT_SYMBOL(cancel_delayed_work_sync);
  */
 int schedule_work(struct work_struct *work)
 {
-#if 0
-#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
-        if(is_nvidia_func(work->func))
-        {
-                u32 nvidiaDevice = get_work_nv_device_num(work);
-                
-                //1) Ask Litmus which task owns GPU <nvidiaDevice>. (API to be defined.)
-                unsigned long flags;
-                struct task_struct* device_owner;
-                
-                lock_nv_registry(nvidiaDevice, &flags);
-                
-                device_owner = get_nv_max_device_owner(nvidiaDevice);
-                
-                //2) If there is an owner, set work->owner to the owner's task struct.
-                if(device_owner==NULL) 
-                {
-                        work->owner = NULL;
-                        //TRACE("%s: the owner task of NVIDIA Device %u is NULL\n",__FUNCTION__,nvidiaDevice);
+#if defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON) || defined(CONFIG_LITMUS_NVIDIA_WORKQ_ON_DEDICATED)
+        if(is_nvidia_func(work->func)) {
+                if (__klmirqd_nv_work_schedule(work)) {
+                        return 1;
                 }
-                else
-                {
-                        if( is_realtime(device_owner))
-                        {
-                                TRACE("%s: Handling NVIDIA work for device\t%u\tat\t%llu\n",
-                                          __FUNCTION__, nvidiaDevice,litmus_clock());
-                                TRACE("%s: the owner task %d of NVIDIA Device %u is RT-task\n",
-                                          __FUNCTION__,
-                                          device_owner->pid,
-                                          nvidiaDevice);
-                                
-                                //3) Call litmus_schedule_work() and return (don't execute the rest
-                                //      of schedule_schedule()).
-                                work->owner = device_owner;
-                                sched_trace_work_release(work->owner);
-                                if(likely(litmus_schedule_work(work, nvidiaDevice)))
-                                {
-                                        unlock_nv_registry(nvidiaDevice, &flags);
-                                        return 1;
-                                }
-                                else
-                                {
-                                        work->owner = NULL; /* fall through to normal work scheduling */
-                                }
-                        }
-                        else
-                        {
-                                work->owner = NULL;
-                        }
-                }
-                unlock_nv_registry(nvidiaDevice, &flags);
         }
 #endif
-#endif
+
         return(__schedule_work(work));
 }
 EXPORT_SYMBOL(schedule_work);