1011 lines
28 KiB
C
1011 lines
28 KiB
C
/******************************************************************************
|
|
*
|
|
* Module Name: utcopy - Internal to external object translation utilities
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Copyright (C) 2000 - 2017, Intel Corp.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions, and the following disclaimer,
|
|
* without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* substantially similar to the "NO WARRANTY" disclaimer below
|
|
* ("Disclaimer") and any redistribution must be conditioned upon
|
|
* including a substantially similar Disclaimer requirement for further
|
|
* binary redistribution.
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
* of any contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
* Software Foundation.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
|
|
#include <acpi/acpi.h>
|
|
#include "accommon.h"
|
|
#include "acnamesp.h"
|
|
|
|
|
|
#define _COMPONENT ACPI_UTILITIES
|
|
ACPI_MODULE_NAME("utcopy")
|
|
|
|
/* Local prototypes */
|
|
static acpi_status
|
|
acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
|
|
union acpi_object *external_object,
|
|
u8 *data_space, acpi_size *buffer_space_used);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ielement_to_ielement(u8 object_type,
|
|
union acpi_operand_object *source_object,
|
|
union acpi_generic_state *state,
|
|
void *context);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
|
|
u8 *buffer, acpi_size *space_used);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_esimple_to_isimple(union acpi_object *user_obj,
|
|
union acpi_operand_object **return_obj);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
|
|
union acpi_operand_object **internal_object);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
|
|
union acpi_operand_object *dest_desc);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ielement_to_eelement(u8 object_type,
|
|
union acpi_operand_object *source_object,
|
|
union acpi_generic_state *state,
|
|
void *context);
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
|
|
union acpi_operand_object *dest_obj,
|
|
struct acpi_walk_state *walk_state);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_isimple_to_esimple
|
|
*
|
|
* PARAMETERS: internal_object - Source object to be copied
|
|
* external_object - Where to return the copied object
|
|
* data_space - Where object data is returned (such as
|
|
* buffer and string data)
|
|
* buffer_space_used - Length of data_space that was used
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: This function is called to copy a simple internal object to
|
|
* an external object.
|
|
*
|
|
* The data_space buffer is assumed to have sufficient space for
|
|
* the object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_isimple_to_esimple(union acpi_operand_object *internal_object,
|
|
union acpi_object *external_object,
|
|
u8 *data_space, acpi_size *buffer_space_used)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_isimple_to_esimple);
|
|
|
|
*buffer_space_used = 0;
|
|
|
|
/*
|
|
* Check for NULL object case (could be an uninitialized
|
|
* package element)
|
|
*/
|
|
if (!internal_object) {
|
|
return_ACPI_STATUS(AE_OK);
|
|
}
|
|
|
|
/* Always clear the external object */
|
|
|
|
memset(external_object, 0, sizeof(union acpi_object));
|
|
|
|
/*
|
|
* In general, the external object will be the same type as
|
|
* the internal object
|
|
*/
|
|
external_object->type = internal_object->common.type;
|
|
|
|
/* However, only a limited number of external types are supported */
|
|
|
|
switch (internal_object->common.type) {
|
|
case ACPI_TYPE_STRING:
|
|
|
|
external_object->string.pointer = (char *)data_space;
|
|
external_object->string.length = internal_object->string.length;
|
|
*buffer_space_used = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
|
|
internal_object->
|
|
string.
|
|
length + 1);
|
|
|
|
memcpy((void *)data_space,
|
|
(void *)internal_object->string.pointer,
|
|
(acpi_size)internal_object->string.length + 1);
|
|
break;
|
|
|
|
case ACPI_TYPE_BUFFER:
|
|
|
|
external_object->buffer.pointer = data_space;
|
|
external_object->buffer.length = internal_object->buffer.length;
|
|
*buffer_space_used =
|
|
ACPI_ROUND_UP_TO_NATIVE_WORD(internal_object->string.
|
|
length);
|
|
|
|
memcpy((void *)data_space,
|
|
(void *)internal_object->buffer.pointer,
|
|
internal_object->buffer.length);
|
|
break;
|
|
|
|
case ACPI_TYPE_INTEGER:
|
|
|
|
external_object->integer.value = internal_object->integer.value;
|
|
break;
|
|
|
|
case ACPI_TYPE_LOCAL_REFERENCE:
|
|
|
|
/* This is an object reference. */
|
|
|
|
switch (internal_object->reference.class) {
|
|
case ACPI_REFCLASS_NAME:
|
|
/*
|
|
* For namepath, return the object handle ("reference")
|
|
* We are referring to the namespace node
|
|
*/
|
|
external_object->reference.handle =
|
|
internal_object->reference.node;
|
|
external_object->reference.actual_type =
|
|
acpi_ns_get_type(internal_object->reference.node);
|
|
break;
|
|
|
|
default:
|
|
|
|
/* All other reference types are unsupported */
|
|
|
|
return_ACPI_STATUS(AE_TYPE);
|
|
}
|
|
break;
|
|
|
|
case ACPI_TYPE_PROCESSOR:
|
|
|
|
external_object->processor.proc_id =
|
|
internal_object->processor.proc_id;
|
|
external_object->processor.pblk_address =
|
|
internal_object->processor.address;
|
|
external_object->processor.pblk_length =
|
|
internal_object->processor.length;
|
|
break;
|
|
|
|
case ACPI_TYPE_POWER:
|
|
|
|
external_object->power_resource.system_level =
|
|
internal_object->power_resource.system_level;
|
|
|
|
external_object->power_resource.resource_order =
|
|
internal_object->power_resource.resource_order;
|
|
break;
|
|
|
|
default:
|
|
/*
|
|
* There is no corresponding external object type
|
|
*/
|
|
ACPI_ERROR((AE_INFO,
|
|
"Unsupported object type, cannot convert to external object: %s",
|
|
acpi_ut_get_type_name(internal_object->common.
|
|
type)));
|
|
|
|
return_ACPI_STATUS(AE_SUPPORT);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_ielement_to_eelement
|
|
*
|
|
* PARAMETERS: acpi_pkg_callback
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Copy one package element to another package element
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ielement_to_eelement(u8 object_type,
|
|
union acpi_operand_object *source_object,
|
|
union acpi_generic_state *state,
|
|
void *context)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
|
|
acpi_size object_space;
|
|
u32 this_index;
|
|
union acpi_object *target_object;
|
|
|
|
ACPI_FUNCTION_ENTRY();
|
|
|
|
this_index = state->pkg.index;
|
|
target_object = (union acpi_object *)&((union acpi_object *)
|
|
(state->pkg.dest_object))->
|
|
package.elements[this_index];
|
|
|
|
switch (object_type) {
|
|
case ACPI_COPY_TYPE_SIMPLE:
|
|
/*
|
|
* This is a simple or null object
|
|
*/
|
|
status = acpi_ut_copy_isimple_to_esimple(source_object,
|
|
target_object,
|
|
info->free_space,
|
|
&object_space);
|
|
if (ACPI_FAILURE(status)) {
|
|
return (status);
|
|
}
|
|
break;
|
|
|
|
case ACPI_COPY_TYPE_PACKAGE:
|
|
/*
|
|
* Build the package object
|
|
*/
|
|
target_object->type = ACPI_TYPE_PACKAGE;
|
|
target_object->package.count = source_object->package.count;
|
|
target_object->package.elements =
|
|
ACPI_CAST_PTR(union acpi_object, info->free_space);
|
|
|
|
/*
|
|
* Pass the new package object back to the package walk routine
|
|
*/
|
|
state->pkg.this_target_obj = target_object;
|
|
|
|
/*
|
|
* Save space for the array of objects (Package elements)
|
|
* update the buffer length counter
|
|
*/
|
|
object_space = ACPI_ROUND_UP_TO_NATIVE_WORD((acpi_size)
|
|
target_object->
|
|
package.count *
|
|
sizeof(union
|
|
acpi_object));
|
|
break;
|
|
|
|
default:
|
|
|
|
return (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
info->free_space += object_space;
|
|
info->length += object_space;
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_ipackage_to_epackage
|
|
*
|
|
* PARAMETERS: internal_object - Pointer to the object we are returning
|
|
* buffer - Where the object is returned
|
|
* space_used - Where the object length is returned
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: This function is called to place a package object in a user
|
|
* buffer. A package object by definition contains other objects.
|
|
*
|
|
* The buffer is assumed to have sufficient space for the object.
|
|
* The caller must have verified the buffer length needed using
|
|
* the acpi_ut_get_object_size function before calling this function.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ipackage_to_epackage(union acpi_operand_object *internal_object,
|
|
u8 *buffer, acpi_size *space_used)
|
|
{
|
|
union acpi_object *external_object;
|
|
acpi_status status;
|
|
struct acpi_pkg_info info;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_epackage);
|
|
|
|
/*
|
|
* First package at head of the buffer
|
|
*/
|
|
external_object = ACPI_CAST_PTR(union acpi_object, buffer);
|
|
|
|
/*
|
|
* Free space begins right after the first package
|
|
*/
|
|
info.length = ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
|
|
info.free_space = buffer +
|
|
ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
|
|
info.object_space = 0;
|
|
info.num_packages = 1;
|
|
|
|
external_object->type = internal_object->common.type;
|
|
external_object->package.count = internal_object->package.count;
|
|
external_object->package.elements =
|
|
ACPI_CAST_PTR(union acpi_object, info.free_space);
|
|
|
|
/*
|
|
* Leave room for an array of ACPI_OBJECTS in the buffer
|
|
* and move the free space past it
|
|
*/
|
|
info.length += (acpi_size)external_object->package.count *
|
|
ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
|
|
info.free_space += external_object->package.count *
|
|
ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object));
|
|
|
|
status = acpi_ut_walk_package_tree(internal_object, external_object,
|
|
acpi_ut_copy_ielement_to_eelement,
|
|
&info);
|
|
|
|
*space_used = info.length;
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_iobject_to_eobject
|
|
*
|
|
* PARAMETERS: internal_object - The internal object to be converted
|
|
* ret_buffer - Where the object is returned
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: This function is called to build an API object to be returned
|
|
* to the caller.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status
|
|
acpi_ut_copy_iobject_to_eobject(union acpi_operand_object *internal_object,
|
|
struct acpi_buffer *ret_buffer)
|
|
{
|
|
acpi_status status;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_iobject_to_eobject);
|
|
|
|
if (internal_object->common.type == ACPI_TYPE_PACKAGE) {
|
|
/*
|
|
* Package object: Copy all subobjects (including
|
|
* nested packages)
|
|
*/
|
|
status = acpi_ut_copy_ipackage_to_epackage(internal_object,
|
|
ret_buffer->pointer,
|
|
&ret_buffer->length);
|
|
} else {
|
|
/*
|
|
* Build a simple object (no nested objects)
|
|
*/
|
|
status = acpi_ut_copy_isimple_to_esimple(internal_object,
|
|
ACPI_CAST_PTR(union
|
|
acpi_object,
|
|
ret_buffer->
|
|
pointer),
|
|
ACPI_ADD_PTR(u8,
|
|
ret_buffer->
|
|
pointer,
|
|
ACPI_ROUND_UP_TO_NATIVE_WORD
|
|
(sizeof
|
|
(union
|
|
acpi_object))),
|
|
&ret_buffer->length);
|
|
/*
|
|
* build simple does not include the object size in the length
|
|
* so we add it in here
|
|
*/
|
|
ret_buffer->length += sizeof(union acpi_object);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_esimple_to_isimple
|
|
*
|
|
* PARAMETERS: external_object - The external object to be converted
|
|
* ret_internal_object - Where the internal object is returned
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: This function copies an external object to an internal one.
|
|
* NOTE: Pointers can be copied, we don't need to copy data.
|
|
* (The pointers have to be valid in our address space no matter
|
|
* what we do with them!)
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
|
|
union acpi_operand_object **ret_internal_object)
|
|
{
|
|
union acpi_operand_object *internal_object;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_esimple_to_isimple);
|
|
|
|
/*
|
|
* Simple types supported are: String, Buffer, Integer
|
|
*/
|
|
switch (external_object->type) {
|
|
case ACPI_TYPE_STRING:
|
|
case ACPI_TYPE_BUFFER:
|
|
case ACPI_TYPE_INTEGER:
|
|
case ACPI_TYPE_LOCAL_REFERENCE:
|
|
|
|
internal_object = acpi_ut_create_internal_object((u8)
|
|
external_object->
|
|
type);
|
|
if (!internal_object) {
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
break;
|
|
|
|
case ACPI_TYPE_ANY: /* This is the case for a NULL object */
|
|
|
|
*ret_internal_object = NULL;
|
|
return_ACPI_STATUS(AE_OK);
|
|
|
|
default:
|
|
|
|
/* All other types are not supported */
|
|
|
|
ACPI_ERROR((AE_INFO,
|
|
"Unsupported object type, cannot convert to internal object: %s",
|
|
acpi_ut_get_type_name(external_object->type)));
|
|
|
|
return_ACPI_STATUS(AE_SUPPORT);
|
|
}
|
|
|
|
/* Must COPY string and buffer contents */
|
|
|
|
switch (external_object->type) {
|
|
case ACPI_TYPE_STRING:
|
|
|
|
internal_object->string.pointer =
|
|
ACPI_ALLOCATE_ZEROED((acpi_size)
|
|
external_object->string.length + 1);
|
|
|
|
if (!internal_object->string.pointer) {
|
|
goto error_exit;
|
|
}
|
|
|
|
memcpy(internal_object->string.pointer,
|
|
external_object->string.pointer,
|
|
external_object->string.length);
|
|
|
|
internal_object->string.length = external_object->string.length;
|
|
break;
|
|
|
|
case ACPI_TYPE_BUFFER:
|
|
|
|
internal_object->buffer.pointer =
|
|
ACPI_ALLOCATE_ZEROED(external_object->buffer.length);
|
|
if (!internal_object->buffer.pointer) {
|
|
goto error_exit;
|
|
}
|
|
|
|
memcpy(internal_object->buffer.pointer,
|
|
external_object->buffer.pointer,
|
|
external_object->buffer.length);
|
|
|
|
internal_object->buffer.length = external_object->buffer.length;
|
|
|
|
/* Mark buffer data valid */
|
|
|
|
internal_object->buffer.flags |= AOPOBJ_DATA_VALID;
|
|
break;
|
|
|
|
case ACPI_TYPE_INTEGER:
|
|
|
|
internal_object->integer.value = external_object->integer.value;
|
|
break;
|
|
|
|
case ACPI_TYPE_LOCAL_REFERENCE:
|
|
|
|
/* An incoming reference is defined to be a namespace node */
|
|
|
|
internal_object->reference.class = ACPI_REFCLASS_REFOF;
|
|
internal_object->reference.object =
|
|
external_object->reference.handle;
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Other types can't get here */
|
|
|
|
break;
|
|
}
|
|
|
|
*ret_internal_object = internal_object;
|
|
return_ACPI_STATUS(AE_OK);
|
|
|
|
error_exit:
|
|
acpi_ut_remove_reference(internal_object);
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_epackage_to_ipackage
|
|
*
|
|
* PARAMETERS: external_object - The external object to be converted
|
|
* internal_object - Where the internal object is returned
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Copy an external package object to an internal package.
|
|
* Handles nested packages.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_epackage_to_ipackage(union acpi_object *external_object,
|
|
union acpi_operand_object **internal_object)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
union acpi_operand_object *package_object;
|
|
union acpi_operand_object **package_elements;
|
|
u32 i;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_epackage_to_ipackage);
|
|
|
|
/* Create the package object */
|
|
|
|
package_object =
|
|
acpi_ut_create_package_object(external_object->package.count);
|
|
if (!package_object) {
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
|
|
package_elements = package_object->package.elements;
|
|
|
|
/*
|
|
* Recursive implementation. Probably ok, since nested external
|
|
* packages as parameters should be very rare.
|
|
*/
|
|
for (i = 0; i < external_object->package.count; i++) {
|
|
status =
|
|
acpi_ut_copy_eobject_to_iobject(&external_object->package.
|
|
elements[i],
|
|
&package_elements[i]);
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
/* Truncate package and delete it */
|
|
|
|
package_object->package.count = i;
|
|
package_elements[i] = NULL;
|
|
acpi_ut_remove_reference(package_object);
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
}
|
|
|
|
/* Mark package data valid */
|
|
|
|
package_object->package.flags |= AOPOBJ_DATA_VALID;
|
|
|
|
*internal_object = package_object;
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_eobject_to_iobject
|
|
*
|
|
* PARAMETERS: external_object - The external object to be converted
|
|
* internal_object - Where the internal object is returned
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Converts an external object to an internal object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status
|
|
acpi_ut_copy_eobject_to_iobject(union acpi_object *external_object,
|
|
union acpi_operand_object **internal_object)
|
|
{
|
|
acpi_status status;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_eobject_to_iobject);
|
|
|
|
if (external_object->type == ACPI_TYPE_PACKAGE) {
|
|
status =
|
|
acpi_ut_copy_epackage_to_ipackage(external_object,
|
|
internal_object);
|
|
} else {
|
|
/*
|
|
* Build a simple object (no nested objects)
|
|
*/
|
|
status = acpi_ut_copy_esimple_to_isimple(external_object,
|
|
internal_object);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_simple_object
|
|
*
|
|
* PARAMETERS: source_desc - The internal object to be copied
|
|
* dest_desc - New target object
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Simple copy of one internal object to another. Reference count
|
|
* of the destination object is preserved.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
|
|
union acpi_operand_object *dest_desc)
|
|
{
|
|
u16 reference_count;
|
|
union acpi_operand_object *next_object;
|
|
acpi_status status;
|
|
acpi_size copy_size;
|
|
|
|
/* Save fields from destination that we don't want to overwrite */
|
|
|
|
reference_count = dest_desc->common.reference_count;
|
|
next_object = dest_desc->common.next_object;
|
|
|
|
/*
|
|
* Copy the entire source object over the destination object.
|
|
* Note: Source can be either an operand object or namespace node.
|
|
*/
|
|
copy_size = sizeof(union acpi_operand_object);
|
|
if (ACPI_GET_DESCRIPTOR_TYPE(source_desc) == ACPI_DESC_TYPE_NAMED) {
|
|
copy_size = sizeof(struct acpi_namespace_node);
|
|
}
|
|
|
|
memcpy(ACPI_CAST_PTR(char, dest_desc),
|
|
ACPI_CAST_PTR(char, source_desc), copy_size);
|
|
|
|
/* Restore the saved fields */
|
|
|
|
dest_desc->common.reference_count = reference_count;
|
|
dest_desc->common.next_object = next_object;
|
|
|
|
/* New object is not static, regardless of source */
|
|
|
|
dest_desc->common.flags &= ~AOPOBJ_STATIC_POINTER;
|
|
|
|
/* Handle the objects with extra data */
|
|
|
|
switch (dest_desc->common.type) {
|
|
case ACPI_TYPE_BUFFER:
|
|
/*
|
|
* Allocate and copy the actual buffer if and only if:
|
|
* 1) There is a valid buffer pointer
|
|
* 2) The buffer has a length > 0
|
|
*/
|
|
if ((source_desc->buffer.pointer) &&
|
|
(source_desc->buffer.length)) {
|
|
dest_desc->buffer.pointer =
|
|
ACPI_ALLOCATE(source_desc->buffer.length);
|
|
if (!dest_desc->buffer.pointer) {
|
|
return (AE_NO_MEMORY);
|
|
}
|
|
|
|
/* Copy the actual buffer data */
|
|
|
|
memcpy(dest_desc->buffer.pointer,
|
|
source_desc->buffer.pointer,
|
|
source_desc->buffer.length);
|
|
}
|
|
break;
|
|
|
|
case ACPI_TYPE_STRING:
|
|
/*
|
|
* Allocate and copy the actual string if and only if:
|
|
* 1) There is a valid string pointer
|
|
* (Pointer to a NULL string is allowed)
|
|
*/
|
|
if (source_desc->string.pointer) {
|
|
dest_desc->string.pointer =
|
|
ACPI_ALLOCATE((acpi_size)source_desc->string.
|
|
length + 1);
|
|
if (!dest_desc->string.pointer) {
|
|
return (AE_NO_MEMORY);
|
|
}
|
|
|
|
/* Copy the actual string data */
|
|
|
|
memcpy(dest_desc->string.pointer,
|
|
source_desc->string.pointer,
|
|
(acpi_size)source_desc->string.length + 1);
|
|
}
|
|
break;
|
|
|
|
case ACPI_TYPE_LOCAL_REFERENCE:
|
|
/*
|
|
* We copied the reference object, so we now must add a reference
|
|
* to the object pointed to by the reference
|
|
*
|
|
* DDBHandle reference (from Load/load_table) is a special reference,
|
|
* it does not have a Reference.Object, so does not need to
|
|
* increase the reference count
|
|
*/
|
|
if (source_desc->reference.class == ACPI_REFCLASS_TABLE) {
|
|
break;
|
|
}
|
|
|
|
acpi_ut_add_reference(source_desc->reference.object);
|
|
break;
|
|
|
|
case ACPI_TYPE_REGION:
|
|
/*
|
|
* We copied the Region Handler, so we now must add a reference
|
|
*/
|
|
if (dest_desc->region.handler) {
|
|
acpi_ut_add_reference(dest_desc->region.handler);
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* For Mutex and Event objects, we cannot simply copy the underlying
|
|
* OS object. We must create a new one.
|
|
*/
|
|
case ACPI_TYPE_MUTEX:
|
|
|
|
status = acpi_os_create_mutex(&dest_desc->mutex.os_mutex);
|
|
if (ACPI_FAILURE(status)) {
|
|
return (status);
|
|
}
|
|
break;
|
|
|
|
case ACPI_TYPE_EVENT:
|
|
|
|
status = acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0,
|
|
&dest_desc->event.
|
|
os_semaphore);
|
|
if (ACPI_FAILURE(status)) {
|
|
return (status);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Nothing to do for other simple objects */
|
|
|
|
break;
|
|
}
|
|
|
|
return (AE_OK);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_ielement_to_ielement
|
|
*
|
|
* PARAMETERS: acpi_pkg_callback
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Copy one package element to another package element
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ielement_to_ielement(u8 object_type,
|
|
union acpi_operand_object *source_object,
|
|
union acpi_generic_state *state,
|
|
void *context)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
u32 this_index;
|
|
union acpi_operand_object **this_target_ptr;
|
|
union acpi_operand_object *target_object;
|
|
|
|
ACPI_FUNCTION_ENTRY();
|
|
|
|
this_index = state->pkg.index;
|
|
this_target_ptr = (union acpi_operand_object **)
|
|
&state->pkg.dest_object->package.elements[this_index];
|
|
|
|
switch (object_type) {
|
|
case ACPI_COPY_TYPE_SIMPLE:
|
|
|
|
/* A null source object indicates a (legal) null package element */
|
|
|
|
if (source_object) {
|
|
/*
|
|
* This is a simple object, just copy it
|
|
*/
|
|
target_object =
|
|
acpi_ut_create_internal_object(source_object->
|
|
common.type);
|
|
if (!target_object) {
|
|
return (AE_NO_MEMORY);
|
|
}
|
|
|
|
status =
|
|
acpi_ut_copy_simple_object(source_object,
|
|
target_object);
|
|
if (ACPI_FAILURE(status)) {
|
|
goto error_exit;
|
|
}
|
|
|
|
*this_target_ptr = target_object;
|
|
} else {
|
|
/* Pass through a null element */
|
|
|
|
*this_target_ptr = NULL;
|
|
}
|
|
break;
|
|
|
|
case ACPI_COPY_TYPE_PACKAGE:
|
|
/*
|
|
* This object is a package - go down another nesting level
|
|
* Create and build the package object
|
|
*/
|
|
target_object =
|
|
acpi_ut_create_package_object(source_object->package.count);
|
|
if (!target_object) {
|
|
return (AE_NO_MEMORY);
|
|
}
|
|
|
|
target_object->common.flags = source_object->common.flags;
|
|
|
|
/* Pass the new package object back to the package walk routine */
|
|
|
|
state->pkg.this_target_obj = target_object;
|
|
|
|
/* Store the object pointer in the parent package object */
|
|
|
|
*this_target_ptr = target_object;
|
|
break;
|
|
|
|
default:
|
|
|
|
return (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
return (status);
|
|
|
|
error_exit:
|
|
acpi_ut_remove_reference(target_object);
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_ipackage_to_ipackage
|
|
*
|
|
* PARAMETERS: source_obj - Pointer to the source package object
|
|
* dest_obj - Where the internal object is returned
|
|
* walk_state - Current Walk state descriptor
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: This function is called to copy an internal package object
|
|
* into another internal package object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
|
|
union acpi_operand_object *dest_obj,
|
|
struct acpi_walk_state *walk_state)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_ipackage_to_ipackage);
|
|
|
|
dest_obj->common.type = source_obj->common.type;
|
|
dest_obj->common.flags = source_obj->common.flags;
|
|
dest_obj->package.count = source_obj->package.count;
|
|
|
|
/*
|
|
* Create the object array and walk the source package tree
|
|
*/
|
|
dest_obj->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
|
|
source_obj->package.
|
|
count +
|
|
1) * sizeof(void *));
|
|
if (!dest_obj->package.elements) {
|
|
ACPI_ERROR((AE_INFO, "Package allocation failure"));
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
|
|
/*
|
|
* Copy the package element-by-element by walking the package "tree".
|
|
* This handles nested packages of arbitrary depth.
|
|
*/
|
|
status = acpi_ut_walk_package_tree(source_obj, dest_obj,
|
|
acpi_ut_copy_ielement_to_ielement,
|
|
walk_state);
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
/* On failure, delete the destination package object */
|
|
|
|
acpi_ut_remove_reference(dest_obj);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_copy_iobject_to_iobject
|
|
*
|
|
* PARAMETERS: source_desc - The internal object to be copied
|
|
* dest_desc - Where the copied object is returned
|
|
* walk_state - Current walk state
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Copy an internal object to a new internal object
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status
|
|
acpi_ut_copy_iobject_to_iobject(union acpi_operand_object *source_desc,
|
|
union acpi_operand_object **dest_desc,
|
|
struct acpi_walk_state *walk_state)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_copy_iobject_to_iobject);
|
|
|
|
/* Create the top level object */
|
|
|
|
*dest_desc = acpi_ut_create_internal_object(source_desc->common.type);
|
|
if (!*dest_desc) {
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
|
|
/* Copy the object and possible subobjects */
|
|
|
|
if (source_desc->common.type == ACPI_TYPE_PACKAGE) {
|
|
status =
|
|
acpi_ut_copy_ipackage_to_ipackage(source_desc, *dest_desc,
|
|
walk_state);
|
|
} else {
|
|
status = acpi_ut_copy_simple_object(source_desc, *dest_desc);
|
|
}
|
|
|
|
/* Delete the allocated object if copy failed */
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
acpi_ut_remove_reference(*dest_desc);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|