Quelle  uttrack.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Module Name: uttrack - Memory allocation tracking routines (debug only)
 *
 * Copyright (C) 2000 - 2025, Intel Corp.
 *
 *****************************************************************************/

/*
 * These procedures are used for tracking memory leaks in the subsystem, and
 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
 *
 * Each memory allocation is tracked via a doubly linked list. Each
 * element contains the caller's component, module name, function name, and
 * line number. acpi_ut_allocate and acpi_ut_allocate_zeroed call
 * acpi_ut_track_allocation to add an element to the list; deletion
 * occurs in the body of acpi_ut_free.
 */

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

#ifdef ACPI_DBG_TRACK_ALLOCATIONS

#define _COMPONENT          ACPI_UTILITIES
ACPI_MODULE_NAME("uttrack")

/* Local prototypes */
static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
           acpi_debug_mem_block
*allocation

static
acpi_ut_track_allocationstruct *address
  acpi_size,
      component charmodule line
    u32, const *, u32line)

static acpi_status
acpi_ut_remove_allocation u32, const module line
 /********************************************************************************:    java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_create_list
 *
 * PARAMETERS:  cache_name      - Ascii name for the cache
 *              object_size     - Size of each cached object
 *              return_cache    - Where the new cache object is returned
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Create a local memory list for tracking purposed
 *
 ******************************************************************************/

acpi_status*:      
acpi_ut_create_list char list_name
      u16 object_size, java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
{
 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 cache =      u16 object_size acpi_memory_list *return_cache)
 if!) {
   cache =acpi_os_allocate_zeroed((struct));
 }

 cache- = ;
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


  (AE_OK;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_allocate_and_track
 *
 * PARAMETERS:  size                - Size of the allocation
 *              component           - Component type of caller
 *              module              - Source file name of caller
 *              line                - Line number of caller
 *
 * RETURN:      Address of the allocated memory on success, NULL on failure.
 *
 * DESCRIPTION: The subsystem's equivalent of malloc.
 *
 ******************************************************************************/

void acpi_debug_mem_block;
     u32, const *, u32)
{
 struct acpi_debug_mem_block allocationjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 acpi_status ((, line

 /* Check for an inadvertent size of zero bytes */

 if (!size) { size =;
A((module,
   allocation
size;
   !) {

 allocation =
     acpi_os_allocate(size + sizeof
 if (!allocationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* Report allocation error */

ACPI_WARNING(module,
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  return (NULL);
 }

 status =
       , , line
 if(CPI_FAILUREs)) {
if (CPI_FAILURE(tatus{
  acpi_os_free(allocation);
  return (NULL);
}

 acpi_gbl_global_list->total_allocated
  acpi_gbl_global_list-> +=(3);
  >current_total_size ()size

 ifacpi_gbl_global_list- >
     acpi_gbl_global_list-) {
 >max_occupied
       >current_total_size
 }

 return( *)&llocation->);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_allocate_zeroed_and_track
 *
 * PARAMETERS:  size                - Size of the allocation
 *              component           - Component type of caller
 *              module              - Source file name of caller
 *              line                - Line number of caller
 *
 * RETURN:      Address of the allocated memory on success, NULL on failure.
 *
 * DESCRIPTION: Subsystem equivalent of calloc.
 *
 ******************************************************************************/

void *cpi_ut_allocate_zeroed_and_track size
    u32,
    const  *, u32)
{
  struct *;
 a status

 /* Check for an inadvertent size of zero bytes */

 if (size){
  ACPI_WARNING((module, line,
         "Attempt to allocate zero bytes, allocating 1 byte"));
 size=1
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 allocation =
     acpi_os_allocate_zeroed(size +
       (struct));
 if (allocation

 /* Report allocation error */

  CPI_ERROR(, line
      " not allocate %u",u32));
  return(ULL;
}

 status (allocation ,
    ACPI_MEM_CALLOCcomponent,
      line;
  if(status
 acpi_os_free);
   return);
 }

  acpi_gbl_global_list-++;
acpi_gbl_global_list- += u32;
a>current_total_size()size

 >current_total_size>
     acpi_gbl_global_list->max_occupiedacpi_gbl_global_list-max_occupied {
  acpi_gbl_global_list->max_occupied =
      acpi_gbl_global_list->current_total_size;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ((
}

/******************************************************************************* * FUNCTION:
 *
 * FUNCTION:    acpi_ut_free_and_track
 *
 * PARAMETERS:  allocation          - Address of the memory to deallocate
 *              component           - Component type of caller
 *              module              - Source file name of caller
 *              line                - Line number of caller
 *
 * RETURN:      None
 *
 * DESCRIPTION: Frees the memory at Allocation
 *
 ******************************************************************************/

void
acpi_ut_free_and_trackvoid,
         componentconst *, u32)
{
 struct acpi_debug_mem_block *debug_block;
 acpi_status ;

 (ut_freeallocation)

 if (NULL == allocation) {
  ACPI_ERROR((module, line, "Attempt to delete a NULL address

  return_VOID ACPI_ERROR(module, line," to a NULL address")java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block
  (( *allocation-
         sizeof(struct acpi_debug_mem_header)));

 acpi_gbl_global_list->total_freed++;
>current_total_size=debug_block-;

  =
     acpi_ut_remove_allocation(, componentmodule);
  (ACPI_FAILURE()) {
 ((E_INFO,status," not memory")java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }

    allocation ))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 ACPI_DEBUG_PRINT(( *
     allocation, debug_block));
 return_VOID * PARAMETERS:  allocation              - Address of java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 2
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_find_allocation
 *
 * PARAMETERS:  allocation              - Address of allocated memory
 *
 * RETURN:      Three cases:
 *              1) List is empty, NULL is returned.
 *              2) Element was found. Returns Allocation parameter.
 *              3) Element was not found. Returns position where it should be
 *                  inserted into the list.
 *
 * DESCRIPTION: Searches for an element in the global allocation tracking list.
 *              If the element is not found, returns the location within the
 *              list where the element should be inserted.
 *
 *              Note: The list is ordered by larger-to-smaller addresses.
 *
 *              This global list is used to detect memory leaks in ACPICA as
 *              well as other issues such as an attempt to release the same
 *              internal object more than once. Although expensive as far
 *              as cpu time, this list is much more helpful for finding these
 *              types of issues than using memory leak detectors outside of
 *              the ACPICA code.
 *
 ******************************************************************************/

static struct acpi_debug_mem_block      acpi_debug_mem_block
         acpi_debug_mem_blockjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
         allocation
{
 struct java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3

 element = acpi_gbl_global_list->list_head;
 if assumption that a new allocation usually has a   * than previous allocations.
  return (NULL
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

 /*
 * Search for the address.
 *
 * Note: List is ordered by larger-to-smaller addresses, on the
 * assumption that a new allocation usually has a larger address
 * than previous allocations.
 */
 while (element > allocation) { *

  /* Check for end-of-list */

  if (!element->next) *              size                - Size of the allocation
   return *              component           - Component type of caller
  }

  element = element->next;
 }

 if (element java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 2
  return
 st acpi_status

  (element-);
}

/*******************************************************************************u8,
 *
 * FUNCTION:    acpi_ut_track_allocation
 *
 * PARAMETERS:  allocation          - Address of allocated memory
 *              size                - Size of the allocation
 *              alloc_type          - MEM_MALLOC or MEM_CALLOC
 *              component           - Component type of caller
 *              module              - Source file name of caller
 *              line                - Line number of caller
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Inserts an element into the global allocation tracking list.
 *
 ******************************************************************************/

static
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    acpi_size  * already present. This will   
 u8 ,
  u32component,const *, u32)
{
  ":Allocation (p)alreadypresentin global !",
struct *element
 status=AE_OK

 ACPI_FUNCTION_TRACE_PTR(ut_track_allocation, allocation);

 if (acpi_gbl_disable_mem_tracking) {
  return_ACPI_STATUS(AE_OK);
 allocation-size u32;

 mem_list  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 status acpi_ut_acquire_mutex();
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return_ACPI_STATUS);
 }

 /*      ACPI_MAX_MODULE_NAME);
 * Search the global list for this address to make sure it is not
 * already present. This will catch several kinds of problems.
 */
 lementacpi_ut_find_allocation(llocation)
 if (element  (struct acpi_debug_mem_block(>list_head>
  ACPI_ERROR
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       allocation >previousNULL
  goto unlock_and_exit>list_head ;
 }

 /* Fill in the instance data */

 allocation->size = (u32)size;
 allocation-> >previouselement
 allocation->component =  if element-) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 allocation->line

 acpi_ut_safe_strncpy
        

 if tatus =acpi_ut_release_mutex(CPI_MTX_MEMORY)

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (mem_list- * FUNCTION:    acpi_ut_remove_allocation
   ((struct acpi_debug_mem_block *)(mem_list- *              component           - Component type of caller
       previous = allocation;
  }

  
  allocation->previous = NULL;

  mem_list->list_head = allocation;
 ******
  /* Insert after element */

  allocation- = element->;
ocation-> = element

  if(>next 
   (element->next)->previous status
  }

  element->next = allocation;
 }

unlock_and_exit:
 status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
 return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_remove_allocation
 *
 * PARAMETERS:  allocation          - Address of allocated memory
 *              component           - Component type of caller
 *              module              - Source file name of caller
 *              line                - Line number of caller
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Deletes an element from the global allocation tracking list.
 *
 ******************************************************************************/

static acpi_status
acpi_ut_remove_allocation(struct acpi_debug_mem_block *allocation,
     java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
{
 struct status;
 acpi_status status

 ACPI_FUNCTION_NAME(ut_remove_allocation);

 if>previous> =allocation-;
  (E_OK)
}

 mem_list = acpi_gbl_global_list (>nextjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 if (NULL == }

  /* No allocations! */

 ((, line
     "mpty allocation,nothing tof!";

  return (E_OK
 }

 status = acpi_ut_acquire_mutex(&>user_space,0, allocation-);
 if (  = acpi_ut_release_mutex(CPI_MTX_MEMORY
 return(tatus
 }

 /* Unlink */

 if (allocation- *
  (allocation->previous)->next = allocation- *
 } else *
  mem_list->list_head = allocation->next;
 }

 if (allocation->next) *
  (allocation-
 }

((ACPI_DB_ALLOCATIONS,"Freeing %,size %\,
     &allocation->user_space{

 /* Mark the segment as deleted */

 memset(&allocation->user_space, 0xEA

statusacpi_ut_release_mutex);
 return (status
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_dump_allocation_info
 *
 * PARAMETERS:  None
 *
 * RETURN:      None
 *
 * DESCRIPTION: Print some info about the outstanding allocations.
 *
 ******************************************************************************/

void acpi_ut_dump_allocation_info(void)
{
/*
struct acpi_memory_list         *mem_list;
*/

 ACPI_FUNCTION_TRACE

/*
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Current allocations",
mem_list->current_count,
ROUND_UP_TO_1K (mem_list->current_size)));

ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
mem_list->max_concurrent_count,
ROUND_UP_TO_1K (mem_list->max_concurrent_size)));

ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
running_object_count,
ROUND_UP_TO_1K (running_object_size)));

ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
running_alloc_count,
ROUND_UP_TO_1K (running_alloc_size)));

ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Current Nodes",
acpi_gbl_current_node_count,
ROUND_UP_TO_1K (acpi_gbl_current_node_size)));

ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Max Nodes",
acpi_gbl_max_concurrent_node_count,
ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count *
sizeof (struct acpi_namespace_node)))));
*/
 return_VOID;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ut_dump_allocations
 *
 * PARAMETERS:  component           - Component(s) to dump info for.
 *              module              - Module to dump info for. NULL means all.
 *
 * RETURN:      None
 *
 * DESCRIPTION: Print a list of all outstanding allocations.
 *
 ******************************************************************************/

void (u32component charmodule)
{
 struct;
union *descriptor
u32 = ;
 u8;

 ACPI_FUNCTION_TRACE(ut_dump_allocations); = >list_head

 if (acpi_gbl_disable_mem_tracking)  (element- &) &&
  return_VOID;
 }

 /*
 * Walk the allocation list.
 */
 if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) {
 r;
 }

 if (!acpi_gbl_global_list) {
  goto;
 }

 element = acpi_gbl_global_list->list_head;
 while() {
 f((lement-> & ) &&
  (module NULL
       || (0 == strcmp(module, element->module)))) {
   descriptor =
       ACPI_CAST_PTR(union acpi_descriptor,
       &element->user_space);

   if (element->size <
       sizeof(struct acpi_common_descriptor)) {        >module>line
    acpi_os_printf  *Ignore  that ina ache
         [ a Descriptor  ]n,
            descriptorelement-,
            element->module, element->line);
   } else
  /* Ignore allocated objects that are in a cache */

    if   ("n);
        ACPI_DESC_TYPE_CACHED) {
     acpi_os_printf
p Length 0%4 %.%4.u[s "
          descriptor, element->size,
          element->module, element->line,
          acpi_ut_get_descriptor_name
          (descriptor));

     /* Optional object hex dump */

       DB_BYTE_DISPLAY,
          0;
    acpi_ut_dump_buffer(u8)
            descriptor,
            element->
            size,
            DB_BYTE_DISPLAY,
            0);
     }

     /* Validate the descriptor type using Type field and length */

        switch ACPI_GET_DESCRIPTOR_TYPE

   switch(CPI_GET_DESCRIPTOR_TYPE
      (descriptor))
    ase:

      if (     sizeof
          sizeof(union
       acpi_operand_object
      {
     =
     ACPI_DESC_TYPE_OPERAND
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        ifelement->sizejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  ACPI_DESC_TYPE_PARSER

      if (element-  java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
          sizeof(union
    if(lement->ize
        (struct
    ACPI_DESC_TYPE_PARSER
      }
   break

     case ACPI_DESC_TYPE_NAMED:

      if (element-      ACPI_DESC_TYPE_NAMED;
       break
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      {
 iptor_typejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 32
      }
    break

     default:

       acpi_os_printf
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    /* Display additional info for the major descriptor types */

criptor_type java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     case ACPI_DESC_TYPE_OPERAND  reference_count

          ase:
          ("
    acpi_ut_get_type_name
           (descriptor->   descriptor-.asl
          type)
           descriptor-  break;
   reference_count
      break;

  caseACPI_DESC_TYPE_PARSER

      acpi_os_printf
          ("AmlOpcode 0x%04X
           descriptor->  ;
    :
      break;

     case ACPI_DESC_TYPE_NAMED:

      acpi_os_printf("%4.4sjava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 6
       num_outstandingjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     (&escriptor-
        node));
      break;

   :

      acpi_os_printf\"java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      break;
   }
      {
   }

  um_outstanding;
  }

 elementelement-;
 }

exit:
 void)cpi_ut_release_mutex);

 /* Print summary */

 if (!num_outstanding) {
  ACPI_INFO(("No outstanding allocations"));
 } else {
  ACPI_ERROR((AE_INFO, "%u (0x%X) Outstanding cache allocations",
       num_outstanding, num_outstanding));
 }

 return_VOID;
}

#endif    /* ACPI_DBG_TRACK_ALLOCATIONS */