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
27 ACPI_MODULE_NAME("uttrack")
28 
29 /* Local prototypes */
30 static struct acpi_debug_mem_block *acpi_ut_find_allocation(struct
31 							    acpi_debug_mem_block
32 							    *allocation);
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
acpi_ut_create_list(const char * list_name,u16 object_size,struct acpi_memory_list ** return_cache)59 acpi_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 
acpi_ut_allocate_and_track(acpi_size size,u32 component,const char * module,u32 line)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 
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 
acpi_ut_allocate_zeroed_and_track(acpi_size size,u32 component,const char * module,u32 line)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 
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 
216 void
acpi_ut_free_and_track(void * allocation,u32 component,const char * module,u32 line)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 
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 
acpi_ut_find_allocation(struct acpi_debug_mem_block * allocation)277 static 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 
330 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)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 	/*
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 
400 unlock_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 
420 static acpi_status
acpi_ut_remove_allocation(struct acpi_debug_mem_block * allocation,u32 component,const char * module,u32 line)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 
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 
acpi_ut_dump_allocation_info(void)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,
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 
acpi_ut_dump_allocations(u32 component,const char * module)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) {
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 
690 exit:
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