1 /******************************************************************************* 2 * 3 * Module Name: utmutex - local mutex support 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, Intel Corp. 9 * All rights reserved. 10 * 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. 25 * 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. 29 * 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 */ 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 55 static ACPI_STATUS 56 AcpiUtCreateMutex ( 57 ACPI_MUTEX_HANDLE MutexId); 58 59 static void 60 AcpiUtDeleteMutex ( 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 77 ACPI_STATUS 78 AcpiUtMutexInitialize ( 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 or for speed */ 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 Status = AcpiOsCreateLock (&AcpiGbl_ReferenceCountLock); 114 if (ACPI_FAILURE (Status)) 115 { 116 return_ACPI_STATUS (Status); 117 } 118 119 /* Mutex for _OSI support */ 120 121 Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex); 122 if (ACPI_FAILURE (Status)) 123 { 124 return_ACPI_STATUS (Status); 125 } 126 127 /* Create the reader/writer lock for namespace access */ 128 129 Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock); 130 return_ACPI_STATUS (Status); 131 } 132 133 134 /******************************************************************************* 135 * 136 * FUNCTION: AcpiUtMutexTerminate 137 * 138 * PARAMETERS: None. 139 * 140 * RETURN: None. 141 * 142 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes, 143 * spin locks, and reader/writer locks. 144 * 145 ******************************************************************************/ 146 147 void 148 AcpiUtMutexTerminate ( 149 void) 150 { 151 UINT32 i; 152 153 154 ACPI_FUNCTION_TRACE (UtMutexTerminate); 155 156 157 /* Delete each predefined mutex object */ 158 159 for (i = 0; i < ACPI_NUM_MUTEX; i++) 160 { 161 AcpiUtDeleteMutex (i); 162 } 163 164 AcpiOsDeleteMutex (AcpiGbl_OsiMutex); 165 166 /* Delete the spinlocks */ 167 168 AcpiOsDeleteLock (AcpiGbl_GpeLock); 169 AcpiOsDeleteLock (AcpiGbl_HardwareLock); 170 AcpiOsDeleteLock (AcpiGbl_ReferenceCountLock); 171 172 /* Delete the reader/writer lock */ 173 174 AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock); 175 return_VOID; 176 } 177 178 179 /******************************************************************************* 180 * 181 * FUNCTION: AcpiUtCreateMutex 182 * 183 * PARAMETERS: MutexID - ID of the mutex to be created 184 * 185 * RETURN: Status 186 * 187 * DESCRIPTION: Create a mutex object. 188 * 189 ******************************************************************************/ 190 191 static ACPI_STATUS 192 AcpiUtCreateMutex ( 193 ACPI_MUTEX_HANDLE MutexId) 194 { 195 ACPI_STATUS Status = AE_OK; 196 197 198 ACPI_FUNCTION_TRACE_U32 (UtCreateMutex, MutexId); 199 200 201 if (!AcpiGbl_MutexInfo[MutexId].Mutex) 202 { 203 Status = AcpiOsCreateMutex (&AcpiGbl_MutexInfo[MutexId].Mutex); 204 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 205 AcpiGbl_MutexInfo[MutexId].UseCount = 0; 206 } 207 208 return_ACPI_STATUS (Status); 209 } 210 211 212 /******************************************************************************* 213 * 214 * FUNCTION: AcpiUtDeleteMutex 215 * 216 * PARAMETERS: MutexID - ID of the mutex to be deleted 217 * 218 * RETURN: Status 219 * 220 * DESCRIPTION: Delete a mutex object. 221 * 222 ******************************************************************************/ 223 224 static void 225 AcpiUtDeleteMutex ( 226 ACPI_MUTEX_HANDLE MutexId) 227 { 228 229 ACPI_FUNCTION_TRACE_U32 (UtDeleteMutex, MutexId); 230 231 232 AcpiOsDeleteMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 233 234 AcpiGbl_MutexInfo[MutexId].Mutex = NULL; 235 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 236 237 return_VOID; 238 } 239 240 241 /******************************************************************************* 242 * 243 * FUNCTION: AcpiUtAcquireMutex 244 * 245 * PARAMETERS: MutexID - ID of the mutex to be acquired 246 * 247 * RETURN: Status 248 * 249 * DESCRIPTION: Acquire a mutex object. 250 * 251 ******************************************************************************/ 252 253 ACPI_STATUS 254 AcpiUtAcquireMutex ( 255 ACPI_MUTEX_HANDLE MutexId) 256 { 257 ACPI_STATUS Status; 258 ACPI_THREAD_ID ThisThreadId; 259 260 261 ACPI_FUNCTION_NAME (UtAcquireMutex); 262 263 264 if (MutexId > ACPI_MAX_MUTEX) 265 { 266 return (AE_BAD_PARAMETER); 267 } 268 269 ThisThreadId = AcpiOsGetThreadId (); 270 271 #ifdef ACPI_MUTEX_DEBUG 272 { 273 UINT32 i; 274 /* 275 * Mutex debug code, for internal debugging only. 276 * 277 * Deadlock prevention. Check if this thread owns any mutexes of value 278 * greater than or equal to this one. If so, the thread has violated 279 * the mutex ordering rule. This indicates a coding error somewhere in 280 * the ACPI subsystem code. 281 */ 282 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 283 { 284 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 285 { 286 if (i == MutexId) 287 { 288 ACPI_ERROR ((AE_INFO, 289 "Mutex [%s] already acquired by this thread [%u]", 290 AcpiUtGetMutexName (MutexId), 291 (UINT32) ThisThreadId)); 292 293 return (AE_ALREADY_ACQUIRED); 294 } 295 296 ACPI_ERROR ((AE_INFO, 297 "Invalid acquire order: Thread %u owns [%s], wants [%s]", 298 (UINT32) ThisThreadId, AcpiUtGetMutexName (i), 299 AcpiUtGetMutexName (MutexId))); 300 301 return (AE_ACQUIRE_DEADLOCK); 302 } 303 } 304 } 305 #endif 306 307 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 308 "Thread %u attempting to acquire Mutex [%s]\n", 309 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 310 311 Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex, 312 ACPI_WAIT_FOREVER); 313 if (ACPI_SUCCESS (Status)) 314 { 315 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n", 316 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 317 318 AcpiGbl_MutexInfo[MutexId].UseCount++; 319 AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId; 320 } 321 else 322 { 323 ACPI_EXCEPTION ((AE_INFO, Status, 324 "Thread %u could not acquire Mutex [0x%X]", 325 (UINT32) ThisThreadId, MutexId)); 326 } 327 328 return (Status); 329 } 330 331 332 /******************************************************************************* 333 * 334 * FUNCTION: AcpiUtReleaseMutex 335 * 336 * PARAMETERS: MutexID - ID of the mutex to be released 337 * 338 * RETURN: Status 339 * 340 * DESCRIPTION: Release a mutex object. 341 * 342 ******************************************************************************/ 343 344 ACPI_STATUS 345 AcpiUtReleaseMutex ( 346 ACPI_MUTEX_HANDLE MutexId) 347 { 348 ACPI_FUNCTION_NAME (UtReleaseMutex); 349 350 351 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n", 352 (UINT32) AcpiOsGetThreadId (), AcpiUtGetMutexName (MutexId))); 353 354 if (MutexId > ACPI_MAX_MUTEX) 355 { 356 return (AE_BAD_PARAMETER); 357 } 358 359 /* 360 * Mutex must be acquired in order to release it! 361 */ 362 if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED) 363 { 364 ACPI_ERROR ((AE_INFO, 365 "Mutex [0x%X] is not acquired, cannot release", MutexId)); 366 367 return (AE_NOT_ACQUIRED); 368 } 369 370 #ifdef ACPI_MUTEX_DEBUG 371 { 372 UINT32 i; 373 /* 374 * Mutex debug code, for internal debugging only. 375 * 376 * Deadlock prevention. Check if this thread owns any mutexes of value 377 * greater than this one. If so, the thread has violated the mutex 378 * ordering rule. This indicates a coding error somewhere in 379 * the ACPI subsystem code. 380 */ 381 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 382 { 383 if (AcpiGbl_MutexInfo[i].ThreadId == AcpiOsGetThreadId ()) 384 { 385 if (i == MutexId) 386 { 387 continue; 388 } 389 390 ACPI_ERROR ((AE_INFO, 391 "Invalid release order: owns [%s], releasing [%s]", 392 AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); 393 394 return (AE_RELEASE_DEADLOCK); 395 } 396 } 397 } 398 #endif 399 400 /* Mark unlocked FIRST */ 401 402 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 403 404 AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 405 return (AE_OK); 406 } 407