xref: /linux/drivers/acpi/acpica/utdelete.c (revision 3932b9ca55b0be314a36d3e84faff3e823c081f5)
1 /*******************************************************************************
2  *
3  * Module Name: utdelete - object deletion and reference count utilities
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2014, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acinterp.h"
47 #include "acnamesp.h"
48 #include "acevents.h"
49 
50 #define _COMPONENT          ACPI_UTILITIES
51 ACPI_MODULE_NAME("utdelete")
52 
53 /* Local prototypes */
54 static void acpi_ut_delete_internal_obj(union acpi_operand_object *object);
55 
56 static void
57 acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action);
58 
59 /*******************************************************************************
60  *
61  * FUNCTION:    acpi_ut_delete_internal_obj
62  *
63  * PARAMETERS:  object         - Object to be deleted
64  *
65  * RETURN:      None
66  *
67  * DESCRIPTION: Low level object deletion, after reference counts have been
68  *              updated (All reference counts, including sub-objects!)
69  *
70  ******************************************************************************/
71 
72 static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
73 {
74 	void *obj_pointer = NULL;
75 	union acpi_operand_object *handler_desc;
76 	union acpi_operand_object *second_desc;
77 	union acpi_operand_object *next_desc;
78 	union acpi_operand_object *start_desc;
79 	union acpi_operand_object **last_obj_ptr;
80 
81 	ACPI_FUNCTION_TRACE_PTR(ut_delete_internal_obj, object);
82 
83 	if (!object) {
84 		return_VOID;
85 	}
86 
87 	/*
88 	 * Must delete or free any pointers within the object that are not
89 	 * actual ACPI objects (for example, a raw buffer pointer).
90 	 */
91 	switch (object->common.type) {
92 	case ACPI_TYPE_STRING:
93 
94 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
95 				  "**** String %p, ptr %p\n", object,
96 				  object->string.pointer));
97 
98 		/* Free the actual string buffer */
99 
100 		if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) {
101 
102 			/* But only if it is NOT a pointer into an ACPI table */
103 
104 			obj_pointer = object->string.pointer;
105 		}
106 		break;
107 
108 	case ACPI_TYPE_BUFFER:
109 
110 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
111 				  "**** Buffer %p, ptr %p\n", object,
112 				  object->buffer.pointer));
113 
114 		/* Free the actual buffer */
115 
116 		if (!(object->common.flags & AOPOBJ_STATIC_POINTER)) {
117 
118 			/* But only if it is NOT a pointer into an ACPI table */
119 
120 			obj_pointer = object->buffer.pointer;
121 		}
122 		break;
123 
124 	case ACPI_TYPE_PACKAGE:
125 
126 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
127 				  " **** Package of count %X\n",
128 				  object->package.count));
129 
130 		/*
131 		 * Elements of the package are not handled here, they are deleted
132 		 * separately
133 		 */
134 
135 		/* Free the (variable length) element pointer array */
136 
137 		obj_pointer = object->package.elements;
138 		break;
139 
140 		/*
141 		 * These objects have a possible list of notify handlers.
142 		 * Device object also may have a GPE block.
143 		 */
144 	case ACPI_TYPE_DEVICE:
145 
146 		if (object->device.gpe_block) {
147 			(void)acpi_ev_delete_gpe_block(object->device.
148 						       gpe_block);
149 		}
150 
151 		/*lint -fallthrough */
152 
153 	case ACPI_TYPE_PROCESSOR:
154 	case ACPI_TYPE_THERMAL:
155 
156 		/* Walk the address handler list for this object */
157 
158 		handler_desc = object->common_notify.handler;
159 		while (handler_desc) {
160 			next_desc = handler_desc->address_space.next;
161 			acpi_ut_remove_reference(handler_desc);
162 			handler_desc = next_desc;
163 		}
164 		break;
165 
166 	case ACPI_TYPE_MUTEX:
167 
168 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
169 				  "***** Mutex %p, OS Mutex %p\n",
170 				  object, object->mutex.os_mutex));
171 
172 		if (object == acpi_gbl_global_lock_mutex) {
173 
174 			/* Global Lock has extra semaphore */
175 
176 			(void)
177 			    acpi_os_delete_semaphore
178 			    (acpi_gbl_global_lock_semaphore);
179 			acpi_gbl_global_lock_semaphore = NULL;
180 
181 			acpi_os_delete_mutex(object->mutex.os_mutex);
182 			acpi_gbl_global_lock_mutex = NULL;
183 		} else {
184 			acpi_ex_unlink_mutex(object);
185 			acpi_os_delete_mutex(object->mutex.os_mutex);
186 		}
187 		break;
188 
189 	case ACPI_TYPE_EVENT:
190 
191 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
192 				  "***** Event %p, OS Semaphore %p\n",
193 				  object, object->event.os_semaphore));
194 
195 		(void)acpi_os_delete_semaphore(object->event.os_semaphore);
196 		object->event.os_semaphore = NULL;
197 		break;
198 
199 	case ACPI_TYPE_METHOD:
200 
201 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
202 				  "***** Method %p\n", object));
203 
204 		/* Delete the method mutex if it exists */
205 
206 		if (object->method.mutex) {
207 			acpi_os_delete_mutex(object->method.mutex->mutex.
208 					     os_mutex);
209 			acpi_ut_delete_object_desc(object->method.mutex);
210 			object->method.mutex = NULL;
211 		}
212 		break;
213 
214 	case ACPI_TYPE_REGION:
215 
216 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
217 				  "***** Region %p\n", object));
218 
219 		/*
220 		 * Update address_range list. However, only permanent regions
221 		 * are installed in this list. (Not created within a method)
222 		 */
223 		if (!(object->region.node->flags & ANOBJ_TEMPORARY)) {
224 			acpi_ut_remove_address_range(object->region.space_id,
225 						     object->region.node);
226 		}
227 
228 		second_desc = acpi_ns_get_secondary_object(object);
229 		if (second_desc) {
230 			/*
231 			 * Free the region_context if and only if the handler is one of the
232 			 * default handlers -- and therefore, we created the context object
233 			 * locally, it was not created by an external caller.
234 			 */
235 			handler_desc = object->region.handler;
236 			if (handler_desc) {
237 				next_desc =
238 				    handler_desc->address_space.region_list;
239 				start_desc = next_desc;
240 				last_obj_ptr =
241 				    &handler_desc->address_space.region_list;
242 
243 				/* Remove the region object from the handler list */
244 
245 				while (next_desc) {
246 					if (next_desc == object) {
247 						*last_obj_ptr =
248 						    next_desc->region.next;
249 						break;
250 					}
251 
252 					/* Walk the linked list of handlers */
253 
254 					last_obj_ptr = &next_desc->region.next;
255 					next_desc = next_desc->region.next;
256 
257 					/* Prevent infinite loop if list is corrupted */
258 
259 					if (next_desc == start_desc) {
260 						ACPI_ERROR((AE_INFO,
261 							    "Circular region list in address handler object %p",
262 							    handler_desc));
263 						return_VOID;
264 					}
265 				}
266 
267 				if (handler_desc->address_space.handler_flags &
268 				    ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) {
269 
270 					/* Deactivate region and free region context */
271 
272 					if (handler_desc->address_space.setup) {
273 						(void)handler_desc->
274 						    address_space.setup(object,
275 									ACPI_REGION_DEACTIVATE,
276 									handler_desc->
277 									address_space.
278 									context,
279 									&second_desc->
280 									extra.
281 									region_context);
282 					}
283 				}
284 
285 				acpi_ut_remove_reference(handler_desc);
286 			}
287 
288 			/* Now we can free the Extra object */
289 
290 			acpi_ut_delete_object_desc(second_desc);
291 		}
292 		break;
293 
294 	case ACPI_TYPE_BUFFER_FIELD:
295 
296 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
297 				  "***** Buffer Field %p\n", object));
298 
299 		second_desc = acpi_ns_get_secondary_object(object);
300 		if (second_desc) {
301 			acpi_ut_delete_object_desc(second_desc);
302 		}
303 		break;
304 
305 	case ACPI_TYPE_LOCAL_BANK_FIELD:
306 
307 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
308 				  "***** Bank Field %p\n", object));
309 
310 		second_desc = acpi_ns_get_secondary_object(object);
311 		if (second_desc) {
312 			acpi_ut_delete_object_desc(second_desc);
313 		}
314 		break;
315 
316 	default:
317 
318 		break;
319 	}
320 
321 	/* Free any allocated memory (pointer within the object) found above */
322 
323 	if (obj_pointer) {
324 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
325 				  "Deleting Object Subptr %p\n", obj_pointer));
326 		ACPI_FREE(obj_pointer);
327 	}
328 
329 	/* Now the object can be safely deleted */
330 
331 	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
332 			  object, acpi_ut_get_object_type_name(object)));
333 
334 	acpi_ut_delete_object_desc(object);
335 	return_VOID;
336 }
337 
338 /*******************************************************************************
339  *
340  * FUNCTION:    acpi_ut_delete_internal_object_list
341  *
342  * PARAMETERS:  obj_list        - Pointer to the list to be deleted
343  *
344  * RETURN:      None
345  *
346  * DESCRIPTION: This function deletes an internal object list, including both
347  *              simple objects and package objects
348  *
349  ******************************************************************************/
350 
351 void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list)
352 {
353 	union acpi_operand_object **internal_obj;
354 
355 	ACPI_FUNCTION_ENTRY();
356 
357 	/* Walk the null-terminated internal list */
358 
359 	for (internal_obj = obj_list; *internal_obj; internal_obj++) {
360 		acpi_ut_remove_reference(*internal_obj);
361 	}
362 
363 	/* Free the combined parameter pointer list and object array */
364 
365 	ACPI_FREE(obj_list);
366 	return;
367 }
368 
369 /*******************************************************************************
370  *
371  * FUNCTION:    acpi_ut_update_ref_count
372  *
373  * PARAMETERS:  object          - Object whose ref count is to be updated
374  *              action          - What to do (REF_INCREMENT or REF_DECREMENT)
375  *
376  * RETURN:      None. Sets new reference count within the object
377  *
378  * DESCRIPTION: Modify the reference count for an internal acpi object
379  *
380  ******************************************************************************/
381 
382 static void
383 acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action)
384 {
385 	u16 original_count;
386 	u16 new_count = 0;
387 	acpi_cpu_flags lock_flags;
388 
389 	ACPI_FUNCTION_NAME(ut_update_ref_count);
390 
391 	if (!object) {
392 		return;
393 	}
394 
395 	/*
396 	 * Always get the reference count lock. Note: Interpreter and/or
397 	 * Namespace is not always locked when this function is called.
398 	 */
399 	lock_flags = acpi_os_acquire_lock(acpi_gbl_reference_count_lock);
400 	original_count = object->common.reference_count;
401 
402 	/* Perform the reference count action (increment, decrement) */
403 
404 	switch (action) {
405 	case REF_INCREMENT:
406 
407 		new_count = original_count + 1;
408 		object->common.reference_count = new_count;
409 		acpi_os_release_lock(acpi_gbl_reference_count_lock, lock_flags);
410 
411 		/* The current reference count should never be zero here */
412 
413 		if (!original_count) {
414 			ACPI_WARNING((AE_INFO,
415 				      "Obj %p, Reference Count was zero before increment\n",
416 				      object));
417 		}
418 
419 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
420 				  "Obj %p Type %.2X Refs %.2X [Incremented]\n",
421 				  object, object->common.type, new_count));
422 		break;
423 
424 	case REF_DECREMENT:
425 
426 		/* The current reference count must be non-zero */
427 
428 		if (original_count) {
429 			new_count = original_count - 1;
430 			object->common.reference_count = new_count;
431 		}
432 
433 		acpi_os_release_lock(acpi_gbl_reference_count_lock, lock_flags);
434 
435 		if (!original_count) {
436 			ACPI_WARNING((AE_INFO,
437 				      "Obj %p, Reference Count is already zero, cannot decrement\n",
438 				      object));
439 		}
440 
441 		ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
442 				  "Obj %p Type %.2X Refs %.2X [Decremented]\n",
443 				  object, object->common.type, new_count));
444 
445 		/* Actually delete the object on a reference count of zero */
446 
447 		if (new_count == 0) {
448 			acpi_ut_delete_internal_obj(object);
449 		}
450 		break;
451 
452 	default:
453 
454 		acpi_os_release_lock(acpi_gbl_reference_count_lock, lock_flags);
455 		ACPI_ERROR((AE_INFO, "Unknown Reference Count action (0x%X)",
456 			    action));
457 		return;
458 	}
459 
460 	/*
461 	 * Sanity check the reference count, for debug purposes only.
462 	 * (A deleted object will have a huge reference count)
463 	 */
464 	if (new_count > ACPI_MAX_REFERENCE_COUNT) {
465 		ACPI_WARNING((AE_INFO,
466 			      "Large Reference Count (0x%X) in object %p, Type=0x%.2X",
467 			      new_count, object, object->common.type));
468 	}
469 }
470 
471 /*******************************************************************************
472  *
473  * FUNCTION:    acpi_ut_update_object_reference
474  *
475  * PARAMETERS:  object              - Increment ref count for this object
476  *                                    and all sub-objects
477  *              action              - Either REF_INCREMENT or REF_DECREMENT
478  *
479  * RETURN:      Status
480  *
481  * DESCRIPTION: Increment the object reference count
482  *
483  * Object references are incremented when:
484  * 1) An object is attached to a Node (namespace object)
485  * 2) An object is copied (all subobjects must be incremented)
486  *
487  * Object references are decremented when:
488  * 1) An object is detached from an Node
489  *
490  ******************************************************************************/
491 
492 acpi_status
493 acpi_ut_update_object_reference(union acpi_operand_object *object, u16 action)
494 {
495 	acpi_status status = AE_OK;
496 	union acpi_generic_state *state_list = NULL;
497 	union acpi_operand_object *next_object = NULL;
498 	union acpi_operand_object *prev_object;
499 	union acpi_generic_state *state;
500 	u32 i;
501 
502 	ACPI_FUNCTION_NAME(ut_update_object_reference);
503 
504 	while (object) {
505 
506 		/* Make sure that this isn't a namespace handle */
507 
508 		if (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED) {
509 			ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
510 					  "Object %p is NS handle\n", object));
511 			return (AE_OK);
512 		}
513 
514 		/*
515 		 * All sub-objects must have their reference count incremented also.
516 		 * Different object types have different subobjects.
517 		 */
518 		switch (object->common.type) {
519 		case ACPI_TYPE_DEVICE:
520 		case ACPI_TYPE_PROCESSOR:
521 		case ACPI_TYPE_POWER:
522 		case ACPI_TYPE_THERMAL:
523 			/*
524 			 * Update the notify objects for these types (if present)
525 			 * Two lists, system and device notify handlers.
526 			 */
527 			for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++) {
528 				prev_object =
529 				    object->common_notify.notify_list[i];
530 				while (prev_object) {
531 					next_object =
532 					    prev_object->notify.next[i];
533 					acpi_ut_update_ref_count(prev_object,
534 								 action);
535 					prev_object = next_object;
536 				}
537 			}
538 			break;
539 
540 		case ACPI_TYPE_PACKAGE:
541 			/*
542 			 * We must update all the sub-objects of the package,
543 			 * each of whom may have their own sub-objects.
544 			 */
545 			for (i = 0; i < object->package.count; i++) {
546 				/*
547 				 * Null package elements are legal and can be simply
548 				 * ignored.
549 				 */
550 				next_object = object->package.elements[i];
551 				if (!next_object) {
552 					continue;
553 				}
554 
555 				switch (next_object->common.type) {
556 				case ACPI_TYPE_INTEGER:
557 				case ACPI_TYPE_STRING:
558 				case ACPI_TYPE_BUFFER:
559 					/*
560 					 * For these very simple sub-objects, we can just
561 					 * update the reference count here and continue.
562 					 * Greatly increases performance of this operation.
563 					 */
564 					acpi_ut_update_ref_count(next_object,
565 								 action);
566 					break;
567 
568 				default:
569 					/*
570 					 * For complex sub-objects, push them onto the stack
571 					 * for later processing (this eliminates recursion.)
572 					 */
573 					status =
574 					    acpi_ut_create_update_state_and_push
575 					    (next_object, action, &state_list);
576 					if (ACPI_FAILURE(status)) {
577 						goto error_exit;
578 					}
579 					break;
580 				}
581 			}
582 			next_object = NULL;
583 			break;
584 
585 		case ACPI_TYPE_BUFFER_FIELD:
586 
587 			next_object = object->buffer_field.buffer_obj;
588 			break;
589 
590 		case ACPI_TYPE_LOCAL_REGION_FIELD:
591 
592 			next_object = object->field.region_obj;
593 			break;
594 
595 		case ACPI_TYPE_LOCAL_BANK_FIELD:
596 
597 			next_object = object->bank_field.bank_obj;
598 			status =
599 			    acpi_ut_create_update_state_and_push(object->
600 								 bank_field.
601 								 region_obj,
602 								 action,
603 								 &state_list);
604 			if (ACPI_FAILURE(status)) {
605 				goto error_exit;
606 			}
607 			break;
608 
609 		case ACPI_TYPE_LOCAL_INDEX_FIELD:
610 
611 			next_object = object->index_field.index_obj;
612 			status =
613 			    acpi_ut_create_update_state_and_push(object->
614 								 index_field.
615 								 data_obj,
616 								 action,
617 								 &state_list);
618 			if (ACPI_FAILURE(status)) {
619 				goto error_exit;
620 			}
621 			break;
622 
623 		case ACPI_TYPE_LOCAL_REFERENCE:
624 			/*
625 			 * The target of an Index (a package, string, or buffer) or a named
626 			 * reference must track changes to the ref count of the index or
627 			 * target object.
628 			 */
629 			if ((object->reference.class == ACPI_REFCLASS_INDEX) ||
630 			    (object->reference.class == ACPI_REFCLASS_NAME)) {
631 				next_object = object->reference.object;
632 			}
633 			break;
634 
635 		case ACPI_TYPE_REGION:
636 		default:
637 
638 			break;	/* No subobjects for all other types */
639 		}
640 
641 		/*
642 		 * Now we can update the count in the main object. This can only
643 		 * happen after we update the sub-objects in case this causes the
644 		 * main object to be deleted.
645 		 */
646 		acpi_ut_update_ref_count(object, action);
647 		object = NULL;
648 
649 		/* Move on to the next object to be updated */
650 
651 		if (next_object) {
652 			object = next_object;
653 			next_object = NULL;
654 		} else if (state_list) {
655 			state = acpi_ut_pop_generic_state(&state_list);
656 			object = state->update.object;
657 			acpi_ut_delete_generic_state(state);
658 		}
659 	}
660 
661 	return (AE_OK);
662 
663 error_exit:
664 
665 	ACPI_EXCEPTION((AE_INFO, status,
666 			"Could not update object reference count"));
667 
668 	/* Free any stacked Update State objects */
669 
670 	while (state_list) {
671 		state = acpi_ut_pop_generic_state(&state_list);
672 		acpi_ut_delete_generic_state(state);
673 	}
674 
675 	return (status);
676 }
677 
678 /*******************************************************************************
679  *
680  * FUNCTION:    acpi_ut_add_reference
681  *
682  * PARAMETERS:  object          - Object whose reference count is to be
683  *                                incremented
684  *
685  * RETURN:      None
686  *
687  * DESCRIPTION: Add one reference to an ACPI object
688  *
689  ******************************************************************************/
690 
691 void acpi_ut_add_reference(union acpi_operand_object *object)
692 {
693 
694 	ACPI_FUNCTION_NAME(ut_add_reference);
695 
696 	/* Ensure that we have a valid object */
697 
698 	if (!acpi_ut_valid_internal_object(object)) {
699 		return;
700 	}
701 
702 	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
703 			  "Obj %p Current Refs=%X [To Be Incremented]\n",
704 			  object, object->common.reference_count));
705 
706 	/* Increment the reference count */
707 
708 	(void)acpi_ut_update_object_reference(object, REF_INCREMENT);
709 	return;
710 }
711 
712 /*******************************************************************************
713  *
714  * FUNCTION:    acpi_ut_remove_reference
715  *
716  * PARAMETERS:  object         - Object whose ref count will be decremented
717  *
718  * RETURN:      None
719  *
720  * DESCRIPTION: Decrement the reference count of an ACPI internal object
721  *
722  ******************************************************************************/
723 
724 void acpi_ut_remove_reference(union acpi_operand_object *object)
725 {
726 
727 	ACPI_FUNCTION_NAME(ut_remove_reference);
728 
729 	/*
730 	 * Allow a NULL pointer to be passed in, just ignore it. This saves
731 	 * each caller from having to check. Also, ignore NS nodes.
732 	 */
733 	if (!object ||
734 	    (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED)) {
735 		return;
736 	}
737 
738 	/* Ensure that we have a valid object */
739 
740 	if (!acpi_ut_valid_internal_object(object)) {
741 		return;
742 	}
743 
744 	ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
745 			  "Obj %p Current Refs=%X [To Be Decremented]\n",
746 			  object, object->common.reference_count));
747 
748 	/*
749 	 * Decrement the reference count, and only actually delete the object
750 	 * if the reference count becomes 0. (Must also decrement the ref count
751 	 * of all subobjects!)
752 	 */
753 	(void)acpi_ut_update_object_reference(object, REF_DECREMENT);
754 	return;
755 }
756