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