Quelle  utmutex.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/*******************************************************************************
 *
 * Module Name: utmutex - local mutex support
 *
 ******************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"

#define _COMPONENT          ACPI_UTILITIES
ACPI_MODULE_NAME("utmutex")

/* Local prototypes */
static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id);

static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_mutex_initialize
 *
 * PARAMETERS:  None.
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Create the system mutex objects. This includes mutexes,
 *              spin locks, and reader/writer locks.
 *
 ******************************************************************************/

acpi_status acpi_ut_mutex_initialize(void)
{
 u32 i;
 acpi_status status;

 ACPI_FUNCTION_TRACE(ut_mutex_initialize);

 /* Create each of the predefined mutex objects */

 for (i = 0; i < ACPI_NUM_MUTEX; i++) {
  status = acpi_ut_create_mutex(i);
  if (ACPI_FAILURE(status)) {
   return_ACPI_STATUS(status);
  }
 }

 /* Create the spinlocks for use at interrupt level or for speed */

 status = acpi_os_create_lock (&acpi_gbl_gpe_lock);
 if (ACPI_FAILURE (status)) {
  return_ACPI_STATUS (status);
 }

 status = acpi_os_create_raw_lock(&acpi_gbl_hardware_lock);
 if (ACPI_FAILURE (status)) {
  return_ACPI_STATUS (status);
 }

 status = acpi_os_create_lock(&acpi_gbl_reference_count_lock);
 if (ACPI_FAILURE(status)) {
  return_ACPI_STATUS(status);
 }

 /* Mutex for _OSI support */

 status = acpi_os_create_mutex(&acpi_gbl_osi_mutex);
 if (ACPI_FAILURE(status)) {
  return_ACPI_STATUS(status);
 }

 /* Create the reader/writer lock for namespace access */

 status = acpi_ut_create_rw_lock(&acpi_gbl_namespace_rw_lock);
 if (ACPI_FAILURE(status)) {
  return_ACPI_STATUS(status);
 }

 return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_mutex_terminate
 *
 * PARAMETERS:  None.
 *
 * RETURN:      None.
 *
 * DESCRIPTION: Delete all of the system mutex objects. This includes mutexes,
 *              spin locks, and reader/writer locks.
 *
 ******************************************************************************/

void acpi_ut_mutex_terminate(void)
{
 u32 i;

 ACPI_FUNCTION_TRACE(ut_mutex_terminate);

 /* Delete each predefined mutex object */

 for (i = 0; i < ACPI_NUM_MUTEX; i++) {
  acpi_ut_delete_mutex(i);
 }

 acpi_os_delete_mutex(acpi_gbl_osi_mutex);

 /* Delete the spinlocks */

 acpi_os_delete_lock(acpi_gbl_gpe_lock);
 acpi_os_delete_raw_lock(acpi_gbl_hardware_lock);
 acpi_os_delete_lock(acpi_gbl_reference_count_lock);

 /* Delete the reader/writer lock */

 acpi_ut_delete_rw_lock(&acpi_gbl_namespace_rw_lock);
 return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_create_mutex
 *
 * PARAMETERS:  mutex_ID        - ID of the mutex to be created
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Create a mutex object.
 *
 ******************************************************************************/

static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
{
 acpi_status status = AE_OK;

 ACPI_FUNCTION_TRACE_U32(ut_create_mutex, mutex_id);

 if (!acpi_gbl_mutex_info[mutex_id].mutex) {
  status =
      acpi_os_create_mutex(&acpi_gbl_mutex_info[mutex_id].mutex);
  acpi_gbl_mutex_info[mutex_id].thread_id =
      ACPI_MUTEX_NOT_ACQUIRED;
  acpi_gbl_mutex_info[mutex_id].use_count = 0;
 }

 return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_delete_mutex
 *
 * PARAMETERS:  mutex_ID        - ID of the mutex to be deleted
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Delete a mutex object.
 *
 ******************************************************************************/

static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
{

 ACPI_FUNCTION_TRACE_U32(ut_delete_mutex, mutex_id);

 acpi_os_delete_mutex(acpi_gbl_mutex_info[mutex_id].mutex);

 acpi_gbl_mutex_info[mutex_id].mutex = NULL;
 acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;

 return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_acquire_mutex
 *
 * PARAMETERS:  mutex_ID        - ID of the mutex to be acquired
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Acquire a mutex object.
 *
 ******************************************************************************/

acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
{
 acpi_status status;
 acpi_thread_id this_thread_id;

 ACPI_FUNCTION_NAME(ut_acquire_mutex);

 if (mutex_id > ACPI_MAX_MUTEX) {
  return (AE_BAD_PARAMETER);
 }

 this_thread_id = acpi_os_get_thread_id();

#ifdef ACPI_MUTEX_DEBUG
 {
  u32 i;
  /*
 * Mutex debug code, for internal debugging only.
 *
 * Deadlock prevention. Check if this thread owns any mutexes of value
 * greater than or equal to this one. If so, the thread has violated
 * the mutex ordering rule. This indicates a coding error somewhere in
 * the ACPI subsystem code.
 */
  for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) {
   if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) {
    if (i == mutex_id) {
     ACPI_ERROR((AE_INFO,
          "Mutex [%s] already acquired by this thread [%u]",
          acpi_ut_get_mutex_name
          (mutex_id),
          (u32)this_thread_id));

     return (AE_ALREADY_ACQUIRED);
    }

    ACPI_ERROR((AE_INFO,
         "Invalid acquire order: Thread %u owns [%s], wants [%s]",
         (u32)this_thread_id,
         acpi_ut_get_mutex_name(i),
         acpi_ut_get_mutex_name(mutex_id)));

    return (AE_ACQUIRE_DEADLOCK);
   }
  }
 }
#endif

 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
     "Thread %u attempting to acquire Mutex [%s]\n",
     (u32)this_thread_id,
     acpi_ut_get_mutex_name(mutex_id)));

 status =
     acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex,
      ACPI_WAIT_FOREVER);
 if (ACPI_SUCCESS(status)) {
  ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
      "Thread %u acquired Mutex [%s]\n",
      (u32)this_thread_id,
      acpi_ut_get_mutex_name(mutex_id)));

  acpi_gbl_mutex_info[mutex_id].use_count++;
  acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
 } else {
  ACPI_EXCEPTION((AE_INFO, status,
    "Thread %u could not acquire Mutex [%s] (0x%X)",
    (u32)this_thread_id,
    acpi_ut_get_mutex_name(mutex_id), mutex_id));
 }

 return (status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_release_mutex
 *
 * PARAMETERS:  mutex_ID        - ID of the mutex to be released
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Release a mutex object.
 *
 ******************************************************************************/

acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
{
 ACPI_FUNCTION_NAME(ut_release_mutex);

 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
     (u32)acpi_os_get_thread_id(),
     acpi_ut_get_mutex_name(mutex_id)));

 if (mutex_id > ACPI_MAX_MUTEX) {
  return (AE_BAD_PARAMETER);
 }

 /*
 * Mutex must be acquired in order to release it!
 */
 if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
  ACPI_ERROR((AE_INFO,
       "Mutex [%s] (0x%X) is not acquired, cannot release",
       acpi_ut_get_mutex_name(mutex_id), mutex_id));

  return (AE_NOT_ACQUIRED);
 }
#ifdef ACPI_MUTEX_DEBUG
 {
  u32 i;
  /*
 * Mutex debug code, for internal debugging only.
 *
 * Deadlock prevention. Check if this thread owns any mutexes of value
 * greater than this one. If so, the thread has violated the mutex
 * ordering rule. This indicates a coding error somewhere in
 * the ACPI subsystem code.
 */
  for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) {
   if (acpi_gbl_mutex_info[i].thread_id ==
       acpi_os_get_thread_id()) {
    if (i == mutex_id) {
     continue;
    }

    ACPI_ERROR((AE_INFO,
         "Invalid release order: owns [%s], releasing [%s]",
         acpi_ut_get_mutex_name(i),
         acpi_ut_get_mutex_name(mutex_id)));

    return (AE_RELEASE_DEADLOCK);
   }
  }
 }
#endif

 /* Mark unlocked FIRST */

 acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;

 acpi_os_release_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
 return (AE_OK);
}