Branch data Line data Source code
1 : : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 : : /******************************************************************************
3 : : *
4 : : * Module Name: utobject - ACPI object create/delete/size/cache routines
5 : : *
6 : : * Copyright (C) 2000 - 2020, Intel Corp.
7 : : *
8 : : *****************************************************************************/
9 : :
10 : : #include <acpi/acpi.h>
11 : : #include <linux/kmemleak.h>
12 : : #include "accommon.h"
13 : : #include "acnamesp.h"
14 : :
15 : : #define _COMPONENT ACPI_UTILITIES
16 : : ACPI_MODULE_NAME("utobject")
17 : :
18 : : /* Local prototypes */
19 : : static acpi_status
20 : : acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
21 : : acpi_size *obj_length);
22 : :
23 : : static acpi_status
24 : : acpi_ut_get_package_object_size(union acpi_operand_object *obj,
25 : : acpi_size *obj_length);
26 : :
27 : : static acpi_status
28 : : acpi_ut_get_element_length(u8 object_type,
29 : : union acpi_operand_object *source_object,
30 : : union acpi_generic_state *state, void *context);
31 : :
32 : : /*******************************************************************************
33 : : *
34 : : * FUNCTION: acpi_ut_create_internal_object_dbg
35 : : *
36 : : * PARAMETERS: module_name - Source file name of caller
37 : : * line_number - Line number of caller
38 : : * component_id - Component type of caller
39 : : * type - ACPI Type of the new object
40 : : *
41 : : * RETURN: A new internal object, null on failure
42 : : *
43 : : * DESCRIPTION: Create and initialize a new internal object.
44 : : *
45 : : * NOTE: We always allocate the worst-case object descriptor because
46 : : * these objects are cached, and we want them to be
47 : : * one-size-satisifies-any-request. This in itself may not be
48 : : * the most memory efficient, but the efficiency of the object
49 : : * cache should more than make up for this!
50 : : *
51 : : ******************************************************************************/
52 : :
53 : 1276407 : union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
54 : : *module_name,
55 : : u32 line_number,
56 : : u32 component_id,
57 : : acpi_object_type
58 : : type)
59 : : {
60 : 1276407 : union acpi_operand_object *object;
61 : 1276407 : union acpi_operand_object *second_object;
62 : :
63 : : ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
64 : 1276407 : acpi_ut_get_type_name(type));
65 : :
66 : : /* Allocate the raw object descriptor */
67 : :
68 : 1276407 : object =
69 : 1276407 : acpi_ut_allocate_object_desc_dbg(module_name, line_number,
70 : : component_id);
71 [ + - ]: 1276407 : if (!object) {
72 : : return_PTR(NULL);
73 : : }
74 [ + + ]: 1276407 : kmemleak_not_leak(object);
75 : :
76 [ + + ]: 1276407 : switch (type) {
77 : 1404 : case ACPI_TYPE_REGION:
78 : : case ACPI_TYPE_BUFFER_FIELD:
79 : : case ACPI_TYPE_LOCAL_BANK_FIELD:
80 : :
81 : : /* These types require a secondary object */
82 : :
83 : 1404 : second_object =
84 : 1404 : acpi_ut_allocate_object_desc_dbg(module_name, line_number,
85 : : component_id);
86 [ - + ]: 1404 : if (!second_object) {
87 : 0 : acpi_ut_delete_object_desc(object);
88 : 0 : return_PTR(NULL);
89 : : }
90 : :
91 : 1404 : second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
92 : 1404 : second_object->common.reference_count = 1;
93 : :
94 : : /* Link the second object to the first */
95 : :
96 : 1404 : object->common.next_object = second_object;
97 : 1404 : break;
98 : :
99 : : default:
100 : :
101 : : /* All others have no secondary object */
102 : : break;
103 : : }
104 : :
105 : : /* Save the object type in the object descriptor */
106 : :
107 : 1276407 : object->common.type = (u8) type;
108 : :
109 : : /* Init the reference count */
110 : :
111 : 1276407 : object->common.reference_count = 1;
112 : :
113 : : /* Any per-type initialization should go here */
114 : :
115 : 1276407 : return_PTR(object);
116 : : }
117 : :
118 : : /*******************************************************************************
119 : : *
120 : : * FUNCTION: acpi_ut_create_package_object
121 : : *
122 : : * PARAMETERS: count - Number of package elements
123 : : *
124 : : * RETURN: Pointer to a new Package object, null on failure
125 : : *
126 : : * DESCRIPTION: Create a fully initialized package object
127 : : *
128 : : ******************************************************************************/
129 : :
130 : 1092 : union acpi_operand_object *acpi_ut_create_package_object(u32 count)
131 : : {
132 : 1092 : union acpi_operand_object *package_desc;
133 : 1092 : union acpi_operand_object **package_elements;
134 : :
135 : 1092 : ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
136 : :
137 : : /* Create a new Package object */
138 : :
139 : 1092 : package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
140 [ + - ]: 1092 : if (!package_desc) {
141 : : return_PTR(NULL);
142 : : }
143 : :
144 : : /*
145 : : * Create the element array. Count+1 allows the array to be null
146 : : * terminated.
147 : : */
148 : 1092 : package_elements = ACPI_ALLOCATE_ZEROED(((acpi_size)count +
149 : : 1) * sizeof(void *));
150 [ - + ]: 1092 : if (!package_elements) {
151 : 0 : ACPI_FREE(package_desc);
152 : 0 : return_PTR(NULL);
153 : : }
154 : :
155 : 1092 : package_desc->package.count = count;
156 : 1092 : package_desc->package.elements = package_elements;
157 : 1092 : return_PTR(package_desc);
158 : : }
159 : :
160 : : /*******************************************************************************
161 : : *
162 : : * FUNCTION: acpi_ut_create_integer_object
163 : : *
164 : : * PARAMETERS: initial_value - Initial value for the integer
165 : : *
166 : : * RETURN: Pointer to a new Integer object, null on failure
167 : : *
168 : : * DESCRIPTION: Create an initialized integer object
169 : : *
170 : : ******************************************************************************/
171 : :
172 : 9795 : union acpi_operand_object *acpi_ut_create_integer_object(u64 initial_value)
173 : : {
174 : 9795 : union acpi_operand_object *integer_desc;
175 : :
176 : 9795 : ACPI_FUNCTION_TRACE(ut_create_integer_object);
177 : :
178 : : /* Create and initialize a new integer object */
179 : :
180 : 9795 : integer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
181 [ + - ]: 9795 : if (!integer_desc) {
182 : : return_PTR(NULL);
183 : : }
184 : :
185 : 9795 : integer_desc->integer.value = initial_value;
186 : 9795 : return_PTR(integer_desc);
187 : : }
188 : :
189 : : /*******************************************************************************
190 : : *
191 : : * FUNCTION: acpi_ut_create_buffer_object
192 : : *
193 : : * PARAMETERS: buffer_size - Size of buffer to be created
194 : : *
195 : : * RETURN: Pointer to a new Buffer object, null on failure
196 : : *
197 : : * DESCRIPTION: Create a fully initialized buffer object
198 : : *
199 : : ******************************************************************************/
200 : :
201 : 0 : union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
202 : : {
203 : 0 : union acpi_operand_object *buffer_desc;
204 : 0 : u8 *buffer = NULL;
205 : :
206 : 0 : ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
207 : :
208 : : /* Create a new Buffer object */
209 : :
210 : 0 : buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
211 [ # # ]: 0 : if (!buffer_desc) {
212 : : return_PTR(NULL);
213 : : }
214 : :
215 : : /* Create an actual buffer only if size > 0 */
216 : :
217 [ # # ]: 0 : if (buffer_size > 0) {
218 : :
219 : : /* Allocate the actual buffer */
220 : :
221 : 0 : buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
222 [ # # ]: 0 : if (!buffer) {
223 : 0 : ACPI_ERROR((AE_INFO, "Could not allocate size %u",
224 : : (u32)buffer_size));
225 : :
226 : 0 : acpi_ut_remove_reference(buffer_desc);
227 : 0 : return_PTR(NULL);
228 : : }
229 : : }
230 : :
231 : : /* Complete buffer object initialization */
232 : :
233 : 0 : buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
234 : 0 : buffer_desc->buffer.pointer = buffer;
235 : 0 : buffer_desc->buffer.length = (u32) buffer_size;
236 : :
237 : : /* Return the new buffer descriptor */
238 : :
239 : 0 : return_PTR(buffer_desc);
240 : : }
241 : :
242 : : /*******************************************************************************
243 : : *
244 : : * FUNCTION: acpi_ut_create_string_object
245 : : *
246 : : * PARAMETERS: string_size - Size of string to be created. Does not
247 : : * include NULL terminator, this is added
248 : : * automatically.
249 : : *
250 : : * RETURN: Pointer to a new String object
251 : : *
252 : : * DESCRIPTION: Create a fully initialized string object
253 : : *
254 : : ******************************************************************************/
255 : :
256 : 1560 : union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
257 : : {
258 : 1560 : union acpi_operand_object *string_desc;
259 : 1560 : char *string;
260 : :
261 : 1560 : ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
262 : :
263 : : /* Create a new String object */
264 : :
265 : 1560 : string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
266 [ + - ]: 1560 : if (!string_desc) {
267 : : return_PTR(NULL);
268 : : }
269 : :
270 : : /*
271 : : * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
272 : : * NOTE: Zero-length strings are NULL terminated
273 : : */
274 : 1560 : string = ACPI_ALLOCATE_ZEROED(string_size + 1);
275 [ - + ]: 1560 : if (!string) {
276 : 0 : ACPI_ERROR((AE_INFO, "Could not allocate size %u",
277 : : (u32)string_size));
278 : :
279 : 0 : acpi_ut_remove_reference(string_desc);
280 : 0 : return_PTR(NULL);
281 : : }
282 : :
283 : : /* Complete string object initialization */
284 : :
285 : 1560 : string_desc->string.pointer = string;
286 : 1560 : string_desc->string.length = (u32) string_size;
287 : :
288 : : /* Return the new string descriptor */
289 : :
290 : 1560 : return_PTR(string_desc);
291 : : }
292 : :
293 : : /*******************************************************************************
294 : : *
295 : : * FUNCTION: acpi_ut_valid_internal_object
296 : : *
297 : : * PARAMETERS: object - Object to be validated
298 : : *
299 : : * RETURN: TRUE if object is valid, FALSE otherwise
300 : : *
301 : : * DESCRIPTION: Validate a pointer to be of type union acpi_operand_object
302 : : *
303 : : ******************************************************************************/
304 : :
305 : 2735187 : u8 acpi_ut_valid_internal_object(void *object)
306 : : {
307 : :
308 : 2735187 : ACPI_FUNCTION_NAME(ut_valid_internal_object);
309 : :
310 : : /* Check for a null pointer */
311 : :
312 [ + + ]: 2735187 : if (!object) {
313 : : ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "**** Null Object Ptr\n"));
314 : : return (FALSE);
315 : : }
316 : :
317 : : /* Check the descriptor type field */
318 : :
319 [ - + ]: 2703699 : switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
320 : : case ACPI_DESC_TYPE_OPERAND:
321 : :
322 : : /* The object appears to be a valid union acpi_operand_object */
323 : :
324 : : return (TRUE);
325 : :
326 : : default:
327 : :
328 : : ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
329 : : "%p is not an ACPI operand obj [%s]\n",
330 : 0 : object, acpi_ut_get_descriptor_name(object)));
331 : 0 : break;
332 : : }
333 : :
334 : 0 : return (FALSE);
335 : : }
336 : :
337 : : /*******************************************************************************
338 : : *
339 : : * FUNCTION: acpi_ut_allocate_object_desc_dbg
340 : : *
341 : : * PARAMETERS: module_name - Caller's module name (for error output)
342 : : * line_number - Caller's line number (for error output)
343 : : * component_id - Caller's component ID (for error output)
344 : : *
345 : : * RETURN: Pointer to newly allocated object descriptor. Null on error
346 : : *
347 : : * DESCRIPTION: Allocate a new object descriptor. Gracefully handle
348 : : * error conditions.
349 : : *
350 : : ******************************************************************************/
351 : :
352 : 1277811 : void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
353 : : u32 line_number, u32 component_id)
354 : : {
355 : 1277811 : union acpi_operand_object *object;
356 : :
357 : 1277811 : ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
358 : :
359 : 1277811 : object = acpi_os_acquire_object(acpi_gbl_operand_cache);
360 [ - + ]: 1277811 : if (!object) {
361 : 0 : ACPI_ERROR((module_name, line_number,
362 : : "Could not allocate an object descriptor"));
363 : :
364 : 0 : return_PTR(NULL);
365 : : }
366 : :
367 : : /* Mark the descriptor type */
368 : :
369 : 1277811 : ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
370 : :
371 : : ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
372 : 1277811 : object, (u32) sizeof(union acpi_operand_object)));
373 : :
374 : 1277811 : return_PTR(object);
375 : : }
376 : :
377 : : /*******************************************************************************
378 : : *
379 : : * FUNCTION: acpi_ut_delete_object_desc
380 : : *
381 : : * PARAMETERS: object - An Acpi internal object to be deleted
382 : : *
383 : : * RETURN: None.
384 : : *
385 : : * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
386 : : *
387 : : ******************************************************************************/
388 : :
389 : 1249731 : void acpi_ut_delete_object_desc(union acpi_operand_object *object)
390 : : {
391 : 1249731 : ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
392 : :
393 : : /* Object must be of type union acpi_operand_object */
394 : :
395 [ - + ]: 1249731 : if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
396 : 0 : ACPI_ERROR((AE_INFO,
397 : : "%p is not an ACPI Operand object [%s]", object,
398 : : acpi_ut_get_descriptor_name(object)));
399 : 0 : return_VOID;
400 : : }
401 : :
402 : 1249731 : (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
403 : 1249731 : return_VOID;
404 : : }
405 : :
406 : : /*******************************************************************************
407 : : *
408 : : * FUNCTION: acpi_ut_get_simple_object_size
409 : : *
410 : : * PARAMETERS: internal_object - An ACPI operand object
411 : : * obj_length - Where the length is returned
412 : : *
413 : : * RETURN: Status
414 : : *
415 : : * DESCRIPTION: This function is called to determine the space required to
416 : : * contain a simple object for return to an external user.
417 : : *
418 : : * The length includes the object structure plus any additional
419 : : * needed space.
420 : : *
421 : : ******************************************************************************/
422 : :
423 : : static acpi_status
424 : 26754 : acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
425 : : acpi_size *obj_length)
426 : : {
427 : 26754 : acpi_size length;
428 : 26754 : acpi_size size;
429 : 26754 : acpi_status status = AE_OK;
430 : :
431 : 26754 : ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
432 : :
433 : : /* Start with the length of the (external) Acpi object */
434 : :
435 : 26754 : length = sizeof(union acpi_object);
436 : :
437 : : /* A NULL object is allowed, can be a legal uninitialized package element */
438 : :
439 [ - + ]: 26754 : if (!internal_object) {
440 : : /*
441 : : * Object is NULL, just return the length of union acpi_object
442 : : * (A NULL union acpi_object is an object of all zeroes.)
443 : : */
444 : 0 : *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
445 : 0 : return_ACPI_STATUS(AE_OK);
446 : : }
447 : :
448 : : /* A Namespace Node should never appear here */
449 : :
450 [ - + ]: 26754 : if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
451 : :
452 : : /* A namespace node should never get here */
453 : :
454 : 0 : ACPI_ERROR((AE_INFO,
455 : : "Received a namespace node [%4.4s] "
456 : : "where an operand object is required",
457 : : ACPI_CAST_PTR(struct acpi_namespace_node,
458 : : internal_object)->name.ascii));
459 : 0 : return_ACPI_STATUS(AE_AML_INTERNAL);
460 : : }
461 : :
462 : : /*
463 : : * The final length depends on the object type
464 : : * Strings and Buffers are packed right up against the parent object and
465 : : * must be accessed bytewise or there may be alignment problems on
466 : : * certain processors
467 : : */
468 [ - + - - : 26754 : switch (internal_object->common.type) {
+ ]
469 : 0 : case ACPI_TYPE_STRING:
470 : :
471 : 0 : length += (acpi_size)internal_object->string.length + 1;
472 : 0 : break;
473 : :
474 : 156 : case ACPI_TYPE_BUFFER:
475 : :
476 : 156 : length += (acpi_size)internal_object->buffer.length;
477 : 156 : break;
478 : :
479 : : case ACPI_TYPE_INTEGER:
480 : : case ACPI_TYPE_PROCESSOR:
481 : : case ACPI_TYPE_POWER:
482 : :
483 : : /* No extra data for these types */
484 : :
485 : : break;
486 : :
487 : 0 : case ACPI_TYPE_LOCAL_REFERENCE:
488 : :
489 [ # # ]: 0 : switch (internal_object->reference.class) {
490 : 0 : case ACPI_REFCLASS_NAME:
491 : : /*
492 : : * Get the actual length of the full pathname to this object.
493 : : * The reference will be converted to the pathname to the object
494 : : */
495 : 0 : size =
496 : 0 : acpi_ns_get_pathname_length(internal_object->
497 : : reference.node);
498 [ # # ]: 0 : if (!size) {
499 : : return_ACPI_STATUS(AE_BAD_PARAMETER);
500 : : }
501 : :
502 : 0 : length += ACPI_ROUND_UP_TO_NATIVE_WORD(size);
503 : 0 : break;
504 : :
505 : 0 : default:
506 : : /*
507 : : * No other reference opcodes are supported.
508 : : * Notably, Locals and Args are not supported, but this may be
509 : : * required eventually.
510 : : */
511 : 0 : ACPI_ERROR((AE_INFO,
512 : : "Cannot convert to external object - "
513 : : "unsupported Reference Class [%s] 0x%X in object %p",
514 : : acpi_ut_get_reference_name(internal_object),
515 : : internal_object->reference.class,
516 : : internal_object));
517 : 0 : status = AE_TYPE;
518 : 0 : break;
519 : : }
520 : : break;
521 : :
522 : 0 : default:
523 : :
524 : 0 : ACPI_ERROR((AE_INFO, "Cannot convert to external object - "
525 : : "unsupported type [%s] 0x%X in object %p",
526 : : acpi_ut_get_object_type_name(internal_object),
527 : : internal_object->common.type, internal_object));
528 : 0 : status = AE_TYPE;
529 : 0 : break;
530 : : }
531 : :
532 : : /*
533 : : * Account for the space required by the object rounded up to the next
534 : : * multiple of the machine word size. This keeps each object aligned
535 : : * on a machine word boundary. (preventing alignment faults on some
536 : : * machines.)
537 : : */
538 : 26754 : *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
539 : 26754 : return_ACPI_STATUS(status);
540 : : }
541 : :
542 : : /*******************************************************************************
543 : : *
544 : : * FUNCTION: acpi_ut_get_element_length
545 : : *
546 : : * PARAMETERS: acpi_pkg_callback
547 : : *
548 : : * RETURN: Status
549 : : *
550 : : * DESCRIPTION: Get the length of one package element.
551 : : *
552 : : ******************************************************************************/
553 : :
554 : : static acpi_status
555 : 0 : acpi_ut_get_element_length(u8 object_type,
556 : : union acpi_operand_object *source_object,
557 : : union acpi_generic_state *state, void *context)
558 : : {
559 : 0 : acpi_status status = AE_OK;
560 : 0 : struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
561 : 0 : acpi_size object_space;
562 : :
563 [ # # # ]: 0 : switch (object_type) {
564 : 0 : case ACPI_COPY_TYPE_SIMPLE:
565 : : /*
566 : : * Simple object - just get the size (Null object/entry is handled
567 : : * here also) and sum it into the running package length
568 : : */
569 : 0 : status =
570 : 0 : acpi_ut_get_simple_object_size(source_object,
571 : : &object_space);
572 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
573 : : return (status);
574 : : }
575 : :
576 : 0 : info->length += object_space;
577 : 0 : break;
578 : :
579 : 0 : case ACPI_COPY_TYPE_PACKAGE:
580 : :
581 : : /* Package object - nothing much to do here, let the walk handle it */
582 : :
583 : 0 : info->num_packages++;
584 : 0 : state->pkg.this_target_obj = NULL;
585 : 0 : break;
586 : :
587 : : default:
588 : :
589 : : /* No other types allowed */
590 : :
591 : : return (AE_BAD_PARAMETER);
592 : : }
593 : :
594 : : return (status);
595 : : }
596 : :
597 : : /*******************************************************************************
598 : : *
599 : : * FUNCTION: acpi_ut_get_package_object_size
600 : : *
601 : : * PARAMETERS: internal_object - An ACPI internal object
602 : : * obj_length - Where the length is returned
603 : : *
604 : : * RETURN: Status
605 : : *
606 : : * DESCRIPTION: This function is called to determine the space required to
607 : : * contain a package object for return to an external user.
608 : : *
609 : : * This is moderately complex since a package contains other
610 : : * objects including packages.
611 : : *
612 : : ******************************************************************************/
613 : :
614 : : static acpi_status
615 : 0 : acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
616 : : acpi_size *obj_length)
617 : : {
618 : 0 : acpi_status status;
619 : 0 : struct acpi_pkg_info info;
620 : :
621 : 0 : ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
622 : :
623 : 0 : info.length = 0;
624 : 0 : info.object_space = 0;
625 : 0 : info.num_packages = 1;
626 : :
627 : 0 : status =
628 : 0 : acpi_ut_walk_package_tree(internal_object, NULL,
629 : : acpi_ut_get_element_length, &info);
630 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
631 : : return_ACPI_STATUS(status);
632 : : }
633 : :
634 : : /*
635 : : * We have handled all of the objects in all levels of the package.
636 : : * just add the length of the package objects themselves.
637 : : * Round up to the next machine word.
638 : : */
639 : 0 : info.length +=
640 : 0 : ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
641 : 0 : (acpi_size)info.num_packages;
642 : :
643 : : /* Return the total package length */
644 : :
645 : 0 : *obj_length = info.length;
646 : 0 : return_ACPI_STATUS(status);
647 : : }
648 : :
649 : : /*******************************************************************************
650 : : *
651 : : * FUNCTION: acpi_ut_get_object_size
652 : : *
653 : : * PARAMETERS: internal_object - An ACPI internal object
654 : : * obj_length - Where the length will be returned
655 : : *
656 : : * RETURN: Status
657 : : *
658 : : * DESCRIPTION: This function is called to determine the space required to
659 : : * contain an object for return to an API user.
660 : : *
661 : : ******************************************************************************/
662 : :
663 : : acpi_status
664 : 26754 : acpi_ut_get_object_size(union acpi_operand_object *internal_object,
665 : : acpi_size *obj_length)
666 : : {
667 : 26754 : acpi_status status;
668 : :
669 : 26754 : ACPI_FUNCTION_ENTRY();
670 : :
671 [ + - ]: 26754 : if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
672 : 26754 : ACPI_DESC_TYPE_OPERAND) &&
673 [ - + ]: 26754 : (internal_object->common.type == ACPI_TYPE_PACKAGE)) {
674 : 0 : status =
675 : 0 : acpi_ut_get_package_object_size(internal_object,
676 : : obj_length);
677 : : } else {
678 : 26754 : status =
679 : 26754 : acpi_ut_get_simple_object_size(internal_object, obj_length);
680 : : }
681 : :
682 : 26754 : return (status);
683 : : }
|
