| // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
| /****************************************************************************** |
| * |
| * Module Name: uttrack - Memory allocation tracking routines (debug only) |
| * |
| * Copyright (C) 2000 - 2019, 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_status |
| acpi_ut_track_allocation(struct acpi_debug_mem_block *address, |
| acpi_size size, |
| u8 alloc_type, |
| u32 component, const char *module, u32 line); |
| |
| static acpi_status |
| acpi_ut_remove_allocation(struct acpi_debug_mem_block *address, |
| u32 component, const char *module, u32 line); |
| |
| /******************************************************************************* |
| * |
| * 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(const char *list_name, |
| u16 object_size, struct acpi_memory_list **return_cache) |
| { |
| struct acpi_memory_list *cache; |
| |
| cache = acpi_os_allocate_zeroed(sizeof(struct acpi_memory_list)); |
| if (!cache) { |
| return (AE_NO_MEMORY); |
| } |
| |
| cache->list_name = list_name; |
| cache->object_size = object_size; |
| |
| *return_cache = cache; |
| return (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_ut_allocate_and_track(acpi_size size, |
| u32 component, const char *module, u32 line) |
| { |
| struct acpi_debug_mem_block *allocation; |
| acpi_status 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; |
| } |
| |
| allocation = |
| acpi_os_allocate(size + sizeof(struct acpi_debug_mem_header)); |
| if (!allocation) { |
| |
| /* Report allocation error */ |
| |
| ACPI_WARNING((module, line, |
| "Could not allocate size %u", (u32)size)); |
| |
| return (NULL); |
| } |
| |
| status = |
| acpi_ut_track_allocation(allocation, size, ACPI_MEM_MALLOC, |
| component, module, line); |
| if (ACPI_FAILURE(status)) { |
| acpi_os_free(allocation); |
| return (NULL); |
| } |
| |
| acpi_gbl_global_list->total_allocated++; |
| acpi_gbl_global_list->total_size += (u32)size; |
| acpi_gbl_global_list->current_total_size += (u32)size; |
| |
| if (acpi_gbl_global_list->current_total_size > |
| acpi_gbl_global_list->max_occupied) { |
| acpi_gbl_global_list->max_occupied = |
| acpi_gbl_global_list->current_total_size; |
| } |
| |
| return ((void *)&allocation->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_ut_allocate_zeroed_and_track(acpi_size size, |
| u32 component, |
| const char *module, u32 line) |
| { |
| struct acpi_debug_mem_block *allocation; |
| acpi_status 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; |
| } |
| |
| allocation = |
| acpi_os_allocate_zeroed(size + |
| sizeof(struct acpi_debug_mem_header)); |
| if (!allocation) { |
| |
| /* Report allocation error */ |
| |
| ACPI_ERROR((module, line, |
| "Could not allocate size %u", (u32)size)); |
| return (NULL); |
| } |
| |
| status = acpi_ut_track_allocation(allocation, size, |
| ACPI_MEM_CALLOC, component, module, |
| line); |
| if (ACPI_FAILURE(status)) { |
| acpi_os_free(allocation); |
| return (NULL); |
| } |
| |
| acpi_gbl_global_list->total_allocated++; |
| acpi_gbl_global_list->total_size += (u32)size; |
| acpi_gbl_global_list->current_total_size += (u32)size; |
| |
| if (acpi_gbl_global_list->current_total_size > |
| acpi_gbl_global_list->max_occupied) { |
| acpi_gbl_global_list->max_occupied = |
| acpi_gbl_global_list->current_total_size; |
| } |
| |
| return ((void *)&allocation->user_space); |
| } |
| |
| /******************************************************************************* |
| * |
| * 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(void *allocation, |
| u32 component, const char *module, u32 line) |
| { |
| struct acpi_debug_mem_block *debug_block; |
| acpi_status status; |
| |
| ACPI_FUNCTION_TRACE_PTR(ut_free, allocation); |
| |
| if (NULL == allocation) { |
| ACPI_ERROR((module, line, "Attempt to delete a NULL address")); |
| |
| return_VOID; |
| } |
| |
| debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block, |
| (((char *)allocation) - |
| sizeof(struct acpi_debug_mem_header))); |
| |
| acpi_gbl_global_list->total_freed++; |
| acpi_gbl_global_list->current_total_size -= debug_block->size; |
| |
| status = |
| acpi_ut_remove_allocation(debug_block, component, module, line); |
| if (ACPI_FAILURE(status)) { |
| ACPI_EXCEPTION((AE_INFO, status, "Could not free memory")); |
| } |
| |
| 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 *acpi_ut_find_allocation(struct |
| acpi_debug_mem_block |
| *allocation) |
| { |
| struct acpi_debug_mem_block *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) { |
| |
| /* Check for end-of-list */ |
| |
| 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. |
| * |
| ******************************************************************************/ |
| |
| static acpi_status |
| acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation, |
| acpi_size size, |
| u8 alloc_type, |
| u32 component, const char *module, u32 line) |
| { |
| struct acpi_memory_list *mem_list; |
| struct acpi_debug_mem_block *element; |
| acpi_status status = AE_OK; |
| |
| ACPI_FUNCTION_TRACE_PTR(ut_track_allocation, allocation); |
| |
| if (acpi_gbl_disable_mem_tracking) { |
| return_ACPI_STATUS(AE_OK); |
| } |
| |
| mem_list = acpi_gbl_global_list; |
| status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY); |
| if (ACPI_FAILURE(status)) { |
| 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); |
| if (element == allocation) { |
| ACPI_ERROR((AE_INFO, |
| "UtTrackAllocation: Allocation (%p) already present in global list!", |
| allocation)); |
| goto unlock_and_exit; |
| } |
| |
| /* Fill in the instance data */ |
| |
| allocation->size = (u32)size; |
| allocation->alloc_type = alloc_type; |
| allocation->component = component; |
| allocation->line = line; |
| |
| acpi_ut_safe_strncpy(allocation->module, (char *)module, |
| ACPI_MAX_MODULE_NAME); |
| |
| if (!element) { |
| |
| /* Insert at list head */ |
| |
| if (mem_list->list_head) { |
| ((struct acpi_debug_mem_block *)(mem_list->list_head))-> |
| previous = allocation; |
| } |
| |
| allocation->next = mem_list->list_head; |
| allocation->previous = NULL; |
| |
| mem_list->list_head = allocation; |
| } else { |
| /* Insert after element */ |
| |
| allocation->next = element->next; |
| allocation->previous = element; |
| |
| if (element->next) { |
| (element->next)->previous = allocation; |
| } |
| |
| 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, |
| u32 component, const char *module, u32 line) |
| { |
| struct acpi_memory_list *mem_list; |
| acpi_status status; |
| |
| ACPI_FUNCTION_NAME(ut_remove_allocation); |
| |
| if (acpi_gbl_disable_mem_tracking) { |
| return (AE_OK); |
| } |
| |
| mem_list = acpi_gbl_global_list; |
| if (NULL == mem_list->list_head) { |
| |
| /* No allocations! */ |
| |
| ACPI_ERROR((module, line, |
| "Empty allocation list, nothing to free!")); |
| |
| return (AE_OK); |
| } |
| |
| status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY); |
| if (ACPI_FAILURE(status)) { |
| return (status); |
| } |
| |
| /* Unlink */ |
| |
| if (allocation->previous) { |
| (allocation->previous)->next = allocation->next; |
| } else { |
| mem_list->list_head = allocation->next; |
| } |
| |
| if (allocation->next) { |
| (allocation->next)->previous = allocation->previous; |
| } |
| |
| ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n", |
| &allocation->user_space, allocation->size)); |
| |
| /* Mark the segment as deleted */ |
| |
| memset(&allocation->user_space, 0xEA, allocation->size); |
| |
| status = acpi_ut_release_mutex(ACPI_MTX_MEMORY); |
| 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(ut_dump_allocation_info); |
| |
| /* |
| 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 acpi_ut_dump_allocations(u32 component, const char *module) |
| { |
| struct acpi_debug_mem_block *element; |
| union acpi_descriptor *descriptor; |
| u32 num_outstanding = 0; |
| u8 descriptor_type; |
| |
| ACPI_FUNCTION_TRACE(ut_dump_allocations); |
| |
| if (acpi_gbl_disable_mem_tracking) { |
| return_VOID; |
| } |
| |
| /* |
| * Walk the allocation list. |
| */ |
| if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) { |
| return_VOID; |
| } |
| |
| if (!acpi_gbl_global_list) { |
| goto exit; |
| } |
| |
| element = acpi_gbl_global_list->list_head; |
| while (element) { |
| if ((element->component & component) && |
| ((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)) { |
| acpi_os_printf("%p Length 0x%04X %9.9s-%4.4u " |
| "[Not a Descriptor - too small]\n", |
| descriptor, element->size, |
| element->module, element->line); |
| } else { |
| /* Ignore allocated objects that are in a cache */ |
| |
| if (ACPI_GET_DESCRIPTOR_TYPE(descriptor) != |
| ACPI_DESC_TYPE_CACHED) { |
| 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)); |
| |
| /* Optional object hex dump */ |
| |
| if (acpi_gbl_verbose_leak_dump) { |
| acpi_os_printf("\n"); |
| acpi_ut_dump_buffer((u8 *) |
| descriptor, |
| element-> |
| size, |
| DB_BYTE_DISPLAY, |
| 0); |
| } |
| |
| /* Validate the descriptor type using Type field and length */ |
| |
| descriptor_type = 0; /* Not a valid descriptor type */ |
| |
| switch (ACPI_GET_DESCRIPTOR_TYPE |
| (descriptor)) { |
| case ACPI_DESC_TYPE_OPERAND: |
| |
| if (element->size == |
| sizeof(union |
| acpi_operand_object)) |
| { |
| descriptor_type = |
| ACPI_DESC_TYPE_OPERAND; |
| } |
| break; |
| |
| case ACPI_DESC_TYPE_PARSER: |
| |
| if (element->size == |
| sizeof(union |
| acpi_parse_object)) { |
| descriptor_type = |
| ACPI_DESC_TYPE_PARSER; |
| } |
| break; |
| |
| case ACPI_DESC_TYPE_NAMED: |
| |
| if (element->size == |
| sizeof(struct |
| acpi_namespace_node)) |
| { |
| descriptor_type = |
| ACPI_DESC_TYPE_NAMED; |
| } |
| break; |
| |
| default: |
| |
| break; |
| } |
| |
| /* Display additional info for the major descriptor types */ |
| |
| switch (descriptor_type) { |
| case ACPI_DESC_TYPE_OPERAND: |
| |
| acpi_os_printf |
| ("%12.12s RefCount 0x%04X\n", |
| acpi_ut_get_type_name |
| (descriptor->object.common. |
| type), |
| descriptor->object.common. |
| reference_count); |
| break; |
| |
| case ACPI_DESC_TYPE_PARSER: |
| |
| acpi_os_printf |
| ("AmlOpcode 0x%04X\n", |
| descriptor->op.asl. |
| aml_opcode); |
| break; |
| |
| case ACPI_DESC_TYPE_NAMED: |
| |
| acpi_os_printf("%4.4s\n", |
| acpi_ut_get_node_name |
| (&descriptor-> |
| node)); |
| break; |
| |
| default: |
| |
| acpi_os_printf("\n"); |
| break; |
| } |
| } |
| } |
| |
| num_outstanding++; |
| } |
| |
| element = element->next; |
| } |
| |
| exit: |
| (void)acpi_ut_release_mutex(ACPI_MTX_MEMORY); |
| |
| /* 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 */ |