X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/6601e61aa18bf4f09af135ff61fc7f4771d23b06..0c530ab8987f0ae6a1a3d9284f40182b88852816:/iokit/Kernel/IOCommandGate.cpp

diff --git a/iokit/Kernel/IOCommandGate.cpp b/iokit/Kernel/IOCommandGate.cpp
index dadd04753..37a5304c2 100644
--- 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;