1 /*******************************************************************************
2  *
3  * Module Name: dbmethod - Debug commands for control methods
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2013, 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 
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acdispat.h"
48 #include "acnamesp.h"
49 #include "acdebug.h"
50 #include "acdisasm.h"
51 #include "acparser.h"
52 #include "acpredef.h"
53 
54 
55 #ifdef ACPI_DEBUGGER
56 
57 #define _COMPONENT          ACPI_CA_DEBUGGER
58         ACPI_MODULE_NAME    ("dbmethod")
59 
60 
61 /* Local prototypes */
62 
63 static ACPI_STATUS
64 AcpiDbWalkForExecute (
65     ACPI_HANDLE             ObjHandle,
66     UINT32                  NestingLevel,
67     void                    *Context,
68     void                    **ReturnValue);
69 
70 
71 /*******************************************************************************
72  *
73  * FUNCTION:    AcpiDbSetMethodBreakpoint
74  *
75  * PARAMETERS:  Location            - AML offset of breakpoint
76  *              WalkState           - Current walk info
77  *              Op                  - Current Op (from parse walk)
78  *
79  * RETURN:      None
80  *
81  * DESCRIPTION: Set a breakpoint in a control method at the specified
82  *              AML offset
83  *
84  ******************************************************************************/
85 
86 void
87 AcpiDbSetMethodBreakpoint (
88     char                    *Location,
89     ACPI_WALK_STATE         *WalkState,
90     ACPI_PARSE_OBJECT       *Op)
91 {
92     UINT32                  Address;
93 
94 
95     if (!Op)
96     {
97         AcpiOsPrintf ("There is no method currently executing\n");
98         return;
99     }
100 
101     /* Get and verify the breakpoint address */
102 
103     Address = ACPI_STRTOUL (Location, NULL, 16);
104     if (Address <= Op->Common.AmlOffset)
105     {
106         AcpiOsPrintf ("Breakpoint %X is beyond current address %X\n",
107             Address, Op->Common.AmlOffset);
108     }
109 
110     /* Save breakpoint in current walk */
111 
112     WalkState->UserBreakpoint = Address;
113     AcpiOsPrintf ("Breakpoint set at AML offset %X\n", Address);
114 }
115 
116 
117 /*******************************************************************************
118  *
119  * FUNCTION:    AcpiDbSetMethodCallBreakpoint
120  *
121  * PARAMETERS:  Op                  - Current Op (from parse walk)
122  *
123  * RETURN:      None
124  *
125  * DESCRIPTION: Set a breakpoint in a control method at the specified
126  *              AML offset
127  *
128  ******************************************************************************/
129 
130 void
131 AcpiDbSetMethodCallBreakpoint (
132     ACPI_PARSE_OBJECT       *Op)
133 {
134 
135 
136     if (!Op)
137     {
138         AcpiOsPrintf ("There is no method currently executing\n");
139         return;
140     }
141 
142     AcpiGbl_StepToNextCall = TRUE;
143 }
144 
145 
146 /*******************************************************************************
147  *
148  * FUNCTION:    AcpiDbSetMethodData
149  *
150  * PARAMETERS:  TypeArg         - L for local, A for argument
151  *              IndexArg        - which one
152  *              ValueArg        - Value to set.
153  *
154  * RETURN:      None
155  *
156  * DESCRIPTION: Set a local or argument for the running control method.
157  *              NOTE: only object supported is Number.
158  *
159  ******************************************************************************/
160 
161 void
162 AcpiDbSetMethodData (
163     char                    *TypeArg,
164     char                    *IndexArg,
165     char                    *ValueArg)
166 {
167     char                    Type;
168     UINT32                  Index;
169     UINT32                  Value;
170     ACPI_WALK_STATE         *WalkState;
171     ACPI_OPERAND_OBJECT     *ObjDesc;
172     ACPI_STATUS             Status;
173     ACPI_NAMESPACE_NODE     *Node;
174 
175 
176     /* Validate TypeArg */
177 
178     AcpiUtStrupr (TypeArg);
179     Type = TypeArg[0];
180     if ((Type != 'L') &&
181         (Type != 'A') &&
182         (Type != 'N'))
183     {
184         AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg);
185         return;
186     }
187 
188     Value = ACPI_STRTOUL (ValueArg, NULL, 16);
189 
190     if (Type == 'N')
191     {
192         Node = AcpiDbConvertToNode (IndexArg);
193         if (Node->Type != ACPI_TYPE_INTEGER)
194         {
195             AcpiOsPrintf ("Can only set Integer nodes\n");
196             return;
197         }
198         ObjDesc = Node->Object;
199         ObjDesc->Integer.Value = Value;
200         return;
201     }
202 
203     /* Get the index and value */
204 
205     Index = ACPI_STRTOUL (IndexArg, NULL, 16);
206 
207     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
208     if (!WalkState)
209     {
210         AcpiOsPrintf ("There is no method currently executing\n");
211         return;
212     }
213 
214     /* Create and initialize the new object */
215 
216     ObjDesc = AcpiUtCreateIntegerObject ((UINT64) Value);
217     if (!ObjDesc)
218     {
219         AcpiOsPrintf ("Could not create an internal object\n");
220         return;
221     }
222 
223     /* Store the new object into the target */
224 
225     switch (Type)
226     {
227     case 'A':
228 
229         /* Set a method argument */
230 
231         if (Index > ACPI_METHOD_MAX_ARG)
232         {
233             AcpiOsPrintf ("Arg%u - Invalid argument name\n", Index);
234             goto Cleanup;
235         }
236 
237         Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_ARG, Index, ObjDesc,
238                     WalkState);
239         if (ACPI_FAILURE (Status))
240         {
241             goto Cleanup;
242         }
243 
244         ObjDesc = WalkState->Arguments[Index].Object;
245 
246         AcpiOsPrintf ("Arg%u: ", Index);
247         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
248         break;
249 
250     case 'L':
251 
252         /* Set a method local */
253 
254         if (Index > ACPI_METHOD_MAX_LOCAL)
255         {
256             AcpiOsPrintf ("Local%u - Invalid local variable name\n", Index);
257             goto Cleanup;
258         }
259 
260         Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_LOCAL, Index, ObjDesc,
261                     WalkState);
262         if (ACPI_FAILURE (Status))
263         {
264             goto Cleanup;
265         }
266 
267         ObjDesc = WalkState->LocalVariables[Index].Object;
268 
269         AcpiOsPrintf ("Local%u: ", Index);
270         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
271         break;
272 
273     default:
274 
275         break;
276     }
277 
278 Cleanup:
279     AcpiUtRemoveReference (ObjDesc);
280 }
281 
282 
283 /*******************************************************************************
284  *
285  * FUNCTION:    AcpiDbDisassembleAml
286  *
287  * PARAMETERS:  Statements          - Number of statements to disassemble
288  *              Op                  - Current Op (from parse walk)
289  *
290  * RETURN:      None
291  *
292  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
293  *              of statements specified.
294  *
295  ******************************************************************************/
296 
297 void
298 AcpiDbDisassembleAml (
299     char                    *Statements,
300     ACPI_PARSE_OBJECT       *Op)
301 {
302     UINT32                  NumStatements = 8;
303 
304 
305     if (!Op)
306     {
307         AcpiOsPrintf ("There is no method currently executing\n");
308         return;
309     }
310 
311     if (Statements)
312     {
313         NumStatements = ACPI_STRTOUL (Statements, NULL, 0);
314     }
315 
316     AcpiDmDisassemble (NULL, Op, NumStatements);
317 }
318 
319 
320 /*******************************************************************************
321  *
322  * FUNCTION:    AcpiDbDisassembleMethod
323  *
324  * PARAMETERS:  Name            - Name of control method
325  *
326  * RETURN:      None
327  *
328  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
329  *              of statements specified.
330  *
331  ******************************************************************************/
332 
333 ACPI_STATUS
334 AcpiDbDisassembleMethod (
335     char                    *Name)
336 {
337     ACPI_STATUS             Status;
338     ACPI_PARSE_OBJECT       *Op;
339     ACPI_WALK_STATE         *WalkState;
340     ACPI_OPERAND_OBJECT     *ObjDesc;
341     ACPI_NAMESPACE_NODE     *Method;
342 
343 
344     Method = AcpiDbConvertToNode (Name);
345     if (!Method)
346     {
347         return (AE_BAD_PARAMETER);
348     }
349 
350     if (Method->Type != ACPI_TYPE_METHOD)
351     {
352         ACPI_ERROR ((AE_INFO, "%s (%s): Object must be a control method",
353             Name, AcpiUtGetTypeName (Method->Type)));
354         return (AE_BAD_PARAMETER);
355     }
356 
357     ObjDesc = Method->Object;
358 
359     Op = AcpiPsCreateScopeOp ();
360     if (!Op)
361     {
362         return (AE_NO_MEMORY);
363     }
364 
365     /* Create and initialize a new walk state */
366 
367     WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);
368     if (!WalkState)
369     {
370         return (AE_NO_MEMORY);
371     }
372 
373     Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,
374         ObjDesc->Method.AmlStart,
375         ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
376     if (ACPI_FAILURE (Status))
377     {
378         return (Status);
379     }
380 
381     Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
382     WalkState->OwnerId = ObjDesc->Method.OwnerId;
383 
384     /* Push start scope on scope stack and make it current */
385 
386     Status = AcpiDsScopeStackPush (Method,
387         Method->Type, WalkState);
388     if (ACPI_FAILURE (Status))
389     {
390         return (Status);
391     }
392 
393     /* Parse the entire method AML including deferred operators */
394 
395     WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
396     WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
397 
398     Status = AcpiPsParseAml (WalkState);
399     (void) AcpiDmParseDeferredOps (Op);
400 
401     /* Now we can disassemble the method */
402 
403     AcpiGbl_DbOpt_verbose = FALSE;
404     AcpiDmDisassemble (NULL, Op, 0);
405     AcpiGbl_DbOpt_verbose = TRUE;
406 
407     AcpiPsDeleteParseTree (Op);
408 
409     /* Method cleanup */
410 
411     AcpiNsDeleteNamespaceSubtree (Method);
412     AcpiNsDeleteNamespaceByOwner (ObjDesc->Method.OwnerId);
413     AcpiUtReleaseOwnerId (&ObjDesc->Method.OwnerId);
414     return (AE_OK);
415 }
416 
417 
418 /*******************************************************************************
419  *
420  * FUNCTION:    AcpiDbWalkForExecute
421  *
422  * PARAMETERS:  Callback from WalkNamespace
423  *
424  * RETURN:      Status
425  *
426  * DESCRIPTION: Batch execution module. Currently only executes predefined
427  *              ACPI names.
428  *
429  ******************************************************************************/
430 
431 static ACPI_STATUS
432 AcpiDbWalkForExecute (
433     ACPI_HANDLE             ObjHandle,
434     UINT32                  NestingLevel,
435     void                    *Context,
436     void                    **ReturnValue)
437 {
438     ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
439     ACPI_DB_EXECUTE_WALK        *Info = (ACPI_DB_EXECUTE_WALK *) Context;
440     char                        *Pathname;
441     const ACPI_PREDEFINED_INFO  *Predefined;
442     ACPI_DEVICE_INFO            *ObjInfo;
443     ACPI_OBJECT_LIST            ParamObjects;
444     ACPI_OBJECT                 Params[ACPI_METHOD_NUM_ARGS];
445     ACPI_OBJECT                 *ThisParam;
446     ACPI_BUFFER                 ReturnObj;
447     ACPI_STATUS                 Status;
448     UINT16                      ArgTypeList;
449     UINT8                       ArgCount;
450     UINT8                       ArgType;
451     UINT32                      i;
452 
453 
454     /* The name must be a predefined ACPI name */
455 
456     Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
457     if (!Predefined)
458     {
459         return (AE_OK);
460     }
461 
462     if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
463     {
464         return (AE_OK);
465     }
466 
467     Pathname = AcpiNsGetExternalPathname (Node);
468     if (!Pathname)
469     {
470         return (AE_OK);
471     }
472 
473     /* Get the object info for number of method parameters */
474 
475     Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo);
476     if (ACPI_FAILURE (Status))
477     {
478         return (Status);
479     }
480 
481     ParamObjects.Count = 0;
482     ParamObjects.Pointer = NULL;
483 
484     if (ObjInfo->Type == ACPI_TYPE_METHOD)
485     {
486         /* Setup default parameters (with proper types) */
487 
488         ArgTypeList = Predefined->Info.ArgumentList;
489         ArgCount = METHOD_GET_ARG_COUNT (ArgTypeList);
490 
491         /*
492          * Setup the ACPI-required number of arguments, regardless of what
493          * the actual method defines. If there is a difference, then the
494          * method is wrong and a warning will be issued during execution.
495          */
496         ThisParam = Params;
497         for (i = 0; i < ArgCount; i++)
498         {
499             ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList);
500             ThisParam->Type = ArgType;
501 
502             switch (ArgType)
503             {
504             case ACPI_TYPE_INTEGER:
505 
506                 ThisParam->Integer.Value = 1;
507                 break;
508 
509             case ACPI_TYPE_STRING:
510 
511                 ThisParam->String.Pointer = "This is the default argument string";
512                 ThisParam->String.Length = ACPI_STRLEN (ThisParam->String.Pointer);
513                 break;
514 
515             case ACPI_TYPE_BUFFER:
516 
517                 ThisParam->Buffer.Pointer = (UINT8 *) Params; /* just a garbage buffer */
518                 ThisParam->Buffer.Length = 48;
519                 break;
520 
521              case ACPI_TYPE_PACKAGE:
522 
523                 ThisParam->Package.Elements = NULL;
524                 ThisParam->Package.Count = 0;
525                 break;
526 
527            default:
528 
529                 AcpiOsPrintf ("%s: Unsupported argument type: %u\n",
530                     Pathname, ArgType);
531                 break;
532             }
533 
534             ThisParam++;
535         }
536 
537         ParamObjects.Count = ArgCount;
538         ParamObjects.Pointer = Params;
539     }
540 
541     ACPI_FREE (ObjInfo);
542     ReturnObj.Pointer = NULL;
543     ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
544 
545     /* Do the actual method execution */
546 
547     AcpiGbl_MethodExecuting = TRUE;
548 
549     Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj);
550 
551     AcpiOsPrintf ("%-32s returned %s\n", Pathname, AcpiFormatException (Status));
552     AcpiGbl_MethodExecuting = FALSE;
553     ACPI_FREE (Pathname);
554 
555     /* Ignore status from method execution */
556 
557     Status = AE_OK;
558 
559     /* Update count, check if we have executed enough methods */
560 
561     Info->Count++;
562     if (Info->Count >= Info->MaxCount)
563     {
564         Status = AE_CTRL_TERMINATE;
565     }
566 
567     return (Status);
568 }
569 
570 
571 /*******************************************************************************
572  *
573  * FUNCTION:    AcpiDbBatchExecute
574  *
575  * PARAMETERS:  CountArg            - Max number of methods to execute
576  *
577  * RETURN:      None
578  *
579  * DESCRIPTION: Namespace batch execution. Execute predefined names in the
580  *              namespace, up to the max count, if specified.
581  *
582  ******************************************************************************/
583 
584 void
585 AcpiDbBatchExecute (
586     char                    *CountArg)
587 {
588     ACPI_DB_EXECUTE_WALK    Info;
589 
590 
591     Info.Count = 0;
592     Info.MaxCount = ACPI_UINT32_MAX;
593 
594     if (CountArg)
595     {
596         Info.MaxCount = ACPI_STRTOUL (CountArg, NULL, 0);
597     }
598 
599 
600     /* Search all nodes in namespace */
601 
602     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
603                 AcpiDbWalkForExecute, NULL, (void *) &Info, NULL);
604 
605     AcpiOsPrintf ("Evaluated %u predefined names in the namespace\n", Info.Count);
606 }
607 
608 #endif /* ACPI_DEBUGGER */
609