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