1 /******************************************************************************* 2 * 3 * Module Name: utmutex - local mutex support 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2011, 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 #include <acpi/acpi.h> 45 #include "accommon.h" 46 47 #define _COMPONENT ACPI_UTILITIES 48 ACPI_MODULE_NAME("utmutex") 49 50 /* Local prototypes */ 51 static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id); 52 53 static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id); 54 55 /******************************************************************************* 56 * 57 * FUNCTION: acpi_ut_mutex_initialize 58 * 59 * PARAMETERS: None. 60 * 61 * RETURN: Status 62 * 63 * DESCRIPTION: Create the system mutex objects. This includes mutexes, 64 * spin locks, and reader/writer locks. 65 * 66 ******************************************************************************/ 67 68 acpi_status acpi_ut_mutex_initialize(void) 69 { 70 u32 i; 71 acpi_status status; 72 73 ACPI_FUNCTION_TRACE(ut_mutex_initialize); 74 75 /* Create each of the predefined mutex objects */ 76 77 for (i = 0; i < ACPI_NUM_MUTEX; i++) { 78 status = acpi_ut_create_mutex(i); 79 if (ACPI_FAILURE(status)) { 80 return_ACPI_STATUS(status); 81 } 82 } 83 84 /* Create the spinlocks for use at interrupt level */ 85 86 spin_lock_init(acpi_gbl_gpe_lock); 87 spin_lock_init(acpi_gbl_hardware_lock); 88 spin_lock_init(acpi_ev_global_lock_pending_lock); 89 90 /* Mutex for _OSI support */ 91 status = acpi_os_create_mutex(&acpi_gbl_osi_mutex); 92 if (ACPI_FAILURE(status)) { 93 return_ACPI_STATUS(status); 94 } 95 96 /* Create the reader/writer lock for namespace access */ 97 98 status = acpi_ut_create_rw_lock(&acpi_gbl_namespace_rw_lock); 99 return_ACPI_STATUS(status); 100 } 101 102 /******************************************************************************* 103 * 104 * FUNCTION: acpi_ut_mutex_terminate 105 * 106 * PARAMETERS: None. 107 * 108 * RETURN: None. 109 * 110 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes, 111 * spin locks, and reader/writer locks. 112 * 113 ******************************************************************************/ 114 115 void acpi_ut_mutex_terminate(void) 116 { 117 u32 i; 118 119 ACPI_FUNCTION_TRACE(ut_mutex_terminate); 120 121 /* Delete each predefined mutex object */ 122 123 for (i = 0; i < ACPI_NUM_MUTEX; i++) { 124 acpi_ut_delete_mutex(i); 125 } 126 127 acpi_os_delete_mutex(acpi_gbl_osi_mutex); 128 129 /* Delete the spinlocks */ 130 131 acpi_os_delete_lock(acpi_gbl_gpe_lock); 132 acpi_os_delete_lock(acpi_gbl_hardware_lock); 133 134 /* Delete the reader/writer lock */ 135 136 acpi_ut_delete_rw_lock(&acpi_gbl_namespace_rw_lock); 137 return_VOID; 138 } 139 140 /******************************************************************************* 141 * 142 * FUNCTION: acpi_ut_create_mutex 143 * 144 * PARAMETERS: mutex_iD - ID of the mutex to be created 145 * 146 * RETURN: Status 147 * 148 * DESCRIPTION: Create a mutex object. 149 * 150 ******************************************************************************/ 151 152 static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id) 153 { 154 acpi_status status = AE_OK; 155 156 ACPI_FUNCTION_TRACE_U32(ut_create_mutex, mutex_id); 157 158 if (!acpi_gbl_mutex_info[mutex_id].mutex) { 159 status = 160 acpi_os_create_mutex(&acpi_gbl_mutex_info[mutex_id].mutex); 161 acpi_gbl_mutex_info[mutex_id].thread_id = 162 ACPI_MUTEX_NOT_ACQUIRED; 163 acpi_gbl_mutex_info[mutex_id].use_count = 0; 164 } 165 166 return_ACPI_STATUS(status); 167 } 168 169 /******************************************************************************* 170 * 171 * FUNCTION: acpi_ut_delete_mutex 172 * 173 * PARAMETERS: mutex_iD - ID of the mutex to be deleted 174 * 175 * RETURN: Status 176 * 177 * DESCRIPTION: Delete a mutex object. 178 * 179 ******************************************************************************/ 180 181 static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id) 182 { 183 184 ACPI_FUNCTION_TRACE_U32(ut_delete_mutex, mutex_id); 185 186 acpi_os_delete_mutex(acpi_gbl_mutex_info[mutex_id].mutex); 187 188 acpi_gbl_mutex_info[mutex_id].mutex = NULL; 189 acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED; 190 } 191 192 /******************************************************************************* 193 * 194 * FUNCTION: acpi_ut_acquire_mutex 195 * 196 * PARAMETERS: mutex_iD - ID of the mutex to be acquired 197 * 198 * RETURN: Status 199 * 200 * DESCRIPTION: Acquire a mutex object. 201 * 202 ******************************************************************************/ 203 204 acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id) 205 { 206 acpi_status status; 207 acpi_thread_id this_thread_id; 208 209 ACPI_FUNCTION_NAME(ut_acquire_mutex); 210 211 if (mutex_id > ACPI_MAX_MUTEX) { 212 return (AE_BAD_PARAMETER); 213 } 214 215 this_thread_id = acpi_os_get_thread_id(); 216 217 #ifdef ACPI_MUTEX_DEBUG 218 { 219 u32 i; 220 /* 221 * Mutex debug code, for internal debugging only. 222 * 223 * Deadlock prevention. Check if this thread owns any mutexes of value 224 * greater than or equal to this one. If so, the thread has violated 225 * the mutex ordering rule. This indicates a coding error somewhere in 226 * the ACPI subsystem code. 227 */ 228 for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) { 229 if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) { 230 if (i == mutex_id) { 231 ACPI_ERROR((AE_INFO, 232 "Mutex [%s] already acquired by this thread [%u]", 233 acpi_ut_get_mutex_name 234 (mutex_id), 235 (u32)this_thread_id)); 236 237 return (AE_ALREADY_ACQUIRED); 238 } 239 240 ACPI_ERROR((AE_INFO, 241 "Invalid acquire order: Thread %u owns [%s], wants [%s]", 242 (u32)this_thread_id, 243 acpi_ut_get_mutex_name(i), 244 acpi_ut_get_mutex_name(mutex_id))); 245 246 return (AE_ACQUIRE_DEADLOCK); 247 } 248 } 249 } 250 #endif 251 252 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, 253 "Thread %u attempting to acquire Mutex [%s]\n", 254 (u32)this_thread_id, 255 acpi_ut_get_mutex_name(mutex_id))); 256 257 status = acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex, 258 ACPI_WAIT_FOREVER); 259 if (ACPI_SUCCESS(status)) { 260 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, 261 "Thread %u acquired Mutex [%s]\n", 262 (u32)this_thread_id, 263 acpi_ut_get_mutex_name(mutex_id))); 264 265 acpi_gbl_mutex_info[mutex_id].use_count++; 266 acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id; 267 } else { 268 ACPI_EXCEPTION((AE_INFO, status, 269 "Thread %u could not acquire Mutex [0x%X]", 270 (u32)this_thread_id, mutex_id)); 271 } 272 273 return (status); 274 } 275 276 /******************************************************************************* 277 * 278 * FUNCTION: acpi_ut_release_mutex 279 * 280 * PARAMETERS: mutex_iD - ID of the mutex to be released 281 * 282 * RETURN: Status 283 * 284 * DESCRIPTION: Release a mutex object. 285 * 286 ******************************************************************************/ 287 288 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id) 289 { 290 acpi_thread_id this_thread_id; 291 292 ACPI_FUNCTION_NAME(ut_release_mutex); 293 294 this_thread_id = acpi_os_get_thread_id(); 295 296 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n", 297 (u32)this_thread_id, 298 acpi_ut_get_mutex_name(mutex_id))); 299 300 if (mutex_id > ACPI_MAX_MUTEX) { 301 return (AE_BAD_PARAMETER); 302 } 303 304 /* 305 * Mutex must be acquired in order to release it! 306 */ 307 if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) { 308 ACPI_ERROR((AE_INFO, 309 "Mutex [0x%X] is not acquired, cannot release", 310 mutex_id)); 311 312 return (AE_NOT_ACQUIRED); 313 } 314 #ifdef ACPI_MUTEX_DEBUG 315 { 316 u32 i; 317 /* 318 * Mutex debug code, for internal debugging only. 319 * 320 * Deadlock prevention. Check if this thread owns any mutexes of value 321 * greater than this one. If so, the thread has violated the mutex 322 * ordering rule. This indicates a coding error somewhere in 323 * the ACPI subsystem code. 324 */ 325 for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) { 326 if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) { 327 if (i == mutex_id) { 328 continue; 329 } 330 331 ACPI_ERROR((AE_INFO, 332 "Invalid release order: owns [%s], releasing [%s]", 333 acpi_ut_get_mutex_name(i), 334 acpi_ut_get_mutex_name(mutex_id))); 335 336 return (AE_RELEASE_DEADLOCK); 337 } 338 } 339 } 340 #endif 341 342 /* Mark unlocked FIRST */ 343 344 acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED; 345 346 acpi_os_release_mutex(acpi_gbl_mutex_info[mutex_id].mutex); 347 return (AE_OK); 348 } 349