1/****************************************************************************** 2 * 3 * Module Name: nspredef - Validation of ACPI predefined methods and objects 4 * $Revision: 1.1 $ 5 * 6 *****************************************************************************/ 7 8/* 9 * Copyright (C) 2000 - 2012, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45#define ACPI_CREATE_PREDEFINED_TABLE 46 47#include <acpi/acpi.h> 48#include "accommon.h" 49#include "acnamesp.h" 50#include "acpredef.h" 51 52#define _COMPONENT ACPI_NAMESPACE 53ACPI_MODULE_NAME("nspredef") 54 55/******************************************************************************* 56 * 57 * This module validates predefined ACPI objects that appear in the namespace, 58 * at the time they are evaluated (via acpi_evaluate_object). The purpose of this 59 * validation is to detect problems with BIOS-exposed predefined ACPI objects 60 * before the results are returned to the ACPI-related drivers. 61 * 62 * There are several areas that are validated: 63 * 64 * 1) The number of input arguments as defined by the method/object in the 65 * ASL is validated against the ACPI specification. 66 * 2) The type of the return object (if any) is validated against the ACPI 67 * specification. 68 * 3) For returned package objects, the count of package elements is 69 * validated, as well as the type of each package element. Nested 70 * packages are supported. 71 * 72 * For any problems found, a warning message is issued. 73 * 74 ******************************************************************************/ 75/* Local prototypes */ 76static acpi_status 77acpi_ns_check_package(struct acpi_predefined_data *data, 78 union acpi_operand_object **return_object_ptr); 79 80static acpi_status 81acpi_ns_check_package_list(struct acpi_predefined_data *data, 82 const union acpi_predefined_info *package, 83 union acpi_operand_object **elements, u32 count); 84 85static acpi_status 86acpi_ns_check_package_elements(struct acpi_predefined_data *data, 87 union acpi_operand_object **elements, 88 u8 type1, 89 u32 count1, 90 u8 type2, u32 count2, u32 start_index); 91 92static acpi_status 93acpi_ns_check_object_type(struct acpi_predefined_data *data, 94 union acpi_operand_object **return_object_ptr, 95 u32 expected_btypes, u32 package_index); 96 97static acpi_status 98acpi_ns_check_reference(struct acpi_predefined_data *data, 99 union acpi_operand_object *return_object); 100 101static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes); 102 103/* 104 * Names for the types that can be returned by the predefined objects. 105 * Used for warning messages. Must be in the same order as the ACPI_RTYPEs 106 */ 107static const char *acpi_rtype_names[] = { 108 "/Integer", 109 "/String", 110 "/Buffer", 111 "/Package", 112 "/Reference", 113}; 114 115/******************************************************************************* 116 * 117 * FUNCTION: acpi_ns_check_predefined_names 118 * 119 * PARAMETERS: Node - Namespace node for the method/object 120 * user_param_count - Number of parameters actually passed 121 * return_status - Status from the object evaluation 122 * return_object_ptr - Pointer to the object returned from the 123 * evaluation of a method or object 124 * 125 * RETURN: Status 126 * 127 * DESCRIPTION: Check an ACPI name for a match in the predefined name list. 128 * 129 ******************************************************************************/ 130 131acpi_status 132acpi_ns_check_predefined_names(struct acpi_namespace_node *node, 133 u32 user_param_count, 134 acpi_status return_status, 135 union acpi_operand_object **return_object_ptr) 136{ 137 union acpi_operand_object *return_object = *return_object_ptr; 138 acpi_status status = AE_OK; 139 const union acpi_predefined_info *predefined; 140 char *pathname; 141 struct acpi_predefined_data *data; 142 143 /* Match the name for this method/object against the predefined list */ 144 145 predefined = acpi_ns_check_for_predefined_name(node); 146 147 /* Get the full pathname to the object, for use in warning messages */ 148 149 pathname = acpi_ns_get_external_pathname(node); 150 if (!pathname) { 151 return AE_OK; /* Could not get pathname, ignore */ 152 } 153 154 /* 155 * Check that the parameter count for this method matches the ASL 156 * definition. For predefined names, ensure that both the caller and 157 * the method itself are in accordance with the ACPI specification. 158 */ 159 acpi_ns_check_parameter_count(pathname, node, user_param_count, 160 predefined); 161 162 /* If not a predefined name, we cannot validate the return object */ 163 164 if (!predefined) { 165 goto cleanup; 166 } 167 168 /* 169 * If the method failed or did not actually return an object, we cannot 170 * validate the return object 171 */ 172 if ((return_status != AE_OK) && (return_status != AE_CTRL_RETURN_VALUE)) { 173 goto cleanup; 174 } 175 176 /* 177 * If there is no return value, check if we require a return value for 178 * this predefined name. Either one return value is expected, or none, 179 * for both methods and other objects. 180 * 181 * Exit now if there is no return object. Warning if one was expected. 182 */ 183 if (!return_object) { 184 if ((predefined->info.expected_btypes) && 185 (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) { 186 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 187 ACPI_WARN_ALWAYS, 188 "Missing expected return value")); 189 190 status = AE_AML_NO_RETURN_VALUE; 191 } 192 goto cleanup; 193 } 194 195 /* 196 * Return value validation and possible repair. 197 * 198 * 1) Don't perform return value validation/repair if this feature 199 * has been disabled via a global option. 200 * 201 * 2) We have a return value, but if one wasn't expected, just exit, 202 * this is not a problem. For example, if the "Implicit Return" 203 * feature is enabled, methods will always return a value. 204 * 205 * 3) If the return value can be of any type, then we cannot perform 206 * any validation, just exit. 207 */ 208 if (acpi_gbl_disable_auto_repair || 209 (!predefined->info.expected_btypes) || 210 (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) { 211 goto cleanup; 212 } 213 214 /* Create the parameter data block for object validation */ 215 216 data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data)); 217 if (!data) { 218 goto cleanup; 219 } 220 data->predefined = predefined; 221 data->node = node; 222 data->node_flags = node->flags; 223 data->pathname = pathname; 224 225 /* 226 * Check that the type of the main return object is what is expected 227 * for this predefined name 228 */ 229 status = acpi_ns_check_object_type(data, return_object_ptr, 230 predefined->info.expected_btypes, 231 ACPI_NOT_PACKAGE_ELEMENT); 232 if (ACPI_FAILURE(status)) { 233 goto exit; 234 } 235 236 /* 237 * For returned Package objects, check the type of all sub-objects. 238 * Note: Package may have been newly created by call above. 239 */ 240 if ((*return_object_ptr)->common.type == ACPI_TYPE_PACKAGE) { 241 data->parent_package = *return_object_ptr; 242 status = acpi_ns_check_package(data, return_object_ptr); 243 if (ACPI_FAILURE(status)) { 244 goto exit; 245 } 246 } 247 248 /* 249 * The return object was OK, or it was successfully repaired above. 250 * Now make some additional checks such as verifying that package 251 * objects are sorted correctly (if required) or buffer objects have 252 * the correct data width (bytes vs. dwords). These repairs are 253 * performed on a per-name basis, i.e., the code is specific to 254 * particular predefined names. 255 */ 256 status = acpi_ns_complex_repairs(data, node, status, return_object_ptr); 257 258exit: 259 /* 260 * If the object validation failed or if we successfully repaired one 261 * or more objects, mark the parent node to suppress further warning 262 * messages during the next evaluation of the same method/object. 263 */ 264 if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) { 265 node->flags |= ANOBJ_EVALUATED; 266 } 267 ACPI_FREE(data); 268 269cleanup: 270 ACPI_FREE(pathname); 271 return (status); 272} 273 274/******************************************************************************* 275 * 276 * FUNCTION: acpi_ns_check_parameter_count 277 * 278 * PARAMETERS: Pathname - Full pathname to the node (for error msgs) 279 * Node - Namespace node for the method/object 280 * user_param_count - Number of args passed in by the caller 281 * Predefined - Pointer to entry in predefined name table 282 * 283 * RETURN: None 284 * 285 * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a 286 * predefined name is what is expected (i.e., what is defined in 287 * the ACPI specification for this predefined name.) 288 * 289 ******************************************************************************/ 290 291void 292acpi_ns_check_parameter_count(char *pathname, 293 struct acpi_namespace_node *node, 294 u32 user_param_count, 295 const union acpi_predefined_info *predefined) 296{ 297 u32 param_count; 298 u32 required_params_current; 299 u32 required_params_old; 300 301 /* Methods have 0-7 parameters. All other types have zero. */ 302 303 param_count = 0; 304 if (node->type == ACPI_TYPE_METHOD) { 305 param_count = node->object->method.param_count; 306 } 307 308 if (!predefined) { 309 /* 310 * Check the parameter count for non-predefined methods/objects. 311 * 312 * Warning if too few or too many arguments have been passed by the 313 * caller. An incorrect number of arguments may not cause the method 314 * to fail. However, the method will fail if there are too few 315 * arguments and the method attempts to use one of the missing ones. 316 */ 317 if (user_param_count < param_count) { 318 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 319 ACPI_WARN_ALWAYS, 320 "Insufficient arguments - needs %u, found %u", 321 param_count, user_param_count)); 322 } else if (user_param_count > param_count) { 323 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 324 ACPI_WARN_ALWAYS, 325 "Excess arguments - needs %u, found %u", 326 param_count, user_param_count)); 327 } 328 return; 329 } 330 331 /* 332 * Validate the user-supplied parameter count. 333 * Allow two different legal argument counts (_SCP, etc.) 334 */ 335 required_params_current = predefined->info.param_count & 0x0F; 336 required_params_old = predefined->info.param_count >> 4; 337 338 if (user_param_count != ACPI_UINT32_MAX) { 339 if ((user_param_count != required_params_current) && 340 (user_param_count != required_params_old)) { 341 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 342 ACPI_WARN_ALWAYS, 343 "Parameter count mismatch - " 344 "caller passed %u, ACPI requires %u", 345 user_param_count, 346 required_params_current)); 347 } 348 } 349 350 /* 351 * Check that the ASL-defined parameter count is what is expected for 352 * this predefined name (parameter count as defined by the ACPI 353 * specification) 354 */ 355 if ((param_count != required_params_current) && 356 (param_count != required_params_old)) { 357 ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags, 358 "Parameter count mismatch - ASL declared %u, ACPI requires %u", 359 param_count, required_params_current)); 360 } 361} 362 363/******************************************************************************* 364 * 365 * FUNCTION: acpi_ns_check_for_predefined_name 366 * 367 * PARAMETERS: Node - Namespace node for the method/object 368 * 369 * RETURN: Pointer to entry in predefined table. NULL indicates not found. 370 * 371 * DESCRIPTION: Check an object name against the predefined object list. 372 * 373 ******************************************************************************/ 374 375const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct 376 acpi_namespace_node 377 *node) 378{ 379 const union acpi_predefined_info *this_name; 380 381 /* Quick check for a predefined name, first character must be underscore */ 382 383 if (node->name.ascii[0] != '_') { 384 return (NULL); 385 } 386 387 /* Search info table for a predefined method/object name */ 388 389 this_name = predefined_names; 390 while (this_name->info.name[0]) { 391 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) { 392 return (this_name); 393 } 394 395 /* 396 * Skip next entry in the table if this name returns a Package 397 * (next entry contains the package info) 398 */ 399 if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) { 400 this_name++; 401 } 402 403 this_name++; 404 } 405 406 return (NULL); /* Not found */ 407} 408 409/******************************************************************************* 410 * 411 * FUNCTION: acpi_ns_check_package 412 * 413 * PARAMETERS: Data - Pointer to validation data structure 414 * return_object_ptr - Pointer to the object returned from the 415 * evaluation of a method or object 416 * 417 * RETURN: Status 418 * 419 * DESCRIPTION: Check a returned package object for the correct count and 420 * correct type of all sub-objects. 421 * 422 ******************************************************************************/ 423 424static acpi_status 425acpi_ns_check_package(struct acpi_predefined_data *data, 426 union acpi_operand_object **return_object_ptr) 427{ 428 union acpi_operand_object *return_object = *return_object_ptr; 429 const union acpi_predefined_info *package; 430 union acpi_operand_object **elements; 431 acpi_status status = AE_OK; 432 u32 expected_count; 433 u32 count; 434 u32 i; 435 436 ACPI_FUNCTION_NAME(ns_check_package); 437 438 /* The package info for this name is in the next table entry */ 439 440 package = data->predefined + 1; 441 442 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 443 "%s Validating return Package of Type %X, Count %X\n", 444 data->pathname, package->ret_info.type, 445 return_object->package.count)); 446 447 /* 448 * For variable-length Packages, we can safely remove all embedded 449 * and trailing NULL package elements 450 */ 451 acpi_ns_remove_null_elements(data, package->ret_info.type, 452 return_object); 453 454 /* Extract package count and elements array */ 455 456 elements = return_object->package.elements; 457 count = return_object->package.count; 458 459 /* The package must have at least one element, else invalid */ 460 461 if (!count) { 462 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 463 "Return Package has no elements (empty)")); 464 465 return (AE_AML_OPERAND_VALUE); 466 } 467 468 /* 469 * Decode the type of the expected package contents 470 * 471 * PTYPE1 packages contain no subpackages 472 * PTYPE2 packages contain sub-packages 473 */ 474 switch (package->ret_info.type) { 475 case ACPI_PTYPE1_FIXED: 476 477 /* 478 * The package count is fixed and there are no sub-packages 479 * 480 * If package is too small, exit. 481 * If package is larger than expected, issue warning but continue 482 */ 483 expected_count = 484 package->ret_info.count1 + package->ret_info.count2; 485 if (count < expected_count) { 486 goto package_too_small; 487 } else if (count > expected_count) { 488 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, 489 "%s: Return Package is larger than needed - " 490 "found %u, expected %u\n", 491 data->pathname, count, 492 expected_count)); 493 } 494 495 /* Validate all elements of the returned package */ 496 497 status = acpi_ns_check_package_elements(data, elements, 498 package->ret_info. 499 object_type1, 500 package->ret_info. 501 count1, 502 package->ret_info. 503 object_type2, 504 package->ret_info. 505 count2, 0); 506 break; 507 508 case ACPI_PTYPE1_VAR: 509 510 /* 511 * The package count is variable, there are no sub-packages, and all 512 * elements must be of the same type 513 */ 514 for (i = 0; i < count; i++) { 515 status = acpi_ns_check_object_type(data, elements, 516 package->ret_info. 517 object_type1, i); 518 if (ACPI_FAILURE(status)) { 519 return (status); 520 } 521 elements++; 522 } 523 break; 524 525 case ACPI_PTYPE1_OPTION: 526 527 /* 528 * The package count is variable, there are no sub-packages. There are 529 * a fixed number of required elements, and a variable number of 530 * optional elements. 531 * 532 * Check if package is at least as large as the minimum required 533 */ 534 expected_count = package->ret_info3.count; 535 if (count < expected_count) { 536 goto package_too_small; 537 } 538 539 /* Variable number of sub-objects */ 540 541 for (i = 0; i < count; i++) { 542 if (i < package->ret_info3.count) { 543 544 /* These are the required package elements (0, 1, or 2) */ 545 546 status = 547 acpi_ns_check_object_type(data, elements, 548 package-> 549 ret_info3. 550 object_type[i], 551 i); 552 if (ACPI_FAILURE(status)) { 553 return (status); 554 } 555 } else { 556 /* These are the optional package elements */ 557 558 status = 559 acpi_ns_check_object_type(data, elements, 560 package-> 561 ret_info3. 562 tail_object_type, 563 i); 564 if (ACPI_FAILURE(status)) { 565 return (status); 566 } 567 } 568 elements++; 569 } 570 break; 571 572 case ACPI_PTYPE2_REV_FIXED: 573 574 /* First element is the (Integer) revision */ 575 576 status = acpi_ns_check_object_type(data, elements, 577 ACPI_RTYPE_INTEGER, 0); 578 if (ACPI_FAILURE(status)) { 579 return (status); 580 } 581 582 elements++; 583 count--; 584 585 /* Examine the sub-packages */ 586 587 status = 588 acpi_ns_check_package_list(data, package, elements, count); 589 break; 590 591 case ACPI_PTYPE2_PKG_COUNT: 592 593 /* First element is the (Integer) count of sub-packages to follow */ 594 595 status = acpi_ns_check_object_type(data, elements, 596 ACPI_RTYPE_INTEGER, 0); 597 if (ACPI_FAILURE(status)) { 598 return (status); 599 } 600 601 /* 602 * Count cannot be larger than the parent package length, but allow it 603 * to be smaller. The >= accounts for the Integer above. 604 */ 605 expected_count = (u32) (*elements)->integer.value; 606 if (expected_count >= count) { 607 goto package_too_small; 608 } 609 610 count = expected_count; 611 elements++; 612 613 /* Examine the sub-packages */ 614 615 status = 616 acpi_ns_check_package_list(data, package, elements, count); 617 break; 618 619 case ACPI_PTYPE2: 620 case ACPI_PTYPE2_FIXED: 621 case ACPI_PTYPE2_MIN: 622 case ACPI_PTYPE2_COUNT: 623 case ACPI_PTYPE2_FIX_VAR: 624 625 /* 626 * These types all return a single Package that consists of a 627 * variable number of sub-Packages. 628 * 629 * First, ensure that the first element is a sub-Package. If not, 630 * the BIOS may have incorrectly returned the object as a single 631 * package instead of a Package of Packages (a common error if 632 * there is only one entry). We may be able to repair this by 633 * wrapping the returned Package with a new outer Package. 634 */ 635 if (*elements 636 && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) { 637 638 /* Create the new outer package and populate it */ 639 640 status = 641 acpi_ns_wrap_with_package(data, *elements, 642 return_object_ptr); 643 if (ACPI_FAILURE(status)) { 644 return (status); 645 } 646 647 /* Update locals to point to the new package (of 1 element) */ 648 649 return_object = *return_object_ptr; 650 elements = return_object->package.elements; 651 count = 1; 652 } 653 654 /* Examine the sub-packages */ 655 656 status = 657 acpi_ns_check_package_list(data, package, elements, count); 658 break; 659 660 default: 661 662 /* Should not get here if predefined info table is correct */ 663 664 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 665 "Invalid internal return type in table entry: %X", 666 package->ret_info.type)); 667 668 return (AE_AML_INTERNAL); 669 } 670 671 return (status); 672 673package_too_small: 674 675 /* Error exit for the case with an incorrect package count */ 676 677 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 678 "Return Package is too small - found %u elements, expected %u", 679 count, expected_count)); 680 681 return (AE_AML_OPERAND_VALUE); 682} 683 684/******************************************************************************* 685 * 686 * FUNCTION: acpi_ns_check_package_list 687 * 688 * PARAMETERS: Data - Pointer to validation data structure 689 * Package - Pointer to package-specific info for method 690 * Elements - Element list of parent package. All elements 691 * of this list should be of type Package. 692 * Count - Count of subpackages 693 * 694 * RETURN: Status 695 * 696 * DESCRIPTION: Examine a list of subpackages 697 * 698 ******************************************************************************/ 699 700static acpi_status 701acpi_ns_check_package_list(struct acpi_predefined_data *data, 702 const union acpi_predefined_info *package, 703 union acpi_operand_object **elements, u32 count) 704{ 705 union acpi_operand_object *sub_package; 706 union acpi_operand_object **sub_elements; 707 acpi_status status; 708 u32 expected_count; 709 u32 i; 710 u32 j; 711 712 /* 713 * Validate each sub-Package in the parent Package 714 * 715 * NOTE: assumes list of sub-packages contains no NULL elements. 716 * Any NULL elements should have been removed by earlier call 717 * to acpi_ns_remove_null_elements. 718 */ 719 for (i = 0; i < count; i++) { 720 sub_package = *elements; 721 sub_elements = sub_package->package.elements; 722 data->parent_package = sub_package; 723 724 /* Each sub-object must be of type Package */ 725 726 status = acpi_ns_check_object_type(data, &sub_package, 727 ACPI_RTYPE_PACKAGE, i); 728 if (ACPI_FAILURE(status)) { 729 return (status); 730 } 731 732 /* Examine the different types of expected sub-packages */ 733 734 data->parent_package = sub_package; 735 switch (package->ret_info.type) { 736 case ACPI_PTYPE2: 737 case ACPI_PTYPE2_PKG_COUNT: 738 case ACPI_PTYPE2_REV_FIXED: 739 740 /* Each subpackage has a fixed number of elements */ 741 742 expected_count = 743 package->ret_info.count1 + package->ret_info.count2; 744 if (sub_package->package.count < expected_count) { 745 goto package_too_small; 746 } 747 748 status = 749 acpi_ns_check_package_elements(data, sub_elements, 750 package->ret_info. 751 object_type1, 752 package->ret_info. 753 count1, 754 package->ret_info. 755 object_type2, 756 package->ret_info. 757 count2, 0); 758 if (ACPI_FAILURE(status)) { 759 return (status); 760 } 761 break; 762 763 case ACPI_PTYPE2_FIX_VAR: 764 /* 765 * Each subpackage has a fixed number of elements and an 766 * optional element 767 */ 768 expected_count = 769 package->ret_info.count1 + package->ret_info.count2; 770 if (sub_package->package.count < expected_count) { 771 goto package_too_small; 772 } 773 774 status = 775 acpi_ns_check_package_elements(data, sub_elements, 776 package->ret_info. 777 object_type1, 778 package->ret_info. 779 count1, 780 package->ret_info. 781 object_type2, 782 sub_package->package. 783 count - 784 package->ret_info. 785 count1, 0); 786 if (ACPI_FAILURE(status)) { 787 return (status); 788 } 789 break; 790 791 case ACPI_PTYPE2_FIXED: 792 793 /* Each sub-package has a fixed length */ 794 795 expected_count = package->ret_info2.count; 796 if (sub_package->package.count < expected_count) { 797 goto package_too_small; 798 } 799 800 /* Check the type of each sub-package element */ 801 802 for (j = 0; j < expected_count; j++) { 803 status = 804 acpi_ns_check_object_type(data, 805 &sub_elements[j], 806 package-> 807 ret_info2. 808 object_type[j], 809 j); 810 if (ACPI_FAILURE(status)) { 811 return (status); 812 } 813 } 814 break; 815 816 case ACPI_PTYPE2_MIN: 817 818 /* Each sub-package has a variable but minimum length */ 819 820 expected_count = package->ret_info.count1; 821 if (sub_package->package.count < expected_count) { 822 goto package_too_small; 823 } 824 825 /* Check the type of each sub-package element */ 826 827 status = 828 acpi_ns_check_package_elements(data, sub_elements, 829 package->ret_info. 830 object_type1, 831 sub_package->package. 832 count, 0, 0, 0); 833 if (ACPI_FAILURE(status)) { 834 return (status); 835 } 836 break; 837 838 case ACPI_PTYPE2_COUNT: 839 840 /* 841 * First element is the (Integer) count of elements, including 842 * the count field (the ACPI name is num_elements) 843 */ 844 status = acpi_ns_check_object_type(data, sub_elements, 845 ACPI_RTYPE_INTEGER, 846 0); 847 if (ACPI_FAILURE(status)) { 848 return (status); 849 } 850 851 /* 852 * Make sure package is large enough for the Count and is 853 * is as large as the minimum size 854 */ 855 expected_count = (u32)(*sub_elements)->integer.value; 856 if (sub_package->package.count < expected_count) { 857 goto package_too_small; 858 } 859 if (sub_package->package.count < 860 package->ret_info.count1) { 861 expected_count = package->ret_info.count1; 862 goto package_too_small; 863 } 864 if (expected_count == 0) { 865 /* 866 * Either the num_entries element was originally zero or it was 867 * a NULL element and repaired to an Integer of value zero. 868 * In either case, repair it by setting num_entries to be the 869 * actual size of the subpackage. 870 */ 871 expected_count = sub_package->package.count; 872 (*sub_elements)->integer.value = expected_count; 873 } 874 875 /* Check the type of each sub-package element */ 876 877 status = 878 acpi_ns_check_package_elements(data, 879 (sub_elements + 1), 880 package->ret_info. 881 object_type1, 882 (expected_count - 1), 883 0, 0, 1); 884 if (ACPI_FAILURE(status)) { 885 return (status); 886 } 887 break; 888 889 default: /* Should not get here, type was validated by caller */ 890 891 return (AE_AML_INTERNAL); 892 } 893 894 elements++; 895 } 896 897 return (AE_OK); 898 899package_too_small: 900 901 /* The sub-package count was smaller than required */ 902 903 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 904 "Return Sub-Package[%u] is too small - found %u elements, expected %u", 905 i, sub_package->package.count, expected_count)); 906 907 return (AE_AML_OPERAND_VALUE); 908} 909 910/******************************************************************************* 911 * 912 * FUNCTION: acpi_ns_check_package_elements 913 * 914 * PARAMETERS: Data - Pointer to validation data structure 915 * Elements - Pointer to the package elements array 916 * Type1 - Object type for first group 917 * Count1 - Count for first group 918 * Type2 - Object type for second group 919 * Count2 - Count for second group 920 * start_index - Start of the first group of elements 921 * 922 * RETURN: Status 923 * 924 * DESCRIPTION: Check that all elements of a package are of the correct object 925 * type. Supports up to two groups of different object types. 926 * 927 ******************************************************************************/ 928 929static acpi_status 930acpi_ns_check_package_elements(struct acpi_predefined_data *data, 931 union acpi_operand_object **elements, 932 u8 type1, 933 u32 count1, 934 u8 type2, u32 count2, u32 start_index) 935{ 936 union acpi_operand_object **this_element = elements; 937 acpi_status status; 938 u32 i; 939 940 /* 941 * Up to two groups of package elements are supported by the data 942 * structure. All elements in each group must be of the same type. 943 * The second group can have a count of zero. 944 */ 945 for (i = 0; i < count1; i++) { 946 status = acpi_ns_check_object_type(data, this_element, 947 type1, i + start_index); 948 if (ACPI_FAILURE(status)) { 949 return (status); 950 } 951 this_element++; 952 } 953 954 for (i = 0; i < count2; i++) { 955 status = acpi_ns_check_object_type(data, this_element, 956 type2, 957 (i + count1 + start_index)); 958 if (ACPI_FAILURE(status)) { 959 return (status); 960 } 961 this_element++; 962 } 963 964 return (AE_OK); 965} 966 967/******************************************************************************* 968 * 969 * FUNCTION: acpi_ns_check_object_type 970 * 971 * PARAMETERS: Data - Pointer to validation data structure 972 * return_object_ptr - Pointer to the object returned from the 973 * evaluation of a method or object 974 * expected_btypes - Bitmap of expected return type(s) 975 * package_index - Index of object within parent package (if 976 * applicable - ACPI_NOT_PACKAGE_ELEMENT 977 * otherwise) 978 * 979 * RETURN: Status 980 * 981 * DESCRIPTION: Check the type of the return object against the expected object 982 * type(s). Use of Btype allows multiple expected object types. 983 * 984 ******************************************************************************/ 985 986static acpi_status 987acpi_ns_check_object_type(struct acpi_predefined_data *data, 988 union acpi_operand_object **return_object_ptr, 989 u32 expected_btypes, u32 package_index) 990{ 991 union acpi_operand_object *return_object = *return_object_ptr; 992 acpi_status status = AE_OK; 993 u32 return_btype; 994 char type_buffer[48]; /* Room for 5 types */ 995 996 /* 997 * If we get a NULL return_object here, it is a NULL package element. 998 * Since all extraneous NULL package elements were removed earlier by a 999 * call to acpi_ns_remove_null_elements, this is an unexpected NULL element. 1000 * We will attempt to repair it. 1001 */ 1002 if (!return_object) { 1003 status = acpi_ns_repair_null_element(data, expected_btypes, 1004 package_index, 1005 return_object_ptr); 1006 if (ACPI_SUCCESS(status)) { 1007 return (AE_OK); /* Repair was successful */ 1008 } 1009 goto type_error_exit; 1010 } 1011 1012 /* A Namespace node should not get here, but make sure */ 1013 1014 if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) { 1015 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1016 "Invalid return type - Found a Namespace node [%4.4s] type %s", 1017 return_object->node.name.ascii, 1018 acpi_ut_get_type_name(return_object->node. 1019 type))); 1020 return (AE_AML_OPERAND_TYPE); 1021 } 1022 1023 /* 1024 * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type. 1025 * The bitmapped type allows multiple possible return types. 1026 * 1027 * Note, the cases below must handle all of the possible types returned 1028 * from all of the predefined names (including elements of returned 1029 * packages) 1030 */ 1031 switch (return_object->common.type) { 1032 case ACPI_TYPE_INTEGER: 1033 return_btype = ACPI_RTYPE_INTEGER; 1034 break; 1035 1036 case ACPI_TYPE_BUFFER: 1037 return_btype = ACPI_RTYPE_BUFFER; 1038 break; 1039 1040 case ACPI_TYPE_STRING: 1041 return_btype = ACPI_RTYPE_STRING; 1042 break; 1043 1044 case ACPI_TYPE_PACKAGE: 1045 return_btype = ACPI_RTYPE_PACKAGE; 1046 break; 1047 1048 case ACPI_TYPE_LOCAL_REFERENCE: 1049 return_btype = ACPI_RTYPE_REFERENCE; 1050 break; 1051 1052 default: 1053 /* Not one of the supported objects, must be incorrect */ 1054 1055 goto type_error_exit; 1056 } 1057 1058 /* Is the object one of the expected types? */ 1059 1060 if (return_btype & expected_btypes) { 1061 1062 /* For reference objects, check that the reference type is correct */ 1063 1064 if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) { 1065 status = acpi_ns_check_reference(data, return_object); 1066 } 1067 1068 return (status); 1069 } 1070 1071 /* Type mismatch -- attempt repair of the returned object */ 1072 1073 status = acpi_ns_repair_object(data, expected_btypes, 1074 package_index, return_object_ptr); 1075 if (ACPI_SUCCESS(status)) { 1076 return (AE_OK); /* Repair was successful */ 1077 } 1078 1079 type_error_exit: 1080 1081 /* Create a string with all expected types for this predefined object */ 1082 1083 acpi_ns_get_expected_types(type_buffer, expected_btypes); 1084 1085 if (package_index == ACPI_NOT_PACKAGE_ELEMENT) { 1086 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1087 "Return type mismatch - found %s, expected %s", 1088 acpi_ut_get_object_type_name 1089 (return_object), type_buffer)); 1090 } else { 1091 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1092 "Return Package type mismatch at index %u - " 1093 "found %s, expected %s", package_index, 1094 acpi_ut_get_object_type_name 1095 (return_object), type_buffer)); 1096 } 1097 1098 return (AE_AML_OPERAND_TYPE); 1099} 1100 1101/******************************************************************************* 1102 * 1103 * FUNCTION: acpi_ns_check_reference 1104 * 1105 * PARAMETERS: Data - Pointer to validation data structure 1106 * return_object - Object returned from the evaluation of a 1107 * method or object 1108 * 1109 * RETURN: Status 1110 * 1111 * DESCRIPTION: Check a returned reference object for the correct reference 1112 * type. The only reference type that can be returned from a 1113 * predefined method is a named reference. All others are invalid. 1114 * 1115 ******************************************************************************/ 1116 1117static acpi_status 1118acpi_ns_check_reference(struct acpi_predefined_data *data, 1119 union acpi_operand_object *return_object) 1120{ 1121 1122 /* 1123 * Check the reference object for the correct reference type (opcode). 1124 * The only type of reference that can be converted to an union acpi_object is 1125 * a reference to a named object (reference class: NAME) 1126 */ 1127 if (return_object->reference.class == ACPI_REFCLASS_NAME) { 1128 return (AE_OK); 1129 } 1130 1131 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1132 "Return type mismatch - unexpected reference object type [%s] %2.2X", 1133 acpi_ut_get_reference_name(return_object), 1134 return_object->reference.class)); 1135 1136 return (AE_AML_OPERAND_TYPE); 1137} 1138 1139/******************************************************************************* 1140 * 1141 * FUNCTION: acpi_ns_get_expected_types 1142 * 1143 * PARAMETERS: Buffer - Pointer to where the string is returned 1144 * expected_btypes - Bitmap of expected return type(s) 1145 * 1146 * RETURN: Buffer is populated with type names. 1147 * 1148 * DESCRIPTION: Translate the expected types bitmap into a string of ascii 1149 * names of expected types, for use in warning messages. 1150 * 1151 ******************************************************************************/ 1152 1153static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes) 1154{ 1155 u32 this_rtype; 1156 u32 i; 1157 u32 j; 1158 1159 j = 1; 1160 buffer[0] = 0; 1161 this_rtype = ACPI_RTYPE_INTEGER; 1162 1163 for (i = 0; i < ACPI_NUM_RTYPES; i++) { 1164 1165 /* If one of the expected types, concatenate the name of this type */ 1166 1167 if (expected_btypes & this_rtype) { 1168 ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]); 1169 j = 0; /* Use name separator from now on */ 1170 } 1171 this_rtype <<= 1; /* Next Rtype */ 1172 } 1173} 1174