iokit/Kernel/IOSyncer.cpp

   1 /*
   2  * Copyright (c) 1998-2000 Apple Computer, 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 /* IOSyncer.cpp created by wgulland on 2000-02-02 */
  29
  30 #include <IOKit/IOLib.h>
  31 #include <IOKit/IOSyncer.h>
  32
  33 OSDefineMetaClassAndStructors(IOSyncer, OSObject)
  34
  35 IOSyncer * IOSyncer::create(bool twoRetains)
  36 {
  37         IOSyncer * me = new IOSyncer;
  38
  39         if (me && !me->init(twoRetains)) {
  40                 me->release();
  41                 return NULL;
  42         }
  43
  44         return me;
  45 }
  46
  47 bool
  48 IOSyncer::init(bool twoRetains)
  49 {
  50         if (!OSObject::init()) {
  51                 return false;
  52         }
  53
  54         if (!(guardLock = IOSimpleLockAlloc())) {
  55                 return false;
  56         }
  57
  58         IOSimpleLockInit(guardLock);
  59
  60         if (twoRetains) {
  61                 retain();
  62         }
  63
  64         fResult = kIOReturnSuccess;
  65
  66         reinit();
  67
  68         return true;
  69 }
  70
  71 void
  72 IOSyncer::reinit()
  73 {
  74         IOInterruptState is = IOSimpleLockLockDisableInterrupt(guardLock);
  75         threadMustStop = true;
  76         IOSimpleLockUnlockEnableInterrupt(guardLock, is);
  77 }
  78
  79 void
  80 IOSyncer::free()
  81 {
  82         // just in case a thread is blocked here:
  83         privateSignal();
  84
  85         if (guardLock != NULL) {
  86                 IOSimpleLockFree(guardLock);
  87         }
  88
  89         OSObject::free();
  90 }
  91
  92 IOReturn
  93 IOSyncer::wait(bool autoRelease)
  94 {
  95         IOInterruptState is = IOSimpleLockLockDisableInterrupt(guardLock);
  96
  97         if (threadMustStop) {
  98                 assert_wait((void *) &threadMustStop, false);
  99                 IOSimpleLockUnlockEnableInterrupt(guardLock, is);
 100                 thread_block(THREAD_CONTINUE_NULL);
 101         } else {
 102                 IOSimpleLockUnlockEnableInterrupt(guardLock, is);
 103         }
 104
 105         IOReturn result = fResult; // Pick up before auto deleting!
 106
 107         if (autoRelease) {
 108                 release();
 109         }
 110
 111         return result;
 112 }
 113
 114 void
 115 IOSyncer::signal(IOReturn res, bool autoRelease)
 116 {
 117         fResult = res;
 118         privateSignal();
 119         if (autoRelease) {
 120                 release();
 121         }
 122 }
 123
 124 void
 125 IOSyncer::privateSignal()
 126 {
 127         if (threadMustStop) {
 128                 IOInterruptState is = IOSimpleLockLockDisableInterrupt(guardLock);
 129                 threadMustStop = false;
 130                 thread_wakeup_one((void *) &threadMustStop);
 131                 IOSimpleLockUnlockEnableInterrupt(guardLock, is);
 132         }
 133 }