• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*******************************************************************************
2  *
3  * Module Name: utmutex - local mutex support
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 
acpi_ut_mutex_initialize(void)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 
acpi_ut_mutex_terminate(void)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 
acpi_ut_create_mutex(acpi_mutex_handle mutex_id)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 
acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)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 
acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)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 [0x%X]",
290 				(u32)this_thread_id, mutex_id));
291 	}
292 
293 	return (status);
294 }
295 
296 /*******************************************************************************
297  *
298  * FUNCTION:    acpi_ut_release_mutex
299  *
300  * PARAMETERS:  mutex_ID        - ID of the mutex to be released
301  *
302  * RETURN:      Status
303  *
304  * DESCRIPTION: Release a mutex object.
305  *
306  ******************************************************************************/
307 
acpi_ut_release_mutex(acpi_mutex_handle mutex_id)308 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
309 {
310 	ACPI_FUNCTION_NAME(ut_release_mutex);
311 
312 	ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
313 			  (u32)acpi_os_get_thread_id(),
314 			  acpi_ut_get_mutex_name(mutex_id)));
315 
316 	if (mutex_id > ACPI_MAX_MUTEX) {
317 		return (AE_BAD_PARAMETER);
318 	}
319 
320 	/*
321 	 * Mutex must be acquired in order to release it!
322 	 */
323 	if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
324 		ACPI_ERROR((AE_INFO,
325 			    "Mutex [0x%X] is not acquired, cannot release",
326 			    mutex_id));
327 
328 		return (AE_NOT_ACQUIRED);
329 	}
330 #ifdef ACPI_MUTEX_DEBUG
331 	{
332 		u32 i;
333 		/*
334 		 * Mutex debug code, for internal debugging only.
335 		 *
336 		 * Deadlock prevention. Check if this thread owns any mutexes of value
337 		 * greater than this one. If so, the thread has violated the mutex
338 		 * ordering rule. This indicates a coding error somewhere in
339 		 * the ACPI subsystem code.
340 		 */
341 		for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) {
342 			if (acpi_gbl_mutex_info[i].thread_id ==
343 			    acpi_os_get_thread_id()) {
344 				if (i == mutex_id) {
345 					continue;
346 				}
347 
348 				ACPI_ERROR((AE_INFO,
349 					    "Invalid release order: owns [%s], releasing [%s]",
350 					    acpi_ut_get_mutex_name(i),
351 					    acpi_ut_get_mutex_name(mutex_id)));
352 
353 				return (AE_RELEASE_DEADLOCK);
354 			}
355 		}
356 	}
357 #endif
358 
359 	/* Mark unlocked FIRST */
360 
361 	acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
362 
363 	acpi_os_release_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
364 	return (AE_OK);
365 }
366