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

/******************************************************************************* * * FUNCTION:    acpi_evaluate_object * * PARAMETERS:  handle              - Object handle (optional) *              pathname            - Object pathname (optional) *              external_params     - List of parameters to pass to method, *                                    terminated by NULL. May be NULL *                                    if no parameters are being passed. *              return_buffer       - Where to put method's return value (if *                                    any). If NULL, no value is returned. * * RETURN:      Status * * DESCRIPTION: Find and evaluate the given object, passing the given *              parameters if necessary. One of "Handle" or "Pathname" must *              be valid (non-null) * ******************************************************************************/acpi_statusacpi_evaluate_object(acpi_handle handle,		     acpi_string pathname,		     struct acpi_object_list *external_params,		     struct acpi_buffer *return_buffer){	acpi_status status;	struct acpi_evaluate_info *info;	acpi_size buffer_space_needed;	u32 i;	ACPI_FUNCTION_TRACE(acpi_evaluate_object);	/* Allocate and initialize the evaluation information block */	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));	if (!info) {		return_ACPI_STATUS(AE_NO_MEMORY);	}	/* Convert and validate the device handle */	info->prefix_node = acpi_ns_validate_handle(handle);	if (!info->prefix_node) {		status = AE_BAD_PARAMETER;		goto cleanup;	}	/*	 * Get the actual namespace node for the target object.	 * Handles these cases:	 *	 * 1) Null node, valid pathname from root (absolute path)	 * 2) Node and valid pathname (path relative to Node)	 * 3) Node, Null pathname	 */	if ((pathname) && (ACPI_IS_ROOT_PREFIX(pathname[0]))) {		/* The path is fully qualified, just evaluate by name */		info->prefix_node = NULL;	} else if (!handle) {		/*		 * A handle is optional iff a fully qualified pathname is specified.		 * Since we've already handled fully qualified names above, this is		 * an error.		 */		if (!pathname) {			ACPI_DEBUG_PRINT((ACPI_DB_INFO,					  "Both Handle and Pathname are NULL"));		} else {			ACPI_DEBUG_PRINT((ACPI_DB_INFO,					  "Null Handle with relative pathname [%s]",					  pathname));		}		status = AE_BAD_PARAMETER;		goto cleanup;	}	info->relative_pathname = pathname;	/*	 * Convert all external objects passed as arguments to the	 * internal version(s).	 */	if (external_params && external_params->count) {		info->param_count = (u16)external_params->count;		/* Warn on impossible argument count */		if (info->param_count > ACPI_METHOD_NUM_ARGS) {			ACPI_WARN_PREDEFINED((AE_INFO, pathname,					      ACPI_WARN_ALWAYS,					      "Excess arguments (%u) - using only %u",					      info->param_count,					      ACPI_METHOD_NUM_ARGS));			info->param_count = ACPI_METHOD_NUM_ARGS;		}//.........这里部分代码省略.........

acpi_statusacpi_ex_insert_into_field(union acpi_operand_object *obj_desc,			  void *buffer, u32 buffer_length){	void *new_buffer;	acpi_status status;	u64 mask;	u64 width_mask;	u64 merged_datum;	u64 raw_datum = 0;	u32 field_offset = 0;	u32 buffer_offset = 0;	u32 buffer_tail_bits;	u32 datum_count;	u32 field_datum_count;	u32 access_bit_width;	u32 required_length;	u32 i;	ACPI_FUNCTION_TRACE(ex_insert_into_field);	/* Validate input buffer */	new_buffer = NULL;	required_length =	    ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length);	/*	 * We must have a buffer that is at least as long as the field	 * we are writing to.  This is because individual fields are	 * indivisible and partial writes are not supported -- as per	 * the ACPI specification.	 */	if (buffer_length < required_length) {		/* We need to create a new buffer */		new_buffer = ACPI_ALLOCATE_ZEROED(required_length);		if (!new_buffer) {			return_ACPI_STATUS(AE_NO_MEMORY);		}		/*		 * Copy the original data to the new buffer, starting		 * at Byte zero.  All unused (upper) bytes of the		 * buffer will be 0.		 */		ACPI_MEMCPY((char *)new_buffer, (char *)buffer, buffer_length);		buffer = new_buffer;		buffer_length = required_length;	}/* TBD: Move to common setup code */	/* Algo is limited to sizeof(u64), so cut the access_byte_width */	if (obj_desc->common_field.access_byte_width > sizeof(u64)) {		obj_desc->common_field.access_byte_width = sizeof(u64);	}	access_bit_width = ACPI_MUL_8(obj_desc->common_field.access_byte_width);	/*	 * Create the bitmasks used for bit insertion.	 * Note: This if/else is used to bypass compiler differences with the	 * shift operator	 */	if (access_bit_width == ACPI_INTEGER_BIT_SIZE) {		width_mask = ACPI_UINT64_MAX;	} else {		width_mask = ACPI_MASK_BITS_ABOVE(access_bit_width);	}	mask = width_mask &	    ACPI_MASK_BITS_BELOW(obj_desc->common_field.start_field_bit_offset);	/* Compute the number of datums (access width data items) */	datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length,				       access_bit_width);	field_datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length +					     obj_desc->common_field.					     start_field_bit_offset,					     access_bit_width);	/* Get initial Datum from the input buffer */	ACPI_MEMCPY(&raw_datum, buffer,		    ACPI_MIN(obj_desc->common_field.access_byte_width,			     buffer_length - buffer_offset));	merged_datum =	    raw_datum << obj_desc->common_field.start_field_bit_offset;	/* Write the entire field */	for (i = 1; i < field_datum_count; i++) {		/* Write merged datum to the target field */		merged_datum &= mask;//.........这里部分代码省略.........

voidAcpiDmAddNodeToExternalList (    ACPI_NAMESPACE_NODE     *Node,    UINT8                   Type,    UINT32                  Value,    UINT16                  Flags){    char                    *ExternalPath;    char                    *InternalPath;    char                    *Temp;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (DmAddNodeToExternalList);    if (!Node)    {        return_VOID;    }    /* Get the full external and internal pathnames to the node */    ExternalPath = AcpiNsGetExternalPathname (Node);    if (!ExternalPath)    {        return_VOID;    }    Status = AcpiNsInternalizeName (ExternalPath, &InternalPath);    if (ACPI_FAILURE (Status))    {        ACPI_FREE (ExternalPath);        return_VOID;    }    /* Remove the root backslash */    if ((*ExternalPath == AML_ROOT_PREFIX) && (ExternalPath[1]))    {        Temp = ACPI_ALLOCATE_ZEROED (strlen (ExternalPath) + 1);        if (!Temp)        {            return_VOID;        }        strcpy (Temp, &ExternalPath[1]);        ACPI_FREE (ExternalPath);        ExternalPath = Temp;    }    /* Create the new External() declaration node */    Status = AcpiDmCreateNewExternal (ExternalPath, InternalPath, Type,        Value, (Flags | ACPI_EXT_INTERNAL_PATH_ALLOCATED));    if (ACPI_FAILURE (Status))    {        ACPI_FREE (ExternalPath);        ACPI_FREE (InternalPath);    }    return_VOID;}

ACPI_STATUSAcpiDecodePldBuffer (    UINT8                   *InBuffer,    ACPI_SIZE               Length,    ACPI_PLD_INFO           **ReturnBuffer){    ACPI_PLD_INFO           *PldInfo;    UINT32                  *Buffer = ACPI_CAST_PTR (UINT32, InBuffer);    UINT32                  Dword;    /* Parameter validation */    if (!InBuffer || !ReturnBuffer || (Length < 16))    {        return (AE_BAD_PARAMETER);    }    PldInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PLD_INFO));    if (!PldInfo)    {        return (AE_NO_MEMORY);    }    /* First 32-bit DWord */    ACPI_MOVE_32_TO_32 (&Dword, &Buffer[0]);    PldInfo->Revision =             ACPI_PLD_GET_REVISION (&Dword);    PldInfo->IgnoreColor =          ACPI_PLD_GET_IGNORE_COLOR (&Dword);    PldInfo->Color =                ACPI_PLD_GET_COLOR (&Dword);    /* Second 32-bit DWord */    ACPI_MOVE_32_TO_32 (&Dword, &Buffer[1]);    PldInfo->Width =                ACPI_PLD_GET_WIDTH (&Dword);    PldInfo->Height =               ACPI_PLD_GET_HEIGHT(&Dword);    /* Third 32-bit DWord */    ACPI_MOVE_32_TO_32 (&Dword, &Buffer[2]);    PldInfo->UserVisible =          ACPI_PLD_GET_USER_VISIBLE (&Dword);    PldInfo->Dock =                 ACPI_PLD_GET_DOCK (&Dword);    PldInfo->Lid =                  ACPI_PLD_GET_LID (&Dword);    PldInfo->Panel =                ACPI_PLD_GET_PANEL (&Dword);    PldInfo->VerticalPosition =     ACPI_PLD_GET_VERTICAL (&Dword);    PldInfo->HorizontalPosition =   ACPI_PLD_GET_HORIZONTAL (&Dword);    PldInfo->Shape =                ACPI_PLD_GET_SHAPE (&Dword);    PldInfo->GroupOrientation =     ACPI_PLD_GET_ORIENTATION (&Dword);    PldInfo->GroupToken =           ACPI_PLD_GET_TOKEN (&Dword);    PldInfo->GroupPosition =        ACPI_PLD_GET_POSITION (&Dword);    PldInfo->Bay =                  ACPI_PLD_GET_BAY (&Dword);    /* Fourth 32-bit DWord */    ACPI_MOVE_32_TO_32 (&Dword, &Buffer[3]);    PldInfo->Ejectable =            ACPI_PLD_GET_EJECTABLE (&Dword);    PldInfo->OspmEjectRequired =    ACPI_PLD_GET_OSPM_EJECT (&Dword);    PldInfo->CabinetNumber =        ACPI_PLD_GET_CABINET (&Dword);    PldInfo->CardCageNumber =       ACPI_PLD_GET_CARD_CAGE (&Dword);    PldInfo->Reference =            ACPI_PLD_GET_REFERENCE (&Dword);    PldInfo->Rotation =             ACPI_PLD_GET_ROTATION (&Dword);    PldInfo->Order =                ACPI_PLD_GET_ORDER (&Dword);    if (Length >= ACPI_PLD_BUFFER_SIZE)    {        /* Fifth 32-bit DWord (Revision 2 of _PLD) */        ACPI_MOVE_32_TO_32 (&Dword, &Buffer[4]);        PldInfo->VerticalOffset =       ACPI_PLD_GET_VERT_OFFSET (&Dword);        PldInfo->HorizontalOffset =     ACPI_PLD_GET_HORIZ_OFFSET (&Dword);    }    *ReturnBuffer = PldInfo;    return (AE_OK);}

static ACPI_GPE_XRUPT_INFO *AcpiEvGetGpeXruptBlock (    UINT32                  InterruptNumber){    ACPI_GPE_XRUPT_INFO     *NextGpeXrupt;    ACPI_GPE_XRUPT_INFO     *GpeXrupt;    ACPI_STATUS             Status;    ACPI_CPU_FLAGS          Flags;    ACPI_FUNCTION_TRACE (EvGetGpeXruptBlock);    /* No need for lock since we are not changing any list elements here */    NextGpeXrupt = AcpiGbl_GpeXruptListHead;    while (NextGpeXrupt)    {        if (NextGpeXrupt->InterruptNumber == InterruptNumber)        {            return_PTR (NextGpeXrupt);        }        NextGpeXrupt = NextGpeXrupt->Next;    }    /* Not found, must allocate a new xrupt descriptor */    GpeXrupt = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_XRUPT_INFO));    if (!GpeXrupt)    {        return_PTR (NULL);    }    GpeXrupt->InterruptNumber = InterruptNumber;    /* Install new interrupt descriptor with spin lock */    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);    if (AcpiGbl_GpeXruptListHead)    {        NextGpeXrupt = AcpiGbl_GpeXruptListHead;        while (NextGpeXrupt->Next)        {            NextGpeXrupt = NextGpeXrupt->Next;        }        NextGpeXrupt->Next = GpeXrupt;        GpeXrupt->Previous = NextGpeXrupt;    }    else    {        AcpiGbl_GpeXruptListHead = GpeXrupt;    }    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);    /* Install new interrupt handler if not SCI_INT */    if (InterruptNumber != AcpiGbl_FADT.SciInterrupt)    {        Status = AcpiOsInstallInterruptHandler (InterruptNumber,                    AcpiEvGpeXruptHandler, GpeXrupt);        if (ACPI_FAILURE (Status))        {            ACPI_ERROR ((AE_INFO,                "Could not install GPE interrupt handler at level 0x%X",                InterruptNumber));            return_PTR (NULL);        }    }    return_PTR (GpeXrupt);}

static char *AcpiGetTagPathname (    ACPI_PARSE_OBJECT       *IndexOp,    ACPI_NAMESPACE_NODE     *BufferNode,    ACPI_NAMESPACE_NODE     *ResourceNode,    UINT32                  BitIndex){    ACPI_STATUS             Status;    UINT32                  ResourceBitIndex;    UINT8                   ResourceTableIndex;    ACPI_SIZE               RequiredSize;    char                    *Pathname;    AML_RESOURCE            *Aml;    ACPI_PARSE_OBJECT       *Op;    char                    *InternalPath;    char                    *Tag;    /* Get the Op that contains the actual buffer data */    Op = BufferNode->Op->Common.Value.Arg;    Op = Op->Common.Next;    if (!Op)    {        return (NULL);    }    /* Get the individual resource descriptor and validate it */    Aml = ACPI_CAST_PTR (AML_RESOURCE,            &Op->Named.Data[ResourceNode->Value]);    Status = AcpiUtValidateResource (NULL, Aml, &ResourceTableIndex);    if (ACPI_FAILURE (Status))    {        return (NULL);    }    /* Get offset into this descriptor (from offset into entire buffer) */    ResourceBitIndex = BitIndex - ACPI_MUL_8 (ResourceNode->Value);    /* Get the tag associated with this resource descriptor and offset */    Tag = AcpiDmGetResourceTag (ResourceBitIndex, Aml, ResourceTableIndex);    if (!Tag)    {        return (NULL);    }    /*     * Now that we know that we have a reference that can be converted to a     * symbol, change the name of the resource to a unique name.     */    AcpiDmUpdateResourceName (ResourceNode);    /* Get the full pathname to the parent buffer */    RequiredSize = AcpiNsGetPathnameLength (BufferNode);    if (!RequiredSize)    {        return (NULL);    }    Pathname = ACPI_ALLOCATE_ZEROED (RequiredSize + ACPI_PATH_SEGMENT_LENGTH);    if (!Pathname)    {        return (NULL);    }    Status = AcpiNsBuildExternalPath (BufferNode, RequiredSize, Pathname);    if (ACPI_FAILURE (Status))    {        ACPI_FREE (Pathname);        return (NULL);    }    /*     * Create the full path to the resource and tag by: remove the buffer name,     * append the resource descriptor name, append a dot, append the tag name.     *     * TBD: Always using the full path is a bit brute force, the path can be     * often be optimized with carats (if the original buffer namepath is a     * single nameseg). This doesn't really matter, because these paths do not     * end up in the final compiled AML, it's just an appearance issue for the     * disassembled code.     */    Pathname[ACPI_STRLEN (Pathname) - ACPI_NAME_SIZE] = 0;    ACPI_STRNCAT (Pathname, ResourceNode->Name.Ascii, ACPI_NAME_SIZE);    ACPI_STRCAT (Pathname, ".");    ACPI_STRNCAT (Pathname, Tag, ACPI_NAME_SIZE);    /* Internalize the namepath to AML format */    AcpiNsInternalizeName (Pathname, &InternalPath);    ACPI_FREE (Pathname);    /* Update the Op with the symbol */    AcpiPsInitOp (IndexOp, AML_INT_NAMEPATH_OP);//.........这里部分代码省略.........

/******************************************************************************* * * FUNCTION:    acpi_install_gpe_handler * * PARAMETERS:  gpe_device      - Namespace node for the GPE (NULL for FADT *                                defined GPEs) *              gpe_number      - The GPE number within the GPE block *              Type            - Whether this GPE should be treated as an *                                edge- or level-triggered interrupt. *              Address         - Address of the handler *              Context         - Value passed to the handler on each GPE * * RETURN:      Status * * DESCRIPTION: Install a handler for a General Purpose Event. * ******************************************************************************/acpi_statusacpi_install_gpe_handler(acpi_handle gpe_device,			 u32 gpe_number,			 u32 type, acpi_event_handler address, void *context){	struct acpi_gpe_event_info *gpe_event_info;	struct acpi_handler_info *handler;	acpi_status status;	acpi_cpu_flags flags;	ACPI_FUNCTION_TRACE(acpi_install_gpe_handler);	/* Parameter validation */	if ((!address) || (type > ACPI_GPE_XRUPT_TYPE_MASK)) {		status = AE_BAD_PARAMETER;		goto exit;	}	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);	if (ACPI_FAILURE(status)) {		goto exit;	}	/* Ensure that we have a valid GPE number */	gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);	if (!gpe_event_info) {		status = AE_BAD_PARAMETER;		goto unlock_and_exit;	}	/* Make sure that there isn't a handler there already */	if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==	    ACPI_GPE_DISPATCH_HANDLER) {		status = AE_ALREADY_EXISTS;		goto unlock_and_exit;	}	/* Allocate and init handler object */	handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));	if (!handler) {		status = AE_NO_MEMORY;		goto unlock_and_exit;	}	handler->address = address;	handler->context = context;	handler->method_node = gpe_event_info->dispatch.method_node;	/* Disable the GPE before installing the handler */	status = acpi_ev_disable_gpe(gpe_event_info);	if (ACPI_FAILURE(status)) {		goto unlock_and_exit;	}	/* Install the handler */	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);	gpe_event_info->dispatch.handler = handler;	/* Setup up dispatch flags to indicate handler (vs. method) */	gpe_event_info->flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);	/* Clear bits */	gpe_event_info->flags |= (u8) (type | ACPI_GPE_DISPATCH_HANDLER);	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);      unlock_and_exit:	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);      exit:	if (ACPI_FAILURE(status))		ACPI_EXCEPTION((AE_INFO, status,				"Installing notify handler failed"));	return_ACPI_STATUS(status);}

static ACPI_STATUSAcpiUtCopyEsimpleToIsimple (    ACPI_OBJECT             *ExternalObject,    ACPI_OPERAND_OBJECT     **RetInternalObject){    ACPI_OPERAND_OBJECT     *InternalObject;    ACPI_FUNCTION_TRACE (UtCopyEsimpleToIsimple);    /*     * Simple types supported are: String, Buffer, Integer     */    switch (ExternalObject->Type)    {    case ACPI_TYPE_STRING:    case ACPI_TYPE_BUFFER:    case ACPI_TYPE_INTEGER:    case ACPI_TYPE_LOCAL_REFERENCE:        InternalObject = AcpiUtCreateInternalObject (                            (UINT8) ExternalObject->Type);        if (!InternalObject)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        break;    case ACPI_TYPE_ANY: /* This is the case for a NULL object */        *RetInternalObject = NULL;        return_ACPI_STATUS (AE_OK);    default:        /* All other types are not supported */        ACPI_ERROR ((AE_INFO,            "Unsupported object type, cannot convert to internal object: %s",            AcpiUtGetTypeName (ExternalObject->Type)));        return_ACPI_STATUS (AE_SUPPORT);    }    /* Must COPY string and buffer contents */    switch (ExternalObject->Type)    {    case ACPI_TYPE_STRING:        InternalObject->String.Pointer =            ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)                ExternalObject->String.Length + 1);        if (!InternalObject->String.Pointer)        {            goto ErrorExit;        }        ACPI_MEMCPY (InternalObject->String.Pointer,                     ExternalObject->String.Pointer,                     ExternalObject->String.Length);        InternalObject->String.Length  = ExternalObject->String.Length;        break;    case ACPI_TYPE_BUFFER:        InternalObject->Buffer.Pointer =            ACPI_ALLOCATE_ZEROED (ExternalObject->Buffer.Length);        if (!InternalObject->Buffer.Pointer)        {            goto ErrorExit;        }        ACPI_MEMCPY (InternalObject->Buffer.Pointer,                     ExternalObject->Buffer.Pointer,                     ExternalObject->Buffer.Length);        InternalObject->Buffer.Length  = ExternalObject->Buffer.Length;        /* Mark buffer data valid */        InternalObject->Buffer.Flags |= AOPOBJ_DATA_VALID;        break;    case ACPI_TYPE_INTEGER:        InternalObject->Integer.Value   = ExternalObject->Integer.Value;        break;    case ACPI_TYPE_LOCAL_REFERENCE:        /* TBD: should validate incoming handle */        InternalObject->Reference.Class = ACPI_REFCLASS_NAME;        InternalObject->Reference.Node = ExternalObject->Reference.Handle;//.........这里部分代码省略.........

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

acpi_statusacpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,			 struct acpi_generic_address *gpe_block_address,			 u32 register_count,			 u8 gpe_block_base_number,			 u32 interrupt_number,			 struct acpi_gpe_block_info **return_gpe_block){	acpi_status status;	struct acpi_gpe_block_info *gpe_block;	struct acpi_gpe_walk_info walk_info;	ACPI_FUNCTION_TRACE(ev_create_gpe_block);	if (!register_count) {		return_ACPI_STATUS(AE_OK);	}	/* Allocate a new GPE block */	gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));	if (!gpe_block) {		return_ACPI_STATUS(AE_NO_MEMORY);	}	/* Initialize the new GPE block */	gpe_block->node = gpe_device;	gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);	gpe_block->initialized = FALSE;	gpe_block->register_count = register_count;	gpe_block->block_base_number = gpe_block_base_number;	ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,		    sizeof(struct acpi_generic_address));	/*	 * Create the register_info and event_info sub-structures	 * Note: disables and clears all GPEs in the block	 */	status = acpi_ev_create_gpe_info_blocks(gpe_block);	if (ACPI_FAILURE(status)) {		ACPI_FREE(gpe_block);		return_ACPI_STATUS(status);	}	/* Install the new block in the global lists */	status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);	if (ACPI_FAILURE(status)) {		ACPI_FREE(gpe_block->register_info);		ACPI_FREE(gpe_block->event_info);		ACPI_FREE(gpe_block);		return_ACPI_STATUS(status);	}	acpi_gbl_all_gpes_initialized = FALSE;	/* Find all GPE methods (_Lxx or_Exx) for this block */	walk_info.gpe_block = gpe_block;	walk_info.gpe_device = gpe_device;	walk_info.execute_by_owner_id = FALSE;	status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,					ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,					acpi_ev_match_gpe_method, NULL,					&walk_info, NULL);	/* Return the new block */	if (return_gpe_block) {		(*return_gpe_block) = gpe_block;	}	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,			      "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X/n",			      (u32)gpe_block->block_base_number,			      (u32)(gpe_block->block_base_number +				    (gpe_block->gpe_count - 1)),			      gpe_device->name.ascii, gpe_block->register_count,			      interrupt_number));	/* Update global count of currently available GPEs */	acpi_current_gpe_count += gpe_block->gpe_count;	return_ACPI_STATUS(AE_OK);}

acpi_status acpi_ns_initialize_devices(void){	acpi_status status;	struct acpi_device_walk_info info;	ACPI_FUNCTION_TRACE(ns_initialize_devices);	/* Init counters */	info.device_count = 0;	info.num_STA = 0;	info.num_INI = 0;	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,			      "Initializing Device/Processor/Thermal objects "			      "by executing _INI methods:"));	/* Tree analysis: find all subtrees that contain _INI methods */	status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,					ACPI_UINT32_MAX, FALSE,					acpi_ns_find_ini_methods, NULL, &info,					NULL);	if (ACPI_FAILURE(status)) {		goto error_exit;	}	/* Allocate the evaluation information block */	info.evaluate_info =	    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));	if (!info.evaluate_info) {		status = AE_NO_MEMORY;		goto error_exit;	}	/*	 * Execute the "global" _INI method that may appear at the root. This	 * support is provided for Windows compatibility (Vista+) and is not	 * part of the ACPI specification.	 */	info.evaluate_info->prefix_node = acpi_gbl_root_node;	info.evaluate_info->pathname = METHOD_NAME__INI;	info.evaluate_info->parameters = NULL;	info.evaluate_info->flags = ACPI_IGNORE_RETURN_VALUE;	status = acpi_ns_evaluate(info.evaluate_info);	if (ACPI_SUCCESS(status)) {		info.num_INI++;	}	/* Walk namespace to execute all _INIs on present devices */	status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,					ACPI_UINT32_MAX, FALSE,					acpi_ns_init_one_device, NULL, &info,					NULL);	/*	 * Any _OSI requests should be completed by now. If the BIOS has	 * requested any Windows OSI strings, we will always truncate	 * I/O addresses to 16 bits -- for Windows compatibility.	 */	if (acpi_gbl_osi_data >= ACPI_OSI_WIN_2000) {		acpi_gbl_truncate_io_addresses = TRUE;	}	ACPI_FREE(info.evaluate_info);	if (ACPI_FAILURE(status)) {		goto error_exit;	}	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,			      "/nExecuted %u _INI methods requiring %u _STA executions "			      "(examined %u objects)/n",			      info.num_INI, info.num_STA, info.device_count));	return_ACPI_STATUS(status);      error_exit:	ACPI_EXCEPTION((AE_INFO, status, "During device initialization"));	return_ACPI_STATUS(status);}

static acpi_statusacpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block){	struct acpi_gpe_register_info *gpe_register_info = NULL;	struct acpi_gpe_event_info *gpe_event_info = NULL;	struct acpi_gpe_event_info *this_event;	struct acpi_gpe_register_info *this_register;	u32 i;	u32 j;	acpi_status status;	ACPI_FUNCTION_TRACE(ev_create_gpe_info_blocks);	/* Allocate the GPE register information block */	gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->						 register_count *						 sizeof(struct							acpi_gpe_register_info));	if (!gpe_register_info) {		ACPI_ERROR((AE_INFO,			    "Could not allocate the GpeRegisterInfo table"));		return_ACPI_STATUS(AE_NO_MEMORY);	}	/*	 * Allocate the GPE event_info block. There are eight distinct GPEs	 * per register. Initialization to zeros is sufficient.	 */	gpe_event_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->gpe_count *					      sizeof(struct						     acpi_gpe_event_info));	if (!gpe_event_info) {		ACPI_ERROR((AE_INFO,			    "Could not allocate the GpeEventInfo table"));		status = AE_NO_MEMORY;		goto error_exit;	}	/* Save the new Info arrays in the GPE block */	gpe_block->register_info = gpe_register_info;	gpe_block->event_info = gpe_event_info;	/*	 * Initialize the GPE Register and Event structures. A goal of these	 * tables is to hide the fact that there are two separate GPE register	 * sets in a given GPE hardware block, the status registers occupy the	 * first half, and the enable registers occupy the second half.	 */	this_register = gpe_register_info;	this_event = gpe_event_info;	for (i = 0; i < gpe_block->register_count; i++) {		/* Init the register_info for this GPE register (8 GPEs) */		this_register->base_gpe_number =		    (u8) (gpe_block->block_base_number +			  (i * ACPI_GPE_REGISTER_WIDTH));		this_register->status_address.address =		    gpe_block->block_address.address + i;		this_register->enable_address.address =		    gpe_block->block_address.address + i +		    gpe_block->register_count;		this_register->status_address.space_id =		    gpe_block->block_address.space_id;		this_register->enable_address.space_id =		    gpe_block->block_address.space_id;		this_register->status_address.bit_width =		    ACPI_GPE_REGISTER_WIDTH;		this_register->enable_address.bit_width =		    ACPI_GPE_REGISTER_WIDTH;		this_register->status_address.bit_offset = 0;		this_register->enable_address.bit_offset = 0;		/* Init the event_info for each GPE within this register */		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {			this_event->gpe_number =			    (u8) (this_register->base_gpe_number + j);			this_event->register_info = this_register;			this_event++;		}		/* Disable all GPEs within this register */		status = acpi_hw_write(0x00, &this_register->enable_address);		if (ACPI_FAILURE(status)) {			goto error_exit;		}		/* Clear any pending GPE events within this register */		status = acpi_hw_write(0xFF, &this_register->status_address);		if (ACPI_FAILURE(status)) {			goto error_exit;//.........这里部分代码省略.........

ACPI_STATUSAcpiUtInitializeBuffer (    ACPI_BUFFER             *Buffer,    ACPI_SIZE               RequiredLength){    ACPI_STATUS             Status = AE_OK;    switch (Buffer->Length)    {    case ACPI_NO_BUFFER:        /* Set the exception and returned the required length */        Status = AE_BUFFER_OVERFLOW;        break;    case ACPI_ALLOCATE_BUFFER:        /* Allocate a new buffer */        Buffer->Pointer = AcpiOsAllocate (RequiredLength);        if (!Buffer->Pointer)        {            return (AE_NO_MEMORY);        }        /* Clear the buffer */        ACPI_MEMSET (Buffer->Pointer, 0, RequiredLength);        break;    case ACPI_ALLOCATE_LOCAL_BUFFER:        /* Allocate a new buffer with local interface to allow tracking */        Buffer->Pointer = ACPI_ALLOCATE_ZEROED (RequiredLength);        if (!Buffer->Pointer)        {            return (AE_NO_MEMORY);        }        break;    default:        /* Existing buffer: Validate the size of the buffer */        if (Buffer->Length < RequiredLength)        {            Status = AE_BUFFER_OVERFLOW;            break;        }        /* Clear the buffer */        ACPI_MEMSET (Buffer->Pointer, 0, RequiredLength);        break;    }    Buffer->Length = RequiredLength;    return (Status);}

ACPI_STATUSAcpiEvExecuteRegMethod (    ACPI_OPERAND_OBJECT     *RegionObj,    UINT32                  Function){    ACPI_EVALUATE_INFO      *Info;    ACPI_OPERAND_OBJECT     *Args[3];    ACPI_OPERAND_OBJECT     *RegionObj2;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (EvExecuteRegMethod);    RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);    if (!RegionObj2)    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    if (RegionObj2->Extra.Method_REG == NULL)    {        return_ACPI_STATUS (AE_OK);    }    /* Allocate and initialize the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->PrefixNode = RegionObj2->Extra.Method_REG;    Info->RelativePathname = NULL;    Info->Parameters = Args;    Info->Flags = ACPI_IGNORE_RETURN_VALUE;    /*     * The _REG method has two arguments:     *     * Arg0 - Integer:     *  Operation region space ID Same value as RegionObj->Region.SpaceId     *     * Arg1 - Integer:     *  connection status 1 for connecting the handler, 0 for disconnecting     *  the handler (Passed as a parameter)     */    Args[0] = AcpiUtCreateIntegerObject ((UINT64) RegionObj->Region.SpaceId);    if (!Args[0])    {        Status = AE_NO_MEMORY;        goto Cleanup1;    }    Args[1] = AcpiUtCreateIntegerObject ((UINT64) Function);    if (!Args[1])    {        Status = AE_NO_MEMORY;        goto Cleanup2;    }    Args[2] = NULL; /* Terminate list */    /* Execute the method, no return value */    ACPI_DEBUG_EXEC (        AcpiUtDisplayInitPathname (ACPI_TYPE_METHOD, Info->PrefixNode, NULL));    Status = AcpiNsEvaluate (Info);    AcpiUtRemoveReference (Args[1]);Cleanup2:    AcpiUtRemoveReference (Args[0]);Cleanup1:    ACPI_FREE (Info);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiSetupGpeForWake (    ACPI_HANDLE             WakeDevice,    ACPI_HANDLE             GpeDevice,    UINT32                  GpeNumber){    ACPI_STATUS             Status;    ACPI_GPE_EVENT_INFO     *GpeEventInfo;    ACPI_NAMESPACE_NODE     *DeviceNode;    ACPI_GPE_NOTIFY_INFO    *Notify;    ACPI_GPE_NOTIFY_INFO    *NewNotify;    ACPI_CPU_FLAGS          Flags;    ACPI_FUNCTION_TRACE (AcpiSetupGpeForWake);    /* Parameter Validation */    if (!WakeDevice)    {        /*         * By forcing WakeDevice to be valid, we automatically enable the         * implicit notify feature on all hosts.         */        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Handle root object case */    if (WakeDevice == ACPI_ROOT_OBJECT)    {        DeviceNode = AcpiGbl_RootNode;    }    else    {        DeviceNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, WakeDevice);    }    /* Validate WakeDevice is of type Device */    if (DeviceNode->Type != ACPI_TYPE_DEVICE)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /*     * Allocate a new notify object up front, in case it is needed.     * Memory allocation while holding a spinlock is a big no-no     * on some hosts.     */    NewNotify = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_NOTIFY_INFO));    if (!NewNotify)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);    /* Ensure that we have a valid GPE number */    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);    if (!GpeEventInfo)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /*     * If there is no method or handler for this GPE, then the     * WakeDevice will be notified whenever this GPE fires. This is     * known as an "implicit notify". Note: The GPE is assumed to be     * level-triggered (for windows compatibility).     */    if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==            ACPI_GPE_DISPATCH_NONE)    {        /*         * This is the first device for implicit notify on this GPE.         * Just set the flags here, and enter the NOTIFY block below.         */        GpeEventInfo->Flags =            (ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);    }    /*     * If we already have an implicit notify on this GPE, add     * this device to the notify list.     */    if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==            ACPI_GPE_DISPATCH_NOTIFY)    {        /* Ensure that the device is not already in the list */        Notify = GpeEventInfo->Dispatch.NotifyList;        while (Notify)        {            if (Notify->DeviceNode == DeviceNode)            {                Status = AE_ALREADY_EXISTS;//.........这里部分代码省略.........

acpi_statusacpi_ex_store_string_to_string(union acpi_operand_object *source_desc,			       union acpi_operand_object *target_desc){	u32 length;	u8 *buffer;	ACPI_FUNCTION_TRACE_PTR(ex_store_string_to_string, source_desc);	/* If Source and Target are the same, just return */	if (source_desc == target_desc) {		return_ACPI_STATUS(AE_OK);	}	/* We know that source_desc is a string by now */	buffer = ACPI_CAST_PTR(u8, source_desc->string.pointer);	length = source_desc->string.length;	/*	 * Replace existing string value if it will fit and the string	 * pointer is not a static pointer (part of an ACPI table)	 */	if ((length < target_desc->string.length) &&	    (!(target_desc->common.flags & AOPOBJ_STATIC_POINTER))) {		/*		 * String will fit in existing non-static buffer.		 * Clear old string and copy in the new one		 */		memset(target_desc->string.pointer, 0,		       (acpi_size) target_desc->string.length + 1);		memcpy(target_desc->string.pointer, buffer, length);	} else {		/*		 * Free the current buffer, then allocate a new buffer		 * large enough to hold the value		 */		if (target_desc->string.pointer &&		    (!(target_desc->common.flags & AOPOBJ_STATIC_POINTER))) {			/* Only free if not a pointer into the DSDT */			ACPI_FREE(target_desc->string.pointer);		}		target_desc->string.pointer =		    ACPI_ALLOCATE_ZEROED((acpi_size) length + 1);		if (!target_desc->string.pointer) {			return_ACPI_STATUS(AE_NO_MEMORY);		}		target_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;		memcpy(target_desc->string.pointer, buffer, length);	}	/* Set the new target length */	target_desc->string.length = length;	return_ACPI_STATUS(AE_OK);}

ACPI_STATUSAcpiInstallGpeHandler (    ACPI_HANDLE             GpeDevice,    UINT32                  GpeNumber,    UINT32                  Type,    ACPI_EVENT_HANDLER      Address,    void                    *Context){    ACPI_GPE_EVENT_INFO     *GpeEventInfo;    ACPI_HANDLER_INFO       *Handler;    ACPI_STATUS             Status;    ACPI_CPU_FLAGS          Flags;    ACPI_FUNCTION_TRACE (AcpiInstallGpeHandler);    /* Parameter validation */    if ((!Address) || (Type & ~ACPI_GPE_XRUPT_TYPE_MASK))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Ensure that we have a valid GPE number */    GpeEventInfo = AcpiEvGetGpeEventInfo (GpeDevice, GpeNumber);    if (!GpeEventInfo)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Make sure that there isn't a handler there already */    if ((GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK) ==            ACPI_GPE_DISPATCH_HANDLER)    {        Status = AE_ALREADY_EXISTS;        goto UnlockAndExit;    }    /* Allocate and init handler object */    Handler = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_HANDLER_INFO));    if (!Handler)    {        Status = AE_NO_MEMORY;        goto UnlockAndExit;    }    Handler->Address    = Address;    Handler->Context    = Context;    Handler->MethodNode = GpeEventInfo->Dispatch.MethodNode;    /* Install the handler */    Flags = AcpiOsAcquireLock (AcpiGbl_GpeLock);    GpeEventInfo->Dispatch.Handler = Handler;    /* Setup up dispatch flags to indicate handler (vs. method) */    GpeEventInfo->Flags &= ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);    GpeEventInfo->Flags |= (UINT8) (Type | ACPI_GPE_DISPATCH_HANDLER);    AcpiOsReleaseLock (AcpiGbl_GpeLock, Flags);UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);    return_ACPI_STATUS (Status);}

struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number){	struct acpi_gpe_xrupt_info *next_gpe_xrupt;	struct acpi_gpe_xrupt_info *gpe_xrupt;	acpi_status status;	acpi_cpu_flags flags;	ACPI_FUNCTION_TRACE(ev_get_gpe_xrupt_block);	/* No need for lock since we are not changing any list elements here */	next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;	while (next_gpe_xrupt) {		if (next_gpe_xrupt->interrupt_number == interrupt_number) {			return_PTR(next_gpe_xrupt);		}		next_gpe_xrupt = next_gpe_xrupt->next;	}	/* Not found, must allocate a new xrupt descriptor */	gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));	if (!gpe_xrupt) {		return_PTR(NULL);	}	gpe_xrupt->interrupt_number = interrupt_number;	/* Install new interrupt descriptor with spin lock */	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);	if (acpi_gbl_gpe_xrupt_list_head) {		next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;		while (next_gpe_xrupt->next) {			next_gpe_xrupt = next_gpe_xrupt->next;		}		next_gpe_xrupt->next = gpe_xrupt;		gpe_xrupt->previous = next_gpe_xrupt;	} else {		acpi_gbl_gpe_xrupt_list_head = gpe_xrupt;	}	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);	/* Install new interrupt handler if not SCI_INT */	if (interrupt_number != acpi_gbl_FADT.sci_interrupt) {		status = acpi_os_install_interrupt_handler(interrupt_number,							   acpi_ev_gpe_xrupt_handler,							   gpe_xrupt);		if (ACPI_FAILURE(status)) {			ACPI_ERROR((AE_INFO,				    "Could not install GPE interrupt handler at level 0x%X",				    interrupt_number));			return_PTR(NULL);		}	}	return_PTR(gpe_xrupt);}

acpi_statusacpi_ds_call_control_method(struct acpi_thread_state *thread,			    struct acpi_walk_state *this_walk_state,			    union acpi_parse_object *op){	acpi_status status;	struct acpi_namespace_node *method_node;	struct acpi_walk_state *next_walk_state = NULL;	union acpi_operand_object *obj_desc;	struct acpi_evaluate_info *info;	u32 i;	ACPI_FUNCTION_TRACE_PTR(ds_call_control_method, this_walk_state);	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,			  "Calling method %p, currentstate=%p/n",			  this_walk_state->prev_op, this_walk_state));	/*	 * Get the namespace entry for the control method we are about to call	 */	method_node = this_walk_state->method_call_node;	if (!method_node) {		return_ACPI_STATUS(AE_NULL_ENTRY);	}	obj_desc = acpi_ns_get_attached_object(method_node);	if (!obj_desc) {		return_ACPI_STATUS(AE_NULL_OBJECT);	}	/* Init for new method, possibly wait on method mutex */	status =	    acpi_ds_begin_method_execution(method_node, obj_desc,					   this_walk_state);	if (ACPI_FAILURE(status)) {		return_ACPI_STATUS(status);	}	/* Begin method parse/execution. Create a new walk state */	next_walk_state =	    acpi_ds_create_walk_state(obj_desc->method.owner_id, NULL, obj_desc,				      thread);	if (!next_walk_state) {		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	 */	this_walk_state->operands[this_walk_state->num_operands] = NULL;	/*	 * Allocate and initialize the evaluation information block	 * TBD: this is somewhat inefficient, should change interface to	 * ds_init_aml_walk. For now, keeps this struct off the CPU stack	 */	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));	if (!info) {		status = AE_NO_MEMORY;		goto cleanup;	}	info->parameters = &this_walk_state->operands[0];	status = acpi_ds_init_aml_walk(next_walk_state, NULL, method_node,				       obj_desc->method.aml_start,				       obj_desc->method.aml_length, 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 < obj_desc->method.param_count; i++) {		acpi_ut_remove_reference(this_walk_state->operands[i]);		this_walk_state->operands[i] = NULL;	}	/* Clear the operand stack */	this_walk_state->num_operands = 0;	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,			  "**** Begin nested execution of [%4.4s] **** WalkState=%p/n",			  method_node->name.ascii, next_walk_state));	/* Invoke an internal method if necessary */	if (obj_desc->method.info_flags & ACPI_METHOD_INTERNAL_ONLY) {//.........这里部分代码省略.........

//.........这里部分代码省略.........				    ||				    !(ACPI_STRNCMP				      (object_hID.value,				       PCI_EXPRESS_ROOT_HID_STRING,				       sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) {					/* Install a handler for this PCI root bridge */					status =					    acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);					if (ACPI_FAILURE(status)) {						if (status == AE_SAME_HANDLER) {							/*							 * It is OK if the handler is already installed on the root							 * bridge.  Still need to return a context object for the							 * new PCI_Config operation region, however.							 */							status = AE_OK;						} else {							ACPI_EXCEPTION((AE_INFO,									status,									"Could not install PciConfig handler for Root Bridge %4.4s",									acpi_ut_get_node_name									(pci_root_node)));						}					}					break;				}			}			pci_root_node = acpi_ns_get_parent_node(pci_root_node);		}		/* PCI root bridge not found, use namespace root node */	} else {		pci_root_node = handler_obj->address_space.node;	}	/*	 * If this region is now initialized, we are done.	 * (install_address_space_handler could have initialized it)	 */	if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {		return_ACPI_STATUS(AE_OK);	}	/* Region is still not initialized. Create a new context */	pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));	if (!pci_id) {		return_ACPI_STATUS(AE_NO_MEMORY);	}	/*	 * For PCI_Config space access, we need the segment, bus,	 * device and function numbers.  Acquire them here.	 */	/*	 * Get the PCI device and function numbers from the _ADR object	 * contained in the parent's scope.	 */	status =	    acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, parent_node,					    &pci_value);	/*	 * The default is zero, and since the allocation above zeroed	 * the data, just do nothing on failure.	 */	if (ACPI_SUCCESS(status)) {		pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));		pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));	}	/* The PCI segment number comes from the _SEG method */	status =	    acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, pci_root_node,					    &pci_value);	if (ACPI_SUCCESS(status)) {		pci_id->segment = ACPI_LOWORD(pci_value);	}	/* The PCI bus number comes from the _BBN method */	status =	    acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, pci_root_node,					    &pci_value);	if (ACPI_SUCCESS(status)) {		pci_id->bus = ACPI_LOWORD(pci_value);	}	/* Complete this device's pci_id */	acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id);	*region_context = pci_id;	return_ACPI_STATUS(AE_OK);}

ACPI_STATUSAcpiNsExecuteTable (    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *StartNode){    ACPI_STATUS             Status;    ACPI_TABLE_HEADER       *Table;    ACPI_OWNER_ID           OwnerId;    ACPI_EVALUATE_INFO      *Info = NULL;    UINT32                  AmlLength;    UINT8                   *AmlStart;    ACPI_OPERAND_OBJECT     *MethodObj = NULL;    ACPI_FUNCTION_TRACE (NsExecuteTable);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Table must consist of at least a complete header */    if (Table->Length < sizeof (ACPI_TABLE_HEADER))    {        return_ACPI_STATUS (AE_BAD_HEADER);    }    AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Create, initialize, and link a new temporary method object */    MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);    if (!MethodObj)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Allocate the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,        "%s: Create table pseudo-method for [%4.4s] @%p, method %p/n",        ACPI_GET_FUNCTION_NAME, Table->Signature, Table, MethodObj));    MethodObj->Method.AmlStart = AmlStart;    MethodObj->Method.AmlLength = AmlLength;    MethodObj->Method.OwnerId = OwnerId;    MethodObj->Method.InfoFlags |= ACPI_METHOD_MODULE_LEVEL;    Info->PassNumber = ACPI_IMODE_EXECUTE;    Info->Node = StartNode;    Info->ObjDesc = MethodObj;    Info->NodeFlags = Info->Node->Flags;    Info->FullPathname = AcpiNsGetNormalizedPathname (Info->Node, TRUE);    if (!Info->FullPathname)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiPsExecuteTable (Info);Cleanup:    if (Info)    {        ACPI_FREE (Info->FullPathname);        Info->FullPathname = NULL;    }    ACPI_FREE (Info);    AcpiUtRemoveReference (MethodObj);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiNsCheckPredefinedNames (    ACPI_NAMESPACE_NODE         *Node,    UINT32                      UserParamCount,    ACPI_STATUS                 ReturnStatus,    ACPI_OPERAND_OBJECT         **ReturnObjectPtr){    ACPI_OPERAND_OBJECT         *ReturnObject = *ReturnObjectPtr;    ACPI_STATUS                 Status = AE_OK;    const ACPI_PREDEFINED_INFO  *Predefined;    char                        *Pathname;    ACPI_PREDEFINED_DATA        *Data;    /* Match the name for this method/object against the predefined list */    Predefined = AcpiNsCheckForPredefinedName (Node);    /* Get the full pathname to the object, for use in warning messages */#ifdef ACPI_DEBUG_OUTPUT /* AB */    Pathname = AcpiNsGetExternalPathname (Node);#else    Pathname = NULL;#endif    if (!Pathname)    {        return (AE_OK); /* Could not get pathname, ignore */    }    /*     * Check that the parameter count for this method matches the ASL     * definition. For predefined names, ensure that both the caller and     * the method itself are in accordance with the ACPI specification.     */    AcpiNsCheckParameterCount (Pathname, Node, UserParamCount, Predefined);    /* If not a predefined name, we cannot validate the return object */    if (!Predefined)    {        goto Cleanup;    }    /*     * If the method failed or did not actually return an object, we cannot     * validate the return object     */    if ((ReturnStatus != AE_OK) && (ReturnStatus != AE_CTRL_RETURN_VALUE))    {        goto Cleanup;    }    /*     * If there is no return value, check if we require a return value for     * this predefined name. Either one return value is expected, or none,     * for both methods and other objects.     *     * Exit now if there is no return object. Warning if one was expected.     */    if (!ReturnObject)    {        if ((Predefined->Info.ExpectedBtypes) &&            (!(Predefined->Info.ExpectedBtypes & ACPI_RTYPE_NONE)))        {            ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,                "Missing expected return value"));            Status = AE_AML_NO_RETURN_VALUE;        }        goto Cleanup;    }    /*     * 1) We have a return value, but if one wasn't expected, just exit, this is     * not a problem. For example, if the "Implicit Return" feature is     * enabled, methods will always return a value.     *     * 2) If the return value can be of any type, then we cannot perform any     * validation, exit.     */    if ((!Predefined->Info.ExpectedBtypes) ||        (Predefined->Info.ExpectedBtypes == ACPI_RTYPE_ALL))    {        goto Cleanup;    }    /* Create the parameter data block for object validation */    Data = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_PREDEFINED_DATA));    if (!Data)    {        goto Cleanup;    }    Data->Predefined = Predefined;    Data->NodeFlags = Node->Flags;    Data->Pathname = Pathname;    /*     * Check that the type of the return object is what is expected for//.........这里部分代码省略.........

ACPI_STATUSAcpiEvCreateGpeBlock (    ACPI_NAMESPACE_NODE     *GpeDevice,    ACPI_GENERIC_ADDRESS    *GpeBlockAddress,    UINT32                  RegisterCount,    UINT8                   GpeBlockBaseNumber,    UINT32                  InterruptNumber,    ACPI_GPE_BLOCK_INFO     **ReturnGpeBlock){    ACPI_STATUS             Status;    ACPI_GPE_BLOCK_INFO     *GpeBlock;    ACPI_FUNCTION_TRACE (EvCreateGpeBlock);    if (!RegisterCount)    {        return_ACPI_STATUS (AE_OK);    }    /* Allocate a new GPE block */    GpeBlock = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO));    if (!GpeBlock)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Initialize the new GPE block */    GpeBlock->Node = GpeDevice;    GpeBlock->RegisterCount = RegisterCount;    GpeBlock->BlockBaseNumber = GpeBlockBaseNumber;    ACPI_MEMCPY (&GpeBlock->BlockAddress, GpeBlockAddress,        sizeof (ACPI_GENERIC_ADDRESS));    /*     * Create the RegisterInfo and EventInfo sub-structures     * Note: disables and clears all GPEs in the block     */    Status = AcpiEvCreateGpeInfoBlocks (GpeBlock);    if (ACPI_FAILURE (Status))    {        ACPI_FREE (GpeBlock);        return_ACPI_STATUS (Status);    }    /* Install the new block in the global lists */    Status = AcpiEvInstallGpeBlock (GpeBlock, InterruptNumber);    if (ACPI_FAILURE (Status))    {        ACPI_FREE (GpeBlock);        return_ACPI_STATUS (Status);    }    /* Find all GPE methods (_Lxx, _Exx) for this block */    Status = AcpiNsWalkNamespace (ACPI_TYPE_METHOD, GpeDevice,                ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,                AcpiEvSaveMethodInfo, NULL, GpeBlock, NULL);    /* Return the new block */    if (ReturnGpeBlock)    {        (*ReturnGpeBlock) = GpeBlock;    }    ACPI_DEBUG_PRINT ((ACPI_DB_INIT,        "GPE %02X to %02X [%4.4s] %u regs on int 0x%X/n",        (UINT32) GpeBlock->BlockBaseNumber,        (UINT32) (GpeBlock->BlockBaseNumber +                ((GpeBlock->RegisterCount * ACPI_GPE_REGISTER_WIDTH) -1)),        GpeDevice->Name.Ascii,        GpeBlock->RegisterCount,        InterruptNumber));    /* Update global count of currently available GPEs */    AcpiCurrentGpeCount += RegisterCount * ACPI_GPE_REGISTER_WIDTH;    return_ACPI_STATUS (AE_OK);}

static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context){	struct acpi_gpe_event_info *gpe_event_info = context;	acpi_status status;	struct acpi_gpe_event_info *local_gpe_event_info;	struct acpi_evaluate_info *info;	struct acpi_gpe_notify_info *notify;	ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);	/* Allocate a local GPE block */	local_gpe_event_info =	    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_event_info));	if (!local_gpe_event_info) {		ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "while handling a GPE"));		return_VOID;	}	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);	if (ACPI_FAILURE(status)) {		ACPI_FREE(local_gpe_event_info);		return_VOID;	}	/* Must revalidate the gpe_number/gpe_block */	if (!acpi_ev_valid_gpe_event(gpe_event_info)) {		status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);		ACPI_FREE(local_gpe_event_info);		return_VOID;	}	/*	 * Take a snapshot of the GPE info for this level - we copy the info to	 * prevent a race condition with remove_handler/remove_block.	 */	ACPI_MEMCPY(local_gpe_event_info, gpe_event_info,		    sizeof(struct acpi_gpe_event_info));	status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);	if (ACPI_FAILURE(status)) {		return_VOID;	}	/* Do the correct dispatch - normal method or implicit notify */	switch (local_gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {	case ACPI_GPE_DISPATCH_NOTIFY:		/*		 * Implicit notify.		 * Dispatch a DEVICE_WAKE notify to the appropriate handler.		 * NOTE: the request is queued for execution after this method		 * completes. The notify handlers are NOT invoked synchronously		 * from this thread -- because handlers may in turn run other		 * control methods.		 *		 * June 2012: Expand implicit notify mechanism to support		 * notifies on multiple device objects.		 */		notify = local_gpe_event_info->dispatch.notify_list;		while (ACPI_SUCCESS(status) && notify) {			status =			    acpi_ev_queue_notify_request(notify->device_node,							 ACPI_NOTIFY_DEVICE_WAKE);			notify = notify->next;		}		break;	case ACPI_GPE_DISPATCH_METHOD:		/* Allocate the evaluation information block */		info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));		if (!info) {			status = AE_NO_MEMORY;		} else {			/*			 * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the _Lxx/_Exx			 * control method that corresponds to this GPE			 */			info->prefix_node =			    local_gpe_event_info->dispatch.method_node;			info->flags = ACPI_IGNORE_RETURN_VALUE;			status = acpi_ns_evaluate(info);			ACPI_FREE(info);		}		if (ACPI_FAILURE(status)) {			ACPI_EXCEPTION((AE_INFO, status,					"while evaluating GPE method [%4.4s]",					acpi_ut_get_node_name					(local_gpe_event_info->dispatch.					 method_node)));		}//.........这里部分代码省略.........

static ACPI_STATUSAcpiEvCreateGpeInfoBlocks (    ACPI_GPE_BLOCK_INFO     *GpeBlock){    ACPI_GPE_REGISTER_INFO  *GpeRegisterInfo = NULL;    ACPI_GPE_EVENT_INFO     *GpeEventInfo = NULL;    ACPI_GPE_EVENT_INFO     *ThisEvent;    ACPI_GPE_REGISTER_INFO  *ThisRegister;    UINT32                  i;    UINT32                  j;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks);    /* Allocate the GPE register information block */    GpeRegisterInfo = ACPI_ALLOCATE_ZEROED (                            (ACPI_SIZE) GpeBlock->RegisterCount *                            sizeof (ACPI_GPE_REGISTER_INFO));    if (!GpeRegisterInfo)    {        ACPI_ERROR ((AE_INFO,            "Could not allocate the GpeRegisterInfo table"));        return_ACPI_STATUS (AE_NO_MEMORY);    }    /*     * Allocate the GPE EventInfo block. There are eight distinct GPEs     * per register. Initialization to zeros is sufficient.     */    GpeEventInfo = ACPI_ALLOCATE_ZEROED (                        ((ACPI_SIZE) GpeBlock->RegisterCount *                        ACPI_GPE_REGISTER_WIDTH) *                        sizeof (ACPI_GPE_EVENT_INFO));    if (!GpeEventInfo)    {        ACPI_ERROR ((AE_INFO,            "Could not allocate the GpeEventInfo table"));        Status = AE_NO_MEMORY;        goto ErrorExit;    }    /* Save the new Info arrays in the GPE block */    GpeBlock->RegisterInfo = GpeRegisterInfo;    GpeBlock->EventInfo    = GpeEventInfo;    /*     * Initialize the GPE Register and Event structures. A goal of these     * tables is to hide the fact that there are two separate GPE register     * sets in a given GPE hardware block, the status registers occupy the     * first half, and the enable registers occupy the second half.     */    ThisRegister = GpeRegisterInfo;    ThisEvent    = GpeEventInfo;    for (i = 0; i < GpeBlock->RegisterCount; i++)    {        /* Init the RegisterInfo for this GPE register (8 GPEs) */        ThisRegister->BaseGpeNumber = (UINT8) (GpeBlock->BlockBaseNumber +                                             (i * ACPI_GPE_REGISTER_WIDTH));        ThisRegister->StatusAddress.Address =            GpeBlock->BlockAddress.Address + i;        ThisRegister->EnableAddress.Address =            GpeBlock->BlockAddress.Address + i + GpeBlock->RegisterCount;        ThisRegister->StatusAddress.SpaceId   = GpeBlock->BlockAddress.SpaceId;        ThisRegister->EnableAddress.SpaceId   = GpeBlock->BlockAddress.SpaceId;        ThisRegister->StatusAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;        ThisRegister->EnableAddress.BitWidth  = ACPI_GPE_REGISTER_WIDTH;        ThisRegister->StatusAddress.BitOffset = 0;        ThisRegister->EnableAddress.BitOffset = 0;        /* Init the EventInfo for each GPE within this register */        for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)        {            ThisEvent->GpeNumber = (UINT8) (ThisRegister->BaseGpeNumber + j);            ThisEvent->RegisterInfo = ThisRegister;            ThisEvent++;        }        /* Disable all GPEs within this register */        Status = AcpiHwWrite (0x00, &ThisRegister->EnableAddress);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }        /* Clear any pending GPE events within this register */        Status = AcpiHwWrite (0xFF, &ThisRegister->StatusAddress);        if (ACPI_FAILURE (Status))        {//.........这里部分代码省略.........

static voidAdCreateTableHeader (    char                    *Filename,    ACPI_TABLE_HEADER       *Table){    char                    *NewFilename;    UINT8                   Checksum;    /*     * Print file header and dump original table header     */    AdDisassemblerHeader (Filename);    AcpiOsPrintf (" * Original Table Header:/n");    AcpiOsPrintf (" *     Signature        /"%4.4s/"/n",    Table->Signature);    AcpiOsPrintf (" *     Length           0x%8.8X (%u)/n", Table->Length, Table->Length);    /* Print and validate the revision */    AcpiOsPrintf (" *     Revision         0x%2.2X",      Table->Revision);    switch (Table->Revision)    {    case 0:        AcpiOsPrintf (" **** Invalid Revision");        break;    case 1:        /* Revision of DSDT controls the ACPI integer width */        if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))        {            AcpiOsPrintf (" **** 32-bit table (V1), no 64-bit math support");        }        break;    default:        break;    }    AcpiOsPrintf ("/n");    /* Print and validate the table checksum */    AcpiOsPrintf (" *     Checksum         0x%2.2X",        Table->Checksum);    Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);    if (Checksum)    {        AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",            (UINT8) (Table->Checksum - Checksum));    }    AcpiOsPrintf ("/n");    AcpiOsPrintf (" *     OEM ID           /"%.6s/"/n",     Table->OemId);    AcpiOsPrintf (" *     OEM Table ID     /"%.8s/"/n",     Table->OemTableId);    AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)/n", Table->OemRevision, Table->OemRevision);    AcpiOsPrintf (" *     Compiler ID      /"%.4s/"/n",     Table->AslCompilerId);    AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)/n", Table->AslCompilerRevision, Table->AslCompilerRevision);    AcpiOsPrintf (" *//n/n");    /* Create AML output filename based on input filename */    if (Filename)    {        NewFilename = FlGenerateFilename (Filename, "aml");    }    else    {        NewFilename = ACPI_ALLOCATE_ZEROED (9);        strncat (NewFilename, Table->Signature, 4);        strcat (NewFilename, ".aml");    }    /* Open the ASL definition block */    AcpiOsPrintf (        "DefinitionBlock (/"%s/", /"%4.4s/", %hu, /"%.6s/", /"%.8s/", 0x%8.8X)/n",        NewFilename, Table->Signature, Table->Revision,        Table->OemId, Table->OemTableId, Table->OemRevision);    ACPI_FREE (NewFilename);}

static char *AcpiDmNormalizeParentPrefix (    ACPI_PARSE_OBJECT       *Op,    char                    *Path){    ACPI_NAMESPACE_NODE     *Node;    char                    *Fullpath;    char                    *ParentPath;    ACPI_SIZE               Length;    UINT32                  Index = 0;    if (!Op)    {        return (NULL);    }    /* Search upwards in the parse tree until we reach the next namespace node */    Op = Op->Common.Parent;    while (Op)    {        if (Op->Common.Node)        {            break;        }        Op = Op->Common.Parent;    }    if (!Op)    {        return (NULL);    }    /*     * Find the actual parent node for the reference:     * Remove all carat prefixes from the input path.     * There may be multiple parent prefixes (For example, ^^^M000)     */    Node = Op->Common.Node;    while (Node && (*Path == (UINT8) AML_PARENT_PREFIX))    {        Node = Node->Parent;        Path++;    }    if (!Node)    {        return (NULL);    }    /* Get the full pathname for the parent node */    ParentPath = AcpiNsGetExternalPathname (Node);    if (!ParentPath)    {        return (NULL);    }    Length = (strlen (ParentPath) + strlen (Path) + 1);    if (ParentPath[1])    {        /*         * If ParentPath is not just a simple '/', increment the length         * for the required dot separator (ParentPath.Path)         */        Length++;        /* For External() statements, we do not want a leading '/' */        if (*ParentPath == AML_ROOT_PREFIX)        {            Index = 1;        }    }    Fullpath = ACPI_ALLOCATE_ZEROED (Length);    if (!Fullpath)    {        goto Cleanup;    }    /*     * Concatenate parent fullpath and path. For example,     * parent fullpath "/_SB_", Path "^INIT", Fullpath "/_SB_.INIT"     *     * Copy the parent path     */    strcpy (Fullpath, &ParentPath[Index]);    /*     * Add dot separator     * (don't need dot if parent fullpath is a single backslash)     */    if (ParentPath[1])    {        strcat (Fullpath, ".");    }//.........这里部分代码省略.........

ACPI_STATUSAcpiNsExternalizeName (    UINT32                  InternalNameLength,    const char              *InternalName,    UINT32                  *ConvertedNameLength,    char                    **ConvertedName){    UINT32                  NamesIndex = 0;    UINT32                  NumSegments = 0;    UINT32                  RequiredLength;    UINT32                  PrefixLength = 0;    UINT32                  i = 0;    UINT32                  j = 0;    ACPI_FUNCTION_TRACE (NsExternalizeName);    if (!InternalNameLength     ||        !InternalName           ||        !ConvertedName)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Check for a prefix (one '/' | one or more '^') */    switch (InternalName[0])    {    case AML_ROOT_PREFIX:        PrefixLength = 1;        break;    case AML_PARENT_PREFIX:        for (i = 0; i < InternalNameLength; i++)        {            if (ACPI_IS_PARENT_PREFIX (InternalName[i]))            {                PrefixLength = i + 1;            }            else            {                break;            }        }        if (i == InternalNameLength)        {            PrefixLength = i;        }        break;    default:        break;    }    /*     * Check for object names. Note that there could be 0-255 of these     * 4-byte elements.     */    if (PrefixLength < InternalNameLength)    {        switch (InternalName[PrefixLength])        {        case AML_MULTI_NAME_PREFIX_OP:            /* <count> 4-byte names */            NamesIndex = PrefixLength + 2;            NumSegments = (UINT8)                InternalName[(ACPI_SIZE) PrefixLength + 1];            break;        case AML_DUAL_NAME_PREFIX:            /* Two 4-byte names */            NamesIndex = PrefixLength + 1;            NumSegments = 2;            break;        case 0:            /* NullName */            NamesIndex = 0;            NumSegments = 0;            break;        default:            /* one 4-byte name */            NamesIndex = PrefixLength;            NumSegments = 1;            break;//.........这里部分代码省略.........

static ACPI_STATUSAcpiDmCreateNewExternal (    char                    *ExternalPath,    char                    *InternalPath,    UINT8                   Type,    UINT32                  Value,    UINT16                  Flags){    ACPI_EXTERNAL_LIST      *NewExternal;    ACPI_EXTERNAL_LIST      *NextExternal;    ACPI_EXTERNAL_LIST      *PrevExternal = NULL;    ACPI_FUNCTION_TRACE (DmCreateNewExternal);    /* Check all existing externals to ensure no duplicates */    NextExternal = AcpiGbl_ExternalList;    while (NextExternal)    {        /* Check for duplicates */        if (!strcmp (ExternalPath, NextExternal->Path))        {            /*             * If this external came from an External() opcode, we are             * finished with this one. (No need to check any further).             */            if (NextExternal->Flags & ACPI_EXT_ORIGIN_FROM_OPCODE)            {                return_ACPI_STATUS (AE_ALREADY_EXISTS);            }            /* Allow upgrade of type from ANY */            else if ((NextExternal->Type == ACPI_TYPE_ANY) &&                (Type != ACPI_TYPE_ANY))            {                NextExternal->Type = Type;            }            /* Update the argument count as necessary */            if (Value < NextExternal->Value)            {                NextExternal->Value = Value;            }            /* Update flags. */            NextExternal->Flags |= Flags;            NextExternal->Flags &= ~ACPI_EXT_INTERNAL_PATH_ALLOCATED;            return_ACPI_STATUS (AE_ALREADY_EXISTS);        }        NextExternal = NextExternal->Next;    }    /* Allocate and init a new External() descriptor */    NewExternal = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EXTERNAL_LIST));    if (!NewExternal)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,        "Adding external reference node (%s) type [%s]/n",        ExternalPath, AcpiUtGetTypeName (Type)));    NewExternal->Flags = Flags;    NewExternal->Value = Value;    NewExternal->Path = ExternalPath;    NewExternal->Type = Type;    NewExternal->Length = (UINT16) strlen (ExternalPath);    NewExternal->InternalPath = InternalPath;    /* Link the new descriptor into the global list, alphabetically ordered */    NextExternal = AcpiGbl_ExternalList;    while (NextExternal)    {        if (AcpiUtStricmp (NewExternal->Path, NextExternal->Path) < 0)        {            if (PrevExternal)            {                PrevExternal->Next = NewExternal;            }            else            {                AcpiGbl_ExternalList = NewExternal;            }            NewExternal->Next = NextExternal;            return_ACPI_STATUS (AE_OK);        }        PrevExternal = NextExternal;//.........这里部分代码省略.........

void *AcpiOsAcquireObject (    ACPI_MEMORY_LIST        *Cache){    ACPI_STATUS             Status;    void                    *Object;    ACPI_FUNCTION_TRACE (OsAcquireObject);    if (!Cache)    {        return_PTR (NULL);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES);    if (ACPI_FAILURE (Status))    {        return_PTR (NULL);    }    ACPI_MEM_TRACKING (Cache->Requests++);    /* Check the cache first */    if (Cache->ListHead)    {        /* There is an object available, use it */        Object = Cache->ListHead;        Cache->ListHead = ACPI_GET_DESCRIPTOR_PTR (Object);        Cache->CurrentDepth--;        ACPI_MEM_TRACKING (Cache->Hits++);        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "Object %p from %s cache/n", Object, Cache->ListName));        Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);        if (ACPI_FAILURE (Status))        {            return_PTR (NULL);        }        /* Clear (zero) the previously used Object */        memset (Object, 0, Cache->ObjectSize);    }    else    {        /* The cache is empty, create a new object */        ACPI_MEM_TRACKING (Cache->TotalAllocated++);#ifdef ACPI_DBG_TRACK_ALLOCATIONS        if ((Cache->TotalAllocated - Cache->TotalFreed) > Cache->MaxOccupied)        {            Cache->MaxOccupied = Cache->TotalAllocated - Cache->TotalFreed;        }#endif        /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */        Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES);        if (ACPI_FAILURE (Status))        {            return_PTR (NULL);        }        Object = ACPI_ALLOCATE_ZEROED (Cache->ObjectSize);        if (!Object)        {            return_PTR (NULL);        }    }    return_PTR (Object);}