iokit/Kernel/IOLocks.cpp

   1 /*
   2  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_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. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  * Copyright (c) 1998 Apple Computer, Inc.  All rights reserved.
  25  *
  26  * HISTORY
  27  *
  28  */
  29
  30
  31 #define IOLOCKS_CPP     1
  32
  33 #include <IOKit/system.h>
  34
  35 #include <IOKit/IOReturn.h>
  36 #include <IOKit/IOLib.h>
  37 #include <IOKit/assert.h>
  38
  39 extern "C" {
  40 #include <kern/locks.h>
  41
  42 void    IOLockInitWithState( IOLock * lock, IOLockState state)
  43 {
  44     if( state == kIOLockStateLocked)
  45         lck_mtx_lock( lock);
  46 }
  47
  48 IOLock * IOLockAlloc( void )
  49 {
  50     return( lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL) );
  51 }
  52
  53 void    IOLockFree( IOLock * lock)
  54 {
  55     lck_mtx_free( lock, IOLockGroup);
  56 }
  57
  58 lck_mtx_t * IOLockGetMachLock( IOLock * lock)
  59 {
  60     return( (lck_mtx_t *)lock);
  61 }
  62
  63 int     IOLockSleep( IOLock * lock, void *event, UInt32 interType)
  64 {
  65     return (int) lck_mtx_sleep(lock, LCK_SLEEP_DEFAULT, (event_t) event, (wait_interrupt_t) interType);
  66 }
  67
  68 int     IOLockSleepDeadline( IOLock * lock, void *event,
  69                                 AbsoluteTime deadline, UInt32 interType)
  70 {
  71     return (int) lck_mtx_sleep_deadline(lock, LCK_SLEEP_DEFAULT, (event_t) event,
  72                                         (wait_interrupt_t) interType, __OSAbsoluteTime(deadline));
  73 }
  74
  75 void    IOLockWakeup(IOLock * lock, void *event, bool oneThread)
  76 {
  77         thread_wakeup_prim((event_t) event, oneThread, THREAD_AWAKENED);
  78 }
  79
  80
  81 struct _IORecursiveLock {
  82     lck_mtx_t   *mutex;
  83     thread_t    thread;
  84     UInt32      count;
  85 };
  86
  87 IORecursiveLock * IORecursiveLockAlloc( void )
  88 {
  89     _IORecursiveLock * lock;
  90
  91     lock = IONew( _IORecursiveLock, 1);
  92     if( !lock)
  93         return( 0 );
  94
  95     lock->mutex = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
  96     if( lock->mutex) {
  97         lock->thread = 0;
  98         lock->count  = 0;
  99     } else {
 100         IODelete( lock, _IORecursiveLock, 1);
 101         lock = 0;
 102     }
 103
 104     return( (IORecursiveLock *) lock );
 105 }
 106
 107 void IORecursiveLockFree( IORecursiveLock * _lock )
 108 {
 109     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 110
 111     lck_mtx_free( lock->mutex , IOLockGroup);
 112     IODelete( lock, _IORecursiveLock, 1);
 113 }
 114
 115 lck_mtx_t * IORecursiveLockGetMachLock( IORecursiveLock * lock)
 116 {
 117     return( lock->mutex);
 118 }
 119
 120 void IORecursiveLockLock( IORecursiveLock * _lock)
 121 {
 122     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 123
 124     if( lock->thread == IOThreadSelf())
 125         lock->count++;
 126     else {
 127         lck_mtx_lock( lock->mutex );
 128         assert( lock->thread == 0 );
 129         assert( lock->count == 0 );
 130         lock->thread = IOThreadSelf();
 131         lock->count = 1;
 132     }
 133 }
 134
 135 boolean_t IORecursiveLockTryLock( IORecursiveLock * _lock)
 136 {
 137     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 138
 139     if( lock->thread == IOThreadSelf()) {
 140         lock->count++;
 141         return( true );
 142     } else {
 143         if( lck_mtx_try_lock( lock->mutex )) {
 144             assert( lock->thread == 0 );
 145             assert( lock->count == 0 );
 146             lock->thread = IOThreadSelf();
 147             lock->count = 1;
 148             return( true );
 149         }
 150     }
 151     return( false );
 152 }
 153
 154 void IORecursiveLockUnlock( IORecursiveLock * _lock)
 155 {
 156     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 157
 158     assert( lock->thread == IOThreadSelf() );
 159
 160     if( 0 == (--lock->count)) {
 161         lock->thread = 0;
 162         lck_mtx_unlock( lock->mutex );
 163     }
 164 }
 165
 166 boolean_t IORecursiveLockHaveLock( const IORecursiveLock * _lock)
 167 {
 168     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 169
 170     return( lock->thread == IOThreadSelf());
 171 }
 172
 173 int IORecursiveLockSleep(IORecursiveLock *_lock, void *event, UInt32 interType)
 174 {
 175     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 176     UInt32 count = lock->count;
 177     int res;
 178
 179     assert(lock->thread == IOThreadSelf());
 180     assert(lock->count == 1 || interType == THREAD_UNINT);
 181
 182     lock->count = 0;
 183     lock->thread = 0;
 184     res = lck_mtx_sleep(lock->mutex, LCK_SLEEP_DEFAULT, (event_t) event, (wait_interrupt_t) interType);
 185
 186     // Must re-establish the recursive lock no matter why we woke up
 187     // otherwise we would potentially leave the return path corrupted.
 188     assert(lock->thread == 0);
 189     assert(lock->count == 0);
 190     lock->thread = IOThreadSelf();
 191     lock->count = count;
 192     return res;
 193 }
 194
 195 void IORecursiveLockWakeup(IORecursiveLock *, void *event, bool oneThread)
 196 {
 197     thread_wakeup_prim((event_t) event, oneThread, THREAD_AWAKENED);
 198 }
 199
 200 /*
 201  * Complex (read/write) lock operations
 202  */
 203
 204 IORWLock * IORWLockAlloc( void )
 205 {
 206     return(  lck_rw_alloc_init(IOLockGroup, LCK_ATTR_NULL)  );
 207 }
 208
 209 void    IORWLockFree( IORWLock * lock)
 210 {
 211     lck_rw_free( lock, IOLockGroup);
 212 }
 213
 214 lck_rw_t * IORWLockGetMachLock( IORWLock * lock)
 215 {
 216     return( (lck_rw_t *)lock);
 217 }
 218
 219
 220 /*
 221  * Spin locks
 222  */
 223
 224 IOSimpleLock * IOSimpleLockAlloc( void )
 225 {
 226     return( lck_spin_alloc_init( IOLockGroup, LCK_ATTR_NULL) );
 227 }
 228
 229 void IOSimpleLockInit( IOSimpleLock * lock)
 230 {
 231     lck_spin_init( lock, IOLockGroup, LCK_ATTR_NULL);
 232 }
 233
 234 void IOSimpleLockFree( IOSimpleLock * lock )
 235 {
 236     lck_spin_free( lock, IOLockGroup);
 237 }
 238
 239 lck_spin_t * IOSimpleLockGetMachLock( IOSimpleLock * lock)
 240 {
 241     return( (lck_spin_t *)lock);
 242 }
 243
 244 } /* extern "C" */
 245
 246