xnu-792.18.15.tar.gz

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

diff --git a/iokit/Kernel/IOCommandGate.cpp b/iokit/Kernel/IOCommandGate.cpp
index 3c7c228549e1f16cb62412e4779dd45c1f3e88b0..f276ebc220ed5e7b94e02d278578ed743f31f8e4 100644 (file)
--- a/iokit/Kernel/IOCommandGate.cpp
+++ b/iokit/Kernel/IOCommandGate.cpp
@@ -25,6 +25,8 @@
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */

+#include <libkern/OSDebug.h>
+

 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOWorkLoop.h>
 #include <IOKit/IOReturn.h>
 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOWorkLoop.h>
 #include <IOKit/IOReturn.h>


@@ -62,71 +64,98 @@ IOCommandGate::commandGate(OSObject *inOwner, Action inAction)
     return me;
 }
 
     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 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);
 
     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();
     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;
     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;
     openGate();
 
     return res;


@@ -138,9 +167,6 @@ IOReturn IOCommandGate::attemptAction(Action inAction,
 {
     IOReturn res;
 
 {
     IOReturn res;
 

-    if (!enabled)
-        return kIOReturnNotPermitted;
-

     if (!inAction)
         return kIOReturnBadArgument;
 
     if (!inAction)
         return kIOReturnBadArgument;
 


@@ -148,10 +174,16 @@ IOReturn IOCommandGate::attemptAction(Action inAction,
     if (!tryCloseGate())
         return kIOReturnCannotLock;
 
     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;
     openGate();
 
     return res;