err.no Git - linux-2.6/blob - drivers/acpi/utilities/utalloc.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utalloc - local cache and memory allocation routines
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  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.
  25  *
  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.
  29  *
  30  * NO WARRANTY
  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.
  42  */
  43
  44
  45 #include <acpi/acpi.h>
  46
  47 #define _COMPONENT          ACPI_UTILITIES
  48          ACPI_MODULE_NAME    ("utalloc")
  49
  50 /* Local prototypes */
  51
  52 #ifdef  ACPI_DBG_TRACK_ALLOCATIONS
  53 static struct acpi_debug_mem_block *
  54 acpi_ut_find_allocation (
  55         u32                             list_id,
  56         void                            *allocation);
  57
  58 static acpi_status
  59 acpi_ut_track_allocation (
  60         u32                             list_id,
  61         struct acpi_debug_mem_block     *address,
  62         acpi_size                       size,
  63         u8                              alloc_type,
  64         u32                             component,
  65         char                            *module,
  66         u32                             line);
  67
  68 static acpi_status
  69 acpi_ut_remove_allocation (
  70         u32                             list_id,
  71         struct acpi_debug_mem_block     *address,
  72         u32                             component,
  73         char                            *module,
  74         u32                             line);
  75 #endif  /* ACPI_DBG_TRACK_ALLOCATIONS */
  76
  77
  78 /*******************************************************************************
  79  *
  80  * FUNCTION:    acpi_ut_release_to_cache
  81  *
  82  * PARAMETERS:  list_id             - Memory list/cache ID
  83  *              Object              - The object to be released
  84  *
  85  * RETURN:      None
  86  *
  87  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
  88  *              the object is deleted.
  89  *
  90  ******************************************************************************/
  91
  92 void
  93 acpi_ut_release_to_cache (
  94         u32                             list_id,
  95         void                            *object)
  96 {
  97         struct acpi_memory_list         *cache_info;
  98
  99
 100         ACPI_FUNCTION_ENTRY ();
 101
 102
 103         cache_info = &acpi_gbl_memory_lists[list_id];
 104
 105 #ifdef ACPI_ENABLE_OBJECT_CACHE
 106
 107         /* If walk cache is full, just free this wallkstate object */
 108
 109         if (cache_info->cache_depth >= cache_info->max_cache_depth) {
 110                 ACPI_MEM_FREE (object);
 111                 ACPI_MEM_TRACKING (cache_info->total_freed++);
 112         }
 113
 114         /* Otherwise put this object back into the cache */
 115
 116         else {
 117                 if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
 118                         return;
 119                 }
 120
 121                 /* Mark the object as cached */
 122
 123                 ACPI_MEMSET (object, 0xCA, cache_info->object_size);
 124                 ACPI_SET_DESCRIPTOR_TYPE (object, ACPI_DESC_TYPE_CACHED);
 125
 126                 /* Put the object at the head of the cache list */
 127
 128                 * (ACPI_CAST_INDIRECT_PTR (char,
 129                         &(((char *) object)[cache_info->link_offset]))) = cache_info->list_head;
 130                 cache_info->list_head = object;
 131                 cache_info->cache_depth++;
 132
 133                 (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
 134         }
 135
 136 #else
 137
 138         /* Object cache is disabled; just free the object */
 139
 140         ACPI_MEM_FREE (object);
 141         ACPI_MEM_TRACKING (cache_info->total_freed++);
 142 #endif
 143 }
 144
 145
 146 /*******************************************************************************
 147  *
 148  * FUNCTION:    acpi_ut_acquire_from_cache
 149  *
 150  * PARAMETERS:  list_id             - Memory list ID
 151  *
 152  * RETURN:      A requested object.  NULL if the object could not be
 153  *              allocated.
 154  *
 155  * DESCRIPTION: Get an object from the specified cache.  If cache is empty,
 156  *              the object is allocated.
 157  *
 158  ******************************************************************************/
 159
 160 void *
 161 acpi_ut_acquire_from_cache (
 162         u32                             list_id)
 163 {
 164         struct acpi_memory_list         *cache_info;
 165         void                            *object;
 166
 167
 168         ACPI_FUNCTION_NAME ("ut_acquire_from_cache");
 169
 170
 171         cache_info = &acpi_gbl_memory_lists[list_id];
 172
 173 #ifdef ACPI_ENABLE_OBJECT_CACHE
 174
 175         if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
 176                 return (NULL);
 177         }
 178
 179         ACPI_MEM_TRACKING (cache_info->cache_requests++);
 180
 181         /* Check the cache first */
 182
 183         if (cache_info->list_head) {
 184                 /* There is an object available, use it */
 185
 186                 object = cache_info->list_head;
 187                 cache_info->list_head = *(ACPI_CAST_INDIRECT_PTR (char,
 188                                  &(((char *) object)[cache_info->link_offset])));
 189
 190                 ACPI_MEM_TRACKING (cache_info->cache_hits++);
 191                 cache_info->cache_depth--;
 192
 193 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 194                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n",
 195                         object, acpi_gbl_memory_lists[list_id].list_name));
 196 #endif
 197
 198                 if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
 199                         return (NULL);
 200                 }
 201
 202                 /* Clear (zero) the previously used Object */
 203
 204                 ACPI_MEMSET (object, 0, cache_info->object_size);
 205         }
 206
 207         else {
 208                 /* The cache is empty, create a new object */
 209
 210                 /* Avoid deadlock with ACPI_MEM_CALLOCATE */
 211
 212                 if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
 213                         return (NULL);
 214                 }
 215
 216                 object = ACPI_MEM_CALLOCATE (cache_info->object_size);
 217                 ACPI_MEM_TRACKING (cache_info->total_allocated++);
 218         }
 219
 220 #else
 221
 222         /* Object cache is disabled; just allocate the object */
 223
 224         object = ACPI_MEM_CALLOCATE (cache_info->object_size);
 225         ACPI_MEM_TRACKING (cache_info->total_allocated++);
 226 #endif
 227
 228         return (object);
 229 }
 230
 231
 232 #ifdef ACPI_ENABLE_OBJECT_CACHE
 233 /*******************************************************************************
 234  *
 235  * FUNCTION:    acpi_ut_delete_generic_cache
 236  *
 237  * PARAMETERS:  list_id         - Memory list ID
 238  *
 239  * RETURN:      None
 240  *
 241  * DESCRIPTION: Free all objects within the requested cache.
 242  *
 243  ******************************************************************************/
 244
 245 void
 246 acpi_ut_delete_generic_cache (
 247         u32                             list_id)
 248 {
 249         struct acpi_memory_list         *cache_info;
 250         char                            *next;
 251
 252
 253         ACPI_FUNCTION_ENTRY ();
 254
 255
 256         cache_info = &acpi_gbl_memory_lists[list_id];
 257         while (cache_info->list_head) {
 258                 /* Delete one cached state object */
 259
 260                 next = *(ACPI_CAST_INDIRECT_PTR (char,
 261                                  &(((char *) cache_info->list_head)[cache_info->link_offset])));
 262                 ACPI_MEM_FREE (cache_info->list_head);
 263
 264                 cache_info->list_head = next;
 265                 cache_info->cache_depth--;
 266         }
 267 }
 268 #endif
 269
 270
 271 /*******************************************************************************
 272  *
 273  * FUNCTION:    acpi_ut_validate_buffer
 274  *
 275  * PARAMETERS:  Buffer              - Buffer descriptor to be validated
 276  *
 277  * RETURN:      Status
 278  *
 279  * DESCRIPTION: Perform parameter validation checks on an struct acpi_buffer
 280  *
 281  ******************************************************************************/
 282
 283 acpi_status
 284 acpi_ut_validate_buffer (
 285         struct acpi_buffer              *buffer)
 286 {
 287
 288         /* Obviously, the structure pointer must be valid */
 289
 290         if (!buffer) {
 291                 return (AE_BAD_PARAMETER);
 292         }
 293
 294         /* Special semantics for the length */
 295
 296         if ((buffer->length == ACPI_NO_BUFFER)              ||
 297                 (buffer->length == ACPI_ALLOCATE_BUFFER)        ||
 298                 (buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
 299                 return (AE_OK);
 300         }
 301
 302         /* Length is valid, the buffer pointer must be also */
 303
 304         if (!buffer->pointer) {
 305                 return (AE_BAD_PARAMETER);
 306         }
 307
 308         return (AE_OK);
 309 }
 310
 311
 312 /*******************************************************************************
 313  *
 314  * FUNCTION:    acpi_ut_initialize_buffer
 315  *
 316  * PARAMETERS:  Buffer              - Buffer to be validated
 317  *              required_length     - Length needed
 318  *
 319  * RETURN:      Status
 320  *
 321  * DESCRIPTION: Validate that the buffer is of the required length or
 322  *              allocate a new buffer.  Returned buffer is always zeroed.
 323  *
 324  ******************************************************************************/
 325
 326 acpi_status
 327 acpi_ut_initialize_buffer (
 328         struct acpi_buffer              *buffer,
 329         acpi_size                       required_length)
 330 {
 331         acpi_status                     status = AE_OK;
 332
 333
 334         switch (buffer->length) {
 335         case ACPI_NO_BUFFER:
 336
 337                 /* Set the exception and returned the required length */
 338
 339                 status = AE_BUFFER_OVERFLOW;
 340                 break;
 341
 342
 343         case ACPI_ALLOCATE_BUFFER:
 344
 345                 /* Allocate a new buffer */
 346
 347                 buffer->pointer = acpi_os_allocate (required_length);
 348                 if (!buffer->pointer) {
 349                         return (AE_NO_MEMORY);
 350                 }
 351
 352                 /* Clear the buffer */
 353
 354                 ACPI_MEMSET (buffer->pointer, 0, required_length);
 355                 break;
 356
 357
 358         case ACPI_ALLOCATE_LOCAL_BUFFER:
 359
 360                 /* Allocate a new buffer with local interface to allow tracking */
 361
 362                 buffer->pointer = ACPI_MEM_CALLOCATE (required_length);
 363                 if (!buffer->pointer) {
 364                         return (AE_NO_MEMORY);
 365                 }
 366                 break;
 367
 368
 369         default:
 370
 371                 /* Existing buffer: Validate the size of the buffer */
 372
 373                 if (buffer->length < required_length) {
 374                         status = AE_BUFFER_OVERFLOW;
 375                         break;
 376                 }
 377
 378                 /* Clear the buffer */
 379
 380                 ACPI_MEMSET (buffer->pointer, 0, required_length);
 381                 break;
 382         }
 383
 384         buffer->length = required_length;
 385         return (status);
 386 }
 387
 388
 389 /*******************************************************************************
 390  *
 391  * FUNCTION:    acpi_ut_allocate
 392  *
 393  * PARAMETERS:  Size                - Size of the allocation
 394  *              Component           - Component type of caller
 395  *              Module              - Source file name of caller
 396  *              Line                - Line number of caller
 397  *
 398  * RETURN:      Address of the allocated memory on success, NULL on failure.
 399  *
 400  * DESCRIPTION: The subsystem's equivalent of malloc.
 401  *
 402  ******************************************************************************/
 403
 404 void *
 405 acpi_ut_allocate (
 406         acpi_size                       size,
 407         u32                             component,
 408         char                            *module,
 409         u32                             line)
 410 {
 411         void                            *allocation;
 412
 413
 414         ACPI_FUNCTION_TRACE_U32 ("ut_allocate", size);
 415
 416
 417         /* Check for an inadvertent size of zero bytes */
 418
 419         if (!size) {
 420                 _ACPI_REPORT_ERROR (module, line, component,
 421                                 ("ut_allocate: Attempt to allocate zero bytes\n"));
 422                 size = 1;
 423         }
 424
 425         allocation = acpi_os_allocate (size);
 426         if (!allocation) {
 427                 /* Report allocation error */
 428
 429                 _ACPI_REPORT_ERROR (module, line, component,
 430                                 ("ut_allocate: Could not allocate size %X\n", (u32) size));
 431
 432                 return_PTR (NULL);
 433         }
 434
 435         return_PTR (allocation);
 436 }
 437
 438
 439 /*******************************************************************************
 440  *
 441  * FUNCTION:    acpi_ut_callocate
 442  *
 443  * PARAMETERS:  Size                - Size of the allocation
 444  *              Component           - Component type of caller
 445  *              Module              - Source file name of caller
 446  *              Line                - Line number of caller
 447  *
 448  * RETURN:      Address of the allocated memory on success, NULL on failure.
 449  *
 450  * DESCRIPTION: Subsystem equivalent of calloc.
 451  *
 452  ******************************************************************************/
 453
 454 void *
 455 acpi_ut_callocate (
 456         acpi_size                       size,
 457         u32                             component,
 458         char                            *module,
 459         u32                             line)
 460 {
 461         void                            *allocation;
 462
 463
 464         ACPI_FUNCTION_TRACE_U32 ("ut_callocate", size);
 465
 466
 467         /* Check for an inadvertent size of zero bytes */
 468
 469         if (!size) {
 470                 _ACPI_REPORT_ERROR (module, line, component,
 471                                 ("ut_callocate: Attempt to allocate zero bytes\n"));
 472                 return_PTR (NULL);
 473         }
 474
 475         allocation = acpi_os_allocate (size);
 476         if (!allocation) {
 477                 /* Report allocation error */
 478
 479                 _ACPI_REPORT_ERROR (module, line, component,
 480                                 ("ut_callocate: Could not allocate size %X\n", (u32) size));
 481                 return_PTR (NULL);
 482         }
 483
 484         /* Clear the memory block */
 485
 486         ACPI_MEMSET (allocation, 0, size);
 487         return_PTR (allocation);
 488 }
 489
 490
 491 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 492 /*
 493  * These procedures are used for tracking memory leaks in the subsystem, and
 494  * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
 495  *
 496  * Each memory allocation is tracked via a doubly linked list.  Each
 497  * element contains the caller's component, module name, function name, and
 498  * line number.  acpi_ut_allocate and acpi_ut_callocate call
 499  * acpi_ut_track_allocation to add an element to the list; deletion
 500  * occurs in the body of acpi_ut_free.
 501  */
 502
 503
 504 /*******************************************************************************
 505  *
 506  * FUNCTION:    acpi_ut_allocate_and_track
 507  *
 508  * PARAMETERS:  Size                - Size of the allocation
 509  *              Component           - Component type of caller
 510  *              Module              - Source file name of caller
 511  *              Line                - Line number of caller
 512  *
 513  * RETURN:      Address of the allocated memory on success, NULL on failure.
 514  *
 515  * DESCRIPTION: The subsystem's equivalent of malloc.
 516  *
 517  ******************************************************************************/
 518
 519 void *
 520 acpi_ut_allocate_and_track (
 521         acpi_size                       size,
 522         u32                             component,
 523         char                            *module,
 524         u32                             line)
 525 {
 526         struct acpi_debug_mem_block     *allocation;
 527         acpi_status                     status;
 528
 529
 530         allocation = acpi_ut_allocate (size + sizeof (struct acpi_debug_mem_header),
 531                           component, module, line);
 532         if (!allocation) {
 533                 return (NULL);
 534         }
 535
 536         status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
 537                           ACPI_MEM_MALLOC, component, module, line);
 538         if (ACPI_FAILURE (status)) {
 539                 acpi_os_free (allocation);
 540                 return (NULL);
 541         }
 542
 543         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
 544         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) size;
 545
 546         return ((void *) &allocation->user_space);
 547 }
 548
 549
 550 /*******************************************************************************
 551  *
 552  * FUNCTION:    acpi_ut_callocate_and_track
 553  *
 554  * PARAMETERS:  Size                - Size of the allocation
 555  *              Component           - Component type of caller
 556  *              Module              - Source file name of caller
 557  *              Line                - Line number of caller
 558  *
 559  * RETURN:      Address of the allocated memory on success, NULL on failure.
 560  *
 561  * DESCRIPTION: Subsystem equivalent of calloc.
 562  *
 563  ******************************************************************************/
 564
 565 void *
 566 acpi_ut_callocate_and_track (
 567         acpi_size                       size,
 568         u32                             component,
 569         char                            *module,
 570         u32                             line)
 571 {
 572         struct acpi_debug_mem_block     *allocation;
 573         acpi_status                     status;
 574
 575
 576         allocation = acpi_ut_callocate (size + sizeof (struct acpi_debug_mem_header),
 577                           component, module, line);
 578         if (!allocation) {
 579                 /* Report allocation error */
 580
 581                 _ACPI_REPORT_ERROR (module, line, component,
 582                                 ("ut_callocate: Could not allocate size %X\n", (u32) size));
 583                 return (NULL);
 584         }
 585
 586         status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
 587                            ACPI_MEM_CALLOC, component, module, line);
 588         if (ACPI_FAILURE (status)) {
 589                 acpi_os_free (allocation);
 590                 return (NULL);
 591         }
 592
 593         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
 594         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) size;
 595
 596         return ((void *) &allocation->user_space);
 597 }
 598
 599
 600 /*******************************************************************************
 601  *
 602  * FUNCTION:    acpi_ut_free_and_track
 603  *
 604  * PARAMETERS:  Allocation          - Address of the memory to deallocate
 605  *              Component           - Component type of caller
 606  *              Module              - Source file name of caller
 607  *              Line                - Line number of caller
 608  *
 609  * RETURN:      None
 610  *
 611  * DESCRIPTION: Frees the memory at Allocation
 612  *
 613  ******************************************************************************/
 614
 615 void
 616 acpi_ut_free_and_track (
 617         void                            *allocation,
 618         u32                             component,
 619         char                            *module,
 620         u32                             line)
 621 {
 622         struct acpi_debug_mem_block     *debug_block;
 623         acpi_status                     status;
 624
 625
 626         ACPI_FUNCTION_TRACE_PTR ("ut_free", allocation);
 627
 628
 629         if (NULL == allocation) {
 630                 _ACPI_REPORT_ERROR (module, line, component,
 631                         ("acpi_ut_free: Attempt to delete a NULL address\n"));
 632
 633                 return_VOID;
 634         }
 635
 636         debug_block = ACPI_CAST_PTR (struct acpi_debug_mem_block,
 637                           (((char *) allocation) - sizeof (struct acpi_debug_mem_header)));
 638
 639         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_freed++;
 640         acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size -= debug_block->size;
 641
 642         status = acpi_ut_remove_allocation (ACPI_MEM_LIST_GLOBAL, debug_block,
 643                           component, module, line);
 644         if (ACPI_FAILURE (status)) {
 645                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not free memory, %s\n",
 646                         acpi_format_exception (status)));
 647         }
 648
 649         acpi_os_free (debug_block);
 650
 651         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation));
 652
 653         return_VOID;
 654 }
 655
 656
 657 /*******************************************************************************
 658  *
 659  * FUNCTION:    acpi_ut_find_allocation
 660  *
 661  * PARAMETERS:  list_id                 - Memory list to search
 662  *              Allocation              - Address of allocated memory
 663  *
 664  * RETURN:      A list element if found; NULL otherwise.
 665  *
 666  * DESCRIPTION: Searches for an element in the global allocation tracking list.
 667  *
 668  ******************************************************************************/
 669
 670 static struct acpi_debug_mem_block *
 671 acpi_ut_find_allocation (
 672         u32                             list_id,
 673         void                            *allocation)
 674 {
 675         struct acpi_debug_mem_block     *element;
 676
 677
 678         ACPI_FUNCTION_ENTRY ();
 679
 680
 681         if (list_id > ACPI_MEM_LIST_MAX) {
 682                 return (NULL);
 683         }
 684
 685         element = acpi_gbl_memory_lists[list_id].list_head;
 686
 687         /* Search for the address. */
 688
 689         while (element) {
 690                 if (element == allocation) {
 691                         return (element);
 692                 }
 693
 694                 element = element->next;
 695         }
 696
 697         return (NULL);
 698 }
 699
 700
 701 /*******************************************************************************
 702  *
 703  * FUNCTION:    acpi_ut_track_allocation
 704  *
 705  * PARAMETERS:  list_id             - Memory list to search
 706  *              Allocation          - Address of allocated memory
 707  *              Size                - Size of the allocation
 708  *              alloc_type          - MEM_MALLOC or MEM_CALLOC
 709  *              Component           - Component type of caller
 710  *              Module              - Source file name of caller
 711  *              Line                - Line number of caller
 712  *
 713  * RETURN:      None.
 714  *
 715  * DESCRIPTION: Inserts an element into the global allocation tracking list.
 716  *
 717  ******************************************************************************/
 718
 719 static acpi_status
 720 acpi_ut_track_allocation (
 721         u32                             list_id,
 722         struct acpi_debug_mem_block     *allocation,
 723         acpi_size                       size,
 724         u8                              alloc_type,
 725         u32                             component,
 726         char                            *module,
 727         u32                             line)
 728 {
 729         struct acpi_memory_list         *mem_list;
 730         struct acpi_debug_mem_block     *element;
 731         acpi_status                     status = AE_OK;
 732
 733
 734         ACPI_FUNCTION_TRACE_PTR ("ut_track_allocation", allocation);
 735
 736
 737         if (list_id > ACPI_MEM_LIST_MAX) {
 738                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 739         }
 740
 741         mem_list = &acpi_gbl_memory_lists[list_id];
 742         status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
 743         if (ACPI_FAILURE (status)) {
 744                 return_ACPI_STATUS (status);
 745         }
 746
 747         /*
 748          * Search list for this address to make sure it is not already on the list.
 749          * This will catch several kinds of problems.
 750          */
 751
 752         element = acpi_ut_find_allocation (list_id, allocation);
 753         if (element) {
 754                 ACPI_REPORT_ERROR ((
 755                         "ut_track_allocation: Allocation already present in list! (%p)\n",
 756                         allocation));
 757
 758                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n",
 759                         element, allocation));
 760
 761                 goto unlock_and_exit;
 762         }
 763
 764         /* Fill in the instance data. */
 765
 766         allocation->size      = (u32) size;
 767         allocation->alloc_type = alloc_type;
 768         allocation->component = component;
 769         allocation->line      = line;
 770
 771         ACPI_STRNCPY (allocation->module, module, ACPI_MAX_MODULE_NAME);
 772         allocation->module[ACPI_MAX_MODULE_NAME-1] = 0;
 773
 774         /* Insert at list head */
 775
 776         if (mem_list->list_head) {
 777                 ((struct acpi_debug_mem_block *)(mem_list->list_head))->previous = allocation;
 778         }
 779
 780         allocation->next = mem_list->list_head;
 781         allocation->previous = NULL;
 782
 783         mem_list->list_head = allocation;
 784
 785
 786 unlock_and_exit:
 787         status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
 788         return_ACPI_STATUS (status);
 789 }
 790
 791
 792 /*******************************************************************************
 793  *
 794  * FUNCTION:    acpi_ut_remove_allocation
 795  *
 796  * PARAMETERS:  list_id             - Memory list to search
 797  *              Allocation          - Address of allocated memory
 798  *              Component           - Component type of caller
 799  *              Module              - Source file name of caller
 800  *              Line                - Line number of caller
 801  *
 802  * RETURN:
 803  *
 804  * DESCRIPTION: Deletes an element from the global allocation tracking list.
 805  *
 806  ******************************************************************************/
 807
 808 static acpi_status
 809 acpi_ut_remove_allocation (
 810         u32                             list_id,
 811         struct acpi_debug_mem_block     *allocation,
 812         u32                             component,
 813         char                            *module,
 814         u32                             line)
 815 {
 816         struct acpi_memory_list         *mem_list;
 817         acpi_status                     status;
 818
 819
 820         ACPI_FUNCTION_TRACE ("ut_remove_allocation");
 821
 822
 823         if (list_id > ACPI_MEM_LIST_MAX) {
 824                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 825         }
 826
 827         mem_list = &acpi_gbl_memory_lists[list_id];
 828         if (NULL == mem_list->list_head) {
 829                 /* No allocations! */
 830
 831                 _ACPI_REPORT_ERROR (module, line, component,
 832                         ("ut_remove_allocation: Empty allocation list, nothing to free!\n"));
 833
 834                 return_ACPI_STATUS (AE_OK);
 835         }
 836
 837         status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
 838         if (ACPI_FAILURE (status)) {
 839                 return_ACPI_STATUS (status);
 840         }
 841
 842         /* Unlink */
 843
 844         if (allocation->previous) {
 845                 (allocation->previous)->next = allocation->next;
 846         }
 847         else {
 848                 mem_list->list_head = allocation->next;
 849         }
 850
 851         if (allocation->next) {
 852                 (allocation->next)->previous = allocation->previous;
 853         }
 854
 855         /* Mark the segment as deleted */
 856
 857         ACPI_MEMSET (&allocation->user_space, 0xEA, allocation->size);
 858
 859         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n",
 860                 allocation->size));
 861
 862         status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
 863         return_ACPI_STATUS (status);
 864 }
 865
 866
 867 /*******************************************************************************
 868  *
 869  * FUNCTION:    acpi_ut_dump_allocation_info
 870  *
 871  * PARAMETERS:
 872  *
 873  * RETURN:      None
 874  *
 875  * DESCRIPTION: Print some info about the outstanding allocations.
 876  *
 877  ******************************************************************************/
 878
 879 #ifdef ACPI_FUTURE_USAGE
 880 void
 881 acpi_ut_dump_allocation_info (
 882         void)
 883 {
 884 /*
 885         struct acpi_memory_list         *mem_list;
 886 */
 887
 888         ACPI_FUNCTION_TRACE ("ut_dump_allocation_info");
 889
 890 /*
 891         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 892                           ("%30s: %4d (%3d Kb)\n", "Current allocations",
 893                           mem_list->current_count,
 894                           ROUND_UP_TO_1K (mem_list->current_size)));
 895
 896         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 897                           ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
 898                           mem_list->max_concurrent_count,
 899                           ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
 900
 901
 902         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 903                           ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
 904                           running_object_count,
 905                           ROUND_UP_TO_1K (running_object_size)));
 906
 907         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 908                           ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
 909                           running_alloc_count,
 910                           ROUND_UP_TO_1K (running_alloc_size)));
 911
 912
 913         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 914                           ("%30s: %4d (%3d Kb)\n", "Current Nodes",
 915                           acpi_gbl_current_node_count,
 916                           ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
 917
 918         ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
 919                           ("%30s: %4d (%3d Kb)\n", "Max Nodes",
 920                           acpi_gbl_max_concurrent_node_count,
 921                           ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count *
 922                                          sizeof (struct acpi_namespace_node)))));
 923 */
 924         return_VOID;
 925 }
 926 #endif  /*  ACPI_FUTURE_USAGE  */
 927
 928
 929 /*******************************************************************************
 930  *
 931  * FUNCTION:    acpi_ut_dump_allocations
 932  *
 933  * PARAMETERS:  Component           - Component(s) to dump info for.
 934  *              Module              - Module to dump info for.  NULL means all.
 935  *
 936  * RETURN:      None
 937  *
 938  * DESCRIPTION: Print a list of all outstanding allocations.
 939  *
 940  ******************************************************************************/
 941
 942 void
 943 acpi_ut_dump_allocations (
 944         u32                             component,
 945         char                            *module)
 946 {
 947         struct acpi_debug_mem_block     *element;
 948         union acpi_descriptor           *descriptor;
 949         u32                             num_outstanding = 0;
 950
 951
 952         ACPI_FUNCTION_TRACE ("ut_dump_allocations");
 953
 954
 955         /*
 956          * Walk the allocation list.
 957          */
 958         if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_MEMORY))) {
 959                 return;
 960         }
 961
 962         element = acpi_gbl_memory_lists[0].list_head;
 963         while (element) {
 964                 if ((element->component & component) &&
 965                         ((module == NULL) || (0 == ACPI_STRCMP (module, element->module)))) {
 966                         /* Ignore allocated objects that are in a cache */
 967
 968                         descriptor = ACPI_CAST_PTR (union acpi_descriptor, &element->user_space);
 969                         if (descriptor->descriptor_id != ACPI_DESC_TYPE_CACHED) {
 970                                 acpi_os_printf ("%p Len %04X %9.9s-%d [%s] ",
 971                                         descriptor, element->size, element->module,
 972                                         element->line, acpi_ut_get_descriptor_name (descriptor));
 973
 974                                 /* Most of the elements will be Operand objects. */
 975
 976                                 switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) {
 977                                 case ACPI_DESC_TYPE_OPERAND:
 978                                         acpi_os_printf ("%12.12s R%hd",
 979                                                 acpi_ut_get_type_name (descriptor->object.common.type),
 980                                                 descriptor->object.common.reference_count);
 981                                         break;
 982
 983                                 case ACPI_DESC_TYPE_PARSER:
 984                                         acpi_os_printf ("aml_opcode %04hX",
 985                                                 descriptor->op.asl.aml_opcode);
 986                                         break;
 987
 988                                 case ACPI_DESC_TYPE_NAMED:
 989                                         acpi_os_printf ("%4.4s",
 990                                                 acpi_ut_get_node_name (&descriptor->node));
 991                                         break;
 992
 993                                 default:
 994                                         break;
 995                                 }
 996
 997                                 acpi_os_printf ( "\n");
 998                                 num_outstanding++;
 999                         }
1000                 }
1001                 element = element->next;
1002         }
1003
1004         (void) acpi_ut_release_mutex (ACPI_MTX_MEMORY);
1005
1006         /* Print summary */
1007
1008         if (!num_outstanding) {
1009                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
1010                         "No outstanding allocations.\n"));
1011         }
1012         else {
1013                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
1014                         "%d(%X) Outstanding allocations\n",
1015                         num_outstanding, num_outstanding));
1016         }
1017
1018         return_VOID;
1019 }
1020
1021 #endif  /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */
1022