xref: /titanic_41/usr/src/uts/intel/io/acpica/utilities/utlock.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: utlock - Reader/Writer lock interfaces
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.h"
45 #include "accommon.h"
46 
47 
48 #define _COMPONENT          ACPI_UTILITIES
49         ACPI_MODULE_NAME    ("utlock")
50 
51 
52 /*******************************************************************************
53  *
54  * FUNCTION:    AcpiUtCreateRwLock
55  *              AcpiUtDeleteRwLock
56  *
57  * PARAMETERS:  Lock                - Pointer to a valid RW lock
58  *
59  * RETURN:      Status
60  *
61  * DESCRIPTION: Reader/writer lock creation and deletion interfaces.
62  *
63  ******************************************************************************/
64 
65 ACPI_STATUS
AcpiUtCreateRwLock(ACPI_RW_LOCK * Lock)66 AcpiUtCreateRwLock (
67     ACPI_RW_LOCK            *Lock)
68 {
69     ACPI_STATUS             Status;
70 
71 
72     Lock->NumReaders = 0;
73     Status = AcpiOsCreateMutex (&Lock->ReaderMutex);
74     if (ACPI_FAILURE (Status))
75     {
76         return (Status);
77     }
78 
79     Status = AcpiOsCreateMutex (&Lock->WriterMutex);
80     return (Status);
81 }
82 
83 
84 void
AcpiUtDeleteRwLock(ACPI_RW_LOCK * Lock)85 AcpiUtDeleteRwLock (
86     ACPI_RW_LOCK            *Lock)
87 {
88 
89     AcpiOsDeleteMutex (Lock->ReaderMutex);
90     AcpiOsDeleteMutex (Lock->WriterMutex);
91 
92     Lock->NumReaders = 0;
93     Lock->ReaderMutex = NULL;
94     Lock->WriterMutex = NULL;
95 }
96 
97 
98 /*******************************************************************************
99  *
100  * FUNCTION:    AcpiUtAcquireReadLock
101  *              AcpiUtReleaseReadLock
102  *
103  * PARAMETERS:  Lock                - Pointer to a valid RW lock
104  *
105  * RETURN:      Status
106  *
107  * DESCRIPTION: Reader interfaces for reader/writer locks. On acquisition,
108  *              only the first reader acquires the write mutex. On release,
109  *              only the last reader releases the write mutex. Although this
110  *              algorithm can in theory starve writers, this should not be a
111  *              problem with ACPICA since the subsystem is infrequently used
112  *              in comparison to (for example) an I/O system.
113  *
114  ******************************************************************************/
115 
116 ACPI_STATUS
AcpiUtAcquireReadLock(ACPI_RW_LOCK * Lock)117 AcpiUtAcquireReadLock (
118     ACPI_RW_LOCK            *Lock)
119 {
120     ACPI_STATUS             Status;
121 
122 
123     Status = AcpiOsAcquireMutex (Lock->ReaderMutex, ACPI_WAIT_FOREVER);
124     if (ACPI_FAILURE (Status))
125     {
126         return (Status);
127     }
128 
129     /* Acquire the write lock only for the first reader */
130 
131     Lock->NumReaders++;
132     if (Lock->NumReaders == 1)
133     {
134         Status = AcpiOsAcquireMutex (Lock->WriterMutex, ACPI_WAIT_FOREVER);
135     }
136 
137     AcpiOsReleaseMutex (Lock->ReaderMutex);
138     return (Status);
139 }
140 
141 
142 ACPI_STATUS
AcpiUtReleaseReadLock(ACPI_RW_LOCK * Lock)143 AcpiUtReleaseReadLock (
144     ACPI_RW_LOCK            *Lock)
145 {
146     ACPI_STATUS             Status;
147 
148 
149     Status = AcpiOsAcquireMutex (Lock->ReaderMutex, ACPI_WAIT_FOREVER);
150     if (ACPI_FAILURE (Status))
151     {
152         return (Status);
153     }
154 
155     /* Release the write lock only for the very last reader */
156 
157     Lock->NumReaders--;
158     if (Lock->NumReaders == 0)
159     {
160         AcpiOsReleaseMutex (Lock->WriterMutex);
161     }
162 
163     AcpiOsReleaseMutex (Lock->ReaderMutex);
164     return (Status);
165 }
166 
167 
168 /*******************************************************************************
169  *
170  * FUNCTION:    AcpiUtAcquireWriteLock
171  *              AcpiUtReleaseWriteLock
172  *
173  * PARAMETERS:  Lock                - Pointer to a valid RW lock
174  *
175  * RETURN:      Status
176  *
177  * DESCRIPTION: Writer interfaces for reader/writer locks. Simply acquire or
178  *              release the writer mutex associated with the lock. Acquisition
179  *              of the lock is fully exclusive and will block all readers and
180  *              writers until it is released.
181  *
182  ******************************************************************************/
183 
184 ACPI_STATUS
AcpiUtAcquireWriteLock(ACPI_RW_LOCK * Lock)185 AcpiUtAcquireWriteLock (
186     ACPI_RW_LOCK            *Lock)
187 {
188     ACPI_STATUS             Status;
189 
190 
191     Status = AcpiOsAcquireMutex (Lock->WriterMutex, ACPI_WAIT_FOREVER);
192     return (Status);
193 }
194 
195 
196 void
AcpiUtReleaseWriteLock(ACPI_RW_LOCK * Lock)197 AcpiUtReleaseWriteLock (
198     ACPI_RW_LOCK            *Lock)
199 {
200 
201     AcpiOsReleaseMutex (Lock->WriterMutex);
202 }
203