xnu-1504.7.4.tar.gz

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

diff --git a/iokit/Kernel/IOWorkLoop.cpp b/iokit/Kernel/IOWorkLoop.cpp
index c5f757160e3d1bdc7c8981807f7e3151ad2bdcc0..688a7c0135ad11e5c5adef29a0a677c3588ee211 100644 (file)
--- a/iokit/Kernel/IOWorkLoop.cpp
+++ b/iokit/Kernel/IOWorkLoop.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2007 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -32,21 +32,29 @@ HISTORY
     1998-7-13  Godfrey van der Linden(gvdl)
         Created.
 */
     1998-7-13  Godfrey van der Linden(gvdl)
         Created.
 */

+
+#include <pexpert/pexpert.h>

 #include <IOKit/IOWorkLoop.h>
 #include <IOKit/IOEventSource.h>
 #include <IOKit/IOInterruptEventSource.h>
 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOTimeStamp.h>
 #include <IOKit/IOWorkLoop.h>
 #include <IOKit/IOEventSource.h>
 #include <IOKit/IOInterruptEventSource.h>
 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOTimeStamp.h>

+#include <libkern/OSDebug.h>

 
 #define super OSObject
 
 OSDefineMetaClassAndStructors(IOWorkLoop, OSObject);
 
 // Block of unused functions intended for future use
 
 #define super OSObject
 
 OSDefineMetaClassAndStructors(IOWorkLoop, OSObject);
 
 // Block of unused functions intended for future use

+#if __LP64__
+OSMetaClassDefineReservedUnused(IOWorkLoop, 0);
+OSMetaClassDefineReservedUnused(IOWorkLoop, 1);
+OSMetaClassDefineReservedUnused(IOWorkLoop, 2);
+#else

 OSMetaClassDefineReservedUsed(IOWorkLoop, 0);
 OSMetaClassDefineReservedUsed(IOWorkLoop, 1);
 OSMetaClassDefineReservedUsed(IOWorkLoop, 0);
 OSMetaClassDefineReservedUsed(IOWorkLoop, 1);

-
-OSMetaClassDefineReservedUnused(IOWorkLoop, 2);
+OSMetaClassDefineReservedUsed(IOWorkLoop, 2);
+#endif

 OSMetaClassDefineReservedUnused(IOWorkLoop, 3);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 4);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 5);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 3);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 4);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 5);


@@ -54,57 +62,93 @@ OSMetaClassDefineReservedUnused(IOWorkLoop, 6);
 OSMetaClassDefineReservedUnused(IOWorkLoop, 7);
 
 enum IOWorkLoopState { kLoopRestart = 0x1, kLoopTerminate = 0x2 };
 OSMetaClassDefineReservedUnused(IOWorkLoop, 7);
 
 enum IOWorkLoopState { kLoopRestart = 0x1, kLoopTerminate = 0x2 };

+#ifdef __ppc__

 static inline void SETP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; *num |= flag; }
 static inline void CLRP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; *num &= ~flag; }
 static inline bool ISSETP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; return (*num & flag) != 0; }
 static inline void SETP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; *num |= flag; }
 static inline void CLRP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; *num &= ~flag; }
 static inline bool ISSETP(void *addr, unsigned int flag)
     { unsigned int *num = (unsigned int *) addr; return (*num & flag) != 0; }

+#else
+static inline void SETP(void *addr, unsigned int flag)
+    { unsigned char *num = (unsigned char *) addr; *num |= flag; }
+static inline void CLRP(void *addr, unsigned int flag)
+    { unsigned char *num = (unsigned char *) addr; *num &= ~flag; }
+static inline bool ISSETP(void *addr, unsigned int flag)
+    { unsigned char *num = (unsigned char *) addr; return (*num & flag) != 0; }
+#endif

 
 #define fFlags loopRestart
 
 
 #define fFlags loopRestart
 

+

 bool IOWorkLoop::init()
 {
     // The super init and gateLock allocation MUST be done first
     if ( !super::init() )
         return false;
 bool IOWorkLoop::init()
 {
     // The super init and gateLock allocation MUST be done first
     if ( !super::init() )
         return false;

+       
+    if ( gateLock == NULL ) {
+        if ( !( gateLock = IORecursiveLockAlloc()) )
+            return false;
+    }
+       
+    if ( workToDoLock == NULL ) {
+        if ( !(workToDoLock = IOSimpleLockAlloc()) )
+            return false;
+        IOSimpleLockInit(workToDoLock);
+        workToDo = false;
+    }

 
 

-    if ( !(gateLock = IORecursiveLockAlloc()) )
-        return false;
-
-    if ( !(workToDoLock = IOSimpleLockAlloc()) )
-        return false;
-
-    controlG = IOCommandGate::
-       commandGate(this, OSMemberFunctionCast(IOCommandGate::Action,
-                                       this, &IOWorkLoop::_maintRequest));
-    if ( !controlG )
-        return false;
-
-    IOSimpleLockInit(workToDoLock);
-    workToDo = false;
-
-    // Point the controlGate at the workLoop.  Usually addEventSource
-    // does this automatically.  The problem is in this case addEventSource
-    // uses the control gate and it has to be bootstrapped.
-    controlG->setWorkLoop(this);
-    if (addEventSource(controlG) != kIOReturnSuccess)
-        return false;
+    if ( controlG == NULL ) {
+        controlG = IOCommandGate::commandGate(
+            this,
+            OSMemberFunctionCast(
+                IOCommandGate::Action,
+                this,
+                &IOWorkLoop::_maintRequest));
+
+        if ( !controlG )
+            return false;
+        // Point the controlGate at the workLoop.  Usually addEventSource
+        // does this automatically.  The problem is in this case addEventSource
+        // uses the control gate and it has to be bootstrapped.
+        controlG->setWorkLoop(this);
+        if (addEventSource(controlG) != kIOReturnSuccess)
+            return false;
+    }

 
 

-    IOThreadFunc cptr =
-       OSMemberFunctionCast(IOThreadFunc, this, &IOWorkLoop::threadMain);
-    workThread = IOCreateThread(cptr, this);
-    if (!workThread)
-        return false;
+    if ( workThread == NULL ) {
+        thread_continue_t cptr = OSMemberFunctionCast(
+            thread_continue_t,
+            this,
+            &IOWorkLoop::threadMain);
+        if (KERN_SUCCESS != kernel_thread_start(cptr, this, &workThread))
+            return false;
+    }

 
     return true;
 }
 
 IOWorkLoop *
 IOWorkLoop::workLoop()
 
     return true;
 }
 
 IOWorkLoop *
 IOWorkLoop::workLoop()

+{
+    return IOWorkLoop::workLoopWithOptions(0);
+}
+
+IOWorkLoop *
+IOWorkLoop::workLoopWithOptions(IOOptionBits options)

 {
     IOWorkLoop *me = new IOWorkLoop;
 
 {
     IOWorkLoop *me = new IOWorkLoop;
 

+    if (me && options) {
+       me->reserved = IONew(ExpansionData, 1);
+       if (!me->reserved) {
+           me->release();
+           return 0;
+       }
+       me->reserved->options = options;
+    }
+

     if (me && !me->init()) {
         me->release();
         return 0;
     if (me && !me->init()) {
         me->release();
         return 0;


@@ -123,7 +167,7 @@ void IOWorkLoop::free()
        IOInterruptState is;
 
        // If we are here then we must be trying to shut down this work loop
        IOInterruptState is;
 
        // If we are here then we must be trying to shut down this work loop

-       // in this case disable all of the event source, mark the loop for
+       // in this case disable all of the event source, mark the loop

        // as terminating and wakeup the work thread itself and return
        // Note: we hold the gate across the entire operation mainly for the 
        // benefit of our event sources so we can disable them cleanly.
        // as terminating and wakeup the work thread itself and return
        // Note: we hold the gate across the entire operation mainly for the 
        // benefit of our event sources so we can disable them cleanly.


@@ -149,9 +193,9 @@ void IOWorkLoop::free()
         }
         eventChain = 0;
 
         }
         eventChain = 0;
 

-       // Either we have a partial initialisation to clean up
-       // or we the workThread itself is performing hari-kari.
-       // either way clean up all of our resources and return.
+       // Either we have a partial initialization to clean up
+       // or the workThread itself is performing hari-kari.
+       // Either way clean up all of our resources and return.

        
        if (controlG) {
            controlG->release();
        
        if (controlG) {
            controlG->release();


@@ -167,6 +211,10 @@ void IOWorkLoop::free()
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }

+       if (reserved) {
+           IODelete(reserved, ExpansionData, 1);
+           reserved = 0;
+       }

 
        super::free();
     }
 
        super::free();
     }


@@ -260,7 +308,10 @@ do {                                                                       \
     bool more;
     do {
        CLRP(&fFlags, kLoopRestart);
     bool more;
     do {
        CLRP(&fFlags, kLoopRestart);

-       workToDo = more = false;
+       more = false;
+       IOInterruptState is = IOSimpleLockLockDisableInterrupt(workToDoLock);
+       workToDo = false;
+       IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);

        for (IOEventSource *evnt = eventChain; evnt; evnt = evnt->getNext()) {
 
            IOTimeClientS();
        for (IOEventSource *evnt = eventChain; evnt; evnt = evnt->getNext()) {
 
            IOTimeClientS();


@@ -286,6 +337,7 @@ abort:
 
 /* virtual */ void IOWorkLoop::threadMain()
 {
 
 /* virtual */ void IOWorkLoop::threadMain()
 {

+restartThread:

     do {
        if ( !runEventSources() )
            goto exitThread;
     do {
        if ( !runEventSources() )
            goto exitThread;


@@ -294,10 +346,12 @@ abort:
         if ( !ISSETP(&fFlags, kLoopTerminate) && !workToDo) {
            assert_wait((void *) &workToDo, false);
            IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);
         if ( !ISSETP(&fFlags, kLoopTerminate) && !workToDo) {
            assert_wait((void *) &workToDo, false);
            IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);

-
-           thread_continue_t cptr = OSMemberFunctionCast(
-                   thread_continue_t, this, &IOWorkLoop::threadMain);
+           thread_continue_t cptr = NULL;
+           if (!reserved || !(kPreciousStack & reserved->options))
+               cptr = OSMemberFunctionCast(
+                       thread_continue_t, this, &IOWorkLoop::threadMain);

            thread_block_parameter(cptr, this);
            thread_block_parameter(cptr, this);

+           goto restartThread;

            /* NOTREACHED */
        }
 
            /* NOTREACHED */
        }
 


@@ -308,9 +362,12 @@ abort:
     } while(workToDo);
 
 exitThread:
     } while(workToDo);
 
 exitThread:

+       thread_t thread = workThread;

     workThread = 0;    // Say we don't have a loop and free ourselves
     free();
     workThread = 0;    // Say we don't have a loop and free ourselves
     free();

-    IOExitThread();
+
+       thread_deallocate(thread);
+    (void) thread_terminate(thread);

 }
 
 IOThread IOWorkLoop::getThread() const
 }
 
 IOThread IOWorkLoop::getThread() const


@@ -359,6 +416,11 @@ int IOWorkLoop::sleepGate(void *event, UInt32 interuptibleType)
     return IORecursiveLockSleep(gateLock, event, interuptibleType);
 }
 
     return IORecursiveLockSleep(gateLock, event, interuptibleType);
 }
 

+int IOWorkLoop::sleepGate(void *event, AbsoluteTime deadline, UInt32 interuptibleType)
+{
+    return IORecursiveLockSleepDeadline(gateLock, event, deadline, interuptibleType);
+}
+

 void IOWorkLoop::wakeupGate(void *event, bool oneThread)
 {
     IORecursiveLockWakeup(gateLock, event, oneThread);
 void IOWorkLoop::wakeupGate(void *event, bool oneThread)
 {
     IORecursiveLockWakeup(gateLock, event, oneThread);


@@ -380,7 +442,7 @@ IOReturn IOWorkLoop::runAction(Action inAction, OSObject *target,
 
 IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
 {
 
 IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
 {

-    maintCommandEnum command = (maintCommandEnum) (vm_address_t) inC;
+    maintCommandEnum command = (maintCommandEnum) (uintptr_t) inC;

     IOEventSource *inEvent = (IOEventSource *) inD;
     IOReturn res = kIOReturnSuccess;
 
     IOEventSource *inEvent = (IOEventSource *) inD;
     IOReturn res = kIOReturnSuccess;