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 */ 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 140 void 141 AcpiUtMutexTerminate ( 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 183 static ACPI_STATUS 184 AcpiUtCreateMutex ( 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 216 static void 217 AcpiUtDeleteMutex ( 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 return_VOID; 230 } 231 232 233 /******************************************************************************* 234 * 235 * FUNCTION: AcpiUtAcquireMutex 236 * 237 * PARAMETERS: MutexID - ID of the mutex to be acquired 238 * 239 * RETURN: Status 240 * 241 * DESCRIPTION: Acquire a mutex object. 242 * 243 ******************************************************************************/ 244 245 ACPI_STATUS 246 AcpiUtAcquireMutex ( 247 ACPI_MUTEX_HANDLE MutexId) 248 { 249 ACPI_STATUS Status; 250 ACPI_THREAD_ID ThisThreadId; 251 252 253 ACPI_FUNCTION_NAME (UtAcquireMutex); 254 255 256 if (MutexId > ACPI_MAX_MUTEX) 257 { 258 return (AE_BAD_PARAMETER); 259 } 260 261 ThisThreadId = AcpiOsGetThreadId (); 262 263 #ifdef ACPI_MUTEX_DEBUG 264 { 265 UINT32 i; 266 /* 267 * Mutex debug code, for internal debugging only. 268 * 269 * Deadlock prevention. Check if this thread owns any mutexes of value 270 * greater than or equal to this one. If so, the thread has violated 271 * the mutex ordering rule. This indicates a coding error somewhere in 272 * the ACPI subsystem code. 273 */ 274 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 275 { 276 if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId) 277 { 278 if (i == MutexId) 279 { 280 ACPI_ERROR ((AE_INFO, 281 "Mutex [%s] already acquired by this thread [%u]", 282 AcpiUtGetMutexName (MutexId), 283 (UINT32) ThisThreadId)); 284 285 return (AE_ALREADY_ACQUIRED); 286 } 287 288 ACPI_ERROR ((AE_INFO, 289 "Invalid acquire order: Thread %u owns [%s], wants [%s]", 290 (UINT32) ThisThreadId, AcpiUtGetMutexName (i), 291 AcpiUtGetMutexName (MutexId))); 292 293 return (AE_ACQUIRE_DEADLOCK); 294 } 295 } 296 } 297 #endif 298 299 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 300 "Thread %u attempting to acquire Mutex [%s]\n", 301 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 302 303 Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex, 304 ACPI_WAIT_FOREVER); 305 if (ACPI_SUCCESS (Status)) 306 { 307 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n", 308 (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId))); 309 310 AcpiGbl_MutexInfo[MutexId].UseCount++; 311 AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId; 312 } 313 else 314 { 315 ACPI_EXCEPTION ((AE_INFO, Status, 316 "Thread %u could not acquire Mutex [0x%X]", 317 (UINT32) ThisThreadId, MutexId)); 318 } 319 320 return (Status); 321 } 322 323 324 /******************************************************************************* 325 * 326 * FUNCTION: AcpiUtReleaseMutex 327 * 328 * PARAMETERS: MutexID - ID of the mutex to be released 329 * 330 * RETURN: Status 331 * 332 * DESCRIPTION: Release a mutex object. 333 * 334 ******************************************************************************/ 335 336 ACPI_STATUS 337 AcpiUtReleaseMutex ( 338 ACPI_MUTEX_HANDLE MutexId) 339 { 340 ACPI_FUNCTION_NAME (UtReleaseMutex); 341 342 343 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n", 344 (UINT32) AcpiOsGetThreadId (), AcpiUtGetMutexName (MutexId))); 345 346 if (MutexId > ACPI_MAX_MUTEX) 347 { 348 return (AE_BAD_PARAMETER); 349 } 350 351 /* 352 * Mutex must be acquired in order to release it! 353 */ 354 if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED) 355 { 356 ACPI_ERROR ((AE_INFO, 357 "Mutex [0x%X] is not acquired, cannot release", MutexId)); 358 359 return (AE_NOT_ACQUIRED); 360 } 361 362 #ifdef ACPI_MUTEX_DEBUG 363 { 364 UINT32 i; 365 /* 366 * Mutex debug code, for internal debugging only. 367 * 368 * Deadlock prevention. Check if this thread owns any mutexes of value 369 * greater than this one. If so, the thread has violated the mutex 370 * ordering rule. This indicates a coding error somewhere in 371 * the ACPI subsystem code. 372 */ 373 for (i = MutexId; i < ACPI_NUM_MUTEX; i++) 374 { 375 if (AcpiGbl_MutexInfo[i].ThreadId == AcpiOsGetThreadId ()) 376 { 377 if (i == MutexId) 378 { 379 continue; 380 } 381 382 ACPI_ERROR ((AE_INFO, 383 "Invalid release order: owns [%s], releasing [%s]", 384 AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); 385 386 return (AE_RELEASE_DEADLOCK); 387 } 388 } 389 } 390 #endif 391 392 /* Mark unlocked FIRST */ 393 394 AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED; 395 396 AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex); 397 return (AE_OK); 398 } 399