void
AcpiTerminateDebugger (
void)
{
/* Terminate the AML Debugger */
AcpiGbl_DbTerminateLoop = TRUE;
if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED)
{
AcpiOsReleaseMutex (AcpiGbl_DbCommandReady);
/* Wait the AML Debugger threads */
while (!AcpiGbl_DbThreadsTerminated)
{
AcpiOsSleep (100);
}
}
if (AcpiGbl_DbBuffer)
{
AcpiOsFree (AcpiGbl_DbBuffer);
AcpiGbl_DbBuffer = NULL;
}
/* Ensure that debug output is now disabled */
AcpiGbl_DbOutputFlags = ACPI_DB_DISABLE_OUTPUT;
}
void ACPI_SYSTEM_XFACE
AcpiDbExecuteThread (
void *Context)
{
ACPI_STATUS Status = AE_OK;
ACPI_STATUS MStatus;
while (Status != AE_CTRL_TERMINATE)
{
AcpiGbl_MethodExecuting = FALSE;
AcpiGbl_StepToNextCall = FALSE;
MStatus = AcpiOsAcquireMutex (AcpiGbl_DbCommandReady,
ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (MStatus))
{
return;
}
Status = AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, NULL, NULL);
AcpiOsReleaseMutex (AcpiGbl_DbCommandComplete);
}
}
ACPI_STATUS
AcpiUtInitializeInterfaces (
void)
{
ACPI_STATUS Status;
UINT32 i;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
AcpiGbl_SupportedInterfaces = AcpiDefaultSupportedInterfaces;
/* Link the static list of supported interfaces */
for (i = 0; i < (ACPI_ARRAY_LENGTH (AcpiDefaultSupportedInterfaces) - 1); i++)
{
AcpiDefaultSupportedInterfaces[i].Next =
&AcpiDefaultSupportedInterfaces[(ACPI_SIZE) i + 1];
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (AE_OK);
}
ACPI_STATUS
AcpiRemoveInterface (
ACPI_STRING InterfaceName)
{
ACPI_STATUS Status;
/* Parameter validation */
if (!InterfaceName || (strlen (InterfaceName) == 0))
{
return (AE_BAD_PARAMETER);
}
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
Status = AcpiUtRemoveInterface (InterfaceName);
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (Status);
}
ACPI_STATUS
AcpiInstallInterfaceHandler (
ACPI_INTERFACE_HANDLER Handler)
{
ACPI_STATUS Status;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
if (Handler && AcpiGbl_InterfaceHandler)
{
Status = AE_ALREADY_EXISTS;
}
else
{
AcpiGbl_InterfaceHandler = Handler;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (Status);
}
ACPI_STATUS
AcpiUtInterfaceTerminate (
void)
{
ACPI_STATUS Status;
ACPI_INTERFACE_INFO *NextInterface;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
NextInterface = AcpiGbl_SupportedInterfaces;
while (NextInterface)
{
AcpiGbl_SupportedInterfaces = NextInterface->Next;
/* Only interfaces added at runtime can be freed */
if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
{
ACPI_FREE (NextInterface->Name);
ACPI_FREE (NextInterface);
}
NextInterface = AcpiGbl_SupportedInterfaces;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (AE_OK);
}
void
AcpiUtReleaseWriteLock (
ACPI_RW_LOCK *Lock)
{
AcpiOsReleaseMutex (Lock->WriterMutex);
}
void
AcpiUtInterfaceTerminate (
void)
{
ACPI_INTERFACE_INFO *NextInterface;
(void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
NextInterface = AcpiGbl_SupportedInterfaces;
while (NextInterface)
{
AcpiGbl_SupportedInterfaces = NextInterface->Next;
/* Only interfaces added at runtime can be freed */
if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
{
ACPI_FREE (NextInterface->Name);
ACPI_FREE (NextInterface);
}
NextInterface = AcpiGbl_SupportedInterfaces;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
}
ACPI_STATUS
AcpiOsNotifyCommandComplete (
void)
{
if (AcpiGbl_DebuggerConfiguration == DEBUGGER_MULTI_THREADED)
{
AcpiOsReleaseMutex (AcpiGbl_DbCommandComplete);
}
return (AE_OK);
}
void
AcpiExReleaseAllMutexes (
ACPI_THREAD_STATE *Thread)
{
ACPI_OPERAND_OBJECT *Next = Thread->AcquiredMutexList;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_FUNCTION_TRACE (ExReleaseAllMutexes);
/* Traverse the list of owned mutexes, releasing each one */
while (Next)
{
ObjDesc = Next;
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Mutex [%4.4s] force-release, SyncLevel %u Depth %u\n",
ObjDesc->Mutex.Node->Name.Ascii, ObjDesc->Mutex.SyncLevel,
ObjDesc->Mutex.AcquisitionDepth));
/* Release the mutex, special case for Global Lock */
if (ObjDesc == AcpiGbl_GlobalLockMutex)
{
/* Ignore errors */
(void) AcpiEvReleaseGlobalLock ();
}
else
{
AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
}
/* Update Thread SyncLevel (Last mutex is the important one) */
Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;
/* Mark mutex unowned */
Next = ObjDesc->Mutex.Next;
ObjDesc->Mutex.Prev = NULL;
ObjDesc->Mutex.Next = NULL;
ObjDesc->Mutex.AcquisitionDepth = 0;
ObjDesc->Mutex.OwnerThread = NULL;
ObjDesc->Mutex.ThreadId = 0;
}
return_VOID;
}
ACPI_STATUS
AcpiInstallInterface (
ACPI_STRING InterfaceName)
{
ACPI_STATUS Status;
ACPI_INTERFACE_INFO *InterfaceInfo;
/* Parameter validation */
if (!InterfaceName || (strlen (InterfaceName) == 0))
{
return (AE_BAD_PARAMETER);
}
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Check if the interface name is already in the global list */
InterfaceInfo = AcpiUtGetInterface (InterfaceName);
if (InterfaceInfo)
{
/*
* The interface already exists in the list. This is OK if the
* interface has been marked invalid -- just clear the bit.
*/
if (InterfaceInfo->Flags & ACPI_OSI_INVALID)
{
InterfaceInfo->Flags &= ~ACPI_OSI_INVALID;
Status = AE_OK;
}
else
{
Status = AE_ALREADY_EXISTS;
}
}
else
{
/* New interface name, install into the global list */
Status = AcpiUtInstallInterface (InterfaceName);
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (Status);
}
ACPI_STATUS
AcpiExReleaseMutexObject (
ACPI_OPERAND_OBJECT *ObjDesc)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (ExReleaseMutexObject);
if (ObjDesc->Mutex.AcquisitionDepth == 0)
{
return_ACPI_STATUS (AE_NOT_ACQUIRED);
}
/* Match multiple Acquires with multiple Releases */
ObjDesc->Mutex.AcquisitionDepth--;
if (ObjDesc->Mutex.AcquisitionDepth != 0)
{
/* Just decrement the depth and return */
return_ACPI_STATUS (AE_OK);
}
if (ObjDesc->Mutex.OwnerThread)
{
/* Unlink the mutex from the owner's list */
AcpiExUnlinkMutex (ObjDesc);
ObjDesc->Mutex.OwnerThread = NULL;
}
/* Release the mutex, special case for Global Lock */
if (ObjDesc == AcpiGbl_GlobalLockMutex)
{
Status = AcpiEvReleaseGlobalLock ();
}
else
{
AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
}
/* Clear mutex info */
ObjDesc->Mutex.ThreadId = 0;
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiUtReleaseReadLock (
ACPI_RW_LOCK *Lock)
{
ACPI_STATUS Status;
Status = AcpiOsAcquireMutex (Lock->ReaderMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Release the write lock only for the very last reader */
Lock->NumReaders--;
if (Lock->NumReaders == 0)
{
AcpiOsReleaseMutex (Lock->WriterMutex);
}
AcpiOsReleaseMutex (Lock->ReaderMutex);
return (Status);
}
ACPI_STATUS
AcpiEvReleaseGlobalLock (
void)
{
BOOLEAN Pending = FALSE;
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (EvReleaseGlobalLock);
/* Lock must be already acquired */
if (!AcpiGbl_GlobalLockAcquired)
{
ACPI_WARNING ((AE_INFO,
"Cannot release the ACPI Global Lock, it has not been acquired"));
return_ACPI_STATUS (AE_NOT_ACQUIRED);
}
if (AcpiGbl_GlobalLockPresent)
{
/* Allow any thread to release the lock */
ACPI_RELEASE_GLOBAL_LOCK (AcpiGbl_FACS, Pending);
/*
* If the pending bit was set, we must write GBL_RLS to the control
* register
*/
if (Pending)
{
Status = AcpiWriteBitRegister (
ACPI_BITREG_GLOBAL_LOCK_RELEASE, ACPI_ENABLE_EVENT);
}
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Released hardware Global Lock\n"));
}
AcpiGbl_GlobalLockAcquired = FALSE;
/* Release the local GL mutex */
AcpiOsReleaseMutex (AcpiGbl_GlobalLockMutex->Mutex.OsMutex);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiUtInterfaceTerminate (
void)
{
ACPI_STATUS Status;
ACPI_INTERFACE_INFO *NextInterface;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
NextInterface = AcpiGbl_SupportedInterfaces;
while (NextInterface)
{
AcpiGbl_SupportedInterfaces = NextInterface->Next;
if (NextInterface->Flags & ACPI_OSI_DYNAMIC)
{
/* Only interfaces added at runtime can be freed */
ACPI_FREE (NextInterface->Name);
ACPI_FREE (NextInterface);
}
else
{
/* Interface is in static list. Reset it to invalid or valid. */
if (NextInterface->Flags & ACPI_OSI_DEFAULT_INVALID)
{
NextInterface->Flags |= ACPI_OSI_INVALID;
}
else
{
NextInterface->Flags &= ~ACPI_OSI_INVALID;
}
}
NextInterface = AcpiGbl_SupportedInterfaces;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (AE_OK);
}
void
AcpiExReleaseAllMutexes (
ACPI_THREAD_STATE *Thread)
{
ACPI_OPERAND_OBJECT *Next = Thread->AcquiredMutexList;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_FUNCTION_ENTRY ();
/* Traverse the list of owned mutexes, releasing each one */
while (Next)
{
ObjDesc = Next;
Next = ObjDesc->Mutex.Next;
ObjDesc->Mutex.Prev = NULL;
ObjDesc->Mutex.Next = NULL;
ObjDesc->Mutex.AcquisitionDepth = 0;
/* Release the mutex, special case for Global Lock */
if (ObjDesc == AcpiGbl_GlobalLockMutex)
{
/* Ignore errors */
(void) AcpiEvReleaseGlobalLock ();
}
else
{
AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
}
/* Mark mutex unowned */
ObjDesc->Mutex.OwnerThread = NULL;
ObjDesc->Mutex.ThreadId = 0;
/* Update Thread SyncLevel (Last mutex is the important one) */
Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;
}
}
ACPI_STATUS
AcpiUpdateInterfaces (
UINT8 Action)
{
ACPI_STATUS Status;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
Status = AcpiUtUpdateInterfaces (Action);
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return (Status);
}
ACPI_STATUS
AcpiReleaseMutex (
ACPI_HANDLE Handle,
ACPI_STRING Pathname)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT *MutexObj;
/* Get the low-level mutex associated with Handle:Pathname */
Status = AcpiUtGetMutexObject (Handle, Pathname, &MutexObj);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Release the OS mutex */
AcpiOsReleaseMutex (MutexObj->Mutex.OsMutex);
return (AE_OK);
}
static void
AcpiDbRunRemoteDebugger (
char *BatchBuffer)
{
ACPI_STATUS Status;
char *Ptr = BatchBuffer;
char *Cmd = Ptr;
while (!AcpiGbl_DbTerminateLoop)
{
if (BatchBuffer)
{
if (*Ptr)
{
while (*Ptr)
{
if (*Ptr == ',')
{
/* Convert commas to spaces */
*Ptr = ' ';
}
else if (*Ptr == ';')
{
*Ptr = '\0';
continue;
}
Ptr++;
}
strncpy (AcpiGbl_DbLineBuf, Cmd, ACPI_DB_LINE_BUFFER_SIZE);
Ptr++;
Cmd = Ptr;
}
else
{
return;
}
}
else
{
/* Force output to console until a command is entered */
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
/* Different prompt if method is executing */
if (!AcpiGbl_MethodExecuting)
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
}
else
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
}
/* Get the user input line */
Status = AcpiOsGetLine (AcpiGbl_DbLineBuf,
ACPI_DB_LINE_BUFFER_SIZE, NULL);
if (ACPI_FAILURE (Status))
{
return;
}
}
/*
* Signal the debug thread that we have a command to execute,
* and wait for the command to complete.
*/
AcpiOsReleaseMutex (AcpiGbl_DbCommandReady);
Status = AcpiOsAcquireMutex (AcpiGbl_DbCommandComplete,
ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return;
}
}
}
void
AcpiDbDisplayInterfaces (
char *ActionArg,
char *InterfaceNameArg)
{
ACPI_INTERFACE_INFO *NextInterface;
char *SubString;
ACPI_STATUS Status;
/* If no arguments, just display current interface list */
if (!ActionArg)
{
(void) AcpiOsAcquireMutex (AcpiGbl_OsiMutex,
ACPI_WAIT_FOREVER);
NextInterface = AcpiGbl_SupportedInterfaces;
while (NextInterface)
{
if (!(NextInterface->Flags & ACPI_OSI_INVALID))
{
AcpiOsPrintf ("%s\n", NextInterface->Name);
}
NextInterface = NextInterface->Next;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
return;
}
/* If ActionArg exists, so must InterfaceNameArg */
if (!InterfaceNameArg)
{
AcpiOsPrintf ("Missing Interface Name argument\n");
return;
}
/* Uppercase the action for match below */
AcpiUtStrupr (ActionArg);
/* Install - install an interface */
SubString = ACPI_STRSTR ("INSTALL", ActionArg);
if (SubString)
{
Status = AcpiInstallInterface (InterfaceNameArg);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, while installing \"%s\"\n",
AcpiFormatException (Status), InterfaceNameArg);
}
return;
}
/* Remove - remove an interface */
SubString = ACPI_STRSTR ("REMOVE", ActionArg);
if (SubString)
{
Status = AcpiRemoveInterface (InterfaceNameArg);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, while removing \"%s\"\n",
AcpiFormatException (Status), InterfaceNameArg);
}
return;
}
/* Invalid ActionArg */
AcpiOsPrintf ("Invalid action argument: %s\n", ActionArg);
return;
}
ACPI_STATUS
AcpiDsBeginMethodExecution (
ACPI_NAMESPACE_NODE *MethodNode,
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE_PTR (DsBeginMethodExecution, MethodNode);
if (!MethodNode)
{
return_ACPI_STATUS (AE_NULL_ENTRY);
}
/* Prevent wraparound of thread count */
if (ObjDesc->Method.ThreadCount == ACPI_UINT8_MAX)
{
ACPI_ERROR ((AE_INFO,
"Method reached maximum reentrancy limit (255)"));
return_ACPI_STATUS (AE_AML_METHOD_LIMIT);
}
/*
* If this method is serialized, we need to acquire the method mutex.
*/
if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)
{
/*
* Create a mutex for the method if it is defined to be Serialized
* and a mutex has not already been created. We defer the mutex creation
* until a method is actually executed, to minimize the object count
*/
if (!ObjDesc->Method.Mutex)
{
Status = AcpiDsCreateMethodMutex (ObjDesc);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* The CurrentSyncLevel (per-thread) must be less than or equal to
* the sync level of the method. This mechanism provides some
* deadlock prevention
*
* Top-level method invocation has no walk state at this point
*/
if (WalkState &&
(WalkState->Thread->CurrentSyncLevel > ObjDesc->Method.Mutex->Mutex.SyncLevel))
{
ACPI_ERROR ((AE_INFO,
"Cannot acquire Mutex for method [%4.4s], current SyncLevel is too large (%u)",
AcpiUtGetNodeName (MethodNode),
WalkState->Thread->CurrentSyncLevel));
return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
}
/*
* Obtain the method mutex if necessary. Do not acquire mutex for a
* recursive call.
*/
if (!WalkState ||
!ObjDesc->Method.Mutex->Mutex.ThreadId ||
(WalkState->Thread->ThreadId != ObjDesc->Method.Mutex->Mutex.ThreadId))
{
/*
* Acquire the method mutex. This releases the interpreter if we
* block (and reacquires it before it returns)
*/
Status = AcpiExSystemWaitMutex (ObjDesc->Method.Mutex->Mutex.OsMutex,
ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Update the mutex and walk info and save the original SyncLevel */
if (WalkState)
{
ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
WalkState->Thread->CurrentSyncLevel;
ObjDesc->Method.Mutex->Mutex.ThreadId = WalkState->Thread->ThreadId;
WalkState->Thread->CurrentSyncLevel = ObjDesc->Method.SyncLevel;
}
else
{
ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
ObjDesc->Method.Mutex->Mutex.SyncLevel;
}
}
/* Always increase acquisition depth */
ObjDesc->Method.Mutex->Mutex.AcquisitionDepth++;
}
/*
* Allocate an Owner ID for this method, only if this is the first thread
* to begin concurrent execution. We only need one OwnerId, even if the
* method is invoked recursively.
*/
if (!ObjDesc->Method.OwnerId)
{
Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
}
/*
* Increment the method parse tree thread count since it has been
* reentered one more time (even if it is the same thread)
*/
ObjDesc->Method.ThreadCount++;
AcpiMethodCount++;
return_ACPI_STATUS (Status);
Cleanup:
/* On error, must release the method mutex (if present) */
if (ObjDesc->Method.Mutex)
{
AcpiOsReleaseMutex (ObjDesc->Method.Mutex->Mutex.OsMutex);
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiDbUserCommands (
char Prompt,
ACPI_PARSE_OBJECT *Op)
{
ACPI_STATUS Status = AE_OK;
AcpiOsPrintf ("\n");
/* TBD: [Restructure] Need a separate command line buffer for step mode */
while (!AcpiGbl_DbTerminateThreads)
{
/* Force output to console until a command is entered */
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
/* Different prompt if method is executing */
if (!AcpiGbl_MethodExecuting)
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
}
else
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
}
/* Get the user input line */
Status = AcpiOsGetLine (AcpiGbl_DbLineBuf,
ACPI_DB_LINE_BUFFER_SIZE, NULL);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While parsing command line"));
return (Status);
}
/* Check for single or multithreaded debug */
if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED)
{
/*
* Signal the debug thread that we have a command to execute,
* and wait for the command to complete.
*/
AcpiOsReleaseMutex (AcpiGbl_DbCommandReady);
if (ACPI_FAILURE (Status))
{
return (Status);
}
Status = AcpiOsAcquireMutex (AcpiGbl_DbCommandComplete,
ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
else
{
/* Just call to the command line interpreter */
AcpiDbSingleThread ();
}
}
/* Shut down the debugger */
AcpiTerminateDebugger ();
/*
* Only this thread (the original thread) should actually terminate the
* subsystem, because all the semaphores are deleted during termination
*/
Status = AcpiTerminate ();
return (Status);
}
static ACPI_STATUS
AcpiDbStartCommand (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op)
{
ACPI_STATUS Status;
/* TBD: [Investigate] are there namespace locking issues here? */
/* AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); */
/* Go into the command loop and await next user command */
AcpiGbl_MethodExecuting = TRUE;
Status = AE_CTRL_TRUE;
while (Status == AE_CTRL_TRUE)
{
if (AcpiGbl_DebuggerConfiguration == DEBUGGER_MULTI_THREADED)
{
/* Handshake with the front-end that gets user command lines */
AcpiOsReleaseMutex (AcpiGbl_DbCommandComplete);
Status = AcpiOsAcquireMutex (AcpiGbl_DbCommandReady,
ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
else
{
/* Single threaded, we must get a command line ourselves */
/* Force output to console until a command is entered */
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
/* Different prompt if method is executing */
if (!AcpiGbl_MethodExecuting)
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
}
else
{
AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
}
/* Get the user input line */
Status = AcpiOsGetLine (AcpiGbl_DbLineBuf,
ACPI_DB_LINE_BUFFER_SIZE, NULL);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"While parsing command line"));
return (Status);
}
}
Status = AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, WalkState, Op);
}
/* AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); */
return (Status);
}
ACPI_STATUS
AcpiUtOsiImplementation (
ACPI_WALK_STATE *WalkState)
{
ACPI_OPERAND_OBJECT *StringDesc;
ACPI_OPERAND_OBJECT *ReturnDesc;
ACPI_INTERFACE_INFO *InterfaceInfo;
ACPI_INTERFACE_HANDLER InterfaceHandler;
ACPI_STATUS Status;
UINT32 ReturnValue;
ACPI_FUNCTION_TRACE (UtOsiImplementation);
/* Validate the string input argument (from the AML caller) */
StringDesc = WalkState->Arguments[0].Object;
if (!StringDesc ||
(StringDesc->Common.Type != ACPI_TYPE_STRING))
{
return_ACPI_STATUS (AE_TYPE);
}
/* Create a return object */
ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
if (!ReturnDesc)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Default return value is 0, NOT SUPPORTED */
ReturnValue = 0;
Status = AcpiOsAcquireMutex (AcpiGbl_OsiMutex, ACPI_WAIT_FOREVER);
if (ACPI_FAILURE (Status))
{
AcpiUtRemoveReference (ReturnDesc);
return_ACPI_STATUS (Status);
}
/* Lookup the interface in the global _OSI list */
InterfaceInfo = AcpiUtGetInterface (StringDesc->String.Pointer);
if (InterfaceInfo &&
!(InterfaceInfo->Flags & ACPI_OSI_INVALID))
{
/*
* The interface is supported.
* Update the OsiData if necessary. We keep track of the latest
* version of Windows that has been requested by the BIOS.
*/
if (InterfaceInfo->Value > AcpiGbl_OsiData)
{
AcpiGbl_OsiData = InterfaceInfo->Value;
}
ReturnValue = ACPI_UINT32_MAX;
}
AcpiOsReleaseMutex (AcpiGbl_OsiMutex);
/*
* Invoke an optional _OSI interface handler. The host OS may wish
* to do some interface-specific handling. For example, warn about
* certain interfaces or override the true/false support value.
*/
InterfaceHandler = AcpiGbl_InterfaceHandler;
if (InterfaceHandler)
{
ReturnValue = InterfaceHandler (
StringDesc->String.Pointer, ReturnValue);
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
"ACPI: BIOS _OSI(\"%s\") is %ssupported\n",
StringDesc->String.Pointer, ReturnValue == 0 ? "not " : ""));
/* Complete the return object */
ReturnDesc->Integer.Value = ReturnValue;
WalkState->ReturnDesc = ReturnDesc;
return_ACPI_STATUS (AE_OK);
}
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);
}
void
AcpiDsTerminateControlMethod (
ACPI_OPERAND_OBJECT *MethodDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_FUNCTION_TRACE_PTR (DsTerminateControlMethod, WalkState);
/* MethodDesc is required, WalkState is optional */
if (!MethodDesc)
{
return_VOID;
}
if (WalkState)
{
/* Delete all arguments and locals */
AcpiDsMethodDataDeleteAll (WalkState);
/*
* If method is serialized, release the mutex and restore the
* current sync level for this thread
*/
if (MethodDesc->Method.Mutex)
{
/* Acquisition Depth handles recursive calls */
MethodDesc->Method.Mutex->Mutex.AcquisitionDepth--;
if (!MethodDesc->Method.Mutex->Mutex.AcquisitionDepth)
{
WalkState->Thread->CurrentSyncLevel =
MethodDesc->Method.Mutex->Mutex.OriginalSyncLevel;
AcpiOsReleaseMutex (MethodDesc->Method.Mutex->Mutex.OsMutex);
MethodDesc->Method.Mutex->Mutex.ThreadId = 0;
}
}
/*
* Delete any namespace objects created anywhere within the
* namespace by the execution of this method. Unless:
* 1) This method is a module-level executable code method, in which
* case we want make the objects permanent.
* 2) There are other threads executing the method, in which case we
* will wait until the last thread has completed.
*/
if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL) &&
(MethodDesc->Method.ThreadCount == 1))
{
/* Delete any direct children of (created by) this method */
AcpiNsDeleteNamespaceSubtree (WalkState->MethodNode);
/*
* Delete any objects that were created by this method
* elsewhere in the namespace (if any were created).
* Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
* deletion such that we don't have to perform an entire
* namespace walk for every control method execution.
*/
if (MethodDesc->Method.InfoFlags & ACPI_METHOD_MODIFIED_NAMESPACE)
{
AcpiNsDeleteNamespaceByOwner (MethodDesc->Method.OwnerId);
MethodDesc->Method.InfoFlags &= ~ACPI_METHOD_MODIFIED_NAMESPACE;
}
}
}
/* Decrement the thread count on the method */
if (MethodDesc->Method.ThreadCount)
{
MethodDesc->Method.ThreadCount--;
}
else
{
ACPI_ERROR ((AE_INFO,
"Invalid zero thread count in method"));
}
/* Are there any other threads currently executing this method? */
if (MethodDesc->Method.ThreadCount)
{
/*
* Additional threads. Do not release the OwnerId in this case,
* we immediately reuse it for the next thread executing this method
*/
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"*** Completed execution of one thread, %u threads remaining\n",
MethodDesc->Method.ThreadCount));
}
else
{
/* This is the only executing thread for this method */
/*
* Support to dynamically change a method from NotSerialized to
* Serialized if it appears that the method is incorrectly written and
* does not support multiple thread execution. The best example of this
* is if such a method creates namespace objects and blocks. A second
* thread will fail with an AE_ALREADY_EXISTS exception.
*
* This code is here because we must wait until the last thread exits
* before marking the method as serialized.
*/
if (MethodDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED_PENDING)
{
if (WalkState)
{
ACPI_INFO ((AE_INFO,
"Marking method %4.4s as Serialized because of AE_ALREADY_EXISTS error",
WalkState->MethodNode->Name.Ascii));
}
/*
* Method tried to create an object twice and was marked as
* "pending serialized". The probable cause is that the method
* cannot handle reentrancy.
*
* The method was created as NotSerialized, but it tried to create
* a named object and then blocked, causing the second thread
* entrance to begin and then fail. Workaround this problem by
* marking the method permanently as Serialized when the last
* thread exits here.
*/
MethodDesc->Method.InfoFlags &= ~ACPI_METHOD_SERIALIZED_PENDING;
MethodDesc->Method.InfoFlags |= ACPI_METHOD_SERIALIZED;
MethodDesc->Method.SyncLevel = 0;
}
/* No more threads, we can free the OwnerId */
if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL))
{
AcpiUtReleaseOwnerId (&MethodDesc->Method.OwnerId);
}
}
return_VOID;
}
ACPI_STATUS
AcpiExReleaseMutex (
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (ExReleaseMutex);
if (!ObjDesc)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* The mutex must have been previously acquired in order to release it */
if (!ObjDesc->Mutex.OwnerThread)
{
ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], not acquired",
AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);
}
/* Sanity check: we must have a valid thread ID */
if (!WalkState->Thread)
{
ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], null thread info",
AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
/*
* The Mutex is owned, but this thread must be the owner.
* Special case for Global Lock, any thread can release
*/
if ((ObjDesc->Mutex.OwnerThread->ThreadId != WalkState->Thread->ThreadId) &&
(ObjDesc->Mutex.OsMutex != AcpiGbl_GlobalLockMutex))
{
ACPI_ERROR ((AE_INFO,
"Thread %X cannot release Mutex [%4.4s] acquired by thread %X",
WalkState->Thread->ThreadId,
AcpiUtGetNodeName (ObjDesc->Mutex.Node),
ObjDesc->Mutex.OwnerThread->ThreadId));
return_ACPI_STATUS (AE_AML_NOT_OWNER);
}
/*
* The sync level of the mutex must be less than or equal to the current
* sync level
*/
if (ObjDesc->Mutex.SyncLevel > WalkState->Thread->CurrentSyncLevel)
{
ACPI_ERROR ((AE_INFO,
"Cannot release Mutex [%4.4s], incorrect SyncLevel",
AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
}
/* Match multiple Acquires with multiple Releases */
ObjDesc->Mutex.AcquisitionDepth--;
if (ObjDesc->Mutex.AcquisitionDepth != 0)
{
/* Just decrement the depth and return */
return_ACPI_STATUS (AE_OK);
}
/* Unlink the mutex from the owner's list */
AcpiExUnlinkMutex (ObjDesc);
/* Release the mutex, special case for Global Lock */
if (ObjDesc->Mutex.OsMutex == AcpiGbl_GlobalLockMutex)
{
Status = AcpiEvReleaseGlobalLock ();
}
else
{
AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
}
/* Update the mutex and restore SyncLevel */
ObjDesc->Mutex.OwnerThread = NULL;
WalkState->Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;
return_ACPI_STATUS (Status);
}