sys/contrib/dev/acpica/source/components/debugger/dbexec.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbexec - debugger control method execution
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, 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 "acdebug.h"
  47 #include "acnamesp.h"
  48
  49 #ifdef ACPI_DEBUGGER
  50
  51 #define _COMPONENT          ACPI_CA_DEBUGGER
  52         ACPI_MODULE_NAME    ("dbexec")
  53
  54
  55 static ACPI_DB_METHOD_INFO          AcpiGbl_DbMethodInfo;
  56
  57 /* Local prototypes */
  58
  59 static ACPI_STATUS
  60 AcpiDbExecuteMethod (
  61     ACPI_DB_METHOD_INFO     *Info,
  62     ACPI_BUFFER             *ReturnObj);
  63
  64 static ACPI_STATUS
  65 AcpiDbExecuteSetup (
  66     ACPI_DB_METHOD_INFO     *Info);
  67
  68 static UINT32
  69 AcpiDbGetOutstandingAllocations (
  70     void);
  71
  72 static void ACPI_SYSTEM_XFACE
  73 AcpiDbMethodThread (
  74     void                    *Context);
  75
  76 static ACPI_STATUS
  77 AcpiDbExecutionWalk (
  78     ACPI_HANDLE             ObjHandle,
  79     UINT32                  NestingLevel,
  80     void                    *Context,
  81     void                    **ReturnValue);
  82
  83
  84 /*******************************************************************************
  85  *
  86  * FUNCTION:    AcpiDbDeleteObjects
  87  *
  88  * PARAMETERS:  Count               - Count of objects in the list
  89  *              Objects             - Array of ACPI_OBJECTs to be deleted
  90  *
  91  * RETURN:      None
  92  *
  93  * DESCRIPTION: Delete a list of ACPI_OBJECTS. Handles packages and nested
  94  *              packages via recursion.
  95  *
  96  ******************************************************************************/
  97
  98 void
  99 AcpiDbDeleteObjects (
 100     UINT32                  Count,
 101     ACPI_OBJECT             *Objects)
 102 {
 103     UINT32                  i;
 104
 105
 106     for (i = 0; i < Count; i++)
 107     {
 108         switch (Objects[i].Type)
 109         {
 110         case ACPI_TYPE_BUFFER:
 111
 112             ACPI_FREE (Objects[i].Buffer.Pointer);
 113             break;
 114
 115         case ACPI_TYPE_PACKAGE:
 116
 117             /* Recursive call to delete package elements */
 118
 119             AcpiDbDeleteObjects (Objects[i].Package.Count,
 120                 Objects[i].Package.Elements);
 121
 122             /* Free the elements array */
 123
 124             ACPI_FREE (Objects[i].Package.Elements);
 125             break;
 126
 127         default:
 128
 129             break;
 130         }
 131     }
 132 }
 133
 134
 135 /*******************************************************************************
 136  *
 137  * FUNCTION:    AcpiDbExecuteMethod
 138  *
 139  * PARAMETERS:  Info            - Valid info segment
 140  *              ReturnObj       - Where to put return object
 141  *
 142  * RETURN:      Status
 143  *
 144  * DESCRIPTION: Execute a control method.
 145  *
 146  ******************************************************************************/
 147
 148 static ACPI_STATUS
 149 AcpiDbExecuteMethod (
 150     ACPI_DB_METHOD_INFO     *Info,
 151     ACPI_BUFFER             *ReturnObj)
 152 {
 153     ACPI_STATUS             Status;
 154     ACPI_OBJECT_LIST        ParamObjects;
 155     ACPI_OBJECT             Params[ACPI_DEBUGGER_MAX_ARGS + 1];
 156     UINT32                  i;
 157
 158
 159     ACPI_FUNCTION_TRACE (DbExecuteMethod);
 160
 161
 162     if (AcpiGbl_DbOutputToFile && !AcpiDbgLevel)
 163     {
 164         AcpiOsPrintf ("Warning: debug output is not enabled!\n");
 165     }
 166
 167     ParamObjects.Count = 0;
 168     ParamObjects.Pointer = NULL;
 169
 170     /* Pass through any command-line arguments */
 171
 172     if (Info->Args && Info->Args[0])
 173     {
 174         /* Get arguments passed on the command line */
 175
 176         for (i = 0; (Info->Args[i] && *(Info->Args[i])); i++)
 177         {
 178             /* Convert input string (token) to an actual ACPI_OBJECT */
 179
 180             Status = AcpiDbConvertToObject (Info->Types[i],
 181                 Info->Args[i], &Params[i]);
 182             if (ACPI_FAILURE (Status))
 183             {
 184                 ACPI_EXCEPTION ((AE_INFO, Status,
 185                     "While parsing method arguments"));
 186                 goto Cleanup;
 187             }
 188         }
 189
 190         ParamObjects.Count = i;
 191         ParamObjects.Pointer = Params;
 192     }
 193
 194     /* Prepare for a return object of arbitrary size */
 195
 196     ReturnObj->Pointer = AcpiGbl_DbBuffer;
 197     ReturnObj->Length  = ACPI_DEBUG_BUFFER_SIZE;
 198
 199     /* Do the actual method execution */
 200
 201     AcpiGbl_MethodExecuting = TRUE;
 202     Status = AcpiEvaluateObject (NULL, Info->Pathname,
 203         &ParamObjects, ReturnObj);
 204
 205     AcpiGbl_CmSingleStep = FALSE;
 206     AcpiGbl_MethodExecuting = FALSE;
 207
 208     if (ACPI_FAILURE (Status))
 209     {
 210         ACPI_EXCEPTION ((AE_INFO, Status,
 211             "while executing %s from debugger", Info->Pathname));
 212
 213         if (Status == AE_BUFFER_OVERFLOW)
 214         {
 215             ACPI_ERROR ((AE_INFO,
 216                 "Possible overflow of internal debugger "
 217                 "buffer (size 0x%X needed 0x%X)",
 218                 ACPI_DEBUG_BUFFER_SIZE, (UINT32) ReturnObj->Length));
 219         }
 220     }
 221
 222 Cleanup:
 223     AcpiDbDeleteObjects (ParamObjects.Count, Params);
 224     return_ACPI_STATUS (Status);
 225 }
 226
 227
 228 /*******************************************************************************
 229  *
 230  * FUNCTION:    AcpiDbExecuteSetup
 231  *
 232  * PARAMETERS:  Info            - Valid method info
 233  *
 234  * RETURN:      None
 235  *
 236  * DESCRIPTION: Setup info segment prior to method execution
 237  *
 238  ******************************************************************************/
 239
 240 static ACPI_STATUS
 241 AcpiDbExecuteSetup (
 242     ACPI_DB_METHOD_INFO     *Info)
 243 {
 244     ACPI_STATUS             Status;
 245
 246
 247     ACPI_FUNCTION_NAME (DbExecuteSetup);
 248
 249
 250     /* Catenate the current scope to the supplied name */
 251
 252     Info->Pathname[0] = 0;
 253     if ((Info->Name[0] != '\\') &&
 254         (Info->Name[0] != '/'))
 255     {
 256         if (AcpiUtSafeStrcat (Info->Pathname, sizeof (Info->Pathname),
 257             AcpiGbl_DbScopeBuf))
 258         {
 259             Status = AE_BUFFER_OVERFLOW;
 260             goto ErrorExit;
 261         }
 262     }
 263
 264     if (AcpiUtSafeStrcat (Info->Pathname, sizeof (Info->Pathname),
 265         Info->Name))
 266     {
 267         Status = AE_BUFFER_OVERFLOW;
 268         goto ErrorExit;
 269     }
 270
 271     AcpiDbPrepNamestring (Info->Pathname);
 272
 273     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 274     AcpiOsPrintf ("Evaluating %s\n", Info->Pathname);
 275
 276     if (Info->Flags & EX_SINGLE_STEP)
 277     {
 278         AcpiGbl_CmSingleStep = TRUE;
 279         AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 280     }
 281
 282     else
 283     {
 284         /* No single step, allow redirection to a file */
 285
 286         AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 287     }
 288
 289     return (AE_OK);
 290
 291 ErrorExit:
 292
 293     ACPI_EXCEPTION ((AE_INFO, Status, "During setup for method execution"));
 294     return (Status);
 295 }
 296
 297
 298 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 299 UINT32
 300 AcpiDbGetCacheInfo (
 301     ACPI_MEMORY_LIST        *Cache)
 302 {
 303
 304     return (Cache->TotalAllocated - Cache->TotalFreed - Cache->CurrentDepth);
 305 }
 306 #endif
 307
 308 /*******************************************************************************
 309  *
 310  * FUNCTION:    AcpiDbGetOutstandingAllocations
 311  *
 312  * PARAMETERS:  None
 313  *
 314  * RETURN:      Current global allocation count minus cache entries
 315  *
 316  * DESCRIPTION: Determine the current number of "outstanding" allocations --
 317  *              those allocations that have not been freed and also are not
 318  *              in one of the various object caches.
 319  *
 320  ******************************************************************************/
 321
 322 static UINT32
 323 AcpiDbGetOutstandingAllocations (
 324     void)
 325 {
 326     UINT32                  Outstanding = 0;
 327
 328 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 329
 330     Outstanding += AcpiDbGetCacheInfo (AcpiGbl_StateCache);
 331     Outstanding += AcpiDbGetCacheInfo (AcpiGbl_PsNodeCache);
 332     Outstanding += AcpiDbGetCacheInfo (AcpiGbl_PsNodeExtCache);
 333     Outstanding += AcpiDbGetCacheInfo (AcpiGbl_OperandCache);
 334 #endif
 335
 336     return (Outstanding);
 337 }
 338
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    AcpiDbExecutionWalk
 343  *
 344  * PARAMETERS:  WALK_CALLBACK
 345  *
 346  * RETURN:      Status
 347  *
 348  * DESCRIPTION: Execute a control method. Name is relative to the current
 349  *              scope.
 350  *
 351  ******************************************************************************/
 352
 353 static ACPI_STATUS
 354 AcpiDbExecutionWalk (
 355     ACPI_HANDLE             ObjHandle,
 356     UINT32                  NestingLevel,
 357     void                    *Context,
 358     void                    **ReturnValue)
 359 {
 360     ACPI_OPERAND_OBJECT     *ObjDesc;
 361     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 362     ACPI_BUFFER             ReturnObj;
 363     ACPI_STATUS             Status;
 364
 365
 366     ObjDesc = AcpiNsGetAttachedObject (Node);
 367     if (ObjDesc->Method.ParamCount)
 368     {
 369         return (AE_OK);
 370     }
 371
 372     ReturnObj.Pointer = NULL;
 373     ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
 374
 375     AcpiNsPrintNodePathname (Node, "Evaluating");
 376
 377     /* Do the actual method execution */
 378
 379     AcpiOsPrintf ("\n");
 380     AcpiGbl_MethodExecuting = TRUE;
 381
 382     Status = AcpiEvaluateObject (Node, NULL, NULL, &ReturnObj);
 383
 384     AcpiOsPrintf ("Evaluation of [%4.4s] returned %s\n",
 385         AcpiUtGetNodeName (Node),
 386         AcpiFormatException (Status));
 387
 388     AcpiGbl_MethodExecuting = FALSE;
 389     return (AE_OK);
 390 }
 391
 392
 393 /*******************************************************************************
 394  *
 395  * FUNCTION:    AcpiDbExecute
 396  *
 397  * PARAMETERS:  Name                - Name of method to execute
 398  *              Args                - Parameters to the method
 399  *              Types               -
 400  *              Flags               - single step/no single step
 401  *
 402  * RETURN:      None
 403  *
 404  * DESCRIPTION: Execute a control method. Name is relative to the current
 405  *              scope.
 406  *
 407  ******************************************************************************/
 408
 409 void
 410 AcpiDbExecute (
 411     char                    *Name,
 412     char                    **Args,
 413     ACPI_OBJECT_TYPE        *Types,
 414     UINT32                  Flags)
 415 {
 416     ACPI_STATUS             Status;
 417     ACPI_BUFFER             ReturnObj;
 418     char                    *NameString;
 419
 420 #ifdef ACPI_DEBUG_OUTPUT
 421     UINT32                  PreviousAllocations;
 422     UINT32                  Allocations;
 423
 424
 425     /* Memory allocation tracking */
 426
 427     PreviousAllocations = AcpiDbGetOutstandingAllocations ();
 428 #endif
 429
 430     if (*Name == '*')
 431     {
 432         (void) AcpiWalkNamespace (ACPI_TYPE_METHOD, ACPI_ROOT_OBJECT,
 433             ACPI_UINT32_MAX, AcpiDbExecutionWalk, NULL, NULL, NULL);
 434         return;
 435     }
 436     else
 437     {
 438         NameString = ACPI_ALLOCATE (strlen (Name) + 1);
 439         if (!NameString)
 440         {
 441             return;
 442         }
 443
 444         memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
 445
 446         strcpy (NameString, Name);
 447         AcpiUtStrupr (NameString);
 448         AcpiGbl_DbMethodInfo.Name = NameString;
 449         AcpiGbl_DbMethodInfo.Args = Args;
 450         AcpiGbl_DbMethodInfo.Types = Types;
 451         AcpiGbl_DbMethodInfo.Flags = Flags;
 452
 453         ReturnObj.Pointer = NULL;
 454         ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
 455
 456         Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
 457         if (ACPI_FAILURE (Status))
 458         {
 459             ACPI_FREE (NameString);
 460             return;
 461         }
 462
 463         /* Get the NS node, determines existence also */
 464
 465         Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
 466             &AcpiGbl_DbMethodInfo.Method);
 467         if (ACPI_SUCCESS (Status))
 468         {
 469             Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo,
 470                 &ReturnObj);
 471         }
 472         ACPI_FREE (NameString);
 473     }
 474
 475     /*
 476      * Allow any handlers in separate threads to complete.
 477      * (Such as Notify handlers invoked from AML executed above).
 478      */
 479     AcpiOsSleep ((UINT64) 10);
 480
 481 #ifdef ACPI_DEBUG_OUTPUT
 482
 483     /* Memory allocation tracking */
 484
 485     Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations;
 486
 487     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 488
 489     if (Allocations > 0)
 490     {
 491         AcpiOsPrintf (
 492             "0x%X Outstanding allocations after evaluation of %s\n",
 493             Allocations, AcpiGbl_DbMethodInfo.Pathname);
 494     }
 495 #endif
 496
 497     if (ACPI_FAILURE (Status))
 498     {
 499         AcpiOsPrintf ("Evaluation of %s failed with status %s\n",
 500             AcpiGbl_DbMethodInfo.Pathname,
 501             AcpiFormatException (Status));
 502     }
 503     else
 504     {
 505         /* Display a return object, if any */
 506
 507         if (ReturnObj.Length)
 508         {
 509             AcpiOsPrintf (
 510                 "Evaluation of %s returned object %p, "
 511                 "external buffer length %X\n",
 512                 AcpiGbl_DbMethodInfo.Pathname, ReturnObj.Pointer,
 513                 (UINT32) ReturnObj.Length);
 514
 515             AcpiDbDumpExternalObject (ReturnObj.Pointer, 1);
 516
 517             /* Dump a _PLD buffer if present */
 518
 519             if (ACPI_COMPARE_NAME ((ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
 520                     AcpiGbl_DbMethodInfo.Method)->Name.Ascii),
 521                     METHOD_NAME__PLD))
 522             {
 523                 AcpiDbDumpPldBuffer (ReturnObj.Pointer);
 524             }
 525         }
 526         else
 527         {
 528             AcpiOsPrintf ("No object was returned from evaluation of %s\n",
 529                 AcpiGbl_DbMethodInfo.Pathname);
 530         }
 531     }
 532
 533     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 534 }
 535
 536
 537 /*******************************************************************************
 538  *
 539  * FUNCTION:    AcpiDbMethodThread
 540  *
 541  * PARAMETERS:  Context             - Execution info segment
 542  *
 543  * RETURN:      None
 544  *
 545  * DESCRIPTION: Debugger execute thread. Waits for a command line, then
 546  *              simply dispatches it.
 547  *
 548  ******************************************************************************/
 549
 550 static void ACPI_SYSTEM_XFACE
 551 AcpiDbMethodThread (
 552     void                    *Context)
 553 {
 554     ACPI_STATUS             Status;
 555     ACPI_DB_METHOD_INFO     *Info = Context;
 556     ACPI_DB_METHOD_INFO     LocalInfo;
 557     UINT32                  i;
 558     UINT8                   Allow;
 559     ACPI_BUFFER             ReturnObj;
 560
 561
 562     /*
 563      * AcpiGbl_DbMethodInfo.Arguments will be passed as method arguments.
 564      * Prevent AcpiGbl_DbMethodInfo from being modified by multiple threads
 565      * concurrently.
 566      *
 567      * Note: The arguments we are passing are used by the ASL test suite
 568      * (aslts). Do not change them without updating the tests.
 569      */
 570     (void) AcpiOsWaitSemaphore (Info->InfoGate, 1, ACPI_WAIT_FOREVER);
 571
 572     if (Info->InitArgs)
 573     {
 574         AcpiDbUint32ToHexString (Info->NumCreated,
 575             Info->IndexOfThreadStr);
 576         AcpiDbUint32ToHexString ((UINT32) AcpiOsGetThreadId (),
 577             Info->IdOfThreadStr);
 578     }
 579
 580     if (Info->Threads && (Info->NumCreated < Info->NumThreads))
 581     {
 582         Info->Threads[Info->NumCreated++] = AcpiOsGetThreadId();
 583     }
 584
 585     LocalInfo = *Info;
 586     LocalInfo.Args = LocalInfo.Arguments;
 587     LocalInfo.Arguments[0] = LocalInfo.NumThreadsStr;
 588     LocalInfo.Arguments[1] = LocalInfo.IdOfThreadStr;
 589     LocalInfo.Arguments[2] = LocalInfo.IndexOfThreadStr;
 590     LocalInfo.Arguments[3] = NULL;
 591
 592     LocalInfo.Types = LocalInfo.ArgTypes;
 593
 594     (void) AcpiOsSignalSemaphore (Info->InfoGate, 1);
 595
 596     for (i = 0; i < Info->NumLoops; i++)
 597     {
 598         Status = AcpiDbExecuteMethod (&LocalInfo, &ReturnObj);
 599         if (ACPI_FAILURE (Status))
 600         {
 601             AcpiOsPrintf ("%s During evaluation of %s at iteration %X\n",
 602                 AcpiFormatException (Status), Info->Pathname, i);
 603             if (Status == AE_ABORT_METHOD)
 604             {
 605                 break;
 606             }
 607         }
 608
 609 #if 0
 610         if ((i % 100) == 0)
 611         {
 612             AcpiOsPrintf ("%u loops, Thread 0x%x\n",
 613                 i, AcpiOsGetThreadId ());
 614         }
 615
 616         if (ReturnObj.Length)
 617         {
 618             AcpiOsPrintf ("Evaluation of %s returned object %p Buflen %X\n",
 619                 Info->Pathname, ReturnObj.Pointer, (UINT32) ReturnObj.Length);
 620             AcpiDbDumpExternalObject (ReturnObj.Pointer, 1);
 621         }
 622 #endif
 623     }
 624
 625     /* Signal our completion */
 626
 627     Allow = 0;
 628     (void) AcpiOsWaitSemaphore (Info->ThreadCompleteGate,
 629         1, ACPI_WAIT_FOREVER);
 630     Info->NumCompleted++;
 631
 632     if (Info->NumCompleted == Info->NumThreads)
 633     {
 634         /* Do signal for main thread once only */
 635         Allow = 1;
 636     }
 637
 638     (void) AcpiOsSignalSemaphore (Info->ThreadCompleteGate, 1);
 639
 640     if (Allow)
 641     {
 642         Status = AcpiOsSignalSemaphore (Info->MainThreadGate, 1);
 643         if (ACPI_FAILURE (Status))
 644         {
 645             AcpiOsPrintf (
 646                 "Could not signal debugger thread sync semaphore, %s\n",
 647                 AcpiFormatException (Status));
 648         }
 649     }
 650 }
 651
 652
 653 /*******************************************************************************
 654  *
 655  * FUNCTION:    AcpiDbCreateExecutionThreads
 656  *
 657  * PARAMETERS:  NumThreadsArg           - Number of threads to create
 658  *              NumLoopsArg             - Loop count for the thread(s)
 659  *              MethodNameArg           - Control method to execute
 660  *
 661  * RETURN:      None
 662  *
 663  * DESCRIPTION: Create threads to execute method(s)
 664  *
 665  ******************************************************************************/
 666
 667 void
 668 AcpiDbCreateExecutionThreads (
 669     char                    *NumThreadsArg,
 670     char                    *NumLoopsArg,
 671     char                    *MethodNameArg)
 672 {
 673     ACPI_STATUS             Status;
 674     UINT32                  NumThreads;
 675     UINT32                  NumLoops;
 676     UINT32                  i;
 677     UINT32                  Size;
 678     ACPI_MUTEX              MainThreadGate;
 679     ACPI_MUTEX              ThreadCompleteGate;
 680     ACPI_MUTEX              InfoGate;
 681
 682
 683     /* Get the arguments */
 684
 685     NumThreads = strtoul (NumThreadsArg, NULL, 0);
 686     NumLoops   = strtoul (NumLoopsArg, NULL, 0);
 687
 688     if (!NumThreads || !NumLoops)
 689     {
 690         AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n",
 691             NumThreads, NumLoops);
 692         return;
 693     }
 694
 695     /*
 696      * Create the semaphore for synchronization of
 697      * the created threads with the main thread.
 698      */
 699     Status = AcpiOsCreateSemaphore (1, 0, &MainThreadGate);
 700     if (ACPI_FAILURE (Status))
 701     {
 702         AcpiOsPrintf ("Could not create semaphore for "
 703             "synchronization with the main thread, %s\n",
 704             AcpiFormatException (Status));
 705         return;
 706     }
 707
 708     /*
 709      * Create the semaphore for synchronization
 710      * between the created threads.
 711      */
 712     Status = AcpiOsCreateSemaphore (1, 1, &ThreadCompleteGate);
 713     if (ACPI_FAILURE (Status))
 714     {
 715         AcpiOsPrintf ("Could not create semaphore for "
 716             "synchronization between the created threads, %s\n",
 717             AcpiFormatException (Status));
 718
 719         (void) AcpiOsDeleteSemaphore (MainThreadGate);
 720         return;
 721     }
 722
 723     Status = AcpiOsCreateSemaphore (1, 1, &InfoGate);
 724     if (ACPI_FAILURE (Status))
 725     {
 726         AcpiOsPrintf ("Could not create semaphore for "
 727             "synchronization of AcpiGbl_DbMethodInfo, %s\n",
 728             AcpiFormatException (Status));
 729
 730         (void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
 731         (void) AcpiOsDeleteSemaphore (MainThreadGate);
 732         return;
 733     }
 734
 735     memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
 736
 737     /* Array to store IDs of threads */
 738
 739     AcpiGbl_DbMethodInfo.NumThreads = NumThreads;
 740     Size = sizeof (ACPI_THREAD_ID) * AcpiGbl_DbMethodInfo.NumThreads;
 741
 742     AcpiGbl_DbMethodInfo.Threads = AcpiOsAllocate (Size);
 743     if (AcpiGbl_DbMethodInfo.Threads == NULL)
 744     {
 745         AcpiOsPrintf ("No memory for thread IDs array\n");
 746         (void) AcpiOsDeleteSemaphore (MainThreadGate);
 747         (void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
 748         (void) AcpiOsDeleteSemaphore (InfoGate);
 749         return;
 750     }
 751     memset (AcpiGbl_DbMethodInfo.Threads, 0, Size);
 752
 753     /* Setup the context to be passed to each thread */
 754
 755     AcpiGbl_DbMethodInfo.Name = MethodNameArg;
 756     AcpiGbl_DbMethodInfo.Flags = 0;
 757     AcpiGbl_DbMethodInfo.NumLoops = NumLoops;
 758     AcpiGbl_DbMethodInfo.MainThreadGate = MainThreadGate;
 759     AcpiGbl_DbMethodInfo.ThreadCompleteGate = ThreadCompleteGate;
 760     AcpiGbl_DbMethodInfo.InfoGate = InfoGate;
 761
 762     /* Init arguments to be passed to method */
 763
 764     AcpiGbl_DbMethodInfo.InitArgs = 1;
 765     AcpiGbl_DbMethodInfo.Args = AcpiGbl_DbMethodInfo.Arguments;
 766     AcpiGbl_DbMethodInfo.Arguments[0] = AcpiGbl_DbMethodInfo.NumThreadsStr;
 767     AcpiGbl_DbMethodInfo.Arguments[1] = AcpiGbl_DbMethodInfo.IdOfThreadStr;
 768     AcpiGbl_DbMethodInfo.Arguments[2] = AcpiGbl_DbMethodInfo.IndexOfThreadStr;
 769     AcpiGbl_DbMethodInfo.Arguments[3] = NULL;
 770
 771     AcpiGbl_DbMethodInfo.Types = AcpiGbl_DbMethodInfo.ArgTypes;
 772     AcpiGbl_DbMethodInfo.ArgTypes[0] = ACPI_TYPE_INTEGER;
 773     AcpiGbl_DbMethodInfo.ArgTypes[1] = ACPI_TYPE_INTEGER;
 774     AcpiGbl_DbMethodInfo.ArgTypes[2] = ACPI_TYPE_INTEGER;
 775
 776     AcpiDbUint32ToHexString (NumThreads, AcpiGbl_DbMethodInfo.NumThreadsStr);
 777
 778     Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
 779     if (ACPI_FAILURE (Status))
 780     {
 781         goto CleanupAndExit;
 782     }
 783
 784     /* Get the NS node, determines existence also */
 785
 786     Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
 787         &AcpiGbl_DbMethodInfo.Method);
 788     if (ACPI_FAILURE (Status))
 789     {
 790         AcpiOsPrintf ("%s Could not get handle for %s\n",
 791             AcpiFormatException (Status), AcpiGbl_DbMethodInfo.Pathname);
 792         goto CleanupAndExit;
 793     }
 794
 795     /* Create the threads */
 796
 797     AcpiOsPrintf ("Creating %X threads to execute %X times each\n",
 798         NumThreads, NumLoops);
 799
 800     for (i = 0; i < (NumThreads); i++)
 801     {
 802         Status = AcpiOsExecute (OSL_DEBUGGER_THREAD, AcpiDbMethodThread,
 803             &AcpiGbl_DbMethodInfo);
 804         if (ACPI_FAILURE (Status))
 805         {
 806             break;
 807         }
 808     }
 809
 810     /* Wait for all threads to complete */
 811
 812     (void) AcpiOsWaitSemaphore (MainThreadGate, 1, ACPI_WAIT_FOREVER);
 813
 814     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 815     AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads);
 816     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 817
 818 CleanupAndExit:
 819
 820     /* Cleanup and exit */
 821
 822     (void) AcpiOsDeleteSemaphore (MainThreadGate);
 823     (void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
 824     (void) AcpiOsDeleteSemaphore (InfoGate);
 825
 826     AcpiOsFree (AcpiGbl_DbMethodInfo.Threads);
 827     AcpiGbl_DbMethodInfo.Threads = NULL;
 828 }
 829
 830 #endif /* ACPI_DEBUGGER */