1 /******************************************************************************
3 * Module Name: utalloc - local cache and memory allocation routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2004, R. Byron Moore
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 #include <acpi/acpi.h>
47 #define _COMPONENT ACPI_UTILITIES
48 ACPI_MODULE_NAME ("utalloc")
51 /******************************************************************************
53 * FUNCTION: acpi_ut_release_to_cache
55 * PARAMETERS: list_id - Memory list/cache ID
56 * Object - The object to be released
60 * DESCRIPTION: Release an object to the specified cache. If cache is full,
61 * the object is deleted.
63 ******************************************************************************/
66 acpi_ut_release_to_cache (
70 struct acpi_memory_list *cache_info;
73 ACPI_FUNCTION_ENTRY ();
76 /* If walk cache is full, just free this wallkstate object */
78 cache_info = &acpi_gbl_memory_lists[list_id];
79 if (cache_info->cache_depth >= cache_info->max_cache_depth) {
80 ACPI_MEM_FREE (object);
81 ACPI_MEM_TRACKING (cache_info->total_freed++);
84 /* Otherwise put this object back into the cache */
87 if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
91 /* Mark the object as cached */
93 ACPI_MEMSET (object, 0xCA, cache_info->object_size);
94 ACPI_SET_DESCRIPTOR_TYPE (object, ACPI_DESC_TYPE_CACHED);
96 /* Put the object at the head of the cache list */
98 * (ACPI_CAST_INDIRECT_PTR (char, &(((char *) object)[cache_info->link_offset]))) = cache_info->list_head;
99 cache_info->list_head = object;
100 cache_info->cache_depth++;
102 (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
107 /******************************************************************************
109 * FUNCTION: acpi_ut_acquire_from_cache
111 * PARAMETERS: list_id - Memory list ID
113 * RETURN: A requested object. NULL if the object could not be
116 * DESCRIPTION: Get an object from the specified cache. If cache is empty,
117 * the object is allocated.
119 ******************************************************************************/
122 acpi_ut_acquire_from_cache (
125 struct acpi_memory_list *cache_info;
129 ACPI_FUNCTION_NAME ("ut_acquire_from_cache");
132 cache_info = &acpi_gbl_memory_lists[list_id];
133 if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
137 ACPI_MEM_TRACKING (cache_info->cache_requests++);
139 /* Check the cache first */
141 if (cache_info->list_head) {
142 /* There is an object available, use it */
144 object = cache_info->list_head;
145 cache_info->list_head = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) object)[cache_info->link_offset])));
147 ACPI_MEM_TRACKING (cache_info->cache_hits++);
148 cache_info->cache_depth--;
150 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
151 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n",
152 object, acpi_gbl_memory_lists[list_id].list_name));
155 if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
159 /* Clear (zero) the previously used Object */
161 ACPI_MEMSET (object, 0, cache_info->object_size);
165 /* The cache is empty, create a new object */
167 /* Avoid deadlock with ACPI_MEM_CALLOCATE */
169 if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
173 object = ACPI_MEM_CALLOCATE (cache_info->object_size);
174 ACPI_MEM_TRACKING (cache_info->total_allocated++);
181 /******************************************************************************
183 * FUNCTION: acpi_ut_delete_generic_cache
185 * PARAMETERS: list_id - Memory list ID
189 * DESCRIPTION: Free all objects within the requested cache.
191 ******************************************************************************/
194 acpi_ut_delete_generic_cache (
197 struct acpi_memory_list *cache_info;
201 ACPI_FUNCTION_ENTRY ();
204 cache_info = &acpi_gbl_memory_lists[list_id];
205 while (cache_info->list_head) {
206 /* Delete one cached state object */
208 next = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) cache_info->list_head)[cache_info->link_offset])));
209 ACPI_MEM_FREE (cache_info->list_head);
211 cache_info->list_head = next;
212 cache_info->cache_depth--;
217 /*******************************************************************************
219 * FUNCTION: acpi_ut_validate_buffer
221 * PARAMETERS: Buffer - Buffer descriptor to be validated
225 * DESCRIPTION: Perform parameter validation checks on an struct acpi_buffer
227 ******************************************************************************/
230 acpi_ut_validate_buffer (
231 struct acpi_buffer *buffer)
234 /* Obviously, the structure pointer must be valid */
237 return (AE_BAD_PARAMETER);
240 /* Special semantics for the length */
242 if ((buffer->length == ACPI_NO_BUFFER) ||
243 (buffer->length == ACPI_ALLOCATE_BUFFER) ||
244 (buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
248 /* Length is valid, the buffer pointer must be also */
250 if (!buffer->pointer) {
251 return (AE_BAD_PARAMETER);
258 /*******************************************************************************
260 * FUNCTION: acpi_ut_initialize_buffer
262 * PARAMETERS: Buffer - Buffer to be validated
263 * required_length - Length needed
267 * DESCRIPTION: Validate that the buffer is of the required length or
268 * allocate a new buffer. Returned buffer is always zeroed.
270 ******************************************************************************/
273 acpi_ut_initialize_buffer (
274 struct acpi_buffer *buffer,
275 acpi_size required_length)
277 acpi_status status = AE_OK;
280 switch (buffer->length) {
283 /* Set the exception and returned the required length */
285 status = AE_BUFFER_OVERFLOW;
289 case ACPI_ALLOCATE_BUFFER:
291 /* Allocate a new buffer */
293 buffer->pointer = acpi_os_allocate (required_length);
294 if (!buffer->pointer) {
295 return (AE_NO_MEMORY);
298 /* Clear the buffer */
300 ACPI_MEMSET (buffer->pointer, 0, required_length);
304 case ACPI_ALLOCATE_LOCAL_BUFFER:
306 /* Allocate a new buffer with local interface to allow tracking */
308 buffer->pointer = ACPI_MEM_CALLOCATE (required_length);
309 if (!buffer->pointer) {
310 return (AE_NO_MEMORY);
317 /* Existing buffer: Validate the size of the buffer */
319 if (buffer->length < required_length) {
320 status = AE_BUFFER_OVERFLOW;
324 /* Clear the buffer */
326 ACPI_MEMSET (buffer->pointer, 0, required_length);
330 buffer->length = required_length;
335 /*******************************************************************************
337 * FUNCTION: acpi_ut_allocate
339 * PARAMETERS: Size - Size of the allocation
340 * Component - Component type of caller
341 * Module - Source file name of caller
342 * Line - Line number of caller
344 * RETURN: Address of the allocated memory on success, NULL on failure.
346 * DESCRIPTION: The subsystem's equivalent of malloc.
348 ******************************************************************************/
360 ACPI_FUNCTION_TRACE_U32 ("ut_allocate", size);
363 /* Check for an inadvertent size of zero bytes */
366 _ACPI_REPORT_ERROR (module, line, component,
367 ("ut_allocate: Attempt to allocate zero bytes\n"));
371 allocation = acpi_os_allocate (size);
373 /* Report allocation error */
375 _ACPI_REPORT_ERROR (module, line, component,
376 ("ut_allocate: Could not allocate size %X\n", (u32) size));
381 return_PTR (allocation);
385 /*******************************************************************************
387 * FUNCTION: acpi_ut_callocate
389 * PARAMETERS: Size - Size of the allocation
390 * Component - Component type of caller
391 * Module - Source file name of caller
392 * Line - Line number of caller
394 * RETURN: Address of the allocated memory on success, NULL on failure.
396 * DESCRIPTION: Subsystem equivalent of calloc.
398 ******************************************************************************/
410 ACPI_FUNCTION_TRACE_U32 ("ut_callocate", size);
413 /* Check for an inadvertent size of zero bytes */
416 _ACPI_REPORT_ERROR (module, line, component,
417 ("ut_callocate: Attempt to allocate zero bytes\n"));
421 allocation = acpi_os_allocate (size);
423 /* Report allocation error */
425 _ACPI_REPORT_ERROR (module, line, component,
426 ("ut_callocate: Could not allocate size %X\n", (u32) size));
430 /* Clear the memory block */
432 ACPI_MEMSET (allocation, 0, size);
433 return_PTR (allocation);
437 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
439 * These procedures are used for tracking memory leaks in the subsystem, and
440 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
442 * Each memory allocation is tracked via a doubly linked list. Each
443 * element contains the caller's component, module name, function name, and
444 * line number. acpi_ut_allocate and acpi_ut_callocate call
445 * acpi_ut_track_allocation to add an element to the list; deletion
446 * occurs in the body of acpi_ut_free.
450 /*******************************************************************************
452 * FUNCTION: acpi_ut_allocate_and_track
454 * PARAMETERS: Size - Size of the allocation
455 * Component - Component type of caller
456 * Module - Source file name of caller
457 * Line - Line number of caller
459 * RETURN: Address of the allocated memory on success, NULL on failure.
461 * DESCRIPTION: The subsystem's equivalent of malloc.
463 ******************************************************************************/
466 acpi_ut_allocate_and_track (
472 struct acpi_debug_mem_block *allocation;
476 allocation = acpi_ut_allocate (size + sizeof (struct acpi_debug_mem_header), component,
482 status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
483 ACPI_MEM_MALLOC, component, module, line);
484 if (ACPI_FAILURE (status)) {
485 acpi_os_free (allocation);
489 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
490 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) size;
492 return ((void *) &allocation->user_space);
496 /*******************************************************************************
498 * FUNCTION: acpi_ut_callocate_and_track
500 * PARAMETERS: Size - Size of the allocation
501 * Component - Component type of caller
502 * Module - Source file name of caller
503 * Line - Line number of caller
505 * RETURN: Address of the allocated memory on success, NULL on failure.
507 * DESCRIPTION: Subsystem equivalent of calloc.
509 ******************************************************************************/
512 acpi_ut_callocate_and_track (
518 struct acpi_debug_mem_block *allocation;
522 allocation = acpi_ut_callocate (size + sizeof (struct acpi_debug_mem_header), component,
525 /* Report allocation error */
527 _ACPI_REPORT_ERROR (module, line, component,
528 ("ut_callocate: Could not allocate size %X\n", (u32) size));
532 status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
533 ACPI_MEM_CALLOC, component, module, line);
534 if (ACPI_FAILURE (status)) {
535 acpi_os_free (allocation);
539 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
540 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) size;
542 return ((void *) &allocation->user_space);
546 /*******************************************************************************
548 * FUNCTION: acpi_ut_free_and_track
550 * PARAMETERS: Allocation - Address of the memory to deallocate
551 * Component - Component type of caller
552 * Module - Source file name of caller
553 * Line - Line number of caller
557 * DESCRIPTION: Frees the memory at Allocation
559 ******************************************************************************/
562 acpi_ut_free_and_track (
568 struct acpi_debug_mem_block *debug_block;
572 ACPI_FUNCTION_TRACE_PTR ("ut_free", allocation);
575 if (NULL == allocation) {
576 _ACPI_REPORT_ERROR (module, line, component,
577 ("acpi_ut_free: Attempt to delete a NULL address\n"));
582 debug_block = ACPI_CAST_PTR (struct acpi_debug_mem_block,
583 (((char *) allocation) - sizeof (struct acpi_debug_mem_header)));
585 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_freed++;
586 acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size -= debug_block->size;
588 status = acpi_ut_remove_allocation (ACPI_MEM_LIST_GLOBAL, debug_block,
589 component, module, line);
590 if (ACPI_FAILURE (status)) {
591 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not free memory, %s\n",
592 acpi_format_exception (status)));
595 acpi_os_free (debug_block);
597 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation));
603 /*******************************************************************************
605 * FUNCTION: acpi_ut_find_allocation
607 * PARAMETERS: list_id - Memory list to search
608 * Allocation - Address of allocated memory
610 * RETURN: A list element if found; NULL otherwise.
612 * DESCRIPTION: Searches for an element in the global allocation tracking list.
614 ******************************************************************************/
616 struct acpi_debug_mem_block *
617 acpi_ut_find_allocation (
621 struct acpi_debug_mem_block *element;
624 ACPI_FUNCTION_ENTRY ();
627 if (list_id > ACPI_MEM_LIST_MAX) {
631 element = acpi_gbl_memory_lists[list_id].list_head;
633 /* Search for the address. */
636 if (element == allocation) {
640 element = element->next;
647 /*******************************************************************************
649 * FUNCTION: acpi_ut_track_allocation
651 * PARAMETERS: list_id - Memory list to search
652 * Allocation - Address of allocated memory
653 * Size - Size of the allocation
654 * alloc_type - MEM_MALLOC or MEM_CALLOC
655 * Component - Component type of caller
656 * Module - Source file name of caller
657 * Line - Line number of caller
661 * DESCRIPTION: Inserts an element into the global allocation tracking list.
663 ******************************************************************************/
666 acpi_ut_track_allocation (
668 struct acpi_debug_mem_block *allocation,
675 struct acpi_memory_list *mem_list;
676 struct acpi_debug_mem_block *element;
677 acpi_status status = AE_OK;
680 ACPI_FUNCTION_TRACE_PTR ("ut_track_allocation", allocation);
683 if (list_id > ACPI_MEM_LIST_MAX) {
684 return_ACPI_STATUS (AE_BAD_PARAMETER);
687 mem_list = &acpi_gbl_memory_lists[list_id];
688 status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
689 if (ACPI_FAILURE (status)) {
690 return_ACPI_STATUS (status);
694 * Search list for this address to make sure it is not already on the list.
695 * This will catch several kinds of problems.
698 element = acpi_ut_find_allocation (list_id, allocation);
700 ACPI_REPORT_ERROR (("ut_track_allocation: Allocation already present in list! (%p)\n",
703 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n", element, allocation));
705 goto unlock_and_exit;
708 /* Fill in the instance data. */
710 allocation->size = (u32) size;
711 allocation->alloc_type = alloc_type;
712 allocation->component = component;
713 allocation->line = line;
715 ACPI_STRNCPY (allocation->module, module, ACPI_MAX_MODULE_NAME);
716 allocation->module[ACPI_MAX_MODULE_NAME-1] = 0;
718 /* Insert at list head */
720 if (mem_list->list_head) {
721 ((struct acpi_debug_mem_block *)(mem_list->list_head))->previous = allocation;
724 allocation->next = mem_list->list_head;
725 allocation->previous = NULL;
727 mem_list->list_head = allocation;
731 status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
732 return_ACPI_STATUS (status);
736 /*******************************************************************************
738 * FUNCTION: acpi_ut_remove_allocation
740 * PARAMETERS: list_id - Memory list to search
741 * Allocation - Address of allocated memory
742 * Component - Component type of caller
743 * Module - Source file name of caller
744 * Line - Line number of caller
748 * DESCRIPTION: Deletes an element from the global allocation tracking list.
750 ******************************************************************************/
753 acpi_ut_remove_allocation (
755 struct acpi_debug_mem_block *allocation,
760 struct acpi_memory_list *mem_list;
764 ACPI_FUNCTION_TRACE ("ut_remove_allocation");
767 if (list_id > ACPI_MEM_LIST_MAX) {
768 return_ACPI_STATUS (AE_BAD_PARAMETER);
771 mem_list = &acpi_gbl_memory_lists[list_id];
772 if (NULL == mem_list->list_head) {
773 /* No allocations! */
775 _ACPI_REPORT_ERROR (module, line, component,
776 ("ut_remove_allocation: Empty allocation list, nothing to free!\n"));
778 return_ACPI_STATUS (AE_OK);
781 status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
782 if (ACPI_FAILURE (status)) {
783 return_ACPI_STATUS (status);
788 if (allocation->previous) {
789 (allocation->previous)->next = allocation->next;
792 mem_list->list_head = allocation->next;
795 if (allocation->next) {
796 (allocation->next)->previous = allocation->previous;
799 /* Mark the segment as deleted */
801 ACPI_MEMSET (&allocation->user_space, 0xEA, allocation->size);
803 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n", allocation->size));
805 status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
806 return_ACPI_STATUS (status);
810 /*******************************************************************************
812 * FUNCTION: acpi_ut_dump_allocation_info
818 * DESCRIPTION: Print some info about the outstanding allocations.
820 ******************************************************************************/
821 #ifdef ACPI_FUTURE_USAGE
823 acpi_ut_dump_allocation_info (
827 struct acpi_memory_list *mem_list;
830 ACPI_FUNCTION_TRACE ("ut_dump_allocation_info");
833 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
834 ("%30s: %4d (%3d Kb)\n", "Current allocations",
835 mem_list->current_count,
836 ROUND_UP_TO_1K (mem_list->current_size)));
838 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
839 ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
840 mem_list->max_concurrent_count,
841 ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
844 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
845 ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
846 running_object_count,
847 ROUND_UP_TO_1K (running_object_size)));
849 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
850 ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
852 ROUND_UP_TO_1K (running_alloc_size)));
855 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
856 ("%30s: %4d (%3d Kb)\n", "Current Nodes",
857 acpi_gbl_current_node_count,
858 ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
860 ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
861 ("%30s: %4d (%3d Kb)\n", "Max Nodes",
862 acpi_gbl_max_concurrent_node_count,
863 ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count * sizeof (struct acpi_namespace_node)))));
867 #endif /* ACPI_FUTURE_USAGE */
870 /*******************************************************************************
872 * FUNCTION: acpi_ut_dump_allocations
874 * PARAMETERS: Component - Component(s) to dump info for.
875 * Module - Module to dump info for. NULL means all.
879 * DESCRIPTION: Print a list of all outstanding allocations.
881 ******************************************************************************/
884 acpi_ut_dump_allocations (
888 struct acpi_debug_mem_block *element;
889 union acpi_descriptor *descriptor;
890 u32 num_outstanding = 0;
893 ACPI_FUNCTION_TRACE ("ut_dump_allocations");
897 * Walk the allocation list.
899 if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_MEMORY))) {
903 element = acpi_gbl_memory_lists[0].list_head;
905 if ((element->component & component) &&
906 ((module == NULL) || (0 == ACPI_STRCMP (module, element->module)))) {
907 /* Ignore allocated objects that are in a cache */
909 descriptor = ACPI_CAST_PTR (union acpi_descriptor, &element->user_space);
910 if (descriptor->descriptor_id != ACPI_DESC_TYPE_CACHED) {
911 acpi_os_printf ("%p Len %04X %9.9s-%d [%s] ",
912 descriptor, element->size, element->module,
913 element->line, acpi_ut_get_descriptor_name (descriptor));
915 /* Most of the elements will be Operand objects. */
917 switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) {
918 case ACPI_DESC_TYPE_OPERAND:
919 acpi_os_printf ("%12.12s R%hd",
920 acpi_ut_get_type_name (descriptor->object.common.type),
921 descriptor->object.common.reference_count);
924 case ACPI_DESC_TYPE_PARSER:
925 acpi_os_printf ("aml_opcode %04hX",
926 descriptor->op.asl.aml_opcode);
929 case ACPI_DESC_TYPE_NAMED:
930 acpi_os_printf ("%4.4s",
931 acpi_ut_get_node_name (&descriptor->node));
938 acpi_os_printf ( "\n");
942 element = element->next;
945 (void) acpi_ut_release_mutex (ACPI_MTX_MEMORY);
949 if (!num_outstanding) {
950 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
951 "No outstanding allocations.\n"));
954 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
955 "%d(%X) Outstanding allocations\n",
956 num_outstanding, num_outstanding));
963 #endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */