void
AcpiDbDisplayLocks (
void)
{
UINT32 i;
for (i = 0; i < ACPI_MAX_MUTEX; i++)
{
AcpiOsPrintf ("%26s : %s\n", AcpiUtGetMutexName (i),
AcpiGbl_MutexInfo[i].ThreadId == ACPI_MUTEX_NOT_ACQUIRED
? "Locked" : "Unlocked");
}
}
ACPI_STATUS
AcpiDbDisplayStatistics (
char *TypeArg)
{
UINT32 i;
UINT32 Temp;
if (!TypeArg)
{
AcpiOsPrintf ("The following subcommands are available:\n ALLOCATIONS, OBJECTS, MEMORY, MISC, SIZES, TABLES\n");
return (AE_OK);
}
AcpiUtStrupr (TypeArg);
Temp = AcpiDbMatchArgument (TypeArg, AcpiDbStatTypes);
if (Temp == (UINT32) -1)
{
AcpiOsPrintf ("Invalid or unsupported argument\n");
return (AE_OK);
}
switch (Temp)
{
case CMD_STAT_ALLOCATIONS:
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiUtDumpAllocationInfo ();
#endif
break;
case CMD_STAT_TABLES:
AcpiOsPrintf ("ACPI Table Information (not implemented):\n\n");
break;
case CMD_STAT_OBJECTS:
AcpiDbCountNamespaceObjects ();
AcpiOsPrintf ("\nObjects defined in the current namespace:\n\n");
AcpiOsPrintf ("%16.16s %10.10s %10.10s\n",
"ACPI_TYPE", "NODES", "OBJECTS");
for (i = 0; i < ACPI_TYPE_NS_NODE_MAX; i++)
{
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", AcpiUtGetTypeName (i),
AcpiGbl_NodeTypeCount [i], AcpiGbl_ObjTypeCount [i]);
}
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "Misc/Unknown",
AcpiGbl_NodeTypeCountMisc, AcpiGbl_ObjTypeCountMisc);
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "TOTALS:",
AcpiGbl_NumNodes, AcpiGbl_NumObjects);
break;
case CMD_STAT_MEMORY:
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiOsPrintf ("\n----Object Statistics (all in hex)---------\n");
AcpiDbListInfo (AcpiGbl_GlobalList);
AcpiDbListInfo (AcpiGbl_NsNodeList);
#endif
#ifdef ACPI_USE_LOCAL_CACHE
AcpiOsPrintf ("\n----Cache Statistics (all in hex)---------\n");
AcpiDbListInfo (AcpiGbl_OperandCache);
AcpiDbListInfo (AcpiGbl_PsNodeCache);
AcpiDbListInfo (AcpiGbl_PsNodeExtCache);
AcpiDbListInfo (AcpiGbl_StateCache);
#endif
break;
case CMD_STAT_MISC:
AcpiOsPrintf ("\nMiscellaneous Statistics:\n\n");
AcpiOsPrintf ("Calls to AcpiPsFind:.. ........% 7ld\n",
AcpiGbl_PsFindCount);
AcpiOsPrintf ("Calls to AcpiNsLookup:..........% 7ld\n",
AcpiGbl_NsLookupCount);
AcpiOsPrintf ("\n");
AcpiOsPrintf ("Mutex usage:\n\n");
for (i = 0; i < ACPI_NUM_MUTEX; i++)
{
AcpiOsPrintf ("%-28s: % 7ld\n",
AcpiUtGetMutexName (i), AcpiGbl_MutexInfo[i].UseCount);
}
break;
case CMD_STAT_SIZES:
AcpiOsPrintf ("\nInternal object sizes:\n\n");
AcpiOsPrintf ("Common %3d\n", sizeof (ACPI_OBJECT_COMMON));
AcpiOsPrintf ("Number %3d\n", sizeof (ACPI_OBJECT_INTEGER));
AcpiOsPrintf ("String %3d\n", sizeof (ACPI_OBJECT_STRING));
AcpiOsPrintf ("Buffer %3d\n", sizeof (ACPI_OBJECT_BUFFER));
AcpiOsPrintf ("Package %3d\n", sizeof (ACPI_OBJECT_PACKAGE));
AcpiOsPrintf ("BufferField %3d\n", sizeof (ACPI_OBJECT_BUFFER_FIELD));
AcpiOsPrintf ("Device %3d\n", sizeof (ACPI_OBJECT_DEVICE));
AcpiOsPrintf ("Event %3d\n", sizeof (ACPI_OBJECT_EVENT));
AcpiOsPrintf ("Method %3d\n", sizeof (ACPI_OBJECT_METHOD));
AcpiOsPrintf ("Mutex %3d\n", sizeof (ACPI_OBJECT_MUTEX));
AcpiOsPrintf ("Region %3d\n", sizeof (ACPI_OBJECT_REGION));
AcpiOsPrintf ("PowerResource %3d\n", sizeof (ACPI_OBJECT_POWER_RESOURCE));
AcpiOsPrintf ("Processor %3d\n", sizeof (ACPI_OBJECT_PROCESSOR));
AcpiOsPrintf ("ThermalZone %3d\n", sizeof (ACPI_OBJECT_THERMAL_ZONE));
AcpiOsPrintf ("RegionField %3d\n", sizeof (ACPI_OBJECT_REGION_FIELD));
AcpiOsPrintf ("BankField %3d\n", sizeof (ACPI_OBJECT_BANK_FIELD));
AcpiOsPrintf ("IndexField %3d\n", sizeof (ACPI_OBJECT_INDEX_FIELD));
AcpiOsPrintf ("Reference %3d\n", sizeof (ACPI_OBJECT_REFERENCE));
AcpiOsPrintf ("Notify %3d\n", sizeof (ACPI_OBJECT_NOTIFY_HANDLER));
AcpiOsPrintf ("AddressSpace %3d\n", sizeof (ACPI_OBJECT_ADDR_HANDLER));
AcpiOsPrintf ("Extra %3d\n", sizeof (ACPI_OBJECT_EXTRA));
AcpiOsPrintf ("Data %3d\n", sizeof (ACPI_OBJECT_DATA));
AcpiOsPrintf ("\n");
AcpiOsPrintf ("ParseObject %3d\n", sizeof (ACPI_PARSE_OBJ_COMMON));
AcpiOsPrintf ("ParseObjectNamed %3d\n", sizeof (ACPI_PARSE_OBJ_NAMED));
AcpiOsPrintf ("ParseObjectAsl %3d\n", sizeof (ACPI_PARSE_OBJ_ASL));
AcpiOsPrintf ("OperandObject %3d\n", sizeof (ACPI_OPERAND_OBJECT));
AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE));
AcpiOsPrintf ("AcpiObject %3d\n", sizeof (ACPI_OBJECT));
break;
case CMD_STAT_STACK:
#if defined(ACPI_DEBUG_OUTPUT)
Temp = (UINT32) ACPI_PTR_DIFF (AcpiGbl_EntryStackPointer, AcpiGbl_LowestStackPointer);
AcpiOsPrintf ("\nSubsystem Stack Usage:\n\n");
AcpiOsPrintf ("Entry Stack Pointer %p\n", AcpiGbl_EntryStackPointer);
AcpiOsPrintf ("Lowest Stack Pointer %p\n", AcpiGbl_LowestStackPointer);
AcpiOsPrintf ("Stack Use %X (%u)\n", Temp, Temp);
AcpiOsPrintf ("Deepest Procedure Nesting %u\n", AcpiGbl_DeepestNesting);
#endif
break;
default:
break;
}
AcpiOsPrintf ("\n");
return (AE_OK);
}
ACPI_STATUS
AcpiUtAcquireMutex (
ACPI_MUTEX_HANDLE MutexId)
{
ACPI_STATUS Status;
ACPI_THREAD_ID ThisThreadId;
ACPI_FUNCTION_NAME (UtAcquireMutex);
if (MutexId > ACPI_MAX_MUTEX)
{
return (AE_BAD_PARAMETER);
}
ThisThreadId = AcpiOsGetThreadId ();
#ifdef ACPI_MUTEX_DEBUG
{
UINT32 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 = MutexId; i < ACPI_NUM_MUTEX; i++)
{
if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId)
{
if (i == MutexId)
{
ACPI_ERROR ((AE_INFO,
"Mutex [%s] already acquired by this thread [%u]",
AcpiUtGetMutexName (MutexId),
(UINT32) ThisThreadId));
return (AE_ALREADY_ACQUIRED);
}
ACPI_ERROR ((AE_INFO,
"Invalid acquire order: Thread %u owns [%s], wants [%s]",
(UINT32) ThisThreadId, AcpiUtGetMutexName (i),
AcpiUtGetMutexName (MutexId)));
return (AE_ACQUIRE_DEADLOCK);
}
}
}
#endif
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %u attempting to acquire Mutex [%s]\n",
(UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
Status = AcpiOsAcquireMutex (AcpiGbl_MutexInfo[MutexId].Mutex,
ACPI_WAIT_FOREVER);
if (ACPI_SUCCESS (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u acquired Mutex [%s]\n",
(UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
AcpiGbl_MutexInfo[MutexId].UseCount++;
AcpiGbl_MutexInfo[MutexId].ThreadId = ThisThreadId;
}
else
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Thread %u could not acquire Mutex [0x%X]",
(UINT32) ThisThreadId, MutexId));
}
return (Status);
}
ACPI_STATUS
AcpiUtReleaseMutex (
ACPI_MUTEX_HANDLE MutexId)
{
ACPI_THREAD_ID ThisThreadId;
ACPI_FUNCTION_NAME (UtReleaseMutex);
ThisThreadId = AcpiOsGetThreadId ();
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
(UINT32) ThisThreadId, AcpiUtGetMutexName (MutexId)));
if (MutexId > ACPI_MAX_MUTEX)
{
return (AE_BAD_PARAMETER);
}
/*
* Mutex must be acquired in order to release it!
*/
if (AcpiGbl_MutexInfo[MutexId].ThreadId == ACPI_MUTEX_NOT_ACQUIRED)
{
ACPI_ERROR ((AE_INFO,
"Mutex [0x%X] is not acquired, cannot release", MutexId));
return (AE_NOT_ACQUIRED);
}
#ifdef ACPI_MUTEX_DEBUG
{
UINT32 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 = MutexId; i < ACPI_NUM_MUTEX; i++)
{
if (AcpiGbl_MutexInfo[i].ThreadId == ThisThreadId)
{
if (i == MutexId)
{
continue;
}
ACPI_ERROR ((AE_INFO,
"Invalid release order: owns [%s], releasing [%s]",
AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
return (AE_RELEASE_DEADLOCK);
}
}
}
#endif
/* Mark unlocked FIRST */
AcpiGbl_MutexInfo[MutexId].ThreadId = ACPI_MUTEX_NOT_ACQUIRED;
AcpiOsReleaseMutex (AcpiGbl_MutexInfo[MutexId].Mutex);
return (AE_OK);
}
ACPI_STATUS
AcpiDbDisplayStatistics (
NATIVE_CHAR *TypeArg)
{
UINT32 i;
UINT32 Type;
UINT32 Size;
if (!AcpiGbl_DSDT)
{
AcpiOsPrintf ("*** Warning: There is no DSDT loaded\n");
}
if (!TypeArg)
{
AcpiOsPrintf ("The following subcommands are available:\n ALLOCATIONS, OBJECTS, MEMORY, MISC, SIZES, TABLES\n");
return (AE_OK);
}
STRUPR (TypeArg);
Type = AcpiDbMatchArgument (TypeArg, AcpiDbStatTypes);
if (Type == (UINT32) -1)
{
AcpiOsPrintf ("Invalid or unsupported argument\n");
return (AE_OK);
}
switch (Type)
{
#ifndef PARSER_ONLY
case CMD_ALLOCATIONS:
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiUtDumpAllocationInfo ();
#endif
break;
#endif
case CMD_TABLES:
AcpiOsPrintf ("ACPI Table Information:\n\n");
if (AcpiGbl_DSDT)
{
AcpiOsPrintf ("DSDT Length:................% 7ld (%X)\n", AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length);
}
break;
case CMD_OBJECTS:
#ifndef PARSER_ONLY
AcpiDbCountNamespaceObjects ();
AcpiOsPrintf ("\nObjects defined in the current namespace:\n\n");
AcpiOsPrintf ("%16.16s % 10.10s % 10.10s\n", "ACPI_TYPE", "NODES", "OBJECTS");
for (i = 0; i < INTERNAL_TYPE_NODE_MAX; i++)
{
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", AcpiUtGetTypeName (i),
AcpiGbl_NodeTypeCount [i], AcpiGbl_ObjTypeCount [i]);
}
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "Misc/Unknown",
AcpiGbl_NodeTypeCountMisc, AcpiGbl_ObjTypeCountMisc);
AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "TOTALS:",
AcpiGbl_NumNodes, AcpiGbl_NumObjects);
#endif
break;
case CMD_MEMORY:
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiOsPrintf ("\n----Object and Cache Statistics---------------------------------------------\n");
for (i = 0; i < ACPI_NUM_MEM_LISTS; i++)
{
AcpiOsPrintf ("\n%s\n", AcpiGbl_MemoryLists[i].ListName);
if (AcpiGbl_MemoryLists[i].MaxCacheDepth > 0)
{
AcpiOsPrintf (" Cache: [Depth Max Avail Size] % 7d % 7d % 7d % 7d B\n",
AcpiGbl_MemoryLists[i].CacheDepth,
AcpiGbl_MemoryLists[i].MaxCacheDepth,
AcpiGbl_MemoryLists[i].MaxCacheDepth - AcpiGbl_MemoryLists[i].CacheDepth,
(AcpiGbl_MemoryLists[i].CacheDepth * AcpiGbl_MemoryLists[i].ObjectSize));
AcpiOsPrintf (" Cache: [Requests Hits Misses ObjSize] % 7d % 7d % 7d % 7d B\n",
AcpiGbl_MemoryLists[i].CacheRequests,
AcpiGbl_MemoryLists[i].CacheHits,
AcpiGbl_MemoryLists[i].CacheRequests - AcpiGbl_MemoryLists[i].CacheHits,
AcpiGbl_MemoryLists[i].ObjectSize);
}
Outstanding = AcpiGbl_MemoryLists[i].TotalAllocated -
AcpiGbl_MemoryLists[i].TotalFreed -
AcpiGbl_MemoryLists[i].CacheDepth;
if (AcpiGbl_MemoryLists[i].ObjectSize)
{
Size = ROUND_UP_TO_1K (Outstanding * AcpiGbl_MemoryLists[i].ObjectSize);
}
else
{
Size = ROUND_UP_TO_1K (AcpiGbl_MemoryLists[i].CurrentTotalSize);
}
AcpiOsPrintf (" Mem: [Alloc Free Outstanding Size] % 7d % 7d % 7d % 7d Kb\n",
AcpiGbl_MemoryLists[i].TotalAllocated,
AcpiGbl_MemoryLists[i].TotalFreed,
Outstanding, Size);
}
#endif
break;
case CMD_MISC:
AcpiOsPrintf ("\nMiscellaneous Statistics:\n\n");
AcpiOsPrintf ("Calls to AcpiPsFind:.. ........% 7ld\n", AcpiGbl_PsFindCount);
AcpiOsPrintf ("Calls to AcpiNsLookup:..........% 7ld\n", AcpiGbl_NsLookupCount);
AcpiOsPrintf ("\n");
AcpiOsPrintf ("Mutex usage:\n\n");
for (i = 0; i < NUM_MTX; i++)
{
AcpiOsPrintf ("%-28s: % 7ld\n", AcpiUtGetMutexName (i), AcpiGbl_AcpiMutexInfo[i].UseCount);
}
break;
case CMD_SIZES:
AcpiOsPrintf ("\nInternal object sizes:\n\n");
AcpiOsPrintf ("Common %3d\n", sizeof (ACPI_OBJECT_COMMON));
AcpiOsPrintf ("Number %3d\n", sizeof (ACPI_OBJECT_INTEGER));
AcpiOsPrintf ("String %3d\n", sizeof (ACPI_OBJECT_STRING));
AcpiOsPrintf ("Buffer %3d\n", sizeof (ACPI_OBJECT_BUFFER));
AcpiOsPrintf ("Package %3d\n", sizeof (ACPI_OBJECT_PACKAGE));
AcpiOsPrintf ("BufferField %3d\n", sizeof (ACPI_OBJECT_BUFFER_FIELD));
AcpiOsPrintf ("Device %3d\n", sizeof (ACPI_OBJECT_DEVICE));
AcpiOsPrintf ("Event %3d\n", sizeof (ACPI_OBJECT_EVENT));
AcpiOsPrintf ("Method %3d\n", sizeof (ACPI_OBJECT_METHOD));
AcpiOsPrintf ("Mutex %3d\n", sizeof (ACPI_OBJECT_MUTEX));
AcpiOsPrintf ("Region %3d\n", sizeof (ACPI_OBJECT_REGION));
AcpiOsPrintf ("PowerResource %3d\n", sizeof (ACPI_OBJECT_POWER_RESOURCE));
AcpiOsPrintf ("Processor %3d\n", sizeof (ACPI_OBJECT_PROCESSOR));
AcpiOsPrintf ("ThermalZone %3d\n", sizeof (ACPI_OBJECT_THERMAL_ZONE));
AcpiOsPrintf ("RegionField %3d\n", sizeof (ACPI_OBJECT_REGION_FIELD));
AcpiOsPrintf ("BankField %3d\n", sizeof (ACPI_OBJECT_BANK_FIELD));
AcpiOsPrintf ("IndexField %3d\n", sizeof (ACPI_OBJECT_INDEX_FIELD));
AcpiOsPrintf ("Reference %3d\n", sizeof (ACPI_OBJECT_REFERENCE));
AcpiOsPrintf ("NotifyHandler %3d\n", sizeof (ACPI_OBJECT_NOTIFY_HANDLER));
AcpiOsPrintf ("AddrHandler %3d\n", sizeof (ACPI_OBJECT_ADDR_HANDLER));
AcpiOsPrintf ("Extra %3d\n", sizeof (ACPI_OBJECT_EXTRA));
AcpiOsPrintf ("\n");
AcpiOsPrintf ("ParseObject %3d\n", sizeof (ACPI_PARSE_OBJECT));
AcpiOsPrintf ("Parse2Object %3d\n", sizeof (ACPI_PARSE2_OBJECT));
AcpiOsPrintf ("OperandObject %3d\n", sizeof (ACPI_OPERAND_OBJECT));
AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE));
break;
case CMD_STACK:
Size = AcpiGbl_EntryStackPointer - AcpiGbl_LowestStackPointer;
AcpiOsPrintf ("\nSubsystem Stack Usage:\n\n");
AcpiOsPrintf ("Entry Stack Pointer %X\n", AcpiGbl_EntryStackPointer);
AcpiOsPrintf ("Lowest Stack Pointer %X\n", AcpiGbl_LowestStackPointer);
AcpiOsPrintf ("Stack Use %X (%d)\n", Size, Size);
AcpiOsPrintf ("Deepest Procedure Nesting %d\n", AcpiGbl_DeepestNesting);
break;
}
AcpiOsPrintf ("\n");
return (AE_OK);
}
ACPI_STATUS
AcpiOsWaitSemaphore (
ACPI_SEMAPHORE Handle,
UINT32 Units,
UINT16 Timeout)
{
UINT32 Index = (UINT32) Handle;
UINT32 WaitStatus;
UINT32 OsTimeout = Timeout;
ACPI_FUNCTION_ENTRY ();
if ((Index >= ACPI_OS_MAX_SEMAPHORES) ||
!AcpiGbl_Semaphores[Index].OsHandle)
{
return (AE_BAD_PARAMETER);
}
if (Units > 1)
{
printf ("WaitSemaphore: Attempt to receive %u units\n", Units);
return (AE_NOT_IMPLEMENTED);
}
if (Timeout == ACPI_WAIT_FOREVER)
{
OsTimeout = INFINITE;
if (AcpiGbl_DebugTimeout)
{
/* The debug timeout will prevent hang conditions */
OsTimeout = ACPI_OS_DEBUG_TIMEOUT;
}
}
else
{
/* Add 10ms to account for clock tick granularity */
OsTimeout += 10;
}
WaitStatus = WaitForSingleObject (AcpiGbl_Semaphores[Index].OsHandle, OsTimeout);
if (WaitStatus == WAIT_TIMEOUT)
{
if (AcpiGbl_DebugTimeout)
{
ACPI_EXCEPTION ((AE_INFO, AE_TIME,
"Debug timeout on semaphore 0x%04X (%ums)\n",
Index, ACPI_OS_DEBUG_TIMEOUT));
}
return (AE_TIME);
}
if (AcpiGbl_Semaphores[Index].CurrentUnits == 0)
{
ACPI_ERROR ((AE_INFO, "%s - No unit received. Timeout 0x%X, OS_Status 0x%X",
AcpiUtGetMutexName (Index), Timeout, WaitStatus));
return (AE_OK);
}
AcpiGbl_Semaphores[Index].CurrentUnits--;
return (AE_OK);
}
ACPI_STATUS
AcpiUtReleaseMutex (
ACPI_MUTEX_HANDLE MutexId)
{
ACPI_STATUS Status;
UINT32 i;
UINT32 ThisThreadId;
ACPI_FUNCTION_NAME ("UtReleaseMutex");
ThisThreadId = AcpiOsGetThreadId ();
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %X releasing Mutex [%s]\n", ThisThreadId,
AcpiUtGetMutexName (MutexId)));
if (MutexId > MAX_MTX)
{
return (AE_BAD_PARAMETER);
}
/*
* Mutex must be acquired in order to release it!
*/
if (AcpiGbl_AcpiMutexInfo[MutexId].OwnerId == ACPI_MUTEX_NOT_ACQUIRED)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Mutex [%s] is not acquired, cannot release\n",
AcpiUtGetMutexName (MutexId)));
return (AE_NOT_ACQUIRED);
}
/*
* 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 = MutexId; i < MAX_MTX; i++)
{
if (AcpiGbl_AcpiMutexInfo[i].OwnerId == ThisThreadId)
{
if (i == MutexId)
{
continue;
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invalid release order: owns [%s], releasing [%s]\n",
AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
return (AE_RELEASE_DEADLOCK);
}
}
/* Mark unlocked FIRST */
AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
Status = AcpiOsSignalSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex, 1);
if (ACPI_FAILURE (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not release Mutex [%s] %s\n",
ThisThreadId, AcpiUtGetMutexName (MutexId),
AcpiFormatException (Status)));
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n",
ThisThreadId, AcpiUtGetMutexName (MutexId)));
}
return (Status);
}
ACPI_STATUS
AcpiUtAcquireMutex (
ACPI_MUTEX_HANDLE MutexId)
{
ACPI_STATUS Status;
UINT32 i;
UINT32 ThisThreadId;
ACPI_FUNCTION_NAME ("UtAcquireMutex");
if (MutexId > MAX_MTX)
{
return (AE_BAD_PARAMETER);
}
ThisThreadId = AcpiOsGetThreadId ();
/*
* 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 = MutexId; i < MAX_MTX; i++)
{
if (AcpiGbl_AcpiMutexInfo[i].OwnerId == ThisThreadId)
{
if (i == MutexId)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Mutex [%s] already acquired by this thread [%X]\n",
AcpiUtGetMutexName (MutexId), ThisThreadId));
return (AE_ALREADY_ACQUIRED);
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
ThisThreadId, AcpiUtGetMutexName (i),
AcpiUtGetMutexName (MutexId)));
return (AE_ACQUIRE_DEADLOCK);
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %X attempting to acquire Mutex [%s]\n",
ThisThreadId, AcpiUtGetMutexName (MutexId)));
Status = AcpiOsWaitSemaphore (AcpiGbl_AcpiMutexInfo[MutexId].Mutex,
1, ACPI_WAIT_FOREVER);
if (ACPI_SUCCESS (Status))
{
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n",
ThisThreadId, AcpiUtGetMutexName (MutexId)));
AcpiGbl_AcpiMutexInfo[MutexId].UseCount++;
AcpiGbl_AcpiMutexInfo[MutexId].OwnerId = ThisThreadId;
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n",
ThisThreadId, AcpiUtGetMutexName (MutexId),
AcpiFormatException (Status)));
}
return (Status);
}
ACPI_STATUS
AcpiOsActualWaitSemaphore (
ACPI_HANDLE Handle,
UINT32 Units,
UINT16 Timeout)
{
#ifdef _MULTI_THREADED
UINT32 Index = (UINT32) Handle;
UINT32 WaitStatus;
UINT32 OsTimeout = Timeout;
ACPI_FUNCTION_ENTRY ();
if ((Index >= NUM_SEMAPHORES) ||
!AcpiGbl_Semaphores[Index].OsHandle)
{
return AE_BAD_PARAMETER;
}
if (Units > 1)
{
printf ("WaitSemaphore: Attempt to receive %d units\n", Units);
return AE_NOT_IMPLEMENTED;
}
/* TBD: Make this a command line option so that we can catch
* synchronization deadlocks
*
if (Timeout == INFINITE)
Timeout = 400000;
*/
if (Timeout == ACPI_WAIT_FOREVER)
{
OsTimeout = INFINITE;
}
else
{
/* Add 10ms to account for clock tick granularity */
OsTimeout += 10;
}
WaitStatus = WaitForSingleObject (AcpiGbl_Semaphores[Index].OsHandle, OsTimeout);
if (WaitStatus == WAIT_TIMEOUT)
{
/* Make optional -- wait of 0 is used to detect if unit is available
ACPI_ERROR ((AE_INFO, "Timeout on semaphore %d",
Handle));
*/
return AE_TIME;
}
if (AcpiGbl_Semaphores[Index].CurrentUnits == 0)
{
ACPI_ERROR ((AE_INFO, "%s - No unit received. Timeout %X, OSstatus 0x%X",
AcpiUtGetMutexName (Index), Timeout, WaitStatus));
return AE_OK;
}
AcpiGbl_Semaphores[Index].CurrentUnits--;
#endif
return AE_OK;
}
