1 /******************************************************************************* 2 * 3 * Module Name: nsaccess - Top-level functions for accessing ACPI namespace 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2017, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "amlcode.h" 47 #include "acnamesp.h" 48 #include "acdispat.h" 49 50 #ifdef ACPI_ASL_COMPILER 51 #include "acdisasm.h" 52 #endif 53 54 #define _COMPONENT ACPI_NAMESPACE 55 ACPI_MODULE_NAME("nsaccess") 56 57 /******************************************************************************* 58 * 59 * FUNCTION: acpi_ns_root_initialize 60 * 61 * PARAMETERS: None 62 * 63 * RETURN: Status 64 * 65 * DESCRIPTION: Allocate and initialize the default root named objects 66 * 67 * MUTEX: Locks namespace for entire execution 68 * 69 ******************************************************************************/ 70 acpi_status acpi_ns_root_initialize(void) 71 { 72 acpi_status status; 73 const struct acpi_predefined_names *init_val = NULL; 74 struct acpi_namespace_node *new_node; 75 union acpi_operand_object *obj_desc; 76 acpi_string val = NULL; 77 78 ACPI_FUNCTION_TRACE(ns_root_initialize); 79 80 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 81 if (ACPI_FAILURE(status)) { 82 return_ACPI_STATUS(status); 83 } 84 85 /* 86 * The global root ptr is initially NULL, so a non-NULL value indicates 87 * that acpi_ns_root_initialize() has already been called; just return. 88 */ 89 if (acpi_gbl_root_node) { 90 status = AE_OK; 91 goto unlock_and_exit; 92 } 93 94 /* 95 * Tell the rest of the subsystem that the root is initialized 96 * (This is OK because the namespace is locked) 97 */ 98 acpi_gbl_root_node = &acpi_gbl_root_node_struct; 99 100 /* Enter the pre-defined names in the name table */ 101 102 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 103 "Entering predefined entries into namespace\n")); 104 105 for (init_val = acpi_gbl_pre_defined_names; init_val->name; init_val++) { 106 107 /* _OSI is optional for now, will be permanent later */ 108 109 if (!strcmp(init_val->name, "_OSI") 110 && !acpi_gbl_create_osi_method) { 111 continue; 112 } 113 114 status = 115 acpi_ns_lookup(NULL, ACPI_CAST_PTR(char, init_val->name), 116 init_val->type, ACPI_IMODE_LOAD_PASS2, 117 ACPI_NS_NO_UPSEARCH, NULL, &new_node); 118 if (ACPI_FAILURE(status)) { 119 ACPI_EXCEPTION((AE_INFO, status, 120 "Could not create predefined name %s", 121 init_val->name)); 122 continue; 123 } 124 125 /* 126 * Name entered successfully. If entry in pre_defined_names[] specifies 127 * an initial value, create the initial value. 128 */ 129 if (init_val->val) { 130 status = acpi_os_predefined_override(init_val, &val); 131 if (ACPI_FAILURE(status)) { 132 ACPI_ERROR((AE_INFO, 133 "Could not override predefined %s", 134 init_val->name)); 135 } 136 137 if (!val) { 138 val = init_val->val; 139 } 140 141 /* 142 * Entry requests an initial value, allocate a 143 * descriptor for it. 144 */ 145 obj_desc = 146 acpi_ut_create_internal_object(init_val->type); 147 if (!obj_desc) { 148 status = AE_NO_MEMORY; 149 goto unlock_and_exit; 150 } 151 152 /* 153 * Convert value string from table entry to 154 * internal representation. Only types actually 155 * used for initial values are implemented here. 156 */ 157 switch (init_val->type) { 158 case ACPI_TYPE_METHOD: 159 160 obj_desc->method.param_count = 161 (u8) ACPI_TO_INTEGER(val); 162 obj_desc->common.flags |= AOPOBJ_DATA_VALID; 163 164 #if defined (ACPI_ASL_COMPILER) 165 166 /* Save the parameter count for the iASL compiler */ 167 168 new_node->value = obj_desc->method.param_count; 169 #else 170 /* Mark this as a very SPECIAL method */ 171 172 obj_desc->method.info_flags = 173 ACPI_METHOD_INTERNAL_ONLY; 174 obj_desc->method.dispatch.implementation = 175 acpi_ut_osi_implementation; 176 #endif 177 break; 178 179 case ACPI_TYPE_INTEGER: 180 181 obj_desc->integer.value = ACPI_TO_INTEGER(val); 182 break; 183 184 case ACPI_TYPE_STRING: 185 186 /* Build an object around the static string */ 187 188 obj_desc->string.length = (u32)strlen(val); 189 obj_desc->string.pointer = val; 190 obj_desc->common.flags |= AOPOBJ_STATIC_POINTER; 191 break; 192 193 case ACPI_TYPE_MUTEX: 194 195 obj_desc->mutex.node = new_node; 196 obj_desc->mutex.sync_level = 197 (u8) (ACPI_TO_INTEGER(val) - 1); 198 199 /* Create a mutex */ 200 201 status = 202 acpi_os_create_mutex(&obj_desc->mutex. 203 os_mutex); 204 if (ACPI_FAILURE(status)) { 205 acpi_ut_remove_reference(obj_desc); 206 goto unlock_and_exit; 207 } 208 209 /* Special case for ACPI Global Lock */ 210 211 if (strcmp(init_val->name, "_GL_") == 0) { 212 acpi_gbl_global_lock_mutex = obj_desc; 213 214 /* Create additional counting semaphore for global lock */ 215 216 status = 217 acpi_os_create_semaphore(1, 0, 218 &acpi_gbl_global_lock_semaphore); 219 if (ACPI_FAILURE(status)) { 220 acpi_ut_remove_reference 221 (obj_desc); 222 goto unlock_and_exit; 223 } 224 } 225 break; 226 227 default: 228 229 ACPI_ERROR((AE_INFO, 230 "Unsupported initial type value 0x%X", 231 init_val->type)); 232 acpi_ut_remove_reference(obj_desc); 233 obj_desc = NULL; 234 continue; 235 } 236 237 /* Store pointer to value descriptor in the Node */ 238 239 status = acpi_ns_attach_object(new_node, obj_desc, 240 obj_desc->common.type); 241 242 /* Remove local reference to the object */ 243 244 acpi_ut_remove_reference(obj_desc); 245 } 246 } 247 248 unlock_and_exit: 249 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 250 251 /* Save a handle to "_GPE", it is always present */ 252 253 if (ACPI_SUCCESS(status)) { 254 status = acpi_ns_get_node(NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH, 255 &acpi_gbl_fadt_gpe_device); 256 } 257 258 return_ACPI_STATUS(status); 259 } 260 261 /******************************************************************************* 262 * 263 * FUNCTION: acpi_ns_lookup 264 * 265 * PARAMETERS: scope_info - Current scope info block 266 * pathname - Search pathname, in internal format 267 * (as represented in the AML stream) 268 * type - Type associated with name 269 * interpreter_mode - IMODE_LOAD_PASS2 => add name if not found 270 * flags - Flags describing the search restrictions 271 * walk_state - Current state of the walk 272 * return_node - Where the Node is placed (if found 273 * or created successfully) 274 * 275 * RETURN: Status 276 * 277 * DESCRIPTION: Find or enter the passed name in the name space. 278 * Log an error if name not found in Exec mode. 279 * 280 * MUTEX: Assumes namespace is locked. 281 * 282 ******************************************************************************/ 283 284 acpi_status 285 acpi_ns_lookup(union acpi_generic_state *scope_info, 286 char *pathname, 287 acpi_object_type type, 288 acpi_interpreter_mode interpreter_mode, 289 u32 flags, 290 struct acpi_walk_state *walk_state, 291 struct acpi_namespace_node **return_node) 292 { 293 acpi_status status; 294 char *path = pathname; 295 struct acpi_namespace_node *prefix_node; 296 struct acpi_namespace_node *current_node = NULL; 297 struct acpi_namespace_node *this_node = NULL; 298 u32 num_segments; 299 u32 num_carats; 300 acpi_name simple_name; 301 acpi_object_type type_to_check_for; 302 acpi_object_type this_search_type; 303 u32 search_parent_flag = ACPI_NS_SEARCH_PARENT; 304 u32 local_flags; 305 306 ACPI_FUNCTION_TRACE(ns_lookup); 307 308 if (!return_node) { 309 return_ACPI_STATUS(AE_BAD_PARAMETER); 310 } 311 312 local_flags = flags & 313 ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_OVERRIDE_IF_FOUND | 314 ACPI_NS_SEARCH_PARENT); 315 *return_node = ACPI_ENTRY_NOT_FOUND; 316 acpi_gbl_ns_lookup_count++; 317 318 if (!acpi_gbl_root_node) { 319 return_ACPI_STATUS(AE_NO_NAMESPACE); 320 } 321 322 /* Get the prefix scope. A null scope means use the root scope */ 323 324 if ((!scope_info) || (!scope_info->scope.node)) { 325 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 326 "Null scope prefix, using root node (%p)\n", 327 acpi_gbl_root_node)); 328 329 prefix_node = acpi_gbl_root_node; 330 } else { 331 prefix_node = scope_info->scope.node; 332 if (ACPI_GET_DESCRIPTOR_TYPE(prefix_node) != 333 ACPI_DESC_TYPE_NAMED) { 334 ACPI_ERROR((AE_INFO, "%p is not a namespace node [%s]", 335 prefix_node, 336 acpi_ut_get_descriptor_name(prefix_node))); 337 return_ACPI_STATUS(AE_AML_INTERNAL); 338 } 339 340 if (!(flags & ACPI_NS_PREFIX_IS_SCOPE)) { 341 /* 342 * This node might not be a actual "scope" node (such as a 343 * Device/Method, etc.) It could be a Package or other object 344 * node. Backup up the tree to find the containing scope node. 345 */ 346 while (!acpi_ns_opens_scope(prefix_node->type) && 347 prefix_node->type != ACPI_TYPE_ANY) { 348 prefix_node = prefix_node->parent; 349 } 350 } 351 } 352 353 /* Save type. TBD: may be no longer necessary */ 354 355 type_to_check_for = type; 356 357 /* 358 * Begin examination of the actual pathname 359 */ 360 if (!pathname) { 361 362 /* A Null name_path is allowed and refers to the root */ 363 364 num_segments = 0; 365 this_node = acpi_gbl_root_node; 366 path = ""; 367 368 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 369 "Null Pathname (Zero segments), Flags=%X\n", 370 flags)); 371 } else { 372 /* 373 * Name pointer is valid (and must be in internal name format) 374 * 375 * Check for scope prefixes: 376 * 377 * As represented in the AML stream, a namepath consists of an 378 * optional scope prefix followed by a name segment part. 379 * 380 * If present, the scope prefix is either a Root Prefix (in 381 * which case the name is fully qualified), or one or more 382 * Parent Prefixes (in which case the name's scope is relative 383 * to the current scope). 384 */ 385 if (*path == (u8) AML_ROOT_PREFIX) { 386 387 /* Pathname is fully qualified, start from the root */ 388 389 this_node = acpi_gbl_root_node; 390 search_parent_flag = ACPI_NS_NO_UPSEARCH; 391 392 /* Point to name segment part */ 393 394 path++; 395 396 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 397 "Path is absolute from root [%p]\n", 398 this_node)); 399 } else { 400 /* Pathname is relative to current scope, start there */ 401 402 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 403 "Searching relative to prefix scope [%4.4s] (%p)\n", 404 acpi_ut_get_node_name(prefix_node), 405 prefix_node)); 406 407 /* 408 * Handle multiple Parent Prefixes (carat) by just getting 409 * the parent node for each prefix instance. 410 */ 411 this_node = prefix_node; 412 num_carats = 0; 413 while (*path == (u8) AML_PARENT_PREFIX) { 414 415 /* Name is fully qualified, no search rules apply */ 416 417 search_parent_flag = ACPI_NS_NO_UPSEARCH; 418 419 /* 420 * Point past this prefix to the name segment 421 * part or the next Parent Prefix 422 */ 423 path++; 424 425 /* Backup to the parent node */ 426 427 num_carats++; 428 this_node = this_node->parent; 429 if (!this_node) { 430 431 /* Current scope has no parent scope */ 432 433 ACPI_ERROR((AE_INFO, 434 "%s: Path has too many parent prefixes (^) " 435 "- reached beyond root node", 436 pathname)); 437 return_ACPI_STATUS(AE_NOT_FOUND); 438 } 439 } 440 441 if (search_parent_flag == ACPI_NS_NO_UPSEARCH) { 442 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 443 "Search scope is [%4.4s], path has %u carat(s)\n", 444 acpi_ut_get_node_name 445 (this_node), num_carats)); 446 } 447 } 448 449 /* 450 * Determine the number of ACPI name segments in this pathname. 451 * 452 * The segment part consists of either: 453 * - A Null name segment (0) 454 * - A dual_name_prefix followed by two 4-byte name segments 455 * - A multi_name_prefix followed by a byte indicating the 456 * number of segments and the segments themselves. 457 * - A single 4-byte name segment 458 * 459 * Examine the name prefix opcode, if any, to determine the number of 460 * segments. 461 */ 462 switch (*path) { 463 case 0: 464 /* 465 * Null name after a root or parent prefixes. We already 466 * have the correct target node and there are no name segments. 467 */ 468 num_segments = 0; 469 type = this_node->type; 470 471 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 472 "Prefix-only Pathname (Zero name segments), Flags=%X\n", 473 flags)); 474 break; 475 476 case AML_DUAL_NAME_PREFIX: 477 478 /* More than one name_seg, search rules do not apply */ 479 480 search_parent_flag = ACPI_NS_NO_UPSEARCH; 481 482 /* Two segments, point to first name segment */ 483 484 num_segments = 2; 485 path++; 486 487 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 488 "Dual Pathname (2 segments, Flags=%X)\n", 489 flags)); 490 break; 491 492 case AML_MULTI_NAME_PREFIX: 493 494 /* More than one name_seg, search rules do not apply */ 495 496 search_parent_flag = ACPI_NS_NO_UPSEARCH; 497 498 /* Extract segment count, point to first name segment */ 499 500 path++; 501 num_segments = (u32) (u8) * path; 502 path++; 503 504 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 505 "Multi Pathname (%u Segments, Flags=%X)\n", 506 num_segments, flags)); 507 break; 508 509 default: 510 /* 511 * Not a Null name, no Dual or Multi prefix, hence there is 512 * only one name segment and Pathname is already pointing to it. 513 */ 514 num_segments = 1; 515 516 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 517 "Simple Pathname (1 segment, Flags=%X)\n", 518 flags)); 519 break; 520 } 521 522 ACPI_DEBUG_EXEC(acpi_ns_print_pathname(num_segments, path)); 523 } 524 525 /* 526 * Search namespace for each segment of the name. Loop through and 527 * verify (or add to the namespace) each name segment. 528 * 529 * The object type is significant only at the last name 530 * segment. (We don't care about the types along the path, only 531 * the type of the final target object.) 532 */ 533 this_search_type = ACPI_TYPE_ANY; 534 current_node = this_node; 535 while (num_segments && current_node) { 536 num_segments--; 537 if (!num_segments) { 538 539 /* This is the last segment, enable typechecking */ 540 541 this_search_type = type; 542 543 /* 544 * Only allow automatic parent search (search rules) if the caller 545 * requested it AND we have a single, non-fully-qualified name_seg 546 */ 547 if ((search_parent_flag != ACPI_NS_NO_UPSEARCH) && 548 (flags & ACPI_NS_SEARCH_PARENT)) { 549 local_flags |= ACPI_NS_SEARCH_PARENT; 550 } 551 552 /* Set error flag according to caller */ 553 554 if (flags & ACPI_NS_ERROR_IF_FOUND) { 555 local_flags |= ACPI_NS_ERROR_IF_FOUND; 556 } 557 558 /* Set override flag according to caller */ 559 560 if (flags & ACPI_NS_OVERRIDE_IF_FOUND) { 561 local_flags |= ACPI_NS_OVERRIDE_IF_FOUND; 562 } 563 } 564 565 /* Extract one ACPI name from the front of the pathname */ 566 567 ACPI_MOVE_32_TO_32(&simple_name, path); 568 569 /* Try to find the single (4 character) ACPI name */ 570 571 status = 572 acpi_ns_search_and_enter(simple_name, walk_state, 573 current_node, interpreter_mode, 574 this_search_type, local_flags, 575 &this_node); 576 if (ACPI_FAILURE(status)) { 577 if (status == AE_NOT_FOUND) { 578 579 /* Name not found in ACPI namespace */ 580 581 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, 582 "Name [%4.4s] not found in scope [%4.4s] %p\n", 583 (char *)&simple_name, 584 (char *)¤t_node->name, 585 current_node)); 586 } 587 #ifdef ACPI_ASL_COMPILER 588 /* 589 * If this ACPI name already exists within the namespace as an 590 * external declaration, then mark the external as a conflicting 591 * declaration and proceed to process the current node as if it did 592 * not exist in the namespace. If this node is not processed as 593 * normal, then it could cause improper namespace resolution 594 * by failing to open a new scope. 595 */ 596 if (acpi_gbl_disasm_flag && 597 (status == AE_ALREADY_EXISTS) && 598 ((this_node->flags & ANOBJ_IS_EXTERNAL) || 599 (walk_state 600 && walk_state->opcode == AML_EXTERNAL_OP))) { 601 this_node->flags &= ~ANOBJ_IS_EXTERNAL; 602 this_node->type = (u8)this_search_type; 603 if (walk_state->opcode != AML_EXTERNAL_OP) { 604 acpi_dm_mark_external_conflict 605 (this_node); 606 } 607 break; 608 } 609 #endif 610 611 *return_node = this_node; 612 return_ACPI_STATUS(status); 613 } 614 615 /* More segments to follow? */ 616 617 if (num_segments > 0) { 618 /* 619 * If we have an alias to an object that opens a scope (such as a 620 * device or processor), we need to dereference the alias here so 621 * that we can access any children of the original node (via the 622 * remaining segments). 623 */ 624 if (this_node->type == ACPI_TYPE_LOCAL_ALIAS) { 625 if (!this_node->object) { 626 return_ACPI_STATUS(AE_NOT_EXIST); 627 } 628 629 if (acpi_ns_opens_scope 630 (((struct acpi_namespace_node *) 631 this_node->object)->type)) { 632 this_node = 633 (struct acpi_namespace_node *) 634 this_node->object; 635 } 636 } 637 } 638 639 /* Special handling for the last segment (num_segments == 0) */ 640 641 else { 642 /* 643 * Sanity typecheck of the target object: 644 * 645 * If 1) This is the last segment (num_segments == 0) 646 * 2) And we are looking for a specific type 647 * (Not checking for TYPE_ANY) 648 * 3) Which is not an alias 649 * 4) Which is not a local type (TYPE_SCOPE) 650 * 5) And the type of target object is known (not TYPE_ANY) 651 * 6) And target object does not match what we are looking for 652 * 653 * Then we have a type mismatch. Just warn and ignore it. 654 */ 655 if ((type_to_check_for != ACPI_TYPE_ANY) && 656 (type_to_check_for != ACPI_TYPE_LOCAL_ALIAS) && 657 (type_to_check_for != ACPI_TYPE_LOCAL_METHOD_ALIAS) 658 && (type_to_check_for != ACPI_TYPE_LOCAL_SCOPE) 659 && (this_node->type != ACPI_TYPE_ANY) 660 && (this_node->type != type_to_check_for)) { 661 662 /* Complain about a type mismatch */ 663 664 ACPI_WARNING((AE_INFO, 665 "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)", 666 ACPI_CAST_PTR(char, &simple_name), 667 acpi_ut_get_type_name(this_node-> 668 type), 669 acpi_ut_get_type_name 670 (type_to_check_for))); 671 } 672 673 /* 674 * If this is the last name segment and we are not looking for a 675 * specific type, but the type of found object is known, use that 676 * type to (later) see if it opens a scope. 677 */ 678 if (type == ACPI_TYPE_ANY) { 679 type = this_node->type; 680 } 681 } 682 683 /* Point to next name segment and make this node current */ 684 685 path += ACPI_NAME_SIZE; 686 current_node = this_node; 687 } 688 689 /* Always check if we need to open a new scope */ 690 691 if (!(flags & ACPI_NS_DONT_OPEN_SCOPE) && (walk_state)) { 692 /* 693 * If entry is a type which opens a scope, push the new scope on the 694 * scope stack. 695 */ 696 if (acpi_ns_opens_scope(type)) { 697 status = 698 acpi_ds_scope_stack_push(this_node, type, 699 walk_state); 700 if (ACPI_FAILURE(status)) { 701 return_ACPI_STATUS(status); 702 } 703 } 704 } 705 706 *return_node = this_node; 707 return_ACPI_STATUS(AE_OK); 708 } 709