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