iokit/Kernel/IOCommandGate.cpp

   1 /*
   2  * Copyright (c) 1998-2000, 2009-2010 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #include <libkern/OSDebug.h>
  29
  30 #include <IOKit/IOCommandGate.h>
  31 #include <IOKit/IOWorkLoop.h>
  32 #include <IOKit/IOReturn.h>
  33 #include <IOKit/IOTimeStamp.h>
  34 #include <IOKit/IOKitDebug.h>
  35
  36 #define super IOEventSource
  37
  38 OSDefineMetaClassAndStructors(IOCommandGate, IOEventSource)
  39 #if __LP64__
  40 OSMetaClassDefineReservedUnused(IOCommandGate, 0);
  41 #else
  42 OSMetaClassDefineReservedUsed(IOCommandGate, 0);
  43 #endif
  44 OSMetaClassDefineReservedUnused(IOCommandGate, 1);
  45 OSMetaClassDefineReservedUnused(IOCommandGate, 2);
  46 OSMetaClassDefineReservedUnused(IOCommandGate, 3);
  47 OSMetaClassDefineReservedUnused(IOCommandGate, 4);
  48 OSMetaClassDefineReservedUnused(IOCommandGate, 5);
  49 OSMetaClassDefineReservedUnused(IOCommandGate, 6);
  50 OSMetaClassDefineReservedUnused(IOCommandGate, 7);
  51
  52 #if IOKITSTATS
  53
  54 #define IOStatisticsInitializeCounter() \
  55 do { \
  56         IOStatistics::setCounterType(IOEventSource::reserved->counter, kIOStatisticsCommandGateCounter); \
  57 } while (0)
  58
  59 #define IOStatisticsActionCall() \
  60 do { \
  61         IOStatistics::countCommandGateActionCall(IOEventSource::reserved->counter); \
  62 } while (0)
  63
  64 #else
  65
  66 #define IOStatisticsInitializeCounter()
  67 #define IOStatisticsActionCall()
  68
  69 #endif /* IOKITSTATS */
  70
  71 bool IOCommandGate::init(OSObject *inOwner, Action inAction)
  72 {
  73     bool res = super::init(inOwner, (IOEventSource::Action) inAction);
  74     if (res) {
  75         IOStatisticsInitializeCounter();
  76     }
  77
  78     return res;
  79 }
  80
  81 IOCommandGate *
  82 IOCommandGate::commandGate(OSObject *inOwner, Action inAction)
  83 {
  84     IOCommandGate *me = new IOCommandGate;
  85
  86     if (me && !me->init(inOwner, inAction)) {
  87         me->release();
  88         return 0;
  89     }
  90
  91     return me;
  92 }
  93
  94 /* virtual */ void IOCommandGate::disable()
  95 {
  96     if (workLoop && !workLoop->inGate())
  97         OSReportWithBacktrace("IOCommandGate::disable() called when not gated");
  98
  99     super::disable();
 100 }
 101
 102 /* virtual */ void IOCommandGate::enable()
 103 {
 104     if (workLoop) {
 105         closeGate();
 106         super::enable();
 107         wakeupGate(&enabled, /* oneThread */ false); // Unblock sleeping threads
 108         openGate();
 109     }
 110 }
 111
 112 /* virtual */ void IOCommandGate::free()
 113 {
 114     if (workLoop) setWorkLoop(0);
 115     super::free();
 116 }
 117
 118 enum
 119 {
 120     kSleepersRemoved     = 0x00000001,
 121     kSleepersWaitEnabled = 0x00000002,
 122     kSleepersActions     = 0x00000100,
 123     kSleepersActionsMask = 0xffffff00,
 124 };
 125
 126 /* virtual */ void IOCommandGate::setWorkLoop(IOWorkLoop *inWorkLoop)
 127 {
 128     IOWorkLoop * wl;
 129     uintptr_t  * sleepersP = (uintptr_t *) &reserved;
 130     bool         defer;
 131
 132     if (!inWorkLoop && (wl = workLoop)) {               // tearing down
 133         wl->closeGate();
 134         *sleepersP |= kSleepersRemoved;
 135         while (*sleepersP & kSleepersWaitEnabled) {
 136             thread_wakeup_with_result(&enabled, THREAD_INTERRUPTED);
 137             sleepGate(sleepersP, THREAD_UNINT);
 138         }
 139         *sleepersP &= ~kSleepersWaitEnabled;
 140         defer = (0 != (kSleepersActionsMask & *sleepersP));
 141         if (!defer)
 142         {
 143             super::setWorkLoop(0);
 144             *sleepersP &= ~kSleepersRemoved;
 145         }
 146         wl->openGate();
 147         return;
 148     }
 149
 150     super::setWorkLoop(inWorkLoop);
 151 }
 152
 153 IOReturn IOCommandGate::runCommand(void *arg0, void *arg1,
 154                                    void *arg2, void *arg3)
 155 {
 156     return runAction((Action) action, arg0, arg1, arg2, arg3);
 157 }
 158
 159 IOReturn IOCommandGate::attemptCommand(void *arg0, void *arg1,
 160                                        void *arg2, void *arg3)
 161 {
 162     return attemptAction((Action) action, arg0, arg1, arg2, arg3);
 163 }
 164
 165 IOReturn IOCommandGate::runAction(Action inAction,
 166                                   void *arg0, void *arg1,
 167                                   void *arg2, void *arg3)
 168 {
 169     IOWorkLoop * wl;
 170     uintptr_t  * sleepersP;
 171
 172     if (!inAction)
 173         return kIOReturnBadArgument;
 174     if (!(wl = workLoop))
 175         return kIOReturnNotReady;
 176
 177     // closeGate is recursive needn't worry if we already hold the lock.
 178     wl->closeGate();
 179     sleepersP = (uintptr_t *) &reserved;
 180
 181     // If the command gate is disabled and we aren't on the workloop thread
 182     // itself then sleep until we get enabled.
 183     IOReturn res;
 184     if (!wl->onThread())
 185     {
 186         while (!enabled)
 187         {
 188             IOReturn sleepResult = kIOReturnSuccess;
 189             if (workLoop)
 190             {
 191                 *sleepersP |= kSleepersWaitEnabled;
 192                 sleepResult = wl->sleepGate(&enabled, THREAD_INTERRUPTIBLE);
 193                 *sleepersP &= ~kSleepersWaitEnabled;
 194             }
 195             bool wakeupTearDown = (!workLoop || (0 != (*sleepersP & kSleepersRemoved)));
 196             if ((kIOReturnSuccess != sleepResult) || wakeupTearDown) {
 197                 wl->openGate();
 198
 199                  if (wakeupTearDown)
 200                      wl->wakeupGate(sleepersP, false);  // No further resources used
 201
 202                 return kIOReturnAborted;
 203             }
 204         }
 205     }
 206
 207     bool trace = ( gIOKitTrace & kIOTraceCommandGates ) ? true : false;
 208
 209     if (trace) IOTimeStampStartConstant(IODBG_CMDQ(IOCMDQ_ACTION),
 210                                          VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
 211
 212     IOStatisticsActionCall();
 213
 214     // Must be gated and on the work loop or enabled
 215
 216     *sleepersP += kSleepersActions;
 217     res = (*inAction)(owner, arg0, arg1, arg2, arg3);
 218     *sleepersP -= kSleepersActions;
 219
 220     if (trace) IOTimeStampEndConstant(IODBG_CMDQ(IOCMDQ_ACTION),
 221                                        VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
 222
 223     if (kSleepersRemoved == ((kSleepersActionsMask|kSleepersRemoved) & *sleepersP))
 224     {
 225         // no actions outstanding
 226         *sleepersP &= ~kSleepersRemoved;
 227         super::setWorkLoop(0);
 228     }
 229
 230     wl->openGate();
 231
 232     return res;
 233 }
 234
 235 IOReturn IOCommandGate::attemptAction(Action inAction,
 236                                       void *arg0, void *arg1,
 237                                       void *arg2, void *arg3)
 238 {
 239     IOReturn res;
 240     IOWorkLoop * wl;
 241
 242     if (!inAction)
 243         return kIOReturnBadArgument;
 244     if (!(wl = workLoop))
 245         return kIOReturnNotReady;
 246
 247     // Try to close the gate if can't get return immediately.
 248     if (!wl->tryCloseGate())
 249         return kIOReturnCannotLock;
 250
 251     // If the command gate is disabled then sleep until we get a wakeup
 252     if (!wl->onThread() && !enabled)
 253         res = kIOReturnNotPermitted;
 254     else {
 255
 256         bool trace = ( gIOKitTrace & kIOTraceCommandGates ) ? true : false;
 257
 258         if (trace)
 259             IOTimeStampStartConstant(IODBG_CMDQ(IOCMDQ_ACTION),
 260                                      VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
 261
 262         IOStatisticsActionCall();
 263
 264         res = (*inAction)(owner, arg0, arg1, arg2, arg3);
 265
 266         if (trace)
 267             IOTimeStampEndConstant(IODBG_CMDQ(IOCMDQ_ACTION),
 268                                    VM_KERNEL_ADDRHIDE(inAction), VM_KERNEL_ADDRHIDE(owner));
 269     }
 270
 271     wl->openGate();
 272
 273     return res;
 274 }
 275
 276 IOReturn IOCommandGate::commandSleep(void *event, UInt32 interruptible)
 277 {
 278     if (!workLoop->inGate())
 279         return kIOReturnNotPermitted;
 280
 281     return sleepGate(event, interruptible);
 282 }
 283
 284 IOReturn IOCommandGate::commandSleep(void *event, AbsoluteTime deadline, UInt32 interruptible)
 285 {
 286     if (!workLoop->inGate())
 287         return kIOReturnNotPermitted;
 288
 289     return sleepGate(event, deadline, interruptible);
 290 }
 291
 292 void IOCommandGate::commandWakeup(void *event, bool oneThread)
 293 {
 294     wakeupGate(event, oneThread);
 295 }