xnu-6153.81.5.tar.gz

[apple/xnu.git] / iokit / Kernel / IOConditionLock.cpp

diff --git a/iokit/Kernel/IOConditionLock.cpp b/iokit/Kernel/IOConditionLock.cpp
index 680f0a6af22f78d9155487360708095d8c675f16..c24d8ce352267e05b0230485c103cc50aebf8ad0 100644 (file)
--- a/iokit/Kernel/IOConditionLock.cpp
+++ b/iokit/Kernel/IOConditionLock.cpp
@@ -1,17 +1,20 @@
 /*
  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
  *
 /*
  * 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
  * 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,
  * 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.
  * 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) 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
  *     kernel version.
  *
  * HISTORY
  * 1997-11-
  * 01-Aug-91    Doug Mitchell at NeXT

- *      Created. 
+ *      Created.

  */
 
 #include <IOKit/IOConditionLock.h>
  */
 
 #include <IOKit/IOConditionLock.h>


@@ -39,159 +42,173 @@
 #define super OSObject
 OSDefineMetaClassAndStructors(IOConditionLock, OSObject)
 
 #define super OSObject
 OSDefineMetaClassAndStructors(IOConditionLock, OSObject)
 

-bool IOConditionLock::initWithCondition(int inCondition, bool inIntr = true)
+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 = true)
+IOConditionLock *
+IOConditionLock::withCondition(int condition, bool intr)

 {
 {

-    IOConditionLock *me = new IOConditionLock;
+       IOConditionLock *me = new IOConditionLock;

 
 

-    if (me && !me->initWithCondition(condition, intr)) {
-        me->free();
-        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;

 }
 }