xnu-3248.60.10.tar.gz

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

diff --git a/iokit/Kernel/IOWorkLoop.cpp b/iokit/Kernel/IOWorkLoop.cpp
index 09135d172fb390838b270f640383d76276020ff8..6207b1ea1be3a465720b954cebd2879f7d09d574 100644 (file)
--- a/iokit/Kernel/IOWorkLoop.cpp
+++ b/iokit/Kernel/IOWorkLoop.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
+ * Copyright (c) 1998-2010 Apple Inc. All rights reserved.

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


@@ -25,29 +25,31 @@
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */

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

 
 

-HISTORY
-    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 <IOKit/IOKitDebug.h>

 #include <libkern/OSDebug.h>
 #include <libkern/OSDebug.h>

+#include <kern/thread.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);


@@ -55,30 +57,81 @@ 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; }
-#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; }
 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
 

+#define passiveEventChain      reserved->passiveEventChain
+
+#if IOKITSTATS
+
+#define IOStatisticsRegisterCounter() \
+do { \
+       reserved->counter = IOStatistics::registerWorkLoop(this); \
+} while(0)
+
+#define IOStatisticsUnregisterCounter() \
+do { \
+       if (reserved) \
+               IOStatistics::unregisterWorkLoop(reserved->counter); \
+} while(0)
+
+#define IOStatisticsOpenGate() \
+do { \
+       IOStatistics::countWorkLoopOpenGate(reserved->counter); \
+} while(0)
+
+#define IOStatisticsCloseGate() \
+do { \
+       IOStatistics::countWorkLoopCloseGate(reserved->counter); \
+} while(0)
+
+#define IOStatisticsAttachEventSource() \
+do { \
+       IOStatistics::attachWorkLoopEventSource(reserved->counter, inEvent->reserved->counter); \
+} while(0)
+
+#define IOStatisticsDetachEventSource() \
+do { \
+       IOStatistics::detachWorkLoopEventSource(reserved->counter, inEvent->reserved->counter); \
+} while(0)
+
+#else
+
+#define IOStatisticsRegisterCounter()
+#define IOStatisticsUnregisterCounter()
+#define IOStatisticsOpenGate()
+#define IOStatisticsCloseGate()
+#define IOStatisticsAttachEventSource()
+#define IOStatisticsDetachEventSource()
+
+#endif /* IOKITSTATS */
+

 bool IOWorkLoop::init()
 {
 bool IOWorkLoop::init()
 {

-    // The super init and gateLock allocation MUST be done first
+    // The super init and gateLock allocation MUST be done first.

     if ( !super::init() )
         return false;
        
     if ( !super::init() )
         return false;
        

+       // Allocate our ExpansionData if it hasn't been allocated already.
+       if ( !reserved )
+       {
+               reserved = IONew(ExpansionData,1);
+               if ( !reserved )
+                       return false;
+               
+               bzero(reserved,sizeof(ExpansionData));
+       }
+       
+#if DEBUG
+       OSBacktrace ( reserved->allocationBacktrace, sizeof ( reserved->allocationBacktrace ) / sizeof ( reserved->allocationBacktrace[0] ) );
+#endif
+       

     if ( gateLock == NULL ) {
         if ( !( gateLock = IORecursiveLockAlloc()) )
             return false;
     if ( gateLock == NULL ) {
         if ( !( gateLock = IORecursiveLockAlloc()) )
             return false;


@@ -91,6 +144,8 @@ bool IOWorkLoop::init()
         workToDo = false;
     }
 
         workToDo = false;
     }
 

+    IOStatisticsRegisterCounter();
+

     if ( controlG == NULL ) {
         controlG = IOCommandGate::commandGate(
             this,
     if ( controlG == NULL ) {
         controlG = IOCommandGate::commandGate(
             this,


@@ -110,15 +165,15 @@ bool IOWorkLoop::init()
     }
 
     if ( workThread == NULL ) {
     }
 
     if ( workThread == NULL ) {

-        IOThreadFunc cptr = OSMemberFunctionCast(
-            IOThreadFunc,
+        thread_continue_t cptr = OSMemberFunctionCast(
+            thread_continue_t,

             this,
             &IOWorkLoop::threadMain);
             this,
             &IOWorkLoop::threadMain);

-        workThread = IOCreateThread(cptr, this);
-        if (!workThread)
+        if (KERN_SUCCESS != kernel_thread_start(cptr, this, &workThread))

             return false;
     }
 
             return false;
     }
 

+    (void) thread_set_tag(workThread, THREAD_TAG_IOWORKLOOP);

     return true;
 }
 
     return true;
 }
 


@@ -131,23 +186,24 @@ IOWorkLoop::workLoop()
 IOWorkLoop *
 IOWorkLoop::workLoopWithOptions(IOOptionBits options)
 {
 IOWorkLoop *
 IOWorkLoop::workLoopWithOptions(IOOptionBits options)
 {

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

        }
        }

-       me->reserved->options = options;
-    }
-
-    if (me && !me->init()) {
-        me->release();
-        return 0;
-    }
-
-    return me;
+       
+       if (me && !me->init()) {
+               me->release();
+               return 0;
+       }
+       
+       return me;

 }
 
 // Free is called twice:
 }
 
 // Free is called twice:


@@ -186,11 +242,20 @@ void IOWorkLoop::free()
         }
         eventChain = 0;
 
         }
         eventChain = 0;
 

+        for (event = passiveEventChain; event; event = next) {
+            next = event->getNext();
+            event->setWorkLoop(0);
+            event->setNext(0);
+            event->release();
+        }
+        passiveEventChain = 0;
+

        // 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) {
        // 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->workLoop = 0;

            controlG->release();
            controlG = 0;
        }
            controlG->release();
            controlG = 0;
        }


@@ -204,6 +269,9 @@ void IOWorkLoop::free()
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }
            IORecursiveLockFree(gateLock);
            gateLock = 0;
        }

+       
+       IOStatisticsUnregisterCounter();
+       

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


@@ -229,6 +297,9 @@ void IOWorkLoop::enableAllEventSources() const
 
     for (event = eventChain; event; event = event->getNext())
         event->enable();
 
     for (event = eventChain; event; event = event->getNext())
         event->enable();

+
+    for (event = passiveEventChain; event; event = event->getNext())
+        event->enable();

 }
 
 void IOWorkLoop::disableAllEventSources() const
 }
 
 void IOWorkLoop::disableAllEventSources() const


@@ -236,6 +307,10 @@ void IOWorkLoop::disableAllEventSources() const
     IOEventSource *event;
 
     for (event = eventChain; event; event = event->getNext())
     IOEventSource *event;
 
     for (event = eventChain; event; event = event->getNext())

+               event->disable();
+       
+       /* NOTE: controlG is in passiveEventChain since it's an IOCommandGate */
+    for (event = passiveEventChain; event; event = event->getNext())

         if (event != controlG) // Don't disable the control gate
             event->disable();
 }
         if (event != controlG) // Don't disable the control gate
             event->disable();
 }


@@ -243,7 +318,7 @@ void IOWorkLoop::disableAllEventSources() const
 void IOWorkLoop::enableAllInterrupts() const
 {
     IOEventSource *event;
 void IOWorkLoop::enableAllInterrupts() const
 {
     IOEventSource *event;

-
+       

     for (event = eventChain; event; event = event->getNext())
         if (OSDynamicCast(IOInterruptEventSource, event))
             event->enable();
     for (event = eventChain; event; event = event->getNext())
         if (OSDynamicCast(IOInterruptEventSource, event))
             event->enable();


@@ -252,74 +327,58 @@ void IOWorkLoop::enableAllInterrupts() const
 void IOWorkLoop::disableAllInterrupts() const
 {
     IOEventSource *event;
 void IOWorkLoop::disableAllInterrupts() const
 {
     IOEventSource *event;

-
+       

     for (event = eventChain; event; event = event->getNext())
         if (OSDynamicCast(IOInterruptEventSource, event))
             event->disable();
 }
 
     for (event = eventChain; event; event = event->getNext())
         if (OSDynamicCast(IOInterruptEventSource, event))
             event->disable();
 }
 

-#if KDEBUG
-#define IOTimeClientS()                                                        \
-do {                                                                   \
-    IOTimeStampStart(IODBG_WORKLOOP(IOWL_CLIENT),                      \
-                     (unsigned int) this, (unsigned int) event);       \
-} while(0)
-
-#define IOTimeClientE()                                                        \
-do {                                                                   \
-    IOTimeStampEnd(IODBG_WORKLOOP(IOWL_CLIENT),                                \
-                   (unsigned int) this, (unsigned int) event);         \
-} while(0)
-
-#define IOTimeWorkS()                                                  \
-do {                                                                   \
-    IOTimeStampStart(IODBG_WORKLOOP(IOWL_WORK),        (unsigned int) this);   \
-} while(0)
-
-#define IOTimeWorkE()                                                  \
-do {                                                                   \
-    IOTimeStampEnd(IODBG_WORKLOOP(IOWL_WORK),(unsigned int) this);     \
-} while(0)
-
-#else /* !KDEBUG */
-
-#define IOTimeClientS()
-#define IOTimeClientE()
-#define IOTimeWorkS()
-#define IOTimeWorkE()
-
-#endif /* KDEBUG */

 
 /* virtual */ bool IOWorkLoop::runEventSources()
 {
     bool res = false;
 
 /* virtual */ bool IOWorkLoop::runEventSources()
 {
     bool res = false;

+    bool traceWL = (gIOKitTrace & kIOTraceWorkLoops) ? true : false;
+    bool traceES = (gIOKitTrace & kIOTraceEventSources) ? true : false;
+    

     closeGate();
     if (ISSETP(&fFlags, kLoopTerminate))
     closeGate();
     if (ISSETP(&fFlags, kLoopTerminate))

-       goto abort;
-
-    IOTimeWorkS();
+               goto abort;
+       
+    if (traceWL)
+       IOTimeStampStartConstant(IODBG_WORKLOOP(IOWL_WORK), (uintptr_t) this);
+       

     bool more;
     do {
     bool more;
     do {

-       CLRP(&fFlags, kLoopRestart);
-       workToDo = more = false;
-       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;
-           }
-       }
+               CLRP(&fFlags, kLoopRestart);
+               more = false;
+               IOInterruptState is = IOSimpleLockLockDisableInterrupt(workToDoLock);
+               workToDo = false;
+               IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);
+               /* NOTE: only loop over event sources in eventChain. Bypass "passive" event sources for performance */
+               for (IOEventSource *evnt = eventChain; evnt; evnt = evnt->getNext()) {
+                       
+                       if (traceES)
+                               IOTimeStampStartConstant(IODBG_WORKLOOP(IOWL_CLIENT), (uintptr_t) this, (uintptr_t) evnt);
+                       
+                       more |= evnt->checkForWork();
+                       
+                       if (traceES)
+                               IOTimeStampEndConstant(IODBG_WORKLOOP(IOWL_CLIENT), (uintptr_t) this, (uintptr_t) evnt);
+                       
+                       if (ISSETP(&fFlags, kLoopTerminate))
+                               goto abort;
+                       else if (fFlags & kLoopRestart) {
+                               more = true;
+                               break;
+                       }
+               }

     } while (more);
     } while (more);

-
+       

     res = true;
     res = true;

-    IOTimeWorkE();
-
+       
+    if (traceWL)
+       IOTimeStampEndConstant(IODBG_WORKLOOP(IOWL_WORK), (uintptr_t) this);
+       

 abort:
     openGate();
     return res;
 abort:
     openGate();
     return res;


@@ -352,9 +411,12 @@ restartThread:
     } 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


@@ -385,22 +447,41 @@ void IOWorkLoop::signalWorkAvailable()
 
 void IOWorkLoop::openGate()
 {
 
 void IOWorkLoop::openGate()
 {

+    IOStatisticsOpenGate();

     IORecursiveLockUnlock(gateLock);
 }
 
 void IOWorkLoop::closeGate()
 {
     IORecursiveLockLock(gateLock);
     IORecursiveLockUnlock(gateLock);
 }
 
 void IOWorkLoop::closeGate()
 {
     IORecursiveLockLock(gateLock);

+    IOStatisticsCloseGate();

 }
 
 bool IOWorkLoop::tryCloseGate()
 {
 }
 
 bool IOWorkLoop::tryCloseGate()
 {

-    return IORecursiveLockTryLock(gateLock) != 0;
+    bool res = (IORecursiveLockTryLock(gateLock) != 0);
+    if (res) {
+        IOStatisticsCloseGate();
+    }
+    return res;

 }
 
 int IOWorkLoop::sleepGate(void *event, UInt32 interuptibleType)
 {
 }
 
 int IOWorkLoop::sleepGate(void *event, UInt32 interuptibleType)
 {

-    return IORecursiveLockSleep(gateLock, event, interuptibleType);
+    int res; 
+    IOStatisticsOpenGate();
+    res = IORecursiveLockSleep(gateLock, event, interuptibleType);
+    IOStatisticsCloseGate();
+    return res;
+}
+
+int IOWorkLoop::sleepGate(void *event, AbsoluteTime deadline, UInt32 interuptibleType)
+{
+    int res; 
+    IOStatisticsOpenGate();
+    res = IORecursiveLockSleepDeadline(gateLock, event, deadline, interuptibleType);
+    IOStatisticsCloseGate();
+    return res;

 }
 
 void IOWorkLoop::wakeupGate(void *event, bool oneThread)
 }
 
 void IOWorkLoop::wakeupGate(void *event, bool oneThread)


@@ -424,7 +505,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;
 


@@ -437,37 +518,79 @@ IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
             inEvent->retain();
             inEvent->setWorkLoop(this);
             inEvent->setNext(0);
             inEvent->retain();
             inEvent->setWorkLoop(this);
             inEvent->setNext(0);

+
+               /* Check if this is a passive or active event source being added */
+               if (eventSourcePerformsWork(inEvent)) {
+               
+                   if (!eventChain)
+                   eventChain = inEvent;
+                   else {
+                   IOEventSource *event, *next;

     
     

-            if (!eventChain)
-                eventChain = inEvent;
+                       for (event = eventChain; (next = event->getNext()); event = next)
+                       ;
+                       event->setNext(inEvent);
+                       
+               }
+               
+            }

             else {
             else {

-                IOEventSource *event, *next;
+               
+                   if (!passiveEventChain)
+                   passiveEventChain = inEvent;
+                   else {
+                   IOEventSource *event, *next;

     
     

-                for (event = eventChain; (next = event->getNext()); event = next)
-                    ;
-                event->setNext(inEvent);
+                       for (event = passiveEventChain; (next = event->getNext()); event = next)
+                       ;
+                       event->setNext(inEvent);
+                       
+               }
+               

             }
             }

+            IOStatisticsAttachEventSource();

         }
         break;
 
     case mRemoveEvent:
         if (inEvent->getWorkLoop()) {
         }
         break;
 
     case mRemoveEvent:
         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());
-            }
-    
+               IOStatisticsDetachEventSource();
+               
+               if (eventSourcePerformsWork(inEvent)) {
+                               if (eventChain == inEvent)
+                                       eventChain = inEvent->getNext();
+                               else {
+                                       IOEventSource *event, *next = 0;
+               
+                                       event = eventChain;
+                                       if (event) while ((next = event->getNext()) && (next != inEvent))
+                                               event = next;
+               
+                                       if (!next) {
+                                               res = kIOReturnBadArgument;
+                                               break;
+                                       }
+                                       event->setNext(inEvent->getNext());
+                               }
+               }
+               else {
+                               if (passiveEventChain == inEvent)
+                                       passiveEventChain = inEvent->getNext();
+                               else {
+                                       IOEventSource *event, *next = 0;
+               
+                                       event = passiveEventChain;
+                                       if (event) while ((next = event->getNext()) && (next != inEvent))
+                                               event = next;
+               
+                                       if (!next) {
+                                               res = kIOReturnBadArgument;
+                                               break;
+                                       }
+                                       event->setNext(inEvent->getNext());
+                               }
+               }
+               

             inEvent->setWorkLoop(0);
             inEvent->setNext(0);
             inEvent->release();
             inEvent->setWorkLoop(0);
             inEvent->setNext(0);
             inEvent->release();


@@ -481,3 +604,40 @@ IOReturn IOWorkLoop::_maintRequest(void *inC, void *inD, void *, void *)
 
     return res;
 }
 
     return res;
 }

+
+bool
+IOWorkLoop::eventSourcePerformsWork(IOEventSource *inEventSource)
+{
+       bool    result = true;
+
+       /*
+        * The idea here is to see if the subclass of IOEventSource has overridden checkForWork().
+        * The assumption is that if you override checkForWork(), you need to be
+        * active and not passive.
+        *
+        * We picked a known quantity controlG that does not override
+        * IOEventSource::checkForWork(), namely the IOCommandGate associated with
+        * the workloop to which this event source is getting attached.
+        * 
+        * We do a pointer comparison on the offset in the vtable for inNewEvent against
+        * the offset in the vtable for inReferenceEvent. This works because
+        * IOCommandGate's slot for checkForWork() has the address of
+        * IOEventSource::checkForWork() in it.
+        * 
+        * Think of OSMemberFunctionCast yielding the value at the vtable offset for
+        * checkForWork() here. We're just testing to see if it's the same or not.
+        *
+        */
+       if (controlG) {
+               void *  ptr1;
+               void *  ptr2;
+               
+               ptr1 = OSMemberFunctionCast(void*, inEventSource, &IOEventSource::checkForWork);
+               ptr2 = OSMemberFunctionCast(void*, controlG, &IOEventSource::checkForWork);
+               
+               if (ptr1 == ptr2)
+                       result = false;
+       }
+       
+    return result;
+}