自学教程：C++ AcpiOsReleaseMutex函数代码示例

voidAcpiTerminateDebugger (    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_XFACEAcpiDbExecuteThread (    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_STATUSAcpiUtInitializeInterfaces (    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_STATUSAcpiRemoveInterface (    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_STATUSAcpiInstallInterfaceHandler (    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_STATUSAcpiUtInterfaceTerminate (    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);}

voidAcpiUtInterfaceTerminate (    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_STATUSAcpiOsNotifyCommandComplete (    void){    if (AcpiGbl_DebuggerConfiguration == DEBUGGER_MULTI_THREADED)    {        AcpiOsReleaseMutex (AcpiGbl_DbCommandComplete);    }    return (AE_OK);}

voidAcpiExReleaseAllMutexes (    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_STATUSAcpiInstallInterface (    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_STATUSAcpiExReleaseMutexObject (    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_STATUSAcpiEvReleaseGlobalLock (    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_STATUSAcpiUtInterfaceTerminate (    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);}

voidAcpiExReleaseAllMutexes (    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_STATUSAcpiUpdateInterfaces (    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_STATUSAcpiReleaseMutex (    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 voidAcpiDbRunRemoteDebugger (    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;        }    }}

voidAcpiDbDisplayInterfaces (    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;}

//.........这里部分代码省略.........        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_STATUSAcpiDbUserCommands (    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_STATUSAcpiDbStartCommand (    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_STATUSAcpiUtOsiImplementation (    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_STATUSAcpiUtReleaseMutex (    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);}

voidAcpiDsTerminateControlMethod (    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 */        /*//.........这里部分代码省略.........

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