1 /******************************************************************************
3 * Module Name: uttrack - Memory allocation tracking routines (debug only)
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
45 * These procedures are used for tracking memory leaks in the subsystem, and
46 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
48 * Each memory allocation is tracked via a doubly linked list. Each
49 * element contains the caller's component, module name, function name, and
50 * line number. AcpiUtAllocate and AcpiUtAllocateZeroed call
51 * AcpiUtTrackAllocation to add an element to the list; deletion
52 * occurs in the body of AcpiUtFree.
55 #include <contrib/dev/acpica/include/acpi.h>
56 #include <contrib/dev/acpica/include/accommon.h>
58 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
60 #define _COMPONENT ACPI_UTILITIES
61 ACPI_MODULE_NAME ("uttrack")
64 /* Local prototypes */
66 static ACPI_DEBUG_MEM_BLOCK *
67 AcpiUtFindAllocation (
68 ACPI_DEBUG_MEM_BLOCK *Allocation);
71 AcpiUtTrackAllocation (
72 ACPI_DEBUG_MEM_BLOCK *Address,
80 AcpiUtRemoveAllocation (
81 ACPI_DEBUG_MEM_BLOCK *Address,
87 /*******************************************************************************
89 * FUNCTION: AcpiUtCreateList
91 * PARAMETERS: CacheName - Ascii name for the cache
92 * ObjectSize - Size of each cached object
93 * ReturnCache - Where the new cache object is returned
97 * DESCRIPTION: Create a local memory list for tracking purposed
99 ******************************************************************************/
103 const char *ListName,
105 ACPI_MEMORY_LIST **ReturnCache)
107 ACPI_MEMORY_LIST *Cache;
110 Cache = AcpiOsAllocate (sizeof (ACPI_MEMORY_LIST));
113 return (AE_NO_MEMORY);
116 memset (Cache, 0, sizeof (ACPI_MEMORY_LIST));
118 Cache->ListName = ListName;
119 Cache->ObjectSize = ObjectSize;
121 *ReturnCache = Cache;
126 /*******************************************************************************
128 * FUNCTION: AcpiUtAllocateAndTrack
130 * PARAMETERS: Size - Size of the allocation
131 * Component - Component type of caller
132 * Module - Source file name of caller
133 * Line - Line number of caller
135 * RETURN: Address of the allocated memory on success, NULL on failure.
137 * DESCRIPTION: The subsystem's equivalent of malloc.
139 ******************************************************************************/
142 AcpiUtAllocateAndTrack (
148 ACPI_DEBUG_MEM_BLOCK *Allocation;
152 /* Check for an inadvertent size of zero bytes */
156 ACPI_WARNING ((Module, Line,
157 "Attempt to allocate zero bytes, allocating 1 byte"));
161 Allocation = AcpiOsAllocate (Size + sizeof (ACPI_DEBUG_MEM_HEADER));
164 /* Report allocation error */
166 ACPI_WARNING ((Module, Line,
167 "Could not allocate size %u", (UINT32) Size));
172 Status = AcpiUtTrackAllocation (
173 Allocation, Size, ACPI_MEM_MALLOC, Component, Module, Line);
174 if (ACPI_FAILURE (Status))
176 AcpiOsFree (Allocation);
180 AcpiGbl_GlobalList->TotalAllocated++;
181 AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
182 AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
184 if (AcpiGbl_GlobalList->CurrentTotalSize >
185 AcpiGbl_GlobalList->MaxOccupied)
187 AcpiGbl_GlobalList->MaxOccupied =
188 AcpiGbl_GlobalList->CurrentTotalSize;
191 return ((void *) &Allocation->UserSpace);
195 /*******************************************************************************
197 * FUNCTION: AcpiUtAllocateZeroedAndTrack
199 * PARAMETERS: Size - Size of the allocation
200 * Component - Component type of caller
201 * Module - Source file name of caller
202 * Line - Line number of caller
204 * RETURN: Address of the allocated memory on success, NULL on failure.
206 * DESCRIPTION: Subsystem equivalent of calloc.
208 ******************************************************************************/
211 AcpiUtAllocateZeroedAndTrack (
217 ACPI_DEBUG_MEM_BLOCK *Allocation;
221 /* Check for an inadvertent size of zero bytes */
225 ACPI_WARNING ((Module, Line,
226 "Attempt to allocate zero bytes, allocating 1 byte"));
230 Allocation = AcpiOsAllocateZeroed (
231 Size + sizeof (ACPI_DEBUG_MEM_HEADER));
234 /* Report allocation error */
236 ACPI_ERROR ((Module, Line,
237 "Could not allocate size %u", (UINT32) Size));
241 Status = AcpiUtTrackAllocation (Allocation, Size,
242 ACPI_MEM_CALLOC, Component, Module, Line);
243 if (ACPI_FAILURE (Status))
245 AcpiOsFree (Allocation);
249 AcpiGbl_GlobalList->TotalAllocated++;
250 AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
251 AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
253 if (AcpiGbl_GlobalList->CurrentTotalSize >
254 AcpiGbl_GlobalList->MaxOccupied)
256 AcpiGbl_GlobalList->MaxOccupied =
257 AcpiGbl_GlobalList->CurrentTotalSize;
260 return ((void *) &Allocation->UserSpace);
264 /*******************************************************************************
266 * FUNCTION: AcpiUtFreeAndTrack
268 * PARAMETERS: Allocation - Address of the memory to deallocate
269 * Component - Component type of caller
270 * Module - Source file name of caller
271 * Line - Line number of caller
275 * DESCRIPTION: Frees the memory at Allocation
277 ******************************************************************************/
286 ACPI_DEBUG_MEM_BLOCK *DebugBlock;
290 ACPI_FUNCTION_TRACE_PTR (UtFree, Allocation);
293 if (NULL == Allocation)
295 ACPI_ERROR ((Module, Line,
296 "Attempt to delete a NULL address"));
301 DebugBlock = ACPI_CAST_PTR (ACPI_DEBUG_MEM_BLOCK,
302 (((char *) Allocation) - sizeof (ACPI_DEBUG_MEM_HEADER)));
304 AcpiGbl_GlobalList->TotalFreed++;
305 AcpiGbl_GlobalList->CurrentTotalSize -= DebugBlock->Size;
307 Status = AcpiUtRemoveAllocation (DebugBlock, Component, Module, Line);
308 if (ACPI_FAILURE (Status))
310 ACPI_EXCEPTION ((AE_INFO, Status, "Could not free memory"));
313 AcpiOsFree (DebugBlock);
314 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
315 Allocation, DebugBlock));
320 /*******************************************************************************
322 * FUNCTION: AcpiUtFindAllocation
324 * PARAMETERS: Allocation - Address of allocated memory
326 * RETURN: Three cases:
327 * 1) List is empty, NULL is returned.
328 * 2) Element was found. Returns Allocation parameter.
329 * 3) Element was not found. Returns position where it should be
330 * inserted into the list.
332 * DESCRIPTION: Searches for an element in the global allocation tracking list.
333 * If the element is not found, returns the location within the
334 * list where the element should be inserted.
336 * Note: The list is ordered by larger-to-smaller addresses.
338 * This global list is used to detect memory leaks in ACPICA as
339 * well as other issues such as an attempt to release the same
340 * internal object more than once. Although expensive as far
341 * as cpu time, this list is much more helpful for finding these
342 * types of issues than using memory leak detectors outside of
345 ******************************************************************************/
347 static ACPI_DEBUG_MEM_BLOCK *
348 AcpiUtFindAllocation (
349 ACPI_DEBUG_MEM_BLOCK *Allocation)
351 ACPI_DEBUG_MEM_BLOCK *Element;
354 Element = AcpiGbl_GlobalList->ListHead;
361 * Search for the address.
363 * Note: List is ordered by larger-to-smaller addresses, on the
364 * assumption that a new allocation usually has a larger address
365 * than previous allocations.
367 while (Element > Allocation)
369 /* Check for end-of-list */
376 Element = Element->Next;
379 if (Element == Allocation)
384 return (Element->Previous);
388 /*******************************************************************************
390 * FUNCTION: AcpiUtTrackAllocation
392 * PARAMETERS: Allocation - Address of allocated memory
393 * Size - Size of the allocation
394 * AllocType - MEM_MALLOC or MEM_CALLOC
395 * Component - Component type of caller
396 * Module - Source file name of caller
397 * Line - Line number of caller
401 * DESCRIPTION: Inserts an element into the global allocation tracking list.
403 ******************************************************************************/
406 AcpiUtTrackAllocation (
407 ACPI_DEBUG_MEM_BLOCK *Allocation,
414 ACPI_MEMORY_LIST *MemList;
415 ACPI_DEBUG_MEM_BLOCK *Element;
416 ACPI_STATUS Status = AE_OK;
419 ACPI_FUNCTION_TRACE_PTR (UtTrackAllocation, Allocation);
422 if (AcpiGbl_DisableMemTracking)
424 return_ACPI_STATUS (AE_OK);
427 MemList = AcpiGbl_GlobalList;
428 Status = AcpiUtAcquireMutex (ACPI_MTX_MEMORY);
429 if (ACPI_FAILURE (Status))
431 return_ACPI_STATUS (Status);
435 * Search the global list for this address to make sure it is not
436 * already present. This will catch several kinds of problems.
438 Element = AcpiUtFindAllocation (Allocation);
439 if (Element == Allocation)
441 ACPI_ERROR ((AE_INFO,
442 "UtTrackAllocation: Allocation (%p) already present in global list!",
447 /* Fill in the instance data */
449 Allocation->Size = (UINT32) Size;
450 Allocation->AllocType = AllocType;
451 Allocation->Component = Component;
452 Allocation->Line = Line;
454 strncpy (Allocation->Module, Module, ACPI_MAX_MODULE_NAME);
455 Allocation->Module[ACPI_MAX_MODULE_NAME-1] = 0;
459 /* Insert at list head */
461 if (MemList->ListHead)
463 ((ACPI_DEBUG_MEM_BLOCK *)(MemList->ListHead))->Previous =
467 Allocation->Next = MemList->ListHead;
468 Allocation->Previous = NULL;
470 MemList->ListHead = Allocation;
474 /* Insert after element */
476 Allocation->Next = Element->Next;
477 Allocation->Previous = Element;
481 (Element->Next)->Previous = Allocation;
484 Element->Next = Allocation;
489 Status = AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
490 return_ACPI_STATUS (Status);
494 /*******************************************************************************
496 * FUNCTION: AcpiUtRemoveAllocation
498 * PARAMETERS: Allocation - Address of allocated memory
499 * Component - Component type of caller
500 * Module - Source file name of caller
501 * Line - Line number of caller
505 * DESCRIPTION: Deletes an element from the global allocation tracking list.
507 ******************************************************************************/
510 AcpiUtRemoveAllocation (
511 ACPI_DEBUG_MEM_BLOCK *Allocation,
516 ACPI_MEMORY_LIST *MemList;
520 ACPI_FUNCTION_NAME (UtRemoveAllocation);
523 if (AcpiGbl_DisableMemTracking)
528 MemList = AcpiGbl_GlobalList;
529 if (NULL == MemList->ListHead)
531 /* No allocations! */
533 ACPI_ERROR ((Module, Line,
534 "Empty allocation list, nothing to free!"));
539 Status = AcpiUtAcquireMutex (ACPI_MTX_MEMORY);
540 if (ACPI_FAILURE (Status))
547 if (Allocation->Previous)
549 (Allocation->Previous)->Next = Allocation->Next;
553 MemList->ListHead = Allocation->Next;
556 if (Allocation->Next)
558 (Allocation->Next)->Previous = Allocation->Previous;
561 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n",
562 &Allocation->UserSpace, Allocation->Size));
564 /* Mark the segment as deleted */
566 memset (&Allocation->UserSpace, 0xEA, Allocation->Size);
568 Status = AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
573 /*******************************************************************************
575 * FUNCTION: AcpiUtDumpAllocationInfo
581 * DESCRIPTION: Print some info about the outstanding allocations.
583 ******************************************************************************/
586 AcpiUtDumpAllocationInfo (
590 ACPI_MEMORY_LIST *MemList;
593 ACPI_FUNCTION_TRACE (UtDumpAllocationInfo);
596 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
597 ("%30s: %4d (%3d Kb)\n", "Current allocations",
598 MemList->CurrentCount,
599 ROUND_UP_TO_1K (MemList->CurrentSize)));
601 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
602 ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
603 MemList->MaxConcurrentCount,
604 ROUND_UP_TO_1K (MemList->MaxConcurrentSize)));
607 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
608 ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
610 ROUND_UP_TO_1K (RunningObjectSize)));
612 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
613 ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
615 ROUND_UP_TO_1K (RunningAllocSize)));
618 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
619 ("%30s: %4d (%3d Kb)\n", "Current Nodes",
620 AcpiGbl_CurrentNodeCount,
621 ROUND_UP_TO_1K (AcpiGbl_CurrentNodeSize)));
623 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
624 ("%30s: %4d (%3d Kb)\n", "Max Nodes",
625 AcpiGbl_MaxConcurrentNodeCount,
626 ROUND_UP_TO_1K ((AcpiGbl_MaxConcurrentNodeCount *
627 sizeof (ACPI_NAMESPACE_NODE)))));
633 /*******************************************************************************
635 * FUNCTION: AcpiUtDumpAllocations
637 * PARAMETERS: Component - Component(s) to dump info for.
638 * Module - Module to dump info for. NULL means all.
642 * DESCRIPTION: Print a list of all outstanding allocations.
644 ******************************************************************************/
647 AcpiUtDumpAllocations (
651 ACPI_DEBUG_MEM_BLOCK *Element;
652 ACPI_DESCRIPTOR *Descriptor;
653 UINT32 NumOutstanding = 0;
654 UINT8 DescriptorType;
657 ACPI_FUNCTION_TRACE (UtDumpAllocations);
660 if (AcpiGbl_DisableMemTracking)
666 * Walk the allocation list.
668 if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_MEMORY)))
673 Element = AcpiGbl_GlobalList->ListHead;
676 if ((Element->Component & Component) &&
677 ((Module == NULL) || (0 == strcmp (Module, Element->Module))))
679 Descriptor = ACPI_CAST_PTR (
680 ACPI_DESCRIPTOR, &Element->UserSpace);
682 if (Element->Size < sizeof (ACPI_COMMON_DESCRIPTOR))
684 AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u "
685 "[Not a Descriptor - too small]\n",
686 Descriptor, Element->Size, Element->Module,
691 /* Ignore allocated objects that are in a cache */
693 if (ACPI_GET_DESCRIPTOR_TYPE (Descriptor) !=
694 ACPI_DESC_TYPE_CACHED)
696 AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u [%s] ",
697 Descriptor, Element->Size, Element->Module,
698 Element->Line, AcpiUtGetDescriptorName (Descriptor));
700 /* Validate the descriptor type using Type field and length */
702 DescriptorType = 0; /* Not a valid descriptor type */
704 switch (ACPI_GET_DESCRIPTOR_TYPE (Descriptor))
706 case ACPI_DESC_TYPE_OPERAND:
708 if (Element->Size == sizeof (ACPI_OPERAND_OBJECT))
710 DescriptorType = ACPI_DESC_TYPE_OPERAND;
714 case ACPI_DESC_TYPE_PARSER:
716 if (Element->Size == sizeof (ACPI_PARSE_OBJECT))
718 DescriptorType = ACPI_DESC_TYPE_PARSER;
722 case ACPI_DESC_TYPE_NAMED:
724 if (Element->Size == sizeof (ACPI_NAMESPACE_NODE))
726 DescriptorType = ACPI_DESC_TYPE_NAMED;
735 /* Display additional info for the major descriptor types */
737 switch (DescriptorType)
739 case ACPI_DESC_TYPE_OPERAND:
741 AcpiOsPrintf ("%12.12s RefCount 0x%04X\n",
742 AcpiUtGetTypeName (Descriptor->Object.Common.Type),
743 Descriptor->Object.Common.ReferenceCount);
746 case ACPI_DESC_TYPE_PARSER:
748 AcpiOsPrintf ("AmlOpcode 0x%04hX\n",
749 Descriptor->Op.Asl.AmlOpcode);
752 case ACPI_DESC_TYPE_NAMED:
754 AcpiOsPrintf ("%4.4s\n",
755 AcpiUtGetNodeName (&Descriptor->Node));
760 AcpiOsPrintf ( "\n");
769 Element = Element->Next;
772 (void) AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
778 ACPI_INFO (("No outstanding allocations"));
782 ACPI_ERROR ((AE_INFO, "%u(0x%X) Outstanding allocations",
783 NumOutstanding, NumOutstanding));
789 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */