drivers/acpi/utilities/utcopy.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utcopy - Internal to external object translation utilities
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2007, R. Byron Moore
   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 <acpi/amlcode.h>
  46
  47 #define _COMPONENT          ACPI_UTILITIES
  48 ACPI_MODULE_NAME("utcopy")
  49
  50 /* Local prototypes */
  51 static acpi_status
  52 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
  53                                 union acpi_object *external_object,
  54                                 u8 * data_space, acpi_size * buffer_space_used);
  55
  56 static acpi_status
  57 acpi_ut_copy_ielement_to_ielement(u8 object_type,
  58                                   union acpi_operand_object *source_object,
  59                                   union acpi_generic_state *state,
  60                                   void *context);
  61
  62 static acpi_status
  63 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
  64                                   u8 * buffer, acpi_size * space_used);
  65
  66 static acpi_status
  67 acpi_ut_copy_esimple_to_isimple(union acpi_object *user_obj,
  68                                 union acpi_operand_object **return_obj);
  69
  70 static acpi_status
  71 acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
  72                                   union acpi_operand_object **internal_object);
  73
  74 static acpi_status
  75 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
  76                            union acpi_operand_object *dest_desc);
  77
  78 static acpi_status
  79 acpi_ut_copy_ielement_to_eelement(u8 object_type,
  80                                   union acpi_operand_object *source_object,
  81                                   union acpi_generic_state *state,
  82                                   void *context);
  83
  84 static acpi_status
  85 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
  86                                   union acpi_operand_object *dest_obj,
  87                                   struct acpi_walk_state *walk_state);
  88
  89 /*******************************************************************************
  90  *
  91  * FUNCTION:    acpi_ut_copy_isimple_to_esimple
  92  *
  93  * PARAMETERS:  internal_object     - Source object to be copied
  94  *              external_object     - Where to return the copied object
  95  *              data_space          - Where object data is returned (such as
  96  *                                    buffer and string data)
  97  *              buffer_space_used   - Length of data_space that was used
  98  *
  99  * RETURN:      Status
 100  *
 101  * DESCRIPTION: This function is called to copy a simple internal object to
 102  *              an external object.
 103  *
 104  *              The data_space buffer is assumed to have sufficient space for
 105  *              the object.
 106  *
 107  ******************************************************************************/
 108
 109 static acpi_status
 110 acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
 111                                 union acpi_object *external_object,
 112                                 u8 * data_space, acpi_size * buffer_space_used)
 113 {
 114         acpi_status status = AE_OK;
 115
 116         ACPI_FUNCTION_TRACE(ut_copy_isimple_to_esimple);
 117
 118         *buffer_space_used = 0;
 119
 120         /*
 121          * Check for NULL object case (could be an uninitialized
 122          * package element)
 123          */
 124         if (!internal_object) {
 125                 return_ACPI_STATUS(AE_OK);
 126         }
 127
 128         /* Always clear the external object */
 129
 130         ACPI_MEMSET(external_object, 0, sizeof(union acpi_object));
 131
 132         /*
 133          * In general, the external object will be the same type as
 134          * the internal object
 135          */
 136         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
 137
 138         /* However, only a limited number of external types are supported */
 139
 140         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
 141         case ACPI_TYPE_STRING:
 142
 143                 external_object->string.pointer = (char *)data_space;
 144                 external_object->string.length = internal_object->string.length;
 145                 *buffer_space_used = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
 146                                                                   internal_object->
 147                                                                   string.
 148                                                                   length + 1);
 149
 150                 ACPI_MEMCPY((void *)data_space,
 151                             (void *)internal_object->string.pointer,
 152                             (acpi_size) internal_object->string.length + 1);
 153                 break;
 154
 155         case ACPI_TYPE_BUFFER:
 156
 157                 external_object->buffer.pointer = data_space;
 158                 external_object->buffer.length = internal_object->buffer.length;
 159                 *buffer_space_used =
 160                     ACPI_ROUND_UP_TO_NATIVE_WORD(internal_object->string.
 161                                                  length);
 162
 163                 ACPI_MEMCPY((void *)data_space,
 164                             (void *)internal_object->buffer.pointer,
 165                             internal_object->buffer.length);
 166                 break;
 167
 168         case ACPI_TYPE_INTEGER:
 169
 170                 external_object->integer.value = internal_object->integer.value;
 171                 break;
 172
 173         case ACPI_TYPE_LOCAL_REFERENCE:
 174
 175                 /*
 176                  * This is an object reference.  Attempt to dereference it.
 177                  */
 178                 switch (internal_object->reference.opcode) {
 179                 case AML_INT_NAMEPATH_OP:
 180
 181                         /* For namepath, return the object handle ("reference") */
 182
 183                 default:
 184                         /*
 185                          * Use the object type of "Any" to indicate a reference
 186                          * to object containing a handle to an ACPI named object.
 187                          */
 188                         external_object->type = ACPI_TYPE_ANY;
 189                         external_object->reference.handle =
 190                             internal_object->reference.node;
 191                         break;
 192                 }
 193                 break;
 194
 195         case ACPI_TYPE_PROCESSOR:
 196
 197                 external_object->processor.proc_id =
 198                     internal_object->processor.proc_id;
 199                 external_object->processor.pblk_address =
 200                     internal_object->processor.address;
 201                 external_object->processor.pblk_length =
 202                     internal_object->processor.length;
 203                 break;
 204
 205         case ACPI_TYPE_POWER:
 206
 207                 external_object->power_resource.system_level =
 208                     internal_object->power_resource.system_level;
 209
 210                 external_object->power_resource.resource_order =
 211                     internal_object->power_resource.resource_order;
 212                 break;
 213
 214         default:
 215                 /*
 216                  * There is no corresponding external object type
 217                  */
 218                 ACPI_ERROR((AE_INFO,
 219                             "Unsupported object type, cannot convert to external object: %s",
 220                             acpi_ut_get_type_name(ACPI_GET_OBJECT_TYPE
 221                                                   (internal_object))));
 222
 223                 return_ACPI_STATUS(AE_SUPPORT);
 224         }
 225
 226         return_ACPI_STATUS(status);
 227 }
 228
 229 /*******************************************************************************
 230  *
 231  * FUNCTION:    acpi_ut_copy_ielement_to_eelement
 232  *
 233  * PARAMETERS:  acpi_pkg_callback
 234  *
 235  * RETURN:      Status
 236  *
 237  * DESCRIPTION: Copy one package element to another package element
 238  *
 239  ******************************************************************************/
 240
 241 static acpi_status
 242 acpi_ut_copy_ielement_to_eelement(u8 object_type,
 243                                   union acpi_operand_object *source_object,
 244                                   union acpi_generic_state *state,
 245                                   void *context)
 246 {
 247         acpi_status status = AE_OK;
 248         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
 249         acpi_size object_space;
 250         u32 this_index;
 251         union acpi_object *target_object;
 252
 253         ACPI_FUNCTION_ENTRY();
 254
 255         this_index = state->pkg.index;
 256         target_object = (union acpi_object *)
 257             &((union acpi_object *)(state->pkg.dest_object))->package.
 258             elements[this_index];
 259
 260         switch (object_type) {
 261         case ACPI_COPY_TYPE_SIMPLE:
 262
 263                 /*
 264                  * This is a simple or null object
 265                  */
 266                 status = acpi_ut_copy_isimple_to_esimple(source_object,
 267                                                          target_object,
 268                                                          info->free_space,
 269                                                          &object_space);
 270                 if (ACPI_FAILURE(status)) {
 271                         return (status);
 272                 }
 273                 break;
 274
 275         case ACPI_COPY_TYPE_PACKAGE:
 276
 277                 /*
 278                  * Build the package object
 279                  */
 280                 target_object->type = ACPI_TYPE_PACKAGE;
 281                 target_object->package.count = source_object->package.count;
 282                 target_object->package.elements =
 283                     ACPI_CAST_PTR(union acpi_object, info->free_space);
 284
 285                 /*
 286                  * Pass the new package object back to the package walk routine
 287                  */
 288                 state->pkg.this_target_obj = target_object;
 289
 290                 /*
 291                  * Save space for the array of objects (Package elements)
 292                  * update the buffer length counter
 293                  */
 294                 object_space = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
 295                                                             target_object->
 296                                                             package.count *
 297                                                             sizeof(union
 298                                                                    acpi_object));
 299                 break;
 300
 301         default:
 302                 return (AE_BAD_PARAMETER);
 303         }
 304
 305         info->free_space += object_space;
 306         info->length += object_space;
 307         return (status);
 308 }
 309
 310 /*******************************************************************************
 311  *
 312  * FUNCTION:    acpi_ut_copy_ipackage_to_epackage
 313  *
 314  * PARAMETERS:  internal_object     - Pointer to the object we are returning
 315  *              Buffer              - Where the object is returned
 316  *              space_used          - Where the object length is returned
 317  *
 318  * RETURN:      Status
 319  *
 320  * DESCRIPTION: This function is called to place a package object in a user
 321  *              buffer.  A package object by definition contains other objects.
 322  *
 323  *              The buffer is assumed to have sufficient space for the object.
 324  *              The caller must have verified the buffer length needed using the
 325  *              acpi_ut_get_object_size function before calling this function.
 326  *
 327  ******************************************************************************/
 328
 329 static acpi_status
 330 acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
 331                                   u8 * buffer, acpi_size * space_used)
 332 {
 333         union acpi_object *external_object;
 334         acpi_status status;
 335         struct acpi_pkg_info info;
 336
 337         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_epackage);
 338
 339         /*
 340          * First package at head of the buffer
 341          */
 342         external_object = ACPI_CAST_PTR(union acpi_object, buffer);
 343
 344         /*
 345          * Free space begins right after the first package
 346          */
 347         info.length = ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 348         info.free_space =
 349             buffer + ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 350         info.object_space = 0;
 351         info.num_packages = 1;
 352
 353         external_object->type = ACPI_GET_OBJECT_TYPE(internal_object);
 354         external_object->package.count = internal_object->package.count;
 355         external_object->package.elements = ACPI_CAST_PTR(union acpi_object,
 356                                                           info.free_space);
 357
 358         /*
 359          * Leave room for an array of ACPI_OBJECTS in the buffer
 360          * and move the free space past it
 361          */
 362         info.length += (acpi_size) external_object->package.count *
 363             ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 364         info.free_space += external_object->package.count *
 365             ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
 366
 367         status = acpi_ut_walk_package_tree(internal_object, external_object,
 368                                            acpi_ut_copy_ielement_to_eelement,
 369                                            &info);
 370
 371         *space_used = info.length;
 372         return_ACPI_STATUS(status);
 373 }
 374
 375 /*******************************************************************************
 376  *
 377  * FUNCTION:    acpi_ut_copy_iobject_to_eobject
 378  *
 379  * PARAMETERS:  internal_object     - The internal object to be converted
 380  *              buffer_ptr          - Where the object is returned
 381  *
 382  * RETURN:      Status
 383  *
 384  * DESCRIPTION: This function is called to build an API object to be returned to
 385  *              the caller.
 386  *
 387  ******************************************************************************/
 388
 389 acpi_status
 390 acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *internal_object,
 391                                 struct acpi_buffer *ret_buffer)
 392 {
 393         acpi_status status;
 394
 395         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_eobject);
 396
 397         if (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE) {
 398                 /*
 399                  * Package object:  Copy all subobjects (including
 400                  * nested packages)
 401                  */
 402                 status = acpi_ut_copy_ipackage_to_epackage(internal_object,
 403                                                            ret_buffer->pointer,
 404                                                            &ret_buffer->length);
 405         } else {
 406                 /*
 407                  * Build a simple object (no nested objects)
 408                  */
 409                 status = acpi_ut_copy_isimple_to_esimple(internal_object,
 410                                                          ACPI_CAST_PTR(union
 411                                                                        acpi_object,
 412                                                                        ret_buffer->
 413                                                                        pointer),
 414                                                          ACPI_ADD_PTR(u8,
 415                                                                       ret_buffer->
 416                                                                       pointer,
 417                                                                       ACPI_ROUND_UP_TO_NATIVE_WORD
 418                                                                       (sizeof
 419                                                                        (union
 420                                                                         acpi_object))),
 421                                                          &ret_buffer->length);
 422                 /*
 423                  * build simple does not include the object size in the length
 424                  * so we add it in here
 425                  */
 426                 ret_buffer->length += sizeof(union acpi_object);
 427         }
 428
 429         return_ACPI_STATUS(status);
 430 }
 431
 432 /*******************************************************************************
 433  *
 434  * FUNCTION:    acpi_ut_copy_esimple_to_isimple
 435  *
 436  * PARAMETERS:  external_object     - The external object to be converted
 437  *              ret_internal_object - Where the internal object is returned
 438  *
 439  * RETURN:      Status
 440  *
 441  * DESCRIPTION: This function copies an external object to an internal one.
 442  *              NOTE: Pointers can be copied, we don't need to copy data.
 443  *              (The pointers have to be valid in our address space no matter
 444  *              what we do with them!)
 445  *
 446  ******************************************************************************/
 447
 448 static acpi_status
 449 acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
 450                                 union acpi_operand_object **ret_internal_object)
 451 {
 452         union acpi_operand_object *internal_object;
 453
 454         ACPI_FUNCTION_TRACE(ut_copy_esimple_to_isimple);
 455
 456         /*
 457          * Simple types supported are: String, Buffer, Integer
 458          */
 459         switch (external_object->type) {
 460         case ACPI_TYPE_STRING:
 461         case ACPI_TYPE_BUFFER:
 462         case ACPI_TYPE_INTEGER:
 463
 464                 internal_object = acpi_ut_create_internal_object((u8)
 465                                                                  external_object->
 466                                                                  type);
 467                 if (!internal_object) {
 468                         return_ACPI_STATUS(AE_NO_MEMORY);
 469                 }
 470                 break;
 471
 472         default:
 473                 /* All other types are not supported */
 474
 475                 ACPI_ERROR((AE_INFO,
 476                             "Unsupported object type, cannot convert to internal object: %s",
 477                             acpi_ut_get_type_name(external_object->type)));
 478
 479                 return_ACPI_STATUS(AE_SUPPORT);
 480         }
 481
 482         /* Must COPY string and buffer contents */
 483
 484         switch (external_object->type) {
 485         case ACPI_TYPE_STRING:
 486
 487                 internal_object->string.pointer =
 488                     ACPI_ALLOCATE_ZEROED((acpi_size) external_object->string.
 489                                          length + 1);
 490                 if (!internal_object->string.pointer) {
 491                         goto error_exit;
 492                 }
 493
 494                 ACPI_MEMCPY(internal_object->string.pointer,
 495                             external_object->string.pointer,
 496                             external_object->string.length);
 497
 498                 internal_object->string.length = external_object->string.length;
 499                 break;
 500
 501         case ACPI_TYPE_BUFFER:
 502
 503                 internal_object->buffer.pointer =
 504                     ACPI_ALLOCATE_ZEROED(external_object->buffer.length);
 505                 if (!internal_object->buffer.pointer) {
 506                         goto error_exit;
 507                 }
 508
 509                 ACPI_MEMCPY(internal_object->buffer.pointer,
 510                             external_object->buffer.pointer,
 511                             external_object->buffer.length);
 512
 513                 internal_object->buffer.length = external_object->buffer.length;
 514
 515                 /* Mark buffer data valid */
 516
 517                 internal_object->buffer.flags |= AOPOBJ_DATA_VALID;
 518                 break;
 519
 520         case ACPI_TYPE_INTEGER:
 521
 522                 internal_object->integer.value = external_object->integer.value;
 523                 break;
 524
 525         default:
 526                 /* Other types can't get here */
 527                 break;
 528         }
 529
 530         *ret_internal_object = internal_object;
 531         return_ACPI_STATUS(AE_OK);
 532
 533       error_exit:
 534         acpi_ut_remove_reference(internal_object);
 535         return_ACPI_STATUS(AE_NO_MEMORY);
 536 }
 537
 538 /*******************************************************************************
 539  *
 540  * FUNCTION:    acpi_ut_copy_epackage_to_ipackage
 541  *
 542  * PARAMETERS:  external_object     - The external object to be converted
 543  *              internal_object     - Where the internal object is returned
 544  *
 545  * RETURN:      Status
 546  *
 547  * DESCRIPTION: Copy an external package object to an internal package.
 548  *              Handles nested packages.
 549  *
 550  ******************************************************************************/
 551
 552 static acpi_status
 553 acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
 554                                   union acpi_operand_object **internal_object)
 555 {
 556         acpi_status status = AE_OK;
 557         union acpi_operand_object *package_object;
 558         union acpi_operand_object **package_elements;
 559         acpi_native_uint i;
 560
 561         ACPI_FUNCTION_TRACE(ut_copy_epackage_to_ipackage);
 562
 563         /* Create the package object */
 564
 565         package_object =
 566             acpi_ut_create_package_object(external_object->package.count);
 567         if (!package_object) {
 568                 return_ACPI_STATUS(AE_NO_MEMORY);
 569         }
 570
 571         package_elements = package_object->package.elements;
 572
 573         /*
 574          * Recursive implementation. Probably ok, since nested external packages
 575          * as parameters should be very rare.
 576          */
 577         for (i = 0; i < external_object->package.count; i++) {
 578                 status =
 579                     acpi_ut_copy_eobject_to_iobject(&external_object->package.
 580                                                     elements[i],
 581                                                     &package_elements[i]);
 582                 if (ACPI_FAILURE(status)) {
 583
 584                         /* Truncate package and delete it */
 585
 586                         package_object->package.count = (u32) i;
 587                         package_elements[i] = NULL;
 588                         acpi_ut_remove_reference(package_object);
 589                         return_ACPI_STATUS(status);
 590                 }
 591         }
 592
 593         /* Mark package data valid */
 594
 595         package_object->package.flags |= AOPOBJ_DATA_VALID;
 596
 597         *internal_object = package_object;
 598         return_ACPI_STATUS(status);
 599 }
 600
 601 /*******************************************************************************
 602  *
 603  * FUNCTION:    acpi_ut_copy_eobject_to_iobject
 604  *
 605  * PARAMETERS:  external_object     - The external object to be converted
 606  *              internal_object     - Where the internal object is returned
 607  *
 608  * RETURN:      Status              - the status of the call
 609  *
 610  * DESCRIPTION: Converts an external object to an internal object.
 611  *
 612  ******************************************************************************/
 613
 614 acpi_status
 615 acpi_ut_copy_eobject_to_iobject(union acpi_object *external_object,
 616                                 union acpi_operand_object **internal_object)
 617 {
 618         acpi_status status;
 619
 620         ACPI_FUNCTION_TRACE(ut_copy_eobject_to_iobject);
 621
 622         if (external_object->type == ACPI_TYPE_PACKAGE) {
 623                 status =
 624                     acpi_ut_copy_epackage_to_ipackage(external_object,
 625                                                       internal_object);
 626         } else {
 627                 /*
 628                  * Build a simple object (no nested objects)
 629                  */
 630                 status =
 631                     acpi_ut_copy_esimple_to_isimple(external_object,
 632                                                     internal_object);
 633         }
 634
 635         return_ACPI_STATUS(status);
 636 }
 637
 638 /*******************************************************************************
 639  *
 640  * FUNCTION:    acpi_ut_copy_simple_object
 641  *
 642  * PARAMETERS:  source_desc         - The internal object to be copied
 643  *              dest_desc           - New target object
 644  *
 645  * RETURN:      Status
 646  *
 647  * DESCRIPTION: Simple copy of one internal object to another.  Reference count
 648  *              of the destination object is preserved.
 649  *
 650  ******************************************************************************/
 651
 652 static acpi_status
 653 acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
 654                            union acpi_operand_object *dest_desc)
 655 {
 656         u16 reference_count;
 657         union acpi_operand_object *next_object;
 658
 659         /* Save fields from destination that we don't want to overwrite */
 660
 661         reference_count = dest_desc->common.reference_count;
 662         next_object = dest_desc->common.next_object;
 663
 664         /* Copy the entire source object over the destination object */
 665
 666         ACPI_MEMCPY((char *)dest_desc, (char *)source_desc,
 667                     sizeof(union acpi_operand_object));
 668
 669         /* Restore the saved fields */
 670
 671         dest_desc->common.reference_count = reference_count;
 672         dest_desc->common.next_object = next_object;
 673
 674         /* New object is not static, regardless of source */
 675
 676         dest_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;
 677
 678         /* Handle the objects with extra data */
 679
 680         switch (ACPI_GET_OBJECT_TYPE(dest_desc)) {
 681         case ACPI_TYPE_BUFFER:
 682                 /*
 683                  * Allocate and copy the actual buffer if and only if:
 684                  * 1) There is a valid buffer pointer
 685                  * 2) The buffer has a length > 0
 686                  */
 687                 if ((source_desc->buffer.pointer) &&
 688                     (source_desc->buffer.length)) {
 689                         dest_desc->buffer.pointer =
 690                             ACPI_ALLOCATE(source_desc->buffer.length);
 691                         if (!dest_desc->buffer.pointer) {
 692                                 return (AE_NO_MEMORY);
 693                         }
 694
 695                         /* Copy the actual buffer data */
 696
 697                         ACPI_MEMCPY(dest_desc->buffer.pointer,
 698                                     source_desc->buffer.pointer,
 699                                     source_desc->buffer.length);
 700                 }
 701                 break;
 702
 703         case ACPI_TYPE_STRING:
 704                 /*
 705                  * Allocate and copy the actual string if and only if:
 706                  * 1) There is a valid string pointer
 707                  * (Pointer to a NULL string is allowed)
 708                  */
 709                 if (source_desc->string.pointer) {
 710                         dest_desc->string.pointer =
 711                             ACPI_ALLOCATE((acpi_size) source_desc->string.
 712                                           length + 1);
 713                         if (!dest_desc->string.pointer) {
 714                                 return (AE_NO_MEMORY);
 715                         }
 716
 717                         /* Copy the actual string data */
 718
 719                         ACPI_MEMCPY(dest_desc->string.pointer,
 720                                     source_desc->string.pointer,
 721                                     (acpi_size) source_desc->string.length + 1);
 722                 }
 723                 break;
 724
 725         case ACPI_TYPE_LOCAL_REFERENCE:
 726                 /*
 727                  * We copied the reference object, so we now must add a reference
 728                  * to the object pointed to by the reference
 729                  *
 730                  * DDBHandle reference (from Load/load_table is a special reference,
 731                  * it's Reference.Object is the table index, so does not need to
 732                  * increase the reference count
 733                  */
 734                 if (source_desc->reference.opcode == AML_LOAD_OP) {
 735                         break;
 736                 }
 737
 738                 acpi_ut_add_reference(source_desc->reference.object);
 739                 break;
 740
 741         case ACPI_TYPE_REGION:
 742                 /*
 743                  * We copied the Region Handler, so we now must add a reference
 744                  */
 745                 if (dest_desc->region.handler) {
 746                         acpi_ut_add_reference(dest_desc->region.handler);
 747                 }
 748                 break;
 749
 750         default:
 751                 /* Nothing to do for other simple objects */
 752                 break;
 753         }
 754
 755         return (AE_OK);
 756 }
 757
 758 /*******************************************************************************
 759  *
 760  * FUNCTION:    acpi_ut_copy_ielement_to_ielement
 761  *
 762  * PARAMETERS:  acpi_pkg_callback
 763  *
 764  * RETURN:      Status
 765  *
 766  * DESCRIPTION: Copy one package element to another package element
 767  *
 768  ******************************************************************************/
 769
 770 static acpi_status
 771 acpi_ut_copy_ielement_to_ielement(u8 object_type,
 772                                   union acpi_operand_object *source_object,
 773                                   union acpi_generic_state *state,
 774                                   void *context)
 775 {
 776         acpi_status status = AE_OK;
 777         u32 this_index;
 778         union acpi_operand_object **this_target_ptr;
 779         union acpi_operand_object *target_object;
 780
 781         ACPI_FUNCTION_ENTRY();
 782
 783         this_index = state->pkg.index;
 784         this_target_ptr = (union acpi_operand_object **)
 785             &state->pkg.dest_object->package.elements[this_index];
 786
 787         switch (object_type) {
 788         case ACPI_COPY_TYPE_SIMPLE:
 789
 790                 /* A null source object indicates a (legal) null package element */
 791
 792                 if (source_object) {
 793                         /*
 794                          * This is a simple object, just copy it
 795                          */
 796                         target_object =
 797                             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE
 798                                                            (source_object));
 799                         if (!target_object) {
 800                                 return (AE_NO_MEMORY);
 801                         }
 802
 803                         status =
 804                             acpi_ut_copy_simple_object(source_object,
 805                                                        target_object);
 806                         if (ACPI_FAILURE(status)) {
 807                                 goto error_exit;
 808                         }
 809
 810                         *this_target_ptr = target_object;
 811                 } else {
 812                         /* Pass through a null element */
 813
 814                         *this_target_ptr = NULL;
 815                 }
 816                 break;
 817
 818         case ACPI_COPY_TYPE_PACKAGE:
 819
 820                 /*
 821                  * This object is a package - go down another nesting level
 822                  * Create and build the package object
 823                  */
 824                 target_object =
 825                     acpi_ut_create_package_object(source_object->package.count);
 826                 if (!target_object) {
 827                         return (AE_NO_MEMORY);
 828                 }
 829
 830                 target_object->common.flags = source_object->common.flags;
 831
 832                 /* Pass the new package object back to the package walk routine */
 833
 834                 state->pkg.this_target_obj = target_object;
 835
 836                 /* Store the object pointer in the parent package object */
 837
 838                 *this_target_ptr = target_object;
 839                 break;
 840
 841         default:
 842                 return (AE_BAD_PARAMETER);
 843         }
 844
 845         return (status);
 846
 847       error_exit:
 848         acpi_ut_remove_reference(target_object);
 849         return (status);
 850 }
 851
 852 /*******************************************************************************
 853  *
 854  * FUNCTION:    acpi_ut_copy_ipackage_to_ipackage
 855  *
 856  * PARAMETERS:  *source_obj     - Pointer to the source package object
 857  *              *dest_obj       - Where the internal object is returned
 858  *
 859  * RETURN:      Status          - the status of the call
 860  *
 861  * DESCRIPTION: This function is called to copy an internal package object
 862  *              into another internal package object.
 863  *
 864  ******************************************************************************/
 865
 866 static acpi_status
 867 acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
 868                                   union acpi_operand_object *dest_obj,
 869                                   struct acpi_walk_state *walk_state)
 870 {
 871         acpi_status status = AE_OK;
 872
 873         ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_ipackage);
 874
 875         dest_obj->common.type = ACPI_GET_OBJECT_TYPE(source_obj);
 876         dest_obj->common.flags = source_obj->common.flags;
 877         dest_obj->package.count = source_obj->package.count;
 878
 879         /*
 880          * Create the object array and walk the source package tree
 881          */
 882         dest_obj->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
 883                                                            source_obj->package.
 884                                                            count +
 885                                                            1) * sizeof(void *));
 886         if (!dest_obj->package.elements) {
 887                 ACPI_ERROR((AE_INFO, "Package allocation failure"));
 888                 return_ACPI_STATUS(AE_NO_MEMORY);
 889         }
 890
 891         /*
 892          * Copy the package element-by-element by walking the package "tree".
 893          * This handles nested packages of arbitrary depth.
 894          */
 895         status = acpi_ut_walk_package_tree(source_obj, dest_obj,
 896                                            acpi_ut_copy_ielement_to_ielement,
 897                                            walk_state);
 898         if (ACPI_FAILURE(status)) {
 899
 900                 /* On failure, delete the destination package object */
 901
 902                 acpi_ut_remove_reference(dest_obj);
 903         }
 904
 905         return_ACPI_STATUS(status);
 906 }
 907
 908 /*******************************************************************************
 909  *
 910  * FUNCTION:    acpi_ut_copy_iobject_to_iobject
 911  *
 912  * PARAMETERS:  walk_state          - Current walk state
 913  *              source_desc         - The internal object to be copied
 914  *              dest_desc           - Where the copied object is returned
 915  *
 916  * RETURN:      Status
 917  *
 918  * DESCRIPTION: Copy an internal object to a new internal object
 919  *
 920  ******************************************************************************/
 921
 922 acpi_status
 923 acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
 924                                 union acpi_operand_object **dest_desc,
 925                                 struct acpi_walk_state *walk_state)
 926 {
 927         acpi_status status = AE_OK;
 928
 929         ACPI_FUNCTION_TRACE(ut_copy_iobject_to_iobject);
 930
 931         /* Create the top level object */
 932
 933         *dest_desc =
 934             acpi_ut_create_internal_object(ACPI_GET_OBJECT_TYPE(source_desc));
 935         if (!*dest_desc) {
 936                 return_ACPI_STATUS(AE_NO_MEMORY);
 937         }
 938
 939         /* Copy the object and possible subobjects */
 940
 941         if (ACPI_GET_OBJECT_TYPE(source_desc) == ACPI_TYPE_PACKAGE) {
 942                 status =
 943                     acpi_ut_copy_ipackage_to_ipackage(source_desc, *dest_desc,
 944                                                       walk_state);
 945         } else {
 946                 status = acpi_ut_copy_simple_object(source_desc, *dest_desc);
 947         }
 948
 949         return_ACPI_STATUS(status);
 950 }