xnu-1228.0.2.tar.gz

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

diff --git a/iokit/Kernel/IOWorkLoop.cpp b/iokit/Kernel/IOWorkLoop.cpp
index 99205ee243f0bdb5bcf64450e6ce932f67aa3793..54eaa0e3c7a42183a75fca994dc29b91ad66c35f 100644 (file)
--- a/iokit/Kernel/IOWorkLoop.cpp
+++ b/iokit/Kernel/IOWorkLoop.cpp
@@ -1,23 +1,29 @@
 /*
 /*

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

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
 Copyright (c) 1998 Apple Computer, Inc.  All rights reserved.
  */
 /*
 Copyright (c) 1998 Apple Computer, Inc.  All rights reserved.


@@ -31,14 +37,16 @@ HISTORY
 #include <IOKit/IOInterruptEventSource.h>
 #include <IOKit/IOCommandGate.h>
 #include <IOKit/IOTimeStamp.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

-OSMetaClassDefineReservedUnused(IOWorkLoop, 0);
-OSMetaClassDefineReservedUnused(IOWorkLoop, 1);
+OSMetaClassDefineReservedUsed(IOWorkLoop, 0);
+OSMetaClassDefineReservedUsed(IOWorkLoop, 1);
+

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


@@ -47,66 +55,95 @@ 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
 

-void IOWorkLoop::launchThreadMain(void *self)
-{
-    register thread_t mythread = current_thread();
-
-    // Make sure that this thread always has a kernel stack
-    stack_privilege(mythread);
-    thread_set_cont_arg((int) self);
-    threadMainContinuation();
-}
-

 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, (IOCommandGate::Action) &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;
+    }

 
 

-    workThread = IOCreateThread(launchThreadMain, (void *) this);
-    if (!workThread)
-        return false;
+    if ( workThread == NULL ) {
+        IOThreadFunc cptr = OSMemberFunctionCast(
+            IOThreadFunc,
+            this,
+            &IOWorkLoop::threadMain);
+        workThread = IOCreateThread(cptr, this);
+        if (!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()) {
     if (me && !me->init()) {

-        me->free();
+        me->release();

         return 0;
     }
 
         return 0;
     }
 


@@ -123,7 +160,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 +186,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 +204,10 @@ void IOWorkLoop::free()
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }

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

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


@@ -249,61 +290,61 @@ do {                                                                      \
 
 #endif /* KDEBUG */
 
 
 #endif /* KDEBUG */
 

-void IOWorkLoop::threadMainContinuation()
+/* virtual */ bool IOWorkLoop::runEventSources()

 {
 {

-  IOWorkLoop* self;
-  self = (IOWorkLoop *) thread_get_cont_arg();
-
-  self->threadMain();
-}
-
-void IOWorkLoop::threadMain()
-{
-    CLRP(&fFlags, kLoopRestart);
-
-    for (;;) {
-        bool more;
-       IOInterruptState is;
+    bool res = false;
+    closeGate();
+    if (ISSETP(&fFlags, kLoopTerminate))
+       goto abort;

 
     IOTimeWorkS();
 
     IOTimeWorkS();

+    bool more;
+    do {
+       CLRP(&fFlags, kLoopRestart);
+       more = false;
+       IOInterruptState is = IOSimpleLockLockDisableInterrupt(workToDoLock);
+       workToDo = false;
+       IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);
+       for (IOEventSource *evnt = eventChain; evnt; evnt = evnt->getNext()) {
+
+           IOTimeClientS();
+           more |= evnt->checkForWork();
+           IOTimeClientE();
+
+           if (ISSETP(&fFlags, kLoopTerminate))
+               goto abort;
+           else if (fFlags & kLoopRestart) {
+               more = true;
+               break;
+           }
+       }
+    } while (more);

 
 

-        closeGate();
-        if (ISSETP(&fFlags, kLoopTerminate))
-           goto exitThread;
-
-        do {
-            workToDo = more = false;
-            for (IOEventSource *event = eventChain; event; event = event->getNext()) {
-
-            IOTimeClientS();
-                more |= event->checkForWork();
-            IOTimeClientE();
-
-               if (ISSETP(&fFlags, kLoopTerminate))
-                   goto exitThread;
-                else if (fFlags & kLoopRestart) {
-                   CLRP(&fFlags, kLoopRestart);
-                    continue;
-                }
-            }
-        } while (more);
-
+    res = true;

     IOTimeWorkE();
 
     IOTimeWorkE();
 

-        openGate();
+abort:
+    openGate();
+    return res;
+}

 
 

-       is = IOSimpleLockLockDisableInterrupt(workToDoLock);
+/* virtual */ void IOWorkLoop::threadMain()
+{
+restartThread:
+    do {
+       if ( !runEventSources() )
+           goto exitThread;
+
+       IOInterruptState is = IOSimpleLockLockDisableInterrupt(workToDoLock);

         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);

-
-#if defined (__i386__)
-           thread_block(0);
-           continue;
-#else
-           thread_set_cont_arg((int) this);
-           thread_block(&threadMainContinuation);
-#endif
+           thread_continue_t cptr = NULL;
+           if (!reserved || !(kPreciousStack & reserved->options))
+               cptr = OSMemberFunctionCast(
+                       thread_continue_t, this, &IOWorkLoop::threadMain);
+           thread_block_parameter(cptr, this);
+           goto restartThread;

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


@@ -311,16 +352,12 @@ void IOWorkLoop::threadMain()
        // to commit suicide.  But no matter 
        // Clear the simple lock and retore the interrupt state
        IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);
        // to commit suicide.  But no matter 
        // Clear the simple lock and retore the interrupt state
        IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);

-       if (workToDo)
-           continue;
-       else
-           break;
-    }
+    } while(workToDo);

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

-    IOExitThread(0);
+    IOExitThread();

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


@@ -374,6 +411,20 @@ void IOWorkLoop::wakeupGate(void *event, bool oneThread)
     IORecursiveLockWakeup(gateLock, event, oneThread);
 }
 
     IORecursiveLockWakeup(gateLock, event, oneThread);
 }
 

+IOReturn IOWorkLoop::runAction(Action inAction, OSObject *target,
+                                  void *arg0, void *arg1,
+                                  void *arg2, void *arg3)
+{
+    IOReturn res;
+
+    // closeGate is recursive so don't worry if we already hold the lock.
+    closeGate();
+    res = (*inAction)(target, arg0, arg1, arg2, arg3);
+    openGate();
+
+    return res;
+}
+

 IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
 {
     maintCommandEnum command = (maintCommandEnum) (vm_address_t) inC;
 IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
 {
     maintCommandEnum command = (maintCommandEnum) (vm_address_t) inC;


@@ -383,43 +434,48 @@ IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
     switch (command)
     {
     case mAddEvent:
     switch (command)
     {
     case mAddEvent:

-       SETP(&fFlags, kLoopRestart);
-        inEvent->retain();
-        inEvent->setWorkLoop(this);
-        inEvent->setNext(0);
-
-        if (!eventChain)
-            eventChain = inEvent;
-        else {
-            IOEventSource *event, *next;
-
-            for (event = eventChain; (next = event->getNext()); event = next)
-                ;
-            event->setNext(inEvent);
+        if (!inEvent->getWorkLoop()) {
+            SETP(&fFlags, kLoopRestart);
+
+            inEvent->retain();
+            inEvent->setWorkLoop(this);
+            inEvent->setNext(0);
+    
+            if (!eventChain)
+                eventChain = inEvent;
+            else {
+                IOEventSource *event, *next;
+    
+                for (event = eventChain; (next = event->getNext()); event = next)
+                    ;
+                event->setNext(inEvent);
+            }

         }
         break;
 
     case mRemoveEvent:
         }
         break;
 
     case mRemoveEvent:

-        if (eventChain == inEvent)
-            eventChain = inEvent->getNext();
-        else {
-            IOEventSource *event, *next;
-
-            event = eventChain;
-            while ((next = event->getNext()) && next != inEvent)
-                event = next;
-
-            if (!next) {
-                res = kIOReturnBadArgument;
-                break;
+        if (inEvent->getWorkLoop()) {
+            if (eventChain == inEvent)
+                eventChain = inEvent->getNext();
+            else {
+                IOEventSource *event, *next;
+    
+                event = eventChain;
+                while ((next = event->getNext()) && next != inEvent)
+                    event = next;
+    
+                if (!next) {
+                    res = kIOReturnBadArgument;
+                    break;
+                }
+                event->setNext(inEvent->getNext());

             }
             }

-            event->setNext(inEvent->getNext());
+    
+            inEvent->setWorkLoop(0);
+            inEvent->setNext(0);
+            inEvent->release();
+            SETP(&fFlags, kLoopRestart);

         }
         }

-
-        inEvent->setWorkLoop(0);
-        inEvent->setNext(0);
-        inEvent->release();
-       SETP(&fFlags, kLoopRestart);

         break;
 
     default:
         break;
 
     default: