sys/contrib/dev/acpica-unix-20040527/INTERPRETER/DISPATCHER/dsmethod.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsmethod - Parser/Interpreter interface - control method parsing
   4  *              $Revision: 97 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #define __DSMETHOD_C__
 118
 119 #include "acpi.h"
 120 #include "acparser.h"
 121 #include "amlcode.h"
 122 #include "acdispat.h"
 123 #include "acinterp.h"
 124 #include "acnamesp.h"
 125
 126
 127 #define _COMPONENT          ACPI_DISPATCHER
 128         ACPI_MODULE_NAME    ("dsmethod")
 129
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    AcpiDsParseMethod
 134  *
 135  * PARAMETERS:  ObjHandle       - Node of the method
 136  *              Level           - Current nesting level
 137  *              Context         - Points to a method counter
 138  *              ReturnValue     - Not used
 139  *
 140  * RETURN:      Status
 141  *
 142  * DESCRIPTION: Call the parser and parse the AML that is
 143  *              associated with the method.
 144  *
 145  * MUTEX:       Assumes parser is locked
 146  *
 147  ******************************************************************************/
 148
 149 ACPI_STATUS
 150 AcpiDsParseMethod (
 151     ACPI_HANDLE             ObjHandle)
 152 {
 153     ACPI_STATUS             Status;
 154     ACPI_OPERAND_OBJECT     *ObjDesc;
 155     ACPI_PARSE_OBJECT       *Op;
 156     ACPI_NAMESPACE_NODE     *Node;
 157     ACPI_OWNER_ID           OwnerId;
 158     ACPI_WALK_STATE         *WalkState;
 159
 160
 161     ACPI_FUNCTION_TRACE_PTR ("DsParseMethod", ObjHandle);
 162
 163
 164     /* Parameter Validation */
 165
 166     if (!ObjHandle)
 167     {
 168         return_ACPI_STATUS (AE_NULL_ENTRY);
 169     }
 170
 171     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Parsing [%4.4s] **** NamedObj=%p\n",
 172         AcpiUtGetNodeName (ObjHandle), ObjHandle));
 173
 174     /* Extract the method object from the method Node */
 175
 176     Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 177     ObjDesc = AcpiNsGetAttachedObject (Node);
 178     if (!ObjDesc)
 179     {
 180         return_ACPI_STATUS (AE_NULL_OBJECT);
 181     }
 182
 183     /* Create a mutex for the method if there is a concurrency limit */
 184
 185     if ((ObjDesc->Method.Concurrency != ACPI_INFINITE_CONCURRENCY) &&
 186         (!ObjDesc->Method.Semaphore))
 187     {
 188         Status = AcpiOsCreateSemaphore (ObjDesc->Method.Concurrency,
 189                                         ObjDesc->Method.Concurrency,
 190                                         &ObjDesc->Method.Semaphore);
 191         if (ACPI_FAILURE (Status))
 192         {
 193             return_ACPI_STATUS (Status);
 194         }
 195     }
 196
 197     /*
 198      * Allocate a new parser op to be the root of the parsed
 199      * method tree
 200      */
 201     Op = AcpiPsAllocOp (AML_METHOD_OP);
 202     if (!Op)
 203     {
 204         return_ACPI_STATUS (AE_NO_MEMORY);
 205     }
 206
 207     /* Init new op with the method name and pointer back to the Node */
 208
 209     AcpiPsSetName (Op, Node->Name.Integer);
 210     Op->Common.Node = Node;
 211
 212     /*
 213      * Get a new OwnerId for objects created by this method.  Namespace
 214      * objects (such as Operation Regions) can be created during the
 215      * first pass parse.
 216      */
 217     OwnerId = AcpiUtAllocateOwnerId (ACPI_OWNER_TYPE_METHOD);
 218     ObjDesc->Method.OwningId = OwnerId;
 219
 220     /* Create and initialize a new walk state */
 221
 222     WalkState = AcpiDsCreateWalkState (OwnerId, NULL, NULL, NULL);
 223     if (!WalkState)
 224     {
 225         return_ACPI_STATUS (AE_NO_MEMORY);
 226     }
 227
 228     Status = AcpiDsInitAmlWalk (WalkState, Op, Node,
 229                     ObjDesc->Method.AmlStart,
 230                     ObjDesc->Method.AmlLength, NULL, 1);
 231     if (ACPI_FAILURE (Status))
 232     {
 233         AcpiDsDeleteWalkState (WalkState);
 234         return_ACPI_STATUS (Status);
 235     }
 236
 237     /*
 238      * Parse the method, first pass
 239      *
 240      * The first pass load is where newly declared named objects are
 241      * added into the namespace.  Actual evaluation of
 242      * the named objects (what would be called a "second
 243      * pass") happens during the actual execution of the
 244      * method so that operands to the named objects can
 245      * take on dynamic run-time values.
 246      */
 247     Status = AcpiPsParseAml (WalkState);
 248     if (ACPI_FAILURE (Status))
 249     {
 250         return_ACPI_STATUS (Status);
 251     }
 252
 253     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 254         "**** [%4.4s] Parsed **** NamedObj=%p Op=%p\n",
 255         AcpiUtGetNodeName (ObjHandle), ObjHandle, Op));
 256
 257     AcpiPsDeleteParseTree (Op);
 258     return_ACPI_STATUS (Status);
 259 }
 260
 261
 262 /*******************************************************************************
 263  *
 264  * FUNCTION:    AcpiDsBeginMethodExecution
 265  *
 266  * PARAMETERS:  MethodNode          - Node of the method
 267  *              ObjDesc             - The method object
 268  *              CallingMethodNode   - Caller of this method (if non-null)
 269  *
 270  * RETURN:      Status
 271  *
 272  * DESCRIPTION: Prepare a method for execution.  Parses the method if necessary,
 273  *              increments the thread count, and waits at the method semaphore
 274  *              for clearance to execute.
 275  *
 276  * MUTEX:       Locks/unlocks parser.
 277  *
 278  ******************************************************************************/
 279
 280 ACPI_STATUS
 281 AcpiDsBeginMethodExecution (
 282     ACPI_NAMESPACE_NODE     *MethodNode,
 283     ACPI_OPERAND_OBJECT     *ObjDesc,
 284     ACPI_NAMESPACE_NODE     *CallingMethodNode)
 285 {
 286     ACPI_STATUS             Status = AE_OK;
 287
 288
 289     ACPI_FUNCTION_TRACE_PTR ("DsBeginMethodExecution", MethodNode);
 290
 291
 292     if (!MethodNode)
 293     {
 294         return_ACPI_STATUS (AE_NULL_ENTRY);
 295     }
 296
 297     /*
 298      * If there is a concurrency limit on this method, we need to
 299      * obtain a unit from the method semaphore.
 300      */
 301     if (ObjDesc->Method.Semaphore)
 302     {
 303         /*
 304          * Allow recursive method calls, up to the reentrancy/concurrency
 305          * limit imposed by the SERIALIZED rule and the SyncLevel method
 306          * parameter.
 307          *
 308          * The point of this code is to avoid permanently blocking a
 309          * thread that is making recursive method calls.
 310          */
 311         if (MethodNode == CallingMethodNode)
 312         {
 313             if (ObjDesc->Method.ThreadCount >= ObjDesc->Method.Concurrency)
 314             {
 315                 return_ACPI_STATUS (AE_AML_METHOD_LIMIT);
 316             }
 317         }
 318
 319         /*
 320          * Get a unit from the method semaphore. This releases the
 321          * interpreter if we block
 322          */
 323         Status = AcpiExSystemWaitSemaphore (ObjDesc->Method.Semaphore,
 324                                             ACPI_WAIT_FOREVER);
 325     }
 326
 327     /*
 328      * Increment the method parse tree thread count since it has been
 329      * reentered one more time (even if it is the same thread)
 330      */
 331     ObjDesc->Method.ThreadCount++;
 332     return_ACPI_STATUS (Status);
 333 }
 334
 335
 336 /*******************************************************************************
 337  *
 338  * FUNCTION:    AcpiDsCallControlMethod
 339  *
 340  * PARAMETERS:  WalkState           - Current state of the walk
 341  *              Op                  - Current Op to be walked
 342  *
 343  * RETURN:      Status
 344  *
 345  * DESCRIPTION: Transfer execution to a called control method
 346  *
 347  ******************************************************************************/
 348
 349 ACPI_STATUS
 350 AcpiDsCallControlMethod (
 351     ACPI_THREAD_STATE       *Thread,
 352     ACPI_WALK_STATE         *ThisWalkState,
 353     ACPI_PARSE_OBJECT       *Op)
 354 {
 355     ACPI_STATUS             Status;
 356     ACPI_NAMESPACE_NODE     *MethodNode;
 357     ACPI_WALK_STATE         *NextWalkState;
 358     ACPI_OPERAND_OBJECT     *ObjDesc;
 359     ACPI_PARAMETER_INFO     Info;
 360     UINT32                  i;
 361
 362
 363     ACPI_FUNCTION_TRACE_PTR ("DsCallControlMethod", ThisWalkState);
 364
 365     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Execute method %p, currentstate=%p\n",
 366         ThisWalkState->PrevOp, ThisWalkState));
 367
 368     /*
 369      * Get the namespace entry for the control method we are about to call
 370      */
 371     MethodNode = ThisWalkState->MethodCallNode;
 372     if (!MethodNode)
 373     {
 374         return_ACPI_STATUS (AE_NULL_ENTRY);
 375     }
 376
 377     ObjDesc = AcpiNsGetAttachedObject (MethodNode);
 378     if (!ObjDesc)
 379     {
 380         return_ACPI_STATUS (AE_NULL_OBJECT);
 381     }
 382
 383     ObjDesc->Method.OwningId = AcpiUtAllocateOwnerId (ACPI_OWNER_TYPE_METHOD);
 384
 385     /* Init for new method, wait on concurrency semaphore */
 386
 387     Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc,
 388                     ThisWalkState->MethodNode);
 389     if (ACPI_FAILURE (Status))
 390     {
 391         return_ACPI_STATUS (Status);
 392     }
 393
 394     if (!(ObjDesc->Method.MethodFlags & AML_METHOD_INTERNAL_ONLY))
 395     {
 396         /* 1) Parse: Create a new walk state for the preempting walk */
 397
 398         NextWalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwningId,
 399                                                 Op, ObjDesc, NULL);
 400         if (!NextWalkState)
 401         {
 402             return_ACPI_STATUS (AE_NO_MEMORY);
 403         }
 404
 405         /* Create and init a Root Node */
 406
 407         Op = AcpiPsCreateScopeOp ();
 408         if (!Op)
 409         {
 410             Status = AE_NO_MEMORY;
 411             goto Cleanup;
 412         }
 413
 414         Status = AcpiDsInitAmlWalk (NextWalkState, Op, MethodNode,
 415                         ObjDesc->Method.AmlStart,  ObjDesc->Method.AmlLength,
 416                         NULL, 1);
 417         if (ACPI_FAILURE (Status))
 418         {
 419             AcpiDsDeleteWalkState (NextWalkState);
 420             goto Cleanup;
 421         }
 422
 423         /* Begin AML parse */
 424
 425         Status = AcpiPsParseAml (NextWalkState);
 426         AcpiPsDeleteParseTree (Op);
 427     }
 428
 429     /* 2) Execute: Create a new state for the preempting walk */
 430
 431     NextWalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwningId,
 432                                             NULL, ObjDesc, Thread);
 433     if (!NextWalkState)
 434     {
 435         Status = AE_NO_MEMORY;
 436         goto Cleanup;
 437     }
 438     /*
 439      * The resolved arguments were put on the previous walk state's operand
 440      * stack.  Operands on the previous walk state stack always
 441      * start at index 0.
 442      * Null terminate the list of arguments
 443      */
 444     ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL;
 445
 446     Info.Parameters = &ThisWalkState->Operands[0];
 447     Info.ParameterType = ACPI_PARAM_ARGS;
 448
 449     Status = AcpiDsInitAmlWalk (NextWalkState, NULL, MethodNode,
 450                     ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength,
 451                     &Info, 3);
 452     if (ACPI_FAILURE (Status))
 453     {
 454         goto Cleanup;
 455     }
 456
 457     /*
 458      * Delete the operands on the previous walkstate operand stack
 459      * (they were copied to new objects)
 460      */
 461     for (i = 0; i < ObjDesc->Method.ParamCount; i++)
 462     {
 463         AcpiUtRemoveReference (ThisWalkState->Operands [i]);
 464         ThisWalkState->Operands [i] = NULL;
 465     }
 466
 467     /* Clear the operand stack */
 468
 469     ThisWalkState->NumOperands = 0;
 470
 471     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 472         "Starting nested execution, newstate=%p\n", NextWalkState));
 473
 474     if (ObjDesc->Method.MethodFlags & AML_METHOD_INTERNAL_ONLY)
 475     {
 476         Status = ObjDesc->Method.Implementation (NextWalkState);
 477         return_ACPI_STATUS (Status);
 478     }
 479
 480     return_ACPI_STATUS (AE_OK);
 481
 482
 483     /* On error, we must delete the new walk state */
 484
 485 Cleanup:
 486     if (NextWalkState && (NextWalkState->MethodDesc))
 487     {
 488         /* Decrement the thread count on the method parse tree */
 489
 490        NextWalkState->MethodDesc->Method.ThreadCount--;
 491     }
 492     (void) AcpiDsTerminateControlMethod (NextWalkState);
 493     AcpiDsDeleteWalkState (NextWalkState);
 494     return_ACPI_STATUS (Status);
 495 }
 496
 497
 498 /*******************************************************************************
 499  *
 500  * FUNCTION:    AcpiDsRestartControlMethod
 501  *
 502  * PARAMETERS:  WalkState           - State of the method when it was preempted
 503  *              Op                  - Pointer to new current op
 504  *
 505  * RETURN:      Status
 506  *
 507  * DESCRIPTION: Restart a method that was preempted
 508  *
 509  ******************************************************************************/
 510
 511 ACPI_STATUS
 512 AcpiDsRestartControlMethod (
 513     ACPI_WALK_STATE         *WalkState,
 514     ACPI_OPERAND_OBJECT     *ReturnDesc)
 515 {
 516     ACPI_STATUS             Status;
 517
 518
 519     ACPI_FUNCTION_TRACE_PTR ("DsRestartControlMethod", WalkState);
 520
 521
 522     if (ReturnDesc)
 523     {
 524         if (WalkState->ReturnUsed)
 525         {
 526             /*
 527              * Get the return value (if any) from the previous method.
 528              * NULL if no return value
 529              */
 530             Status = AcpiDsResultPush (ReturnDesc, WalkState);
 531             if (ACPI_FAILURE (Status))
 532             {
 533                 AcpiUtRemoveReference (ReturnDesc);
 534                 return_ACPI_STATUS (Status);
 535             }
 536         }
 537         else
 538         {
 539             /*
 540              * Delete the return value if it will not be used by the
 541              * calling method
 542              */
 543             AcpiUtRemoveReference (ReturnDesc);
 544         }
 545     }
 546
 547     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 548         "Method=%p Return=%p ReturnUsed?=%X ResStack=%p State=%p\n",
 549         WalkState->MethodCallOp, ReturnDesc, WalkState->ReturnUsed,
 550         WalkState->Results, WalkState));
 551
 552     return_ACPI_STATUS (AE_OK);
 553 }
 554
 555
 556 /*******************************************************************************
 557  *
 558  * FUNCTION:    AcpiDsTerminateControlMethod
 559  *
 560  * PARAMETERS:  WalkState           - State of the method
 561  *
 562  * RETURN:      Status
 563  *
 564  * DESCRIPTION: Terminate a control method.  Delete everything that the method
 565  *              created, delete all locals and arguments, and delete the parse
 566  *              tree if requested.
 567  *
 568  ******************************************************************************/
 569
 570 ACPI_STATUS
 571 AcpiDsTerminateControlMethod (
 572     ACPI_WALK_STATE         *WalkState)
 573 {
 574     ACPI_OPERAND_OBJECT     *ObjDesc;
 575     ACPI_NAMESPACE_NODE     *MethodNode;
 576     ACPI_STATUS             Status;
 577
 578
 579     ACPI_FUNCTION_TRACE_PTR ("DsTerminateControlMethod", WalkState);
 580
 581
 582     if (!WalkState)
 583     {
 584         return (AE_BAD_PARAMETER);
 585     }
 586
 587     /* The current method object was saved in the walk state */
 588
 589     ObjDesc = WalkState->MethodDesc;
 590     if (!ObjDesc)
 591     {
 592         return_ACPI_STATUS (AE_OK);
 593     }
 594
 595     /* Delete all arguments and locals */
 596
 597     AcpiDsMethodDataDeleteAll (WalkState);
 598
 599     /*
 600      * Lock the parser while we terminate this method.
 601      * If this is the last thread executing the method,
 602      * we have additional cleanup to perform
 603      */
 604     Status = AcpiUtAcquireMutex (ACPI_MTX_PARSER);
 605     if (ACPI_FAILURE (Status))
 606     {
 607         return_ACPI_STATUS (Status);
 608     }
 609
 610     /* Signal completion of the execution of this method if necessary */
 611
 612     if (WalkState->MethodDesc->Method.Semaphore)
 613     {
 614         Status = AcpiOsSignalSemaphore (
 615                         WalkState->MethodDesc->Method.Semaphore, 1);
 616         if (ACPI_FAILURE (Status))
 617         {
 618             ACPI_REPORT_ERROR (("Could not signal method semaphore\n"));
 619             Status = AE_OK;
 620
 621             /* Ignore error and continue cleanup */
 622         }
 623     }
 624
 625     if (WalkState->MethodDesc->Method.ThreadCount)
 626     {
 627         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 628             "*** Not deleting method namespace, there are still %d threads\n",
 629             WalkState->MethodDesc->Method.ThreadCount));
 630     }
 631
 632     if (!WalkState->MethodDesc->Method.ThreadCount)
 633     {
 634         /*
 635          * Support to dynamically change a method from NotSerialized to
 636          * Serialized if it appears that the method is written foolishly and
 637          * does not support multiple thread execution.  The best example of this
 638          * is if such a method creates namespace objects and blocks.  A second
 639          * thread will fail with an AE_ALREADY_EXISTS exception
 640          *
 641          * This code is here because we must wait until the last thread exits
 642          * before creating the synchronization semaphore.
 643          */
 644         if ((WalkState->MethodDesc->Method.Concurrency == 1) &&
 645             (!WalkState->MethodDesc->Method.Semaphore))
 646         {
 647             Status = AcpiOsCreateSemaphore (1,
 648                                     1,
 649                                     &WalkState->MethodDesc->Method.Semaphore);
 650         }
 651
 652         /*
 653          * There are no more threads executing this method.  Perform
 654          * additional cleanup.
 655          *
 656          * The method Node is stored in the walk state
 657          */
 658         MethodNode = WalkState->MethodNode;
 659
 660         /*
 661          * Delete any namespace entries created immediately underneath
 662          * the method
 663          */
 664         Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 665         if (ACPI_FAILURE (Status))
 666         {
 667             return_ACPI_STATUS (Status);
 668         }
 669
 670         if (MethodNode->Child)
 671         {
 672             AcpiNsDeleteNamespaceSubtree (MethodNode);
 673         }
 674
 675         /*
 676          * Delete any namespace entries created anywhere else within
 677          * the namespace
 678          */
 679         AcpiNsDeleteNamespaceByOwner (WalkState->MethodDesc->Method.OwningId);
 680         Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 681         if (ACPI_FAILURE (Status))
 682         {
 683             return_ACPI_STATUS (Status);
 684         }
 685     }
 686
 687     Status = AcpiUtReleaseMutex (ACPI_MTX_PARSER);
 688     return_ACPI_STATUS (Status);
 689 }
 690
 691