Merge branch 'for-2.6.30' of git://linux-nfs.org/~bfields/linux
[linux-2.6] / drivers / acpi / acpica / utmutex.c
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 [%X]",
234                                                     acpi_ut_get_mutex_name
235                                                     (mutex_id),
236                                                     this_thread_id));
237
238                                         return (AE_ALREADY_ACQUIRED);
239                                 }
240
241                                 ACPI_ERROR((AE_INFO,
242                                             "Invalid acquire order: Thread %X owns [%s], wants [%s]",
243                                             this_thread_id,
244                                             acpi_ut_get_mutex_name(i),
245                                             acpi_ut_get_mutex_name(mutex_id)));
246
247                                 return (AE_ACQUIRE_DEADLOCK);
248                         }
249                 }
250         }
251 #endif
252
253         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
254                           "Thread %lX attempting to acquire Mutex [%s]\n",
255                           (unsigned long)this_thread_id,
256                           acpi_ut_get_mutex_name(mutex_id)));
257
258         status = acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex,
259                                        ACPI_WAIT_FOREVER);
260         if (ACPI_SUCCESS(status)) {
261                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
262                                   "Thread %lX acquired Mutex [%s]\n",
263                                   (unsigned long)this_thread_id,
264                                   acpi_ut_get_mutex_name(mutex_id)));
265
266                 acpi_gbl_mutex_info[mutex_id].use_count++;
267                 acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
268         } else {
269                 ACPI_EXCEPTION((AE_INFO, status,
270                                 "Thread %lX could not acquire Mutex [%X]",
271                                 (unsigned long)this_thread_id, mutex_id));
272         }
273
274         return (status);
275 }
276
277 /*******************************************************************************
278  *
279  * FUNCTION:    acpi_ut_release_mutex
280  *
281  * PARAMETERS:  mutex_iD        - ID of the mutex to be released
282  *
283  * RETURN:      Status
284  *
285  * DESCRIPTION: Release a mutex object.
286  *
287  ******************************************************************************/
288
289 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
290 {
291         acpi_thread_id this_thread_id;
292
293         ACPI_FUNCTION_NAME(ut_release_mutex);
294
295         this_thread_id = acpi_os_get_thread_id();
296         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
297                           "Thread %lX releasing Mutex [%s]\n",
298                           (unsigned long)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 }