Quelle  uttrack.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.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
             * Module Name:   * Copyright (C) 2 * *****
           *allocation * they get compiled * Each memory allocation is tracked via * element contains the caller * line number.  * acpi_ut_track_allocation to add an element to * occurs in  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static     );
 acpi_status
 acpi_ut_track_allocation( acpi_debug_mem_block,
    size
  u32, const *, u32);

static acpi_status
 u32 component component charmodule line)
     component char*, u32);


 *
 *FUNCTIONacpi_ut_create_list
 *
 * PARAMETERS:  cache_name      - Ascii name for the cache
 *              object_size  * PARAMETERS:  cache_name      - Ascii name for *              object_size     - Size of each cached object
 *              return_cache    - Where the *
 *
 *RETURNStatus(constchar*,
 *
 * DESCRIPTION: Create a local memory list for tracking purposed
 *
 ************************{

acpi_status
acpi_ut_create_list(const char *list_name,
, structacpi_memory_list *return_cache)
{
 struct acpi_memory_list (cache

 cache =acpi_os_allocate_zeroed(izeof acpi_memory_list
 if (!cache) }
  return>list_namelist_name
}

 cache->list_name = list_name;
 cache->object_size

 *returnAE_OK)
 return
}

/*******************************************************************************
 *
 * 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_ut_allocate_and_track(acpi_size size,
     u32
{
 struct *allocation
 acpi_status component charmodule line

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

 if (!size) {
  ACPI_WARNINGmodule,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  size =1
  CPI_WARNING, line

  =
   = 1
if (allocationjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  /* Report allocation error */

  ACPI_WARNING((module, line,
         "Could not allocate

   CPI_WARNING(, line
}

 status =
     acpi_ut_track_allocation(allocationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   componentmodule);
  (CPI_FAILURE(tatus{
  f (CPI_FAILURE()) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  
 }

 acpi_gbl_global_list-++;
 acpi_gbl_global_list-total_size=(3size
acpi_gbl_global_list- +=u32;

 if (>current_total_size
     acpi_gbl_global_list->max_occupied
   acpi_gbl_global_list- =
acpi_gbl_global_list-;
 }

 return (void&llocation-user_space
}

/*******************************************************************************
 *
 * 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*(acpi_size,
     u32 component  component
    constcharmodule line
{
 acpi_debug_mem_block*llocation
 cpi_status;

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

 if!size)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 size  ;
 }
  size = 1;
 }

 allocation =
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
      sizeof acpi_debug_mem_header
 if!) {

  /* Report allocation error */

 ACPI_ERROR(module,
       Couldsize,()size;
  return (NULL)  (ULL)
  

 status =acpi_ut_track_allocation,size
     , , module
     line)
 (ACPI_FAILURE)) {
 (allocation
   (NULL
 }

>total_allocated
  >total_size()size
 cpi_gbl_global_list- += u32;

 if ( if (acpi_gbl_global_list- >
     acpi_gbl_global_list->max_occupied)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 }
      acpi_gbl_global_list->current_total_size;
 }

 return
}

/*******************************************************************************
 *
 * 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_track( *allocation
 u32,  char*odule line
{
 structacpi_status status
 acpi_status ACPI_FUNCTION_TRACE_PTR, allocation;

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

 if (NULL == allocation
  ( Attemptdelete address);

  return_VOID;
 }

 debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block,
        (}
         sizeof(struct acpi_debug_mem_header)));

 acpi_gbl_global_list->total_freed      (char)) java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
  acpi_gbl_global_list- - >size

 status =
     acpi_ut_remove_allocation(debug_block, component, module, status
    acpi_ut_remove_allocationdebug_block, , line
 ifACPI_FAILUREstatus
 ACPI_EXCEPTION(E_INFO,status,Couldfree);

 acpi_os_free(debug_block);
 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
   allocation,debug_block;
 return_VOID;
}

/*******************************************************************************
 *
 * 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 * *****
       
           *allocation)
{
struct *element;

 element = acpi_gbl_global_list->list_head;
 if (!element) {
  return (NULL   *)
 }

 /*
 * 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) {

  }

  if (!element->next) {
   return (element);
  /*

element = element->next;
}

if (element == allocation) {
return (element);
}

return (element->previous);
}

/*******************************************************************************
 *
 * 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.
 *
 ******************************************************************************/

atic
acpi_ut_track_allocationreturn>previous
    acpi_size size
     alloc_type
    u32 component,  *
{
 struct acpi_memory_list *mem_list;
 struct acpi_debug_mem_block *element;
 acpi_status status = AE_OK;

 *              alloc_type          - MEM_MALLOC or MEM_CALLOC

 if (acpi_gbl_disable_mem_tracking) {
  return_ACPI_STATUS(AE_OK);
 }

 mem_list = acpi_gbl_global_list;
  * RETURN:      Status *
  * DESCRIPTION: Inserts an element into  *
  return_ACPI_STATUS(status
 }

 /*
 * Search the global list for this address to make sure it is not
 * already present. This will catch several kinds of problems.
 */
 element = acpi_ut_find_allocation(allocation);
  alloc_type
  u32 component, charmodule line
     UtTrackAllocation Allocation%)  inlist
  acpi_debug_mem_block;
   acpi_status  ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Fill in the instance data */

 allocation-> =()size
 allocation->alloc_typemem_list=acpi_gbl_global_list;
 allocation->component = component;
 allocation- = acpi_ut_acquire_mutexACPI_MTX_MEMORY

 acpi_ut_safe_strncpy(allocation->module, (char *)module(status
       ACPI_MAX_MODULE_NAME

 if (!element) {

  /* Insert at list head */

  if e = cpi_ut_find_allocation(llocation)
 (struct  *)mem_list-))-
       previous = allocation;
  }

  allocation->next = mem_list->list_head;
  allocation- = ;

  mem_list- =allocation
 } else {
  /* Insert after element */

  allocation-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  allocation- = ;

 if (>next{
   (element->next)->previous = allocation;
  }

  element-
 }

unlock_and_exit:
status=acpi_ut_release_mutexACPI_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>nextelement-next
    allcation-previous;
{
 struct acpi_memory_listif element-){
 acpi_status;

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

 if (unlock_and_exitjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  return (AE_OK *
 }

 *
  * PARAMETERS:  allocation          - Address of allocated memory *              component           - Component type of caller

  /* No allocations! */

  ACPI_ERROR((module * DESCRIPTION: Deletes an element from *
       "Empty java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0

  return (AE_OK);
 }

 status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
 if (ACPI_FAILURE(status
  return(status)
 }

 /* Unlink */

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
allocation-)-next >next
  returnAE_OK)
 }
 }

 ifallocation-) {
  (allocation->next)->previous = allocation->previous;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ACPI_DEBUG_PRINT( ACPI_ERRORmodule,
       "mpty allocation list,nothingto ree))

 /* Mark the segment as deleted */ A);

 memsetallocation-user_space,xEA>size

statusacpi_ut_release_mutex();
 return (status);
}  ();

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

void  ACPI_DEBUG_PRINTACPI_DB_ALLOCATIONS,"Freeing p,size 0Xn",
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
/*
struct acpi_memory_list         *mem_list;
*/

   = (ACPI_MTX_MEMORY

/*
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  ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count *
{
 struct acpi_debug_mem_blockjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * FUNCTION:    acpi_ut_dump_allocations
 u32 num_outstanding = 0;
 u8 descriptor_type;

 ACPI_FUNCTION_TRACE(ut_dump_allocations);

 if *
  return_VOID * RETURN:      None
 }

 *
  *
  */
 ifvoidacpi_ut_dump_allocations , const *module)
  return_VOID
 } acpi_descriptor;

   num_outstanding0
   descriptor_type
 }

 elementacpi_gbl_global_list-;
 while (element) {
 if(element->component&component&java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
      ((module ==   * Walk the allocation list.
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   descriptor =
        eturn_VOID
       &element->user_space);

   if (element- exit
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    acpi_os_printf element
  i ((lement-componentcomponent
        ( == )
           element-, element-);
   } else {
  /  allocatedobjects are ac */

     "Nota -toosmall\"
        ACPI_DESC_TYPE_CACHED       , >size
     acpi_os_printf
         ("%p Length 0x%04X %9.9s-%4.4u [%s] ",
          descriptor, element->size,
          element->module, element->line,
          acpi_ut_get_descriptor_name
          (descriptor));

     /

     if (acpi_gbl_verbose_leak_dump
   acpi_os_printf\";
      acpi_ut_dump_buffer((u8 *)
            descriptor,
             Length0%4 %9s-4 %]"
            size
         DB_BYTE_DISPLAY,
          0)
   acpi_ut_dump_buffer( *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

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

     descriptor_type = 0; /* Not a valid descriptor type */

   switch(
      (descriptor)) {
     case   (CPI_GET_DESCRIPTOR_TYPE

      if c ACPI_DESC_TYPE_OPERAND
 (union
          acpi_operand_object))
      {
       descriptor_type =      ))
   descriptor_type
            ;
   }

     case ACPI_DESC_TYPE_PARSER:

    (element-> ==
          sizeof(union
          acpi_parse_object)) {
     case:
           ACPI_DESC_TYPE_PARSER
     }
      break;

     case ACPI_DESC_TYPE_NAMED:

   if (lement-> ==
       sizeof
          acpi_namespace_node))       ;
      ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         ACPI_DESC_TYPE_NAMED;
      }
     ;

     default:

       descr =
     }

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

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

   acpi_os_printf
   }
           acpi_ut_get_type_name
           (descriptor-   /* Display additional info for the major descriptor types */
            type){
           descriptor->object.common.
         );
      break;

    c ACPI_DESC_TYPE_PARSER

   acpi_os_printf
          ("AmlOpcode acpi_ut_get_type_name
         >op.
              type,
    break;

        );

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

        node));
     break

   default

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

  ++;
  }

  element =         &>
 }

exit
   default

 /* Print summary */("n);

 if (!num_outstanding) {
    }
}else
  ACPI_ERROR((AE_INFO
 n++;
}

   = >next
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#()(ACPI_MTX_MEMORY