utmutex.c revision 256281 
1/*******************************************************************************
2 *
3 * Module Name: utmutex - local mutex support
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2013, 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
45#define __UTMUTEX_C__
46
47#include <contrib/dev/acpica/include/acpi.h>
48#include <contrib/dev/acpica/include/accommon.h>
49
50#define _COMPONENT          ACPI_UTILITIES
51        ACPI_MODULE_NAME    ("utmutex")
52
53/* Local prototypes */
54
55static ACPI_STATUS
56AcpiUtCreateMutex (
57    ACPI_MUTEX_HANDLE       MutexId);
58
59static void
60AcpiUtDeleteMutex (
61    ACPI_MUTEX_HANDLE       MutexId);
62
63
64/*******************************************************************************
65 *
66 * FUNCTION:    AcpiUtMutexInitialize
67 *
68 * PARAMETERS:  None.
69 *
70 * RETURN:      Status
71 *
72 * DESCRIPTION: Create the system mutex objects. This includes mutexes,
73 *              spin locks, and reader/writer locks.
74 *
75 ******************************************************************************/
76
77ACPI_STATUS
78AcpiUtMutexInitialize (
79    void)
80{
81    UINT32                  i;
82    ACPI_STATUS             Status;
83
84
85    ACPI_FUNCTION_TRACE (UtMutexInitialize);
86
87
88    /* Create each of the predefined mutex objects */
89
90    for (i = 0; i < ACPI_NUM_MUTEX; i++)
91    {
92        Status = AcpiUtCreateMutex (i);
93        if (ACPI_FAILURE (Status))
94        {
95            return_ACPI_STATUS (Status);
96        }
97    }
98
99    /* Create the spinlocks for use at interrupt level or for speed */
100
101    Status = AcpiOsCreateLock (&AcpiGbl_GpeLock);
102    if (ACPI_FAILURE (Status))
103    {
104        return_ACPI_STATUS (Status);
105    }
106
107    Status = AcpiOsCreateLock (&AcpiGbl_HardwareLock);
108    if (ACPI_FAILURE (Status))
109    {
110        return_ACPI_STATUS (Status);
111    }
112
113    Status = AcpiOsCreateLock (&AcpiGbl_ReferenceCountLock);
114    if (ACPI_FAILURE (Status))
115    {
116        return_ACPI_STATUS (Status);
117    }
118
119    /* Mutex for _OSI support */
120
121    Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex);
122    if (ACPI_FAILURE (Status))
123    {
124        return_ACPI_STATUS (Status);
125    }
126
127    /* Create the reader/writer lock for namespace access */
128
129    Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock);
130    return_ACPI_STATUS (Status);
131}
132
133
134/*******************************************************************************
135 *
136 * FUNCTION:    AcpiUtMutexTerminate
137 *
138 * PARAMETERS:  None.
139 *
140 * RETURN:      None.
141 *
142 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes,
143 *              spin locks, and reader/writer locks.
144 *
145 ******************************************************************************/
146
147void
148AcpiUtMutexTerminate (
149    void)
150{
151    UINT32                  i;
152
153
154    ACPI_FUNCTION_TRACE (UtMutexTerminate);
155
156
157    /* Delete each predefined mutex object */
158
159    for (i = 0; i < ACPI_NUM_MUTEX; i++)
160    {
161        AcpiUtDeleteMutex (i);
162    }
163
164    AcpiOsDeleteMutex (AcpiGbl_OsiMutex);
165
166    /* Delete the spinlocks */
167
168    AcpiOsDeleteLock (AcpiGbl_GpeLock);
169    AcpiOsDeleteLock (AcpiGbl_HardwareLock);
170    AcpiOsDeleteLock (AcpiGbl_ReferenceCountLock);
171
172    /* Delete the reader/writer lock */
173
174    AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock);
175    return_VOID;
176}
177
178
179/*******************************************************************************
180 *
181 * FUNCTION:    AcpiUtCreateMutex
182 *
183 * PARAMETERS:  MutexID         - ID of the mutex to be created
184 *
185 * RETURN:      Status
186 *
187 * DESCRIPTION: Create a mutex object.
188 *
189 ******************************************************************************/
190
191static ACPI_STATUS
192AcpiUtCreateMutex (
193    ACPI_MUTEX_HANDLE       MutexId)
194{
195    ACPI_STATUS             Status = AE_OK;
196
197
198    ACPI_FUNCTION_TRACE_U32 (UtCreateMutex, MutexId);
199
200
201    if (!AcpiGbl_MutexInfo[MutexId].Mutex)
202    {
203        Status = AcpiOsCreateMutex (&AcpiGbl_MutexInfo[MutexId].Mutex);
204        AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
205        AcpiGbl_MutexInfo[MutexId].UseCount = 0;
206    }
207
208    return_ACPI_STATUS (Status);
209}
210
211
212/*******************************************************************************
213 *
214 * FUNCTION:    AcpiUtDeleteMutex
215 *
216 * PARAMETERS:  MutexID         - ID of the mutex to be deleted
217 *
218 * RETURN:      Status
219 *
220 * DESCRIPTION: Delete a mutex object.
221 *
222 ******************************************************************************/
223
224static void
225AcpiUtDeleteMutex (
226    ACPI_MUTEX_HANDLE       MutexId)
227{
228
229    ACPI_FUNCTION_TRACE_U32 (UtDeleteMutex, MutexId);
230
231
232    AcpiOsDeleteMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
233
234    AcpiGbl_MutexInfo[MutexId].Mutex = NULL;
235    AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
236
237    return_VOID;
238}
239
240
241/*******************************************************************************
242 *
243 * FUNCTION:    AcpiUtAcquireMutex
244 *
245 * PARAMETERS:  MutexID         - ID of the mutex to be acquired
246 *
247 * RETURN:      Status
248 *
249 * DESCRIPTION: Acquire a mutex object.
250 *
251 ******************************************************************************/
252
253ACPI_STATUS
254AcpiUtAcquireMutex (
255    ACPI_MUTEX_HANDLE       MutexId)
256{
257    ACPI_STATUS             Status;
258    ACPI_THREAD_ID          ThisThreadId;
259
260
261    ACPI_FUNCTION_NAME (UtAcquireMutex);
262
263
264    if (MutexId > ACPI_MAX_MUTEX)
265    {
266        return (AE_BAD_PARAMETER);
267    }
268
269    ThisThreadId = AcpiOsGetThreadId ();
270
271#ifdef ACPI_MUTEX_DEBUG
272    {
273        UINT32                  i;
274        /*
275         * Mutex debug code, for internal debugging only.
276         *
277         * Deadlock prevention. Check if this thread owns any mutexes of value
278         * greater than or equal to this one. If so, the thread has violated
279         * the mutex ordering rule. This indicates a coding error somewhere in
280         * the ACPI subsystem code.
281         */
282        for (i = MutexId; i < ACPI_NUM_MUTEX; i++)
283        {
284            if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId)
285            {
286                if (i == MutexId)
287                {
288                    ACPI_ERROR ((AE_INFO,
289                        "Mutex [%s] already acquired by this thread [%u]",
290                        AcpiUtGetMutexName (MutexId),
291                        (UINT32) ThisThreadId));
292
293                    return (AE_ALREADY_ACQUIRED);
294                }
295
296                ACPI_ERROR ((AE_INFO,
297                    "Invalid acquire order: Thread %u owns [%s], wants [%s]",
298                    (UINT32) ThisThreadId, AcpiUtGetMutexName (i),
299                    AcpiUtGetMutexName (MutexId)));
300
301                return (AE_ACQUIRE_DEADLOCK);
302            }
303        }
304    }
305#endif
306
307    ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
308        "Thread %u attempting to acquire Mutex [%s]\n",
309        (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
310
311    Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex,
312                ACPI_WAIT_FOREVER);
313    if (ACPI_SUCCESS (Status))
314    {
315        ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n",
316            (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
317
318        AcpiGbl_MutexInfo[MutexId].UseCount++;
319        AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId;
320    }
321    else
322    {
323        ACPI_EXCEPTION ((AE_INFO, Status,
324            "Thread %u could not acquire Mutex [0x%X]",
325            (UINT32) ThisThreadId, MutexId));
326    }
327
328    return (Status);
329}
330
331
332/*******************************************************************************
333 *
334 * FUNCTION:    AcpiUtReleaseMutex
335 *
336 * PARAMETERS:  MutexID         - ID of the mutex to be released
337 *
338 * RETURN:      Status
339 *
340 * DESCRIPTION: Release a mutex object.
341 *
342 ******************************************************************************/
343
344ACPI_STATUS
345AcpiUtReleaseMutex (
346    ACPI_MUTEX_HANDLE       MutexId)
347{
348    ACPI_FUNCTION_NAME (UtReleaseMutex);
349
350
351    ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
352        (UINT32) AcpiOsGetThreadId (), AcpiUtGetMutexName (MutexId)));
353
354    if (MutexId > ACPI_MAX_MUTEX)
355    {
356        return (AE_BAD_PARAMETER);
357    }
358
359    /*
360     * Mutex must be acquired in order to release it!
361     */
362    if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED)
363    {
364        ACPI_ERROR ((AE_INFO,
365            "Mutex [0x%X] is not acquired, cannot release", MutexId));
366
367        return (AE_NOT_ACQUIRED);
368    }
369
370#ifdef ACPI_MUTEX_DEBUG
371    {
372        UINT32                  i;
373        /*
374         * Mutex debug code, for internal debugging only.
375         *
376         * Deadlock prevention. Check if this thread owns any mutexes of value
377         * greater than this one. If so, the thread has violated the mutex
378         * ordering rule. This indicates a coding error somewhere in
379         * the ACPI subsystem code.
380         */
381        for (i = MutexId; i < ACPI_NUM_MUTEX; i++)
382        {
383            if (AcpiGbl_MutexInfo[i].ThreadId == AcpiOsGetThreadId ())
384            {
385                if (i == MutexId)
386                {
387                    continue;
388                }
389
390                ACPI_ERROR ((AE_INFO,
391                    "Invalid release order: owns [%s], releasing [%s]",
392                    AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
393
394                return (AE_RELEASE_DEADLOCK);
395            }
396        }
397    }
398#endif
399
400    /* Mark unlocked FIRST */
401
402    AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
403
404    AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
405    return (AE_OK);
406}
407