1/****************************************************************************** 2 * 3 * Module Name: nsutils - Utilities for accessing ACPI namespace, accessing 4 * parents and siblings and Scope manipulation 5 * 6 *****************************************************************************/ 7 8/* 9 * Copyright (C) 2000 - 2023, 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 MERCHANTABILITY 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#include "acpi.h" 46#include "accommon.h" 47#include "acnamesp.h" 48#include "amlcode.h" 49 50#define _COMPONENT ACPI_NAMESPACE 51 ACPI_MODULE_NAME ("nsutils") 52 53/* Local prototypes */ 54 55#ifdef ACPI_OBSOLETE_FUNCTIONS 56ACPI_NAME 57AcpiNsFindParentName ( 58 ACPI_NAMESPACE_NODE *NodeToSearch); 59#endif 60 61 62/******************************************************************************* 63 * 64 * FUNCTION: AcpiNsPrintNodePathname 65 * 66 * PARAMETERS: Node - Object 67 * Message - Prefix message 68 * 69 * DESCRIPTION: Print an object's full namespace pathname 70 * Manages allocation/freeing of a pathname buffer 71 * 72 ******************************************************************************/ 73 74void 75AcpiNsPrintNodePathname ( 76 ACPI_NAMESPACE_NODE *Node, 77 const char *Message) 78{ 79 ACPI_BUFFER Buffer; 80 ACPI_STATUS Status; 81 82 83 if (!Node) 84 { 85 AcpiOsPrintf ("[NULL NAME]"); 86 return; 87 } 88 89 /* Convert handle to full pathname and print it (with supplied message) */ 90 91 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 92 93 Status = AcpiNsHandleToPathname (Node, &Buffer, TRUE); 94 if (ACPI_SUCCESS (Status)) 95 { 96 if (Message) 97 { 98 AcpiOsPrintf ("%s ", Message); 99 } 100 101 AcpiOsPrintf ("%s", (char *) Buffer.Pointer); 102 ACPI_FREE (Buffer.Pointer); 103 } 104} 105 106 107/******************************************************************************* 108 * 109 * FUNCTION: AcpiNsGetType 110 * 111 * PARAMETERS: Node - Parent Node to be examined 112 * 113 * RETURN: Type field from Node whose handle is passed 114 * 115 * DESCRIPTION: Return the type of a Namespace node 116 * 117 ******************************************************************************/ 118 119ACPI_OBJECT_TYPE 120AcpiNsGetType ( 121 ACPI_NAMESPACE_NODE *Node) 122{ 123 ACPI_FUNCTION_TRACE (NsGetType); 124 125 126 if (!Node) 127 { 128 ACPI_WARNING ((AE_INFO, "Null Node parameter")); 129 return_UINT8 (ACPI_TYPE_ANY); 130 } 131 132 return_UINT8 (Node->Type); 133} 134 135 136/******************************************************************************* 137 * 138 * FUNCTION: AcpiNsLocal 139 * 140 * PARAMETERS: Type - A namespace object type 141 * 142 * RETURN: LOCAL if names must be found locally in objects of the 143 * passed type, 0 if enclosing scopes should be searched 144 * 145 * DESCRIPTION: Returns scope rule for the given object type. 146 * 147 ******************************************************************************/ 148 149UINT32 150AcpiNsLocal ( 151 ACPI_OBJECT_TYPE Type) 152{ 153 ACPI_FUNCTION_TRACE (NsLocal); 154 155 156 if (!AcpiUtValidObjectType (Type)) 157 { 158 /* Type code out of range */ 159 160 ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type)); 161 return_UINT32 (ACPI_NS_NORMAL); 162 } 163 164 return_UINT32 (AcpiGbl_NsProperties[Type] & ACPI_NS_LOCAL); 165} 166 167 168/******************************************************************************* 169 * 170 * FUNCTION: AcpiNsGetInternalNameLength 171 * 172 * PARAMETERS: Info - Info struct initialized with the 173 * external name pointer. 174 * 175 * RETURN: None 176 * 177 * DESCRIPTION: Calculate the length of the internal (AML) namestring 178 * corresponding to the external (ASL) namestring. 179 * 180 ******************************************************************************/ 181 182void 183AcpiNsGetInternalNameLength ( 184 ACPI_NAMESTRING_INFO *Info) 185{ 186 const char *NextExternalChar; 187 UINT32 i; 188 189 190 ACPI_FUNCTION_ENTRY (); 191 192 193 NextExternalChar = Info->ExternalName; 194 Info->NumCarats = 0; 195 Info->NumSegments = 0; 196 Info->FullyQualified = FALSE; 197 198 /* 199 * For the internal name, the required length is 4 bytes per segment, 200 * plus 1 each for RootPrefix, MultiNamePrefixOp, segment count, 201 * trailing null (which is not really needed, but no there's harm in 202 * putting it there) 203 * 204 * strlen() + 1 covers the first NameSeg, which has no path separator 205 */ 206 if (ACPI_IS_ROOT_PREFIX (*NextExternalChar)) 207 { 208 Info->FullyQualified = TRUE; 209 NextExternalChar++; 210 211 /* Skip redundant RootPrefix, like \\_SB.PCI0.SBRG.EC0 */ 212 213 while (ACPI_IS_ROOT_PREFIX (*NextExternalChar)) 214 { 215 NextExternalChar++; 216 } 217 } 218 else 219 { 220 /* Handle Carat prefixes */ 221 222 while (ACPI_IS_PARENT_PREFIX (*NextExternalChar)) 223 { 224 Info->NumCarats++; 225 NextExternalChar++; 226 } 227 } 228 229 /* 230 * Determine the number of ACPI name "segments" by counting the number of 231 * path separators within the string. Start with one segment since the 232 * segment count is [(# separators) + 1], and zero separators is ok. 233 */ 234 if (*NextExternalChar) 235 { 236 Info->NumSegments = 1; 237 for (i = 0; NextExternalChar[i]; i++) 238 { 239 if (ACPI_IS_PATH_SEPARATOR (NextExternalChar[i])) 240 { 241 Info->NumSegments++; 242 } 243 } 244 } 245 246 Info->Length = (ACPI_NAMESEG_SIZE * Info->NumSegments) + 247 4 + Info->NumCarats; 248 249 Info->NextExternalChar = NextExternalChar; 250} 251 252 253/******************************************************************************* 254 * 255 * FUNCTION: AcpiNsBuildInternalName 256 * 257 * PARAMETERS: Info - Info struct fully initialized 258 * 259 * RETURN: Status 260 * 261 * DESCRIPTION: Construct the internal (AML) namestring 262 * corresponding to the external (ASL) namestring. 263 * 264 ******************************************************************************/ 265 266ACPI_STATUS 267AcpiNsBuildInternalName ( 268 ACPI_NAMESTRING_INFO *Info) 269{ 270 UINT32 NumSegments = Info->NumSegments; 271 char *InternalName = Info->InternalName; 272 const char *ExternalName = Info->NextExternalChar; 273 char *Result = NULL; 274 UINT32 i; 275 276 277 ACPI_FUNCTION_TRACE (NsBuildInternalName); 278 279 280 /* Setup the correct prefixes, counts, and pointers */ 281 282 if (Info->FullyQualified) 283 { 284 InternalName[0] = AML_ROOT_PREFIX; 285 286 if (NumSegments <= 1) 287 { 288 Result = &InternalName[1]; 289 } 290 else if (NumSegments == 2) 291 { 292 InternalName[1] = AML_DUAL_NAME_PREFIX; 293 Result = &InternalName[2]; 294 } 295 else 296 { 297 InternalName[1] = AML_MULTI_NAME_PREFIX; 298 InternalName[2] = (char) NumSegments; 299 Result = &InternalName[3]; 300 } 301 } 302 else 303 { 304 /* 305 * Not fully qualified. 306 * Handle Carats first, then append the name segments 307 */ 308 i = 0; 309 if (Info->NumCarats) 310 { 311 for (i = 0; i < Info->NumCarats; i++) 312 { 313 InternalName[i] = AML_PARENT_PREFIX; 314 } 315 } 316 317 if (NumSegments <= 1) 318 { 319 Result = &InternalName[i]; 320 } 321 else if (NumSegments == 2) 322 { 323 InternalName[i] = AML_DUAL_NAME_PREFIX; 324 Result = &InternalName[(ACPI_SIZE) i+1]; 325 } 326 else 327 { 328 InternalName[i] = AML_MULTI_NAME_PREFIX; 329 InternalName[(ACPI_SIZE) i+1] = (char) NumSegments; 330 Result = &InternalName[(ACPI_SIZE) i+2]; 331 } 332 } 333 334 /* Build the name (minus path separators) */ 335 336 for (; NumSegments; NumSegments--) 337 { 338 for (i = 0; i < ACPI_NAMESEG_SIZE; i++) 339 { 340 if (ACPI_IS_PATH_SEPARATOR (*ExternalName) || 341 (*ExternalName == 0)) 342 { 343 /* Pad the segment with underscore(s) if segment is short */ 344 345 Result[i] = '_'; 346 } 347 else 348 { 349 /* Convert the character to uppercase and save it */ 350 351 Result[i] = (char) toupper ((int) *ExternalName); 352 ExternalName++; 353 } 354 } 355 356 /* Now we must have a path separator, or the pathname is bad */ 357 358 if (!ACPI_IS_PATH_SEPARATOR (*ExternalName) && 359 (*ExternalName != 0)) 360 { 361 return_ACPI_STATUS (AE_BAD_PATHNAME); 362 } 363 364 /* Move on the next segment */ 365 366 ExternalName++; 367 Result += ACPI_NAMESEG_SIZE; 368 } 369 370 /* Terminate the string */ 371 372 *Result = 0; 373 374 if (Info->FullyQualified) 375 { 376 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n", 377 InternalName, InternalName)); 378 } 379 else 380 { 381 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n", 382 InternalName, InternalName)); 383 } 384 385 return_ACPI_STATUS (AE_OK); 386} 387 388 389/******************************************************************************* 390 * 391 * FUNCTION: AcpiNsInternalizeName 392 * 393 * PARAMETERS: *ExternalName - External representation of name 394 * **Converted Name - Where to return the resulting 395 * internal representation of the name 396 * 397 * RETURN: Status 398 * 399 * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0") 400 * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) 401 * 402 *******************************************************************************/ 403 404ACPI_STATUS 405AcpiNsInternalizeName ( 406 const char *ExternalName, 407 char **ConvertedName) 408{ 409 char *InternalName; 410 ACPI_NAMESTRING_INFO Info; 411 ACPI_STATUS Status; 412 413 414 ACPI_FUNCTION_TRACE (NsInternalizeName); 415 416 417 if ((!ExternalName) || 418 (*ExternalName == 0) || 419 (!ConvertedName)) 420 { 421 return_ACPI_STATUS (AE_BAD_PARAMETER); 422 } 423 424 /* Get the length of the new internal name */ 425 426 Info.ExternalName = ExternalName; 427 AcpiNsGetInternalNameLength (&Info); 428 429 /* We need a segment to store the internal name */ 430 431 InternalName = ACPI_ALLOCATE_ZEROED (Info.Length); 432 if (!InternalName) 433 { 434 return_ACPI_STATUS (AE_NO_MEMORY); 435 } 436 437 /* Build the name */ 438 439 Info.InternalName = InternalName; 440 Status = AcpiNsBuildInternalName (&Info); 441 if (ACPI_FAILURE (Status)) 442 { 443 ACPI_FREE (InternalName); 444 return_ACPI_STATUS (Status); 445 } 446 447 *ConvertedName = InternalName; 448 return_ACPI_STATUS (AE_OK); 449} 450 451 452/******************************************************************************* 453 * 454 * FUNCTION: AcpiNsExternalizeName 455 * 456 * PARAMETERS: InternalNameLength - Length of the internal name below 457 * InternalName - Internal representation of name 458 * ConvertedNameLength - Where the length is returned 459 * ConvertedName - Where the resulting external name 460 * is returned 461 * 462 * RETURN: Status 463 * 464 * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30) 465 * to its external (printable) form (e.g. "\_PR_.CPU0") 466 * 467 ******************************************************************************/ 468 469ACPI_STATUS 470AcpiNsExternalizeName ( 471 UINT32 InternalNameLength, 472 const char *InternalName, 473 UINT32 *ConvertedNameLength, 474 char **ConvertedName) 475{ 476 UINT32 NamesIndex = 0; 477 UINT32 NumSegments = 0; 478 UINT32 RequiredLength; 479 UINT32 PrefixLength = 0; 480 UINT32 i = 0; 481 UINT32 j = 0; 482 483 484 ACPI_FUNCTION_TRACE (NsExternalizeName); 485 486 487 if (!InternalNameLength || 488 !InternalName || 489 !ConvertedName) 490 { 491 return_ACPI_STATUS (AE_BAD_PARAMETER); 492 } 493 494 /* Check for a prefix (one '\' | one or more '^') */ 495 496 switch (InternalName[0]) 497 { 498 case AML_ROOT_PREFIX: 499 500 PrefixLength = 1; 501 break; 502 503 case AML_PARENT_PREFIX: 504 505 for (i = 0; i < InternalNameLength; i++) 506 { 507 if (ACPI_IS_PARENT_PREFIX (InternalName[i])) 508 { 509 PrefixLength = i + 1; 510 } 511 else 512 { 513 break; 514 } 515 } 516 517 if (i == InternalNameLength) 518 { 519 PrefixLength = i; 520 } 521 522 break; 523 524 default: 525 526 break; 527 } 528 529 /* 530 * Check for object names. Note that there could be 0-255 of these 531 * 4-byte elements. 532 */ 533 if (PrefixLength < InternalNameLength) 534 { 535 switch (InternalName[PrefixLength]) 536 { 537 case AML_MULTI_NAME_PREFIX: 538 539 /* <count> 4-byte names */ 540 541 NamesIndex = PrefixLength + 2; 542 NumSegments = (UINT8) 543 InternalName[(ACPI_SIZE) PrefixLength + 1]; 544 break; 545 546 case AML_DUAL_NAME_PREFIX: 547 548 /* Two 4-byte names */ 549 550 NamesIndex = PrefixLength + 1; 551 NumSegments = 2; 552 break; 553 554 case 0: 555 556 /* NullName */ 557 558 NamesIndex = 0; 559 NumSegments = 0; 560 break; 561 562 default: 563 564 /* one 4-byte name */ 565 566 NamesIndex = PrefixLength; 567 NumSegments = 1; 568 break; 569 } 570 } 571 572 /* 573 * Calculate the length of ConvertedName, which equals the length 574 * of the prefix, length of all object names, length of any required 575 * punctuation ('.') between object names, plus the NULL terminator. 576 */ 577 RequiredLength = PrefixLength + (4 * NumSegments) + 578 ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1; 579 580 /* 581 * Check to see if we're still in bounds. If not, there's a problem 582 * with InternalName (invalid format). 583 */ 584 if (RequiredLength > InternalNameLength) 585 { 586 ACPI_ERROR ((AE_INFO, "Invalid internal name")); 587 return_ACPI_STATUS (AE_BAD_PATHNAME); 588 } 589 590 /* Build the ConvertedName */ 591 592 *ConvertedName = ACPI_ALLOCATE_ZEROED (RequiredLength); 593 if (!(*ConvertedName)) 594 { 595 return_ACPI_STATUS (AE_NO_MEMORY); 596 } 597 598 j = 0; 599 600 for (i = 0; i < PrefixLength; i++) 601 { 602 (*ConvertedName)[j++] = InternalName[i]; 603 } 604 605 if (NumSegments > 0) 606 { 607 for (i = 0; i < NumSegments; i++) 608 { 609 if (i > 0) 610 { 611 (*ConvertedName)[j++] = '.'; 612 } 613 614 /* Copy and validate the 4-char name segment */ 615 616 ACPI_COPY_NAMESEG (&(*ConvertedName)[j], 617 &InternalName[NamesIndex]); 618 AcpiUtRepairName (&(*ConvertedName)[j]); 619 620 j += ACPI_NAMESEG_SIZE; 621 NamesIndex += ACPI_NAMESEG_SIZE; 622 } 623 } 624 625 if (ConvertedNameLength) 626 { 627 *ConvertedNameLength = (UINT32) RequiredLength; 628 } 629 630 return_ACPI_STATUS (AE_OK); 631} 632 633 634/******************************************************************************* 635 * 636 * FUNCTION: AcpiNsValidateHandle 637 * 638 * PARAMETERS: Handle - Handle to be validated and typecast to a 639 * namespace node. 640 * 641 * RETURN: A pointer to a namespace node 642 * 643 * DESCRIPTION: Convert a namespace handle to a namespace node. Handles special 644 * cases for the root node. 645 * 646 * NOTE: Real integer handles would allow for more verification 647 * and keep all pointers within this subsystem - however this introduces 648 * more overhead and has not been necessary to this point. Drivers 649 * holding handles are typically notified before a node becomes invalid 650 * due to a table unload. 651 * 652 ******************************************************************************/ 653 654ACPI_NAMESPACE_NODE * 655AcpiNsValidateHandle ( 656 ACPI_HANDLE Handle) 657{ 658 659 ACPI_FUNCTION_ENTRY (); 660 661 662 /* Parameter validation */ 663 664 if ((!Handle) || (Handle == ACPI_ROOT_OBJECT)) 665 { 666 return (AcpiGbl_RootNode); 667 } 668 669 /* We can at least attempt to verify the handle */ 670 671 if (ACPI_GET_DESCRIPTOR_TYPE (Handle) != ACPI_DESC_TYPE_NAMED) 672 { 673 return (NULL); 674 } 675 676 return (ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Handle)); 677} 678 679 680/******************************************************************************* 681 * 682 * FUNCTION: AcpiNsTerminate 683 * 684 * PARAMETERS: none 685 * 686 * RETURN: none 687 * 688 * DESCRIPTION: free memory allocated for namespace and ACPI table storage. 689 * 690 ******************************************************************************/ 691 692void 693AcpiNsTerminate ( 694 void) 695{ 696 ACPI_STATUS Status; 697 698 699 ACPI_FUNCTION_TRACE (NsTerminate); 700 701 702 /* 703 * Free the entire namespace -- all nodes and all objects 704 * attached to the nodes 705 */ 706 AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode); 707 708 /* Delete any objects attached to the root node */ 709 710 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 711 if (ACPI_FAILURE (Status)) 712 { 713 return_VOID; 714 } 715 716 AcpiNsDeleteNode (AcpiGbl_RootNode); 717 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 718 719 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n")); 720 return_VOID; 721} 722 723 724/******************************************************************************* 725 * 726 * FUNCTION: AcpiNsOpensScope 727 * 728 * PARAMETERS: Type - A valid namespace type 729 * 730 * RETURN: NEWSCOPE if the passed type "opens a name scope" according 731 * to the ACPI specification, else 0 732 * 733 ******************************************************************************/ 734 735UINT32 736AcpiNsOpensScope ( 737 ACPI_OBJECT_TYPE Type) 738{ 739 ACPI_FUNCTION_ENTRY (); 740 741 742 if (Type > ACPI_TYPE_LOCAL_MAX) 743 { 744 /* type code out of range */ 745 746 ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type)); 747 return (ACPI_NS_NORMAL); 748 } 749 750 return (((UINT32) AcpiGbl_NsProperties[Type]) & ACPI_NS_NEWSCOPE); 751} 752 753 754/******************************************************************************* 755 * 756 * FUNCTION: AcpiNsGetNodeUnlocked 757 * 758 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The 759 * \ (backslash) and ^ (carat) prefixes, and the 760 * . (period) to separate segments are supported. 761 * PrefixNode - Root of subtree to be searched, or NS_ALL for the 762 * root of the name space. If Name is fully 763 * qualified (first INT8 is '\'), the passed value 764 * of Scope will not be accessed. 765 * Flags - Used to indicate whether to perform upsearch or 766 * not. 767 * ReturnNode - Where the Node is returned 768 * 769 * DESCRIPTION: Look up a name relative to a given scope and return the 770 * corresponding Node. NOTE: Scope can be null. 771 * 772 * MUTEX: Doesn't locks namespace 773 * 774 ******************************************************************************/ 775 776ACPI_STATUS 777AcpiNsGetNodeUnlocked ( 778 ACPI_NAMESPACE_NODE *PrefixNode, 779 const char *Pathname, 780 UINT32 Flags, 781 ACPI_NAMESPACE_NODE **ReturnNode) 782{ 783 ACPI_GENERIC_STATE ScopeInfo; 784 ACPI_STATUS Status; 785 char *InternalPath; 786 787 788 ACPI_FUNCTION_TRACE_PTR (NsGetNodeUnlocked, ACPI_CAST_PTR (char, Pathname)); 789 790 791 /* Simplest case is a null pathname */ 792 793 if (!Pathname) 794 { 795 *ReturnNode = PrefixNode; 796 if (!PrefixNode) 797 { 798 *ReturnNode = AcpiGbl_RootNode; 799 } 800 801 return_ACPI_STATUS (AE_OK); 802 } 803 804 /* Quick check for a reference to the root */ 805 806 if (ACPI_IS_ROOT_PREFIX (Pathname[0]) && (!Pathname[1])) 807 { 808 *ReturnNode = AcpiGbl_RootNode; 809 return_ACPI_STATUS (AE_OK); 810 } 811 812 /* Convert path to internal representation */ 813 814 Status = AcpiNsInternalizeName (Pathname, &InternalPath); 815 if (ACPI_FAILURE (Status)) 816 { 817 return_ACPI_STATUS (Status); 818 } 819 820 /* Setup lookup scope (search starting point) */ 821 822 ScopeInfo.Scope.Node = PrefixNode; 823 824 /* Lookup the name in the namespace */ 825 826 Status = AcpiNsLookup (&ScopeInfo, InternalPath, ACPI_TYPE_ANY, 827 ACPI_IMODE_EXECUTE, (Flags | ACPI_NS_DONT_OPEN_SCOPE), 828 NULL, ReturnNode); 829 if (ACPI_FAILURE (Status)) 830 { 831 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s, %s\n", 832 Pathname, AcpiFormatException (Status))); 833 } 834 835 ACPI_FREE (InternalPath); 836 return_ACPI_STATUS (Status); 837} 838 839 840/******************************************************************************* 841 * 842 * FUNCTION: AcpiNsGetNode 843 * 844 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The 845 * \ (backslash) and ^ (carat) prefixes, and the 846 * . (period) to separate segments are supported. 847 * PrefixNode - Root of subtree to be searched, or NS_ALL for the 848 * root of the name space. If Name is fully 849 * qualified (first INT8 is '\'), the passed value 850 * of Scope will not be accessed. 851 * Flags - Used to indicate whether to perform upsearch or 852 * not. 853 * ReturnNode - Where the Node is returned 854 * 855 * DESCRIPTION: Look up a name relative to a given scope and return the 856 * corresponding Node. NOTE: Scope can be null. 857 * 858 * MUTEX: Locks namespace 859 * 860 ******************************************************************************/ 861 862ACPI_STATUS 863AcpiNsGetNode ( 864 ACPI_NAMESPACE_NODE *PrefixNode, 865 const char *Pathname, 866 UINT32 Flags, 867 ACPI_NAMESPACE_NODE **ReturnNode) 868{ 869 ACPI_STATUS Status; 870 871 872 ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname)); 873 874 875 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 876 if (ACPI_FAILURE (Status)) 877 { 878 return_ACPI_STATUS (Status); 879 } 880 881 Status = AcpiNsGetNodeUnlocked (PrefixNode, Pathname, 882 Flags, ReturnNode); 883 884 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 885 return_ACPI_STATUS (Status); 886} 887