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