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 - 2018, 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 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 union acpi_operand_object *object; 61 union acpi_operand_object *second_object; 62 63 ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg, 64 acpi_ut_get_type_name(type)); 65 66 /* Allocate the raw object descriptor */ 67 68 object = 69 acpi_ut_allocate_object_desc_dbg(module_name, line_number, 70 component_id); 71 if (!object) { 72 return_PTR(NULL); 73 } 74 kmemleak_not_leak(object); 75 76 switch (type) { 77 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 second_object = 84 acpi_ut_allocate_object_desc_dbg(module_name, line_number, 85 component_id); 86 if (!second_object) { 87 acpi_ut_delete_object_desc(object); 88 return_PTR(NULL); 89 } 90 91 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA; 92 second_object->common.reference_count = 1; 93 94 /* Link the second object to the first */ 95 96 object->common.next_object = second_object; 97 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 object->common.type = (u8) type; 108 109 /* Init the reference count */ 110 111 object->common.reference_count = 1; 112 113 /* Any per-type initialization should go here */ 114 115 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 union acpi_operand_object *acpi_ut_create_package_object(u32 count) 131 { 132 union acpi_operand_object *package_desc; 133 union acpi_operand_object **package_elements; 134 135 ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count); 136 137 /* Create a new Package object */ 138 139 package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE); 140 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 package_elements = ACPI_ALLOCATE_ZEROED(((acpi_size)count + 149 1) * sizeof(void *)); 150 if (!package_elements) { 151 ACPI_FREE(package_desc); 152 return_PTR(NULL); 153 } 154 155 package_desc->package.count = count; 156 package_desc->package.elements = package_elements; 157 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 union acpi_operand_object *acpi_ut_create_integer_object(u64 initial_value) 173 { 174 union acpi_operand_object *integer_desc; 175 176 ACPI_FUNCTION_TRACE(ut_create_integer_object); 177 178 /* Create and initialize a new integer object */ 179 180 integer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 181 if (!integer_desc) { 182 return_PTR(NULL); 183 } 184 185 integer_desc->integer.value = initial_value; 186 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 union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size) 202 { 203 union acpi_operand_object *buffer_desc; 204 u8 *buffer = NULL; 205 206 ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size); 207 208 /* Create a new Buffer object */ 209 210 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER); 211 if (!buffer_desc) { 212 return_PTR(NULL); 213 } 214 215 /* Create an actual buffer only if size > 0 */ 216 217 if (buffer_size > 0) { 218 219 /* Allocate the actual buffer */ 220 221 buffer = ACPI_ALLOCATE_ZEROED(buffer_size); 222 if (!buffer) { 223 ACPI_ERROR((AE_INFO, "Could not allocate size %u", 224 (u32)buffer_size)); 225 226 acpi_ut_remove_reference(buffer_desc); 227 return_PTR(NULL); 228 } 229 } 230 231 /* Complete buffer object initialization */ 232 233 buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID; 234 buffer_desc->buffer.pointer = buffer; 235 buffer_desc->buffer.length = (u32) buffer_size; 236 237 /* Return the new buffer descriptor */ 238 239 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 union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size) 257 { 258 union acpi_operand_object *string_desc; 259 char *string; 260 261 ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size); 262 263 /* Create a new String object */ 264 265 string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING); 266 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 string = ACPI_ALLOCATE_ZEROED(string_size + 1); 275 if (!string) { 276 ACPI_ERROR((AE_INFO, "Could not allocate size %u", 277 (u32)string_size)); 278 279 acpi_ut_remove_reference(string_desc); 280 return_PTR(NULL); 281 } 282 283 /* Complete string object initialization */ 284 285 string_desc->string.pointer = string; 286 string_desc->string.length = (u32) string_size; 287 288 /* Return the new string descriptor */ 289 290 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 u8 acpi_ut_valid_internal_object(void *object) 306 { 307 308 ACPI_FUNCTION_NAME(ut_valid_internal_object); 309 310 /* Check for a null pointer */ 311 312 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 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 object, acpi_ut_get_descriptor_name(object))); 331 break; 332 } 333 334 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 void *acpi_ut_allocate_object_desc_dbg(const char *module_name, 353 u32 line_number, u32 component_id) 354 { 355 union acpi_operand_object *object; 356 357 ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg); 358 359 object = acpi_os_acquire_object(acpi_gbl_operand_cache); 360 if (!object) { 361 ACPI_ERROR((module_name, line_number, 362 "Could not allocate an object descriptor")); 363 364 return_PTR(NULL); 365 } 366 367 /* Mark the descriptor type */ 368 369 ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND); 370 371 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n", 372 object, (u32) sizeof(union acpi_operand_object))); 373 374 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 void acpi_ut_delete_object_desc(union acpi_operand_object *object) 390 { 391 ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object); 392 393 /* Object must be of type union acpi_operand_object */ 394 395 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) { 396 ACPI_ERROR((AE_INFO, 397 "%p is not an ACPI Operand object [%s]", object, 398 acpi_ut_get_descriptor_name(object))); 399 return_VOID; 400 } 401 402 (void)acpi_os_release_object(acpi_gbl_operand_cache, object); 403 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 acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object, 425 acpi_size *obj_length) 426 { 427 acpi_size length; 428 acpi_size size; 429 acpi_status status = AE_OK; 430 431 ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object); 432 433 /* Start with the length of the (external) Acpi object */ 434 435 length = sizeof(union acpi_object); 436 437 /* A NULL object is allowed, can be a legal uninitialized package element */ 438 439 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 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length); 445 return_ACPI_STATUS(AE_OK); 446 } 447 448 /* A Namespace Node should never appear here */ 449 450 if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) { 451 452 /* A namespace node should never get here */ 453 454 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 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 switch (internal_object->common.type) { 469 case ACPI_TYPE_STRING: 470 471 length += (acpi_size)internal_object->string.length + 1; 472 break; 473 474 case ACPI_TYPE_BUFFER: 475 476 length += (acpi_size)internal_object->buffer.length; 477 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 case ACPI_TYPE_LOCAL_REFERENCE: 488 489 switch (internal_object->reference.class) { 490 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 size = 496 acpi_ns_get_pathname_length(internal_object-> 497 reference.node); 498 if (!size) { 499 return_ACPI_STATUS(AE_BAD_PARAMETER); 500 } 501 502 length += ACPI_ROUND_UP_TO_NATIVE_WORD(size); 503 break; 504 505 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 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 status = AE_TYPE; 518 break; 519 } 520 break; 521 522 default: 523 524 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 status = AE_TYPE; 529 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 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length); 539 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 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 acpi_status status = AE_OK; 560 struct acpi_pkg_info *info = (struct acpi_pkg_info *)context; 561 acpi_size object_space; 562 563 switch (object_type) { 564 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 status = 570 acpi_ut_get_simple_object_size(source_object, 571 &object_space); 572 if (ACPI_FAILURE(status)) { 573 return (status); 574 } 575 576 info->length += object_space; 577 break; 578 579 case ACPI_COPY_TYPE_PACKAGE: 580 581 /* Package object - nothing much to do here, let the walk handle it */ 582 583 info->num_packages++; 584 state->pkg.this_target_obj = NULL; 585 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 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object, 616 acpi_size *obj_length) 617 { 618 acpi_status status; 619 struct acpi_pkg_info info; 620 621 ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object); 622 623 info.length = 0; 624 info.object_space = 0; 625 info.num_packages = 1; 626 627 status = 628 acpi_ut_walk_package_tree(internal_object, NULL, 629 acpi_ut_get_element_length, &info); 630 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 info.length += 640 ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) * 641 (acpi_size)info.num_packages; 642 643 /* Return the total package length */ 644 645 *obj_length = info.length; 646 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 acpi_ut_get_object_size(union acpi_operand_object *internal_object, 665 acpi_size *obj_length) 666 { 667 acpi_status status; 668 669 ACPI_FUNCTION_ENTRY(); 670 671 if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) == 672 ACPI_DESC_TYPE_OPERAND) && 673 (internal_object->common.type == ACPI_TYPE_PACKAGE)) { 674 status = 675 acpi_ut_get_package_object_size(internal_object, 676 obj_length); 677 } else { 678 status = 679 acpi_ut_get_simple_object_size(internal_object, obj_length); 680 } 681 682 return (status); 683 } 684