sys/contrib/dev/acpica-unix-20040527/debugger/dbexec.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbexec - debugger control method execution
   4  *              $Revision: 60 $
   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
 118 #include "acpi.h"
 119 #include "acdebug.h"
 120 #include "acnamesp.h"
 121
 122 #ifdef ACPI_DEBUGGER
 123
 124 #define _COMPONENT          ACPI_CA_DEBUGGER
 125         ACPI_MODULE_NAME    ("dbexec")
 126
 127
 128 static ACPI_DB_METHOD_INFO  AcpiGbl_DbMethodInfo;
 129
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    AcpiDbExecuteMethod
 134  *
 135  * PARAMETERS:  Info            - Valid info segment
 136  *              ReturnObj       - Where to put return object
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Execute a control method.
 141  *
 142  ******************************************************************************/
 143
 144 ACPI_STATUS
 145 AcpiDbExecuteMethod (
 146     ACPI_DB_METHOD_INFO     *Info,
 147     ACPI_BUFFER             *ReturnObj)
 148 {
 149     ACPI_STATUS             Status;
 150     ACPI_OBJECT_LIST        ParamObjects;
 151     ACPI_OBJECT             Params[ACPI_METHOD_NUM_ARGS];
 152     UINT32                  i;
 153
 154
 155     if (AcpiGbl_DbOutputToFile && !AcpiDbgLevel)
 156     {
 157         AcpiOsPrintf ("Warning: debug output is not enabled!\n");
 158     }
 159
 160     /* Are there arguments to the method? */
 161
 162     if (Info->Args && Info->Args[0])
 163     {
 164         for (i = 0; Info->Args[i] && i < ACPI_METHOD_NUM_ARGS; i++)
 165         {
 166             Params[i].Type              = ACPI_TYPE_INTEGER;
 167             Params[i].Integer.Value     = ACPI_STRTOUL (Info->Args[i], NULL, 16);
 168         }
 169
 170         ParamObjects.Pointer        = Params;
 171         ParamObjects.Count          = i;
 172     }
 173     else
 174     {
 175         /* Setup default parameters */
 176
 177         Params[0].Type              = ACPI_TYPE_INTEGER;
 178         Params[0].Integer.Value     = 0x01020304;
 179
 180         Params[1].Type              = ACPI_TYPE_STRING;
 181         Params[1].String.Length     = 12;
 182         Params[1].String.Pointer    = "AML Debugger";
 183
 184         ParamObjects.Pointer        = Params;
 185         ParamObjects.Count          = 2;
 186     }
 187
 188     /* Prepare for a return object of arbitrary size */
 189
 190     ReturnObj->Pointer           = AcpiGbl_DbBuffer;
 191     ReturnObj->Length            = ACPI_DEBUG_BUFFER_SIZE;
 192
 193     /* Do the actual method execution */
 194
 195     AcpiGbl_MethodExecuting = TRUE;
 196     Status = AcpiEvaluateObject (NULL, Info->Pathname, &ParamObjects, ReturnObj);
 197
 198     AcpiGbl_CmSingleStep = FALSE;
 199     AcpiGbl_MethodExecuting = FALSE;
 200
 201     return (Status);
 202 }
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    AcpiDbExecuteSetup
 208  *
 209  * PARAMETERS:  Info            - Valid method info
 210  *
 211  * RETURN:      Status
 212  *
 213  * DESCRIPTION: Setup info segment prior to method execution
 214  *
 215  ******************************************************************************/
 216
 217 void
 218 AcpiDbExecuteSetup (
 219     ACPI_DB_METHOD_INFO     *Info)
 220 {
 221
 222     /* Catenate the current scope to the supplied name */
 223
 224     Info->Pathname[0] = 0;
 225     if ((Info->Name[0] != '\\') &&
 226         (Info->Name[0] != '/'))
 227     {
 228         ACPI_STRCAT (Info->Pathname, AcpiGbl_DbScopeBuf);
 229     }
 230
 231     ACPI_STRCAT (Info->Pathname, Info->Name);
 232     AcpiDbPrepNamestring (Info->Pathname);
 233
 234     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 235     AcpiOsPrintf ("Executing %s\n", Info->Pathname);
 236
 237     if (Info->Flags & EX_SINGLE_STEP)
 238     {
 239         AcpiGbl_CmSingleStep = TRUE;
 240         AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 241     }
 242
 243     else
 244     {
 245         /* No single step, allow redirection to a file */
 246
 247         AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 248     }
 249 }
 250
 251
 252 /*******************************************************************************
 253  *
 254  * FUNCTION:    AcpiDbGetOutstandingAllocations
 255  *
 256  * PARAMETERS:  None
 257  *
 258  * RETURN:      Current global allocation count minus cache entries
 259  *
 260  * DESCRIPTION: Determine the current number of "outstanding" allocations --
 261  *              those allocations that have not been freed and also are not
 262  *              in one of the various object caches.
 263  *
 264  ******************************************************************************/
 265
 266 UINT32
 267 AcpiDbGetOutstandingAllocations (
 268     void)
 269 {
 270     UINT32                  Outstanding = 0;
 271
 272 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
 273     UINT32                  i;
 274
 275
 276     for (i = ACPI_MEM_LIST_FIRST_CACHE_LIST; i < ACPI_NUM_MEM_LISTS; i++)
 277     {
 278         Outstanding += (AcpiGbl_MemoryLists[i].TotalAllocated -
 279                         AcpiGbl_MemoryLists[i].TotalFreed -
 280                         AcpiGbl_MemoryLists[i].CacheDepth);
 281     }
 282 #endif
 283
 284     return (Outstanding);
 285 }
 286
 287
 288 /*******************************************************************************
 289  *
 290  * FUNCTION:    AcpiDbExecutionWalk
 291  *
 292  * PARAMETERS:  WALK_CALLBACK
 293  *
 294  * RETURN:      Status
 295  *
 296  * DESCRIPTION: Execute a control method.  Name is relative to the current
 297  *              scope.
 298  *
 299  ******************************************************************************/
 300
 301 ACPI_STATUS
 302 AcpiDbExecutionWalk (
 303     ACPI_HANDLE             ObjHandle,
 304     UINT32                  NestingLevel,
 305     void                    *Context,
 306     void                    **ReturnValue)
 307 {
 308     ACPI_OPERAND_OBJECT     *ObjDesc;
 309     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 310     ACPI_BUFFER             ReturnObj;
 311     ACPI_STATUS             Status;
 312
 313
 314     ObjDesc = AcpiNsGetAttachedObject (Node);
 315     if (ObjDesc->Method.ParamCount)
 316     {
 317         return (AE_OK);
 318     }
 319
 320     ReturnObj.Pointer = NULL;
 321     ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
 322
 323     AcpiNsPrintNodePathname (Node, "Execute");
 324
 325     /* Do the actual method execution */
 326
 327     AcpiOsPrintf ("\n");
 328     AcpiGbl_MethodExecuting = TRUE;
 329
 330     Status = AcpiEvaluateObject (Node, NULL, NULL, &ReturnObj);
 331
 332     AcpiOsPrintf ("[%4.4s] returned %s\n", AcpiUtGetNodeName (Node),
 333             AcpiFormatException (Status));
 334     AcpiGbl_MethodExecuting = FALSE;
 335
 336     return (AE_OK);
 337 }
 338
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    AcpiDbExecute
 343  *
 344  * PARAMETERS:  Name                - Name of method to execute
 345  *              Args                - Parameters to the method
 346  *              Flags               - single step/no single step
 347  *
 348  * RETURN:      Status
 349  *
 350  * DESCRIPTION: Execute a control method.  Name is relative to the current
 351  *              scope.
 352  *
 353  ******************************************************************************/
 354
 355 void
 356 AcpiDbExecute (
 357     char                    *Name,
 358     char                    **Args,
 359     UINT32                  Flags)
 360 {
 361     ACPI_STATUS             Status;
 362     ACPI_BUFFER             ReturnObj;
 363
 364
 365 #ifdef ACPI_DEBUG_OUTPUT
 366     UINT32                  PreviousAllocations;
 367     UINT32                  Allocations;
 368
 369
 370     /* Memory allocation tracking */
 371
 372     PreviousAllocations = AcpiDbGetOutstandingAllocations ();
 373 #endif
 374
 375     if (*Name == '*')
 376     {
 377         (void) AcpiWalkNamespace (ACPI_TYPE_METHOD, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 378                     AcpiDbExecutionWalk, NULL, NULL);
 379         return;
 380     }
 381     else
 382     {
 383         AcpiGbl_DbMethodInfo.Name = Name;
 384         AcpiGbl_DbMethodInfo.Args = Args;
 385         AcpiGbl_DbMethodInfo.Flags = Flags;
 386
 387         ReturnObj.Pointer = NULL;
 388         ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
 389
 390         AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
 391         Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo, &ReturnObj);
 392     }
 393
 394     /*
 395      * Allow any handlers in separate threads to complete.
 396      * (Such as Notify handlers invoked from AML executed above).
 397      */
 398     AcpiOsSleep (0, 10);
 399
 400
 401 #ifdef ACPI_DEBUG_OUTPUT
 402
 403     /* Memory allocation tracking */
 404
 405     Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations;
 406
 407     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 408
 409     if (Allocations > 0)
 410     {
 411         AcpiOsPrintf ("Outstanding: %u allocations after execution\n",
 412                         Allocations);
 413     }
 414 #endif
 415
 416     if (ACPI_FAILURE (Status))
 417     {
 418         AcpiOsPrintf ("Execution of %s failed with status %s\n",
 419             AcpiGbl_DbMethodInfo.Pathname, AcpiFormatException (Status));
 420     }
 421
 422     else
 423     {
 424         /* Display a return object, if any */
 425
 426         if (ReturnObj.Length)
 427         {
 428             AcpiOsPrintf ("Execution of %s returned object %p Buflen %X\n",
 429                 AcpiGbl_DbMethodInfo.Pathname, ReturnObj.Pointer,
 430                 (UINT32) ReturnObj.Length);
 431             AcpiDbDumpObject (ReturnObj.Pointer, 1);
 432         }
 433         else
 434         {
 435             AcpiOsPrintf ("No return object from execution of %s\n",
 436                 AcpiGbl_DbMethodInfo.Pathname);
 437         }
 438     }
 439
 440     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 441 }
 442
 443
 444 /*******************************************************************************
 445  *
 446  * FUNCTION:    AcpiDbMethodThread
 447  *
 448  * PARAMETERS:  Context             - Execution info segment
 449  *
 450  * RETURN:      None
 451  *
 452  * DESCRIPTION: Debugger execute thread.  Waits for a command line, then
 453  *              simply dispatches it.
 454  *
 455  ******************************************************************************/
 456
 457 void ACPI_SYSTEM_XFACE
 458 AcpiDbMethodThread (
 459     void                    *Context)
 460 {
 461     ACPI_STATUS             Status;
 462     ACPI_DB_METHOD_INFO     *Info = Context;
 463     UINT32                  i;
 464     ACPI_BUFFER             ReturnObj;
 465
 466
 467     for (i = 0; i < Info->NumLoops; i++)
 468     {
 469 #if 0
 470        if (i == 0xEFDC)
 471         {
 472             AcpiDbgLevel = 0x00FFFFFF;
 473         }
 474 #endif
 475
 476         Status = AcpiDbExecuteMethod (Info, &ReturnObj);
 477         if (ACPI_FAILURE (Status))
 478         {
 479             AcpiOsPrintf ("%s During execution of %s at iteration %X\n",
 480                 AcpiFormatException (Status), Info->Pathname, i);
 481             if (Status == AE_ABORT_METHOD)
 482             {
 483                 break;
 484             }
 485         }
 486
 487         if ((i % 100) == 0)
 488         {
 489             AcpiOsPrintf ("%d executions\n", i);
 490         }
 491
 492 #if 0
 493         if (ReturnObj.Length)
 494         {
 495             AcpiOsPrintf ("Execution of %s returned object %p Buflen %X\n",
 496                 Info->Pathname, ReturnObj.Pointer, (UINT32) ReturnObj.Length);
 497             AcpiDbDumpObject (ReturnObj.Pointer, 1);
 498         }
 499 #endif
 500     }
 501
 502     /* Signal our completion */
 503
 504     Status = AcpiOsSignalSemaphore (Info->ThreadGate, 1);
 505     if (ACPI_FAILURE (Status))
 506     {
 507         AcpiOsPrintf ("Could not signal debugger semaphore\n");
 508     }
 509 }
 510
 511
 512 /*******************************************************************************
 513  *
 514  * FUNCTION:    AcpiDbCreateExecutionThreads
 515  *
 516  * PARAMETERS:  NumThreadsArg           - Number of threads to create
 517  *              NumLoopsArg             - Loop count for the thread(s)
 518  *              MethodNameArg           - Control method to execute
 519  *
 520  * RETURN:      None
 521  *
 522  * DESCRIPTION: Create threads to execute method(s)
 523  *
 524  ******************************************************************************/
 525
 526 void
 527 AcpiDbCreateExecutionThreads (
 528     char                    *NumThreadsArg,
 529     char                    *NumLoopsArg,
 530     char                    *MethodNameArg)
 531 {
 532     ACPI_STATUS             Status;
 533     UINT32                  NumThreads;
 534     UINT32                  NumLoops;
 535     UINT32                  i;
 536     ACPI_HANDLE             ThreadGate;
 537
 538
 539     /* Get the arguments */
 540
 541     NumThreads = ACPI_STRTOUL (NumThreadsArg, NULL, 0);
 542     NumLoops   = ACPI_STRTOUL (NumLoopsArg, NULL, 0);
 543
 544     if (!NumThreads || !NumLoops)
 545     {
 546         AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n", NumThreads, NumLoops);
 547         return;
 548     }
 549
 550     /* Create the synchronization semaphore */
 551
 552     Status = AcpiOsCreateSemaphore (1, 0, &ThreadGate);
 553     if (ACPI_FAILURE (Status))
 554     {
 555         AcpiOsPrintf ("Could not create semaphore, %s\n", AcpiFormatException (Status));
 556         return;
 557     }
 558
 559     /* Setup the context to be passed to each thread */
 560
 561     AcpiGbl_DbMethodInfo.Name = MethodNameArg;
 562     AcpiGbl_DbMethodInfo.Args = NULL;
 563     AcpiGbl_DbMethodInfo.Flags = 0;
 564     AcpiGbl_DbMethodInfo.NumLoops = NumLoops;
 565     AcpiGbl_DbMethodInfo.ThreadGate = ThreadGate;
 566
 567     AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
 568
 569     /* Create the threads */
 570
 571     AcpiOsPrintf ("Creating %X threads to execute %X times each\n", NumThreads, NumLoops);
 572
 573     for (i = 0; i < (NumThreads); i++)
 574     {
 575         Status = AcpiOsQueueForExecution (OSD_PRIORITY_MED, AcpiDbMethodThread, &AcpiGbl_DbMethodInfo);
 576         if (ACPI_FAILURE (Status))
 577         {
 578             break;
 579         }
 580     }
 581
 582     /* Wait for all threads to complete */
 583
 584     i = NumThreads;
 585     while (i)   /* Brain damage for OSD implementations that only support wait of 1 unit */
 586     {
 587         Status = AcpiOsWaitSemaphore (ThreadGate, 1, ACPI_WAIT_FOREVER);
 588         i--;
 589     }
 590
 591     /* Cleanup and exit */
 592
 593     (void) AcpiOsDeleteSemaphore (ThreadGate);
 594
 595     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 596     AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads);
 597     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 598 }
 599
 600
 601 #endif /* ACPI_DEBUGGER */
 602
 603