xnu-792.25.20.tar.gz

[apple/xnu.git] / iokit / Kernel / IOCommandGate.cpp

diff --git a/iokit/Kernel/IOCommandGate.cpp b/iokit/Kernel/IOCommandGate.cpp
index dadd047536948761df81d0097ecc73373520872d..37a5304c2e30f14d3f8a3a6f990a4edf42cd106a 100644 (file)
--- a/iokit/Kernel/IOCommandGate.cpp
+++ b/iokit/Kernel/IOCommandGate.cpp
@@ -19,6 +19,8 @@
  * 
  * @APPLE_LICENSE_HEADER_END@
  */
+#include <libkern/OSDebug.h>
+
 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOWorkLoop.h>
 #include <IOKit/IOReturn.h>
@@ -56,71 +58,98 @@ IOCommandGate::commandGate(OSObject *inOwner, Action inAction)
     return me;
 }
 
-IOReturn IOCommandGate::runCommand(void *arg0, void *arg1,
-                                   void *arg2, void *arg3)
+/* virtual */ void IOCommandGate::disable()
 {
-    IOReturn res;
+    if (workLoop && !workLoop->inGate())
+       OSReportWithBacktrace("IOCommandGate::disable() called when not gated");
 
-    if (!enabled)
-        return kIOReturnNotPermitted;
+    super::disable();
+}
 
-    if (!action)
-        return kIOReturnNoResources;
+/* virtual */ void IOCommandGate::enable()
+{
+    if (workLoop) {
+       closeGate();
+       super::enable();
+       wakeupGate(&enabled, /* oneThread */ false); // Unblock sleeping threads
+       openGate();
+    }
+}
 
-    // closeGate is recursive so don't worry if we already hold the lock.
-    IOTimeStampConstant(IODBG_CMDQ(IOCMDQ_ACTION),
-                       (unsigned int) action, (unsigned int) owner);
+/* virtual */ void IOCommandGate::free()
+{
+    setWorkLoop(0);
+    super::free();
+}
 
-    closeGate();
-    res = (*(Action) action)(owner, arg0, arg1, arg2, arg3);
-    openGate();
+/* virtual */ void IOCommandGate::setWorkLoop(IOWorkLoop *inWorkLoop)
+{
+    uintptr_t *sleepersP = (uintptr_t *) &reserved;
+    if (!inWorkLoop && workLoop) {             // tearing down
+       closeGate();
+       *sleepersP |= 1;
+       while (*sleepersP >> 1) {
+           thread_wakeup_with_result(&enabled, THREAD_INTERRUPTED);
+           sleepGate(sleepersP, THREAD_UNINT);
+       }
+       *sleepersP = 0;
+       openGate();
+    }
+    else
 
-    return res;
+    super::setWorkLoop(inWorkLoop);
+}
+
+IOReturn IOCommandGate::runCommand(void *arg0, void *arg1,
+                                   void *arg2, void *arg3)
+{
+    return runAction((Action) action, arg0, arg1, arg2, arg3);
+}
+
+IOReturn IOCommandGate::attemptCommand(void *arg0, void *arg1,
+                                       void *arg2, void *arg3)
+{
+    return attemptAction((Action) action, arg0, arg1, arg2, arg3);
 }
 
 IOReturn IOCommandGate::runAction(Action inAction,
                                   void *arg0, void *arg1,
                                   void *arg2, void *arg3)
 {
-    IOReturn res;
-
-    if (!enabled)
-        return kIOReturnNotPermitted;
-
     if (!inAction)
         return kIOReturnBadArgument;
 
     IOTimeStampConstant(IODBG_CMDQ(IOCMDQ_ACTION),
                        (unsigned int) inAction, (unsigned int) owner);
 
-    // closeGate is recursive so don't worry if we already hold the lock.
+    // closeGate is recursive needn't worry if we already hold the lock.
     closeGate();
-    res = (*inAction)(owner, arg0, arg1, arg2, arg3);
-    openGate();
 
-    return res;
-}
-
-IOReturn IOCommandGate::attemptCommand(void *arg0, void *arg1,
-                                       void *arg2, void *arg3)
-{
+    // If the command gate is disabled and we aren't on the workloop thread
+    // itself then sleep until we get enabled.
     IOReturn res;
+    if (!workLoop->onThread()) {
+       while (!enabled) {
+           uintptr_t *sleepersP = (uintptr_t *) &reserved;
 
-    if (!enabled)
-        return kIOReturnNotPermitted;
+           *sleepersP += 2;
+           IOReturn res = sleepGate(&enabled, THREAD_ABORTSAFE);
+           *sleepersP -= 2;
 
-    if (!action)
-        return kIOReturnNoResources;
+           bool wakeupTearDown = (*sleepersP & 1);
+           if (res || wakeupTearDown) {
+               openGate();
 
-    // Try to hold the lock if can't get return immediately.
-    if (!tryCloseGate())
-        return kIOReturnCannotLock;
+                if (wakeupTearDown)
+                    commandWakeup(sleepersP);  // No further resources used
 
-    // closeGate is recursive so don't worry if we already hold the lock.
-    IOTimeStampConstant(IODBG_CMDQ(IOCMDQ_ACTION),
-                       (unsigned int) action, (unsigned int) owner);
+               return kIOReturnAborted;
+           }
+       }
+    }
 
-    res = (*(Action) action)(owner, arg0, arg1, arg2, arg3);
+    // Must be gated and on the work loop or enabled
+    res = (*inAction)(owner, arg0, arg1, arg2, arg3);
     openGate();
 
     return res;
@@ -132,9 +161,6 @@ IOReturn IOCommandGate::attemptAction(Action inAction,
 {
     IOReturn res;
 
-    if (!enabled)
-        return kIOReturnNotPermitted;
-
     if (!inAction)
         return kIOReturnBadArgument;
 
@@ -142,10 +168,16 @@ IOReturn IOCommandGate::attemptAction(Action inAction,
     if (!tryCloseGate())
         return kIOReturnCannotLock;
 
-    IOTimeStampConstant(IODBG_CMDQ(IOCMDQ_ACTION),
-                       (unsigned int) inAction, (unsigned int) owner);
+    // If the command gate is disabled then sleep until we get a wakeup
+    if (!workLoop->onThread() && !enabled)
+        res = kIOReturnNotPermitted;
+    else {
+       IOTimeStampConstant(IODBG_CMDQ(IOCMDQ_ACTION),
+                           (unsigned int) inAction, (unsigned int) owner);
+
+       res = (*inAction)(owner, arg0, arg1, arg2, arg3);
+    }
 
-    res = (*inAction)(owner, arg0, arg1, arg2, arg3);
     openGate();
 
     return res;