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); }