dbexec.c revision 67754 
1219820Sjeff/*******************************************************************************
2219820Sjeff *
3219820Sjeff * Module Name: dbexec - debugger control method execution
4219820Sjeff *              $Revision: 16 $
5219820Sjeff *
6219820Sjeff ******************************************************************************/
7219820Sjeff
8219820Sjeff/******************************************************************************
9219820Sjeff *
10219820Sjeff * 1. Copyright Notice
11219820Sjeff *
12219820Sjeff * Some or all of this work - Copyright (c) 1999, Intel Corp.  All rights
13219820Sjeff * reserved.
14219820Sjeff *
15219820Sjeff * 2. License
16219820Sjeff *
17219820Sjeff * 2.1. This is your license from Intel Corp. under its intellectual property
18219820Sjeff * rights.  You may have additional license terms from the party that provided
19219820Sjeff * you this software, covering your right to use that party's intellectual
20219820Sjeff * property rights.
21219820Sjeff *
22219820Sjeff * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23219820Sjeff * copy of the source code appearing in this file ("Covered Code") an
24219820Sjeff * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25219820Sjeff * 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 "acparser.h"
120#include "acdispat.h"
121#include "amlcode.h"
122#include "acnamesp.h"
123#include "acparser.h"
124#include "acevents.h"
125#include "acinterp.h"
126#include "acdebug.h"
127#include "actables.h"
128
129#ifdef ENABLE_DEBUGGER
130
131#define _COMPONENT          DEBUGGER
132        MODULE_NAME         ("dbexec")
133
134
135typedef struct dbmethodinfo
136{
137    ACPI_HANDLE             ThreadGate;
138    NATIVE_CHAR             *Name;
139    NATIVE_CHAR             **Args;
140    UINT32                  Flags;
141    UINT32                  NumLoops;
142    NATIVE_CHAR             Pathname[128];
143
144} DB_METHOD_INFO;
145
146
147DB_METHOD_INFO              Info;
148
149
150/*******************************************************************************
151 *
152 * FUNCTION:    AcpiDbExecuteMethod
153 *
154 * PARAMETERS:  Info            - Valid info segment
155 *              ReturnObj       - Where to put return object
156 *
157 * RETURN:      Status
158 *
159 * DESCRIPTION: Execute a control method.
160 *
161 ******************************************************************************/
162
163ACPI_STATUS
164AcpiDbExecuteMethod (
165    DB_METHOD_INFO          *Info,
166    ACPI_BUFFER             *ReturnObj)
167{
168    ACPI_STATUS             Status;
169    ACPI_OBJECT_LIST        ParamObjects;
170    ACPI_OBJECT             Params[MTH_NUM_ARGS];
171    UINT32                  i;
172
173
174    if (OutputToFile && !AcpiDbgLevel)
175    {
176        AcpiOsPrintf ("Warning: debug output is not enabled!\n");
177    }
178
179    /* Are there arguments to the method? */
180
181    if (Info->Args && Info->Args[0])
182    {
183        for (i = 0; Info->Args[i] && i < MTH_NUM_ARGS; i++)
184        {
185            Params[i].Type              = ACPI_TYPE_NUMBER;
186            Params[i].Number.Value      = STRTOUL (Info->Args[i], NULL, 16);
187        }
188
189        ParamObjects.Pointer        = Params;
190        ParamObjects.Count          = i;
191    }
192
193    else
194    {
195        /* Setup default parameters */
196
197        Params[0].Type              = ACPI_TYPE_NUMBER;
198        Params[0].Number.Value      = 0x01020304;
199
200        Params[1].Type              = ACPI_TYPE_STRING;
201        Params[1].String.Length     = 12;
202        Params[1].String.Pointer    = "AML Debugger";
203
204        ParamObjects.Pointer        = Params;
205        ParamObjects.Count          = 2;
206    }
207
208    /* Prepare for a return object of arbitrary size */
209
210    ReturnObj->Pointer           = Buffer;
211    ReturnObj->Length            = BUFFER_SIZE;
212
213
214    /* Do the actual method execution */
215
216    Status = AcpiEvaluateObject (NULL, Info->Pathname, &ParamObjects, ReturnObj);
217
218    AcpiGbl_CmSingleStep = FALSE;
219    AcpiGbl_MethodExecuting = FALSE;
220
221    return (Status);
222}
223
224
225/*******************************************************************************
226 *
227 * FUNCTION:    AcpiDbExecuteSetup
228 *
229 * PARAMETERS:  Info            - Valid method info
230 *
231 * RETURN:      Status
232 *
233 * DESCRIPTION: Setup info segment prior to method execution
234 *
235 ******************************************************************************/
236
237void
238AcpiDbExecuteSetup (
239    DB_METHOD_INFO          *Info)
240{
241
242    /* Catenate the current scope to the supplied name */
243
244    Info->Pathname[0] = 0;
245    if ((Info->Name[0] != '\\') &&
246        (Info->Name[0] != '/'))
247    {
248        STRCAT (Info->Pathname, ScopeBuf);
249    }
250
251    STRCAT (Info->Pathname, Info->Name);
252    AcpiDbPrepNamestring (Info->Pathname);
253
254    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
255    AcpiOsPrintf ("Executing %s\n", Info->Pathname);
256
257    if (Info->Flags & EX_SINGLE_STEP)
258    {
259        AcpiGbl_CmSingleStep = TRUE;
260        AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
261    }
262
263    else
264    {
265        /* No single step, allow redirection to a file */
266
267        AcpiDbSetOutputDestination (DB_REDIRECTABLE_OUTPUT);
268    }
269}
270
271
272/*******************************************************************************
273 *
274 * FUNCTION:    AcpiDbExecute
275 *
276 * PARAMETERS:  Name                - Name of method to execute
277 *              Args                - Parameters to the method
278 *              Flags               - single step/no single step
279 *
280 * RETURN:      Status
281 *
282 * DESCRIPTION: Execute a control method.  Name is relative to the current
283 *              scope.
284 *
285 ******************************************************************************/
286
287void
288AcpiDbExecute (
289    NATIVE_CHAR             *Name,
290    NATIVE_CHAR             **Args,
291    UINT32                  Flags)
292{
293    ACPI_STATUS             Status;
294    UINT32                  PreviousAllocations;
295    UINT32                  PreviousSize;
296    UINT32                  Allocations;
297    UINT32                  Size;
298    ACPI_BUFFER             ReturnObj;
299
300
301    /* Memory allocation tracking */
302
303    PreviousAllocations = AcpiGbl_CurrentAllocCount;
304    PreviousSize = AcpiGbl_CurrentAllocSize;
305
306
307    Info.Name = Name;
308    Info.Args = Args;
309    Info.Flags = Flags;
310
311    AcpiDbExecuteSetup (&Info);
312    Status = AcpiDbExecuteMethod (&Info, &ReturnObj);
313
314
315    /* Memory allocation tracking */
316
317    Allocations = AcpiGbl_CurrentAllocCount - PreviousAllocations;
318    Size = AcpiGbl_CurrentAllocSize - PreviousSize;
319
320    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
321
322    if (Allocations > 0)
323    {
324        AcpiOsPrintf ("Outstanding: %ld allocations of total size %ld after execution\n",
325                        Allocations, Size);
326    }
327
328
329    if (ACPI_FAILURE (Status))
330    {
331        AcpiOsPrintf ("Execution of %s failed with status %s\n", Info.Pathname, AcpiCmFormatException (Status));
332    }
333
334    else
335    {
336        /* Display a return object, if any */
337
338        if (ReturnObj.Length)
339        {
340            AcpiOsPrintf ("Execution of %s returned object %p\n", Info.Pathname, ReturnObj.Pointer);
341            AcpiDbDumpObject (ReturnObj.Pointer, 1);
342        }
343    }
344
345    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
346}
347
348
349/*******************************************************************************
350 *
351 * FUNCTION:    AcpiDbMethodThread
352 *
353 * PARAMETERS:  Context             - Execution info segment
354 *
355 * RETURN:      None
356 *
357 * DESCRIPTION: Debugger execute thread.  Waits for a command line, then
358 *              simply dispatches it.
359 *
360 ******************************************************************************/
361
362void
363AcpiDbMethodThread (
364    void                    *Context)
365{
366    ACPI_STATUS             Status;
367    DB_METHOD_INFO          *Info = Context;
368    UINT32                  i;
369    ACPI_BUFFER             ReturnObj;
370
371
372    for (i = 0; i < Info->NumLoops; i++)
373    {
374        Status = AcpiDbExecuteMethod (Info, &ReturnObj);
375        if (ACPI_SUCCESS (Status))
376        {
377            if (ReturnObj.Length)
378            {
379                AcpiOsPrintf ("Execution of %s returned object %p\n", Info->Pathname, ReturnObj.Pointer);
380                AcpiDbDumpObject (ReturnObj.Pointer, 1);
381            }
382        }
383    }
384
385
386    /* Signal our completion */
387
388    AcpiOsSignalSemaphore (Info->ThreadGate, 1);
389}
390
391
392/*******************************************************************************
393 *
394 * FUNCTION:    AcpiDbCreateExecutionThreads
395 *
396 * PARAMETERS:  NumThreadsArg           - Number of threads to create
397 *              NumLoopsArg             - Loop count for the thread(s)
398 *              MethodNameArg           - Control method to execute
399 *
400 * RETURN:      None
401 *
402 * DESCRIPTION: Create threads to execute method(s)
403 *
404 ******************************************************************************/
405
406void
407AcpiDbCreateExecutionThreads (
408    NATIVE_CHAR             *NumThreadsArg,
409    NATIVE_CHAR             *NumLoopsArg,
410    NATIVE_CHAR             *MethodNameArg)
411{
412    ACPI_STATUS             Status;
413    UINT32                  NumThreads;
414    UINT32                  NumLoops;
415    UINT32                  i;
416    ACPI_HANDLE             ThreadGate;
417
418
419    /* Get the arguments */
420
421    NumThreads = STRTOUL (NumThreadsArg, NULL, 0);
422    NumLoops = STRTOUL (NumLoopsArg, NULL, 0);
423
424    if (!NumThreads || !NumLoops)
425    {
426        AcpiOsPrintf ("Bad argument: Threads %d, Loops %d\n", NumThreads, NumLoops);
427        return;
428    }
429
430
431    /* Create the synchronization semaphore */
432
433    Status = AcpiOsCreateSemaphore (1, 0, &ThreadGate);
434    if (ACPI_FAILURE (Status))
435    {
436        AcpiOsPrintf ("Could not create semaphore, %s\n", AcpiCmFormatException (Status));
437        return;
438    }
439
440    /* Setup the context to be passed to each thread */
441
442    Info.Name = MethodNameArg;
443    Info.Args = NULL;
444    Info.Flags = 0;
445    Info.NumLoops = NumLoops;
446    Info.ThreadGate = ThreadGate;
447
448    AcpiDbExecuteSetup (&Info);
449
450
451    /* Create the threads */
452
453    AcpiOsPrintf ("Creating %d threads to execute %d times each\n", NumThreads, NumLoops);
454
455    for (i = 0; i < (NumThreads); i++)
456    {
457        AcpiOsQueueForExecution (OSD_PRIORITY_MED, AcpiDbMethodThread, &Info);
458    }
459
460
461    /* Wait for all threads to complete */
462
463    i = NumThreads;
464    while (i)   /* Brain damage for OSD implementations that only support wait of 1 unit */
465    {
466        Status = AcpiOsWaitSemaphore (ThreadGate, 1, WAIT_FOREVER);
467        i--;
468    }
469
470    /* Cleanup and exit */
471
472    AcpiOsDeleteSemaphore (ThreadGate);
473
474    AcpiDbSetOutputDestination (DB_DUPLICATE_OUTPUT);
475    AcpiOsPrintf ("All threads (%d) have completed\n", NumThreads);
476    AcpiDbSetOutputDestination (DB_CONSOLE_OUTPUT);
477}
478
479
480#endif /* ENABLE_DEBUGGER */
481
482
483