patch-2.4.22 linux-2.4.22/drivers/acpi/utilities/utalloc.c
Next file: linux-2.4.22/drivers/acpi/utilities/utcopy.c
Previous file: linux-2.4.22/drivers/acpi/utilities/Makefile
Back to the patch index
Back to the overall index
- Lines: 1312
- Date:
2003-08-25 04:44:41.000000000 -0700
- Orig file:
linux-2.4.21/drivers/acpi/utilities/utalloc.c
- Orig date:
2001-10-24 14:06:22.000000000 -0700
diff -urN linux-2.4.21/drivers/acpi/utilities/utalloc.c linux-2.4.22/drivers/acpi/utilities/utalloc.c
@@ -1,44 +1,58 @@
/******************************************************************************
*
* Module Name: utalloc - local cache and memory allocation routines
- * $Revision: 106 $
*
*****************************************************************************/
/*
- * Copyright (C) 2000, 2001 R. Byron Moore
+ * Copyright (C) 2000 - 2003, R. Byron Moore
+ * All rights reserved.
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer,
+ * without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ * substantially similar to the "NO WARRANTY" disclaimer below
+ * ("Disclaimer") and any redistribution must be conditioned upon
+ * including a substantially similar Disclaimer requirement for further
+ * binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ * of any contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
*/
-#include "acpi.h"
-#include "acparser.h"
-#include "acinterp.h"
-#include "acnamesp.h"
-#include "acglobal.h"
+#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
- MODULE_NAME ("utalloc")
+ ACPI_MODULE_NAME ("utalloc")
/******************************************************************************
*
- * FUNCTION: Acpi_ut_release_to_cache
+ * FUNCTION: acpi_ut_release_to_cache
*
- * PARAMETERS: List_id - Memory list/cache ID
+ * PARAMETERS: list_id - Memory list/cache ID
* Object - The object to be released
*
* RETURN: None
@@ -50,13 +64,13 @@
void
acpi_ut_release_to_cache (
- u32 list_id,
- void *object)
+ u32 list_id,
+ void *object)
{
- ACPI_MEMORY_LIST *cache_info;
+ struct acpi_memory_list *cache_info;
- FUNCTION_ENTRY ();
+ ACPI_FUNCTION_ENTRY ();
/* If walk cache is full, just free this wallkstate object */
@@ -70,29 +84,31 @@
/* Otherwise put this object back into the cache */
else {
- acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
+ if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
+ return;
+ }
/* Mark the object as cached */
- MEMSET (object, 0xCA, cache_info->object_size);
- ((acpi_operand_object *) object)->common.data_type = ACPI_CACHED_OBJECT;
+ ACPI_MEMSET (object, 0xCA, cache_info->object_size);
+ ACPI_SET_DESCRIPTOR_TYPE (object, ACPI_DESC_TYPE_CACHED);
/* Put the object at the head of the cache list */
- * (char **) (((char *) object) + cache_info->link_offset) = cache_info->list_head;
+ * (ACPI_CAST_INDIRECT_PTR (char, &(((char *) object)[cache_info->link_offset]))) = cache_info->list_head;
cache_info->list_head = object;
cache_info->cache_depth++;
- acpi_ut_release_mutex (ACPI_MTX_CACHES);
+ (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
}
}
/******************************************************************************
*
- * FUNCTION: Acpi_ut_acquire_from_cache
+ * FUNCTION: acpi_ut_acquire_from_cache
*
- * PARAMETERS: List_id - Memory list ID
+ * PARAMETERS: list_id - Memory list ID
*
* RETURN: A requested object. NULL if the object could not be
* allocated.
@@ -104,17 +120,20 @@
void *
acpi_ut_acquire_from_cache (
- u32 list_id)
+ u32 list_id)
{
- ACPI_MEMORY_LIST *cache_info;
- void *object;
+ struct acpi_memory_list *cache_info;
+ void *object;
- PROC_NAME ("Ut_acquire_from_cache");
+ ACPI_FUNCTION_NAME ("ut_acquire_from_cache");
cache_info = &acpi_gbl_memory_lists[list_id];
- acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
+ if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) {
+ return (NULL);
+ }
+
ACPI_MEM_TRACKING (cache_info->cache_requests++);
/* Check the cache first */
@@ -123,7 +142,7 @@
/* There is an object available, use it */
object = cache_info->list_head;
- cache_info->list_head = * (char **) (((char *) object) + cache_info->link_offset);
+ cache_info->list_head = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) object)[cache_info->link_offset])));
ACPI_MEM_TRACKING (cache_info->cache_hits++);
cache_info->cache_depth--;
@@ -133,11 +152,13 @@
object, acpi_gbl_memory_lists[list_id].list_name));
#endif
- acpi_ut_release_mutex (ACPI_MTX_CACHES);
+ if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
+ return (NULL);
+ }
/* Clear (zero) the previously used Object */
- MEMSET (object, 0, cache_info->object_size);
+ ACPI_MEMSET (object, 0, cache_info->object_size);
}
else {
@@ -145,7 +166,9 @@
/* Avoid deadlock with ACPI_MEM_CALLOCATE */
- acpi_ut_release_mutex (ACPI_MTX_CACHES);
+ if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) {
+ return (NULL);
+ }
object = ACPI_MEM_CALLOCATE (cache_info->object_size);
ACPI_MEM_TRACKING (cache_info->total_allocated++);
@@ -157,9 +180,9 @@
/******************************************************************************
*
- * FUNCTION: Acpi_ut_delete_generic_cache
+ * FUNCTION: acpi_ut_delete_generic_cache
*
- * PARAMETERS: List_id - Memory list ID
+ * PARAMETERS: list_id - Memory list ID
*
* RETURN: None
*
@@ -169,20 +192,20 @@
void
acpi_ut_delete_generic_cache (
- u32 list_id)
+ u32 list_id)
{
- ACPI_MEMORY_LIST *cache_info;
- char *next;
+ struct acpi_memory_list *cache_info;
+ char *next;
- FUNCTION_ENTRY ();
+ ACPI_FUNCTION_ENTRY ();
cache_info = &acpi_gbl_memory_lists[list_id];
while (cache_info->list_head) {
/* Delete one cached state object */
- next = * (char **) (((char *) cache_info->list_head) + cache_info->link_offset);
+ next = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) cache_info->list_head)[cache_info->link_offset])));
ACPI_MEM_FREE (cache_info->list_head);
cache_info->list_head = next;
@@ -191,26 +214,396 @@
}
-#ifdef ACPI_DBG_TRACK_ALLOCATIONS
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_validate_buffer
+ *
+ * PARAMETERS: Buffer - Buffer descriptor to be validated
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Perform parameter validation checks on an struct acpi_buffer
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_validate_buffer (
+ struct acpi_buffer *buffer)
+{
+
+ /* Obviously, the structure pointer must be valid */
+
+ if (!buffer) {
+ return (AE_BAD_PARAMETER);
+ }
+
+ /* Special semantics for the length */
+
+ if ((buffer->length == ACPI_NO_BUFFER) ||
+ (buffer->length == ACPI_ALLOCATE_BUFFER) ||
+ (buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
+ return (AE_OK);
+ }
+
+ /* Length is valid, the buffer pointer must be also */
+ if (!buffer->pointer) {
+ return (AE_BAD_PARAMETER);
+ }
+
+ return (AE_OK);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_initialize_buffer
+ *
+ * PARAMETERS: required_length - Length needed
+ * Buffer - Buffer to be validated
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Validate that the buffer is of the required length or
+ * allocate a new buffer.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_initialize_buffer (
+ struct acpi_buffer *buffer,
+ acpi_size required_length)
+{
+ acpi_status status = AE_OK;
+
+
+ switch (buffer->length) {
+ case ACPI_NO_BUFFER:
+
+ /* Set the exception and returned the required length */
+
+ status = AE_BUFFER_OVERFLOW;
+ break;
+
+
+ case ACPI_ALLOCATE_BUFFER:
+
+ /* Allocate a new buffer */
+
+ buffer->pointer = acpi_os_allocate (required_length);
+ if (!buffer->pointer) {
+ return (AE_NO_MEMORY);
+ }
+
+ /* Clear the buffer */
+
+ ACPI_MEMSET (buffer->pointer, 0, required_length);
+ break;
+
+
+ case ACPI_ALLOCATE_LOCAL_BUFFER:
+
+ /* Allocate a new buffer with local interface to allow tracking */
+
+ buffer->pointer = ACPI_MEM_ALLOCATE (required_length);
+ if (!buffer->pointer) {
+ return (AE_NO_MEMORY);
+ }
+
+ /* Clear the buffer */
+
+ ACPI_MEMSET (buffer->pointer, 0, required_length);
+ break;
+
+
+ default:
+
+ /* Validate the size of the buffer */
+
+ if (buffer->length < required_length) {
+ status = AE_BUFFER_OVERFLOW;
+ }
+ break;
+ }
+
+ buffer->length = required_length;
+ return (status);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_allocate
+ *
+ * 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 (
+ acpi_size size,
+ u32 component,
+ char *module,
+ u32 line)
+{
+ void *allocation;
+
+
+ ACPI_FUNCTION_TRACE_U32 ("ut_allocate", size);
+
+
+ /* Check for an inadvertent size of zero bytes */
+
+ if (!size) {
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_allocate: Attempt to allocate zero bytes\n"));
+ size = 1;
+ }
+
+ allocation = acpi_os_allocate (size);
+ if (!allocation) {
+ /* Report allocation error */
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_allocate: Could not allocate size %X\n", (u32) size));
+
+ return_PTR (NULL);
+ }
+
+ return_PTR (allocation);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_callocate
+ *
+ * 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_callocate (
+ acpi_size size,
+ u32 component,
+ char *module,
+ u32 line)
+{
+ void *allocation;
+
+
+ ACPI_FUNCTION_TRACE_U32 ("ut_callocate", size);
+
+
+ /* Check for an inadvertent size of zero bytes */
+
+ if (!size) {
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_callocate: Attempt to allocate zero bytes\n"));
+ return_PTR (NULL);
+ }
+
+ allocation = acpi_os_allocate (size);
+ if (!allocation) {
+ /* Report allocation error */
+
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_callocate: Could not allocate size %X\n", (u32) size));
+ return_PTR (NULL);
+ }
+
+ /* Clear the memory block */
+
+ ACPI_MEMSET (allocation, 0, size);
+ return_PTR (allocation);
+}
+
+
+#ifdef ACPI_DBG_TRACK_ALLOCATIONS
/*
* 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.
*
* Each memory allocation is tracked via a doubly linked list. Each
* element contains the caller's component, module name, function name, and
- * line number. Acpi_ut_allocate and Acpi_ut_callocate call
- * Acpi_ut_track_allocation to add an element to the list; deletion
- * occurs in the body of Acpi_ut_free.
+ * line number. acpi_ut_allocate and acpi_ut_callocate call
+ * acpi_ut_track_allocation to add an element to the list; deletion
+ * occurs in the body of acpi_ut_free.
*/
/*******************************************************************************
*
- * FUNCTION: Acpi_ut_find_allocation
+ * 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,
+ char *module,
+ u32 line)
+{
+ struct acpi_debug_mem_block *allocation;
+ acpi_status status;
+
+
+ allocation = acpi_ut_allocate (size + sizeof (struct acpi_debug_mem_block), component,
+ module, line);
+ if (!allocation) {
+ return (NULL);
+ }
+
+ status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
+ ACPI_MEM_MALLOC, component, module, line);
+ if (ACPI_FAILURE (status)) {
+ acpi_os_free (allocation);
+ return (NULL);
+ }
+
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) size;
+
+ return ((void *) &allocation->user_space);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_callocate_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_callocate_and_track (
+ acpi_size size,
+ u32 component,
+ char *module,
+ u32 line)
+{
+ struct acpi_debug_mem_block *allocation;
+ acpi_status status;
+
+
+ allocation = acpi_ut_callocate (size + sizeof (struct acpi_debug_mem_block), component,
+ module, line);
+ if (!allocation) {
+ /* Report allocation error */
+
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_callocate: Could not allocate size %X\n", (u32) size));
+ return (NULL);
+ }
+
+ status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, allocation, size,
+ ACPI_MEM_CALLOC, component, module, line);
+ if (ACPI_FAILURE (status)) {
+ acpi_os_free (allocation);
+ return (NULL);
+ }
+
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += (u32) 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,
+ 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_REPORT_ERROR (module, line, component,
+ ("acpi_ut_free: Attempt to delete a NULL address\n"));
+
+ return_VOID;
+ }
+
+ debug_block = ACPI_CAST_PTR (struct acpi_debug_mem_block,
+ (((char *) allocation) - sizeof (struct acpi_debug_mem_header)));
+
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_freed++;
+ acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size -= debug_block->size;
+
+ status = acpi_ut_remove_allocation (ACPI_MEM_LIST_GLOBAL, debug_block,
+ component, module, line);
+ if (ACPI_FAILURE (status)) {
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not free memory, %s\n",
+ acpi_format_exception (status)));
+ }
+
+ acpi_os_free (debug_block);
+
+ ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation));
+
+ return_VOID;
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_ut_find_allocation
*
- * PARAMETERS: Address - Address of allocated memory
+ * PARAMETERS: Allocation - Address of allocated memory
*
* RETURN: A list element if found; NULL otherwise.
*
@@ -218,15 +611,15 @@
*
******************************************************************************/
-acpi_debug_mem_block *
+struct acpi_debug_mem_block *
acpi_ut_find_allocation (
- u32 list_id,
- void *address)
+ u32 list_id,
+ void *allocation)
{
- acpi_debug_mem_block *element;
+ struct acpi_debug_mem_block *element;
- FUNCTION_ENTRY ();
+ ACPI_FUNCTION_ENTRY ();
if (list_id > ACPI_MEM_LIST_MAX) {
@@ -238,7 +631,7 @@
/* Search for the address. */
while (element) {
- if (element == address) {
+ if (element == allocation) {
return (element);
}
@@ -251,11 +644,11 @@
/*******************************************************************************
*
- * FUNCTION: Acpi_ut_track_allocation
+ * FUNCTION: acpi_ut_track_allocation
*
- * PARAMETERS: Address - Address of allocated memory
+ * PARAMETERS: Allocation - Address of allocated memory
* Size - Size of the allocation
- * Alloc_type - MEM_MALLOC or MEM_CALLOC
+ * alloc_type - MEM_MALLOC or MEM_CALLOC
* Component - Component type of caller
* Module - Source file name of caller
* Line - Line number of caller
@@ -268,20 +661,20 @@
acpi_status
acpi_ut_track_allocation (
- u32 list_id,
- acpi_debug_mem_block *address,
- u32 size,
- u8 alloc_type,
- u32 component,
- NATIVE_CHAR *module,
- u32 line)
-{
- ACPI_MEMORY_LIST *mem_list;
- acpi_debug_mem_block *element;
- acpi_status status = AE_OK;
+ u32 list_id,
+ struct acpi_debug_mem_block *allocation,
+ acpi_size size,
+ u8 alloc_type,
+ u32 component,
+ char *module,
+ u32 line)
+{
+ struct acpi_memory_list *mem_list;
+ struct acpi_debug_mem_block *element;
+ acpi_status status = AE_OK;
- FUNCTION_TRACE_PTR ("Ut_track_allocation", address);
+ ACPI_FUNCTION_TRACE_PTR ("ut_track_allocation", allocation);
if (list_id > ACPI_MEM_LIST_MAX) {
@@ -289,55 +682,58 @@
}
mem_list = &acpi_gbl_memory_lists[list_id];
- acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
+ status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
+ if (ACPI_FAILURE (status)) {
+ return_ACPI_STATUS (status);
+ }
/*
* Search list for this address to make sure it is not already on the list.
* This will catch several kinds of problems.
*/
- element = acpi_ut_find_allocation (list_id, address);
+ element = acpi_ut_find_allocation (list_id, allocation);
if (element) {
- REPORT_ERROR (("Ut_track_allocation: Address already present in list! (%p)\n",
- address));
+ ACPI_REPORT_ERROR (("ut_track_allocation: Allocation already present in list! (%p)\n",
+ allocation));
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n", element, address));
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n", element, allocation));
goto unlock_and_exit;
}
/* Fill in the instance data. */
- address->size = size;
- address->alloc_type = alloc_type;
- address->component = component;
- address->line = line;
+ allocation->size = (u32) size;
+ allocation->alloc_type = alloc_type;
+ allocation->component = component;
+ allocation->line = line;
- STRNCPY (address->module, module, MAX_MODULE_NAME);
+ ACPI_STRNCPY (allocation->module, module, ACPI_MAX_MODULE_NAME);
/* Insert at list head */
if (mem_list->list_head) {
- ((acpi_debug_mem_block *)(mem_list->list_head))->previous = address;
+ ((struct acpi_debug_mem_block *)(mem_list->list_head))->previous = allocation;
}
- address->next = mem_list->list_head;
- address->previous = NULL;
+ allocation->next = mem_list->list_head;
+ allocation->previous = NULL;
- mem_list->list_head = address;
+ mem_list->list_head = allocation;
unlock_and_exit:
- acpi_ut_release_mutex (ACPI_MTX_MEMORY);
+ status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
return_ACPI_STATUS (status);
}
/*******************************************************************************
*
- * FUNCTION: Acpi_ut_remove_allocation
+ * FUNCTION: acpi_ut_remove_allocation
*
- * PARAMETERS: Address - Address of allocated memory
+ * PARAMETERS: Allocation - Address of allocated memory
* Component - Component type of caller
* Module - Source file name of caller
* Line - Line number of caller
@@ -350,16 +746,17 @@
acpi_status
acpi_ut_remove_allocation (
- u32 list_id,
- acpi_debug_mem_block *address,
- u32 component,
- NATIVE_CHAR *module,
- u32 line)
+ u32 list_id,
+ struct acpi_debug_mem_block *allocation,
+ u32 component,
+ char *module,
+ u32 line)
{
- ACPI_MEMORY_LIST *mem_list;
+ struct acpi_memory_list *mem_list;
+ acpi_status status;
- FUNCTION_TRACE ("Ut_remove_allocation");
+ ACPI_FUNCTION_TRACE ("ut_remove_allocation");
if (list_id > ACPI_MEM_LIST_MAX) {
@@ -370,43 +767,44 @@
if (NULL == mem_list->list_head) {
/* No allocations! */
- _REPORT_ERROR (module, line, component,
- ("Ut_remove_allocation: Empty allocation list, nothing to free!\n"));
+ _ACPI_REPORT_ERROR (module, line, component,
+ ("ut_remove_allocation: Empty allocation list, nothing to free!\n"));
return_ACPI_STATUS (AE_OK);
}
-
- acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
+ status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
+ if (ACPI_FAILURE (status)) {
+ return_ACPI_STATUS (status);
+ }
/* Unlink */
- if (address->previous) {
- (address->previous)->next = address->next;
+ if (allocation->previous) {
+ (allocation->previous)->next = allocation->next;
}
else {
- mem_list->list_head = address->next;
+ mem_list->list_head = allocation->next;
}
- if (address->next) {
- (address->next)->previous = address->previous;
+ if (allocation->next) {
+ (allocation->next)->previous = allocation->previous;
}
-
/* Mark the segment as deleted */
- MEMSET (&address->user_space, 0xEA, address->size);
+ ACPI_MEMSET (&allocation->user_space, 0xEA, allocation->size);
- ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size %X\n", address->size));
+ ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size %X\n", allocation->size));
- acpi_ut_release_mutex (ACPI_MTX_MEMORY);
- return_ACPI_STATUS (AE_OK);
+ status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
+ return_ACPI_STATUS (status);
}
/*******************************************************************************
*
- * FUNCTION: Acpi_ut_dump_allocation_info
+ * FUNCTION: acpi_ut_dump_allocation_info
*
* PARAMETERS:
*
@@ -421,43 +819,43 @@
void)
{
/*
- ACPI_MEMORY_LIST *Mem_list;
+ struct acpi_memory_list *mem_list;
*/
- FUNCTION_TRACE ("Ut_dump_allocation_info");
+ ACPI_FUNCTION_TRACE ("ut_dump_allocation_info");
/*
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Current allocations",
- Mem_list->Current_count,
- ROUND_UP_TO_1K (Mem_list->Current_size)));
+ mem_list->current_count,
+ ROUND_UP_TO_1K (mem_list->current_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
- Mem_list->Max_concurrent_count,
- ROUND_UP_TO_1K (Mem_list->Max_concurrent_size)));
+ mem_list->max_concurrent_count,
+ ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
- Running_object_count,
- ROUND_UP_TO_1K (Running_object_size)));
+ running_object_count,
+ ROUND_UP_TO_1K (running_object_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
- Running_alloc_count,
- ROUND_UP_TO_1K (Running_alloc_size)));
+ running_alloc_count,
+ ROUND_UP_TO_1K (running_alloc_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Current Nodes",
- Acpi_gbl_Current_node_count,
- ROUND_UP_TO_1K (Acpi_gbl_Current_node_size)));
+ acpi_gbl_current_node_count,
+ ROUND_UP_TO_1K (acpi_gbl_current_node_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Max Nodes",
- Acpi_gbl_Max_concurrent_node_count,
- ROUND_UP_TO_1K ((Acpi_gbl_Max_concurrent_node_count * sizeof (acpi_namespace_node)))));
+ acpi_gbl_max_concurrent_node_count,
+ ROUND_UP_TO_1K ((acpi_gbl_max_concurrent_node_count * sizeof (struct acpi_namespace_node)))));
*/
return_VOID;
}
@@ -465,7 +863,7 @@
/*******************************************************************************
*
- * FUNCTION: Acpi_ut_dump_allocations
+ * FUNCTION: acpi_ut_dump_allocations
*
* PARAMETERS: Component - Component(s) to dump info for.
* Module - Module to dump info for. NULL means all.
@@ -478,306 +876,124 @@
void
acpi_ut_dump_allocations (
- u32 component,
- NATIVE_CHAR *module)
+ u32 component,
+ char *module)
{
- acpi_debug_mem_block *element;
- u32 i;
-
+ struct acpi_debug_mem_block *element;
+ union acpi_descriptor *descriptor;
+ u32 num_outstanding = 0;
- FUNCTION_TRACE ("Ut_dump_allocations");
-
- element = acpi_gbl_memory_lists[0].list_head;
- if (element == NULL) {
- ACPI_DEBUG_PRINT ((ACPI_DB_OK,
- "No outstanding allocations.\n"));
- return_VOID;
- }
+ ACPI_FUNCTION_TRACE ("ut_dump_allocations");
/*
* Walk the allocation list.
*/
- acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
-
- ACPI_DEBUG_PRINT ((ACPI_DB_OK,
- "Outstanding allocations:\n"));
+ if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_MEMORY))) {
+ return;
+ }
- for (i = 1; ; i++) /* Just a counter */ {
+ element = acpi_gbl_memory_lists[0].list_head;
+ while (element) {
if ((element->component & component) &&
- ((module == NULL) || (0 == STRCMP (module, element->module)))) {
- if (((acpi_operand_object *)(&element->user_space))->common.type != ACPI_CACHED_OBJECT) {
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- "%p Len %04X %9.9s-%d",
- &element->user_space, element->size, element->module,
- element->line));
+ ((module == NULL) || (0 == ACPI_STRCMP (module, element->module)))) {
+ /* Ignore allocated objects that are in a cache */
+
+ descriptor = ACPI_CAST_PTR (union acpi_descriptor, &element->user_space);
+ if (descriptor->descriptor_id != ACPI_DESC_TYPE_CACHED) {
+ acpi_os_printf ("%p Len %04X %9.9s-%d ",
+ descriptor, element->size, element->module,
+ element->line);
/* Most of the elements will be internal objects. */
- switch (((acpi_operand_object *)
- (&element->user_space))->common.data_type) {
- case ACPI_DESC_TYPE_INTERNAL:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " Obj_type %12.12s R%d",
- acpi_ut_get_type_name (((acpi_operand_object *)(&element->user_space))->common.type),
- ((acpi_operand_object *)(&element->user_space))->common.reference_count));
+ switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) {
+ case ACPI_DESC_TYPE_OPERAND:
+ acpi_os_printf ("obj_type %12.12s R%hd",
+ acpi_ut_get_type_name (descriptor->object.common.type),
+ descriptor->object.common.reference_count);
break;
case ACPI_DESC_TYPE_PARSER:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " Parse_obj Opcode %04X",
- ((acpi_parse_object *)(&element->user_space))->opcode));
+ acpi_os_printf ("parse_obj aml_opcode %04hX",
+ descriptor->op.asl.aml_opcode);
break;
case ACPI_DESC_TYPE_NAMED:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " Node %4.4s",
- (char*)&((acpi_namespace_node *)(&element->user_space))->name));
+ acpi_os_printf ("Node %4.4s",
+ descriptor->node.name.ascii);
break;
case ACPI_DESC_TYPE_STATE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " Untyped State_obj"));
+ acpi_os_printf ("Untyped state_obj");
break;
case ACPI_DESC_TYPE_STATE_UPDATE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " UPDATE State_obj"));
+ acpi_os_printf ("UPDATE state_obj");
break;
case ACPI_DESC_TYPE_STATE_PACKAGE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " PACKAGE State_obj"));
+ acpi_os_printf ("PACKAGE state_obj");
break;
case ACPI_DESC_TYPE_STATE_CONTROL:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " CONTROL State_obj"));
+ acpi_os_printf ("CONTROL state_obj");
break;
case ACPI_DESC_TYPE_STATE_RPSCOPE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " ROOT-PARSE-SCOPE State_obj"));
+ acpi_os_printf ("ROOT-PARSE-SCOPE state_obj");
break;
case ACPI_DESC_TYPE_STATE_PSCOPE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " PARSE-SCOPE State_obj"));
+ acpi_os_printf ("PARSE-SCOPE state_obj");
break;
case ACPI_DESC_TYPE_STATE_WSCOPE:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " WALK-SCOPE State_obj"));
+ acpi_os_printf ("WALK-SCOPE state_obj");
break;
case ACPI_DESC_TYPE_STATE_RESULT:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " RESULT State_obj"));
+ acpi_os_printf ("RESULT state_obj");
break;
case ACPI_DESC_TYPE_STATE_NOTIFY:
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK,
- " NOTIFY State_obj"));
+ acpi_os_printf ("NOTIFY state_obj");
+ break;
+
+ case ACPI_DESC_TYPE_STATE_THREAD:
+ acpi_os_printf ("THREAD state_obj");
+ break;
+
+ default:
+ /* All types should appear above */
break;
}
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_OK, "\n"));
+ acpi_os_printf ( "\n");
+ num_outstanding++;
}
}
-
- if (element->next == NULL) {
- break;
- }
-
element = element->next;
}
- acpi_ut_release_mutex (ACPI_MTX_MEMORY);
-
- ACPI_DEBUG_PRINT ((ACPI_DB_OK,
- "Total number of unfreed allocations = %d(%X)\n", i,i));
-
-
- return_VOID;
-
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION: Acpi_ut_allocate
- *
- * 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 (
- u32 size,
- u32 component,
- NATIVE_CHAR *module,
- u32 line)
-{
- acpi_debug_mem_block *address;
- acpi_status status;
+ (void) acpi_ut_release_mutex (ACPI_MTX_MEMORY);
+ /* Print summary */
- FUNCTION_TRACE_U32 ("Ut_allocate", size);
-
-
- /* Check for an inadvertent size of zero bytes */
-
- if (!size) {
- _REPORT_ERROR (module, line, component,
- ("Ut_allocate: Attempt to allocate zero bytes\n"));
- size = 1;
- }
-
- address = acpi_os_allocate (size + sizeof (acpi_debug_mem_block));
- if (!address) {
- /* Report allocation error */
-
- _REPORT_ERROR (module, line, component,
- ("Ut_allocate: Could not allocate size %X\n", size));
-
- return_PTR (NULL);
- }
-
- status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, address, size,
- MEM_MALLOC, component, module, line);
- if (ACPI_FAILURE (status)) {
- acpi_os_free (address);
- return_PTR (NULL);
- }
-
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += size;
-
- ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", address, size));
-
- return_PTR ((void *) &address->user_space);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION: Acpi_ut_callocate
- *
- * 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_callocate (
- u32 size,
- u32 component,
- NATIVE_CHAR *module,
- u32 line)
-{
- acpi_debug_mem_block *address;
- acpi_status status;
-
-
- FUNCTION_TRACE_U32 ("Ut_callocate", size);
-
-
- /* Check for an inadvertent size of zero bytes */
-
- if (!size) {
- _REPORT_ERROR (module, line, component,
- ("Ut_callocate: Attempt to allocate zero bytes\n"));
- return_PTR (NULL);
- }
-
-
- address = acpi_os_callocate (size + sizeof (acpi_debug_mem_block));
- if (!address) {
- /* Report allocation error */
-
- _REPORT_ERROR (module, line, component,
- ("Ut_callocate: Could not allocate size %X\n", size));
- return_PTR (NULL);
- }
-
- status = acpi_ut_track_allocation (ACPI_MEM_LIST_GLOBAL, address, size,
- MEM_CALLOC, component, module, line);
- if (ACPI_FAILURE (status)) {
- acpi_os_free (address);
- return_PTR (NULL);
+ if (!num_outstanding) {
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
+ "No outstanding allocations.\n"));
}
-
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_allocated++;
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size += size;
-
- ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", address, size));
- return_PTR ((void *) &address->user_space);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION: Acpi_ut_free
- *
- * PARAMETERS: Address - 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 Address
- *
- ******************************************************************************/
-
-void
-acpi_ut_free (
- void *address,
- u32 component,
- NATIVE_CHAR *module,
- u32 line)
-{
- acpi_debug_mem_block *debug_block;
-
-
- FUNCTION_TRACE_PTR ("Ut_free", address);
-
-
- if (NULL == address) {
- _REPORT_ERROR (module, line, component,
- ("Acpi_ut_free: Trying to delete a NULL address\n"));
-
- return_VOID;
+ else {
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
+ "%d(%X) Outstanding allocations\n",
+ num_outstanding, num_outstanding));
}
- debug_block = (acpi_debug_mem_block *)
- (((char *) address) - sizeof (acpi_debug_mem_header));
-
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].total_freed++;
- acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].current_total_size -= debug_block->size;
-
- acpi_ut_remove_allocation (ACPI_MEM_LIST_GLOBAL, debug_block,
- component, module, line);
- acpi_os_free (debug_block);
-
- ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", address));
-
return_VOID;
}
+
#endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)