1/******************************************************************************
2 *
3 * Module Name: utalloc - local cache and memory allocation routines
4 *              $Revision: 1.1.1.1 $
5 *
6 *****************************************************************************/
7
8/*
9 *  Copyright (C) 2000, 2001 R. Byron Moore
10 *
11 *  This program is free software; you can redistribute it and/or modify
12 *  it under the terms of the GNU General Public License as published by
13 *  the Free Software Foundation; either version 2 of the License, or
14 *  (at your option) any later version.
15 *
16 *  This program is distributed in the hope that it will be useful,
17 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *  GNU General Public License for more details.
20 *
21 *  You should have received a copy of the GNU General Public License
22 *  along with this program; if not, write to the Free Software
23 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24 */
25
26
27#include "acpi.h"
28#include "acparser.h"
29#include "acinterp.h"
30#include "acnamesp.h"
31#include "acglobal.h"
32
33#define _COMPONENT          ACPI_UTILITIES
34	 MODULE_NAME         ("utalloc")
35
36
37/******************************************************************************
38 *
39 * FUNCTION:    Acpi_ut_release_to_cache
40 *
41 * PARAMETERS:  List_id             - Memory list/cache ID
42 *              Object              - The object to be released
43 *
44 * RETURN:      None
45 *
46 * DESCRIPTION: Release an object to the specified cache.  If cache is full,
47 *              the object is deleted.
48 *
49 ******************************************************************************/
50
51void
52acpi_ut_release_to_cache (
53	u32                     list_id,
54	void                    *object)
55{
56	ACPI_MEMORY_LIST        *cache_info;
57
58
59	FUNCTION_ENTRY ();
60
61
62	/* If walk cache is full, just free this wallkstate object */
63
64	cache_info = &acpi_gbl_memory_lists[list_id];
65	if (cache_info->cache_depth >= cache_info->max_cache_depth) {
66		ACPI_MEM_FREE (object);
67		ACPI_MEM_TRACKING (cache_info->total_freed++);
68	}
69
70	/* Otherwise put this object back into the cache */
71
72	else {
73		acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
74
75		/* Mark the object as cached */
76
77		MEMSET (object, 0xCA, cache_info->object_size);
78		((acpi_operand_object *) object)->common.data_type = ACPI_CACHED_OBJECT;
79
80		/* Put the object at the head of the cache list */
81
82		* (char **) (((char *) object) + cache_info->link_offset) = cache_info->list_head;
83		cache_info->list_head = object;
84		cache_info->cache_depth++;
85
86		acpi_ut_release_mutex (ACPI_MTX_CACHES);
87	}
88}
89
90
91/******************************************************************************
92 *
93 * FUNCTION:    Acpi_ut_acquire_from_cache
94 *
95 * PARAMETERS:  List_id             - Memory list ID
96 *
97 * RETURN:      A requested object.  NULL if the object could not be
98 *              allocated.
99 *
100 * DESCRIPTION: Get an object from the specified cache.  If cache is empty,
101 *              the object is allocated.
102 *
103 ******************************************************************************/
104
105void *
106acpi_ut_acquire_from_cache (
107	u32                     list_id)
108{
109	ACPI_MEMORY_LIST        *cache_info;
110	void                    *object;
111
112
113	PROC_NAME ("Ut_acquire_from_cache");
114
115
116	cache_info = &acpi_gbl_memory_lists[list_id];
117	acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
118	ACPI_MEM_TRACKING (cache_info->cache_requests++);
119
120	/* Check the cache first */
121
122	if (cache_info->list_head) {
123		/* There is an object available, use it */
124
125		object = cache_info->list_head;
126		cache_info->list_head = * (char **) (((char *) object) + cache_info->link_offset);
127
128		ACPI_MEM_TRACKING (cache_info->cache_hits++);
129		cache_info->cache_depth--;
130
131#ifdef ACPI_DBG_TRACK_ALLOCATIONS
132		ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n",
133			object, acpi_gbl_memory_lists[list_id].list_name));
134#endif
135
136		acpi_ut_release_mutex (ACPI_MTX_CACHES);
137
138		/* Clear (zero) the previously used Object */
139
140		MEMSET (object, 0, cache_info->object_size);
141	}
142
143	else {
144		/* The cache is empty, create a new object */
145
146		/* Avoid deadlock with ACPI_MEM_CALLOCATE */
147
148		acpi_ut_release_mutex (ACPI_MTX_CACHES);
149
150		object = ACPI_MEM_CALLOCATE (cache_info->object_size);
151		ACPI_MEM_TRACKING (cache_info->total_allocated++);
152	}
153
154	return (object);
155}
156
157
158/******************************************************************************
159 *
160 * FUNCTION:    Acpi_ut_delete_generic_cache
161 *
162 * PARAMETERS:  List_id         - Memory list ID
163 *
164 * RETURN:      None
165 *
166 * DESCRIPTION: Free all objects within the requested cache.
167 *
168 ******************************************************************************/
169
170void
171acpi_ut_delete_generic_cache (
172	u32                     list_id)
173{
174	ACPI_MEMORY_LIST        *cache_info;
175	char                    *next;
176
177
178	FUNCTION_ENTRY ();
179
180
181	cache_info = &acpi_gbl_memory_lists[list_id];
182	while (cache_info->list_head) {
183		/* Delete one cached state object */
184
185		next = * (char **) (((char *) cache_info->list_head) + cache_info->link_offset);
186		ACPI_MEM_FREE (cache_info->list_head);
187
188		cache_info->list_head = next;
189		cache_info->cache_depth--;
190	}
191}
192
193
194#ifdef ACPI_DBG_TRACK_ALLOCATIONS
195
196
197/*
198 * These procedures are used for tracking memory leaks in the subsystem, and
199 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
200 *
201 * Each memory allocation is tracked via a doubly linked list.  Each
202 * element contains the caller's component, module name, function name, and
203 * line number.  Acpi_ut_allocate and Acpi_ut_callocate call
204 * Acpi_ut_track_allocation to add an element to the list; deletion
205 * occurs in the body of Acpi_ut_free.
206 */
207
208
209/*******************************************************************************
210 *
211 * FUNCTION:    Acpi_ut_find_allocation
212 *
213 * PARAMETERS:  Address             - Address of allocated memory
214 *
215 * RETURN:      A list element if found; NULL otherwise.
216 *
217 * DESCRIPTION: Searches for an element in the global allocation tracking list.
218 *
219 ******************************************************************************/
220
221acpi_debug_mem_block *
222acpi_ut_find_allocation (
223	u32                     list_id,
224	void                    *address)
225{
226	acpi_debug_mem_block    *element;
227
228
229	FUNCTION_ENTRY ();
230
231
232	if (list_id > ACPI_MEM_LIST_MAX) {
233		return (NULL);
234	}
235
236	element = acpi_gbl_memory_lists[list_id].list_head;
237
238	/* Search for the address. */
239
240	while (element) {
241		if (element == address) {
242			return (element);
243		}
244
245		element = element->next;
246	}
247
248	return (NULL);
249}
250
251
252/*******************************************************************************
253 *
254 * FUNCTION:    Acpi_ut_track_allocation
255 *
256 * PARAMETERS:  Address             - Address of allocated memory
257 *              Size                - Size of the allocation
258 *              Alloc_type          - MEM_MALLOC or MEM_CALLOC
259 *              Component           - Component type of caller
260 *              Module              - Source file name of caller
261 *              Line                - Line number of caller
262 *
263 * RETURN:      None.
264 *
265 * DESCRIPTION: Inserts an element into the global allocation tracking list.
266 *
267 ******************************************************************************/
268
269acpi_status
270acpi_ut_track_allocation (
271	u32                     list_id,
272	acpi_debug_mem_block    *address,
273	u32                     size,
274	u8                      alloc_type,
275	u32                     component,
276	NATIVE_CHAR             *module,
277	u32                     line)
278{
279	ACPI_MEMORY_LIST        *mem_list;
280	acpi_debug_mem_block    *element;
281	acpi_status             status = AE_OK;
282
283
284	FUNCTION_TRACE_PTR ("Ut_track_allocation", address);
285
286
287	if (list_id > ACPI_MEM_LIST_MAX) {
288		return_ACPI_STATUS (AE_BAD_PARAMETER);
289	}
290
291	mem_list = &acpi_gbl_memory_lists[list_id];
292	acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
293
294	/*
295	 * Search list for this address to make sure it is not already on the list.
296	 * This will catch several kinds of problems.
297	 */
298
299	element = acpi_ut_find_allocation (list_id, address);
300	if (element) {
301		REPORT_ERROR (("Ut_track_allocation: Address already present in list! (%p)\n",
302			address));
303
304		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n", element, address));
305
306		goto unlock_and_exit;
307	}
308
309	/* Fill in the instance data. */
310
311	address->size      = size;
312	address->alloc_type = alloc_type;
313	address->component = component;
314	address->line      = line;
315
316	STRNCPY (address->module, module, MAX_MODULE_NAME);
317
318	/* Insert at list head */
319
320	if (mem_list->list_head) {
321		((acpi_debug_mem_block *)(mem_list->list_head))->previous = address;
322	}
323
324	address->next = mem_list->list_head;
325	address->previous = NULL;
326
327	mem_list->list_head = address;
328
329
330unlock_and_exit:
331	acpi_ut_release_mutex (ACPI_MTX_MEMORY);
332	return_ACPI_STATUS (status);
333}
334
335
336/*******************************************************************************
337 *
338 * FUNCTION:    Acpi_ut_remove_allocation
339 *
340 * PARAMETERS:  Address             - Address of allocated memory
341 *              Component           - Component type of caller
342 *              Module              - Source file name of caller
343 *              Line                - Line number of caller
344 *
345 * RETURN:
346 *
347 * DESCRIPTION: Deletes an element from the global allocation tracking list.
348 *
349 ******************************************************************************/
350
351acpi_status
352acpi_ut_remove_allocation (
353	u32                     list_id,
354	acpi_debug_mem_block    *address,
355	u32                     component,
356	NATIVE_CHAR             *module,
357	u32                     line)
358{
359	ACPI_MEMORY_LIST        *mem_list;
360
361
362	FUNCTION_TRACE ("Ut_remove_allocation");
363
364
365	if (list_id > ACPI_MEM_LIST_MAX) {
366		return_ACPI_STATUS (AE_BAD_PARAMETER);
367	}
368
369	mem_list = &acpi_gbl_memory_lists[list_id];
370	if (NULL == mem_list->list_head) {
371		/* No allocations! */
372
373		_REPORT_ERROR (module, line, component,
374				("Ut_remove_allocation: Empty allocation list, nothing to free!\n"));
375
376		return_ACPI_STATUS (AE_OK);
377	}
378
379
380	acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
381
382	/* Unlink */
383
384	if (address->previous) {
385		(address->previous)->next = address->next;
386	}
387	else {
388		mem_list->list_head = address->next;
389	}
390
391	if (address->next) {
392		(address->next)->previous = address->previous;
393	}
394
395
396	/* Mark the segment as deleted */
397
398	MEMSET (&address->user_space, 0xEA, address->size);
399
400	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size %X\n", address->size));
401
402	acpi_ut_release_mutex (ACPI_MTX_MEMORY);
403	return_ACPI_STATUS (AE_OK);
404}
405
406
407/*******************************************************************************
408 *
409 * FUNCTION:    Acpi_ut_dump_allocation_info
410 *
411 * PARAMETERS:
412 *
413 * RETURN:      None
414 *
415 * DESCRIPTION: Print some info about the outstanding allocations.
416 *
417 ******************************************************************************/
418
419void
420acpi_ut_dump_allocation_info (
421	void)
422{
423/*
424	ACPI_MEMORY_LIST        *Mem_list;
425*/
426
427	FUNCTION_TRACE ("Ut_dump_allocation_info");
428
429/*
430	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
431			  ("%30s: %4d (%3d Kb)\n", "Current allocations",
432			  Mem_list->Current_count,
433			  ROUND_UP_TO_1K (Mem_list->Current_size)));
434
435	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
436			  ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
437			  Mem_list->Max_concurrent_count,
438			  ROUND_UP_TO_1K (Mem_list->Max_concurrent_size)));
439
440
441	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
442			  ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
443			  Running_object_count,
444			  ROUND_UP_TO_1K (Running_object_size)));
445
446	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
447			  ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
448			  Running_alloc_count,
449			  ROUND_UP_TO_1K (Running_alloc_size)));
450
451
452	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
453			  ("%30s: %4d (%3d Kb)\n", "Current Nodes",
454			  Acpi_gbl_Current_node_count,
455			  ROUND_UP_TO_1K (Acpi_gbl_Current_node_size)));
456
457	ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
458			  ("%30s: %4d (%3d Kb)\n", "Max Nodes",
459			  Acpi_gbl_Max_concurrent_node_count,
460			  ROUND_UP_TO_1K ((Acpi_gbl_Max_concurrent_node_count * sizeof (acpi_namespace_node)))));
461*/
462	return_VOID;
463}
464
465
466/*******************************************************************************
467 *
468 * FUNCTION:    Acpi_ut_dump_allocations
469 *
470 * PARAMETERS:  Component           - Component(s) to dump info for.
471 *              Module              - Module to dump info for.  NULL means all.
472 *
473 * RETURN:      None
474 *
475 * DESCRIPTION: Print a list of all outstanding allocations.
476 *
477 ******************************************************************************/
478
479void
480acpi_ut_dump_allocations (
481	u32                     component,
482	NATIVE_CHAR             *module)
483{
484	acpi_debug_mem_block    *element;
485	u32                     i;
486
487
488	FUNCTION_TRACE ("Ut_dump_allocations");
489
490
491	element = acpi_gbl_memory_lists[0].list_head;
492	if (element == NULL) {
493		ACPI_DEBUG_PRINT ((ACPI_DB_OK,
494				"No outstanding allocations.\n"));
495		return_VOID;
496	}
497
498
499	/*
500	 * Walk the allocation list.
501	 */
502	acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
503
504	ACPI_DEBUG_PRINT ((ACPI_DB_OK,
505		"Outstanding allocations:\n"));
506
507	for (i = 1; ; i++)  /* Just a counter */ {
508		if ((element->component & component) &&
509			((module == NULL) || (0 == STRCMP (module, element->module)))) {
510			if (((acpi_operand_object  *)(&element->user_space))->common.type != ACPI_CACHED_OBJECT) {
511				ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
512						 "%p Len %04X %9.9s-%d",
513						 &element->user_space, element->size, element->module,
514						 element->line));
515
516				/* Most of the elements will be internal objects. */
517
518				switch (((acpi_operand_object  *)
519					(&element->user_space))->common.data_type) {
520				case ACPI_DESC_TYPE_INTERNAL:
521					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
522							" Obj_type %12.12s R%d",
523							acpi_ut_get_type_name (((acpi_operand_object *)(&element->user_space))->common.type),
524							((acpi_operand_object *)(&element->user_space))->common.reference_count));
525					break;
526
527				case ACPI_DESC_TYPE_PARSER:
528					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
529							" Parse_obj Opcode %04X",
530							((acpi_parse_object *)(&element->user_space))->opcode));
531					break;
532
533				case ACPI_DESC_TYPE_NAMED:
534					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
535							" Node %4.4s",
536							(char*)&((acpi_namespace_node *)(&element->user_space))->name));
537					break;
538
539				case ACPI_DESC_TYPE_STATE:
540					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
541							" Untyped State_obj"));
542					break;
543
544				case ACPI_DESC_TYPE_STATE_UPDATE:
545					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
546							" UPDATE State_obj"));
547					break;
548
549				case ACPI_DESC_TYPE_STATE_PACKAGE:
550					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
551							" PACKAGE State_obj"));
552					break;
553
554				case ACPI_DESC_TYPE_STATE_CONTROL:
555					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
556							" CONTROL State_obj"));
557					break;
558
559				case ACPI_DESC_TYPE_STATE_RPSCOPE:
560					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
561							" ROOT-PARSE-SCOPE State_obj"));
562					break;
563
564				case ACPI_DESC_TYPE_STATE_PSCOPE:
565					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
566							" PARSE-SCOPE State_obj"));
567					break;
568
569				case ACPI_DESC_TYPE_STATE_WSCOPE:
570					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
571							" WALK-SCOPE State_obj"));
572					break;
573
574				case ACPI_DESC_TYPE_STATE_RESULT:
575					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
576							" RESULT State_obj"));
577					break;
578
579				case ACPI_DESC_TYPE_STATE_NOTIFY:
580					ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
581							" NOTIFY State_obj"));
582					break;
583				}
584
585				ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "\n"));
586			}
587		}
588
589		if (element->next == NULL) {
590			break;
591		}
592
593		element = element->next;
594	}
595
596	acpi_ut_release_mutex (ACPI_MTX_MEMORY);
597
598	ACPI_DEBUG_PRINT ((ACPI_DB_OK,
599		"Total number of unfreed allocations = %d(%X)\n", i,i));
600
601
602	return_VOID;
603
604}
605
606
607/*******************************************************************************
608 *
609 * FUNCTION:    Acpi_ut_allocate
610 *
611 * PARAMETERS:  Size                - Size of the allocation
612 *              Component           - Component type of caller
613 *              Module              - Source file name of caller
614 *              Line                - Line number of caller
615 *
616 * RETURN:      Address of the allocated memory on success, NULL on failure.
617 *
618 * DESCRIPTION: The subsystem's equivalent of malloc.
619 *
620 ******************************************************************************/
621
622void *
623acpi_ut_allocate (
624	u32                     size,
625	u32                     component,
626	NATIVE_CHAR             *module,
627	u32                     line)
628{
629	acpi_debug_mem_block    *address;
630	acpi_status             status;
631
632
633	FUNCTION_TRACE_U32 ("Ut_allocate", size);
634
635
636	/* Check for an inadvertent size of zero bytes */
637
638	if (!size) {
639		_REPORT_ERROR (module, line, component,
640				("Ut_allocate: Attempt to allocate zero bytes\n"));
641		size = 1;
642	}
643
644	address = acpi_os_allocate (size + sizeof (acpi_debug_mem_block));
645	if (!address) {
646		/* Report allocation error */
647
648		_REPORT_ERROR (module, line, component,
649				("Ut_allocate: Could not allocate size %X\n", size));
650
651		return_PTR (NULL);
652	}
653
654	status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, address, size,
655			  MEM_MALLOC, component, module, line);
656	if (ACPI_FAILURE (status)) {
657		acpi_os_free (address);
658		return_PTR (NULL);
659	}
660
661	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
662	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += size;
663
664	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", address, size));
665
666	return_PTR ((void *) &address->user_space);
667}
668
669
670/*******************************************************************************
671 *
672 * FUNCTION:    Acpi_ut_callocate
673 *
674 * PARAMETERS:  Size                - Size of the allocation
675 *              Component           - Component type of caller
676 *              Module              - Source file name of caller
677 *              Line                - Line number of caller
678 *
679 * RETURN:      Address of the allocated memory on success, NULL on failure.
680 *
681 * DESCRIPTION: Subsystem equivalent of calloc.
682 *
683 ******************************************************************************/
684
685void *
686acpi_ut_callocate (
687	u32                     size,
688	u32                     component,
689	NATIVE_CHAR             *module,
690	u32                     line)
691{
692	acpi_debug_mem_block    *address;
693	acpi_status             status;
694
695
696	FUNCTION_TRACE_U32 ("Ut_callocate", size);
697
698
699	/* Check for an inadvertent size of zero bytes */
700
701	if (!size) {
702		_REPORT_ERROR (module, line, component,
703				("Ut_callocate: Attempt to allocate zero bytes\n"));
704		return_PTR (NULL);
705	}
706
707
708	address = acpi_os_callocate (size + sizeof (acpi_debug_mem_block));
709	if (!address) {
710		/* Report allocation error */
711
712		_REPORT_ERROR (module, line, component,
713				("Ut_callocate: Could not allocate size %X\n", size));
714		return_PTR (NULL);
715	}
716
717	status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, address, size,
718			   MEM_CALLOC, component, module, line);
719	if (ACPI_FAILURE (status)) {
720		acpi_os_free (address);
721		return_PTR (NULL);
722	}
723
724	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
725	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += size;
726
727	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", address, size));
728	return_PTR ((void *) &address->user_space);
729}
730
731
732/*******************************************************************************
733 *
734 * FUNCTION:    Acpi_ut_free
735 *
736 * PARAMETERS:  Address             - Address of the memory to deallocate
737 *              Component           - Component type of caller
738 *              Module              - Source file name of caller
739 *              Line                - Line number of caller
740 *
741 * RETURN:      None
742 *
743 * DESCRIPTION: Frees the memory at Address
744 *
745 ******************************************************************************/
746
747void
748acpi_ut_free (
749	void                    *address,
750	u32                     component,
751	NATIVE_CHAR             *module,
752	u32                     line)
753{
754	acpi_debug_mem_block    *debug_block;
755
756
757	FUNCTION_TRACE_PTR ("Ut_free", address);
758
759
760	if (NULL == address) {
761		_REPORT_ERROR (module, line, component,
762			("Acpi_ut_free: Trying to delete a NULL address\n"));
763
764		return_VOID;
765	}
766
767	debug_block = (acpi_debug_mem_block *)
768			  (((char *) address) - sizeof (acpi_debug_mem_header));
769
770	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_freed++;
771	acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size -= debug_block->size;
772
773	acpi_ut_remove_allocation (ACPI_MEM_LIST_GLOBAL, debug_block,
774			component, module, line);
775	acpi_os_free (debug_block);
776
777	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", address));
778
779	return_VOID;
780}
781
782#endif  /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */
783
784