1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/******************************************************************************
3 *
4 * Module Name: uttrack - Memory allocation tracking routines (debug only)
5 *
6 * Copyright (C) 2000 - 2023, Intel Corp.
7 *
8 *****************************************************************************/
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 *
14 * Each memory allocation is tracked via a doubly linked list. Each
15 * element contains the caller's component, module name, function name, and
16 * line number. acpi_ut_allocate and acpi_ut_allocate_zeroed call
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
27ACPI_MODULE_NAME("uttrack")
28
29/* Local prototypes */
30static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
31							    acpi_debug_mem_block
32							    *allocation);
33
34static acpi_status
35acpi_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
40static acpi_status
41acpi_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
58acpi_status
59acpi_ut_create_list(const char *list_name,
60		    u16 object_size, struct acpi_memory_list **return_cache)
61{
62	struct acpi_memory_list *cache;
63
64	cache = acpi_os_allocate_zeroed(sizeof(struct acpi_memory_list));
65	if (!cache) {
66		return (AE_NO_MEMORY);
67	}
68
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
91void *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
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
105	allocation =
106	    acpi_os_allocate(size + sizeof(struct acpi_debug_mem_header));
107	if (!allocation) {
108
109		/* Report allocation error */
110
111		ACPI_WARNING((module, line,
112			      "Could not allocate size %u", (u32)size));
113
114		return (NULL);
115	}
116
117	status =
118	    acpi_ut_track_allocation(allocation, size, ACPI_MEM_MALLOC,
119				     component, module, line);
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;
128
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
153void *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
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
168	allocation =
169	    acpi_os_allocate_zeroed(size +
170				    sizeof(struct acpi_debug_mem_header));
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;
191
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
216void
217acpi_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
238	status =
239	    acpi_ut_remove_allocation(debug_block, component, module, line);
240	if (ACPI_FAILURE(status)) {
241		ACPI_EXCEPTION((AE_INFO, status, "Could not free memory"));
242	}
243
244	acpi_os_free(debug_block);
245	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
246			  allocation, debug_block));
247	return_VOID;
248}
249
250/*******************************************************************************
251 *
252 * FUNCTION:    acpi_ut_find_allocation
253 *
254 * PARAMETERS:  allocation              - Address of allocated memory
255 *
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.
261 *
262 * DESCRIPTION: Searches for an element in the global allocation tracking list.
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.
274 *
275 ******************************************************************************/
276
277static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
278							    acpi_debug_mem_block
279							    *allocation)
280{
281	struct acpi_debug_mem_block *element;
282
283	element = acpi_gbl_global_list->list_head;
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) {
296
297		/* Check for end-of-list */
298
299		if (!element->next) {
300			return (element);
301		}
302
303		element = element->next;
304	}
305
306	if (element == allocation) {
307		return (element);
308	}
309
310	return (element->previous);
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 *
324 * RETURN:      Status
325 *
326 * DESCRIPTION: Inserts an element into the global allocation tracking list.
327 *
328 ******************************************************************************/
329
330static acpi_status
331acpi_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	/*
353	 * Search the global list for this address to make sure it is not
354	 * already present. This will catch several kinds of problems.
355	 */
356	element = acpi_ut_find_allocation(allocation);
357	if (element == allocation) {
358		ACPI_ERROR((AE_INFO,
359			    "UtTrackAllocation: Allocation (%p) already present in global list!",
360			    allocation));
361		goto unlock_and_exit;
362	}
363
364	/* Fill in the instance data */
365
366	allocation->size = (u32)size;
367	allocation->alloc_type = alloc_type;
368	allocation->component = component;
369	allocation->line = line;
370
371	acpi_ut_safe_strncpy(allocation->module, (char *)module,
372			     ACPI_MAX_MODULE_NAME);
373
374	if (!element) {
375
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;
385
386		mem_list->list_head = allocation;
387	} else {
388		/* Insert after element */
389
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	}
399
400unlock_and_exit:
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 *
414 * RETURN:      Status
415 *
416 * DESCRIPTION: Deletes an element from the global allocation tracking list.
417 *
418 ******************************************************************************/
419
420static acpi_status
421acpi_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
427	ACPI_FUNCTION_NAME(ut_remove_allocation);
428
429	if (acpi_gbl_disable_mem_tracking) {
430		return (AE_OK);
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
441		return (AE_OK);
442	}
443
444	status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
445	if (ACPI_FAILURE(status)) {
446		return (status);
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
461	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n",
462			  &allocation->user_space, allocation->size));
463
464	/* Mark the segment as deleted */
465
466	memset(&allocation->user_space, 0xEA, allocation->size);
467
468	status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
469	return (status);
470}
471
472/*******************************************************************************
473 *
474 * FUNCTION:    acpi_ut_dump_allocation_info
475 *
476 * PARAMETERS:  None
477 *
478 * RETURN:      None
479 *
480 * DESCRIPTION: Print some info about the outstanding allocations.
481 *
482 ******************************************************************************/
483
484void 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,
494		("%30s: %4d (%3d Kb)\n", "Current allocations",
495		mem_list->current_count,
496		ROUND_UP_TO_1K (mem_list->current_size)));
497
498	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
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)));
502
503	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
504		("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
505		running_object_count,
506		ROUND_UP_TO_1K (running_object_size)));
507
508	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
509		("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
510		running_alloc_count,
511		ROUND_UP_TO_1K (running_alloc_size)));
512
513	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
514		("%30s: %4d (%3d Kb)\n", "Current Nodes",
515		acpi_gbl_current_node_count,
516		ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
517
518	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
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)))));
523*/
524	return_VOID;
525}
526
527/*******************************************************************************
528 *
529 * FUNCTION:    acpi_ut_dump_allocations
530 *
531 * PARAMETERS:  component           - Component(s) to dump info for.
532 *              module              - Module to dump info for. NULL means all.
533 *
534 * RETURN:      None
535 *
536 * DESCRIPTION: Print a list of all outstanding allocations.
537 *
538 ******************************************************************************/
539
540void 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) {
550		return_VOID;
551	}
552
553	/*
554	 * Walk the allocation list.
555	 */
556	if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) {
557		return_VOID;
558	}
559
560	if (!acpi_gbl_global_list) {
561		goto exit;
562	}
563
564	element = acpi_gbl_global_list->list_head;
565	while (element) {
566		if ((element->component & component) &&
567		    ((module == NULL)
568		     || (0 == strcmp(module, element->module)))) {
569			descriptor =
570			    ACPI_CAST_PTR(union acpi_descriptor,
571					  &element->user_space);
572
573			if (element->size <
574			    sizeof(struct acpi_common_descriptor)) {
575				acpi_os_printf("%p Length 0x%04X %9.9s-%4.4u "
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
585					    ("%p Length 0x%04X %9.9s-%4.4u [%s] ",
586					     descriptor, element->size,
587					     element->module, element->line,
588					     acpi_ut_get_descriptor_name
589					     (descriptor));
590
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
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:
610
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:
621
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:
631
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:
642
643						break;
644					}
645
646					/* Display additional info for the major descriptor types */
647
648					switch (descriptor_type) {
649					case ACPI_DESC_TYPE_OPERAND:
650
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:
661
662						acpi_os_printf
663						    ("AmlOpcode 0x%04X\n",
664						     descriptor->op.asl.
665						     aml_opcode);
666						break;
667
668					case ACPI_DESC_TYPE_NAMED:
669
670						acpi_os_printf("%4.4s\n",
671							       acpi_ut_get_node_name
672							       (&descriptor->
673								node));
674						break;
675
676					default:
677
678						acpi_os_printf("\n");
679						break;
680					}
681				}
682			}
683
684			num_outstanding++;
685		}
686
687		element = element->next;
688	}
689
690exit:
691	(void)acpi_ut_release_mutex(ACPI_MTX_MEMORY);
692
693	/* Print summary */
694
695	if (!num_outstanding) {
696		ACPI_INFO(("No outstanding allocations"));
697	} else {
698		ACPI_ERROR((AE_INFO, "%u (0x%X) Outstanding cache allocations",
699			    num_outstanding, num_outstanding));
700	}
701
702	return_VOID;
703}
704
705#endif				/* ACPI_DBG_TRACK_ALLOCATIONS */
706