X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/55e303ae13a4cf49d70f2294092726f2fffb9ef2..c6bf4f310a33a9262d455ea4d3f0630b1255e3fe:/iokit/Kernel/IOConditionLock.cpp diff --git a/iokit/Kernel/IOConditionLock.cpp b/iokit/Kernel/IOConditionLock.cpp index 7d0916893..c24d8ce35 100644 --- a/iokit/Kernel/IOConditionLock.cpp +++ b/iokit/Kernel/IOConditionLock.cpp @@ -1,17 +1,20 @@ /* * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. - * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in - * compliance with the License. Please obtain a copy of the License at - * http://www.opensource.apple.com/apsl/ and read it before using this - * file. - * + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -19,19 +22,19 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * - * @APPLE_LICENSE_HEADER_END@ + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* Copyright (c) 1997 Apple Computer, Inc. All rights reserved. - * Copyright (c) 1994-1996 NeXT Software, Inc. All rights reserved. + * Copyright (c) 1994-1996 NeXT Software, Inc. All rights reserved. * - * AppleIOPSSafeCondLock.m. Lock object with exported condition variable, + * AppleIOPSSafeCondLock.m. Lock object with exported condition variable, * kernel version. * * HISTORY * 1997-11- * 01-Aug-91 Doug Mitchell at NeXT - * Created. + * Created. */ #include @@ -39,159 +42,173 @@ #define super OSObject OSDefineMetaClassAndStructors(IOConditionLock, OSObject) -bool IOConditionLock::initWithCondition(int inCondition, bool inIntr) +bool +IOConditionLock::initWithCondition(int inCondition, bool inIntr) { - if (!super::init()) - return false; + if (!super::init()) { + return false; + } - cond_interlock = IOLockAlloc(); - sleep_interlock = IOLockAlloc(); + cond_interlock = IOLockAlloc(); + sleep_interlock = IOLockAlloc(); - condition = inCondition; - want_lock = false; - waiting = false; - interruptible = (inIntr) ? THREAD_INTERRUPTIBLE : THREAD_UNINT; + condition = inCondition; + want_lock = false; + waiting = false; + interruptible = (inIntr) ? THREAD_INTERRUPTIBLE : THREAD_UNINT; - return cond_interlock && sleep_interlock; + return cond_interlock && sleep_interlock; } -IOConditionLock *IOConditionLock::withCondition(int condition, bool intr) +IOConditionLock * +IOConditionLock::withCondition(int condition, bool intr) { - IOConditionLock *me = new IOConditionLock; + IOConditionLock *me = new IOConditionLock; - if (me && !me->initWithCondition(condition, intr)) { - me->release(); - return 0; - } + if (me && !me->initWithCondition(condition, intr)) { + me->release(); + return NULL; + } - return me; + return me; } -void IOConditionLock::free() +void +IOConditionLock::free() { - if (cond_interlock) - IOLockFree(cond_interlock); - if (sleep_interlock) - IOLockFree(sleep_interlock); - super::free(); + if (cond_interlock) { + IOLockFree(cond_interlock); + } + if (sleep_interlock) { + IOLockFree(sleep_interlock); + } + super::free(); } -bool IOConditionLock::getInterruptible() const +bool +IOConditionLock::getInterruptible() const { - return interruptible; + return interruptible; } -int IOConditionLock:: getCondition() const +int +IOConditionLock:: getCondition() const { - return condition; + return condition; } -int IOConditionLock:: setCondition(int inCondition) +int +IOConditionLock:: setCondition(int inCondition) { - int old = condition; + int old = condition; - condition = inCondition; - thread_wakeup_one((void *) &condition); + condition = inCondition; + thread_wakeup_one((void *) &condition); - return old; + return old; } -void IOConditionLock::unlock() +void +IOConditionLock::unlock() { - IOTakeLock(sleep_interlock); + IOTakeLock(sleep_interlock); - thread_wakeup_one((void *) &condition); + thread_wakeup_one((void *) &condition); - want_lock = false; - if (waiting) { - waiting = false; - IOLockWakeup(sleep_interlock, this, /* one-thread */ false); // Wakeup everybody - } + want_lock = false; + if (waiting) { + waiting = false; + IOLockWakeup(sleep_interlock, this, /* one-thread */ false); // Wakeup everybody + } - IOUnlock(sleep_interlock); + IOUnlock(sleep_interlock); } -void IOConditionLock::unlockWith(int inCondition) +void +IOConditionLock::unlockWith(int inCondition) { - IOTakeLock(sleep_interlock); - IOTakeLock(cond_interlock); - - condition = inCondition; + IOTakeLock(sleep_interlock); + IOTakeLock(cond_interlock); + + condition = inCondition; - IOUnlock(cond_interlock); - IOUnlock(sleep_interlock); + IOUnlock(cond_interlock); + IOUnlock(sleep_interlock); - unlock(); + unlock(); } -bool IOConditionLock::tryLock() +bool +IOConditionLock::tryLock() { - bool result; + bool result; - IOTakeLock(sleep_interlock); + IOTakeLock(sleep_interlock); - result = !want_lock; - if (result) - want_lock = true; + result = !want_lock; + if (result) { + want_lock = true; + } - IOUnlock(sleep_interlock); + IOUnlock(sleep_interlock); - return result; + return result; } -int IOConditionLock::lock() +int +IOConditionLock::lock() { - int thread_res = THREAD_AWAKENED; - - IOTakeLock(sleep_interlock); - - /* Try to acquire the want_lock bit. */ - while (want_lock && thread_res == THREAD_AWAKENED) - { - waiting = true; - thread_res = IOLockSleep(sleep_interlock, (void *) this, interruptible); - } - if (thread_res == THREAD_AWAKENED) - want_lock = true; - - IOUnlock(sleep_interlock); - - return thread_res; + int thread_res = THREAD_AWAKENED; + + IOTakeLock(sleep_interlock); + + /* Try to acquire the want_lock bit. */ + while (want_lock && thread_res == THREAD_AWAKENED) { + waiting = true; + thread_res = IOLockSleep(sleep_interlock, (void *) this, interruptible); + } + if (thread_res == THREAD_AWAKENED) { + want_lock = true; + } + + IOUnlock(sleep_interlock); + + return thread_res; } -int IOConditionLock::lockWhen(int inCondition) +int +IOConditionLock::lockWhen(int inCondition) { - int thread_res; - - do - { - /* First get the actual lock */ - thread_res = lock(); - if (thread_res != THREAD_AWAKENED) - break; // Failed to acquire lock - - if (inCondition == condition) - break; // Hold lock and condition is expected value - - /* - * Need to hold a IOTakeLock when we call thread_sleep(). - * Both _cond_interlock and want_lock must be held to - * change _condition. - */ - IOTakeLock(cond_interlock); - unlock(); // Release lock and sleep - - /* - * this is the critical section on a multi in which - * another thread could hold _sleep_interlock, but they - * can't change _condition. Holding _cond_interlock here - * (until after assert_wait() is called from - * thread_sleep()) ensures that we'll be notified - * of changes in _condition. - */ - assert_wait((void *) &condition, interruptible); /* assert event */ - IOUnlock(cond_interlock); /* release the lock */ - thread_res = thread_block(THREAD_CONTINUE_NULL); /* block ourselves */ - } while (thread_res == THREAD_AWAKENED); - - return thread_res; + int thread_res; + + do{ + /* First get the actual lock */ + thread_res = lock(); + if (thread_res != THREAD_AWAKENED) { + break; // Failed to acquire lock + } + if (inCondition == condition) { + break; // Hold lock and condition is expected value + } + /* + * Need to hold a IOTakeLock when we call thread_sleep(). + * Both _cond_interlock and want_lock must be held to + * change _condition. + */ + IOTakeLock(cond_interlock); + unlock(); // Release lock and sleep + + /* + * this is the critical section on a multi in which + * another thread could hold _sleep_interlock, but they + * can't change _condition. Holding _cond_interlock here + * (until after assert_wait() is called from + * thread_sleep()) ensures that we'll be notified + * of changes in _condition. + */ + assert_wait((void *) &condition, interruptible); /* assert event */ + IOUnlock(cond_interlock); /* release the lock */ + thread_res = thread_block(THREAD_CONTINUE_NULL); /* block ourselves */ + } while (thread_res == THREAD_AWAKENED); + + return thread_res; }