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 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 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 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 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 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 197 AcpiUtReleaseWriteLock ( 198 ACPI_RW_LOCK *Lock) 199 { 200 201 AcpiOsReleaseMutex (Lock->WriterMutex); 202 } 203