Print this page
acpica-unix2-20130823
PANKOVs restructure
   1 /*******************************************************************************
   2  *
   3  * Module Name: utmutex - local mutex support
   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.


  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 */
 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     /* Mutex for _OSI support */

 114     Status = AcpiOsCreateMutex (&AcpiGbl_OsiMutex);
 115     if (ACPI_FAILURE (Status))
 116     {
 117         return_ACPI_STATUS (Status);
 118     }
 119 
 120     /* Create the reader/writer lock for namespace access */
 121 
 122     Status = AcpiUtCreateRwLock (&AcpiGbl_NamespaceRwLock);
 123     return_ACPI_STATUS (Status);
 124 }
 125 
 126 
 127 /*******************************************************************************
 128  *
 129  * FUNCTION:    AcpiUtMutexTerminate
 130  *
 131  * PARAMETERS:  None.
 132  *
 133  * RETURN:      None.


 143 {
 144     UINT32                  i;
 145 
 146 
 147     ACPI_FUNCTION_TRACE (UtMutexTerminate);
 148 
 149 
 150     /* Delete each predefined mutex object */
 151 
 152     for (i = 0; i < ACPI_NUM_MUTEX; i++)
 153     {
 154         AcpiUtDeleteMutex (i);
 155     }
 156 
 157     AcpiOsDeleteMutex (AcpiGbl_OsiMutex);
 158 
 159     /* Delete the spinlocks */
 160 
 161     AcpiOsDeleteLock (AcpiGbl_GpeLock);
 162     AcpiOsDeleteLock (AcpiGbl_HardwareLock);

 163 
 164     /* Delete the reader/writer lock */
 165 
 166     AcpiUtDeleteRwLock (&AcpiGbl_NamespaceRwLock);
 167     return_VOID;
 168 }
 169 
 170 
 171 /*******************************************************************************
 172  *
 173  * FUNCTION:    AcpiUtCreateMutex
 174  *
 175  * PARAMETERS:  MutexID         - ID of the mutex to be created
 176  *
 177  * RETURN:      Status
 178  *
 179  * DESCRIPTION: Create a mutex object.
 180  *
 181  ******************************************************************************/
 182 


 208  * PARAMETERS:  MutexID         - ID of the mutex to be deleted
 209  *
 210  * RETURN:      Status
 211  *
 212  * DESCRIPTION: Delete a mutex object.
 213  *
 214  ******************************************************************************/
 215 
 216 static void
 217 AcpiUtDeleteMutex (
 218     ACPI_MUTEX_HANDLE       MutexId)
 219 {
 220 
 221     ACPI_FUNCTION_TRACE_U32 (UtDeleteMutex, MutexId);
 222 
 223 
 224     AcpiOsDeleteMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
 225 
 226     AcpiGbl_MutexInfo[MutexId].Mutex = NULL;
 227     AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;


 228 }
 229 
 230 
 231 /*******************************************************************************
 232  *
 233  * FUNCTION:    AcpiUtAcquireMutex
 234  *
 235  * PARAMETERS:  MutexID         - ID of the mutex to be acquired
 236  *
 237  * RETURN:      Status
 238  *
 239  * DESCRIPTION: Acquire a mutex object.
 240  *
 241  ******************************************************************************/
 242 
 243 ACPI_STATUS
 244 AcpiUtAcquireMutex (
 245     ACPI_MUTEX_HANDLE       MutexId)
 246 {
 247     ACPI_STATUS             Status;


 318     return (Status);
 319 }
 320 
 321 
 322 /*******************************************************************************
 323  *
 324  * FUNCTION:    AcpiUtReleaseMutex
 325  *
 326  * PARAMETERS:  MutexID         - ID of the mutex to be released
 327  *
 328  * RETURN:      Status
 329  *
 330  * DESCRIPTION: Release a mutex object.
 331  *
 332  ******************************************************************************/
 333 
 334 ACPI_STATUS
 335 AcpiUtReleaseMutex (
 336     ACPI_MUTEX_HANDLE       MutexId)
 337 {
 338     ACPI_THREAD_ID          ThisThreadId;
 339 
 340 
 341     ACPI_FUNCTION_NAME (UtReleaseMutex);
 342 
 343 
 344     ThisThreadId = AcpiOsGetThreadId ();
 345     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
 346         (UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
 347 
 348     if (MutexId > ACPI_MAX_MUTEX)
 349     {
 350         return (AE_BAD_PARAMETER);
 351     }
 352 
 353     /*
 354      * Mutex must be acquired in order to release it!
 355      */
 356     if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED)
 357     {
 358         ACPI_ERROR ((AE_INFO,
 359             "Mutex [0x%X] is not acquired, cannot release", MutexId));
 360 
 361         return (AE_NOT_ACQUIRED);
 362     }
 363 
 364 #ifdef ACPI_MUTEX_DEBUG
 365     {
 366         UINT32                  i;
 367         /*
 368          * Mutex debug code, for internal debugging only.
 369          *
 370          * Deadlock prevention.  Check if this thread owns any mutexes of value
 371          * greater than this one.  If so, the thread has violated the mutex
 372          * ordering rule.  This indicates a coding error somewhere in
 373          * the ACPI subsystem code.
 374          */
 375         for (i = MutexId; i < ACPI_NUM_MUTEX; i++)
 376         {
 377             if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId)
 378             {
 379                 if (i == MutexId)
 380                 {
 381                     continue;
 382                 }
 383 
 384                 ACPI_ERROR ((AE_INFO,
 385                     "Invalid release order: owns [%s], releasing [%s]",
 386                     AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
 387 
 388                 return (AE_RELEASE_DEADLOCK);
 389             }
 390         }
 391     }
 392 #endif
 393 
 394     /* Mark unlocked FIRST */
 395 
 396     AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
 397 
 398     AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
 399     return (AE_OK);
 400 }
 401 
 402 
   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.


  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.


 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 


 216  * PARAMETERS:  MutexID         - ID of the mutex to be deleted
 217  *
 218  * RETURN:      Status
 219  *
 220  * DESCRIPTION: Delete a mutex object.
 221  *
 222  ******************************************************************************/
 223 
 224 static void
 225 AcpiUtDeleteMutex (
 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 
 253 ACPI_STATUS
 254 AcpiUtAcquireMutex (
 255     ACPI_MUTEX_HANDLE       MutexId)
 256 {
 257     ACPI_STATUS             Status;


 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 
 344 ACPI_STATUS
 345 AcpiUtReleaseMutex (
 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 }