Quelle  exnames.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: exnames - interpreter/scanner name load/execute
 *
 * Copyright (C) 2000 - 2025, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acinterp.h"
#include "amlcode.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exnames")

/* Local prototypes */
static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs);

static acpi_status acpi_ex_name_segment(u8 **in_aml_address, char *name_string);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_allocate_name_string
 *
 * PARAMETERS:  prefix_count        - Count of parent levels. Special cases:
 *                                    (-1)==root,  0==none
 *              num_name_segs       - count of 4-character name segments
 *
 * RETURN:      A pointer to the allocated string segment. This segment must
 *              be deleted by the caller.
 *
 * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
 *              string is long enough, and set up prefix if any.
 *
 ******************************************************************************/

static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs)
{
 char *temp_ptr;
 char *name_string;
 u32 size_needed;

 ACPI_FUNCTION_TRACE(ex_allocate_name_string);

 /*
  * Allow room for all \ and ^ prefixes, all segments and a multi_name_prefix.
  * Also, one byte for the null terminator.
  * This may actually be somewhat longer than needed.
 */
 if (prefix_count == ACPI_UINT32_MAX) {

  /* Special case for root */

  size_needed = 1 + (ACPI_NAMESEG_SIZE * num_name_segs) + 2 + 1;
 } else {
  size_needed =
      prefix_count + (ACPI_NAMESEG_SIZE * num_name_segs) + 2 + 1;
 }

 /*
  * Allocate a buffer for the name.
  * This buffer must be deleted by the caller!
 */
 name_string = ACPI_ALLOCATE(size_needed);
 if (!name_string) {
  ACPI_ERROR((AE_INFO,
       "Could not allocate size %u", size_needed));
  return_PTR(NULL);
 }

 temp_ptr = name_string;

 /* Set up Root or Parent prefixes if needed */

 if (prefix_count == ACPI_UINT32_MAX) {
  *temp_ptr++ = AML_ROOT_PREFIX;
 } else {
  while (prefix_count--) {
   *temp_ptr++ = AML_PARENT_PREFIX;
  }
 }

 /* Set up Dual or Multi prefixes if needed */

 if (num_name_segs > 2) {

  /* Set up multi prefixes   */

  *temp_ptr++ = AML_MULTI_NAME_PREFIX;
  *temp_ptr++ = (char)num_name_segs;
 } else if (2 == num_name_segs) {

  /* Set up dual prefixes */

  *temp_ptr++ = AML_DUAL_NAME_PREFIX;
 }

 /*
  * Terminate string following prefixes. acpi_ex_name_segment() will
  * append the segment(s)
 */
 *temp_ptr = 0;

 return_PTR(name_string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_name_segment
 *
 * PARAMETERS:  in_aml_address  - Pointer to the name in the AML code
 *              name_string     - Where to return the name. The name is appended
 *                                to any existing string to form a namepath
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Extract an ACPI name (4 bytes) from the AML byte stream
 *
 ******************************************************************************/

static acpi_status acpi_ex_name_segment(u8 ** in_aml_address, char *name_string)
{
 char *aml_address = (void *)*in_aml_address;
 acpi_status status = AE_OK;
 u32 index;
 char char_buf[5];

 ACPI_FUNCTION_TRACE(ex_name_segment);

 /*
  * If first character is a digit, then we know that we aren't looking
  * at a valid name segment
 */
 char_buf[0] = *aml_address;

 if ('0' <= char_buf[0] && char_buf[0] <= '9') {
  ACPI_ERROR((AE_INFO, "Invalid leading digit: %c", char_buf[0]));
  return_ACPI_STATUS(AE_CTRL_PENDING);
 }

 for (index = 0;
      (index < ACPI_NAMESEG_SIZE)
      && (acpi_ut_valid_name_char(*aml_address, 0)); index++) {
  char_buf[index] = *aml_address++;
 }

 /* Valid name segment  */

 if (index == 4) {

  /* Found 4 valid characters */

  char_buf[4] = '\0';

  if (name_string) {
   ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
       "Appending NameSeg %s\n", char_buf));
   strcat(name_string, char_buf);
  } else {
   ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
       "No Name string - %s\n", char_buf));
  }
 } else if (index == 0) {
  /*
   * First character was not a valid name character,
   * so we are looking at something other than a name.
 */
  ACPI_DEBUG_PRINT((ACPI_DB_INFO,
      "Leading character is not alpha: %02Xh (not a name)\n",
      char_buf[0]));
  status = AE_CTRL_PENDING;
 } else {
  /*
   * Segment started with one or more valid characters, but fewer than
   * the required 4
 */
  status = AE_AML_BAD_NAME;
  ACPI_ERROR((AE_INFO,
       "Bad character 0x%02x in name, at %p",
       *aml_address, aml_address));
 }

 *in_aml_address = ACPI_CAST_PTR(u8, aml_address);
 return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_get_name_string
 *
 * PARAMETERS:  data_type           - Object type to be associated with this
 *                                    name
 *              in_aml_address      - Pointer to the namestring in the AML code
 *              out_name_string     - Where the namestring is returned
 *              out_name_length     - Length of the returned string
 *
 * RETURN:      Status, namestring and length
 *
 * DESCRIPTION: Extract a full namepath from the AML byte stream,
 *              including any prefixes.
 *
 ******************************************************************************/

acpi_status
acpi_ex_get_name_string(acpi_object_type data_type,
   u8 * in_aml_address,
   char **out_name_string, u32 * out_name_length)
{
 acpi_status status = AE_OK;
 u8 *aml_address = in_aml_address;
 char *name_string = NULL;
 u32 num_segments;
 u32 prefix_count = 0;
 u8 has_prefix = FALSE;

 ACPI_FUNCTION_TRACE_PTR(ex_get_name_string, aml_address);

 if (ACPI_TYPE_LOCAL_REGION_FIELD == data_type ||
     ACPI_TYPE_LOCAL_BANK_FIELD == data_type ||
     ACPI_TYPE_LOCAL_INDEX_FIELD == data_type) {

  /* Disallow prefixes for types associated with field_unit names */

  name_string = acpi_ex_allocate_name_string(0, 1);
  if (!name_string) {
   status = AE_NO_MEMORY;
  } else {
   status =
       acpi_ex_name_segment(&aml_address, name_string);
  }
 } else {
  /*
   * data_type is not a field name.
   * Examine first character of name for root or parent prefix operators
 */
  switch (*aml_address) {
  case AML_ROOT_PREFIX:

   ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
       "RootPrefix(\\) at %p\n",
       aml_address));

   /*
    * Remember that we have a root_prefix --
    * see comment in acpi_ex_allocate_name_string()
 */
   aml_address++;
   prefix_count = ACPI_UINT32_MAX;
   has_prefix = TRUE;
   break;

  case AML_PARENT_PREFIX:

   /* Increment past possibly multiple parent prefixes */

   do {
    ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
        "ParentPrefix (^) at %p\n",
        aml_address));

    aml_address++;
    prefix_count++;

   } while (*aml_address == AML_PARENT_PREFIX);

   has_prefix = TRUE;
   break;

  default:

   /* Not a prefix character */

   break;
  }

  /* Examine first character of name for name segment prefix operator */

  switch (*aml_address) {
  case AML_DUAL_NAME_PREFIX:

   ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
       "DualNamePrefix at %p\n",
       aml_address));

   aml_address++;
   name_string =
       acpi_ex_allocate_name_string(prefix_count, 2);
   if (!name_string) {
    status = AE_NO_MEMORY;
    break;
   }

   /* Indicate that we processed a prefix */

   has_prefix = TRUE;

   status =
       acpi_ex_name_segment(&aml_address, name_string);
   if (ACPI_SUCCESS(status)) {
    status =
        acpi_ex_name_segment(&aml_address,
        name_string);
   }
   break;

  case AML_MULTI_NAME_PREFIX:

   ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
       "MultiNamePrefix at %p\n",
       aml_address));

   /* Fetch count of segments remaining in name path */

   aml_address++;
   num_segments = *aml_address;

   name_string =
       acpi_ex_allocate_name_string(prefix_count,
        num_segments);
   if (!name_string) {
    status = AE_NO_MEMORY;
    break;
   }

   /* Indicate that we processed a prefix */

   aml_address++;
   has_prefix = TRUE;

   while (num_segments &&
          (status =
    acpi_ex_name_segment(&aml_address,
           name_string)) == AE_OK) {
    num_segments--;
   }

   break;

  case 0:

   /* null_name valid as of 8-12-98 ASL/AML Grammar Update */

   if (prefix_count == ACPI_UINT32_MAX) {
    ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
        "NameSeg is \"\\\" followed by NULL\n"));
   }

   /* Consume the NULL byte */

   aml_address++;
   name_string =
       acpi_ex_allocate_name_string(prefix_count, 0);
   if (!name_string) {
    status = AE_NO_MEMORY;
    break;
   }

   break;

  default:

   /* Name segment string */

   name_string =
       acpi_ex_allocate_name_string(prefix_count, 1);
   if (!name_string) {
    status = AE_NO_MEMORY;
    break;
   }

   status =
       acpi_ex_name_segment(&aml_address, name_string);
   break;
  }
 }

 if (AE_CTRL_PENDING == status && has_prefix) {

  /* Ran out of segments after processing a prefix */

  ACPI_ERROR((AE_INFO, "Malformed Name at %p", name_string));
  status = AE_AML_BAD_NAME;
 }

 if (ACPI_FAILURE(status)) {
  if (name_string) {
   ACPI_FREE(name_string);
  }
  return_ACPI_STATUS(status);
 }

 *out_name_string = name_string;
 *out_name_length = (u32) (aml_address - in_aml_address);

 return_ACPI_STATUS(status);
}