| /****************************************************************************** |
| * |
| * Module Name: dsmethod - Parser/Interpreter interface - control method parsing |
| * |
| *****************************************************************************/ |
| |
| /* |
| * Copyright (C) 2000 - 2016, Intel Corp. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions, and the following disclaimer, |
| * without modification. |
| * 2. Redistributions in binary form must reproduce at minimum a disclaimer |
| * substantially similar to the "NO WARRANTY" disclaimer below |
| * ("Disclaimer") and any redistribution must be conditioned upon |
| * including a substantially similar Disclaimer requirement for further |
| * binary redistribution. |
| * 3. Neither the names of the above-listed copyright holders nor the names |
| * of any contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * Alternatively, this software may be distributed under the terms of the |
| * GNU General Public License ("GPL") version 2 as published by the Free |
| * Software Foundation. |
| * |
| * NO WARRANTY |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
| * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGES. |
| */ |
| |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "acdispat.h" |
| #include "acinterp.h" |
| #include "acnamesp.h" |
| #include "acparser.h" |
| #include "amlcode.h" |
| #include "acdebug.h" |
| |
| |
| #define _COMPONENT ACPI_DISPATCHER |
| ACPI_MODULE_NAME ("dsmethod") |
| |
| /* Local prototypes */ |
| |
| static ACPI_STATUS |
| AcpiDsDetectNamedOpcodes ( |
| ACPI_WALK_STATE *WalkState, |
| ACPI_PARSE_OBJECT **OutOp); |
| |
| static ACPI_STATUS |
| AcpiDsCreateMethodMutex ( |
| ACPI_OPERAND_OBJECT *MethodDesc); |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsAutoSerializeMethod |
| * |
| * PARAMETERS: Node - Namespace Node of the method |
| * ObjDesc - Method object attached to node |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Parse a control method AML to scan for control methods that |
| * need serialization due to the creation of named objects. |
| * |
| * NOTE: It is a bit of overkill to mark all such methods serialized, since |
| * there is only a problem if the method actually blocks during execution. |
| * A blocking operation is, for example, a Sleep() operation, or any access |
| * to an operation region. However, it is probably not possible to easily |
| * detect whether a method will block or not, so we simply mark all suspicious |
| * methods as serialized. |
| * |
| * NOTE2: This code is essentially a generic routine for parsing a single |
| * control method. |
| * |
| ******************************************************************************/ |
| |
| ACPI_STATUS |
| AcpiDsAutoSerializeMethod ( |
| ACPI_NAMESPACE_NODE *Node, |
| ACPI_OPERAND_OBJECT *ObjDesc) |
| { |
| ACPI_STATUS Status; |
| ACPI_PARSE_OBJECT *Op = NULL; |
| ACPI_WALK_STATE *WalkState; |
| |
| |
| ACPI_FUNCTION_TRACE_PTR (DsAutoSerializeMethod, Node); |
| |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, |
| "Method auto-serialization parse [%4.4s] %p\n", |
| AcpiUtGetNodeName (Node), Node)); |
| |
| /* Create/Init a root op for the method parse tree */ |
| |
| Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart); |
| if (!Op) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| |
| AcpiPsSetName (Op, Node->Name.Integer); |
| Op->Common.Node = Node; |
| |
| /* Create and initialize a new walk state */ |
| |
| WalkState = AcpiDsCreateWalkState (Node->OwnerId, NULL, NULL, NULL); |
| if (!WalkState) |
| { |
| AcpiPsFreeOp (Op); |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| |
| Status = AcpiDsInitAmlWalk (WalkState, Op, Node, |
| ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength, NULL, 0); |
| if (ACPI_FAILURE (Status)) |
| { |
| AcpiDsDeleteWalkState (WalkState); |
| AcpiPsFreeOp (Op); |
| return_ACPI_STATUS (Status); |
| } |
| |
| WalkState->DescendingCallback = AcpiDsDetectNamedOpcodes; |
| |
| /* Parse the method, scan for creation of named objects */ |
| |
| Status = AcpiPsParseAml (WalkState); |
| |
| AcpiPsDeleteParseTree (Op); |
| return_ACPI_STATUS (Status); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsDetectNamedOpcodes |
| * |
| * PARAMETERS: WalkState - Current state of the parse tree walk |
| * OutOp - Unused, required for parser interface |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Descending callback used during the loading of ACPI tables. |
| * Currently used to detect methods that must be marked serialized |
| * in order to avoid problems with the creation of named objects. |
| * |
| ******************************************************************************/ |
| |
| static ACPI_STATUS |
| AcpiDsDetectNamedOpcodes ( |
| ACPI_WALK_STATE *WalkState, |
| ACPI_PARSE_OBJECT **OutOp) |
| { |
| |
| ACPI_FUNCTION_NAME (AcpiDsDetectNamedOpcodes); |
| |
| |
| /* We are only interested in opcodes that create a new name */ |
| |
| if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_CREATE | AML_FIELD))) |
| { |
| return (AE_OK); |
| } |
| |
| /* |
| * At this point, we know we have a Named object opcode. |
| * Mark the method as serialized. Later code will create a mutex for |
| * this method to enforce serialization. |
| * |
| * Note, ACPI_METHOD_IGNORE_SYNC_LEVEL flag means that we will ignore the |
| * Sync Level mechanism for this method, even though it is now serialized. |
| * Otherwise, there can be conflicts with existing ASL code that actually |
| * uses sync levels. |
| */ |
| WalkState->MethodDesc->Method.SyncLevel = 0; |
| WalkState->MethodDesc->Method.InfoFlags |= |
| (ACPI_METHOD_SERIALIZED | ACPI_METHOD_IGNORE_SYNC_LEVEL); |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_INFO, |
| "Method serialized [%4.4s] %p - [%s] (%4.4X)\n", |
| WalkState->MethodNode->Name.Ascii, WalkState->MethodNode, |
| WalkState->OpInfo->Name, WalkState->Opcode)); |
| |
| /* Abort the parse, no need to examine this method any further */ |
| |
| return (AE_CTRL_TERMINATE); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsMethodError |
| * |
| * PARAMETERS: Status - Execution status |
| * WalkState - Current state |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Called on method error. Invoke the global exception handler if |
| * present, dump the method data if the debugger is configured |
| * |
| * Note: Allows the exception handler to change the status code |
| * |
| ******************************************************************************/ |
| |
| ACPI_STATUS |
| AcpiDsMethodError ( |
| ACPI_STATUS Status, |
| ACPI_WALK_STATE *WalkState) |
| { |
| UINT32 AmlOffset; |
| |
| |
| ACPI_FUNCTION_ENTRY (); |
| |
| |
| /* Ignore AE_OK and control exception codes */ |
| |
| if (ACPI_SUCCESS (Status) || |
| (Status & AE_CODE_CONTROL)) |
| { |
| return (Status); |
| } |
| |
| /* Invoke the global exception handler */ |
| |
| if (AcpiGbl_ExceptionHandler) |
| { |
| /* Exit the interpreter, allow handler to execute methods */ |
| |
| AcpiExExitInterpreter (); |
| |
| /* |
| * Handler can map the exception code to anything it wants, including |
| * AE_OK, in which case the executing method will not be aborted. |
| */ |
| AmlOffset = (UINT32) ACPI_PTR_DIFF (WalkState->Aml, |
| WalkState->ParserState.AmlStart); |
| |
| Status = AcpiGbl_ExceptionHandler (Status, |
| WalkState->MethodNode ? |
| WalkState->MethodNode->Name.Integer : 0, |
| WalkState->Opcode, AmlOffset, NULL); |
| AcpiExEnterInterpreter (); |
| } |
| |
| AcpiDsClearImplicitReturn (WalkState); |
| |
| if (ACPI_FAILURE (Status)) |
| { |
| AcpiDsDumpMethodStack (Status, WalkState, WalkState->Op); |
| |
| /* Display method locals/args if debugger is present */ |
| |
| #ifdef ACPI_DEBUGGER |
| AcpiDbDumpMethodInfo (Status, WalkState); |
| #endif |
| } |
| |
| return (Status); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsCreateMethodMutex |
| * |
| * PARAMETERS: ObjDesc - The method object |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Create a mutex object for a serialized control method |
| * |
| ******************************************************************************/ |
| |
| static ACPI_STATUS |
| AcpiDsCreateMethodMutex ( |
| ACPI_OPERAND_OBJECT *MethodDesc) |
| { |
| ACPI_OPERAND_OBJECT *MutexDesc; |
| ACPI_STATUS Status; |
| |
| |
| ACPI_FUNCTION_TRACE (DsCreateMethodMutex); |
| |
| |
| /* Create the new mutex object */ |
| |
| MutexDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX); |
| if (!MutexDesc) |
| { |
| return_ACPI_STATUS (AE_NO_MEMORY); |
| } |
| |
| /* Create the actual OS Mutex */ |
| |
| Status = AcpiOsCreateMutex (&MutexDesc->Mutex.OsMutex); |
| if (ACPI_FAILURE (Status)) |
| { |
| AcpiUtDeleteObjectDesc (MutexDesc); |
| return_ACPI_STATUS (Status); |
| } |
| |
| MutexDesc->Mutex.SyncLevel = MethodDesc->Method.SyncLevel; |
| MethodDesc->Method.Mutex = MutexDesc; |
| return_ACPI_STATUS (AE_OK); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsBeginMethodExecution |
| * |
| * PARAMETERS: MethodNode - Node of the method |
| * ObjDesc - The method object |
| * WalkState - current state, NULL if not yet executing |
| * a method. |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Prepare a method for execution. Parses the method if necessary, |
| * increments the thread count, and waits at the method semaphore |
| * for clearance to execute. |
| * |
| ******************************************************************************/ |
| |
| 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); |
| } |
| |
| AcpiExStartTraceMethod (MethodNode, ObjDesc, WalkState); |
| |
| /* 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. |
| * |
| * If the method was auto-serialized, we just ignore the sync level |
| * mechanism, because auto-serialization of methods can interfere |
| * with ASL code that actually uses sync levels. |
| * |
| * Top-level method invocation has no walk state at this point |
| */ |
| if (WalkState && |
| (!(ObjDesc->Method.InfoFlags & ACPI_METHOD_IGNORE_SYNC_LEVEL)) && |
| (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; |
| |
| /* |
| * Update the current SyncLevel only if this is not an auto- |
| * serialized method. In the auto case, we have to ignore |
| * the sync level for the method mutex (created for the |
| * auto-serialization) because we have no idea of what the |
| * sync level should be. Therefore, just ignore it. |
| */ |
| if (!(ObjDesc->Method.InfoFlags & |
| ACPI_METHOD_IGNORE_SYNC_LEVEL)) |
| { |
| 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); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsCallControlMethod |
| * |
| * PARAMETERS: Thread - Info for this thread |
| * ThisWalkState - Current walk state |
| * Op - Current Op to be walked |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Transfer execution to a called control method |
| * |
| ******************************************************************************/ |
| |
| ACPI_STATUS |
| AcpiDsCallControlMethod ( |
| ACPI_THREAD_STATE *Thread, |
| ACPI_WALK_STATE *ThisWalkState, |
| ACPI_PARSE_OBJECT *Op) |
| { |
| ACPI_STATUS Status; |
| ACPI_NAMESPACE_NODE *MethodNode; |
| ACPI_WALK_STATE *NextWalkState = NULL; |
| ACPI_OPERAND_OBJECT *ObjDesc; |
| ACPI_EVALUATE_INFO *Info; |
| UINT32 i; |
| |
| |
| ACPI_FUNCTION_TRACE_PTR (DsCallControlMethod, ThisWalkState); |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
| "Calling method %p, currentstate=%p\n", |
| ThisWalkState->PrevOp, ThisWalkState)); |
| |
| /* |
| * Get the namespace entry for the control method we are about to call |
| */ |
| MethodNode = ThisWalkState->MethodCallNode; |
| if (!MethodNode) |
| { |
| return_ACPI_STATUS (AE_NULL_ENTRY); |
| } |
| |
| ObjDesc = AcpiNsGetAttachedObject (MethodNode); |
| if (!ObjDesc) |
| { |
| return_ACPI_STATUS (AE_NULL_OBJECT); |
| } |
| |
| /* Init for new method, possibly wait on method mutex */ |
| |
| Status = AcpiDsBeginMethodExecution ( |
| MethodNode, ObjDesc, ThisWalkState); |
| if (ACPI_FAILURE (Status)) |
| { |
| return_ACPI_STATUS (Status); |
| } |
| |
| /* Begin method parse/execution. Create a new walk state */ |
| |
| NextWalkState = AcpiDsCreateWalkState ( |
| ObjDesc->Method.OwnerId, NULL, ObjDesc, Thread); |
| if (!NextWalkState) |
| { |
| Status = AE_NO_MEMORY; |
| goto Cleanup; |
| } |
| |
| /* |
| * The resolved arguments were put on the previous walk state's operand |
| * stack. Operands on the previous walk state stack always |
| * start at index 0. Also, null terminate the list of arguments |
| */ |
| ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL; |
| |
| /* |
| * Allocate and initialize the evaluation information block |
| * TBD: this is somewhat inefficient, should change interface to |
| * DsInitAmlWalk. For now, keeps this struct off the CPU stack |
| */ |
| Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO)); |
| if (!Info) |
| { |
| Status = AE_NO_MEMORY; |
| goto Cleanup; |
| } |
| |
| Info->Parameters = &ThisWalkState->Operands[0]; |
| |
| Status = AcpiDsInitAmlWalk (NextWalkState, NULL, MethodNode, |
| ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength, |
| Info, ACPI_IMODE_EXECUTE); |
| |
| ACPI_FREE (Info); |
| if (ACPI_FAILURE (Status)) |
| { |
| goto Cleanup; |
| } |
| |
| /* |
| * Delete the operands on the previous walkstate operand stack |
| * (they were copied to new objects) |
| */ |
| for (i = 0; i < ObjDesc->Method.ParamCount; i++) |
| { |
| AcpiUtRemoveReference (ThisWalkState->Operands [i]); |
| ThisWalkState->Operands [i] = NULL; |
| } |
| |
| /* Clear the operand stack */ |
| |
| ThisWalkState->NumOperands = 0; |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
| "**** Begin nested execution of [%4.4s] **** WalkState=%p\n", |
| MethodNode->Name.Ascii, NextWalkState)); |
| |
| /* Invoke an internal method if necessary */ |
| |
| if (ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY) |
| { |
| Status = ObjDesc->Method.Dispatch.Implementation (NextWalkState); |
| if (Status == AE_OK) |
| { |
| Status = AE_CTRL_TERMINATE; |
| } |
| } |
| |
| return_ACPI_STATUS (Status); |
| |
| |
| Cleanup: |
| |
| /* On error, we must terminate the method properly */ |
| |
| AcpiDsTerminateControlMethod (ObjDesc, NextWalkState); |
| AcpiDsDeleteWalkState (NextWalkState); |
| |
| return_ACPI_STATUS (Status); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsRestartControlMethod |
| * |
| * PARAMETERS: WalkState - State for preempted method (caller) |
| * ReturnDesc - Return value from the called method |
| * |
| * RETURN: Status |
| * |
| * DESCRIPTION: Restart a method that was preempted by another (nested) method |
| * invocation. Handle the return value (if any) from the callee. |
| * |
| ******************************************************************************/ |
| |
| ACPI_STATUS |
| AcpiDsRestartControlMethod ( |
| ACPI_WALK_STATE *WalkState, |
| ACPI_OPERAND_OBJECT *ReturnDesc) |
| { |
| ACPI_STATUS Status; |
| int SameAsImplicitReturn; |
| |
| |
| ACPI_FUNCTION_TRACE_PTR (DsRestartControlMethod, WalkState); |
| |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
| "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n", |
| AcpiUtGetNodeName (WalkState->MethodNode), |
| WalkState->MethodCallOp, ReturnDesc)); |
| |
| ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, |
| " ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n", |
| WalkState->ReturnUsed, |
| WalkState->Results, WalkState)); |
| |
| /* Did the called method return a value? */ |
| |
| if (ReturnDesc) |
| { |
| /* Is the implicit return object the same as the return desc? */ |
| |
| SameAsImplicitReturn = (WalkState->ImplicitReturnObj == ReturnDesc); |
| |
| /* Are we actually going to use the return value? */ |
| |
| if (WalkState->ReturnUsed) |
| { |
| /* Save the return value from the previous method */ |
| |
| Status = AcpiDsResultPush (ReturnDesc, WalkState); |
| if (ACPI_FAILURE (Status)) |
| { |
| AcpiUtRemoveReference (ReturnDesc); |
| return_ACPI_STATUS (Status); |
| } |
| |
| /* |
| * Save as THIS method's return value in case it is returned |
| * immediately to yet another method |
| */ |
| WalkState->ReturnDesc = ReturnDesc; |
| } |
| |
| /* |
| * The following code is the optional support for the so-called |
| * "implicit return". Some AML code assumes that the last value of the |
| * method is "implicitly" returned to the caller, in the absence of an |
| * explicit return value. |
| * |
| * Just save the last result of the method as the return value. |
| * |
| * NOTE: this is optional because the ASL language does not actually |
| * support this behavior. |
| */ |
| else if (!AcpiDsDoImplicitReturn (ReturnDesc, WalkState, FALSE) || |
| SameAsImplicitReturn) |
| { |
| /* |
| * Delete the return value if it will not be used by the |
| * calling method or remove one reference if the explicit return |
| * is the same as the implicit return value. |
| */ |
| AcpiUtRemoveReference (ReturnDesc); |
| } |
| } |
| |
| return_ACPI_STATUS (AE_OK); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDsTerminateControlMethod |
| * |
| * PARAMETERS: MethodDesc - Method object |
| * WalkState - State associated with the method |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Terminate a control method. Delete everything that the method |
| * created, delete all locals and arguments, and delete the parse |
| * tree if requested. |
| * |
| * MUTEX: Interpreter is locked |
| * |
| ******************************************************************************/ |
| |
| 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 | ACPI_METHOD_IGNORE_SYNC_LEVEL); |
| MethodDesc->Method.SyncLevel = 0; |
| } |
| |
| /* No more threads, we can free the OwnerId */ |
| |
| if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)) |
| { |
| AcpiUtReleaseOwnerId (&MethodDesc->Method.OwnerId); |
| } |
| } |
| |
| AcpiExStopTraceMethod ((ACPI_NAMESPACE_NODE *) MethodDesc->Method.Node, |
| MethodDesc, WalkState); |
| |
| return_VOID; |
| } |
