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 - 2010, 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 * 1) We have a return value, but if one wasn't expected, just exit, this is 197 * not a problem. For example, if the "Implicit Return" feature is 198 * enabled, methods will always return a value. 199 * 200 * 2) If the return value can be of any type, then we cannot perform any 201 * validation, exit. 202 */ 203 if ((!predefined->info.expected_btypes) || 204 (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) { 205 goto cleanup; 206 } 207 208 /* Create the parameter data block for object validation */ 209 210 data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data)); 211 if (!data) { 212 goto cleanup; 213 } 214 data->predefined = predefined; 215 data->node_flags = node->flags; 216 data->pathname = pathname; 217 218 /* 219 * Check that the type of the main return object is what is expected 220 * for this predefined name 221 */ 222 status = acpi_ns_check_object_type(data, return_object_ptr, 223 predefined->info.expected_btypes, 224 ACPI_NOT_PACKAGE_ELEMENT); 225 if (ACPI_FAILURE(status)) { 226 goto exit; 227 } 228 229 /* 230 * For returned Package objects, check the type of all sub-objects. 231 * Note: Package may have been newly created by call above. 232 */ 233 if ((*return_object_ptr)->common.type == ACPI_TYPE_PACKAGE) { 234 data->parent_package = *return_object_ptr; 235 status = acpi_ns_check_package(data, return_object_ptr); 236 if (ACPI_FAILURE(status)) { 237 goto exit; 238 } 239 } 240 241 /* 242 * The return object was OK, or it was successfully repaired above. 243 * Now make some additional checks such as verifying that package 244 * objects are sorted correctly (if required) or buffer objects have 245 * the correct data width (bytes vs. dwords). These repairs are 246 * performed on a per-name basis, i.e., the code is specific to 247 * particular predefined names. 248 */ 249 status = acpi_ns_complex_repairs(data, node, status, return_object_ptr); 250 251exit: 252 /* 253 * If the object validation failed or if we successfully repaired one 254 * or more objects, mark the parent node to suppress further warning 255 * messages during the next evaluation of the same method/object. 256 */ 257 if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) { 258 node->flags |= ANOBJ_EVALUATED; 259 } 260 ACPI_FREE(data); 261 262cleanup: 263 ACPI_FREE(pathname); 264 return (status); 265} 266 267/******************************************************************************* 268 * 269 * FUNCTION: acpi_ns_check_parameter_count 270 * 271 * PARAMETERS: Pathname - Full pathname to the node (for error msgs) 272 * Node - Namespace node for the method/object 273 * user_param_count - Number of args passed in by the caller 274 * Predefined - Pointer to entry in predefined name table 275 * 276 * RETURN: None 277 * 278 * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a 279 * predefined name is what is expected (i.e., what is defined in 280 * the ACPI specification for this predefined name.) 281 * 282 ******************************************************************************/ 283 284void 285acpi_ns_check_parameter_count(char *pathname, 286 struct acpi_namespace_node *node, 287 u32 user_param_count, 288 const union acpi_predefined_info *predefined) 289{ 290 u32 param_count; 291 u32 required_params_current; 292 u32 required_params_old; 293 294 /* Methods have 0-7 parameters. All other types have zero. */ 295 296 param_count = 0; 297 if (node->type == ACPI_TYPE_METHOD) { 298 param_count = node->object->method.param_count; 299 } 300 301 if (!predefined) { 302 /* 303 * Check the parameter count for non-predefined methods/objects. 304 * 305 * Warning if too few or too many arguments have been passed by the 306 * caller. An incorrect number of arguments may not cause the method 307 * to fail. However, the method will fail if there are too few 308 * arguments and the method attempts to use one of the missing ones. 309 */ 310 if (user_param_count < param_count) { 311 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 312 ACPI_WARN_ALWAYS, 313 "Insufficient arguments - needs %u, found %u", 314 param_count, user_param_count)); 315 } else if (user_param_count > param_count) { 316 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 317 ACPI_WARN_ALWAYS, 318 "Excess arguments - needs %u, found %u", 319 param_count, user_param_count)); 320 } 321 return; 322 } 323 324 /* 325 * Validate the user-supplied parameter count. 326 * Allow two different legal argument counts (_SCP, etc.) 327 */ 328 required_params_current = predefined->info.param_count & 0x0F; 329 required_params_old = predefined->info.param_count >> 4; 330 331 if (user_param_count != ACPI_UINT32_MAX) { 332 if ((user_param_count != required_params_current) && 333 (user_param_count != required_params_old)) { 334 ACPI_WARN_PREDEFINED((AE_INFO, pathname, 335 ACPI_WARN_ALWAYS, 336 "Parameter count mismatch - " 337 "caller passed %u, ACPI requires %u", 338 user_param_count, 339 required_params_current)); 340 } 341 } 342 343 /* 344 * Check that the ASL-defined parameter count is what is expected for 345 * this predefined name (parameter count as defined by the ACPI 346 * specification) 347 */ 348 if ((param_count != required_params_current) && 349 (param_count != required_params_old)) { 350 ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags, 351 "Parameter count mismatch - ASL declared %u, ACPI requires %u", 352 param_count, required_params_current)); 353 } 354} 355 356/******************************************************************************* 357 * 358 * FUNCTION: acpi_ns_check_for_predefined_name 359 * 360 * PARAMETERS: Node - Namespace node for the method/object 361 * 362 * RETURN: Pointer to entry in predefined table. NULL indicates not found. 363 * 364 * DESCRIPTION: Check an object name against the predefined object list. 365 * 366 ******************************************************************************/ 367 368const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct 369 acpi_namespace_node 370 *node) 371{ 372 const union acpi_predefined_info *this_name; 373 374 /* Quick check for a predefined name, first character must be underscore */ 375 376 if (node->name.ascii[0] != '_') { 377 return (NULL); 378 } 379 380 /* Search info table for a predefined method/object name */ 381 382 this_name = predefined_names; 383 while (this_name->info.name[0]) { 384 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) { 385 return (this_name); 386 } 387 388 /* 389 * Skip next entry in the table if this name returns a Package 390 * (next entry contains the package info) 391 */ 392 if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) { 393 this_name++; 394 } 395 396 this_name++; 397 } 398 399 return (NULL); /* Not found */ 400} 401 402/******************************************************************************* 403 * 404 * FUNCTION: acpi_ns_check_package 405 * 406 * PARAMETERS: Data - Pointer to validation data structure 407 * return_object_ptr - Pointer to the object returned from the 408 * evaluation of a method or object 409 * 410 * RETURN: Status 411 * 412 * DESCRIPTION: Check a returned package object for the correct count and 413 * correct type of all sub-objects. 414 * 415 ******************************************************************************/ 416 417static acpi_status 418acpi_ns_check_package(struct acpi_predefined_data *data, 419 union acpi_operand_object **return_object_ptr) 420{ 421 union acpi_operand_object *return_object = *return_object_ptr; 422 const union acpi_predefined_info *package; 423 union acpi_operand_object **elements; 424 acpi_status status = AE_OK; 425 u32 expected_count; 426 u32 count; 427 u32 i; 428 429 ACPI_FUNCTION_NAME(ns_check_package); 430 431 /* The package info for this name is in the next table entry */ 432 433 package = data->predefined + 1; 434 435 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 436 "%s Validating return Package of Type %X, Count %X\n", 437 data->pathname, package->ret_info.type, 438 return_object->package.count)); 439 440 /* 441 * For variable-length Packages, we can safely remove all embedded 442 * and trailing NULL package elements 443 */ 444 acpi_ns_remove_null_elements(data, package->ret_info.type, 445 return_object); 446 447 /* Extract package count and elements array */ 448 449 elements = return_object->package.elements; 450 count = return_object->package.count; 451 452 /* The package must have at least one element, else invalid */ 453 454 if (!count) { 455 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 456 "Return Package has no elements (empty)")); 457 458 return (AE_AML_OPERAND_VALUE); 459 } 460 461 /* 462 * Decode the type of the expected package contents 463 * 464 * PTYPE1 packages contain no subpackages 465 * PTYPE2 packages contain sub-packages 466 */ 467 switch (package->ret_info.type) { 468 case ACPI_PTYPE1_FIXED: 469 470 /* 471 * The package count is fixed and there are no sub-packages 472 * 473 * If package is too small, exit. 474 * If package is larger than expected, issue warning but continue 475 */ 476 expected_count = 477 package->ret_info.count1 + package->ret_info.count2; 478 if (count < expected_count) { 479 goto package_too_small; 480 } else if (count > expected_count) { 481 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, 482 "%s: Return Package is larger than needed - " 483 "found %u, expected %u\n", 484 data->pathname, count, 485 expected_count)); 486 } 487 488 /* Validate all elements of the returned package */ 489 490 status = acpi_ns_check_package_elements(data, elements, 491 package->ret_info. 492 object_type1, 493 package->ret_info. 494 count1, 495 package->ret_info. 496 object_type2, 497 package->ret_info. 498 count2, 0); 499 break; 500 501 case ACPI_PTYPE1_VAR: 502 503 /* 504 * The package count is variable, there are no sub-packages, and all 505 * elements must be of the same type 506 */ 507 for (i = 0; i < count; i++) { 508 status = acpi_ns_check_object_type(data, elements, 509 package->ret_info. 510 object_type1, i); 511 if (ACPI_FAILURE(status)) { 512 return (status); 513 } 514 elements++; 515 } 516 break; 517 518 case ACPI_PTYPE1_OPTION: 519 520 /* 521 * The package count is variable, there are no sub-packages. There are 522 * a fixed number of required elements, and a variable number of 523 * optional elements. 524 * 525 * Check if package is at least as large as the minimum required 526 */ 527 expected_count = package->ret_info3.count; 528 if (count < expected_count) { 529 goto package_too_small; 530 } 531 532 /* Variable number of sub-objects */ 533 534 for (i = 0; i < count; i++) { 535 if (i < package->ret_info3.count) { 536 537 /* These are the required package elements (0, 1, or 2) */ 538 539 status = 540 acpi_ns_check_object_type(data, elements, 541 package-> 542 ret_info3. 543 object_type[i], 544 i); 545 if (ACPI_FAILURE(status)) { 546 return (status); 547 } 548 } else { 549 /* These are the optional package elements */ 550 551 status = 552 acpi_ns_check_object_type(data, elements, 553 package-> 554 ret_info3. 555 tail_object_type, 556 i); 557 if (ACPI_FAILURE(status)) { 558 return (status); 559 } 560 } 561 elements++; 562 } 563 break; 564 565 case ACPI_PTYPE2_REV_FIXED: 566 567 /* First element is the (Integer) revision */ 568 569 status = acpi_ns_check_object_type(data, elements, 570 ACPI_RTYPE_INTEGER, 0); 571 if (ACPI_FAILURE(status)) { 572 return (status); 573 } 574 575 elements++; 576 count--; 577 578 /* Examine the sub-packages */ 579 580 status = 581 acpi_ns_check_package_list(data, package, elements, count); 582 break; 583 584 case ACPI_PTYPE2_PKG_COUNT: 585 586 /* First element is the (Integer) count of sub-packages to follow */ 587 588 status = acpi_ns_check_object_type(data, elements, 589 ACPI_RTYPE_INTEGER, 0); 590 if (ACPI_FAILURE(status)) { 591 return (status); 592 } 593 594 /* 595 * Count cannot be larger than the parent package length, but allow it 596 * to be smaller. The >= accounts for the Integer above. 597 */ 598 expected_count = (u32) (*elements)->integer.value; 599 if (expected_count >= count) { 600 goto package_too_small; 601 } 602 603 count = expected_count; 604 elements++; 605 606 /* Examine the sub-packages */ 607 608 status = 609 acpi_ns_check_package_list(data, package, elements, count); 610 break; 611 612 case ACPI_PTYPE2: 613 case ACPI_PTYPE2_FIXED: 614 case ACPI_PTYPE2_MIN: 615 case ACPI_PTYPE2_COUNT: 616 617 /* 618 * These types all return a single Package that consists of a 619 * variable number of sub-Packages. 620 * 621 * First, ensure that the first element is a sub-Package. If not, 622 * the BIOS may have incorrectly returned the object as a single 623 * package instead of a Package of Packages (a common error if 624 * there is only one entry). We may be able to repair this by 625 * wrapping the returned Package with a new outer Package. 626 */ 627 if (*elements 628 && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) { 629 630 /* Create the new outer package and populate it */ 631 632 status = 633 acpi_ns_repair_package_list(data, 634 return_object_ptr); 635 if (ACPI_FAILURE(status)) { 636 return (status); 637 } 638 639 /* Update locals to point to the new package (of 1 element) */ 640 641 return_object = *return_object_ptr; 642 elements = return_object->package.elements; 643 count = 1; 644 } 645 646 /* Examine the sub-packages */ 647 648 status = 649 acpi_ns_check_package_list(data, package, elements, count); 650 break; 651 652 default: 653 654 /* Should not get here if predefined info table is correct */ 655 656 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 657 "Invalid internal return type in table entry: %X", 658 package->ret_info.type)); 659 660 return (AE_AML_INTERNAL); 661 } 662 663 return (status); 664 665package_too_small: 666 667 /* Error exit for the case with an incorrect package count */ 668 669 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 670 "Return Package is too small - found %u elements, expected %u", 671 count, expected_count)); 672 673 return (AE_AML_OPERAND_VALUE); 674} 675 676/******************************************************************************* 677 * 678 * FUNCTION: acpi_ns_check_package_list 679 * 680 * PARAMETERS: Data - Pointer to validation data structure 681 * Package - Pointer to package-specific info for method 682 * Elements - Element list of parent package. All elements 683 * of this list should be of type Package. 684 * Count - Count of subpackages 685 * 686 * RETURN: Status 687 * 688 * DESCRIPTION: Examine a list of subpackages 689 * 690 ******************************************************************************/ 691 692static acpi_status 693acpi_ns_check_package_list(struct acpi_predefined_data *data, 694 const union acpi_predefined_info *package, 695 union acpi_operand_object **elements, u32 count) 696{ 697 union acpi_operand_object *sub_package; 698 union acpi_operand_object **sub_elements; 699 acpi_status status; 700 u32 expected_count; 701 u32 i; 702 u32 j; 703 704 /* 705 * Validate each sub-Package in the parent Package 706 * 707 * NOTE: assumes list of sub-packages contains no NULL elements. 708 * Any NULL elements should have been removed by earlier call 709 * to acpi_ns_remove_null_elements. 710 */ 711 for (i = 0; i < count; i++) { 712 sub_package = *elements; 713 sub_elements = sub_package->package.elements; 714 data->parent_package = sub_package; 715 716 /* Each sub-object must be of type Package */ 717 718 status = acpi_ns_check_object_type(data, &sub_package, 719 ACPI_RTYPE_PACKAGE, i); 720 if (ACPI_FAILURE(status)) { 721 return (status); 722 } 723 724 /* Examine the different types of expected sub-packages */ 725 726 data->parent_package = sub_package; 727 switch (package->ret_info.type) { 728 case ACPI_PTYPE2: 729 case ACPI_PTYPE2_PKG_COUNT: 730 case ACPI_PTYPE2_REV_FIXED: 731 732 /* Each subpackage has a fixed number of elements */ 733 734 expected_count = 735 package->ret_info.count1 + package->ret_info.count2; 736 if (sub_package->package.count < expected_count) { 737 goto package_too_small; 738 } 739 740 status = 741 acpi_ns_check_package_elements(data, sub_elements, 742 package->ret_info. 743 object_type1, 744 package->ret_info. 745 count1, 746 package->ret_info. 747 object_type2, 748 package->ret_info. 749 count2, 0); 750 if (ACPI_FAILURE(status)) { 751 return (status); 752 } 753 break; 754 755 case ACPI_PTYPE2_FIXED: 756 757 /* Each sub-package has a fixed length */ 758 759 expected_count = package->ret_info2.count; 760 if (sub_package->package.count < expected_count) { 761 goto package_too_small; 762 } 763 764 /* Check the type of each sub-package element */ 765 766 for (j = 0; j < expected_count; j++) { 767 status = 768 acpi_ns_check_object_type(data, 769 &sub_elements[j], 770 package-> 771 ret_info2. 772 object_type[j], 773 j); 774 if (ACPI_FAILURE(status)) { 775 return (status); 776 } 777 } 778 break; 779 780 case ACPI_PTYPE2_MIN: 781 782 /* Each sub-package has a variable but minimum length */ 783 784 expected_count = package->ret_info.count1; 785 if (sub_package->package.count < expected_count) { 786 goto package_too_small; 787 } 788 789 /* Check the type of each sub-package element */ 790 791 status = 792 acpi_ns_check_package_elements(data, sub_elements, 793 package->ret_info. 794 object_type1, 795 sub_package->package. 796 count, 0, 0, 0); 797 if (ACPI_FAILURE(status)) { 798 return (status); 799 } 800 break; 801 802 case ACPI_PTYPE2_COUNT: 803 804 /* 805 * First element is the (Integer) count of elements, including 806 * the count field (the ACPI name is num_elements) 807 */ 808 status = acpi_ns_check_object_type(data, sub_elements, 809 ACPI_RTYPE_INTEGER, 810 0); 811 if (ACPI_FAILURE(status)) { 812 return (status); 813 } 814 815 /* 816 * Make sure package is large enough for the Count and is 817 * is as large as the minimum size 818 */ 819 expected_count = (u32)(*sub_elements)->integer.value; 820 if (sub_package->package.count < expected_count) { 821 goto package_too_small; 822 } 823 if (sub_package->package.count < 824 package->ret_info.count1) { 825 expected_count = package->ret_info.count1; 826 goto package_too_small; 827 } 828 if (expected_count == 0) { 829 /* 830 * Either the num_entries element was originally zero or it was 831 * a NULL element and repaired to an Integer of value zero. 832 * In either case, repair it by setting num_entries to be the 833 * actual size of the subpackage. 834 */ 835 expected_count = sub_package->package.count; 836 (*sub_elements)->integer.value = expected_count; 837 } 838 839 /* Check the type of each sub-package element */ 840 841 status = 842 acpi_ns_check_package_elements(data, 843 (sub_elements + 1), 844 package->ret_info. 845 object_type1, 846 (expected_count - 1), 847 0, 0, 1); 848 if (ACPI_FAILURE(status)) { 849 return (status); 850 } 851 break; 852 853 default: /* Should not get here, type was validated by caller */ 854 855 return (AE_AML_INTERNAL); 856 } 857 858 elements++; 859 } 860 861 return (AE_OK); 862 863package_too_small: 864 865 /* The sub-package count was smaller than required */ 866 867 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 868 "Return Sub-Package[%u] is too small - found %u elements, expected %u", 869 i, sub_package->package.count, expected_count)); 870 871 return (AE_AML_OPERAND_VALUE); 872} 873 874/******************************************************************************* 875 * 876 * FUNCTION: acpi_ns_check_package_elements 877 * 878 * PARAMETERS: Data - Pointer to validation data structure 879 * Elements - Pointer to the package elements array 880 * Type1 - Object type for first group 881 * Count1 - Count for first group 882 * Type2 - Object type for second group 883 * Count2 - Count for second group 884 * start_index - Start of the first group of elements 885 * 886 * RETURN: Status 887 * 888 * DESCRIPTION: Check that all elements of a package are of the correct object 889 * type. Supports up to two groups of different object types. 890 * 891 ******************************************************************************/ 892 893static acpi_status 894acpi_ns_check_package_elements(struct acpi_predefined_data *data, 895 union acpi_operand_object **elements, 896 u8 type1, 897 u32 count1, 898 u8 type2, u32 count2, u32 start_index) 899{ 900 union acpi_operand_object **this_element = elements; 901 acpi_status status; 902 u32 i; 903 904 /* 905 * Up to two groups of package elements are supported by the data 906 * structure. All elements in each group must be of the same type. 907 * The second group can have a count of zero. 908 */ 909 for (i = 0; i < count1; i++) { 910 status = acpi_ns_check_object_type(data, this_element, 911 type1, i + start_index); 912 if (ACPI_FAILURE(status)) { 913 return (status); 914 } 915 this_element++; 916 } 917 918 for (i = 0; i < count2; i++) { 919 status = acpi_ns_check_object_type(data, this_element, 920 type2, 921 (i + count1 + start_index)); 922 if (ACPI_FAILURE(status)) { 923 return (status); 924 } 925 this_element++; 926 } 927 928 return (AE_OK); 929} 930 931/******************************************************************************* 932 * 933 * FUNCTION: acpi_ns_check_object_type 934 * 935 * PARAMETERS: Data - Pointer to validation data structure 936 * return_object_ptr - Pointer to the object returned from the 937 * evaluation of a method or object 938 * expected_btypes - Bitmap of expected return type(s) 939 * package_index - Index of object within parent package (if 940 * applicable - ACPI_NOT_PACKAGE_ELEMENT 941 * otherwise) 942 * 943 * RETURN: Status 944 * 945 * DESCRIPTION: Check the type of the return object against the expected object 946 * type(s). Use of Btype allows multiple expected object types. 947 * 948 ******************************************************************************/ 949 950static acpi_status 951acpi_ns_check_object_type(struct acpi_predefined_data *data, 952 union acpi_operand_object **return_object_ptr, 953 u32 expected_btypes, u32 package_index) 954{ 955 union acpi_operand_object *return_object = *return_object_ptr; 956 acpi_status status = AE_OK; 957 u32 return_btype; 958 char type_buffer[48]; /* Room for 5 types */ 959 960 /* 961 * If we get a NULL return_object here, it is a NULL package element. 962 * Since all extraneous NULL package elements were removed earlier by a 963 * call to acpi_ns_remove_null_elements, this is an unexpected NULL element. 964 * We will attempt to repair it. 965 */ 966 if (!return_object) { 967 status = acpi_ns_repair_null_element(data, expected_btypes, 968 package_index, 969 return_object_ptr); 970 if (ACPI_SUCCESS(status)) { 971 return (AE_OK); /* Repair was successful */ 972 } 973 goto type_error_exit; 974 } 975 976 /* A Namespace node should not get here, but make sure */ 977 978 if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) { 979 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 980 "Invalid return type - Found a Namespace node [%4.4s] type %s", 981 return_object->node.name.ascii, 982 acpi_ut_get_type_name(return_object->node. 983 type))); 984 return (AE_AML_OPERAND_TYPE); 985 } 986 987 /* 988 * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type. 989 * The bitmapped type allows multiple possible return types. 990 * 991 * Note, the cases below must handle all of the possible types returned 992 * from all of the predefined names (including elements of returned 993 * packages) 994 */ 995 switch (return_object->common.type) { 996 case ACPI_TYPE_INTEGER: 997 return_btype = ACPI_RTYPE_INTEGER; 998 break; 999 1000 case ACPI_TYPE_BUFFER: 1001 return_btype = ACPI_RTYPE_BUFFER; 1002 break; 1003 1004 case ACPI_TYPE_STRING: 1005 return_btype = ACPI_RTYPE_STRING; 1006 break; 1007 1008 case ACPI_TYPE_PACKAGE: 1009 return_btype = ACPI_RTYPE_PACKAGE; 1010 break; 1011 1012 case ACPI_TYPE_LOCAL_REFERENCE: 1013 return_btype = ACPI_RTYPE_REFERENCE; 1014 break; 1015 1016 default: 1017 /* Not one of the supported objects, must be incorrect */ 1018 1019 goto type_error_exit; 1020 } 1021 1022 /* Is the object one of the expected types? */ 1023 1024 if (return_btype & expected_btypes) { 1025 1026 /* For reference objects, check that the reference type is correct */ 1027 1028 if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) { 1029 status = acpi_ns_check_reference(data, return_object); 1030 } 1031 1032 return (status); 1033 } 1034 1035 /* Type mismatch -- attempt repair of the returned object */ 1036 1037 status = acpi_ns_repair_object(data, expected_btypes, 1038 package_index, return_object_ptr); 1039 if (ACPI_SUCCESS(status)) { 1040 return (AE_OK); /* Repair was successful */ 1041 } 1042 1043 type_error_exit: 1044 1045 /* Create a string with all expected types for this predefined object */ 1046 1047 acpi_ns_get_expected_types(type_buffer, expected_btypes); 1048 1049 if (package_index == ACPI_NOT_PACKAGE_ELEMENT) { 1050 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1051 "Return type mismatch - found %s, expected %s", 1052 acpi_ut_get_object_type_name 1053 (return_object), type_buffer)); 1054 } else { 1055 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1056 "Return Package type mismatch at index %u - " 1057 "found %s, expected %s", package_index, 1058 acpi_ut_get_object_type_name 1059 (return_object), type_buffer)); 1060 } 1061 1062 return (AE_AML_OPERAND_TYPE); 1063} 1064 1065/******************************************************************************* 1066 * 1067 * FUNCTION: acpi_ns_check_reference 1068 * 1069 * PARAMETERS: Data - Pointer to validation data structure 1070 * return_object - Object returned from the evaluation of a 1071 * method or object 1072 * 1073 * RETURN: Status 1074 * 1075 * DESCRIPTION: Check a returned reference object for the correct reference 1076 * type. The only reference type that can be returned from a 1077 * predefined method is a named reference. All others are invalid. 1078 * 1079 ******************************************************************************/ 1080 1081static acpi_status 1082acpi_ns_check_reference(struct acpi_predefined_data *data, 1083 union acpi_operand_object *return_object) 1084{ 1085 1086 /* 1087 * Check the reference object for the correct reference type (opcode). 1088 * The only type of reference that can be converted to an union acpi_object is 1089 * a reference to a named object (reference class: NAME) 1090 */ 1091 if (return_object->reference.class == ACPI_REFCLASS_NAME) { 1092 return (AE_OK); 1093 } 1094 1095 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, 1096 "Return type mismatch - unexpected reference object type [%s] %2.2X", 1097 acpi_ut_get_reference_name(return_object), 1098 return_object->reference.class)); 1099 1100 return (AE_AML_OPERAND_TYPE); 1101} 1102 1103/******************************************************************************* 1104 * 1105 * FUNCTION: acpi_ns_get_expected_types 1106 * 1107 * PARAMETERS: Buffer - Pointer to where the string is returned 1108 * expected_btypes - Bitmap of expected return type(s) 1109 * 1110 * RETURN: Buffer is populated with type names. 1111 * 1112 * DESCRIPTION: Translate the expected types bitmap into a string of ascii 1113 * names of expected types, for use in warning messages. 1114 * 1115 ******************************************************************************/ 1116 1117static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes) 1118{ 1119 u32 this_rtype; 1120 u32 i; 1121 u32 j; 1122 1123 j = 1; 1124 buffer[0] = 0; 1125 this_rtype = ACPI_RTYPE_INTEGER; 1126 1127 for (i = 0; i < ACPI_NUM_RTYPES; i++) { 1128 1129 /* If one of the expected types, concatenate the name of this type */ 1130 1131 if (expected_btypes & this_rtype) { 1132 ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]); 1133 j = 0; /* Use name separator from now on */ 1134 } 1135 this_rtype <<= 1; /* Next Rtype */ 1136 } 1137} 1138