iokit/Kernel/IOLocks.cpp

   1 /*
   2  * Copyright (c) 1998-2007 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
  29 #include <IOKit/system.h>
  30
  31 #include <IOKit/IOReturn.h>
  32 #include <IOKit/IOLib.h>
  33 #include <IOKit/assert.h>
  34
  35 #include <IOKit/IOLocksPrivate.h>
  36
  37 extern "C" {
  38 #include <kern/locks.h>
  39
  40 #if defined(__x86_64__)
  41 /* Synthetic event if none is specified, for backwards compatibility only. */
  42 static bool IOLockSleep_NO_EVENT __attribute__((used)) = 0;
  43 #endif
  44
  45 void    IOLockInitWithState( IOLock * lock, IOLockState state)
  46 {
  47     if( state == kIOLockStateLocked)
  48         lck_mtx_lock( lock);
  49 }
  50
  51 IOLock * IOLockAlloc( void )
  52 {
  53     return( lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL) );
  54 }
  55
  56 void    IOLockFree( IOLock * lock)
  57 {
  58     lck_mtx_free( lock, IOLockGroup);
  59 }
  60
  61 lck_mtx_t * IOLockGetMachLock( IOLock * lock)
  62 {
  63     return( (lck_mtx_t *)lock);
  64 }
  65
  66 int     IOLockSleep( IOLock * lock, void *event, UInt32 interType)
  67 {
  68     return (int) lck_mtx_sleep(lock, LCK_SLEEP_PROMOTED_PRI, (event_t) event, (wait_interrupt_t) interType);
  69 }
  70
  71 int     IOLockSleepDeadline( IOLock * lock, void *event,
  72                                 AbsoluteTime deadline, UInt32 interType)
  73 {
  74     return (int) lck_mtx_sleep_deadline(lock, LCK_SLEEP_PROMOTED_PRI, (event_t) event,
  75                                         (wait_interrupt_t) interType, __OSAbsoluteTime(deadline));
  76 }
  77
  78 void    IOLockWakeup(IOLock * lock, void *event, bool oneThread)
  79 {
  80         thread_wakeup_prim((event_t) event, oneThread, THREAD_AWAKENED);
  81 }
  82
  83
  84 #if defined(__x86_64__)
  85 /*
  86  * For backwards compatibility, kexts built against pre-Darwin 14 headers will bind at runtime to this function,
  87  * which supports a NULL event,
  88  */
  89 int     IOLockSleep_legacy_x86_64( IOLock * lock, void *event, UInt32 interType) __asm("_IOLockSleep");
  90 int     IOLockSleepDeadline_legacy_x86_64( IOLock * lock, void *event,
  91                                            AbsoluteTime deadline, UInt32 interType) __asm("_IOLockSleepDeadline");
  92 void    IOLockWakeup_legacy_x86_64(IOLock * lock, void *event, bool oneThread) __asm("_IOLockWakeup");
  93
  94 int     IOLockSleep_legacy_x86_64( IOLock * lock, void *event, UInt32 interType)
  95 {
  96     if (event == NULL)
  97         event = (void *)&IOLockSleep_NO_EVENT;
  98
  99     return IOLockSleep(lock, event, interType);
 100 }
 101
 102 int     IOLockSleepDeadline_legacy_x86_64( IOLock * lock, void *event,
 103                              AbsoluteTime deadline, UInt32 interType)
 104 {
 105     if (event == NULL)
 106         event = (void *)&IOLockSleep_NO_EVENT;
 107
 108     return IOLockSleepDeadline(lock, event, deadline, interType);
 109 }
 110
 111 void    IOLockWakeup_legacy_x86_64(IOLock * lock, void *event, bool oneThread)
 112 {
 113     if (event == NULL)
 114         event = (void *)&IOLockSleep_NO_EVENT;
 115
 116     IOLockWakeup(lock, event, oneThread);
 117 }
 118 #endif /* defined(__x86_64__) */
 119
 120
 121 struct _IORecursiveLock {
 122         lck_mtx_t       mutex;
 123         lck_grp_t       *group;
 124         thread_t        thread;
 125         UInt32          count;
 126 };
 127
 128 IORecursiveLock * IORecursiveLockAllocWithLockGroup( lck_grp_t * lockGroup )
 129 {
 130     _IORecursiveLock * lock;
 131
 132     if( lockGroup == 0 )
 133         return( 0 );
 134
 135     lock = IONew( _IORecursiveLock, 1 );
 136     if( !lock )
 137         return( 0 );
 138
 139     lck_mtx_init( &lock->mutex, lockGroup, LCK_ATTR_NULL );
 140     lock->group = lockGroup;
 141     lock->thread = 0;
 142     lock->count  = 0;
 143
 144     return( (IORecursiveLock *) lock );
 145 }
 146
 147
 148 IORecursiveLock * IORecursiveLockAlloc( void )
 149 {
 150     return IORecursiveLockAllocWithLockGroup( IOLockGroup );
 151 }
 152
 153 void IORecursiveLockFree( IORecursiveLock * _lock )
 154 {
 155     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 156
 157     lck_mtx_destroy(&lock->mutex, lock->group);
 158     IODelete( lock, _IORecursiveLock, 1 );
 159 }
 160
 161 lck_mtx_t * IORecursiveLockGetMachLock( IORecursiveLock * lock )
 162 {
 163     return( &lock->mutex );
 164 }
 165
 166 void IORecursiveLockLock( IORecursiveLock * _lock)
 167 {
 168     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 169
 170     if( lock->thread == IOThreadSelf())
 171         lock->count++;
 172     else {
 173         lck_mtx_lock( &lock->mutex );
 174         assert( lock->thread == 0 );
 175         assert( lock->count == 0 );
 176         lock->thread = IOThreadSelf();
 177         lock->count = 1;
 178     }
 179 }
 180
 181 boolean_t IORecursiveLockTryLock( IORecursiveLock * _lock)
 182 {
 183     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 184
 185     if( lock->thread == IOThreadSelf()) {
 186         lock->count++;
 187         return( true );
 188     } else {
 189         if( lck_mtx_try_lock( &lock->mutex )) {
 190             assert( lock->thread == 0 );
 191             assert( lock->count == 0 );
 192             lock->thread = IOThreadSelf();
 193             lock->count = 1;
 194             return( true );
 195         }
 196     }
 197     return( false );
 198 }
 199
 200 void IORecursiveLockUnlock( IORecursiveLock * _lock)
 201 {
 202     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 203
 204     assert( lock->thread == IOThreadSelf() );
 205
 206     if( 0 == (--lock->count)) {
 207         lock->thread = 0;
 208         lck_mtx_unlock( &lock->mutex );
 209     }
 210 }
 211
 212 boolean_t IORecursiveLockHaveLock( const IORecursiveLock * _lock)
 213 {
 214     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 215
 216     return( lock->thread == IOThreadSelf());
 217 }
 218
 219 int IORecursiveLockSleep(IORecursiveLock *_lock, void *event, UInt32 interType)
 220 {
 221     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 222     UInt32 count = lock->count;
 223     int res;
 224
 225     assert(lock->thread == IOThreadSelf());
 226
 227     lock->count = 0;
 228     lock->thread = 0;
 229     res = lck_mtx_sleep(&lock->mutex, LCK_SLEEP_PROMOTED_PRI, (event_t) event, (wait_interrupt_t) interType);
 230
 231     // Must re-establish the recursive lock no matter why we woke up
 232     // otherwise we would potentially leave the return path corrupted.
 233     assert(lock->thread == 0);
 234     assert(lock->count == 0);
 235     lock->thread = IOThreadSelf();
 236     lock->count = count;
 237     return res;
 238 }
 239
 240 int     IORecursiveLockSleepDeadline( IORecursiveLock * _lock, void *event,
 241                                   AbsoluteTime deadline, UInt32 interType)
 242 {
 243     _IORecursiveLock * lock = (_IORecursiveLock *)_lock;
 244     UInt32 count = lock->count;
 245     int res;
 246
 247     assert(lock->thread == IOThreadSelf());
 248
 249     lock->count = 0;
 250     lock->thread = 0;
 251     res = lck_mtx_sleep_deadline(&lock->mutex, LCK_SLEEP_PROMOTED_PRI, (event_t) event,
 252                                                                       (wait_interrupt_t) interType, __OSAbsoluteTime(deadline));
 253
 254     // Must re-establish the recursive lock no matter why we woke up
 255     // otherwise we would potentially leave the return path corrupted.
 256     assert(lock->thread == 0);
 257     assert(lock->count == 0);
 258     lock->thread = IOThreadSelf();
 259     lock->count = count;
 260     return res;
 261 }
 262
 263 void IORecursiveLockWakeup(IORecursiveLock *, void *event, bool oneThread)
 264 {
 265     thread_wakeup_prim((event_t) event, oneThread, THREAD_AWAKENED);
 266 }
 267
 268 /*
 269  * Complex (read/write) lock operations
 270  */
 271
 272 IORWLock * IORWLockAlloc( void )
 273 {
 274     return(  lck_rw_alloc_init(IOLockGroup, LCK_ATTR_NULL)  );
 275 }
 276
 277 void    IORWLockFree( IORWLock * lock)
 278 {
 279     lck_rw_free( lock, IOLockGroup);
 280 }
 281
 282 lck_rw_t * IORWLockGetMachLock( IORWLock * lock)
 283 {
 284     return( (lck_rw_t *)lock);
 285 }
 286
 287
 288 /*
 289  * Spin locks
 290  */
 291
 292 IOSimpleLock * IOSimpleLockAlloc( void )
 293 {
 294     return( lck_spin_alloc_init( IOLockGroup, LCK_ATTR_NULL) );
 295 }
 296
 297 void IOSimpleLockInit( IOSimpleLock * lock)
 298 {
 299     lck_spin_init( lock, IOLockGroup, LCK_ATTR_NULL);
 300 }
 301
 302 void IOSimpleLockFree( IOSimpleLock * lock )
 303 {
 304     lck_spin_free( lock, IOLockGroup);
 305 }
 306
 307 lck_spin_t * IOSimpleLockGetMachLock( IOSimpleLock * lock)
 308 {
 309     return( (lck_spin_t *)lock);
 310 }
 311
 312 #ifndef IOLOCKS_INLINE
 313 /*
 314  * Lock assertions
 315  */
 316
 317 void
 318 IOLockAssert(IOLock * lock, IOLockAssertState type)
 319 {
 320     LCK_MTX_ASSERT(lock, type);
 321 }
 322
 323 void
 324 IORWLockAssert(IORWLock * lock, IORWLockAssertState type)
 325 {
 326     LCK_RW_ASSERT(lock, type);
 327 }
 328
 329 void
 330 IOSimpleLockAssert(IOSimpleLock *lock, IOSimpleLockAssertState type)
 331 {
 332     LCK_SPIN_ASSERT(l, type);
 333 }
 334 #endif /* !IOLOCKS_INLINE */
 335
 336 } /* extern "C" */
 337
 338