sys/contrib/dev/acpica/source/components/dispatcher/dsmethod.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsmethod - Parser/Interpreter interface - control method parsing
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, 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 #define __DSMETHOD_C__
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "acdispat.h"
  49 #include "acinterp.h"
  50 #include "acnamesp.h"
  51 #include "acdisasm.h"
  52
  53
  54 #define _COMPONENT          ACPI_DISPATCHER
  55         ACPI_MODULE_NAME    ("dsmethod")
  56
  57 /* Local prototypes */
  58
  59 static ACPI_STATUS
  60 AcpiDsCreateMethodMutex (
  61     ACPI_OPERAND_OBJECT     *MethodDesc);
  62
  63
  64 /*******************************************************************************
  65  *
  66  * FUNCTION:    AcpiDsMethodError
  67  *
  68  * PARAMETERS:  Status          - Execution status
  69  *              WalkState       - Current state
  70  *
  71  * RETURN:      Status
  72  *
  73  * DESCRIPTION: Called on method error. Invoke the global exception handler if
  74  *              present, dump the method data if the disassembler is configured
  75  *
  76  *              Note: Allows the exception handler to change the status code
  77  *
  78  ******************************************************************************/
  79
  80 ACPI_STATUS
  81 AcpiDsMethodError (
  82     ACPI_STATUS             Status,
  83     ACPI_WALK_STATE         *WalkState)
  84 {
  85     ACPI_FUNCTION_ENTRY ();
  86
  87
  88     /* Ignore AE_OK and control exception codes */
  89
  90     if (ACPI_SUCCESS (Status) ||
  91         (Status & AE_CODE_CONTROL))
  92     {
  93         return (Status);
  94     }
  95
  96     /* Invoke the global exception handler */
  97
  98     if (AcpiGbl_ExceptionHandler)
  99     {
 100         /* Exit the interpreter, allow handler to execute methods */
 101
 102         AcpiExExitInterpreter ();
 103
 104         /*
 105          * Handler can map the exception code to anything it wants, including
 106          * AE_OK, in which case the executing method will not be aborted.
 107          */
 108         Status = AcpiGbl_ExceptionHandler (Status,
 109                     WalkState->MethodNode ?
 110                         WalkState->MethodNode->Name.Integer : 0,
 111                     WalkState->Opcode, WalkState->AmlOffset, NULL);
 112         AcpiExEnterInterpreter ();
 113     }
 114
 115     AcpiDsClearImplicitReturn (WalkState);
 116
 117 #ifdef ACPI_DISASSEMBLER
 118     if (ACPI_FAILURE (Status))
 119     {
 120         /* Display method locals/args if disassembler is present */
 121
 122         AcpiDmDumpMethodInfo (Status, WalkState, WalkState->Op);
 123     }
 124 #endif
 125
 126     return (Status);
 127 }
 128
 129
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    AcpiDsCreateMethodMutex
 133  *
 134  * PARAMETERS:  ObjDesc             - The method object
 135  *
 136  * RETURN:      Status
 137  *
 138  * DESCRIPTION: Create a mutex object for a serialized control method
 139  *
 140  ******************************************************************************/
 141
 142 static ACPI_STATUS
 143 AcpiDsCreateMethodMutex (
 144     ACPI_OPERAND_OBJECT     *MethodDesc)
 145 {
 146     ACPI_OPERAND_OBJECT     *MutexDesc;
 147     ACPI_STATUS             Status;
 148
 149
 150     ACPI_FUNCTION_TRACE (DsCreateMethodMutex);
 151
 152
 153     /* Create the new mutex object */
 154
 155     MutexDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX);
 156     if (!MutexDesc)
 157     {
 158         return_ACPI_STATUS (AE_NO_MEMORY);
 159     }
 160
 161     /* Create the actual OS Mutex */
 162
 163     Status = AcpiOsCreateMutex (&MutexDesc->Mutex.OsMutex);
 164     if (ACPI_FAILURE (Status))
 165     {
 166         AcpiUtDeleteObjectDesc (MutexDesc);
 167         return_ACPI_STATUS (Status);
 168     }
 169
 170     MutexDesc->Mutex.SyncLevel = MethodDesc->Method.SyncLevel;
 171     MethodDesc->Method.Mutex = MutexDesc;
 172     return_ACPI_STATUS (AE_OK);
 173 }
 174
 175
 176 /*******************************************************************************
 177  *
 178  * FUNCTION:    AcpiDsBeginMethodExecution
 179  *
 180  * PARAMETERS:  MethodNode          - Node of the method
 181  *              ObjDesc             - The method object
 182  *              WalkState           - current state, NULL if not yet executing
 183  *                                    a method.
 184  *
 185  * RETURN:      Status
 186  *
 187  * DESCRIPTION: Prepare a method for execution. Parses the method if necessary,
 188  *              increments the thread count, and waits at the method semaphore
 189  *              for clearance to execute.
 190  *
 191  ******************************************************************************/
 192
 193 ACPI_STATUS
 194 AcpiDsBeginMethodExecution (
 195     ACPI_NAMESPACE_NODE     *MethodNode,
 196     ACPI_OPERAND_OBJECT     *ObjDesc,
 197     ACPI_WALK_STATE         *WalkState)
 198 {
 199     ACPI_STATUS             Status = AE_OK;
 200
 201
 202     ACPI_FUNCTION_TRACE_PTR (DsBeginMethodExecution, MethodNode);
 203
 204
 205     if (!MethodNode)
 206     {
 207         return_ACPI_STATUS (AE_NULL_ENTRY);
 208     }
 209
 210     /* Prevent wraparound of thread count */
 211
 212     if (ObjDesc->Method.ThreadCount == ACPI_UINT8_MAX)
 213     {
 214         ACPI_ERROR ((AE_INFO,
 215             "Method reached maximum reentrancy limit (255)"));
 216         return_ACPI_STATUS (AE_AML_METHOD_LIMIT);
 217     }
 218
 219     /*
 220      * If this method is serialized, we need to acquire the method mutex.
 221      */
 222     if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)
 223     {
 224         /*
 225          * Create a mutex for the method if it is defined to be Serialized
 226          * and a mutex has not already been created. We defer the mutex creation
 227          * until a method is actually executed, to minimize the object count
 228          */
 229         if (!ObjDesc->Method.Mutex)
 230         {
 231             Status = AcpiDsCreateMethodMutex (ObjDesc);
 232             if (ACPI_FAILURE (Status))
 233             {
 234                 return_ACPI_STATUS (Status);
 235             }
 236         }
 237
 238         /*
 239          * The CurrentSyncLevel (per-thread) must be less than or equal to
 240          * the sync level of the method. This mechanism provides some
 241          * deadlock prevention
 242          *
 243          * Top-level method invocation has no walk state at this point
 244          */
 245         if (WalkState &&
 246             (WalkState->Thread->CurrentSyncLevel > ObjDesc->Method.Mutex->Mutex.SyncLevel))
 247         {
 248             ACPI_ERROR ((AE_INFO,
 249                 "Cannot acquire Mutex for method [%4.4s], current SyncLevel is too large (%u)",
 250                 AcpiUtGetNodeName (MethodNode),
 251                 WalkState->Thread->CurrentSyncLevel));
 252
 253             return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
 254         }
 255
 256         /*
 257          * Obtain the method mutex if necessary. Do not acquire mutex for a
 258          * recursive call.
 259          */
 260         if (!WalkState ||
 261             !ObjDesc->Method.Mutex->Mutex.ThreadId ||
 262             (WalkState->Thread->ThreadId != ObjDesc->Method.Mutex->Mutex.ThreadId))
 263         {
 264             /*
 265              * Acquire the method mutex. This releases the interpreter if we
 266              * block (and reacquires it before it returns)
 267              */
 268             Status = AcpiExSystemWaitMutex (ObjDesc->Method.Mutex->Mutex.OsMutex,
 269                         ACPI_WAIT_FOREVER);
 270             if (ACPI_FAILURE (Status))
 271             {
 272                 return_ACPI_STATUS (Status);
 273             }
 274
 275             /* Update the mutex and walk info and save the original SyncLevel */
 276
 277             if (WalkState)
 278             {
 279                 ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
 280                     WalkState->Thread->CurrentSyncLevel;
 281
 282                 ObjDesc->Method.Mutex->Mutex.ThreadId = WalkState->Thread->ThreadId;
 283                 WalkState->Thread->CurrentSyncLevel = ObjDesc->Method.SyncLevel;
 284             }
 285             else
 286             {
 287                 ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =
 288                     ObjDesc->Method.Mutex->Mutex.SyncLevel;
 289             }
 290         }
 291
 292         /* Always increase acquisition depth */
 293
 294         ObjDesc->Method.Mutex->Mutex.AcquisitionDepth++;
 295     }
 296
 297     /*
 298      * Allocate an Owner ID for this method, only if this is the first thread
 299      * to begin concurrent execution. We only need one OwnerId, even if the
 300      * method is invoked recursively.
 301      */
 302     if (!ObjDesc->Method.OwnerId)
 303     {
 304         Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
 305         if (ACPI_FAILURE (Status))
 306         {
 307             goto Cleanup;
 308         }
 309     }
 310
 311     /*
 312      * Increment the method parse tree thread count since it has been
 313      * reentered one more time (even if it is the same thread)
 314      */
 315     ObjDesc->Method.ThreadCount++;
 316     AcpiMethodCount++;
 317     return_ACPI_STATUS (Status);
 318
 319
 320 Cleanup:
 321     /* On error, must release the method mutex (if present) */
 322
 323     if (ObjDesc->Method.Mutex)
 324     {
 325         AcpiOsReleaseMutex (ObjDesc->Method.Mutex->Mutex.OsMutex);
 326     }
 327     return_ACPI_STATUS (Status);
 328 }
 329
 330
 331 /*******************************************************************************
 332  *
 333  * FUNCTION:    AcpiDsCallControlMethod
 334  *
 335  * PARAMETERS:  Thread              - Info for this thread
 336  *              ThisWalkState       - Current walk state
 337  *              Op                  - Current Op to be walked
 338  *
 339  * RETURN:      Status
 340  *
 341  * DESCRIPTION: Transfer execution to a called control method
 342  *
 343  ******************************************************************************/
 344
 345 ACPI_STATUS
 346 AcpiDsCallControlMethod (
 347     ACPI_THREAD_STATE       *Thread,
 348     ACPI_WALK_STATE         *ThisWalkState,
 349     ACPI_PARSE_OBJECT       *Op)
 350 {
 351     ACPI_STATUS             Status;
 352     ACPI_NAMESPACE_NODE     *MethodNode;
 353     ACPI_WALK_STATE         *NextWalkState = NULL;
 354     ACPI_OPERAND_OBJECT     *ObjDesc;
 355     ACPI_EVALUATE_INFO      *Info;
 356     UINT32                  i;
 357
 358
 359     ACPI_FUNCTION_TRACE_PTR (DsCallControlMethod, ThisWalkState);
 360
 361     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Calling method %p, currentstate=%p\n",
 362         ThisWalkState->PrevOp, ThisWalkState));
 363
 364     /*
 365      * Get the namespace entry for the control method we are about to call
 366      */
 367     MethodNode = ThisWalkState->MethodCallNode;
 368     if (!MethodNode)
 369     {
 370         return_ACPI_STATUS (AE_NULL_ENTRY);
 371     }
 372
 373     ObjDesc = AcpiNsGetAttachedObject (MethodNode);
 374     if (!ObjDesc)
 375     {
 376         return_ACPI_STATUS (AE_NULL_OBJECT);
 377     }
 378
 379     /* Init for new method, possibly wait on method mutex */
 380
 381     Status = AcpiDsBeginMethodExecution (MethodNode, ObjDesc,
 382                 ThisWalkState);
 383     if (ACPI_FAILURE (Status))
 384     {
 385         return_ACPI_STATUS (Status);
 386     }
 387
 388     /* Begin method parse/execution. Create a new walk state */
 389
 390     NextWalkState = AcpiDsCreateWalkState (ObjDesc->Method.OwnerId,
 391                         NULL, ObjDesc, Thread);
 392     if (!NextWalkState)
 393     {
 394         Status = AE_NO_MEMORY;
 395         goto Cleanup;
 396     }
 397
 398     /*
 399      * The resolved arguments were put on the previous walk state's operand
 400      * stack. Operands on the previous walk state stack always
 401      * start at index 0. Also, null terminate the list of arguments
 402      */
 403     ThisWalkState->Operands [ThisWalkState->NumOperands] = NULL;
 404
 405     /*
 406      * Allocate and initialize the evaluation information block
 407      * TBD: this is somewhat inefficient, should change interface to
 408      * DsInitAmlWalk. For now, keeps this struct off the CPU stack
 409      */
 410     Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
 411     if (!Info)
 412     {
 413         Status = AE_NO_MEMORY;
 414         goto Cleanup;
 415     }
 416
 417     Info->Parameters = &ThisWalkState->Operands[0];
 418
 419     Status = AcpiDsInitAmlWalk (NextWalkState, NULL, MethodNode,
 420                 ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength,
 421                 Info, ACPI_IMODE_EXECUTE);
 422
 423     ACPI_FREE (Info);
 424     if (ACPI_FAILURE (Status))
 425     {
 426         goto Cleanup;
 427     }
 428
 429     /*
 430      * Delete the operands on the previous walkstate operand stack
 431      * (they were copied to new objects)
 432      */
 433     for (i = 0; i < ObjDesc->Method.ParamCount; i++)
 434     {
 435         AcpiUtRemoveReference (ThisWalkState->Operands [i]);
 436         ThisWalkState->Operands [i] = NULL;
 437     }
 438
 439     /* Clear the operand stack */
 440
 441     ThisWalkState->NumOperands = 0;
 442
 443     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 444         "**** Begin nested execution of [%4.4s] **** WalkState=%p\n",
 445         MethodNode->Name.Ascii, NextWalkState));
 446
 447     /* Invoke an internal method if necessary */
 448
 449     if (ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY)
 450     {
 451         Status = ObjDesc->Method.Dispatch.Implementation (NextWalkState);
 452         if (Status == AE_OK)
 453         {
 454             Status = AE_CTRL_TERMINATE;
 455         }
 456     }
 457
 458     return_ACPI_STATUS (Status);
 459
 460
 461 Cleanup:
 462
 463     /* On error, we must terminate the method properly */
 464
 465     AcpiDsTerminateControlMethod (ObjDesc, NextWalkState);
 466     if (NextWalkState)
 467     {
 468         AcpiDsDeleteWalkState (NextWalkState);
 469     }
 470
 471     return_ACPI_STATUS (Status);
 472 }
 473
 474
 475 /*******************************************************************************
 476  *
 477  * FUNCTION:    AcpiDsRestartControlMethod
 478  *
 479  * PARAMETERS:  WalkState           - State for preempted method (caller)
 480  *              ReturnDesc          - Return value from the called method
 481  *
 482  * RETURN:      Status
 483  *
 484  * DESCRIPTION: Restart a method that was preempted by another (nested) method
 485  *              invocation. Handle the return value (if any) from the callee.
 486  *
 487  ******************************************************************************/
 488
 489 ACPI_STATUS
 490 AcpiDsRestartControlMethod (
 491     ACPI_WALK_STATE         *WalkState,
 492     ACPI_OPERAND_OBJECT     *ReturnDesc)
 493 {
 494     ACPI_STATUS             Status;
 495     int                     SameAsImplicitReturn;
 496
 497
 498     ACPI_FUNCTION_TRACE_PTR (DsRestartControlMethod, WalkState);
 499
 500
 501     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 502         "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
 503         AcpiUtGetNodeName (WalkState->MethodNode),
 504         WalkState->MethodCallOp, ReturnDesc));
 505
 506     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 507         "    ReturnFromThisMethodUsed?=%X ResStack %p Walk %p\n",
 508         WalkState->ReturnUsed,
 509         WalkState->Results, WalkState));
 510
 511     /* Did the called method return a value? */
 512
 513     if (ReturnDesc)
 514     {
 515         /* Is the implicit return object the same as the return desc? */
 516
 517         SameAsImplicitReturn = (WalkState->ImplicitReturnObj == ReturnDesc);
 518
 519         /* Are we actually going to use the return value? */
 520
 521         if (WalkState->ReturnUsed)
 522         {
 523             /* Save the return value from the previous method */
 524
 525             Status = AcpiDsResultPush (ReturnDesc, WalkState);
 526             if (ACPI_FAILURE (Status))
 527             {
 528                 AcpiUtRemoveReference (ReturnDesc);
 529                 return_ACPI_STATUS (Status);
 530             }
 531
 532             /*
 533              * Save as THIS method's return value in case it is returned
 534              * immediately to yet another method
 535              */
 536             WalkState->ReturnDesc = ReturnDesc;
 537         }
 538
 539         /*
 540          * The following code is the optional support for the so-called
 541          * "implicit return". Some AML code assumes that the last value of the
 542          * method is "implicitly" returned to the caller, in the absence of an
 543          * explicit return value.
 544          *
 545          * Just save the last result of the method as the return value.
 546          *
 547          * NOTE: this is optional because the ASL language does not actually
 548          * support this behavior.
 549          */
 550         else if (!AcpiDsDoImplicitReturn (ReturnDesc, WalkState, FALSE) ||
 551                  SameAsImplicitReturn)
 552         {
 553             /*
 554              * Delete the return value if it will not be used by the
 555              * calling method or remove one reference if the explicit return
 556              * is the same as the implicit return value.
 557              */
 558             AcpiUtRemoveReference (ReturnDesc);
 559         }
 560     }
 561
 562     return_ACPI_STATUS (AE_OK);
 563 }
 564
 565
 566 /*******************************************************************************
 567  *
 568  * FUNCTION:    AcpiDsTerminateControlMethod
 569  *
 570  * PARAMETERS:  MethodDesc          - Method object
 571  *              WalkState           - State associated with the method
 572  *
 573  * RETURN:      None
 574  *
 575  * DESCRIPTION: Terminate a control method. Delete everything that the method
 576  *              created, delete all locals and arguments, and delete the parse
 577  *              tree if requested.
 578  *
 579  * MUTEX:       Interpreter is locked
 580  *
 581  ******************************************************************************/
 582
 583 void
 584 AcpiDsTerminateControlMethod (
 585     ACPI_OPERAND_OBJECT     *MethodDesc,
 586     ACPI_WALK_STATE         *WalkState)
 587 {
 588
 589     ACPI_FUNCTION_TRACE_PTR (DsTerminateControlMethod, WalkState);
 590
 591
 592     /* MethodDesc is required, WalkState is optional */
 593
 594     if (!MethodDesc)
 595     {
 596         return_VOID;
 597     }
 598
 599     if (WalkState)
 600     {
 601         /* Delete all arguments and locals */
 602
 603         AcpiDsMethodDataDeleteAll (WalkState);
 604
 605         /*
 606          * If method is serialized, release the mutex and restore the
 607          * current sync level for this thread
 608          */
 609         if (MethodDesc->Method.Mutex)
 610         {
 611             /* Acquisition Depth handles recursive calls */
 612
 613             MethodDesc->Method.Mutex->Mutex.AcquisitionDepth--;
 614             if (!MethodDesc->Method.Mutex->Mutex.AcquisitionDepth)
 615             {
 616                 WalkState->Thread->CurrentSyncLevel =
 617                     MethodDesc->Method.Mutex->Mutex.OriginalSyncLevel;
 618
 619                 AcpiOsReleaseMutex (MethodDesc->Method.Mutex->Mutex.OsMutex);
 620                 MethodDesc->Method.Mutex->Mutex.ThreadId = 0;
 621             }
 622         }
 623
 624         /*
 625          * Delete any namespace objects created anywhere within the
 626          * namespace by the execution of this method. Unless:
 627          * 1) This method is a module-level executable code method, in which
 628          *    case we want make the objects permanent.
 629          * 2) There are other threads executing the method, in which case we
 630          *    will wait until the last thread has completed.
 631          */
 632         if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL) &&
 633              (MethodDesc->Method.ThreadCount == 1))
 634         {
 635             /* Delete any direct children of (created by) this method */
 636
 637             AcpiNsDeleteNamespaceSubtree (WalkState->MethodNode);
 638
 639             /*
 640              * Delete any objects that were created by this method
 641              * elsewhere in the namespace (if any were created).
 642              * Use of the ACPI_METHOD_MODIFIED_NAMESPACE optimizes the
 643              * deletion such that we don't have to perform an entire
 644              * namespace walk for every control method execution.
 645              */
 646             if (MethodDesc->Method.InfoFlags & ACPI_METHOD_MODIFIED_NAMESPACE)
 647             {
 648                 AcpiNsDeleteNamespaceByOwner (MethodDesc->Method.OwnerId);
 649                 MethodDesc->Method.InfoFlags &= ~ACPI_METHOD_MODIFIED_NAMESPACE;
 650             }
 651         }
 652     }
 653
 654     /* Decrement the thread count on the method */
 655
 656     if (MethodDesc->Method.ThreadCount)
 657     {
 658         MethodDesc->Method.ThreadCount--;
 659     }
 660     else
 661     {
 662         ACPI_ERROR ((AE_INFO,
 663             "Invalid zero thread count in method"));
 664     }
 665
 666     /* Are there any other threads currently executing this method? */
 667
 668     if (MethodDesc->Method.ThreadCount)
 669     {
 670         /*
 671          * Additional threads. Do not release the OwnerId in this case,
 672          * we immediately reuse it for the next thread executing this method
 673          */
 674         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 675             "*** Completed execution of one thread, %u threads remaining\n",
 676             MethodDesc->Method.ThreadCount));
 677     }
 678     else
 679     {
 680         /* This is the only executing thread for this method */
 681
 682         /*
 683          * Support to dynamically change a method from NotSerialized to
 684          * Serialized if it appears that the method is incorrectly written and
 685          * does not support multiple thread execution. The best example of this
 686          * is if such a method creates namespace objects and blocks. A second
 687          * thread will fail with an AE_ALREADY_EXISTS exception.
 688          *
 689          * This code is here because we must wait until the last thread exits
 690          * before marking the method as serialized.
 691          */
 692         if (MethodDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED_PENDING)
 693         {
 694             if (WalkState)
 695             {
 696                 ACPI_INFO ((AE_INFO,
 697                     "Marking method %4.4s as Serialized because of AE_ALREADY_EXISTS error",
 698                     WalkState->MethodNode->Name.Ascii));
 699             }
 700
 701             /*
 702              * Method tried to create an object twice and was marked as
 703              * "pending serialized". The probable cause is that the method
 704              * cannot handle reentrancy.
 705              *
 706              * The method was created as NotSerialized, but it tried to create
 707              * a named object and then blocked, causing the second thread
 708              * entrance to begin and then fail. Workaround this problem by
 709              * marking the method permanently as Serialized when the last
 710              * thread exits here.
 711              */
 712             MethodDesc->Method.InfoFlags &= ~ACPI_METHOD_SERIALIZED_PENDING;
 713             MethodDesc->Method.InfoFlags |= ACPI_METHOD_SERIALIZED;
 714             MethodDesc->Method.SyncLevel = 0;
 715         }
 716
 717         /* No more threads, we can free the OwnerId */
 718
 719         if (!(MethodDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL))
 720         {
 721             AcpiUtReleaseOwnerId (&MethodDesc->Method.OwnerId);
 722         }
 723     }
 724
 725     return_VOID;
 726 }