2018-03-14 16:13:07 -07:00
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2012-10-31 02:25:05 +00:00
/******************************************************************************
*
* Module Name : uttrack - Memory allocation tracking routines ( debug only )
*
2018-01-04 10:06:38 -08:00
* Copyright ( C ) 2000 - 2018 , Intel Corp .
2012-10-31 02:25:05 +00:00
*
2018-03-14 16:13:07 -07:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-10-31 02:25:05 +00:00
/*
* These procedures are used for tracking memory leaks in the subsystem , and
* they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set .
*
2012-10-31 02:26:55 +00:00
* Each memory allocation is tracked via a doubly linked list . Each
2012-10-31 02:25:05 +00:00
* element contains the caller ' s component , module name , function name , and
2012-10-31 02:26:55 +00:00
* line number . acpi_ut_allocate and acpi_ut_allocate_zeroed call
2012-10-31 02:25:05 +00:00
* acpi_ut_track_allocation to add an element to the list ; deletion
* occurs in the body of acpi_ut_free .
*/
# include <acpi/acpi.h>
# include "accommon.h"
# ifdef ACPI_DBG_TRACK_ALLOCATIONS
# define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ( " uttrack " )
/* Local prototypes */
2012-10-31 02:27:32 +00:00
static struct acpi_debug_mem_block * acpi_ut_find_allocation ( struct
acpi_debug_mem_block
* allocation ) ;
2012-10-31 02:25:05 +00:00
static acpi_status
acpi_ut_track_allocation ( struct acpi_debug_mem_block * address ,
acpi_size size ,
u8 alloc_type ,
u32 component , const char * module , u32 line ) ;
static acpi_status
acpi_ut_remove_allocation ( struct acpi_debug_mem_block * address ,
u32 component , const char * module , u32 line ) ;
/*******************************************************************************
*
* FUNCTION : acpi_ut_create_list
*
* PARAMETERS : cache_name - Ascii name for the cache
* object_size - Size of each cached object
* return_cache - Where the new cache object is returned
*
* RETURN : Status
*
* DESCRIPTION : Create a local memory list for tracking purposed
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
acpi_status
2016-03-24 09:40:40 +08:00
acpi_ut_create_list ( const char * list_name ,
2012-10-31 02:25:05 +00:00
u16 object_size , struct acpi_memory_list * * return_cache )
{
struct acpi_memory_list * cache ;
2016-08-04 16:43:32 +08:00
cache = acpi_os_allocate_zeroed ( sizeof ( struct acpi_memory_list ) ) ;
2012-10-31 02:25:05 +00:00
if ( ! cache ) {
return ( AE_NO_MEMORY ) ;
}
cache - > list_name = list_name ;
cache - > object_size = object_size ;
* return_cache = cache ;
return ( AE_OK ) ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_allocate_and_track
*
* PARAMETERS : size - Size of the allocation
* component - Component type of caller
* module - Source file name of caller
* line - Line number of caller
*
* RETURN : Address of the allocated memory on success , NULL on failure .
*
* DESCRIPTION : The subsystem ' s equivalent of malloc .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void * acpi_ut_allocate_and_track ( acpi_size size ,
u32 component , const char * module , u32 line )
{
struct acpi_debug_mem_block * allocation ;
acpi_status status ;
2013-10-29 09:29:27 +08:00
/* Check for an inadvertent size of zero bytes */
if ( ! size ) {
ACPI_WARNING ( ( module , line ,
" Attempt to allocate zero bytes, allocating 1 byte " ) ) ;
size = 1 ;
}
2012-10-31 02:25:05 +00:00
allocation =
2013-10-29 09:29:27 +08:00
acpi_os_allocate ( size + sizeof ( struct acpi_debug_mem_header ) ) ;
2012-10-31 02:25:05 +00:00
if ( ! allocation ) {
2013-10-29 09:29:27 +08:00
/* Report allocation error */
ACPI_WARNING ( ( module , line ,
" Could not allocate size %u " , ( u32 ) size ) ) ;
2012-10-31 02:25:05 +00:00
return ( NULL ) ;
}
2015-12-29 13:54:36 +08:00
status =
acpi_ut_track_allocation ( allocation , size , ACPI_MEM_MALLOC ,
component , module , line ) ;
2012-10-31 02:25:05 +00:00
if ( ACPI_FAILURE ( status ) ) {
acpi_os_free ( allocation ) ;
return ( NULL ) ;
}
acpi_gbl_global_list - > total_allocated + + ;
acpi_gbl_global_list - > total_size + = ( u32 ) size ;
acpi_gbl_global_list - > current_total_size + = ( u32 ) size ;
2015-12-29 13:54:36 +08:00
2012-10-31 02:25:05 +00:00
if ( acpi_gbl_global_list - > current_total_size >
acpi_gbl_global_list - > max_occupied ) {
acpi_gbl_global_list - > max_occupied =
acpi_gbl_global_list - > current_total_size ;
}
return ( ( void * ) & allocation - > user_space ) ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_allocate_zeroed_and_track
*
* PARAMETERS : size - Size of the allocation
* component - Component type of caller
* module - Source file name of caller
* line - Line number of caller
*
* RETURN : Address of the allocated memory on success , NULL on failure .
*
* DESCRIPTION : Subsystem equivalent of calloc .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void * acpi_ut_allocate_zeroed_and_track ( acpi_size size ,
u32 component ,
const char * module , u32 line )
{
struct acpi_debug_mem_block * allocation ;
acpi_status status ;
2013-10-29 09:29:27 +08:00
/* Check for an inadvertent size of zero bytes */
if ( ! size ) {
ACPI_WARNING ( ( module , line ,
" Attempt to allocate zero bytes, allocating 1 byte " ) ) ;
size = 1 ;
}
2012-10-31 02:25:05 +00:00
allocation =
2013-10-29 09:29:27 +08:00
acpi_os_allocate_zeroed ( size +
sizeof ( struct acpi_debug_mem_header ) ) ;
2012-10-31 02:25:05 +00:00
if ( ! allocation ) {
/* Report allocation error */
ACPI_ERROR ( ( module , line ,
" Could not allocate size %u " , ( u32 ) size ) ) ;
return ( NULL ) ;
}
status = acpi_ut_track_allocation ( allocation , size ,
ACPI_MEM_CALLOC , component , module ,
line ) ;
if ( ACPI_FAILURE ( status ) ) {
acpi_os_free ( allocation ) ;
return ( NULL ) ;
}
acpi_gbl_global_list - > total_allocated + + ;
acpi_gbl_global_list - > total_size + = ( u32 ) size ;
acpi_gbl_global_list - > current_total_size + = ( u32 ) size ;
2015-12-29 13:54:36 +08:00
2012-10-31 02:25:05 +00:00
if ( acpi_gbl_global_list - > current_total_size >
acpi_gbl_global_list - > max_occupied ) {
acpi_gbl_global_list - > max_occupied =
acpi_gbl_global_list - > current_total_size ;
}
return ( ( void * ) & allocation - > user_space ) ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_free_and_track
*
* PARAMETERS : allocation - Address of the memory to deallocate
* component - Component type of caller
* module - Source file name of caller
* line - Line number of caller
*
* RETURN : None
*
* DESCRIPTION : Frees the memory at Allocation
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void
acpi_ut_free_and_track ( void * allocation ,
u32 component , const char * module , u32 line )
{
struct acpi_debug_mem_block * debug_block ;
acpi_status status ;
ACPI_FUNCTION_TRACE_PTR ( ut_free , allocation ) ;
if ( NULL = = allocation ) {
ACPI_ERROR ( ( module , line , " Attempt to delete a NULL address " ) ) ;
return_VOID ;
}
debug_block = ACPI_CAST_PTR ( struct acpi_debug_mem_block ,
( ( ( char * ) allocation ) -
sizeof ( struct acpi_debug_mem_header ) ) ) ;
acpi_gbl_global_list - > total_freed + + ;
acpi_gbl_global_list - > current_total_size - = debug_block - > size ;
2015-12-29 13:54:36 +08:00
status =
acpi_ut_remove_allocation ( debug_block , component , module , line ) ;
2012-10-31 02:25:05 +00:00
if ( ACPI_FAILURE ( status ) ) {
ACPI_EXCEPTION ( ( AE_INFO , status , " Could not free memory " ) ) ;
}
acpi_os_free ( debug_block ) ;
2014-02-08 09:42:12 +08:00
ACPI_DEBUG_PRINT ( ( ACPI_DB_ALLOCATIONS , " %p freed (block %p) \n " ,
allocation , debug_block ) ) ;
2012-10-31 02:25:05 +00:00
return_VOID ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_find_allocation
*
* PARAMETERS : allocation - Address of allocated memory
*
2012-10-31 02:27:32 +00:00
* RETURN : Three cases :
* 1 ) List is empty , NULL is returned .
* 2 ) Element was found . Returns Allocation parameter .
* 3 ) Element was not found . Returns position where it should be
* inserted into the list .
2012-10-31 02:25:05 +00:00
*
* DESCRIPTION : Searches for an element in the global allocation tracking list .
2012-10-31 02:27:32 +00:00
* If the element is not found , returns the location within the
* list where the element should be inserted .
*
* Note : The list is ordered by larger - to - smaller addresses .
*
* This global list is used to detect memory leaks in ACPICA as
* well as other issues such as an attempt to release the same
* internal object more than once . Although expensive as far
* as cpu time , this list is much more helpful for finding these
* types of issues than using memory leak detectors outside of
* the ACPICA code .
2012-10-31 02:25:05 +00:00
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-10-31 02:27:32 +00:00
static struct acpi_debug_mem_block * acpi_ut_find_allocation ( struct
acpi_debug_mem_block
* allocation )
2012-10-31 02:25:05 +00:00
{
struct acpi_debug_mem_block * element ;
element = acpi_gbl_global_list - > list_head ;
2012-10-31 02:27:32 +00:00
if ( ! element ) {
return ( NULL ) ;
}
/*
* Search for the address .
*
* Note : List is ordered by larger - to - smaller addresses , on the
* assumption that a new allocation usually has a larger address
* than previous allocations .
*/
while ( element > allocation ) {
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
/* Check for end-of-list */
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
if ( ! element - > next ) {
2012-10-31 02:25:05 +00:00
return ( element ) ;
}
element = element - > next ;
}
2012-10-31 02:27:32 +00:00
if ( element = = allocation ) {
return ( element ) ;
}
return ( element - > previous ) ;
2012-10-31 02:25:05 +00:00
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_track_allocation
*
* PARAMETERS : allocation - Address of allocated memory
* size - Size of the allocation
* alloc_type - MEM_MALLOC or MEM_CALLOC
* component - Component type of caller
* module - Source file name of caller
* line - Line number of caller
*
2012-10-31 02:27:32 +00:00
* RETURN : Status
2012-10-31 02:25:05 +00:00
*
* DESCRIPTION : Inserts an element into the global allocation tracking list .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static acpi_status
acpi_ut_track_allocation ( struct acpi_debug_mem_block * allocation ,
acpi_size size ,
u8 alloc_type ,
u32 component , const char * module , u32 line )
{
struct acpi_memory_list * mem_list ;
struct acpi_debug_mem_block * element ;
acpi_status status = AE_OK ;
ACPI_FUNCTION_TRACE_PTR ( ut_track_allocation , allocation ) ;
if ( acpi_gbl_disable_mem_tracking ) {
return_ACPI_STATUS ( AE_OK ) ;
}
mem_list = acpi_gbl_global_list ;
status = acpi_ut_acquire_mutex ( ACPI_MTX_MEMORY ) ;
if ( ACPI_FAILURE ( status ) ) {
return_ACPI_STATUS ( status ) ;
}
/*
2012-10-31 02:27:32 +00:00
* Search the global list for this address to make sure it is not
* already present . This will catch several kinds of problems .
2012-10-31 02:25:05 +00:00
*/
element = acpi_ut_find_allocation ( allocation ) ;
2012-10-31 02:27:32 +00:00
if ( element = = allocation ) {
2012-10-31 02:25:05 +00:00
ACPI_ERROR ( ( AE_INFO ,
2012-10-31 02:27:32 +00:00
" UtTrackAllocation: Allocation (%p) already present in global list! " ,
2012-10-31 02:25:05 +00:00
allocation ) ) ;
goto unlock_and_exit ;
}
2012-10-31 02:27:32 +00:00
/* Fill in the instance data */
2012-10-31 02:25:05 +00:00
allocation - > size = ( u32 ) size ;
allocation - > alloc_type = alloc_type ;
allocation - > component = component ;
allocation - > line = line ;
2018-01-04 13:41:27 -08:00
acpi_ut_safe_strncpy ( allocation - > module , ( char * ) module ,
ACPI_MAX_MODULE_NAME ) ;
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
if ( ! element ) {
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
/* Insert at list head */
if ( mem_list - > list_head ) {
( ( struct acpi_debug_mem_block * ) ( mem_list - > list_head ) ) - >
previous = allocation ;
}
allocation - > next = mem_list - > list_head ;
allocation - > previous = NULL ;
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
mem_list - > list_head = allocation ;
} else {
/* Insert after element */
2012-10-31 02:25:05 +00:00
2012-10-31 02:27:32 +00:00
allocation - > next = element - > next ;
allocation - > previous = element ;
if ( element - > next ) {
( element - > next ) - > previous = allocation ;
}
element - > next = allocation ;
}
2012-10-31 02:25:05 +00:00
2013-10-29 09:30:02 +08:00
unlock_and_exit :
2012-10-31 02:25:05 +00:00
status = acpi_ut_release_mutex ( ACPI_MTX_MEMORY ) ;
return_ACPI_STATUS ( status ) ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_remove_allocation
*
* PARAMETERS : allocation - Address of allocated memory
* component - Component type of caller
* module - Source file name of caller
* line - Line number of caller
*
2012-10-31 02:27:32 +00:00
* RETURN : Status
2012-10-31 02:25:05 +00:00
*
* DESCRIPTION : Deletes an element from the global allocation tracking list .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static acpi_status
acpi_ut_remove_allocation ( struct acpi_debug_mem_block * allocation ,
u32 component , const char * module , u32 line )
{
struct acpi_memory_list * mem_list ;
acpi_status status ;
2012-12-19 05:37:59 +00:00
ACPI_FUNCTION_NAME ( ut_remove_allocation ) ;
2012-10-31 02:25:05 +00:00
if ( acpi_gbl_disable_mem_tracking ) {
2012-12-19 05:37:59 +00:00
return ( AE_OK ) ;
2012-10-31 02:25:05 +00:00
}
mem_list = acpi_gbl_global_list ;
if ( NULL = = mem_list - > list_head ) {
/* No allocations! */
ACPI_ERROR ( ( module , line ,
" Empty allocation list, nothing to free! " ) ) ;
2012-12-19 05:37:59 +00:00
return ( AE_OK ) ;
2012-10-31 02:25:05 +00:00
}
status = acpi_ut_acquire_mutex ( ACPI_MTX_MEMORY ) ;
if ( ACPI_FAILURE ( status ) ) {
2012-12-19 05:37:59 +00:00
return ( status ) ;
2012-10-31 02:25:05 +00:00
}
/* Unlink */
if ( allocation - > previous ) {
( allocation - > previous ) - > next = allocation - > next ;
} else {
mem_list - > list_head = allocation - > next ;
}
if ( allocation - > next ) {
( allocation - > next ) - > previous = allocation - > previous ;
}
2012-12-19 05:37:59 +00:00
ACPI_DEBUG_PRINT ( ( ACPI_DB_ALLOCATIONS , " Freeing %p, size 0%X \n " ,
& allocation - > user_space , allocation - > size ) ) ;
2012-10-31 02:25:05 +00:00
/* Mark the segment as deleted */
2015-07-01 14:45:11 +08:00
memset ( & allocation - > user_space , 0xEA , allocation - > size ) ;
2012-10-31 02:25:05 +00:00
status = acpi_ut_release_mutex ( ACPI_MTX_MEMORY ) ;
2012-12-19 05:37:59 +00:00
return ( status ) ;
2012-10-31 02:25:05 +00:00
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_dump_allocation_info
*
2012-10-31 02:27:32 +00:00
* PARAMETERS : None
2012-10-31 02:25:05 +00:00
*
* RETURN : None
*
* DESCRIPTION : Print some info about the outstanding allocations .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void acpi_ut_dump_allocation_info ( void )
{
/*
struct acpi_memory_list * mem_list ;
*/
ACPI_FUNCTION_TRACE ( ut_dump_allocation_info ) ;
/*
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Current allocations " ,
mem_list - > current_count ,
ROUND_UP_TO_1K ( mem_list - > current_size ) ) ) ;
2012-10-31 02:25:05 +00:00
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Max concurrent allocations " ,
mem_list - > max_concurrent_count ,
ROUND_UP_TO_1K ( mem_list - > max_concurrent_size ) ) ) ;
2012-10-31 02:25:05 +00:00
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Total (all) internal objects " ,
running_object_count ,
ROUND_UP_TO_1K ( running_object_size ) ) ) ;
2012-10-31 02:25:05 +00:00
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Total (all) allocations " ,
running_alloc_count ,
ROUND_UP_TO_1K ( running_alloc_size ) ) ) ;
2012-10-31 02:25:05 +00:00
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Current Nodes " ,
acpi_gbl_current_node_count ,
ROUND_UP_TO_1K ( acpi_gbl_current_node_size ) ) ) ;
2012-10-31 02:25:05 +00:00
ACPI_DEBUG_PRINT ( TRACE_ALLOCATIONS | TRACE_TABLES ,
2015-12-29 13:54:36 +08:00
( " %30s: %4d (%3d Kb) \n " , " Max Nodes " ,
acpi_gbl_max_concurrent_node_count ,
ROUND_UP_TO_1K ( ( acpi_gbl_max_concurrent_node_count *
sizeof ( struct acpi_namespace_node ) ) ) ) ) ;
2012-10-31 02:25:05 +00:00
*/
return_VOID ;
}
/*******************************************************************************
*
* FUNCTION : acpi_ut_dump_allocations
*
* PARAMETERS : component - Component ( s ) to dump info for .
2012-10-31 02:26:55 +00:00
* module - Module to dump info for . NULL means all .
2012-10-31 02:25:05 +00:00
*
* RETURN : None
*
* DESCRIPTION : Print a list of all outstanding allocations .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void acpi_ut_dump_allocations ( u32 component , const char * module )
{
struct acpi_debug_mem_block * element ;
union acpi_descriptor * descriptor ;
u32 num_outstanding = 0 ;
u8 descriptor_type ;
ACPI_FUNCTION_TRACE ( ut_dump_allocations ) ;
if ( acpi_gbl_disable_mem_tracking ) {
2012-10-31 02:26:01 +00:00
return_VOID ;
2012-10-31 02:25:05 +00:00
}
/*
* Walk the allocation list .
*/
if ( ACPI_FAILURE ( acpi_ut_acquire_mutex ( ACPI_MTX_MEMORY ) ) ) {
2012-10-31 02:26:01 +00:00
return_VOID ;
2012-10-31 02:25:05 +00:00
}
2017-08-03 14:27:22 +08:00
if ( ! acpi_gbl_global_list ) {
goto exit ;
}
2012-10-31 02:25:05 +00:00
element = acpi_gbl_global_list - > list_head ;
while ( element ) {
if ( ( element - > component & component ) & &
( ( module = = NULL )
2015-07-01 14:45:11 +08:00
| | ( 0 = = strcmp ( module , element - > module ) ) ) ) {
2012-10-31 02:25:05 +00:00
descriptor =
ACPI_CAST_PTR ( union acpi_descriptor ,
& element - > user_space ) ;
if ( element - > size <
sizeof ( struct acpi_common_descriptor ) ) {
2017-08-03 14:27:22 +08:00
acpi_os_printf ( " %p Length 0x%04X %9.9s-%4.4u "
2012-10-31 02:25:05 +00:00
" [Not a Descriptor - too small] \n " ,
descriptor , element - > size ,
element - > module , element - > line ) ;
} else {
/* Ignore allocated objects that are in a cache */
if ( ACPI_GET_DESCRIPTOR_TYPE ( descriptor ) ! =
ACPI_DESC_TYPE_CACHED ) {
acpi_os_printf
2017-08-03 14:27:22 +08:00
( " %p Length 0x%04X %9.9s-%4.4u [%s] " ,
2012-10-31 02:25:05 +00:00
descriptor , element - > size ,
element - > module , element - > line ,
acpi_ut_get_descriptor_name
( descriptor ) ) ;
/* Validate the descriptor type using Type field and length */
descriptor_type = 0 ; /* Not a valid descriptor type */
switch ( ACPI_GET_DESCRIPTOR_TYPE
( descriptor ) ) {
case ACPI_DESC_TYPE_OPERAND :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
if ( element - > size = =
sizeof ( union
acpi_operand_object ) )
{
descriptor_type =
ACPI_DESC_TYPE_OPERAND ;
}
break ;
case ACPI_DESC_TYPE_PARSER :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
if ( element - > size = =
sizeof ( union
acpi_parse_object ) ) {
descriptor_type =
ACPI_DESC_TYPE_PARSER ;
}
break ;
case ACPI_DESC_TYPE_NAMED :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
if ( element - > size = =
sizeof ( struct
acpi_namespace_node ) )
{
descriptor_type =
ACPI_DESC_TYPE_NAMED ;
}
break ;
default :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
break ;
}
/* Display additional info for the major descriptor types */
switch ( descriptor_type ) {
case ACPI_DESC_TYPE_OPERAND :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
acpi_os_printf
( " %12.12s RefCount 0x%04X \n " ,
acpi_ut_get_type_name
( descriptor - > object . common .
type ) ,
descriptor - > object . common .
reference_count ) ;
break ;
case ACPI_DESC_TYPE_PARSER :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
acpi_os_printf
( " AmlOpcode 0x%04hX \n " ,
descriptor - > op . asl .
aml_opcode ) ;
break ;
case ACPI_DESC_TYPE_NAMED :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
acpi_os_printf ( " %4.4s \n " ,
acpi_ut_get_node_name
( & descriptor - >
node ) ) ;
break ;
default :
2013-06-08 00:58:14 +00:00
2012-10-31 02:25:05 +00:00
acpi_os_printf ( " \n " ) ;
break ;
}
}
}
num_outstanding + + ;
}
element = element - > next ;
}
2017-08-03 14:27:22 +08:00
exit :
2012-10-31 02:25:05 +00:00
( void ) acpi_ut_release_mutex ( ACPI_MTX_MEMORY ) ;
/* Print summary */
if ( ! num_outstanding ) {
2016-02-19 14:16:42 +08:00
ACPI_INFO ( ( " No outstanding allocations " ) ) ;
2012-10-31 02:25:05 +00:00
} else {
2017-11-17 15:42:20 -08:00
ACPI_ERROR ( ( AE_INFO , " %u (0x%X) Outstanding cache allocations " ,
2012-10-31 02:25:05 +00:00
num_outstanding , num_outstanding ) ) ;
}
return_VOID ;
}
# endif /* ACPI_DBG_TRACK_ALLOCATIONS */
