iokit/Kernel/IOPMinformeeList.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 #include <IOKit/pwr_mgt/IOPM.h>
  29 #include <IOKit/pwr_mgt/IOPMinformeeList.h>
  30 #include <IOKit/pwr_mgt/IOPMinformee.h>
  31
  32 #define super OSObject
  33 OSDefineMetaClassAndStructors(IOPMinformeeList, OSObject)
  34
  35 //*********************************************************************************
  36 // init
  37 //
  38 //*********************************************************************************
  39 void
  40 IOPMinformeeList::initialize( void )
  41 {
  42         firstItem = NULL;
  43         length = 0;
  44 }
  45
  46 //******************************************************************************
  47 // getSharedRecursiveLock
  48 //
  49 //******************************************************************************
  50 IORecursiveLock *
  51 IOPMinformeeList::getSharedRecursiveLock( void )
  52 {
  53         static IORecursiveLock *sharedListLock = NULL;
  54
  55         /* A running system could have 50-60+ instances of IOPMInformeeList.
  56          * They'll share this lock, since list insertion and removal is relatively
  57          * rare, and generally tied to major events like device discovery.
  58          *
  59          * getSharedRecursiveLock() is called from IOStartIOKit to initialize
  60          * the sharedListLock before any IOPMinformeeLists are instantiated.
  61          *
  62          * The IOPMinformeeList class will be around for the lifetime of the system,
  63          * we don't worry about freeing this lock.
  64          */
  65
  66         if (NULL == sharedListLock) {
  67                 sharedListLock = IORecursiveLockAlloc();
  68         }
  69         return sharedListLock;
  70 }
  71
  72 //*********************************************************************************
  73 // appendNewInformee
  74 //
  75 //*********************************************************************************
  76 IOPMinformee *
  77 IOPMinformeeList::appendNewInformee( IOService * newObject )
  78 {
  79         IOPMinformee * newInformee;
  80
  81         if (!newObject) {
  82                 return NULL;
  83         }
  84
  85         newInformee = IOPMinformee::withObject(newObject);
  86
  87         if (!newInformee) {
  88                 return NULL;
  89         }
  90
  91         if (IOPMNoErr == addToList(newInformee)) {
  92                 return newInformee;
  93         } else {
  94                 newInformee->release();
  95                 return NULL;
  96         }
  97 }
  98
  99
 100 //*********************************************************************************
 101 // addToList
 102 // *OBSOLETE* do not call from outside of this file.
 103 // Try appendNewInformee() instead
 104 //*********************************************************************************
 105 IOReturn
 106 IOPMinformeeList::addToList( IOPMinformee * newInformee )
 107 {
 108         IORecursiveLock *listLock = getSharedRecursiveLock();
 109         IOReturn        ret = kIOReturnError;
 110
 111         if (!listLock) {
 112                 return ret;
 113         }
 114
 115         IORecursiveLockLock(listLock);
 116
 117         // Is new object already in the list?
 118         if (findItem(newInformee->whatObject) != NULL) {
 119                 // object is present; just exit
 120                 goto unlock_and_exit;
 121         }
 122
 123         // add it to the front of the list
 124         newInformee->nextInList = firstItem;
 125         firstItem = newInformee;
 126         length++;
 127         ret = IOPMNoErr;
 128
 129 unlock_and_exit:
 130         IORecursiveLockUnlock(listLock);
 131         return ret;
 132 }
 133
 134
 135 //*********************************************************************************
 136 // removeFromList
 137 //
 138 // Find the item in the list, unlink it, and free it.
 139 //*********************************************************************************
 140
 141 IOReturn
 142 IOPMinformeeList::removeFromList( IOService * theItem )
 143 {
 144         IOPMinformee * item = firstItem;
 145         IOPMinformee * temp;
 146         IORecursiveLock    *listLock = getSharedRecursiveLock();
 147
 148         if (NULL == item) {
 149                 return IOPMNoErr;
 150         }
 151         if (!listLock) {
 152                 return kIOReturnError;
 153         }
 154
 155         IORecursiveLockLock( listLock );
 156
 157         if (item->whatObject == theItem) {
 158                 firstItem = item->nextInList;
 159                 length--;
 160                 item->release();
 161                 goto unlock_and_exit;
 162         }
 163
 164         while (item->nextInList != NULL) {
 165                 if (item->nextInList->whatObject == theItem) {
 166                         temp = item->nextInList;
 167                         item->nextInList = temp->nextInList;
 168                         length--;
 169                         temp->release();
 170                         goto unlock_and_exit;
 171                 }
 172                 item = item->nextInList;
 173         }
 174
 175 unlock_and_exit:
 176         IORecursiveLockUnlock(listLock);
 177         return IOPMNoErr;
 178 }
 179
 180
 181 //*********************************************************************************
 182 // firstInList
 183 //
 184 //*********************************************************************************
 185
 186 IOPMinformee *
 187 IOPMinformeeList::firstInList( void )
 188 {
 189         return firstItem;
 190 }
 191
 192 //*********************************************************************************
 193 // nextInList
 194 //
 195 //*********************************************************************************
 196
 197 IOPMinformee *
 198 IOPMinformeeList::nextInList( IOPMinformee * currentItem )
 199 {
 200         if (currentItem != NULL) {
 201                 return currentItem->nextInList;
 202         }
 203         return NULL;
 204 }
 205
 206 //*********************************************************************************
 207 // numberOfItems
 208 //
 209 //*********************************************************************************
 210
 211 unsigned long
 212 IOPMinformeeList::numberOfItems( void )
 213 {
 214         return length;
 215 }
 216
 217 //*********************************************************************************
 218 // findItem
 219 //
 220 // Look through the list for the one which points to the object identified
 221 // by the parameter.  Return a pointer to the list item or NULL.
 222 //*********************************************************************************
 223
 224 IOPMinformee *
 225 IOPMinformeeList::findItem( IOService * driverOrChild )
 226 {
 227         IOPMinformee * nextObject;
 228
 229         nextObject = firstInList();
 230         while (nextObject != NULL) {
 231                 if (nextObject->whatObject == driverOrChild) {
 232                         return nextObject;
 233                 }
 234                 nextObject = nextInList(nextObject);
 235         }
 236         return NULL;
 237 }
 238
 239
 240
 241 //*********************************************************************************
 242 // free
 243 //
 244 // Free all items in the list, and then free the list itself
 245 //*********************************************************************************
 246
 247 void
 248 IOPMinformeeList::free(void )
 249 {
 250         IOPMinformee * next = firstItem;
 251
 252         while (next != NULL) {
 253                 firstItem = next->nextInList;
 254                 length--;
 255                 next->release();
 256                 next = firstItem;
 257         }
 258         super::free();
 259 }