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                 return NULL;
  95         }
  96 }
  97
  98
  99 //*********************************************************************************
 100 // addToList
 101 // *OBSOLETE* do not call from outside of this file.
 102 // Try appendNewInformee() instead
 103 //*********************************************************************************
 104 IOReturn
 105 IOPMinformeeList::addToList( IOPMinformee * newInformee )
 106 {
 107         IOPMinformee * nextInformee;
 108         IORecursiveLock    *listLock = getSharedRecursiveLock();
 109
 110         if (!listLock) {
 111                 return kIOReturnError;
 112         }
 113
 114         IORecursiveLockLock(listLock);
 115         nextInformee = firstItem;
 116
 117         // Is new object already in the list?
 118         while (nextInformee != NULL) {
 119                 if (nextInformee->whatObject == newInformee->whatObject) {
 120                         // object is present; just exit
 121                         goto unlock_and_exit;
 122                 }
 123                 nextInformee = nextInList(nextInformee);
 124         }
 125
 126         // add it to the front of the list
 127         newInformee->nextInList = firstItem;
 128         firstItem = newInformee;
 129         length++;
 130
 131 unlock_and_exit:
 132         IORecursiveLockUnlock(listLock);
 133         return IOPMNoErr;
 134 }
 135
 136
 137 //*********************************************************************************
 138 // removeFromList
 139 //
 140 // Find the item in the list, unlink it, and free it.
 141 //*********************************************************************************
 142
 143 IOReturn
 144 IOPMinformeeList::removeFromList( IOService * theItem )
 145 {
 146         IOPMinformee * item = firstItem;
 147         IOPMinformee * temp;
 148         IORecursiveLock    *listLock = getSharedRecursiveLock();
 149
 150         if (NULL == item) {
 151                 return IOPMNoErr;
 152         }
 153         if (!listLock) {
 154                 return kIOReturnError;
 155         }
 156
 157         IORecursiveLockLock( listLock );
 158
 159         if (item->whatObject == theItem) {
 160                 firstItem = item->nextInList;
 161                 length--;
 162                 item->release();
 163                 goto unlock_and_exit;
 164         }
 165
 166         while (item->nextInList != NULL) {
 167                 if (item->nextInList->whatObject == theItem) {
 168                         temp = item->nextInList;
 169                         item->nextInList = temp->nextInList;
 170                         length--;
 171                         temp->release();
 172                         goto unlock_and_exit;
 173                 }
 174                 item = item->nextInList;
 175         }
 176
 177 unlock_and_exit:
 178         IORecursiveLockUnlock(listLock);
 179         return IOPMNoErr;
 180 }
 181
 182
 183 //*********************************************************************************
 184 // firstInList
 185 //
 186 //*********************************************************************************
 187
 188 IOPMinformee *
 189 IOPMinformeeList::firstInList( void )
 190 {
 191         return firstItem;
 192 }
 193
 194 //*********************************************************************************
 195 // nextInList
 196 //
 197 //*********************************************************************************
 198
 199 IOPMinformee *
 200 IOPMinformeeList::nextInList( IOPMinformee * currentItem )
 201 {
 202         if (currentItem != NULL) {
 203                 return currentItem->nextInList;
 204         }
 205         return NULL;
 206 }
 207
 208 //*********************************************************************************
 209 // numberOfItems
 210 //
 211 //*********************************************************************************
 212
 213 unsigned long
 214 IOPMinformeeList::numberOfItems( void )
 215 {
 216         return length;
 217 }
 218
 219 //*********************************************************************************
 220 // findItem
 221 //
 222 // Look through the list for the one which points to the object identified
 223 // by the parameter.  Return a pointer to the list item or NULL.
 224 //*********************************************************************************
 225
 226 IOPMinformee *
 227 IOPMinformeeList::findItem( IOService * driverOrChild )
 228 {
 229         IOPMinformee * nextObject;
 230
 231         nextObject = firstInList();
 232         while (nextObject != NULL) {
 233                 if (nextObject->whatObject == driverOrChild) {
 234                         return nextObject;
 235                 }
 236                 nextObject = nextInList(nextObject);
 237         }
 238         return NULL;
 239 }
 240
 241
 242
 243 //*********************************************************************************
 244 // free
 245 //
 246 // Free all items in the list, and then free the list itself
 247 //*********************************************************************************
 248
 249 void
 250 IOPMinformeeList::free(void )
 251 {
 252         IOPMinformee * next = firstItem;
 253
 254         while (next != NULL) {
 255                 firstItem = next->nextInList;
 256                 length--;
 257                 next->release();
 258                 next = firstItem;
 259         }
 260         super::free();
 261 }