nsnames.c File Reference

#include "acpi.h"
#include "accommon.h"
#include "amlcode.h"
#include "acnamesp.h"

Include dependency graph for nsnames.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_NAMESPACE
#define	ACPI_PATH_PUT8(Path, Size, Byte, Length)

Functions
char *	AcpiNsGetExternalPathname (ACPI_NAMESPACE_NODE *Node)
ACPI_SIZE	AcpiNsGetPathnameLength (ACPI_NAMESPACE_NODE *Node)
ACPI_STATUS	AcpiNsHandleToName (ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer)
ACPI_STATUS	AcpiNsHandleToPathname (ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer, BOOLEAN NoTrailing)
UINT32	AcpiNsBuildNormalizedPath (ACPI_NAMESPACE_NODE *Node, char *FullPath, UINT32 PathSize, BOOLEAN NoTrailing)
char *	AcpiNsGetNormalizedPathname (ACPI_NAMESPACE_NODE *Node, BOOLEAN NoTrailing)
char *	AcpiNsBuildPrefixedPathname (ACPI_GENERIC_STATE *PrefixScope, const char *InternalPath)
void	AcpiNsNormalizePathname (char *OriginalPath)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_NAMESPACE

Definition at line 50 of file nsnames.c.

ACPI_PATH_PUT8

#define ACPI_PATH_PUT8	(		Path,
			Size,
			Byte,
			Length
	)

Value:

    do {                                            \
        if ((Length) < (Size))                      \
        {                                           \
            (Path)[(Length)] = (Byte);              \
        }                                           \
        (Length)++;                                 \
    } while (0)

Function Documentation

AcpiNsBuildNormalizedPath()

UINT32 AcpiNsBuildNormalizedPath	(	ACPI_NAMESPACE_NODE *	Node,
		char *	FullPath,
		UINT32	PathSize,
		BOOLEAN	NoTrailing
	)

Definition at line 256 of file nsnames.c.

{
    UINT32                  Length = 0, i;
    char                    Name[ACPI_NAMESEG_SIZE];
    BOOLEAN                 DoNoTrailing;
    char                    c, *Left, *Right;
    ACPI_NAMESPACE_NODE     *NextNode;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsBuildNormalizedPath, Node);
 
 
#define ACPI_PATH_PUT8(Path, Size, Byte, Length)    \
    do {                                            \
        if ((Length) < (Size))                      \
        {                                           \
            (Path)[(Length)] = (Byte);              \
        }                                           \
        (Length)++;                                 \
    } while (0)
 
    /*
     * Make sure the PathSize is correct, so that we don't need to
     * validate both FullPath and PathSize.
     */
    if (!FullPath)
    {
        PathSize = 0;
    }
 
    if (!Node)
    {
        goto BuildTrailingNull;
    }
 
    NextNode = Node;
    while (NextNode && NextNode != AcpiGbl_RootNode)
    {
        if (NextNode != Node)
        {
            ACPI_PATH_PUT8(FullPath, PathSize, AML_DUAL_NAME_PREFIX, Length);
        }
 
        ACPI_MOVE_32_TO_32 (Name, &NextNode->Name);
        DoNoTrailing = NoTrailing;
        for (i = 0; i < 4; i++)
        {
            c = Name[4-i-1];
            if (DoNoTrailing && c != '_')
            {
                DoNoTrailing = FALSE;
            }
            if (!DoNoTrailing)
            {
                ACPI_PATH_PUT8(FullPath, PathSize, c, Length);
            }
        }
 
        NextNode = NextNode->Parent;
    }
 
    ACPI_PATH_PUT8(FullPath, PathSize, AML_ROOT_PREFIX, Length);
 
    /* Reverse the path string */
 
    if (Length <= PathSize)
    {
        Left = FullPath;
        Right = FullPath+Length - 1;
 
        while (Left < Right)
        {
            c = *Left;
            *Left++ = *Right;
            *Right-- = c;
        }
    }
 
    /* Append the trailing null */
 
BuildTrailingNull:
    ACPI_PATH_PUT8 (FullPath, PathSize, '\0', Length);
 
#undef ACPI_PATH_PUT8
 
    return_UINT32 (Length);
}

Referenced by AcpiNsGetNormalizedPathname(), AcpiNsGetPathnameLength(), and AcpiNsHandleToPathname().

AcpiNsBuildPrefixedPathname()

char * AcpiNsBuildPrefixedPathname	(	ACPI_GENERIC_STATE *	PrefixScope,
		const char *	InternalPath
	)

Definition at line 423 of file nsnames.c.

{
    ACPI_STATUS             Status;
    char                    *FullPath = NULL;
    char                    *ExternalPath = NULL;
    char                    *PrefixPath = NULL;
    ACPI_SIZE               PrefixPathLength = 0;
 
 
    /* If there is a prefix, get the pathname to it */
 
    if (PrefixScope && PrefixScope->Scope.Node)
    {
        PrefixPath = AcpiNsGetNormalizedPathname (PrefixScope->Scope.Node, TRUE);
        if (PrefixPath)
        {
            PrefixPathLength = strlen (PrefixPath);
        }
    }
 
    Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, InternalPath,
        NULL, &ExternalPath);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Merge the prefix path and the path. 2 is for one dot and trailing null */
 
    FullPath = ACPI_ALLOCATE_ZEROED (
        PrefixPathLength + strlen (ExternalPath) + 2);
    if (!FullPath)
    {
        goto Cleanup;
    }
 
    /* Don't merge if the External path is already fully qualified */
 
    if (PrefixPath &&
        (*ExternalPath != '\\') &&
        (*ExternalPath != '^'))
    {
        strcat (FullPath, PrefixPath);
        if (PrefixPath[1])
        {
            strcat (FullPath, ".");
        }
    }
 
    AcpiNsNormalizePathname (ExternalPath);
    strcat (FullPath, ExternalPath);
 
Cleanup:
    if (PrefixPath)
    {
        ACPI_FREE (PrefixPath);
    }
    if (ExternalPath)
    {
        ACPI_FREE (ExternalPath);
    }
 
    return (FullPath);
}

Referenced by AcpiUtPrefixedNamespaceError().

AcpiNsGetExternalPathname()

char * AcpiNsGetExternalPathname

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 70 of file nsnames.c.

{
    char                    *NameBuffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetExternalPathname, Node);
 
 
    NameBuffer = AcpiNsGetNormalizedPathname (Node, FALSE);
    return_PTR (NameBuffer);
}

Referenced by AcpiDsExecEndOp(), AcpiDsGetFieldNames(), AcpiDsLoad2EndOp(), and AcpiEvaluateObjectTyped().

AcpiNsGetNormalizedPathname()

char * AcpiNsGetNormalizedPathname	(	ACPI_NAMESPACE_NODE *	Node,
		BOOLEAN	NoTrailing
	)

Definition at line 367 of file nsnames.c.

{
    char                    *NameBuffer;
    ACPI_SIZE               Size;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetNormalizedPathname, Node);
 
 
    /* Calculate required buffer size based on depth below root */
 
    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);
    if (!Size)
    {
        return_PTR (NULL);
    }
 
    /* Allocate a buffer to be returned to caller */
 
    NameBuffer = ACPI_ALLOCATE_ZEROED (Size);
    if (!NameBuffer)
    {
        ACPI_ERROR ((AE_INFO,
            "Could not allocate %u bytes", (UINT32) Size));
        return_PTR (NULL);
    }
 
    /* Build the path in the allocated buffer */
 
    (void) AcpiNsBuildNormalizedPath (Node, NameBuffer, (UINT32) Size, NoTrailing);
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "%s: Path \"%s\"\n",
        ACPI_GET_FUNCTION_NAME, NameBuffer));
 
    return_PTR (NameBuffer);
}

Referenced by AcpiDsCallControlMethod(), AcpiExStartTraceMethod(), AcpiExStopTraceMethod(), AcpiNsBuildPrefixedPathname(), AcpiNsEvaluate(), AcpiNsExecuteTable(), AcpiNsGetExternalPathname(), AcpiNsInitOneDevice(), AcpiNsSearchOneScope(), and AcpiUtCheckAddressRange().

AcpiNsGetPathnameLength()

ACPI_SIZE AcpiNsGetPathnameLength

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 97 of file nsnames.c.

{
    ACPI_SIZE               Size;
 
 
    /* Validate the Node */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid/cached reference target node: %p, descriptor type %d",
            Node, ACPI_GET_DESCRIPTOR_TYPE (Node)));
        return (0);
    }
 
    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, FALSE);
    return (Size);
}

Referenced by AcpiRsGetPciRoutingTableLength(), and AcpiUtGetSimpleObjectSize().

AcpiNsHandleToName()

ACPI_STATUS AcpiNsHandleToName	(	ACPI_HANDLE	TargetHandle,
		ACPI_BUFFER *	Buffer
	)

Definition at line 133 of file nsnames.c.

{
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *Node;
    const char              *NodeName;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsHandleToName, TargetHandle);
 
 
    Node = AcpiNsValidateHandle (TargetHandle);
    if (!Node)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Validate/Allocate/Clear caller buffer */
 
    Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Just copy the ACPI name from the Node and zero terminate it */
 
    NodeName = AcpiUtGetNodeName (Node);
    ACPI_COPY_NAMESEG (Buffer->Pointer, NodeName);
    ((char *) Buffer->Pointer) [ACPI_NAMESEG_SIZE] = 0;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%4.4s\n", (char *) Buffer->Pointer));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiGetName().

AcpiNsHandleToPathname()

ACPI_STATUS AcpiNsHandleToPathname	(	ACPI_HANDLE	TargetHandle,
		ACPI_BUFFER *	Buffer,
		BOOLEAN	NoTrailing
	)

Definition at line 187 of file nsnames.c.

{
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_SIZE               RequiredSize;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsHandleToPathname, TargetHandle);
 
 
    Node = AcpiNsValidateHandle (TargetHandle);
    if (!Node)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Determine size required for the caller buffer */
 
    RequiredSize = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);
    if (!RequiredSize)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Validate/Allocate/Clear caller buffer */
 
    Status = AcpiUtInitializeBuffer (Buffer, RequiredSize);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Build the path in the caller buffer */
 
    (void) AcpiNsBuildNormalizedPath (Node, Buffer->Pointer,
        (UINT32) RequiredSize, NoTrailing);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s [%X]\n",
        (char *) Buffer->Pointer, (UINT32) RequiredSize));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiGetName(), AcpiNsPrintNodePathname(), and AcpiRsCreatePciRoutingTable().

AcpiNsNormalizePathname()

void AcpiNsNormalizePathname

(

char *

OriginalPath

)

Definition at line 506 of file nsnames.c.

{
    char                    *InputPath = OriginalPath;
    char                    *NewPathBuffer;
    char                    *NewPath;
    UINT32                  i;
 
 
    /* Allocate a temp buffer in which to construct the new path */
 
    NewPathBuffer = ACPI_ALLOCATE_ZEROED (strlen (InputPath) + 1);
    NewPath = NewPathBuffer;
    if (!NewPathBuffer)
    {
        return;
    }
 
    /* Special characters may appear at the beginning of the path */
 
    if (*InputPath == '\\')
    {
        *NewPath = *InputPath;
        NewPath++;
        InputPath++;
    }
 
    while (*InputPath == '^')
    {
        *NewPath = *InputPath;
        NewPath++;
        InputPath++;
    }
 
    /* Remainder of the path */
 
    while (*InputPath)
    {
        /* Do one nameseg at a time */
 
        for (i = 0; (i < ACPI_NAMESEG_SIZE) && *InputPath; i++)
        {
            if ((i == 0) || (*InputPath != '_')) /* First char is allowed to be underscore */
            {
                *NewPath = *InputPath;
                NewPath++;
            }
 
            InputPath++;
        }
 
        /* Dot means that there are more namesegs to come */
 
        if (*InputPath == '.')
        {
            *NewPath = *InputPath;
            NewPath++;
            InputPath++;
        }
    }
 
    *NewPath = 0;
    strcpy (OriginalPath, NewPathBuffer);
    ACPI_FREE (NewPathBuffer);
}

Referenced by AcpiNsBuildPrefixedPathname().