diff options
Diffstat (limited to 'drivers/acpi/utilities/utalloc.c')
-rw-r--r-- | drivers/acpi/utilities/utalloc.c | 590 |
1 files changed, 30 insertions, 560 deletions
diff --git a/drivers/acpi/utilities/utalloc.c b/drivers/acpi/utilities/utalloc.c index 7b35eb84d058..3b29aecaaca5 100644 --- a/drivers/acpi/utilities/utalloc.c +++ b/drivers/acpi/utilities/utalloc.c | |||
@@ -46,24 +46,6 @@ | |||
46 | #define _COMPONENT ACPI_UTILITIES | 46 | #define _COMPONENT ACPI_UTILITIES |
47 | ACPI_MODULE_NAME("utalloc") | 47 | ACPI_MODULE_NAME("utalloc") |
48 | 48 | ||
49 | /* Local prototypes */ | ||
50 | #ifdef ACPI_DBG_TRACK_ALLOCATIONS | ||
51 | static struct acpi_debug_mem_block *acpi_ut_find_allocation(void *allocation); | ||
52 | |||
53 | static acpi_status | ||
54 | acpi_ut_track_allocation(struct acpi_debug_mem_block *address, | ||
55 | acpi_size size, | ||
56 | u8 alloc_type, u32 component, char *module, u32 line); | ||
57 | |||
58 | static acpi_status | ||
59 | acpi_ut_remove_allocation(struct acpi_debug_mem_block *address, | ||
60 | u32 component, char *module, u32 line); | ||
61 | |||
62 | static acpi_status | ||
63 | acpi_ut_create_list(char *list_name, | ||
64 | u16 object_size, struct acpi_memory_list **return_cache); | ||
65 | #endif | ||
66 | |||
67 | /******************************************************************************* | 49 | /******************************************************************************* |
68 | * | 50 | * |
69 | * FUNCTION: acpi_ut_create_caches | 51 | * FUNCTION: acpi_ut_create_caches |
@@ -75,7 +57,6 @@ acpi_ut_create_list(char *list_name, | |||
75 | * DESCRIPTION: Create all local caches | 57 | * DESCRIPTION: Create all local caches |
76 | * | 58 | * |
77 | ******************************************************************************/ | 59 | ******************************************************************************/ |
78 | |||
79 | acpi_status acpi_ut_create_caches(void) | 60 | acpi_status acpi_ut_create_caches(void) |
80 | { | 61 | { |
81 | acpi_status status; | 62 | acpi_status status; |
@@ -101,7 +82,16 @@ acpi_status acpi_ut_create_caches(void) | |||
101 | /* Object Caches, for frequently used objects */ | 82 | /* Object Caches, for frequently used objects */ |
102 | 83 | ||
103 | status = | 84 | status = |
104 | acpi_os_create_cache("acpi_state", sizeof(union acpi_generic_state), | 85 | acpi_os_create_cache("Acpi-Namespace", |
86 | sizeof(struct acpi_namespace_node), | ||
87 | ACPI_MAX_NAMESPACE_CACHE_DEPTH, | ||
88 | &acpi_gbl_namespace_cache); | ||
89 | if (ACPI_FAILURE(status)) { | ||
90 | return (status); | ||
91 | } | ||
92 | |||
93 | status = | ||
94 | acpi_os_create_cache("Acpi-State", sizeof(union acpi_generic_state), | ||
105 | ACPI_MAX_STATE_CACHE_DEPTH, | 95 | ACPI_MAX_STATE_CACHE_DEPTH, |
106 | &acpi_gbl_state_cache); | 96 | &acpi_gbl_state_cache); |
107 | if (ACPI_FAILURE(status)) { | 97 | if (ACPI_FAILURE(status)) { |
@@ -109,7 +99,7 @@ acpi_status acpi_ut_create_caches(void) | |||
109 | } | 99 | } |
110 | 100 | ||
111 | status = | 101 | status = |
112 | acpi_os_create_cache("acpi_parse", | 102 | acpi_os_create_cache("Acpi-Parse", |
113 | sizeof(struct acpi_parse_obj_common), | 103 | sizeof(struct acpi_parse_obj_common), |
114 | ACPI_MAX_PARSE_CACHE_DEPTH, | 104 | ACPI_MAX_PARSE_CACHE_DEPTH, |
115 | &acpi_gbl_ps_node_cache); | 105 | &acpi_gbl_ps_node_cache); |
@@ -118,7 +108,7 @@ acpi_status acpi_ut_create_caches(void) | |||
118 | } | 108 | } |
119 | 109 | ||
120 | status = | 110 | status = |
121 | acpi_os_create_cache("acpi_parse_ext", | 111 | acpi_os_create_cache("Acpi-parse_ext", |
122 | sizeof(struct acpi_parse_obj_named), | 112 | sizeof(struct acpi_parse_obj_named), |
123 | ACPI_MAX_EXTPARSE_CACHE_DEPTH, | 113 | ACPI_MAX_EXTPARSE_CACHE_DEPTH, |
124 | &acpi_gbl_ps_node_ext_cache); | 114 | &acpi_gbl_ps_node_ext_cache); |
@@ -127,7 +117,7 @@ acpi_status acpi_ut_create_caches(void) | |||
127 | } | 117 | } |
128 | 118 | ||
129 | status = | 119 | status = |
130 | acpi_os_create_cache("acpi_operand", | 120 | acpi_os_create_cache("Acpi-Operand", |
131 | sizeof(union acpi_operand_object), | 121 | sizeof(union acpi_operand_object), |
132 | ACPI_MAX_OBJECT_CACHE_DEPTH, | 122 | ACPI_MAX_OBJECT_CACHE_DEPTH, |
133 | &acpi_gbl_operand_cache); | 123 | &acpi_gbl_operand_cache); |
@@ -153,6 +143,9 @@ acpi_status acpi_ut_create_caches(void) | |||
153 | acpi_status acpi_ut_delete_caches(void) | 143 | acpi_status acpi_ut_delete_caches(void) |
154 | { | 144 | { |
155 | 145 | ||
146 | (void)acpi_os_delete_cache(acpi_gbl_namespace_cache); | ||
147 | acpi_gbl_namespace_cache = NULL; | ||
148 | |||
156 | (void)acpi_os_delete_cache(acpi_gbl_state_cache); | 149 | (void)acpi_os_delete_cache(acpi_gbl_state_cache); |
157 | acpi_gbl_state_cache = NULL; | 150 | acpi_gbl_state_cache = NULL; |
158 | 151 | ||
@@ -288,7 +281,7 @@ acpi_ut_initialize_buffer(struct acpi_buffer * buffer, | |||
288 | * | 281 | * |
289 | * RETURN: Address of the allocated memory on success, NULL on failure. | 282 | * RETURN: Address of the allocated memory on success, NULL on failure. |
290 | * | 283 | * |
291 | * DESCRIPTION: The subsystem's equivalent of malloc. | 284 | * DESCRIPTION: Subsystem equivalent of malloc. |
292 | * | 285 | * |
293 | ******************************************************************************/ | 286 | ******************************************************************************/ |
294 | 287 | ||
@@ -301,8 +294,8 @@ void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line) | |||
301 | /* Check for an inadvertent size of zero bytes */ | 294 | /* Check for an inadvertent size of zero bytes */ |
302 | 295 | ||
303 | if (!size) { | 296 | if (!size) { |
304 | ACPI_ERROR((module, line, | 297 | ACPI_WARNING((module, line, |
305 | "ut_allocate: Attempt to allocate zero bytes, allocating 1 byte")); | 298 | "Attempt to allocate zero bytes, allocating 1 byte")); |
306 | size = 1; | 299 | size = 1; |
307 | } | 300 | } |
308 | 301 | ||
@@ -311,9 +304,8 @@ void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line) | |||
311 | 304 | ||
312 | /* Report allocation error */ | 305 | /* Report allocation error */ |
313 | 306 | ||
314 | ACPI_ERROR((module, line, | 307 | ACPI_WARNING((module, line, |
315 | "ut_allocate: Could not allocate size %X", | 308 | "Could not allocate size %X", (u32) size)); |
316 | (u32) size)); | ||
317 | 309 | ||
318 | return_PTR(NULL); | 310 | return_PTR(NULL); |
319 | } | 311 | } |
@@ -323,7 +315,7 @@ void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line) | |||
323 | 315 | ||
324 | /******************************************************************************* | 316 | /******************************************************************************* |
325 | * | 317 | * |
326 | * FUNCTION: acpi_ut_callocate | 318 | * FUNCTION: acpi_ut_allocate_zeroed |
327 | * | 319 | * |
328 | * PARAMETERS: Size - Size of the allocation | 320 | * PARAMETERS: Size - Size of the allocation |
329 | * Component - Component type of caller | 321 | * Component - Component type of caller |
@@ -332,546 +324,24 @@ void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line) | |||
332 | * | 324 | * |
333 | * RETURN: Address of the allocated memory on success, NULL on failure. | 325 | * RETURN: Address of the allocated memory on success, NULL on failure. |
334 | * | 326 | * |
335 | * DESCRIPTION: Subsystem equivalent of calloc. | 327 | * DESCRIPTION: Subsystem equivalent of calloc. Allocate and zero memory. |
336 | * | 328 | * |
337 | ******************************************************************************/ | 329 | ******************************************************************************/ |
338 | 330 | ||
339 | void *acpi_ut_callocate(acpi_size size, u32 component, char *module, u32 line) | 331 | void *acpi_ut_allocate_zeroed(acpi_size size, |
332 | u32 component, char *module, u32 line) | ||
340 | { | 333 | { |
341 | void *allocation; | 334 | void *allocation; |
342 | 335 | ||
343 | ACPI_FUNCTION_TRACE_U32("ut_callocate", size); | ||
344 | |||
345 | /* Check for an inadvertent size of zero bytes */ | ||
346 | |||
347 | if (!size) { | ||
348 | ACPI_ERROR((module, line, | ||
349 | "Attempt to allocate zero bytes, allocating 1 byte")); | ||
350 | size = 1; | ||
351 | } | ||
352 | |||
353 | allocation = acpi_os_allocate(size); | ||
354 | if (!allocation) { | ||
355 | |||
356 | /* Report allocation error */ | ||
357 | |||
358 | ACPI_ERROR((module, line, | ||
359 | "Could not allocate size %X", (u32) size)); | ||
360 | return_PTR(NULL); | ||
361 | } | ||
362 | |||
363 | /* Clear the memory block */ | ||
364 | |||
365 | ACPI_MEMSET(allocation, 0, size); | ||
366 | return_PTR(allocation); | ||
367 | } | ||
368 | |||
369 | #ifdef ACPI_DBG_TRACK_ALLOCATIONS | ||
370 | /* | ||
371 | * These procedures are used for tracking memory leaks in the subsystem, and | ||
372 | * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set. | ||
373 | * | ||
374 | * Each memory allocation is tracked via a doubly linked list. Each | ||
375 | * element contains the caller's component, module name, function name, and | ||
376 | * line number. acpi_ut_allocate and acpi_ut_callocate call | ||
377 | * acpi_ut_track_allocation to add an element to the list; deletion | ||
378 | * occurs in the body of acpi_ut_free. | ||
379 | */ | ||
380 | |||
381 | /******************************************************************************* | ||
382 | * | ||
383 | * FUNCTION: acpi_ut_create_list | ||
384 | * | ||
385 | * PARAMETERS: cache_name - Ascii name for the cache | ||
386 | * object_size - Size of each cached object | ||
387 | * return_cache - Where the new cache object is returned | ||
388 | * | ||
389 | * RETURN: Status | ||
390 | * | ||
391 | * DESCRIPTION: Create a local memory list for tracking purposed | ||
392 | * | ||
393 | ******************************************************************************/ | ||
394 | |||
395 | static acpi_status | ||
396 | acpi_ut_create_list(char *list_name, | ||
397 | u16 object_size, struct acpi_memory_list **return_cache) | ||
398 | { | ||
399 | struct acpi_memory_list *cache; | ||
400 | |||
401 | cache = acpi_os_allocate(sizeof(struct acpi_memory_list)); | ||
402 | if (!cache) { | ||
403 | return (AE_NO_MEMORY); | ||
404 | } | ||
405 | |||
406 | ACPI_MEMSET(cache, 0, sizeof(struct acpi_memory_list)); | ||
407 | |||
408 | cache->list_name = list_name; | ||
409 | cache->object_size = object_size; | ||
410 | |||
411 | *return_cache = cache; | ||
412 | return (AE_OK); | ||
413 | } | ||
414 | |||
415 | /******************************************************************************* | ||
416 | * | ||
417 | * FUNCTION: acpi_ut_allocate_and_track | ||
418 | * | ||
419 | * PARAMETERS: Size - Size of the allocation | ||
420 | * Component - Component type of caller | ||
421 | * Module - Source file name of caller | ||
422 | * Line - Line number of caller | ||
423 | * | ||
424 | * RETURN: Address of the allocated memory on success, NULL on failure. | ||
425 | * | ||
426 | * DESCRIPTION: The subsystem's equivalent of malloc. | ||
427 | * | ||
428 | ******************************************************************************/ | ||
429 | |||
430 | void *acpi_ut_allocate_and_track(acpi_size size, | ||
431 | u32 component, char *module, u32 line) | ||
432 | { | ||
433 | struct acpi_debug_mem_block *allocation; | ||
434 | acpi_status status; | ||
435 | |||
436 | allocation = | ||
437 | acpi_ut_allocate(size + sizeof(struct acpi_debug_mem_header), | ||
438 | component, module, line); | ||
439 | if (!allocation) { | ||
440 | return (NULL); | ||
441 | } | ||
442 | |||
443 | status = acpi_ut_track_allocation(allocation, size, | ||
444 | ACPI_MEM_MALLOC, component, module, | ||
445 | line); | ||
446 | if (ACPI_FAILURE(status)) { | ||
447 | acpi_os_free(allocation); | ||
448 | return (NULL); | ||
449 | } | ||
450 | |||
451 | acpi_gbl_global_list->total_allocated++; | ||
452 | acpi_gbl_global_list->current_total_size += (u32) size; | ||
453 | |||
454 | return ((void *)&allocation->user_space); | ||
455 | } | ||
456 | |||
457 | /******************************************************************************* | ||
458 | * | ||
459 | * FUNCTION: acpi_ut_callocate_and_track | ||
460 | * | ||
461 | * PARAMETERS: Size - Size of the allocation | ||
462 | * Component - Component type of caller | ||
463 | * Module - Source file name of caller | ||
464 | * Line - Line number of caller | ||
465 | * | ||
466 | * RETURN: Address of the allocated memory on success, NULL on failure. | ||
467 | * | ||
468 | * DESCRIPTION: Subsystem equivalent of calloc. | ||
469 | * | ||
470 | ******************************************************************************/ | ||
471 | |||
472 | void *acpi_ut_callocate_and_track(acpi_size size, | ||
473 | u32 component, char *module, u32 line) | ||
474 | { | ||
475 | struct acpi_debug_mem_block *allocation; | ||
476 | acpi_status status; | ||
477 | |||
478 | allocation = | ||
479 | acpi_ut_callocate(size + sizeof(struct acpi_debug_mem_header), | ||
480 | component, module, line); | ||
481 | if (!allocation) { | ||
482 | |||
483 | /* Report allocation error */ | ||
484 | |||
485 | ACPI_ERROR((module, line, | ||
486 | "Could not allocate size %X", (u32) size)); | ||
487 | return (NULL); | ||
488 | } | ||
489 | |||
490 | status = acpi_ut_track_allocation(allocation, size, | ||
491 | ACPI_MEM_CALLOC, component, module, | ||
492 | line); | ||
493 | if (ACPI_FAILURE(status)) { | ||
494 | acpi_os_free(allocation); | ||
495 | return (NULL); | ||
496 | } | ||
497 | |||
498 | acpi_gbl_global_list->total_allocated++; | ||
499 | acpi_gbl_global_list->current_total_size += (u32) size; | ||
500 | |||
501 | return ((void *)&allocation->user_space); | ||
502 | } | ||
503 | |||
504 | /******************************************************************************* | ||
505 | * | ||
506 | * FUNCTION: acpi_ut_free_and_track | ||
507 | * | ||
508 | * PARAMETERS: Allocation - Address of the memory to deallocate | ||
509 | * Component - Component type of caller | ||
510 | * Module - Source file name of caller | ||
511 | * Line - Line number of caller | ||
512 | * | ||
513 | * RETURN: None | ||
514 | * | ||
515 | * DESCRIPTION: Frees the memory at Allocation | ||
516 | * | ||
517 | ******************************************************************************/ | ||
518 | |||
519 | void | ||
520 | acpi_ut_free_and_track(void *allocation, u32 component, char *module, u32 line) | ||
521 | { | ||
522 | struct acpi_debug_mem_block *debug_block; | ||
523 | acpi_status status; | ||
524 | |||
525 | ACPI_FUNCTION_TRACE_PTR("ut_free", allocation); | ||
526 | |||
527 | if (NULL == allocation) { | ||
528 | ACPI_ERROR((module, line, "Attempt to delete a NULL address")); | ||
529 | |||
530 | return_VOID; | ||
531 | } | ||
532 | |||
533 | debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block, | ||
534 | (((char *)allocation) - | ||
535 | sizeof(struct acpi_debug_mem_header))); | ||
536 | |||
537 | acpi_gbl_global_list->total_freed++; | ||
538 | acpi_gbl_global_list->current_total_size -= debug_block->size; | ||
539 | |||
540 | status = acpi_ut_remove_allocation(debug_block, | ||
541 | component, module, line); | ||
542 | if (ACPI_FAILURE(status)) { | ||
543 | ACPI_EXCEPTION((AE_INFO, status, "Could not free memory")); | ||
544 | } | ||
545 | |||
546 | acpi_os_free(debug_block); | ||
547 | ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation)); | ||
548 | return_VOID; | ||
549 | } | ||
550 | |||
551 | /******************************************************************************* | ||
552 | * | ||
553 | * FUNCTION: acpi_ut_find_allocation | ||
554 | * | ||
555 | * PARAMETERS: Allocation - Address of allocated memory | ||
556 | * | ||
557 | * RETURN: A list element if found; NULL otherwise. | ||
558 | * | ||
559 | * DESCRIPTION: Searches for an element in the global allocation tracking list. | ||
560 | * | ||
561 | ******************************************************************************/ | ||
562 | |||
563 | static struct acpi_debug_mem_block *acpi_ut_find_allocation(void *allocation) | ||
564 | { | ||
565 | struct acpi_debug_mem_block *element; | ||
566 | |||
567 | ACPI_FUNCTION_ENTRY(); | 336 | ACPI_FUNCTION_ENTRY(); |
568 | 337 | ||
569 | element = acpi_gbl_global_list->list_head; | 338 | allocation = acpi_ut_allocate(size, component, module, line); |
570 | 339 | if (allocation) { | |
571 | /* Search for the address. */ | ||
572 | |||
573 | while (element) { | ||
574 | if (element == allocation) { | ||
575 | return (element); | ||
576 | } | ||
577 | |||
578 | element = element->next; | ||
579 | } | ||
580 | |||
581 | return (NULL); | ||
582 | } | ||
583 | |||
584 | /******************************************************************************* | ||
585 | * | ||
586 | * FUNCTION: acpi_ut_track_allocation | ||
587 | * | ||
588 | * PARAMETERS: Allocation - Address of allocated memory | ||
589 | * Size - Size of the allocation | ||
590 | * alloc_type - MEM_MALLOC or MEM_CALLOC | ||
591 | * Component - Component type of caller | ||
592 | * Module - Source file name of caller | ||
593 | * Line - Line number of caller | ||
594 | * | ||
595 | * RETURN: None. | ||
596 | * | ||
597 | * DESCRIPTION: Inserts an element into the global allocation tracking list. | ||
598 | * | ||
599 | ******************************************************************************/ | ||
600 | |||
601 | static acpi_status | ||
602 | acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation, | ||
603 | acpi_size size, | ||
604 | u8 alloc_type, u32 component, char *module, u32 line) | ||
605 | { | ||
606 | struct acpi_memory_list *mem_list; | ||
607 | struct acpi_debug_mem_block *element; | ||
608 | acpi_status status = AE_OK; | ||
609 | |||
610 | ACPI_FUNCTION_TRACE_PTR("ut_track_allocation", allocation); | ||
611 | |||
612 | mem_list = acpi_gbl_global_list; | ||
613 | status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY); | ||
614 | if (ACPI_FAILURE(status)) { | ||
615 | return_ACPI_STATUS(status); | ||
616 | } | ||
617 | |||
618 | /* | ||
619 | * Search list for this address to make sure it is not already on the list. | ||
620 | * This will catch several kinds of problems. | ||
621 | */ | ||
622 | element = acpi_ut_find_allocation(allocation); | ||
623 | if (element) { | ||
624 | ACPI_ERROR((AE_INFO, | ||
625 | "ut_track_allocation: Allocation already present in list! (%p)", | ||
626 | allocation)); | ||
627 | 340 | ||
628 | ACPI_ERROR((AE_INFO, "Element %p Address %p", | 341 | /* Clear the memory block */ |
629 | element, allocation)); | ||
630 | 342 | ||
631 | goto unlock_and_exit; | 343 | ACPI_MEMSET(allocation, 0, size); |
632 | } | 344 | } |
633 | 345 | ||
634 | /* Fill in the instance data. */ | 346 | return (allocation); |
635 | |||
636 | allocation->size = (u32) size; | ||
637 | allocation->alloc_type = alloc_type; | ||
638 | allocation->component = component; | ||
639 | allocation->line = line; | ||
640 | |||
641 | ACPI_STRNCPY(allocation->module, module, ACPI_MAX_MODULE_NAME); | ||
642 | allocation->module[ACPI_MAX_MODULE_NAME - 1] = 0; | ||
643 | |||
644 | /* Insert at list head */ | ||
645 | |||
646 | if (mem_list->list_head) { | ||
647 | ((struct acpi_debug_mem_block *)(mem_list->list_head))-> | ||
648 | previous = allocation; | ||
649 | } | ||
650 | |||
651 | allocation->next = mem_list->list_head; | ||
652 | allocation->previous = NULL; | ||
653 | |||
654 | mem_list->list_head = allocation; | ||
655 | |||
656 | unlock_and_exit: | ||
657 | status = acpi_ut_release_mutex(ACPI_MTX_MEMORY); | ||
658 | return_ACPI_STATUS(status); | ||
659 | } | 347 | } |
660 | |||
661 | /******************************************************************************* | ||
662 | * | ||
663 | * FUNCTION: acpi_ut_remove_allocation | ||
664 | * | ||
665 | * PARAMETERS: Allocation - Address of allocated memory | ||
666 | * Component - Component type of caller | ||
667 | * Module - Source file name of caller | ||
668 | * Line - Line number of caller | ||
669 | * | ||
670 | * RETURN: | ||
671 | * | ||
672 | * DESCRIPTION: Deletes an element from the global allocation tracking list. | ||
673 | * | ||
674 | ******************************************************************************/ | ||
675 | |||
676 | static acpi_status | ||
677 | acpi_ut_remove_allocation(struct acpi_debug_mem_block *allocation, | ||
678 | u32 component, char *module, u32 line) | ||
679 | { | ||
680 | struct acpi_memory_list *mem_list; | ||
681 | acpi_status status; | ||
682 | |||
683 | ACPI_FUNCTION_TRACE("ut_remove_allocation"); | ||
684 | |||
685 | mem_list = acpi_gbl_global_list; | ||
686 | if (NULL == mem_list->list_head) { | ||
687 | |||
688 | /* No allocations! */ | ||
689 | |||
690 | ACPI_ERROR((module, line, | ||
691 | "Empty allocation list, nothing to free!")); | ||
692 | |||
693 | return_ACPI_STATUS(AE_OK); | ||
694 | } | ||
695 | |||
696 | status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY); | ||
697 | if (ACPI_FAILURE(status)) { | ||
698 | return_ACPI_STATUS(status); | ||
699 | } | ||
700 | |||
701 | /* Unlink */ | ||
702 | |||
703 | if (allocation->previous) { | ||
704 | (allocation->previous)->next = allocation->next; | ||
705 | } else { | ||
706 | mem_list->list_head = allocation->next; | ||
707 | } | ||
708 | |||
709 | if (allocation->next) { | ||
710 | (allocation->next)->previous = allocation->previous; | ||
711 | } | ||
712 | |||
713 | /* Mark the segment as deleted */ | ||
714 | |||
715 | ACPI_MEMSET(&allocation->user_space, 0xEA, allocation->size); | ||
716 | |||
717 | ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n", | ||
718 | allocation->size)); | ||
719 | |||
720 | status = acpi_ut_release_mutex(ACPI_MTX_MEMORY); | ||
721 | return_ACPI_STATUS(status); | ||
722 | } | ||
723 | |||
724 | /******************************************************************************* | ||
725 | * | ||
726 | * FUNCTION: acpi_ut_dump_allocation_info | ||
727 | * | ||
728 | * PARAMETERS: | ||
729 | * | ||
730 | * RETURN: None | ||
731 | * | ||
732 | * DESCRIPTION: Print some info about the outstanding allocations. | ||
733 | * | ||
734 | ******************************************************************************/ | ||
735 | |||
736 | #ifdef ACPI_FUTURE_USAGE | ||
737 | void acpi_ut_dump_allocation_info(void) | ||
738 | { | ||
739 | /* | ||
740 | struct acpi_memory_list *mem_list; | ||
741 | */ | ||
742 | |||
743 | ACPI_FUNCTION_TRACE("ut_dump_allocation_info"); | ||
744 | |||
745 | /* | ||
746 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
747 | ("%30s: %4d (%3d Kb)\n", "Current allocations", | ||
748 | mem_list->current_count, | ||
749 | ROUND_UP_TO_1K (mem_list->current_size))); | ||
750 | |||
751 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
752 | ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations", | ||
753 | mem_list->max_concurrent_count, | ||
754 | ROUND_UP_TO_1K (mem_list->max_concurrent_size))); | ||
755 | |||
756 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
757 | ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects", | ||
758 | running_object_count, | ||
759 | ROUND_UP_TO_1K (running_object_size))); | ||
760 | |||
761 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
762 | ("%30s: %4d (%3d Kb)\n", "Total (all) allocations", | ||
763 | running_alloc_count, | ||
764 | ROUND_UP_TO_1K (running_alloc_size))); | ||
765 | |||
766 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
767 | ("%30s: %4d (%3d Kb)\n", "Current Nodes", | ||
768 | acpi_gbl_current_node_count, | ||
769 | ROUND_UP_TO_1K (acpi_gbl_current_node_size))); | ||
770 | |||
771 | ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES, | ||
772 | ("%30s: %4d (%3d Kb)\n", "Max Nodes", | ||
773 | acpi_gbl_max_concurrent_node_count, | ||
774 | ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count * | ||
775 | sizeof (struct acpi_namespace_node))))); | ||
776 | */ | ||
777 | return_VOID; | ||
778 | } | ||
779 | #endif /* ACPI_FUTURE_USAGE */ | ||
780 | |||
781 | /******************************************************************************* | ||
782 | * | ||
783 | * FUNCTION: acpi_ut_dump_allocations | ||
784 | * | ||
785 | * PARAMETERS: Component - Component(s) to dump info for. | ||
786 | * Module - Module to dump info for. NULL means all. | ||
787 | * | ||
788 | * RETURN: None | ||
789 | * | ||
790 | * DESCRIPTION: Print a list of all outstanding allocations. | ||
791 | * | ||
792 | ******************************************************************************/ | ||
793 | |||
794 | void acpi_ut_dump_allocations(u32 component, char *module) | ||
795 | { | ||
796 | struct acpi_debug_mem_block *element; | ||
797 | union acpi_descriptor *descriptor; | ||
798 | u32 num_outstanding = 0; | ||
799 | |||
800 | ACPI_FUNCTION_TRACE("ut_dump_allocations"); | ||
801 | |||
802 | /* | ||
803 | * Walk the allocation list. | ||
804 | */ | ||
805 | if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) { | ||
806 | return; | ||
807 | } | ||
808 | |||
809 | element = acpi_gbl_global_list->list_head; | ||
810 | while (element) { | ||
811 | if ((element->component & component) && | ||
812 | ((module == NULL) | ||
813 | || (0 == ACPI_STRCMP(module, element->module)))) { | ||
814 | |||
815 | /* Ignore allocated objects that are in a cache */ | ||
816 | |||
817 | descriptor = | ||
818 | ACPI_CAST_PTR(union acpi_descriptor, | ||
819 | &element->user_space); | ||
820 | if (descriptor->descriptor_id != ACPI_DESC_TYPE_CACHED) { | ||
821 | acpi_os_printf("%p Len %04X %9.9s-%d [%s] ", | ||
822 | descriptor, element->size, | ||
823 | element->module, element->line, | ||
824 | acpi_ut_get_descriptor_name | ||
825 | (descriptor)); | ||
826 | |||
827 | /* Most of the elements will be Operand objects. */ | ||
828 | |||
829 | switch (ACPI_GET_DESCRIPTOR_TYPE(descriptor)) { | ||
830 | case ACPI_DESC_TYPE_OPERAND: | ||
831 | acpi_os_printf("%12.12s R%hd", | ||
832 | acpi_ut_get_type_name | ||
833 | (descriptor->object. | ||
834 | common.type), | ||
835 | descriptor->object. | ||
836 | common.reference_count); | ||
837 | break; | ||
838 | |||
839 | case ACPI_DESC_TYPE_PARSER: | ||
840 | acpi_os_printf("aml_opcode %04hX", | ||
841 | descriptor->op.asl. | ||
842 | aml_opcode); | ||
843 | break; | ||
844 | |||
845 | case ACPI_DESC_TYPE_NAMED: | ||
846 | acpi_os_printf("%4.4s", | ||
847 | acpi_ut_get_node_name | ||
848 | (&descriptor->node)); | ||
849 | break; | ||
850 | |||
851 | default: | ||
852 | break; | ||
853 | } | ||
854 | |||
855 | acpi_os_printf("\n"); | ||
856 | num_outstanding++; | ||
857 | } | ||
858 | } | ||
859 | element = element->next; | ||
860 | } | ||
861 | |||
862 | (void)acpi_ut_release_mutex(ACPI_MTX_MEMORY); | ||
863 | |||
864 | /* Print summary */ | ||
865 | |||
866 | if (!num_outstanding) { | ||
867 | ACPI_INFO((AE_INFO, "No outstanding allocations")); | ||
868 | } else { | ||
869 | ACPI_ERROR((AE_INFO, | ||
870 | "%d(%X) Outstanding allocations", | ||
871 | num_outstanding, num_outstanding)); | ||
872 | } | ||
873 | |||
874 | return_VOID; | ||
875 | } | ||
876 | |||
877 | #endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */ | ||