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