1/******************************************************************************* 2 * 3 * Module Name: utmutex - local mutex support 4 * 5 ******************************************************************************/ 6
| 1/******************************************************************************* 2 * 3 * Module Name: utmutex - local mutex support 4 * 5 ******************************************************************************/ 6
|
7/****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
| 7/* 8 * Copyright (C) 2000 - 2011, Intel Corp.
|
12 * All rights reserved. 13 *
| 9 * All rights reserved. 10 *
|
14 * 2. License
| 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission.
|
15 *
| 25 *
|
16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights.
| 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation.
|
20 *
| 29 *
|
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/
| 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */
|
115 116 117#define __UTMUTEX_C__ 118 119#include <contrib/dev/acpica/include/acpi.h> 120#include <contrib/dev/acpica/include/accommon.h> 121 122#define _COMPONENT ACPI_UTILITIES 123 ACPI_MODULE_NAME ("utmutex") 124 125/* Local prototypes */ 126 127static ACPI_STATUS 128AcpiUtCreateMutex ( 129 ACPI_MUTEX_HANDLE MutexId); 130 131static void 132AcpiUtDeleteMutex ( 133 ACPI_MUTEX_HANDLE MutexId); 134 135 136/******************************************************************************* 137 * 138 * FUNCTION: AcpiUtMutexInitialize 139 * 140 * PARAMETERS: None. 141 * 142 * RETURN: Status 143 * 144 * DESCRIPTION: Create the system mutex objects. This includes mutexes, 145 * spin locks, and reader/writer locks. 146 * 147 ******************************************************************************/ 148 149ACPI_STATUS 150AcpiUtMutexInitialize ( 151 void) 152{ 153 UINT32 i; 154 ACPI_STATUS Status; 155 156 157 ACPI_FUNCTION_TRACE (UtMutexInitialize); 158 159 160 /* Create each of the predefined mutex objects */ 161 162 for (i = 0; i < ACPI_NUM_MUTEX; i++) 163 { 164 Status = AcpiUtCreateMutex (i); 165 if (ACPI_FAILURE (Status)) 166 { 167 return_ACPI_STATUS (Status); 168 } 169 } 170 171 /* Create the spinlocks for use at interrupt level */ 172 173 Status = AcpiOsCreateLock (&AcpiGbl_GpeLock); 174 if (ACPI_FAILURE (Status)) 175 { 176 return_ACPI_STATUS (Status); 177 } 178 179 Status = AcpiOsCreateLock (&AcpiGbl_HardwareLock); 180 if (ACPI_FAILURE (Status)) 181 { 182 return_ACPI_STATUS (Status); 183 } 184 185 /* Mutex for _OSI support */ 186 Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex); 187 if (ACPI_FAILURE (Status)) 188 { 189 return_ACPI_STATUS (Status); 190 } 191 192 /* Create the reader/writer lock for namespace access */ 193 194 Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock); 195 return_ACPI_STATUS (Status); 196} 197 198 199/******************************************************************************* 200 * 201 * FUNCTION: AcpiUtMutexTerminate 202 * 203 * PARAMETERS: None. 204 * 205 * RETURN: None. 206 * 207 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes, 208 * spin locks, and reader/writer locks. 209 * 210 ******************************************************************************/ 211 212void 213AcpiUtMutexTerminate ( 214 void) 215{ 216 UINT32 i; 217 218 219 ACPI_FUNCTION_TRACE (UtMutexTerminate); 220 221 222 /* Delete each predefined mutex object */ 223 224 for (i = 0; i < ACPI_NUM_MUTEX; i++) 225 { 226 AcpiUtDeleteMutex (i); 227 } 228 229 AcpiOsDeleteMutex (AcpiGbl_OsiMutex); 230 231 /* Delete the spinlocks */ 232 233 AcpiOsDeleteLock (AcpiGbl_GpeLock); 234 AcpiOsDeleteLock (AcpiGbl_HardwareLock); 235 236 /* Delete the reader/writer lock */ 237 238 AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock); 239 return_VOID; 240} 241 242 243/******************************************************************************* 244 * 245 * FUNCTION: AcpiUtCreateMutex 246 * 247 * PARAMETERS: MutexID - ID of the mutex to be created 248 * 249 * RETURN: Status 250 * 251 * DESCRIPTION: Create a mutex object. 252 * 253 ******************************************************************************/ 254 255static ACPI_STATUS 256AcpiUtCreateMutex ( 257 ACPI_MUTEX_HANDLE MutexId) 258{ 259 ACPI_STATUS Status = AE_OK; 260 261 262 ACPI_FUNCTION_TRACE_U32 (UtCreateMutex, MutexId); 263 264 265 if (!AcpiGbl_MutexInfo[MutexId].Mutex) 266 { 267 Status = AcpiOsCreateMutex (&AcpiGbl_MutexInfo[MutexId].Mutex); 268 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 269 AcpiGbl_MutexInfo[MutexId].UseCount = 0; 270 } 271 272 return_ACPI_STATUS (Status); 273} 274 275 276/******************************************************************************* 277 * 278 * FUNCTION: AcpiUtDeleteMutex 279 * 280 * PARAMETERS: MutexID - ID of the mutex to be deleted 281 * 282 * RETURN: Status 283 * 284 * DESCRIPTION: Delete a mutex object. 285 * 286 ******************************************************************************/ 287 288static void 289AcpiUtDeleteMutex ( 290 ACPI_MUTEX_HANDLE MutexId) 291{ 292 293 ACPI_FUNCTION_TRACE_U32 (UtDeleteMutex, MutexId); 294 295 296 AcpiOsDeleteMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 297 298 AcpiGbl_MutexInfo[MutexId].Mutex = NULL; 299 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 300} 301 302 303/******************************************************************************* 304 * 305 * FUNCTION: AcpiUtAcquireMutex 306 * 307 * PARAMETERS: MutexID - ID of the mutex to be acquired 308 * 309 * RETURN: Status 310 * 311 * DESCRIPTION: Acquire a mutex object. 312 * 313 ******************************************************************************/ 314 315ACPI_STATUS 316AcpiUtAcquireMutex ( 317 ACPI_MUTEX_HANDLE MutexId) 318{ 319 ACPI_STATUS Status; 320 ACPI_THREAD_ID ThisThreadId; 321 322 323 ACPI_FUNCTION_NAME (UtAcquireMutex); 324 325 326 if (MutexId > ACPI_MAX_MUTEX) 327 { 328 return (AE_BAD_PARAMETER); 329 } 330 331 ThisThreadId = AcpiOsGetThreadId (); 332 333#ifdef ACPI_MUTEX_DEBUG 334 { 335 UINT32 i; 336 /* 337 * Mutex debug code, for internal debugging only. 338 * 339 * Deadlock prevention. Check if this thread owns any mutexes of value 340 * greater than or equal to this one. If so, the thread has violated 341 * the mutex ordering rule. This indicates a coding error somewhere in 342 * the ACPI subsystem code. 343 */ 344 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 345 { 346 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 347 { 348 if (i == MutexId) 349 { 350 ACPI_ERROR ((AE_INFO, 351 "Mutex [%s] already acquired by this thread [%u]", 352 AcpiUtGetMutexName (MutexId), 353 (UINT32) ThisThreadId)); 354 355 return (AE_ALREADY_ACQUIRED); 356 } 357 358 ACPI_ERROR ((AE_INFO, 359 "Invalid acquire order: Thread %u owns [%s], wants [%s]", 360 (UINT32) ThisThreadId, AcpiUtGetMutexName (i), 361 AcpiUtGetMutexName (MutexId))); 362 363 return (AE_ACQUIRE_DEADLOCK); 364 } 365 } 366 } 367#endif 368 369 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 370 "Thread %u attempting to acquire Mutex [%s]\n", 371 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 372 373 Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex, 374 ACPI_WAIT_FOREVER); 375 if (ACPI_SUCCESS (Status)) 376 { 377 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n", 378 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 379 380 AcpiGbl_MutexInfo[MutexId].UseCount++; 381 AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId; 382 } 383 else 384 { 385 ACPI_EXCEPTION ((AE_INFO, Status, 386 "Thread %u could not acquire Mutex [0x%X]", 387 (UINT32) ThisThreadId, MutexId)); 388 } 389 390 return (Status); 391} 392 393 394/******************************************************************************* 395 * 396 * FUNCTION: AcpiUtReleaseMutex 397 * 398 * PARAMETERS: MutexID - ID of the mutex to be released 399 * 400 * RETURN: Status 401 * 402 * DESCRIPTION: Release a mutex object. 403 * 404 ******************************************************************************/ 405 406ACPI_STATUS 407AcpiUtReleaseMutex ( 408 ACPI_MUTEX_HANDLE MutexId) 409{ 410 ACPI_THREAD_ID ThisThreadId; 411 412 413 ACPI_FUNCTION_NAME (UtReleaseMutex); 414 415 416 ThisThreadId = AcpiOsGetThreadId (); 417 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n", 418 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 419 420 if (MutexId > ACPI_MAX_MUTEX) 421 { 422 return (AE_BAD_PARAMETER); 423 } 424 425 /* 426 * Mutex must be acquired in order to release it! 427 */ 428 if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED) 429 { 430 ACPI_ERROR ((AE_INFO, 431 "Mutex [0x%X] is not acquired, cannot release", MutexId)); 432 433 return (AE_NOT_ACQUIRED); 434 } 435 436#ifdef ACPI_MUTEX_DEBUG 437 { 438 UINT32 i; 439 /* 440 * Mutex debug code, for internal debugging only. 441 * 442 * Deadlock prevention. Check if this thread owns any mutexes of value 443 * greater than this one. If so, the thread has violated the mutex 444 * ordering rule. This indicates a coding error somewhere in 445 * the ACPI subsystem code. 446 */ 447 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 448 { 449 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 450 { 451 if (i == MutexId) 452 { 453 continue; 454 } 455 456 ACPI_ERROR ((AE_INFO, 457 "Invalid release order: owns [%s], releasing [%s]", 458 AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); 459 460 return (AE_RELEASE_DEADLOCK); 461 } 462 } 463 } 464#endif 465 466 /* Mark unlocked FIRST */ 467 468 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 469 470 AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 471 return (AE_OK); 472} 473 474
| 43 44 45#define __UTMUTEX_C__ 46 47#include <contrib/dev/acpica/include/acpi.h> 48#include <contrib/dev/acpica/include/accommon.h> 49 50#define _COMPONENT ACPI_UTILITIES 51 ACPI_MODULE_NAME ("utmutex") 52 53/* Local prototypes */ 54 55static ACPI_STATUS 56AcpiUtCreateMutex ( 57 ACPI_MUTEX_HANDLE MutexId); 58 59static void 60AcpiUtDeleteMutex ( 61 ACPI_MUTEX_HANDLE MutexId); 62 63 64/******************************************************************************* 65 * 66 * FUNCTION: AcpiUtMutexInitialize 67 * 68 * PARAMETERS: None. 69 * 70 * RETURN: Status 71 * 72 * DESCRIPTION: Create the system mutex objects. This includes mutexes, 73 * spin locks, and reader/writer locks. 74 * 75 ******************************************************************************/ 76 77ACPI_STATUS 78AcpiUtMutexInitialize ( 79 void) 80{ 81 UINT32 i; 82 ACPI_STATUS Status; 83 84 85 ACPI_FUNCTION_TRACE (UtMutexInitialize); 86 87 88 /* Create each of the predefined mutex objects */ 89 90 for (i = 0; i < ACPI_NUM_MUTEX; i++) 91 { 92 Status = AcpiUtCreateMutex (i); 93 if (ACPI_FAILURE (Status)) 94 { 95 return_ACPI_STATUS (Status); 96 } 97 } 98 99 /* Create the spinlocks for use at interrupt level */ 100 101 Status = AcpiOsCreateLock (&AcpiGbl_GpeLock); 102 if (ACPI_FAILURE (Status)) 103 { 104 return_ACPI_STATUS (Status); 105 } 106 107 Status = AcpiOsCreateLock (&AcpiGbl_HardwareLock); 108 if (ACPI_FAILURE (Status)) 109 { 110 return_ACPI_STATUS (Status); 111 } 112 113 /* Mutex for _OSI support */ 114 Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex); 115 if (ACPI_FAILURE (Status)) 116 { 117 return_ACPI_STATUS (Status); 118 } 119 120 /* Create the reader/writer lock for namespace access */ 121 122 Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock); 123 return_ACPI_STATUS (Status); 124} 125 126 127/******************************************************************************* 128 * 129 * FUNCTION: AcpiUtMutexTerminate 130 * 131 * PARAMETERS: None. 132 * 133 * RETURN: None. 134 * 135 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes, 136 * spin locks, and reader/writer locks. 137 * 138 ******************************************************************************/ 139 140void 141AcpiUtMutexTerminate ( 142 void) 143{ 144 UINT32 i; 145 146 147 ACPI_FUNCTION_TRACE (UtMutexTerminate); 148 149 150 /* Delete each predefined mutex object */ 151 152 for (i = 0; i < ACPI_NUM_MUTEX; i++) 153 { 154 AcpiUtDeleteMutex (i); 155 } 156 157 AcpiOsDeleteMutex (AcpiGbl_OsiMutex); 158 159 /* Delete the spinlocks */ 160 161 AcpiOsDeleteLock (AcpiGbl_GpeLock); 162 AcpiOsDeleteLock (AcpiGbl_HardwareLock); 163 164 /* Delete the reader/writer lock */ 165 166 AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock); 167 return_VOID; 168} 169 170 171/******************************************************************************* 172 * 173 * FUNCTION: AcpiUtCreateMutex 174 * 175 * PARAMETERS: MutexID - ID of the mutex to be created 176 * 177 * RETURN: Status 178 * 179 * DESCRIPTION: Create a mutex object. 180 * 181 ******************************************************************************/ 182 183static ACPI_STATUS 184AcpiUtCreateMutex ( 185 ACPI_MUTEX_HANDLE MutexId) 186{ 187 ACPI_STATUS Status = AE_OK; 188 189 190 ACPI_FUNCTION_TRACE_U32 (UtCreateMutex, MutexId); 191 192 193 if (!AcpiGbl_MutexInfo[MutexId].Mutex) 194 { 195 Status = AcpiOsCreateMutex (&AcpiGbl_MutexInfo[MutexId].Mutex); 196 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 197 AcpiGbl_MutexInfo[MutexId].UseCount = 0; 198 } 199 200 return_ACPI_STATUS (Status); 201} 202 203 204/******************************************************************************* 205 * 206 * FUNCTION: AcpiUtDeleteMutex 207 * 208 * PARAMETERS: MutexID - ID of the mutex to be deleted 209 * 210 * RETURN: Status 211 * 212 * DESCRIPTION: Delete a mutex object. 213 * 214 ******************************************************************************/ 215 216static void 217AcpiUtDeleteMutex ( 218 ACPI_MUTEX_HANDLE MutexId) 219{ 220 221 ACPI_FUNCTION_TRACE_U32 (UtDeleteMutex, MutexId); 222 223 224 AcpiOsDeleteMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 225 226 AcpiGbl_MutexInfo[MutexId].Mutex = NULL; 227 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 228} 229 230 231/******************************************************************************* 232 * 233 * FUNCTION: AcpiUtAcquireMutex 234 * 235 * PARAMETERS: MutexID - ID of the mutex to be acquired 236 * 237 * RETURN: Status 238 * 239 * DESCRIPTION: Acquire a mutex object. 240 * 241 ******************************************************************************/ 242 243ACPI_STATUS 244AcpiUtAcquireMutex ( 245 ACPI_MUTEX_HANDLE MutexId) 246{ 247 ACPI_STATUS Status; 248 ACPI_THREAD_ID ThisThreadId; 249 250 251 ACPI_FUNCTION_NAME (UtAcquireMutex); 252 253 254 if (MutexId > ACPI_MAX_MUTEX) 255 { 256 return (AE_BAD_PARAMETER); 257 } 258 259 ThisThreadId = AcpiOsGetThreadId (); 260 261#ifdef ACPI_MUTEX_DEBUG 262 { 263 UINT32 i; 264 /* 265 * Mutex debug code, for internal debugging only. 266 * 267 * Deadlock prevention. Check if this thread owns any mutexes of value 268 * greater than or equal to this one. If so, the thread has violated 269 * the mutex ordering rule. This indicates a coding error somewhere in 270 * the ACPI subsystem code. 271 */ 272 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 273 { 274 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 275 { 276 if (i == MutexId) 277 { 278 ACPI_ERROR ((AE_INFO, 279 "Mutex [%s] already acquired by this thread [%u]", 280 AcpiUtGetMutexName (MutexId), 281 (UINT32) ThisThreadId)); 282 283 return (AE_ALREADY_ACQUIRED); 284 } 285 286 ACPI_ERROR ((AE_INFO, 287 "Invalid acquire order: Thread %u owns [%s], wants [%s]", 288 (UINT32) ThisThreadId, AcpiUtGetMutexName (i), 289 AcpiUtGetMutexName (MutexId))); 290 291 return (AE_ACQUIRE_DEADLOCK); 292 } 293 } 294 } 295#endif 296 297 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 298 "Thread %u attempting to acquire Mutex [%s]\n", 299 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 300 301 Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex, 302 ACPI_WAIT_FOREVER); 303 if (ACPI_SUCCESS (Status)) 304 { 305 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n", 306 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 307 308 AcpiGbl_MutexInfo[MutexId].UseCount++; 309 AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId; 310 } 311 else 312 { 313 ACPI_EXCEPTION ((AE_INFO, Status, 314 "Thread %u could not acquire Mutex [0x%X]", 315 (UINT32) ThisThreadId, MutexId)); 316 } 317 318 return (Status); 319} 320 321 322/******************************************************************************* 323 * 324 * FUNCTION: AcpiUtReleaseMutex 325 * 326 * PARAMETERS: MutexID - ID of the mutex to be released 327 * 328 * RETURN: Status 329 * 330 * DESCRIPTION: Release a mutex object. 331 * 332 ******************************************************************************/ 333 334ACPI_STATUS 335AcpiUtReleaseMutex ( 336 ACPI_MUTEX_HANDLE MutexId) 337{ 338 ACPI_THREAD_ID ThisThreadId; 339 340 341 ACPI_FUNCTION_NAME (UtReleaseMutex); 342 343 344 ThisThreadId = AcpiOsGetThreadId (); 345 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n", 346 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 347 348 if (MutexId > ACPI_MAX_MUTEX) 349 { 350 return (AE_BAD_PARAMETER); 351 } 352 353 /* 354 * Mutex must be acquired in order to release it! 355 */ 356 if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED) 357 { 358 ACPI_ERROR ((AE_INFO, 359 "Mutex [0x%X] is not acquired, cannot release", MutexId)); 360 361 return (AE_NOT_ACQUIRED); 362 } 363 364#ifdef ACPI_MUTEX_DEBUG 365 { 366 UINT32 i; 367 /* 368 * Mutex debug code, for internal debugging only. 369 * 370 * Deadlock prevention. Check if this thread owns any mutexes of value 371 * greater than this one. If so, the thread has violated the mutex 372 * ordering rule. This indicates a coding error somewhere in 373 * the ACPI subsystem code. 374 */ 375 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 376 { 377 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 378 { 379 if (i == MutexId) 380 { 381 continue; 382 } 383 384 ACPI_ERROR ((AE_INFO, 385 "Invalid release order: owns [%s], releasing [%s]", 386 AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); 387 388 return (AE_RELEASE_DEADLOCK); 389 } 390 } 391 } 392#endif 393 394 /* Mark unlocked FIRST */ 395 396 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 397 398 AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 399 return (AE_OK); 400} 401 402
|