LXR linux/drivers/acpi/acpica/utdelete.c

   1/*******************************************************************************
   2 *
   3 * Module Name: utdelete - object deletion and reference count utilities
   4 *
   5 ******************************************************************************/
   6
   7/*
   8 * Copyright (C) 2000 - 2015, 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