void
AcpiNsReportMethodError (
const char *ModuleName,
UINT32 LineNumber,
const char *Message,
ACPI_NAMESPACE_NODE *PrefixNode,
const char *Path,
ACPI_STATUS MethodStatus)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node = PrefixNode;
AcpiOsPrintf ("ACPI Error (%s-%04d): ", ModuleName, LineNumber);
if (Path)
{
Status = AcpiNsGetNode (PrefixNode, Path, ACPI_NS_NO_UPSEARCH,
&Node);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("[Could not get node by pathname]");
}
}
AcpiNsPrintNodePathname (Node, Message);
AcpiOsPrintf (", %s\n", AcpiFormatException (MethodStatus));
}
void
AcpiUtMethodError (
const char *ModuleName,
UINT32 LineNumber,
const char *Message,
ACPI_NAMESPACE_NODE *PrefixNode,
const char *Path,
ACPI_STATUS MethodStatus)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node = PrefixNode;
ACPI_MSG_REDIRECT_BEGIN;
AcpiOsPrintf (ACPI_MSG_ERROR);
if (Path)
{
Status = AcpiNsGetNode (PrefixNode, Path,
ACPI_NS_NO_UPSEARCH, &Node);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("[Could not get node by pathname]");
}
}
AcpiNsPrintNodePathname (Node, Message);
AcpiOsPrintf (", %s", AcpiFormatException (MethodStatus));
ACPI_MSG_SUFFIX;
ACPI_MSG_REDIRECT_END;
}
static ACPI_STATUS
AcpiDbExecutionWalk (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
ACPI_BUFFER ReturnObj;
ACPI_STATUS Status;
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc->Method.ParamCount)
{
return (AE_OK);
}
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
AcpiNsPrintNodePathname (Node, "Evaluating");
/* Do the actual method execution */
AcpiOsPrintf ("\n");
AcpiGbl_MethodExecuting = TRUE;
Status = AcpiEvaluateObject (Node, NULL, NULL, &ReturnObj);
AcpiOsPrintf ("Evaluation of [%4.4s] returned %s\n",
AcpiUtGetNodeName (Node),
AcpiFormatException (Status));
AcpiGbl_MethodExecuting = FALSE;
return (AE_OK);
}
void
AcpiNsDumpPathname (
ACPI_HANDLE Handle,
const char *Msg,
UINT32 Level,
UINT32 Component)
{
ACPI_FUNCTION_TRACE (NsDumpPathname);
/* Do this only if the requested debug level and component are enabled */
if (!ACPI_IS_DEBUG_ENABLED (Level, Component))
{
return_VOID;
}
/* Convert handle to a full pathname and print it (with supplied message) */
AcpiNsPrintNodePathname (Handle, Msg);
AcpiOsPrintf ("\n");
return_VOID;
}
void
AcpiDmDumpMethodInfo (
ACPI_STATUS Status,
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *Next;
ACPI_THREAD_STATE *Thread;
ACPI_WALK_STATE *NextWalkState;
ACPI_NAMESPACE_NODE *PreviousMethod = NULL;
/* Ignore control codes, they are not errors */
if ((Status & AE_CODE_MASK) == AE_CODE_CONTROL)
{
return;
}
/* We may be executing a deferred opcode */
if (WalkState->DeferredNode)
{
AcpiOsPrintf ("Executing subtree for Buffer/Package/Region\n");
return;
}
/*
* If there is no Thread, we are not actually executing a method.
* This can happen when the iASL compiler calls the interpreter
* to perform constant folding.
*/
Thread = WalkState->Thread;
if (!Thread)
{
return;
}
/* Display exception and method name */
AcpiOsPrintf ("\n**** Exception %s during execution of method ",
AcpiFormatException (Status));
AcpiNsPrintNodePathname (WalkState->MethodNode, NULL);
/* Display stack of executing methods */
AcpiOsPrintf ("\n\nMethod Execution Stack:\n");
NextWalkState = Thread->WalkStateList;
/* Walk list of linked walk states */
while (NextWalkState)
{
AcpiOsPrintf (" Method [%4.4s] executing: ",
AcpiUtGetNodeName (NextWalkState->MethodNode));
/* First method is the currently executing method */
if (NextWalkState == WalkState)
{
if (Op)
{
/* Display currently executing ASL statement */
Next = Op->Common.Next;
Op->Common.Next = NULL;
AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);
Op->Common.Next = Next;
}
}
else
{
/*
* This method has called another method
* NOTE: the method call parse subtree is already deleted at this
* point, so we cannot disassemble the method invocation.
*/
AcpiOsPrintf ("Call to method ");
AcpiNsPrintNodePathname (PreviousMethod, NULL);
}
PreviousMethod = NextWalkState->MethodNode;
NextWalkState = NextWalkState->Next;
AcpiOsPrintf ("\n");
}
/* Display the method locals and arguments */
AcpiOsPrintf ("\n");
AcpiDmDisplayLocals (WalkState);
AcpiOsPrintf ("\n");
AcpiDmDisplayArguments (WalkState);
AcpiOsPrintf ("\n");
}
void
AcpiDmDumpMethodInfo (
ACPI_STATUS Status,
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *Next;
ACPI_THREAD_STATE *Thread;
ACPI_WALK_STATE *NextWalkState;
ACPI_NAMESPACE_NODE *PreviousMethod = NULL;
/* Ignore control codes, they are not errors */
if ((Status & AE_CODE_MASK) == AE_CODE_CONTROL)
{
return;
}
/* Display exception and method name */
AcpiOsPrintf ("\n**** Exception %s during execution of method ",
AcpiFormatException (Status));
AcpiNsPrintNodePathname (WalkState->MethodNode, NULL);
/* Display stack of executing methods */
AcpiOsPrintf ("\n\nMethod Execution Stack:\n");
Thread = WalkState->Thread;
NextWalkState = Thread->WalkStateList;
/* Walk list of linked walk states */
while (NextWalkState)
{
AcpiOsPrintf (" Method [%4.4s] executing: ",
NextWalkState->MethodNode->Name.Ascii);
/* First method is the currently executing method */
if (NextWalkState == WalkState)
{
/* Display currently executing ASL statement */
Next = Op->Common.Next;
Op->Common.Next = NULL;
AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);
Op->Common.Next = Next;
}
else
{
/*
* This method has called another method
* NOTE: the method call parse subtree is already deleted at this
* point, so we cannot disassemble the method invocation.
*/
AcpiOsPrintf ("Call to method ");
AcpiNsPrintNodePathname (PreviousMethod, NULL);
}
PreviousMethod = NextWalkState->MethodNode;
NextWalkState = NextWalkState->Next;
AcpiOsPrintf ("\n");
}
/* Display the method locals and arguments */
AcpiOsPrintf ("\n");
AcpiDmDisplayLocals (WalkState);
AcpiOsPrintf ("\n");
AcpiDmDisplayArguments (WalkState);
AcpiOsPrintf ("\n");
}
ACPI_STATUS
AcpiPsParseAml (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_THREAD_STATE *Thread;
ACPI_THREAD_STATE *PrevWalkList = AcpiGbl_CurrentWalkList;
ACPI_WALK_STATE *PreviousWalkState;
ACPI_FUNCTION_TRACE (PsParseAml);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Entered with WalkState=%p Aml=%p size=%X\n",
WalkState, WalkState->ParserState.Aml,
WalkState->ParserState.AmlSize));
if (!WalkState->ParserState.Aml)
{
return_ACPI_STATUS (AE_BAD_ADDRESS);
}
/* Create and initialize a new thread state */
Thread = AcpiUtCreateThreadState ();
if (!Thread)
{
if (WalkState->MethodDesc)
{
/* Executing a control method - additional cleanup */
AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
}
AcpiDsDeleteWalkState (WalkState);
return_ACPI_STATUS (AE_NO_MEMORY);
}
WalkState->Thread = Thread;
/*
* If executing a method, the starting SyncLevel is this method's
* SyncLevel
*/
if (WalkState->MethodDesc)
{
WalkState->Thread->CurrentSyncLevel =
WalkState->MethodDesc->Method.SyncLevel;
}
AcpiDsPushWalkState (WalkState, Thread);
/*
* This global allows the AML debugger to get a handle to the currently
* executing control method.
*/
AcpiGbl_CurrentWalkList = Thread;
/*
* Execute the walk loop as long as there is a valid Walk State. This
* handles nested control method invocations without recursion.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p\n", WalkState));
Status = AE_OK;
while (WalkState)
{
if (ACPI_SUCCESS (Status))
{
/*
* The ParseLoop executes AML until the method terminates
* or calls another method.
*/
Status = AcpiPsParseLoop (WalkState);
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Completed one call to walk loop, %s State=%p\n",
AcpiFormatException (Status), WalkState));
if (Status == AE_CTRL_TRANSFER)
{
/*
* A method call was detected.
* Transfer control to the called control method
*/
Status = AcpiDsCallControlMethod (Thread, WalkState, NULL);
if (ACPI_FAILURE (Status))
{
Status = AcpiDsMethodError (Status, WalkState);
}
/*
* If the transfer to the new method method call worked
*, a new walk state was created -- get it
*/
WalkState = AcpiDsGetCurrentWalkState (Thread);
continue;
}
else if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
}
else if ((Status != AE_OK) && (WalkState->MethodDesc))
{
/* Either the method parse or actual execution failed */
AcpiExExitInterpreter ();
if (Status == AE_ABORT_METHOD)
{
AcpiNsPrintNodePathname (
WalkState->MethodNode, "Method aborted:");
AcpiOsPrintf ("\n");
}
else
{
ACPI_ERROR_METHOD ("Method parse/execution failed",
WalkState->MethodNode, NULL, Status);
}
AcpiExEnterInterpreter ();
/* Check for possible multi-thread reentrancy problem */
if ((Status == AE_ALREADY_EXISTS) &&
(!(WalkState->MethodDesc->Method.InfoFlags &
ACPI_METHOD_SERIALIZED)))
{
/*
* Method is not serialized and tried to create an object
* twice. The probable cause is that the method cannot
* handle reentrancy. Mark as "pending serialized" now, and
* then mark "serialized" when the last thread exits.
*/
WalkState->MethodDesc->Method.InfoFlags |=
ACPI_METHOD_SERIALIZED_PENDING;
}
}
/* We are done with this walk, move on to the parent if any */
WalkState = AcpiDsPopWalkState (Thread);
/* Reset the current scope to the beginning of scope stack */
AcpiDsScopeStackClear (WalkState);
/*
* If we just returned from the execution of a control method or if we
* encountered an error during the method parse phase, there's lots of
* cleanup to do
*/
if (((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
ACPI_PARSE_EXECUTE &&
!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) ||
(ACPI_FAILURE (Status)))
{
AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
}
/* Delete this walk state and all linked control states */
AcpiPsCleanupScope (&WalkState->ParserState);
PreviousWalkState = WalkState;
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"ReturnValue=%p, ImplicitValue=%p State=%p\n",
WalkState->ReturnDesc, WalkState->ImplicitReturnObj, WalkState));
/* Check if we have restarted a preempted walk */
WalkState = AcpiDsGetCurrentWalkState (Thread);
if (WalkState)
{
if (ACPI_SUCCESS (Status))
{
/*
* There is another walk state, restart it.
* If the method return value is not used by the parent,
* The object is deleted
*/
if (!PreviousWalkState->ReturnDesc)
{
/*
* In slack mode execution, if there is no return value
* we should implicitly return zero (0) as a default value.
*/
if (AcpiGbl_EnableInterpreterSlack &&
!PreviousWalkState->ImplicitReturnObj)
{
PreviousWalkState->ImplicitReturnObj =
AcpiUtCreateIntegerObject ((UINT64) 0);
if (!PreviousWalkState->ImplicitReturnObj)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
/* Restart the calling control method */
Status = AcpiDsRestartControlMethod (WalkState,
PreviousWalkState->ImplicitReturnObj);
}
else
{
/*
* We have a valid return value, delete any implicit
* return value.
*/
AcpiDsClearImplicitReturn (PreviousWalkState);
Status = AcpiDsRestartControlMethod (WalkState,
PreviousWalkState->ReturnDesc);
}
if (ACPI_SUCCESS (Status))
{
WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;
}
}
else
{
/* On error, delete any return object or implicit return */
AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
AcpiDsClearImplicitReturn (PreviousWalkState);
}
}
/*
* Just completed a 1st-level method, save the final internal return
* value (if any)
*/
else if (PreviousWalkState->CallerReturnDesc)
{
if (PreviousWalkState->ImplicitReturnObj)
{
*(PreviousWalkState->CallerReturnDesc) =
PreviousWalkState->ImplicitReturnObj;
}
else
{
/* NULL if no return value */
*(PreviousWalkState->CallerReturnDesc) =
PreviousWalkState->ReturnDesc;
}
}
else
{
if (PreviousWalkState->ReturnDesc)
{
/* Caller doesn't want it, must delete it */
AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
}
if (PreviousWalkState->ImplicitReturnObj)
{
/* Caller doesn't want it, must delete it */
AcpiUtRemoveReference (PreviousWalkState->ImplicitReturnObj);
}
}
AcpiDsDeleteWalkState (PreviousWalkState);
}
/* Normal exit */
AcpiExReleaseAllMutexes (Thread);
AcpiUtDeleteGenericState (ACPI_CAST_PTR (ACPI_GENERIC_STATE, Thread));
AcpiGbl_CurrentWalkList = PrevWalkList;
return_ACPI_STATUS (Status);
}