[linux-2.6-block.git] / drivers / acpi / acpica / uttrack.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: uttrack - Memory allocation tracking routines (debug only)
 *
 * Copyright (C) 2000 - 2023, 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 */
Commit	Line	Data
95857638	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
6d33b6be LZ	2	/******************************************************************************
	3	*
	4	* Module Name: uttrack - Memory allocation tracking routines (debug only)
	5	*
612c2932	6	* Copyright (C) 2000 - 2023, Intel Corp.
6d33b6be	7	*
95857638	8	*****************************************************************************/
6d33b6be LZ	9
	10	/*
	11	* These procedures are used for tracking memory leaks in the subsystem, and
	12	* they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
	13	*
73a3090a	14	* Each memory allocation is tracked via a doubly linked list. Each
6d33b6be	15	* element contains the caller's component, module name, function name, and
73a3090a	16	* line number. acpi_ut_allocate and acpi_ut_allocate_zeroed call
6d33b6be LZ	17	* acpi_ut_track_allocation to add an element to the list; deletion
	18	* occurs in the body of acpi_ut_free.
	19	*/
	20
	21	#include <acpi/acpi.h>
	22	#include "accommon.h"
	23
	24	#ifdef ACPI_DBG_TRACK_ALLOCATIONS
	25
	26	#define _COMPONENT ACPI_UTILITIES
	27	ACPI_MODULE_NAME("uttrack")
	28
	29	/* Local prototypes */
d8da9151 BM	30	static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
	31	acpi_debug_mem_block
	32	*allocation);
6d33b6be LZ	33
	34	static acpi_status
	35	acpi_ut_track_allocation(struct acpi_debug_mem_block *address,
	36	acpi_size size,
	37	u8 alloc_type,
	38	u32 component, const char *module, u32 line);
	39
	40	static acpi_status
	41	acpi_ut_remove_allocation(struct acpi_debug_mem_block *address,
	42	u32 component, const char *module, u32 line);
	43
	44	/*******************************************************************************
	45	*
	46	* FUNCTION: acpi_ut_create_list
	47	*
	48	* PARAMETERS: cache_name - Ascii name for the cache
	49	* object_size - Size of each cached object
	50	* return_cache - Where the new cache object is returned
	51	*
	52	* RETURN: Status
	53	*
	54	* DESCRIPTION: Create a local memory list for tracking purposed
	55	*
	56	******************************************************************************/
	57
	58	acpi_status
0dfaaa3d	59	acpi_ut_create_list(const char *list_name,
6d33b6be LZ	60	u16 object_size, struct acpi_memory_list **return_cache)
	61	{
	62	struct acpi_memory_list *cache;
	63
9556ec4e	64	cache = acpi_os_allocate_zeroed(sizeof(struct acpi_memory_list));
6d33b6be LZ	65	if (!cache) {
	66	return (AE_NO_MEMORY);
	67	}
	68
6d33b6be LZ	69	cache->list_name = list_name;
	70	cache->object_size = object_size;
	71
	72	*return_cache = cache;
	73	return (AE_OK);
	74	}
	75
	76	/*******************************************************************************
	77	*
	78	* FUNCTION: acpi_ut_allocate_and_track
	79	*
	80	* PARAMETERS: size - Size of the allocation
	81	* component - Component type of caller
	82	* module - Source file name of caller
	83	* line - Line number of caller
	84	*
	85	* RETURN: Address of the allocated memory on success, NULL on failure.
	86	*
	87	* DESCRIPTION: The subsystem's equivalent of malloc.
	88	*
	89	******************************************************************************/
	90
	91	void *acpi_ut_allocate_and_track(acpi_size size,
	92	u32 component, const char *module, u32 line)
	93	{
	94	struct acpi_debug_mem_block *allocation;
	95	acpi_status status;
	96
b3c86c30 LZ	97	/* Check for an inadvertent size of zero bytes */
	98
	99	if (!size) {
	100	ACPI_WARNING((module, line,
	101	"Attempt to allocate zero bytes, allocating 1 byte"));
	102	size = 1;
	103	}
	104
6d33b6be	105	allocation =
b3c86c30	106	acpi_os_allocate(size + sizeof(struct acpi_debug_mem_header));
6d33b6be	107	if (!allocation) {
b3c86c30 LZ	108
	109	/* Report allocation error */
	110
	111	ACPI_WARNING((module, line,
	112	"Could not allocate size %u", (u32)size));
	113
6d33b6be LZ	114	return (NULL);
	115	}
	116
1fad8738 BM	117	status =
	118	acpi_ut_track_allocation(allocation, size, ACPI_MEM_MALLOC,
	119	component, module, line);
6d33b6be LZ	120	if (ACPI_FAILURE(status)) {
	121	acpi_os_free(allocation);
	122	return (NULL);
	123	}
	124
	125	acpi_gbl_global_list->total_allocated++;
	126	acpi_gbl_global_list->total_size += (u32)size;
	127	acpi_gbl_global_list->current_total_size += (u32)size;
1fad8738	128
6d33b6be LZ	129	if (acpi_gbl_global_list->current_total_size >
	130	acpi_gbl_global_list->max_occupied) {
	131	acpi_gbl_global_list->max_occupied =
	132	acpi_gbl_global_list->current_total_size;
	133	}
	134
	135	return ((void *)&allocation->user_space);
	136	}
	137
	138	/*******************************************************************************
	139	*
	140	* FUNCTION: acpi_ut_allocate_zeroed_and_track
	141	*
	142	* PARAMETERS: size - Size of the allocation
	143	* component - Component type of caller
	144	* module - Source file name of caller
	145	* line - Line number of caller
	146	*
	147	* RETURN: Address of the allocated memory on success, NULL on failure.
	148	*
	149	* DESCRIPTION: Subsystem equivalent of calloc.
	150	*
	151	******************************************************************************/
	152
	153	void *acpi_ut_allocate_zeroed_and_track(acpi_size size,
	154	u32 component,
	155	const char *module, u32 line)
	156	{
	157	struct acpi_debug_mem_block *allocation;
	158	acpi_status status;
	159
b3c86c30 LZ	160	/* Check for an inadvertent size of zero bytes */
	161
	162	if (!size) {
	163	ACPI_WARNING((module, line,
	164	"Attempt to allocate zero bytes, allocating 1 byte"));
	165	size = 1;
	166	}
	167
6d33b6be	168	allocation =
b3c86c30 LZ	169	acpi_os_allocate_zeroed(size +
b3c86c30 LZ	170	sizeof(struct acpi_debug_mem_header));
6d33b6be LZ	171	if (!allocation) {
	172
	173	/* Report allocation error */
	174
	175	ACPI_ERROR((module, line,
	176	"Could not allocate size %u", (u32)size));
	177	return (NULL);
	178	}
	179
	180	status = acpi_ut_track_allocation(allocation, size,
	181	ACPI_MEM_CALLOC, component, module,
	182	line);
	183	if (ACPI_FAILURE(status)) {
	184	acpi_os_free(allocation);
	185	return (NULL);
	186	}
	187
	188	acpi_gbl_global_list->total_allocated++;
	189	acpi_gbl_global_list->total_size += (u32)size;
	190	acpi_gbl_global_list->current_total_size += (u32)size;
1fad8738	191
6d33b6be LZ	192	if (acpi_gbl_global_list->current_total_size >
	193	acpi_gbl_global_list->max_occupied) {
	194	acpi_gbl_global_list->max_occupied =
	195	acpi_gbl_global_list->current_total_size;
	196	}
	197
	198	return ((void *)&allocation->user_space);
	199	}
	200
	201	/*******************************************************************************
	202	*
	203	* FUNCTION: acpi_ut_free_and_track
	204	*
	205	* PARAMETERS: allocation - Address of the memory to deallocate
	206	* component - Component type of caller
	207	* module - Source file name of caller
	208	* line - Line number of caller
	209	*
	210	* RETURN: None
	211	*
	212	* DESCRIPTION: Frees the memory at Allocation
	213	*
	214	******************************************************************************/
	215
	216	void
	217	acpi_ut_free_and_track(void *allocation,
	218	u32 component, const char *module, u32 line)
	219	{
	220	struct acpi_debug_mem_block *debug_block;
	221	acpi_status status;
	222
	223	ACPI_FUNCTION_TRACE_PTR(ut_free, allocation);
	224
	225	if (NULL == allocation) {
	226	ACPI_ERROR((module, line, "Attempt to delete a NULL address"));
	227
	228	return_VOID;
	229	}
	230
	231	debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block,
	232	(((char *)allocation) -
	233	sizeof(struct acpi_debug_mem_header)));
	234
	235	acpi_gbl_global_list->total_freed++;
	236	acpi_gbl_global_list->current_total_size -= debug_block->size;
	237
1fad8738 BM	238	status =
1fad8738 BM	239	acpi_ut_remove_allocation(debug_block, component, module, line);
6d33b6be LZ	240	if (ACPI_FAILURE(status)) {
	241	ACPI_EXCEPTION((AE_INFO, status, "Could not free memory"));
	242	}
	243
	244	acpi_os_free(debug_block);
d72c17a8 BM	245	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
d72c17a8 BM	246	allocation, debug_block));
6d33b6be LZ	247	return_VOID;
	248	}
	249
	250	/*******************************************************************************
	251	*
	252	* FUNCTION: acpi_ut_find_allocation
	253	*
	254	* PARAMETERS: allocation - Address of allocated memory
	255	*
d8da9151 BM	256	* RETURN: Three cases:
	257	* 1) List is empty, NULL is returned.
	258	* 2) Element was found. Returns Allocation parameter.
	259	* 3) Element was not found. Returns position where it should be
	260	* inserted into the list.
6d33b6be LZ	261	*
6d33b6be LZ	262	* DESCRIPTION: Searches for an element in the global allocation tracking list.
d8da9151 BM	263	* If the element is not found, returns the location within the
	264	* list where the element should be inserted.
	265	*
	266	* Note: The list is ordered by larger-to-smaller addresses.
	267	*
	268	* This global list is used to detect memory leaks in ACPICA as
	269	* well as other issues such as an attempt to release the same
	270	* internal object more than once. Although expensive as far
	271	* as cpu time, this list is much more helpful for finding these
	272	* types of issues than using memory leak detectors outside of
	273	* the ACPICA code.
6d33b6be LZ	274	*
	275	******************************************************************************/
	276
d8da9151 BM	277	static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
	278	acpi_debug_mem_block
	279	*allocation)
6d33b6be LZ	280	{
	281	struct acpi_debug_mem_block *element;
	282
6d33b6be	283	element = acpi_gbl_global_list->list_head;
d8da9151 BM	284	if (!element) {
	285	return (NULL);
	286	}
	287
	288	/*
	289	* Search for the address.
	290	*
	291	* Note: List is ordered by larger-to-smaller addresses, on the
	292	* assumption that a new allocation usually has a larger address
	293	* than previous allocations.
	294	*/
	295	while (element > allocation) {
6d33b6be	296
d8da9151	297	/* Check for end-of-list */
6d33b6be	298
d8da9151	299	if (!element->next) {
6d33b6be LZ	300	return (element);
	301	}
	302
	303	element = element->next;
	304	}
	305
d8da9151 BM	306	if (element == allocation) {
	307	return (element);
	308	}
	309
	310	return (element->previous);
6d33b6be LZ	311	}
	312
	313	/*******************************************************************************
	314	*
	315	* FUNCTION: acpi_ut_track_allocation
	316	*
	317	* PARAMETERS: allocation - Address of allocated memory
	318	* size - Size of the allocation
	319	* alloc_type - MEM_MALLOC or MEM_CALLOC
	320	* component - Component type of caller
	321	* module - Source file name of caller
	322	* line - Line number of caller
	323	*
d8da9151	324	* RETURN: Status
6d33b6be LZ	325	*
	326	* DESCRIPTION: Inserts an element into the global allocation tracking list.
	327	*
	328	******************************************************************************/
	329
	330	static acpi_status
	331	acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation,
	332	acpi_size size,
	333	u8 alloc_type,
	334	u32 component, const char *module, u32 line)
	335	{
	336	struct acpi_memory_list *mem_list;
	337	struct acpi_debug_mem_block *element;
	338	acpi_status status = AE_OK;
	339
	340	ACPI_FUNCTION_TRACE_PTR(ut_track_allocation, allocation);
	341
	342	if (acpi_gbl_disable_mem_tracking) {
	343	return_ACPI_STATUS(AE_OK);
	344	}
	345
	346	mem_list = acpi_gbl_global_list;
	347	status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
	348	if (ACPI_FAILURE(status)) {
	349	return_ACPI_STATUS(status);
	350	}
	351
	352	/*
d8da9151 BM	353	* Search the global list for this address to make sure it is not
d8da9151 BM	354	* already present. This will catch several kinds of problems.
6d33b6be LZ	355	*/
6d33b6be LZ	356	element = acpi_ut_find_allocation(allocation);
d8da9151	357	if (element == allocation) {
6d33b6be	358	ACPI_ERROR((AE_INFO,
d8da9151	359	"UtTrackAllocation: Allocation (%p) already present in global list!",
6d33b6be	360	allocation));
6d33b6be LZ	361	goto unlock_and_exit;
	362	}
	363
d8da9151	364	/* Fill in the instance data */
6d33b6be LZ	365
	366	allocation->size = (u32)size;
	367	allocation->alloc_type = alloc_type;
	368	allocation->component = component;
	369	allocation->line = line;
	370
ee68d477 BM	371	acpi_ut_safe_strncpy(allocation->module, (char *)module,
ee68d477 BM	372	ACPI_MAX_MODULE_NAME);
6d33b6be	373
d8da9151	374	if (!element) {
6d33b6be	375
d8da9151 BM	376	/* Insert at list head */
	377
	378	if (mem_list->list_head) {
	379	((struct acpi_debug_mem_block *)(mem_list->list_head))->
	380	previous = allocation;
	381	}
	382
	383	allocation->next = mem_list->list_head;
	384	allocation->previous = NULL;
6d33b6be	385
d8da9151 BM	386	mem_list->list_head = allocation;
	387	} else {
	388	/* Insert after element */
6d33b6be	389
d8da9151 BM	390	allocation->next = element->next;
	391	allocation->previous = element;
	392
	393	if (element->next) {
	394	(element->next)->previous = allocation;
	395	}
	396
	397	element->next = allocation;
	398	}
6d33b6be	399
10622bf8	400	unlock_and_exit:
6d33b6be LZ	401	status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
	402	return_ACPI_STATUS(status);
	403	}
	404
	405	/*******************************************************************************
	406	*
	407	* FUNCTION: acpi_ut_remove_allocation
	408	*
	409	* PARAMETERS: allocation - Address of allocated memory
	410	* component - Component type of caller
	411	* module - Source file name of caller
	412	* line - Line number of caller
	413	*
d8da9151	414	* RETURN: Status
6d33b6be LZ	415	*
	416	* DESCRIPTION: Deletes an element from the global allocation tracking list.
	417	*
	418	******************************************************************************/
	419
	420	static acpi_status
	421	acpi_ut_remove_allocation(struct acpi_debug_mem_block *allocation,
	422	u32 component, const char *module, u32 line)
	423	{
	424	struct acpi_memory_list *mem_list;
	425	acpi_status status;
	426
0e770b32	427	ACPI_FUNCTION_NAME(ut_remove_allocation);
6d33b6be LZ	428
6d33b6be LZ	429	if (acpi_gbl_disable_mem_tracking) {
0e770b32	430	return (AE_OK);
6d33b6be LZ	431	}
	432
	433	mem_list = acpi_gbl_global_list;
	434	if (NULL == mem_list->list_head) {
	435
	436	/* No allocations! */
	437
	438	ACPI_ERROR((module, line,
	439	"Empty allocation list, nothing to free!"));
	440
0e770b32	441	return (AE_OK);
6d33b6be LZ	442	}
	443
	444	status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
	445	if (ACPI_FAILURE(status)) {
0e770b32	446	return (status);
6d33b6be LZ	447	}
	448
	449	/* Unlink */
	450
	451	if (allocation->previous) {
	452	(allocation->previous)->next = allocation->next;
	453	} else {
	454	mem_list->list_head = allocation->next;
	455	}
	456
	457	if (allocation->next) {
	458	(allocation->next)->previous = allocation->previous;
	459	}
	460
0e770b32 BM	461	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n",
	462	&allocation->user_space, allocation->size));
	463
6d33b6be LZ	464	/* Mark the segment as deleted */
6d33b6be LZ	465
4fa4616e	466	memset(&allocation->user_space, 0xEA, allocation->size);
6d33b6be	467
6d33b6be	468	status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
0e770b32	469	return (status);
6d33b6be LZ	470	}
	471
	472	/*******************************************************************************
	473	*
	474	* FUNCTION: acpi_ut_dump_allocation_info
	475	*
d8da9151	476	* PARAMETERS: None
6d33b6be LZ	477	*
	478	* RETURN: None
	479	*
	480	* DESCRIPTION: Print some info about the outstanding allocations.
	481	*
	482	******************************************************************************/
	483
	484	void acpi_ut_dump_allocation_info(void)
	485	{
	486	/*
	487	struct acpi_memory_list *mem_list;
	488	*/
	489
	490	ACPI_FUNCTION_TRACE(ut_dump_allocation_info);
	491
	492	/*
	493	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	494	("%30s: %4d (%3d Kb)\n", "Current allocations",
	495	mem_list->current_count,
	496	ROUND_UP_TO_1K (mem_list->current_size)));
6d33b6be LZ	497
6d33b6be LZ	498	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	499	("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
	500	mem_list->max_concurrent_count,
	501	ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
6d33b6be LZ	502
6d33b6be LZ	503	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	504	("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
	505	running_object_count,
	506	ROUND_UP_TO_1K (running_object_size)));
6d33b6be LZ	507
6d33b6be LZ	508	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	509	("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
	510	running_alloc_count,
	511	ROUND_UP_TO_1K (running_alloc_size)));
6d33b6be LZ	512
6d33b6be LZ	513	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	514	("%30s: %4d (%3d Kb)\n", "Current Nodes",
	515	acpi_gbl_current_node_count,
	516	ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
6d33b6be LZ	517
6d33b6be LZ	518	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS \| TRACE_TABLES,
1fad8738 BM	519	("%30s: %4d (%3d Kb)\n", "Max Nodes",
	520	acpi_gbl_max_concurrent_node_count,
	521	ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count *
	522	sizeof (struct acpi_namespace_node)))));
6d33b6be LZ	523	*/
	524	return_VOID;
	525	}
	526
	527	/*******************************************************************************
	528	*
	529	* FUNCTION: acpi_ut_dump_allocations
	530	*
	531	* PARAMETERS: component - Component(s) to dump info for.
73a3090a	532	* module - Module to dump info for. NULL means all.
6d33b6be LZ	533	*
	534	* RETURN: None
	535	*
	536	* DESCRIPTION: Print a list of all outstanding allocations.
	537	*
	538	******************************************************************************/
	539
	540	void acpi_ut_dump_allocations(u32 component, const char *module)
	541	{
	542	struct acpi_debug_mem_block *element;
	543	union acpi_descriptor *descriptor;
	544	u32 num_outstanding = 0;
	545	u8 descriptor_type;
	546
	547	ACPI_FUNCTION_TRACE(ut_dump_allocations);
	548
	549	if (acpi_gbl_disable_mem_tracking) {
68aafc35	550	return_VOID;
6d33b6be LZ	551	}
	552
	553	/*
	554	* Walk the allocation list.
	555	*/
	556	if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) {
68aafc35	557	return_VOID;
6d33b6be LZ	558	}
6d33b6be LZ	559
a62a7117 BM	560	if (!acpi_gbl_global_list) {
	561	goto exit;
	562	}
	563
6d33b6be LZ	564	element = acpi_gbl_global_list->list_head;
	565	while (element) {
	566	if ((element->component & component) &&
	567	((module == NULL)
4fa4616e	568	\|\| (0 == strcmp(module, element->module)))) {
6d33b6be LZ	569	descriptor =
	570	ACPI_CAST_PTR(union acpi_descriptor,
	571	&element->user_space);
	572
	573	if (element->size <
	574	sizeof(struct acpi_common_descriptor)) {
a62a7117	575	acpi_os_printf("%p Length 0x%04X %9.9s-%4.4u "
6d33b6be LZ	576	"[Not a Descriptor - too small]\n",
	577	descriptor, element->size,
	578	element->module, element->line);
	579	} else {
	580	/* Ignore allocated objects that are in a cache */
	581
	582	if (ACPI_GET_DESCRIPTOR_TYPE(descriptor) !=
	583	ACPI_DESC_TYPE_CACHED) {
	584	acpi_os_printf
a62a7117	585	("%p Length 0x%04X %9.9s-%4.4u [%s] ",
6d33b6be LZ	586	descriptor, element->size,
	587	element->module, element->line,
	588	acpi_ut_get_descriptor_name
	589	(descriptor));
	590
894b5cc5 BM	591	/* Optional object hex dump */
	592
	593	if (acpi_gbl_verbose_leak_dump) {
	594	acpi_os_printf("\n");
	595	acpi_ut_dump_buffer((u8 *)
	596	descriptor,
	597	element->
	598	size,
	599	DB_BYTE_DISPLAY,
	600	0);
	601	}
	602
6d33b6be LZ	603	/* Validate the descriptor type using Type field and length */
	604
	605	descriptor_type = 0; /* Not a valid descriptor type */
	606
	607	switch (ACPI_GET_DESCRIPTOR_TYPE
	608	(descriptor)) {
	609	case ACPI_DESC_TYPE_OPERAND:
1d1ea1b7	610
6d33b6be LZ	611	if (element->size ==
	612	sizeof(union
	613	acpi_operand_object))
	614	{
	615	descriptor_type =
	616	ACPI_DESC_TYPE_OPERAND;
	617	}
	618	break;
	619
	620	case ACPI_DESC_TYPE_PARSER:
1d1ea1b7	621
6d33b6be LZ	622	if (element->size ==
	623	sizeof(union
	624	acpi_parse_object)) {
	625	descriptor_type =
	626	ACPI_DESC_TYPE_PARSER;
	627	}
	628	break;
	629
	630	case ACPI_DESC_TYPE_NAMED:
1d1ea1b7	631
6d33b6be LZ	632	if (element->size ==
	633	sizeof(struct
	634	acpi_namespace_node))
	635	{
	636	descriptor_type =
	637	ACPI_DESC_TYPE_NAMED;
	638	}
	639	break;
	640
	641	default:
1d1ea1b7	642
6d33b6be LZ	643	break;
	644	}
	645
	646	/* Display additional info for the major descriptor types */
	647
	648	switch (descriptor_type) {
	649	case ACPI_DESC_TYPE_OPERAND:
1d1ea1b7	650
6d33b6be LZ	651	acpi_os_printf
	652	("%12.12s RefCount 0x%04X\n",
	653	acpi_ut_get_type_name
	654	(descriptor->object.common.
	655	type),
	656	descriptor->object.common.
	657	reference_count);
	658	break;
	659
	660	case ACPI_DESC_TYPE_PARSER:
1d1ea1b7	661
6d33b6be	662	acpi_os_printf
edc5935e	663	("AmlOpcode 0x%04X\n",
6d33b6be LZ	664	descriptor->op.asl.
	665	aml_opcode);
	666	break;
	667
	668	case ACPI_DESC_TYPE_NAMED:
1d1ea1b7	669
6d33b6be LZ	670	acpi_os_printf("%4.4s\n",
	671	acpi_ut_get_node_name
	672	(&descriptor->
	673	node));
	674	break;
	675
	676	default:
1d1ea1b7	677
6d33b6be LZ	678	acpi_os_printf("\n");
	679	break;
	680	}
	681	}
	682	}
	683
	684	num_outstanding++;
	685	}
	686
	687	element = element->next;
	688	}
	689
a62a7117	690	exit:
6d33b6be LZ	691	(void)acpi_ut_release_mutex(ACPI_MTX_MEMORY);
	692
	693	/* Print summary */
	694
	695	if (!num_outstanding) {
05fb04b5	696	ACPI_INFO(("No outstanding allocations"));
6d33b6be	697	} else {
b12ebe59	698	ACPI_ERROR((AE_INFO, "%u (0x%X) Outstanding cache allocations",
6d33b6be LZ	699	num_outstanding, num_outstanding));
	700	}
	701
	702	return_VOID;
	703	}
	704
	705	#endif /* ACPI_DBG_TRACK_ALLOCATIONS */