void * AcpiUtAcquireFromCache ( UINT32 ListId) { ACPI_MEMORY_LIST *CacheInfo; void *Object; PROC_NAME ("UtAcquireFromCache"); CacheInfo = &AcpiGbl_MemoryLists[ListId]; AcpiUtAcquireMutex (ACPI_MTX_CACHES); ACPI_MEM_TRACKING (CacheInfo->CacheRequests++); /* Check the cache first */ if (CacheInfo->ListHead) { /* There is an object available, use it */ Object = CacheInfo->ListHead; CacheInfo->ListHead = * (char **) (((char *) Object) + CacheInfo->LinkOffset); ACPI_MEM_TRACKING (CacheInfo->CacheHits++); CacheInfo->CacheDepth--; #ifdef ACPI_DBG_TRACK_ALLOCATIONS ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n", Object, AcpiGbl_MemoryLists[ListId].ListName)); #endif AcpiUtReleaseMutex (ACPI_MTX_CACHES); /* Clear (zero) the previously used Object */ MEMSET (Object, 0, CacheInfo->ObjectSize); } else { /* The cache is empty, create a new object */ /* Avoid deadlock with ACPI_MEM_CALLOCATE */ AcpiUtReleaseMutex (ACPI_MTX_CACHES); Object = ACPI_MEM_CALLOCATE (CacheInfo->ObjectSize); ACPI_MEM_TRACKING (CacheInfo->TotalAllocated++); } return (Object); }
void acpi_ut_release_to_cache ( u32 list_id, void *object) { struct acpi_memory_list *cache_info; ACPI_FUNCTION_ENTRY (); cache_info = &acpi_gbl_memory_lists[list_id]; #ifdef ACPI_ENABLE_OBJECT_CACHE /* If walk cache is full, just free this wallkstate object */ if (cache_info->cache_depth >= cache_info->max_cache_depth) { ACPI_MEM_FREE (object); ACPI_MEM_TRACKING (cache_info->total_freed++); } /* Otherwise put this object back into the cache */ else { if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) { return; } /* Mark the object as cached */ 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 */ * (ACPI_CAST_INDIRECT_PTR (char, &(((char *) object)[cache_info->link_offset]))) = cache_info->list_head; cache_info->list_head = object; cache_info->cache_depth++; (void) acpi_ut_release_mutex (ACPI_MTX_CACHES); } #else /* Object cache is disabled; just free the object */ ACPI_MEM_FREE (object); ACPI_MEM_TRACKING (cache_info->total_freed++); #endif }
void * AcpiOsAcquireObject ( ACPI_MEMORY_LIST *Cache) { ACPI_STATUS Status; void *Object; ACPI_FUNCTION_NAME (OsAcquireObject); if (!Cache) { return (NULL); } Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return (NULL); } ACPI_MEM_TRACKING (Cache->Requests++); /* Check the cache first */ if (Cache->ListHead) { /* There is an object available, use it */ Object = Cache->ListHead; Cache->ListHead = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) Object)[Cache->LinkOffset]))); Cache->CurrentDepth--; ACPI_MEM_TRACKING (Cache->Hits++); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s cache\n", Object, Cache->ListName)); Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return (NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET (Object, 0, Cache->ObjectSize); }
void acpi_ns_delete_node(struct acpi_namespace_node *node) { union acpi_operand_object *obj_desc; ACPI_FUNCTION_NAME(ns_delete_node); /* Detach an object if there is one */ acpi_ns_detach_object(node); /* * Delete an attached data object if present (an object that was created * and attached via acpi_attach_data). Note: After any normal object is * detached above, the only possible remaining object is a data object. */ obj_desc = node->object; if (obj_desc && (obj_desc->common.type == ACPI_TYPE_LOCAL_DATA)) { /* Invoke the attached data deletion handler if present */ if (obj_desc->data.handler) { obj_desc->data.handler(node, obj_desc->data.pointer); } acpi_ut_remove_reference(obj_desc); } /* Now we can delete the node */ (void)acpi_os_release_object(acpi_gbl_namespace_cache, node); ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_freed++); ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n", node, acpi_gbl_current_node_count)); }
void AcpiNsDeleteNode ( ACPI_NAMESPACE_NODE *Node) { ACPI_NAMESPACE_NODE *ParentNode; ACPI_NAMESPACE_NODE *PrevNode; ACPI_NAMESPACE_NODE *NextNode; ACPI_FUNCTION_TRACE_PTR (NsDeleteNode, Node); ParentNode = AcpiNsGetParentNode (Node); PrevNode = NULL; NextNode = ParentNode->Child; /* Find the node that is the previous peer in the parent's child list */ while (NextNode != Node) { PrevNode = NextNode; NextNode = PrevNode->Peer; } if (PrevNode) { /* Node is not first child, unlink it */ PrevNode->Peer = NextNode->Peer; if (NextNode->Flags & ANOBJ_END_OF_PEER_LIST) { PrevNode->Flags |= ANOBJ_END_OF_PEER_LIST; } } else { /* Node is first child (has no previous peer) */ if (NextNode->Flags & ANOBJ_END_OF_PEER_LIST) { /* No peers at all */ ParentNode->Child = NULL; } else { /* Link peer list to parent */ ParentNode->Child = NextNode->Peer; } } ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalFreed++); /* Detach an object if there is one, then delete the node */ AcpiNsDetachObject (Node); (void) AcpiOsReleaseObject (AcpiGbl_NamespaceCache, Node); return_VOID; }
struct acpi_namespace_node *acpi_ns_create_node(u32 name) { struct acpi_namespace_node *node; #ifdef ACPI_DBG_TRACK_ALLOCATIONS u32 temp; #endif ACPI_FUNCTION_TRACE(ns_create_node); node = acpi_os_acquire_object(acpi_gbl_namespace_cache); if (!node) { return_PTR(NULL); } ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_allocated++); #ifdef ACPI_DBG_TRACK_ALLOCATIONS temp = acpi_gbl_ns_node_list->total_allocated - acpi_gbl_ns_node_list->total_freed; if (temp > acpi_gbl_ns_node_list->max_occupied) { acpi_gbl_ns_node_list->max_occupied = temp; } #endif node->name.integer = name; ACPI_SET_DESCRIPTOR_TYPE(node, ACPI_DESC_TYPE_NAMED); return_PTR(node); }
void acpi_ns_delete_node(struct acpi_namespace_node *node) { union acpi_operand_object *obj_desc; ACPI_FUNCTION_NAME(ns_delete_node); acpi_ns_detach_object(node); obj_desc = node->object; if (obj_desc && (obj_desc->common.type == ACPI_TYPE_LOCAL_DATA)) { if (obj_desc->data.handler) { obj_desc->data.handler(node, obj_desc->data.pointer); } acpi_ut_remove_reference(obj_desc); } (void)acpi_os_release_object(acpi_gbl_namespace_cache, node); ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_freed++); ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n", node, acpi_gbl_current_node_count)); }
ACPI_NAMESPACE_NODE * AcpiNsCreateNode ( UINT32 Name) { ACPI_NAMESPACE_NODE *Node; #ifdef ACPI_DBG_TRACK_ALLOCATIONS UINT32 Temp; #endif ACPI_FUNCTION_TRACE (NsCreateNode); Node = AcpiOsAcquireObject (AcpiGbl_NamespaceCache); if (!Node) { return_PTR (NULL); } ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalAllocated++); #ifdef ACPI_DBG_TRACK_ALLOCATIONS Temp = AcpiGbl_NsNodeList->TotalAllocated - AcpiGbl_NsNodeList->TotalFreed; if (Temp > AcpiGbl_NsNodeList->MaxOccupied) { AcpiGbl_NsNodeList->MaxOccupied = Temp; } #endif Node->Name.Integer = Name; ACPI_SET_DESCRIPTOR_TYPE (Node, ACPI_DESC_TYPE_NAMED); return_PTR (Node); }
void *acpi_os_acquire_object(struct acpi_memory_list *cache) { acpi_status status; void *object; ACPI_FUNCTION_NAME(os_acquire_object); if (!cache) { return (NULL); } status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return (NULL); } ACPI_MEM_TRACKING(cache->requests++); /* Check the cache first */ if (cache->list_head) { /* There is an object available, use it */ object = cache->list_head; cache->list_head = *(ACPI_CAST_INDIRECT_PTR(char, &(((char *) object)[cache-> link_offset]))); cache->current_depth--; ACPI_MEM_TRACKING(cache->hits++); ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Object %p from %s cache\n", object, cache->list_name)); status = acpi_ut_release_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return (NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET(object, 0, cache->object_size); } else {
void * acpi_ut_acquire_from_cache ( u32 list_id) { struct acpi_memory_list *cache_info; void *object; ACPI_FUNCTION_NAME ("ut_acquire_from_cache"); cache_info = &acpi_gbl_memory_lists[list_id]; #ifdef ACPI_ENABLE_OBJECT_CACHE if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_CACHES))) { return (NULL); } ACPI_MEM_TRACKING (cache_info->cache_requests++); /* Check the cache first */ if (cache_info->list_head) { /* There is an object available, use it */ object = cache_info->list_head; 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--; #ifdef ACPI_DBG_TRACK_ALLOCATIONS ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n", object, acpi_gbl_memory_lists[list_id].list_name)); #endif if (ACPI_FAILURE (acpi_ut_release_mutex (ACPI_MTX_CACHES))) { return (NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET (object, 0, cache_info->object_size); }
void * AcpiUtAcquireFromCache ( UINT32 ListId) { ACPI_MEMORY_LIST *CacheInfo; void *Object; ACPI_FUNCTION_NAME ("UtAcquireFromCache"); CacheInfo = &AcpiGbl_MemoryLists[ListId]; if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_CACHES))) { return (NULL); } ACPI_MEM_TRACKING (CacheInfo->CacheRequests++); /* Check the cache first */ if (CacheInfo->ListHead) { /* There is an object available, use it */ Object = CacheInfo->ListHead; CacheInfo->ListHead = *(ACPI_CAST_INDIRECT_PTR (char, &(((char *) Object)[CacheInfo->LinkOffset]))); ACPI_MEM_TRACKING (CacheInfo->CacheHits++); CacheInfo->CacheDepth--; #ifdef ACPI_DBG_TRACK_ALLOCATIONS ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s\n", Object, AcpiGbl_MemoryLists[ListId].ListName)); #endif if (ACPI_FAILURE (AcpiUtReleaseMutex (ACPI_MTX_CACHES))) { return (NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET (Object, 0, CacheInfo->ObjectSize); }
void acpi_ns_delete_node ( struct acpi_namespace_node *node) { struct acpi_namespace_node *parent_node; struct acpi_namespace_node *prev_node; struct acpi_namespace_node *next_node; ACPI_FUNCTION_TRACE_PTR ("ns_delete_node", node); parent_node = acpi_ns_get_parent_node (node); prev_node = NULL; next_node = parent_node->child; /* Find the node that is the previous peer in the parent's child list */ while (next_node != node) { prev_node = next_node; next_node = prev_node->peer; } if (prev_node) { /* Node is not first child, unlink it */ prev_node->peer = next_node->peer; if (next_node->flags & ANOBJ_END_OF_PEER_LIST) { prev_node->flags |= ANOBJ_END_OF_PEER_LIST; } } else { /* Node is first child (has no previous peer) */ if (next_node->flags & ANOBJ_END_OF_PEER_LIST) { /* No peers at all */ parent_node->child = NULL; } else { /* Link peer list to parent */ parent_node->child = next_node->peer; } } ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].total_freed++); /* * Detach an object if there is one then delete the node */ acpi_ns_detach_object (node); ACPI_MEM_FREE (node); return_VOID; }
void AcpiNsDeleteNode ( ACPI_NAMESPACE_NODE *Node) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *NextDesc; ACPI_FUNCTION_NAME (NsDeleteNode); /* Detach an object if there is one */ AcpiNsDetachObject (Node); /* * Delete an attached data object list if present (objects that were * attached via AcpiAttachData). Note: After any normal object is * detached above, the only possible remaining object(s) are data * objects, in a linked list. */ ObjDesc = Node->Object; while (ObjDesc && (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA)) { /* Invoke the attached data deletion handler if present */ if (ObjDesc->Data.Handler) { ObjDesc->Data.Handler (Node, ObjDesc->Data.Pointer); } NextDesc = ObjDesc->Common.NextObject; AcpiUtRemoveReference (ObjDesc); ObjDesc = NextDesc; } /* Special case for the statically allocated root node */ if (Node == AcpiGbl_RootNode) { return; } /* Now we can delete the node */ (void) AcpiOsReleaseObject (AcpiGbl_NamespaceCache, Node); ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalFreed++); ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n", Node, AcpiGbl_CurrentNodeCount)); }
ACPI_STATUS AcpiOsReleaseObject ( ACPI_MEMORY_LIST *Cache, void *Object) { ACPI_STATUS Status; ACPI_FUNCTION_ENTRY (); if (!Cache || !Object) { return (AE_BAD_PARAMETER); } /* If cache is full, just free this object */ if (Cache->CurrentDepth >= Cache->MaxDepth) { ACPI_FREE (Object); ACPI_MEM_TRACKING (Cache->TotalFreed++); } /* Otherwise put this object back into the cache */ else { Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return (Status); } /* Mark the object as cached */ ACPI_MEMSET (Object, 0xCA, Cache->ObjectSize); ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_CACHED); /* Put the object at the head of the cache list */ * (ACPI_CAST_INDIRECT_PTR (char, &(((char *) Object)[Cache->LinkOffset]))) = Cache->ListHead; Cache->ListHead = Object; Cache->CurrentDepth++; (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES); } return (AE_OK); }
void acpi_ns_delete_node(struct acpi_namespace_node *node) { union acpi_operand_object *obj_desc; union acpi_operand_object *next_desc; ACPI_FUNCTION_NAME(ns_delete_node); if (!node) { return_VOID; } /* Detach an object if there is one */ acpi_ns_detach_object(node); /* * Delete an attached data object list if present (objects that were * attached via acpi_attach_data). Note: After any normal object is * detached above, the only possible remaining object(s) are data * objects, in a linked list. */ obj_desc = node->object; while (obj_desc && (obj_desc->common.type == ACPI_TYPE_LOCAL_DATA)) { /* Invoke the attached data deletion handler if present */ if (obj_desc->data.handler) { obj_desc->data.handler(node, obj_desc->data.pointer); } next_desc = obj_desc->common.next_object; acpi_ut_remove_reference(obj_desc); obj_desc = next_desc; } /* Special case for the statically allocated root node */ if (node == acpi_gbl_root_node) { return; } /* Now we can delete the node */ (void)acpi_os_release_object(acpi_gbl_namespace_cache, node); ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_freed++); ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n", node, acpi_gbl_current_node_count)); }
/**ltl * 功能: 创建命名空间对象 * 参数: * 返回值: * 说明: 为命名空间名字赋值,同时设定标志ACPI_DESC_TYPE_NAMED */ struct acpi_namespace_node *acpi_ns_create_node(u32 name) { struct acpi_namespace_node *node; ACPI_FUNCTION_TRACE(ns_create_node); node = acpi_os_acquire_object(acpi_gbl_namespace_cache); if (!node) { return_PTR(NULL); } ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_allocated++); node->name.integer = name; ACPI_SET_DESCRIPTOR_TYPE(node, ACPI_DESC_TYPE_NAMED); return_PTR(node); }
acpi_status acpi_os_release_object(struct acpi_memory_list * cache, void *object) { acpi_status status; ACPI_FUNCTION_ENTRY(); if (!cache || !object) { return (AE_BAD_PARAMETER); } /* If cache is full, just free this object */ if (cache->current_depth >= cache->max_depth) { ACPI_FREE(object); ACPI_MEM_TRACKING(cache->total_freed++); } /* Otherwise put this object back into the cache */ else { status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return (status); } /* Mark the object as cached */ ACPI_MEMSET(object, 0xCA, cache->object_size); ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_CACHED); /* Put the object at the head of the cache list */ *(ACPI_CAST_INDIRECT_PTR(char, &(((char *)object)[cache-> link_offset]))) = cache->list_head; cache->list_head = object; cache->current_depth++; (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); } return (AE_OK); }
void AcpiUtReleaseToCache ( UINT32 ListId, void *Object) { ACPI_MEMORY_LIST *CacheInfo; ACPI_FUNCTION_ENTRY (); /* If walk cache is full, just free this wallkstate object */ CacheInfo = &AcpiGbl_MemoryLists[ListId]; if (CacheInfo->CacheDepth >= CacheInfo->MaxCacheDepth) { ACPI_MEM_FREE (Object); ACPI_MEM_TRACKING (CacheInfo->TotalFreed++); } /* Otherwise put this object back into the cache */ else { if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_CACHES))) { return; } /* Mark the object as cached */ ACPI_MEMSET (Object, 0xCA, CacheInfo->ObjectSize); ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_CACHED); /* Put the object at the head of the cache list */ * (ACPI_CAST_INDIRECT_PTR (char, &(((char *) Object)[CacheInfo->LinkOffset]))) = CacheInfo->ListHead; CacheInfo->ListHead = Object; CacheInfo->CacheDepth++; (void) AcpiUtReleaseMutex (ACPI_MTX_CACHES); } }
void AcpiNsDeleteNode ( ACPI_NAMESPACE_NODE *Node) { ACPI_OPERAND_OBJECT *ObjDesc; ACPI_FUNCTION_NAME (NsDeleteNode); /* Detach an object if there is one */ AcpiNsDetachObject (Node); /* * Delete an attached data object if present (an object that was created * and attached via AcpiAttachData). Note: After any normal object is * detached above, the only possible remaining object is a data object. */ ObjDesc = Node->Object; if (ObjDesc && (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA)) { /* Invoke the attached data deletion handler if present */ if (ObjDesc->Data.Handler) { ObjDesc->Data.Handler (Node, ObjDesc->Data.Pointer); } AcpiUtRemoveReference (ObjDesc); } /* Now we can delete the node */ (void) AcpiOsReleaseObject (AcpiGbl_NamespaceCache, Node); ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalFreed++); ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n", Node, AcpiGbl_CurrentNodeCount)); }
ACPI_NAMESPACE_NODE * AcpiNsCreateNode ( UINT32 Name) { ACPI_NAMESPACE_NODE *Node; ACPI_FUNCTION_TRACE (NsCreateNode); Node = AcpiOsAcquireObject (AcpiGbl_NamespaceCache); if (!Node) { return_PTR (NULL); } ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalAllocated++); Node->Name.Integer = Name; ACPI_SET_DESCRIPTOR_TYPE (Node, ACPI_DESC_TYPE_NAMED); return_PTR (Node); }
void AcpiUtReleaseToCache ( UINT32 ListId, void *Object) { ACPI_MEMORY_LIST *CacheInfo; FUNCTION_ENTRY (); /* If walk cache is full, just free this wallkstate object */ CacheInfo = &AcpiGbl_MemoryLists[ListId]; if (CacheInfo->CacheDepth >= CacheInfo->MaxCacheDepth) { ACPI_MEM_FREE (Object); ACPI_MEM_TRACKING (CacheInfo->TotalFreed++); } /* Otherwise put this object back into the cache */ else { AcpiUtAcquireMutex (ACPI_MTX_CACHES); /* Mark the object as cached */ MEMSET (Object, 0xCA, CacheInfo->ObjectSize); /* Put the object at the head of the cache list */ * (char **) (((char *) Object) + CacheInfo->LinkOffset) = CacheInfo->ListHead; CacheInfo->ListHead = Object; CacheInfo->CacheDepth++; AcpiUtReleaseMutex (ACPI_MTX_CACHES); } }
struct acpi_namespace_node * acpi_ns_create_node ( u32 name) { struct acpi_namespace_node *node; ACPI_FUNCTION_TRACE ("ns_create_node"); node = ACPI_MEM_CALLOCATE (sizeof (struct acpi_namespace_node)); if (!node) { return_PTR (NULL); } ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].total_allocated++); node->name.integer = name; node->reference_count = 1; ACPI_SET_DESCRIPTOR_TYPE (node, ACPI_DESC_TYPE_NAMED); return_PTR (node); }
void AcpiNsDeleteChildren ( ACPI_NAMESPACE_NODE *ParentNode) { ACPI_NAMESPACE_NODE *ChildNode; ACPI_NAMESPACE_NODE *NextNode; UINT8 Flags; ACPI_FUNCTION_TRACE_PTR (NsDeleteChildren, ParentNode); if (!ParentNode) { return_VOID; } /* If no children, all done! */ ChildNode = ParentNode->Child; if (!ChildNode) { return_VOID; } /* * Deallocate all children at this level */ do { /* Get the things we need */ NextNode = ChildNode->Peer; Flags = ChildNode->Flags; /* Grandchildren should have all been deleted already */ if (ChildNode->Child) { ACPI_ERROR ((AE_INFO, "Found a grandchild! P=%p C=%p", ParentNode, ChildNode)); } /* Now we can free this child object */ ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalFreed++); ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Object %p, Remaining %X\n", ChildNode, AcpiGbl_CurrentNodeCount)); /* * Detach an object if there is one, then free the child node */ AcpiNsDetachObject (ChildNode); /* Now we can delete the node */ (void) AcpiOsReleaseObject (AcpiGbl_NamespaceCache, ChildNode); /* And move on to the next child in the list */ ChildNode = NextNode; } while (!(Flags & ANOBJ_END_OF_PEER_LIST)); /* Clear the parent's child pointer */ ParentNode->Child = NULL; return_VOID; }
void *acpi_os_acquire_object(struct acpi_memory_list *cache) { acpi_status status; void *object; ACPI_FUNCTION_NAME(os_acquire_object); if (!cache) { return_PTR(NULL); } status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return_PTR(NULL); } ACPI_MEM_TRACKING(cache->requests++); /* Check the cache first */ if (cache->list_head) { /* There is an object available, use it */ object = cache->list_head; cache->list_head = ACPI_GET_DESCRIPTOR_PTR(object); cache->current_depth--; ACPI_MEM_TRACKING(cache->hits++); ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Object %p from %s cache\n", object, cache->list_name)); status = acpi_ut_release_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return_PTR(NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET(object, 0, cache->object_size); } else { /* The cache is empty, create a new object */ ACPI_MEM_TRACKING(cache->total_allocated++); #ifdef ACPI_DBG_TRACK_ALLOCATIONS if ((cache->total_allocated - cache->total_freed) > cache->max_occupied) { cache->max_occupied = cache->total_allocated - cache->total_freed; } #endif /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */ status = acpi_ut_release_mutex(ACPI_MTX_CACHES); if (ACPI_FAILURE(status)) { return_PTR(NULL); } object = ACPI_ALLOCATE_ZEROED(cache->object_size); if (!object) { return_PTR(NULL); } } return_PTR(object); }
void acpi_ns_delete_children ( struct acpi_namespace_node *parent_node) { struct acpi_namespace_node *child_node; struct acpi_namespace_node *next_node; struct acpi_namespace_node *node; u8 flags; ACPI_FUNCTION_TRACE_PTR ("ns_delete_children", parent_node); if (!parent_node) { return_VOID; } /* If no children, all done! */ child_node = parent_node->child; if (!child_node) { return_VOID; } /* * Deallocate all children at this level */ do { /* Get the things we need */ next_node = child_node->peer; flags = child_node->flags; /* Grandchildren should have all been deleted already */ if (child_node->child) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Found a grandchild! P=%p C=%p\n", parent_node, child_node)); } /* Now we can free this child object */ ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].total_freed++); ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Object %p, Remaining %X\n", child_node, acpi_gbl_current_node_count)); /* * Detach an object if there is one, then free the child node */ acpi_ns_detach_object (child_node); /* * Decrement the reference count(s) of all parents up to * the root! (counts were incremented when the node was created) */ node = child_node; while ((node = acpi_ns_get_parent_node (node)) != NULL) { node->reference_count--; } /* There should be only one reference remaining on this node */ if (child_node->reference_count != 1) { ACPI_REPORT_WARNING (("Existing references (%d) on node being deleted (%p)\n", child_node->reference_count, child_node)); } /* Now we can delete the node */ ACPI_MEM_FREE (child_node); /* And move on to the next child in the list */ child_node = next_node; } while (!(flags & ANOBJ_END_OF_PEER_LIST)); /* Clear the parent's child pointer */ parent_node->child = NULL; return_VOID; }
void AcpiUtInitGlobals ( void) { UINT32 i; ACPI_FUNCTION_TRACE ("UtInitGlobals"); /* Memory allocation and cache lists */ ACPI_MEMSET (AcpiGbl_MemoryLists, 0, sizeof (ACPI_MEMORY_LIST) * ACPI_NUM_MEM_LISTS); AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].LinkOffset = (UINT16) ACPI_PTR_DIFF (&(((ACPI_GENERIC_STATE *) NULL)->Common.Next), NULL); AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].LinkOffset = (UINT16) ACPI_PTR_DIFF (&(((ACPI_PARSE_OBJECT *) NULL)->Common.Next), NULL); AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].LinkOffset = (UINT16) ACPI_PTR_DIFF (&(((ACPI_PARSE_OBJECT *) NULL)->Common.Next), NULL); AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].LinkOffset = (UINT16) ACPI_PTR_DIFF (&(((ACPI_OPERAND_OBJECT *) NULL)->Cache.Next), NULL); AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].LinkOffset = (UINT16) ACPI_PTR_DIFF (&(((ACPI_WALK_STATE *) NULL)->Next), NULL); AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].ObjectSize = sizeof (ACPI_NAMESPACE_NODE); AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].ObjectSize = sizeof (ACPI_GENERIC_STATE); AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].ObjectSize = sizeof (ACPI_PARSE_OBJ_COMMON); AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].ObjectSize = sizeof (ACPI_PARSE_OBJ_NAMED); AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].ObjectSize = sizeof (ACPI_OPERAND_OBJECT); AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].ObjectSize = sizeof (ACPI_WALK_STATE); AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].MaxCacheDepth = ACPI_MAX_STATE_CACHE_DEPTH; AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].MaxCacheDepth = ACPI_MAX_PARSE_CACHE_DEPTH; AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].MaxCacheDepth = ACPI_MAX_EXTPARSE_CACHE_DEPTH; AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].MaxCacheDepth = ACPI_MAX_OBJECT_CACHE_DEPTH; AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].MaxCacheDepth = ACPI_MAX_WALK_CACHE_DEPTH; ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].ListName = "Global Memory Allocation"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_NSNODE].ListName = "Namespace Nodes"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_STATE].ListName = "State Object Cache"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE].ListName = "Parse Node Cache"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_PSNODE_EXT].ListName = "Extended Parse Node Cache"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_OPERAND].ListName = "Operand Object Cache"); ACPI_MEM_TRACKING (AcpiGbl_MemoryLists[ACPI_MEM_LIST_WALK].ListName = "Tree Walk Node Cache"); /* ACPI table structure */ for (i = 0; i < NUM_ACPI_TABLES; i++) { AcpiGbl_AcpiTables[i].Prev = &AcpiGbl_AcpiTables[i]; AcpiGbl_AcpiTables[i].Next = &AcpiGbl_AcpiTables[i]; AcpiGbl_AcpiTables[i].Pointer = NULL; AcpiGbl_AcpiTables[i].Length = 0; AcpiGbl_AcpiTables[i].Allocation = ACPI_MEM_NOT_ALLOCATED; AcpiGbl_AcpiTables[i].Count = 0; } /* Mutex locked flags */ for (i = 0; i < NUM_MTX; i++) { AcpiGbl_AcpiMutexInfo[i].Mutex = NULL; AcpiGbl_AcpiMutexInfo[i].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; AcpiGbl_AcpiMutexInfo[i].UseCount = 0; } /* GPE support */ AcpiGbl_GpeBlockListHead = NULL; /* Global notify handlers */ AcpiGbl_SysNotify.Handler = NULL; AcpiGbl_DrvNotify.Handler = NULL; AcpiGbl_InitHandler = NULL; /* Global "typed" ACPI table pointers */ AcpiGbl_RSDP = NULL; AcpiGbl_XSDT = NULL; AcpiGbl_FACS = NULL; AcpiGbl_FADT = NULL; AcpiGbl_DSDT = NULL; /* Global Lock support */ AcpiGbl_GlobalLockAcquired = FALSE; AcpiGbl_GlobalLockThreadCount = 0; AcpiGbl_GlobalLockHandle = 0; /* Miscellaneous variables */ AcpiGbl_TableFlags = ACPI_PHYSICAL_POINTER; AcpiGbl_RsdpOriginalLocation = 0; AcpiGbl_CmSingleStep = FALSE; AcpiGbl_DbTerminateThreads = FALSE; AcpiGbl_Shutdown = FALSE; AcpiGbl_NsLookupCount = 0; AcpiGbl_PsFindCount = 0; AcpiGbl_AcpiHardwarePresent = TRUE; AcpiGbl_NextTableOwnerId = ACPI_FIRST_TABLE_ID; AcpiGbl_NextMethodOwnerId = ACPI_FIRST_METHOD_ID; AcpiGbl_DebuggerConfiguration = DEBUGGER_THREADING; AcpiGbl_DbOutputFlags = ACPI_DB_CONSOLE_OUTPUT; /* Hardware oriented */ AcpiGbl_EventsInitialized = FALSE; /* Namespace */ AcpiGbl_RootNode = NULL; AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME; AcpiGbl_RootNodeStruct.Descriptor = ACPI_DESC_TYPE_NAMED; AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_DEVICE; AcpiGbl_RootNodeStruct.Child = NULL; AcpiGbl_RootNodeStruct.Peer = NULL; AcpiGbl_RootNodeStruct.Object = NULL; AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST; #ifdef ACPI_DEBUG_OUTPUT AcpiGbl_LowestStackPointer = ACPI_SIZE_MAX; #endif return_VOID; }
void acpi_ut_init_globals ( void) { u32 i; FUNCTION_TRACE ("Ut_init_globals"); /* Memory allocation and cache lists */ MEMSET (acpi_gbl_memory_lists, 0, sizeof (ACPI_MEMORY_LIST) * ACPI_NUM_MEM_LISTS); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].link_offset = (u16) (NATIVE_UINT) &(((acpi_generic_state *) NULL)->common.next); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].link_offset = (u16) (NATIVE_UINT) &(((acpi_parse_object *) NULL)->next); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].link_offset = (u16) (NATIVE_UINT) &(((acpi_parse2_object *) NULL)->next); acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].link_offset = (u16) (NATIVE_UINT) &(((acpi_operand_object *) NULL)->cache.next); acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].link_offset = (u16) (NATIVE_UINT) &(((acpi_walk_state *) NULL)->next); acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].object_size = sizeof (acpi_namespace_node); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].object_size = sizeof (acpi_generic_state); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].object_size = sizeof (acpi_parse_object); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].object_size = sizeof (acpi_parse2_object); acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].object_size = sizeof (acpi_operand_object); acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].object_size = sizeof (acpi_walk_state); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].max_cache_depth = MAX_STATE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].max_cache_depth = MAX_PARSE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].max_cache_depth = MAX_EXTPARSE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].max_cache_depth = MAX_OBJECT_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].max_cache_depth = MAX_WALK_CACHE_DEPTH; ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].list_name = "Global Memory Allocation"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].list_name = "Namespace Nodes"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].list_name = "State Object Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].list_name = "Parse Node Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].list_name = "Extended Parse Node Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].list_name = "Operand Object Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].list_name = "Tree Walk Node Cache"); /* ACPI table structure */ for (i = 0; i < NUM_ACPI_TABLES; i++) { acpi_gbl_acpi_tables[i].prev = &acpi_gbl_acpi_tables[i]; acpi_gbl_acpi_tables[i].next = &acpi_gbl_acpi_tables[i]; acpi_gbl_acpi_tables[i].pointer = NULL; acpi_gbl_acpi_tables[i].length = 0; acpi_gbl_acpi_tables[i].allocation = ACPI_MEM_NOT_ALLOCATED; acpi_gbl_acpi_tables[i].count = 0; } /* Address Space handler array */ for (i = 0; i < ACPI_NUM_ADDRESS_SPACES; i++) { acpi_gbl_address_spaces[i].handler = NULL; acpi_gbl_address_spaces[i].context = NULL; } /* Mutex locked flags */ for (i = 0; i < NUM_MTX; i++) { acpi_gbl_acpi_mutex_info[i].mutex = NULL; acpi_gbl_acpi_mutex_info[i].owner_id = ACPI_MUTEX_NOT_ACQUIRED; acpi_gbl_acpi_mutex_info[i].use_count = 0; } /* Global notify handlers */ acpi_gbl_sys_notify.handler = NULL; acpi_gbl_drv_notify.handler = NULL; /* Global "typed" ACPI table pointers */ acpi_gbl_RSDP = NULL; acpi_gbl_XSDT = NULL; acpi_gbl_FACS = NULL; acpi_gbl_FADT = NULL; acpi_gbl_DSDT = NULL; /* Global Lock support */ acpi_gbl_global_lock_acquired = FALSE; acpi_gbl_global_lock_thread_count = 0; /* Miscellaneous variables */ acpi_gbl_system_flags = 0; acpi_gbl_startup_flags = 0; acpi_gbl_rsdp_original_location = 0; acpi_gbl_cm_single_step = FALSE; acpi_gbl_db_terminate_threads = FALSE; acpi_gbl_shutdown = FALSE; acpi_gbl_ns_lookup_count = 0; acpi_gbl_ps_find_count = 0; acpi_gbl_acpi_hardware_present = TRUE; acpi_gbl_next_table_owner_id = FIRST_TABLE_ID; acpi_gbl_next_method_owner_id = FIRST_METHOD_ID; acpi_gbl_debugger_configuration = DEBUGGER_THREADING; /* Hardware oriented */ acpi_gbl_gpe0enable_register_save = NULL; acpi_gbl_gpe1_enable_register_save = NULL; acpi_gbl_original_mode = SYS_MODE_UNKNOWN; /* original ACPI/legacy mode */ acpi_gbl_gpe_registers = NULL; acpi_gbl_gpe_info = NULL; /* Namespace */ acpi_gbl_root_node = NULL; acpi_gbl_root_node_struct.name = ACPI_ROOT_NAME; acpi_gbl_root_node_struct.data_type = ACPI_DESC_TYPE_NAMED; acpi_gbl_root_node_struct.type = ACPI_TYPE_ANY; acpi_gbl_root_node_struct.child = NULL; acpi_gbl_root_node_struct.peer = NULL; acpi_gbl_root_node_struct.object = NULL; acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST; #ifdef ACPI_DEBUG acpi_gbl_lowest_stack_pointer = ACPI_UINT32_MAX; #endif return_VOID; }
void * AcpiOsAcquireObject ( ACPI_MEMORY_LIST *Cache) { ACPI_STATUS Status; void *Object; ACPI_FUNCTION_NAME (OsAcquireObject); if (!Cache) { return_PTR (NULL); } Status = AcpiUtAcquireMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return_PTR (NULL); } ACPI_MEM_TRACKING (Cache->Requests++); /* Check the cache first */ if (Cache->ListHead) { /* There is an object available, use it */ Object = Cache->ListHead; Cache->ListHead = ACPI_GET_DESCRIPTOR_PTR (Object); Cache->CurrentDepth--; ACPI_MEM_TRACKING (Cache->Hits++); ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p from %s cache\n", Object, Cache->ListName)); Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return_PTR (NULL); } /* Clear (zero) the previously used Object */ ACPI_MEMSET (Object, 0, Cache->ObjectSize); } else { /* The cache is empty, create a new object */ ACPI_MEM_TRACKING (Cache->TotalAllocated++); #ifdef ACPI_DBG_TRACK_ALLOCATIONS if ((Cache->TotalAllocated - Cache->TotalFreed) > Cache->MaxOccupied) { Cache->MaxOccupied = Cache->TotalAllocated - Cache->TotalFreed; } #endif /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */ Status = AcpiUtReleaseMutex (ACPI_MTX_CACHES); if (ACPI_FAILURE (Status)) { return_PTR (NULL); } Object = ACPI_ALLOCATE_ZEROED (Cache->ObjectSize); if (!Object) { return_PTR (NULL); } } return_PTR (Object); }
void acpi_ut_init_globals ( void) { u32 i; ACPI_FUNCTION_TRACE ("ut_init_globals"); /* Memory allocation and cache lists */ ACPI_MEMSET (acpi_gbl_memory_lists, 0, sizeof (struct acpi_memory_list) * ACPI_NUM_MEM_LISTS); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].link_offset = (u16) ACPI_PTR_DIFF (&(((union acpi_generic_state *) NULL)->common.next), NULL); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].link_offset = (u16) ACPI_PTR_DIFF (&(((union acpi_parse_object *) NULL)->common.next), NULL); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].link_offset = (u16) ACPI_PTR_DIFF (&(((union acpi_parse_object *) NULL)->common.next), NULL); acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].link_offset = (u16) ACPI_PTR_DIFF (&(((union acpi_operand_object *) NULL)->cache.next), NULL); acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].link_offset = (u16) ACPI_PTR_DIFF (&(((struct acpi_walk_state *) NULL)->next), NULL); acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].object_size = sizeof (struct acpi_namespace_node); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].object_size = sizeof (union acpi_generic_state); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].object_size = sizeof (struct acpi_parse_obj_common); acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].object_size = sizeof (struct acpi_parse_obj_named); acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].object_size = sizeof (union acpi_operand_object); acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].object_size = sizeof (struct acpi_walk_state); acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].max_cache_depth = ACPI_MAX_STATE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].max_cache_depth = ACPI_MAX_PARSE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].max_cache_depth = ACPI_MAX_EXTPARSE_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].max_cache_depth = ACPI_MAX_OBJECT_CACHE_DEPTH; acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].max_cache_depth = ACPI_MAX_WALK_CACHE_DEPTH; ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_GLOBAL].list_name = "Global Memory Allocation"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_NSNODE].list_name = "Namespace Nodes"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_STATE].list_name = "State Object Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE].list_name = "Parse Node Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_PSNODE_EXT].list_name = "Extended Parse Node Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_OPERAND].list_name = "Operand Object Cache"); ACPI_MEM_TRACKING (acpi_gbl_memory_lists[ACPI_MEM_LIST_WALK].list_name = "Tree Walk Node Cache"); /* ACPI table structure */ for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) { acpi_gbl_table_lists[i].next = NULL; acpi_gbl_table_lists[i].count = 0; } /* Mutex locked flags */ for (i = 0; i < NUM_MUTEX; i++) { acpi_gbl_mutex_info[i].mutex = NULL; acpi_gbl_mutex_info[i].owner_id = ACPI_MUTEX_NOT_ACQUIRED; acpi_gbl_mutex_info[i].use_count = 0; } /* GPE support */ acpi_gbl_gpe_xrupt_list_head = NULL; acpi_gbl_gpe_fadt_blocks[0] = NULL; acpi_gbl_gpe_fadt_blocks[1] = NULL; /* Global notify handlers */ acpi_gbl_system_notify.handler = NULL; acpi_gbl_device_notify.handler = NULL; acpi_gbl_exception_handler = NULL; acpi_gbl_init_handler = NULL; /* Global "typed" ACPI table pointers */ acpi_gbl_RSDP = NULL; acpi_gbl_XSDT = NULL; acpi_gbl_FACS = NULL; acpi_gbl_FADT = NULL; acpi_gbl_DSDT = NULL; /* Global Lock support */ acpi_gbl_global_lock_acquired = FALSE; acpi_gbl_global_lock_thread_count = 0; acpi_gbl_global_lock_handle = 0; /* Miscellaneous variables */ acpi_gbl_table_flags = ACPI_PHYSICAL_POINTER; acpi_gbl_rsdp_original_location = 0; acpi_gbl_cm_single_step = FALSE; acpi_gbl_db_terminate_threads = FALSE; acpi_gbl_shutdown = FALSE; acpi_gbl_ns_lookup_count = 0; acpi_gbl_ps_find_count = 0; acpi_gbl_acpi_hardware_present = TRUE; acpi_gbl_next_table_owner_id = ACPI_FIRST_TABLE_ID; acpi_gbl_next_method_owner_id = ACPI_FIRST_METHOD_ID; acpi_gbl_debugger_configuration = DEBUGGER_THREADING; acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT; /* Hardware oriented */ acpi_gbl_events_initialized = FALSE; acpi_gbl_system_awake_and_running = TRUE; /* Namespace */ acpi_gbl_root_node = NULL; acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME; acpi_gbl_root_node_struct.descriptor = ACPI_DESC_TYPE_NAMED; acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE; acpi_gbl_root_node_struct.child = NULL; acpi_gbl_root_node_struct.peer = NULL; acpi_gbl_root_node_struct.object = NULL; acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST; #ifdef ACPI_DEBUG_OUTPUT acpi_gbl_lowest_stack_pointer = ACPI_SIZE_MAX; #endif return_VOID; }
void acpi_ns_delete_children(struct acpi_namespace_node *parent_node) { struct acpi_namespace_node *child_node; struct acpi_namespace_node *next_node; u8 flags; ACPI_FUNCTION_TRACE_PTR(ns_delete_children, parent_node); if (!parent_node) { return_VOID; } /* If no children, all done! */ child_node = parent_node->child; if (!child_node) { return_VOID; } /* * Deallocate all children at this level */ do { /* Get the things we need */ next_node = child_node->peer; flags = child_node->flags; /* Grandchildren should have all been deleted already */ if (child_node->child) { ACPI_ERROR((AE_INFO, "Found a grandchild! P=%p C=%p", parent_node, child_node)); } /* Now we can free this child object */ ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_freed++); ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Object %p, Remaining %X\n", child_node, acpi_gbl_current_node_count)); /* * Detach an object if there is one, then free the child node */ acpi_ns_detach_object(child_node); /* Now we can delete the node */ (void)acpi_os_release_object(acpi_gbl_namespace_cache, child_node); /* And move on to the next child in the list */ child_node = next_node; } while (!(flags & ANOBJ_END_OF_PEER_LIST)); /* Clear the parent's child pointer */ parent_node->child = NULL; return_VOID; }