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