1 /****************************************************************************** 2 * 3 * Module Name: dsobject - Dispatcher object management routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2018, 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.h" 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "amlcode.h" 48 #include "acdispat.h" 49 #include "acnamesp.h" 50 #include "acinterp.h" 51 52 #define _COMPONENT ACPI_DISPATCHER 53 ACPI_MODULE_NAME ("dsobject") 54 55 56 #ifndef ACPI_NO_METHOD_EXECUTION 57 /******************************************************************************* 58 * 59 * FUNCTION: AcpiDsBuildInternalObject 60 * 61 * PARAMETERS: WalkState - Current walk state 62 * Op - Parser object to be translated 63 * ObjDescPtr - Where the ACPI internal object is returned 64 * 65 * RETURN: Status 66 * 67 * DESCRIPTION: Translate a parser Op object to the equivalent namespace object 68 * Simple objects are any objects other than a package object! 69 * 70 ******************************************************************************/ 71 72 ACPI_STATUS 73 AcpiDsBuildInternalObject ( 74 ACPI_WALK_STATE *WalkState, 75 ACPI_PARSE_OBJECT *Op, 76 ACPI_OPERAND_OBJECT **ObjDescPtr) 77 { 78 ACPI_OPERAND_OBJECT *ObjDesc; 79 ACPI_STATUS Status; 80 81 82 ACPI_FUNCTION_TRACE (DsBuildInternalObject); 83 84 85 *ObjDescPtr = NULL; 86 if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) 87 { 88 /* 89 * This is a named object reference. If this name was 90 * previously looked up in the namespace, it was stored in 91 * this op. Otherwise, go ahead and look it up now 92 */ 93 if (!Op->Common.Node) 94 { 95 /* Check if we are resolving a named reference within a package */ 96 97 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) || 98 (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)) 99 { 100 /* 101 * We won't resolve package elements here, we will do this 102 * after all ACPI tables are loaded into the namespace. This 103 * behavior supports both forward references to named objects 104 * and external references to objects in other tables. 105 */ 106 goto CreateNewObject; 107 } 108 else 109 { 110 Status = AcpiNsLookup (WalkState->ScopeInfo, 111 Op->Common.Value.String, 112 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE, 113 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, 114 ACPI_CAST_INDIRECT_PTR ( 115 ACPI_NAMESPACE_NODE, &(Op->Common.Node))); 116 if (ACPI_FAILURE (Status)) 117 { 118 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, 119 Op->Common.Value.String, Status); 120 return_ACPI_STATUS (Status); 121 } 122 } 123 } 124 } 125 126 CreateNewObject: 127 128 /* Create and init a new internal ACPI object */ 129 130 ObjDesc = AcpiUtCreateInternalObject ( 131 (AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode))->ObjectType); 132 if (!ObjDesc) 133 { 134 return_ACPI_STATUS (AE_NO_MEMORY); 135 } 136 137 Status = AcpiDsInitObjectFromOp ( 138 WalkState, Op, Op->Common.AmlOpcode, &ObjDesc); 139 if (ACPI_FAILURE (Status)) 140 { 141 AcpiUtRemoveReference (ObjDesc); 142 return_ACPI_STATUS (Status); 143 } 144 145 /* 146 * Handling for unresolved package reference elements. 147 * These are elements that are namepaths. 148 */ 149 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) || 150 (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)) 151 { 152 ObjDesc->Reference.Resolved = TRUE; 153 154 if ((Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) && 155 !ObjDesc->Reference.Node) 156 { 157 /* 158 * Name was unresolved above. 159 * Get the prefix node for later lookup 160 */ 161 ObjDesc->Reference.Node = WalkState->ScopeInfo->Scope.Node; 162 ObjDesc->Reference.Aml = Op->Common.Aml; 163 ObjDesc->Reference.Resolved = FALSE; 164 } 165 } 166 167 *ObjDescPtr = ObjDesc; 168 return_ACPI_STATUS (Status); 169 } 170 171 172 /******************************************************************************* 173 * 174 * FUNCTION: AcpiDsBuildInternalBufferObj 175 * 176 * PARAMETERS: WalkState - Current walk state 177 * Op - Parser object to be translated 178 * BufferLength - Length of the buffer 179 * ObjDescPtr - Where the ACPI internal object is returned 180 * 181 * RETURN: Status 182 * 183 * DESCRIPTION: Translate a parser Op package object to the equivalent 184 * namespace object 185 * 186 ******************************************************************************/ 187 188 ACPI_STATUS 189 AcpiDsBuildInternalBufferObj ( 190 ACPI_WALK_STATE *WalkState, 191 ACPI_PARSE_OBJECT *Op, 192 UINT32 BufferLength, 193 ACPI_OPERAND_OBJECT **ObjDescPtr) 194 { 195 ACPI_PARSE_OBJECT *Arg; 196 ACPI_OPERAND_OBJECT *ObjDesc; 197 ACPI_PARSE_OBJECT *ByteList; 198 UINT32 ByteListLength = 0; 199 200 201 ACPI_FUNCTION_TRACE (DsBuildInternalBufferObj); 202 203 204 /* 205 * If we are evaluating a Named buffer object "Name (xxxx, Buffer)". 206 * The buffer object already exists (from the NS node), otherwise it must 207 * be created. 208 */ 209 ObjDesc = *ObjDescPtr; 210 if (!ObjDesc) 211 { 212 /* Create a new buffer object */ 213 214 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); 215 *ObjDescPtr = ObjDesc; 216 if (!ObjDesc) 217 { 218 return_ACPI_STATUS (AE_NO_MEMORY); 219 } 220 } 221 222 /* 223 * Second arg is the buffer data (optional) ByteList can be either 224 * individual bytes or a string initializer. In either case, a 225 * ByteList appears in the AML. 226 */ 227 Arg = Op->Common.Value.Arg; /* skip first arg */ 228 229 ByteList = Arg->Named.Next; 230 if (ByteList) 231 { 232 if (ByteList->Common.AmlOpcode != AML_INT_BYTELIST_OP) 233 { 234 ACPI_ERROR ((AE_INFO, 235 "Expecting bytelist, found AML opcode 0x%X in op %p", 236 ByteList->Common.AmlOpcode, ByteList)); 237 238 AcpiUtRemoveReference (ObjDesc); 239 return (AE_TYPE); 240 } 241 242 ByteListLength = (UINT32) ByteList->Common.Value.Integer; 243 } 244 245 /* 246 * The buffer length (number of bytes) will be the larger of: 247 * 1) The specified buffer length and 248 * 2) The length of the initializer byte list 249 */ 250 ObjDesc->Buffer.Length = BufferLength; 251 if (ByteListLength > BufferLength) 252 { 253 ObjDesc->Buffer.Length = ByteListLength; 254 } 255 256 /* Allocate the buffer */ 257 258 if (ObjDesc->Buffer.Length == 0) 259 { 260 ObjDesc->Buffer.Pointer = NULL; 261 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 262 "Buffer defined with zero length in AML, creating\n")); 263 } 264 else 265 { 266 ObjDesc->Buffer.Pointer = 267 ACPI_ALLOCATE_ZEROED (ObjDesc->Buffer.Length); 268 if (!ObjDesc->Buffer.Pointer) 269 { 270 AcpiUtDeleteObjectDesc (ObjDesc); 271 return_ACPI_STATUS (AE_NO_MEMORY); 272 } 273 274 /* Initialize buffer from the ByteList (if present) */ 275 276 if (ByteList) 277 { 278 memcpy (ObjDesc->Buffer.Pointer, ByteList->Named.Data, 279 ByteListLength); 280 } 281 } 282 283 ObjDesc->Buffer.Flags |= AOPOBJ_DATA_VALID; 284 Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc); 285 return_ACPI_STATUS (AE_OK); 286 } 287 288 /******************************************************************************* 289 * 290 * FUNCTION: AcpiDsCreateNode 291 * 292 * PARAMETERS: WalkState - Current walk state 293 * Node - NS Node to be initialized 294 * Op - Parser object to be translated 295 * 296 * RETURN: Status 297 * 298 * DESCRIPTION: Create the object to be associated with a namespace node 299 * 300 ******************************************************************************/ 301 302 ACPI_STATUS 303 AcpiDsCreateNode ( 304 ACPI_WALK_STATE *WalkState, 305 ACPI_NAMESPACE_NODE *Node, 306 ACPI_PARSE_OBJECT *Op) 307 { 308 ACPI_STATUS Status; 309 ACPI_OPERAND_OBJECT *ObjDesc; 310 311 312 ACPI_FUNCTION_TRACE_PTR (DsCreateNode, Op); 313 314 315 /* 316 * Because of the execution pass through the non-control-method 317 * parts of the table, we can arrive here twice. Only init 318 * the named object node the first time through 319 */ 320 if (AcpiNsGetAttachedObject (Node)) 321 { 322 return_ACPI_STATUS (AE_OK); 323 } 324 325 if (!Op->Common.Value.Arg) 326 { 327 /* No arguments, there is nothing to do */ 328 329 return_ACPI_STATUS (AE_OK); 330 } 331 332 /* Build an internal object for the argument(s) */ 333 334 Status = AcpiDsBuildInternalObject ( 335 WalkState, Op->Common.Value.Arg, &ObjDesc); 336 if (ACPI_FAILURE (Status)) 337 { 338 return_ACPI_STATUS (Status); 339 } 340 341 /* Re-type the object according to its argument */ 342 343 Node->Type = ObjDesc->Common.Type; 344 345 /* Attach obj to node */ 346 347 Status = AcpiNsAttachObject (Node, ObjDesc, Node->Type); 348 349 /* Remove local reference to the object */ 350 351 AcpiUtRemoveReference (ObjDesc); 352 return_ACPI_STATUS (Status); 353 } 354 355 #endif /* ACPI_NO_METHOD_EXECUTION */ 356 357 358 /******************************************************************************* 359 * 360 * FUNCTION: AcpiDsInitObjectFromOp 361 * 362 * PARAMETERS: WalkState - Current walk state 363 * Op - Parser op used to init the internal object 364 * Opcode - AML opcode associated with the object 365 * RetObjDesc - Namespace object to be initialized 366 * 367 * RETURN: Status 368 * 369 * DESCRIPTION: Initialize a namespace object from a parser Op and its 370 * associated arguments. The namespace object is a more compact 371 * representation of the Op and its arguments. 372 * 373 ******************************************************************************/ 374 375 ACPI_STATUS 376 AcpiDsInitObjectFromOp ( 377 ACPI_WALK_STATE *WalkState, 378 ACPI_PARSE_OBJECT *Op, 379 UINT16 Opcode, 380 ACPI_OPERAND_OBJECT **RetObjDesc) 381 { 382 const ACPI_OPCODE_INFO *OpInfo; 383 ACPI_OPERAND_OBJECT *ObjDesc; 384 ACPI_STATUS Status = AE_OK; 385 386 387 ACPI_FUNCTION_TRACE (DsInitObjectFromOp); 388 389 390 ObjDesc = *RetObjDesc; 391 OpInfo = AcpiPsGetOpcodeInfo (Opcode); 392 if (OpInfo->Class == AML_CLASS_UNKNOWN) 393 { 394 /* Unknown opcode */ 395 396 return_ACPI_STATUS (AE_TYPE); 397 } 398 399 /* Perform per-object initialization */ 400 401 switch (ObjDesc->Common.Type) 402 { 403 case ACPI_TYPE_BUFFER: 404 /* 405 * Defer evaluation of Buffer TermArg operand 406 */ 407 ObjDesc->Buffer.Node = ACPI_CAST_PTR ( 408 ACPI_NAMESPACE_NODE, WalkState->Operands[0]); 409 ObjDesc->Buffer.AmlStart = Op->Named.Data; 410 ObjDesc->Buffer.AmlLength = Op->Named.Length; 411 break; 412 413 case ACPI_TYPE_PACKAGE: 414 /* 415 * Defer evaluation of Package TermArg operand and all 416 * package elements. (01/2017): We defer the element 417 * resolution to allow forward references from the package 418 * in order to provide compatibility with other ACPI 419 * implementations. 420 */ 421 ObjDesc->Package.Node = ACPI_CAST_PTR ( 422 ACPI_NAMESPACE_NODE, WalkState->Operands[0]); 423 424 if (!Op->Named.Data) 425 { 426 return_ACPI_STATUS (AE_OK); 427 } 428 429 ObjDesc->Package.AmlStart = Op->Named.Data; 430 ObjDesc->Package.AmlLength = Op->Named.Length; 431 break; 432 433 case ACPI_TYPE_INTEGER: 434 435 switch (OpInfo->Type) 436 { 437 case AML_TYPE_CONSTANT: 438 /* 439 * Resolve AML Constants here - AND ONLY HERE! 440 * All constants are integers. 441 * We mark the integer with a flag that indicates that it started 442 * life as a constant -- so that stores to constants will perform 443 * as expected (noop). ZeroOp is used as a placeholder for optional 444 * target operands. 445 */ 446 ObjDesc->Common.Flags = AOPOBJ_AML_CONSTANT; 447 448 switch (Opcode) 449 { 450 case AML_ZERO_OP: 451 452 ObjDesc->Integer.Value = 0; 453 break; 454 455 case AML_ONE_OP: 456 457 ObjDesc->Integer.Value = 1; 458 break; 459 460 case AML_ONES_OP: 461 462 ObjDesc->Integer.Value = ACPI_UINT64_MAX; 463 464 /* Truncate value if we are executing from a 32-bit ACPI table */ 465 466 #ifndef ACPI_NO_METHOD_EXECUTION 467 (void) AcpiExTruncateFor32bitTable (ObjDesc); 468 #endif 469 break; 470 471 case AML_REVISION_OP: 472 473 ObjDesc->Integer.Value = ACPI_CA_VERSION; 474 break; 475 476 default: 477 478 ACPI_ERROR ((AE_INFO, 479 "Unknown constant opcode 0x%X", Opcode)); 480 Status = AE_AML_OPERAND_TYPE; 481 break; 482 } 483 break; 484 485 case AML_TYPE_LITERAL: 486 487 ObjDesc->Integer.Value = Op->Common.Value.Integer; 488 489 #ifndef ACPI_NO_METHOD_EXECUTION 490 if (AcpiExTruncateFor32bitTable (ObjDesc)) 491 { 492 /* Warn if we found a 64-bit constant in a 32-bit table */ 493 494 ACPI_WARNING ((AE_INFO, 495 "Truncated 64-bit constant found in 32-bit table: %8.8X%8.8X => %8.8X", 496 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer), 497 (UINT32) ObjDesc->Integer.Value)); 498 } 499 #endif 500 break; 501 502 default: 503 504 ACPI_ERROR ((AE_INFO, "Unknown Integer type 0x%X", 505 OpInfo->Type)); 506 Status = AE_AML_OPERAND_TYPE; 507 break; 508 } 509 break; 510 511 case ACPI_TYPE_STRING: 512 513 ObjDesc->String.Pointer = Op->Common.Value.String; 514 ObjDesc->String.Length = (UINT32) strlen (Op->Common.Value.String); 515 516 /* 517 * The string is contained in the ACPI table, don't ever try 518 * to delete it 519 */ 520 ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER; 521 break; 522 523 case ACPI_TYPE_METHOD: 524 break; 525 526 case ACPI_TYPE_LOCAL_REFERENCE: 527 528 switch (OpInfo->Type) 529 { 530 case AML_TYPE_LOCAL_VARIABLE: 531 532 /* Local ID (0-7) is (AML opcode - base AML_FIRST_LOCAL_OP) */ 533 534 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_LOCAL_OP; 535 ObjDesc->Reference.Class = ACPI_REFCLASS_LOCAL; 536 537 #ifndef ACPI_NO_METHOD_EXECUTION 538 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_LOCAL, 539 ObjDesc->Reference.Value, WalkState, 540 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, 541 &ObjDesc->Reference.Object)); 542 #endif 543 break; 544 545 case AML_TYPE_METHOD_ARGUMENT: 546 547 /* Arg ID (0-6) is (AML opcode - base AML_FIRST_ARG_OP) */ 548 549 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_ARG_OP; 550 ObjDesc->Reference.Class = ACPI_REFCLASS_ARG; 551 552 #ifndef ACPI_NO_METHOD_EXECUTION 553 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_ARG, 554 ObjDesc->Reference.Value, WalkState, 555 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, 556 &ObjDesc->Reference.Object)); 557 #endif 558 break; 559 560 default: /* Object name or Debug object */ 561 562 switch (Op->Common.AmlOpcode) 563 { 564 case AML_INT_NAMEPATH_OP: 565 566 /* Node was saved in Op */ 567 568 ObjDesc->Reference.Node = Op->Common.Node; 569 ObjDesc->Reference.Class = ACPI_REFCLASS_NAME; 570 if (Op->Common.Node) 571 { 572 ObjDesc->Reference.Object = Op->Common.Node->Object; 573 } 574 break; 575 576 case AML_DEBUG_OP: 577 578 ObjDesc->Reference.Class = ACPI_REFCLASS_DEBUG; 579 break; 580 581 default: 582 583 ACPI_ERROR ((AE_INFO, 584 "Unimplemented reference type for AML opcode: 0x%4.4X", Opcode)); 585 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 586 } 587 break; 588 } 589 break; 590 591 default: 592 593 ACPI_ERROR ((AE_INFO, "Unimplemented data type: 0x%X", 594 ObjDesc->Common.Type)); 595 596 Status = AE_AML_OPERAND_TYPE; 597 break; 598 } 599 600 return_ACPI_STATUS (Status); 601 } 602