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 51ACPI_MODULE_NAME("utdelete") 52 53/* Local prototypes */ 54static void acpi_ut_delete_internal_obj(union acpi_operand_object *object); 55 56static void 57acpi_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 72static 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 351void 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 382static void 383acpi_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 492acpi_status 493acpi_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 663error_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 691void 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 724void 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