1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /*******************************************************************************
3 *
4 * Module Name: dbxface - AML Debugger external interfaces
5 *
6 ******************************************************************************/
7
8 #include <acpi/acpi.h>
9 #include "accommon.h"
10 #include "amlcode.h"
11 #include "acdebug.h"
12 #include "acinterp.h"
13 #include "acparser.h"
14
15 #define _COMPONENT ACPI_CA_DEBUGGER
16 ACPI_MODULE_NAME("dbxface")
17
18 /* Local prototypes */
19 static acpi_status
20 acpi_db_start_command(struct acpi_walk_state *walk_state,
21 union acpi_parse_object *op);
22
23 #ifdef ACPI_OBSOLETE_FUNCTIONS
24 void acpi_db_method_end(struct acpi_walk_state *walk_state);
25 #endif
26
27 #ifdef ACPI_DISASSEMBLER
28 static union acpi_parse_object *acpi_db_get_display_op(struct acpi_walk_state
29 *walk_state,
30 union acpi_parse_object
31 *op);
32 #endif
33
34 /*******************************************************************************
35 *
36 * FUNCTION: acpi_db_start_command
37 *
38 * PARAMETERS: walk_state - Current walk
39 * op - Current executing Op, from AML interpreter
40 *
41 * RETURN: Status
42 *
43 * DESCRIPTION: Enter debugger command loop
44 *
45 ******************************************************************************/
46
47 static acpi_status
48 acpi_db_start_command(struct acpi_walk_state *walk_state,
49 union acpi_parse_object *op)
50 {
51 acpi_status status;
52
53 /* TBD: [Investigate] are there namespace locking issues here? */
54
55 /* acpi_ut_release_mutex (ACPI_MTX_NAMESPACE); */
56
57 /* Go into the command loop and await next user command */
58
59 acpi_gbl_method_executing = TRUE;
60 status = AE_CTRL_TRUE;
61
62 while (status == AE_CTRL_TRUE) {
63
64 /* Notify the completion of the command */
65
66 status = acpi_os_notify_command_complete();
67 if (ACPI_FAILURE(status)) {
68 goto error_exit;
69 }
70
71 /* Wait the readiness of the command */
72
73 status = acpi_os_wait_command_ready();
74 if (ACPI_FAILURE(status)) {
75 goto error_exit;
76 }
77
78 status =
79 acpi_db_command_dispatch(acpi_gbl_db_line_buf, walk_state,
80 op);
81 }
82
83 /* acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE); */
84
85 error_exit:
86 if (ACPI_FAILURE(status) && status != AE_CTRL_TERMINATE) {
87 ACPI_EXCEPTION((AE_INFO, status,
88 "While parsing/handling command line"));
89 }
90 return (status);
91 }
92
93 /*******************************************************************************
94 *
95 * FUNCTION: acpi_db_signal_break_point
96 *
97 * PARAMETERS: walk_state - Current walk
98 *
99 * RETURN: Status
100 *
101 * DESCRIPTION: Called for AML_BREAKPOINT_OP
102 *
103 ******************************************************************************/
104
105 void acpi_db_signal_break_point(struct acpi_walk_state *walk_state)
106 {
107
108 #ifndef ACPI_APPLICATION
109 if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
110 return;
111 }
112 #endif
113
114 /*
115 * Set the single-step flag. This will cause the debugger (if present)
116 * to break to the console within the AML debugger at the start of the
117 * next AML instruction.
118 */
119 acpi_gbl_cm_single_step = TRUE;
120 acpi_os_printf("**break** Executed AML BreakPoint opcode\n");
121 }
122
123 #ifdef ACPI_DISASSEMBLER
124 /*******************************************************************************
125 *
126 * FUNCTION: acpi_db_get_display_op
127 *
128 * PARAMETERS: walk_state - Current walk
129 * op - Current executing op (from aml interpreter)
130 *
131 * RETURN: Opcode to display
132 *
133 * DESCRIPTION: Find the opcode to display during single stepping
134 *
135 ******************************************************************************/
136
137 static union acpi_parse_object *acpi_db_get_display_op(struct acpi_walk_state
138 *walk_state,
139 union acpi_parse_object
140 *op)
141 {
142 union acpi_parse_object *display_op;
143 union acpi_parse_object *parent_op;
144
145 display_op = op;
146 parent_op = op->common.parent;
147 if (parent_op) {
148 if ((walk_state->control_state) &&
149 (walk_state->control_state->common.state ==
150 ACPI_CONTROL_PREDICATE_EXECUTING)) {
151 /*
152 * We are executing the predicate of an IF or WHILE statement
153 * Search upwards for the containing IF or WHILE so that the
154 * entire predicate can be displayed.
155 */
156 while (parent_op) {
157 if ((parent_op->common.aml_opcode == AML_IF_OP)
158 || (parent_op->common.aml_opcode ==
159 AML_WHILE_OP)) {
160 display_op = parent_op;
161 break;
162 }
163 parent_op = parent_op->common.parent;
164 }
165 } else {
166 while (parent_op) {
167 if ((parent_op->common.aml_opcode == AML_IF_OP)
168 || (parent_op->common.aml_opcode ==
169 AML_ELSE_OP)
170 || (parent_op->common.aml_opcode ==
171 AML_SCOPE_OP)
172 || (parent_op->common.aml_opcode ==
173 AML_METHOD_OP)
174 || (parent_op->common.aml_opcode ==
175 AML_WHILE_OP)) {
176 break;
177 }
178 display_op = parent_op;
179 parent_op = parent_op->common.parent;
180 }
181 }
182 }
183 return display_op;
184 }
185 #endif
186
187 /*******************************************************************************
188 *
189 * FUNCTION: acpi_db_single_step
190 *
191 * PARAMETERS: walk_state - Current walk
192 * op - Current executing op (from aml interpreter)
193 * opcode_class - Class of the current AML Opcode
194 *
195 * RETURN: Status
196 *
197 * DESCRIPTION: Called just before execution of an AML opcode.
198 *
199 ******************************************************************************/
200
201 acpi_status
202 acpi_db_single_step(struct acpi_walk_state *walk_state,
203 union acpi_parse_object *op, u32 opcode_class)
204 {
205 union acpi_parse_object *next;
206 acpi_status status = AE_OK;
207 u32 original_debug_level;
208 u32 aml_offset;
209
210 ACPI_FUNCTION_ENTRY();
211
212 #ifndef ACPI_APPLICATION
213 if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
214 return (AE_OK);
215 }
216 #endif
217
218 /* Check the abort flag */
219
220 if (acpi_gbl_abort_method) {
221 acpi_gbl_abort_method = FALSE;
222 return (AE_ABORT_METHOD);
223 }
224
225 aml_offset = (u32)ACPI_PTR_DIFF(op->common.aml,
226 walk_state->parser_state.aml_start);
227
228 /* Check for single-step breakpoint */
229
230 if (walk_state->method_breakpoint &&
231 (walk_state->method_breakpoint <= aml_offset)) {
232
233 /* Check if the breakpoint has been reached or passed */
234 /* Hit the breakpoint, resume single step, reset breakpoint */
235
236 acpi_os_printf("***Break*** at AML offset %X\n", aml_offset);
237 acpi_gbl_cm_single_step = TRUE;
238 acpi_gbl_step_to_next_call = FALSE;
239 walk_state->method_breakpoint = 0;
240 }
241
242 /* Check for user breakpoint (Must be on exact Aml offset) */
243
244 else if (walk_state->user_breakpoint &&
245 (walk_state->user_breakpoint == aml_offset)) {
246 acpi_os_printf("***UserBreakpoint*** at AML offset %X\n",
247 aml_offset);
248 acpi_gbl_cm_single_step = TRUE;
249 acpi_gbl_step_to_next_call = FALSE;
250 walk_state->method_breakpoint = 0;
251 }
252
253 /*
254 * Check if this is an opcode that we are interested in --
255 * namely, opcodes that have arguments
256 */
257 if (op->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
258 return (AE_OK);
259 }
260
261 switch (opcode_class) {
262 case AML_CLASS_UNKNOWN:
263 case AML_CLASS_ARGUMENT: /* constants, literals, etc. do nothing */
264
265 return (AE_OK);
266
267 default:
268
269 /* All other opcodes -- continue */
270 break;
271 }
272
273 /*
274 * Under certain debug conditions, display this opcode and its operands
275 */
276 if ((acpi_gbl_db_output_to_file) ||
277 (acpi_gbl_cm_single_step) || (acpi_dbg_level & ACPI_LV_PARSE)) {
278 if ((acpi_gbl_db_output_to_file) ||
279 (acpi_dbg_level & ACPI_LV_PARSE)) {
280 acpi_os_printf
281 ("\nAML Debug: Next AML Opcode to execute:\n");
282 }
283
284 /*
285 * Display this op (and only this op - zero out the NEXT field
286 * temporarily, and disable parser trace output for the duration of
287 * the display because we don't want the extraneous debug output)
288 */
289 original_debug_level = acpi_dbg_level;
290 acpi_dbg_level &= ~(ACPI_LV_PARSE | ACPI_LV_FUNCTIONS);
291 next = op->common.next;
292 op->common.next = NULL;
293
294 /* Now we can disassemble and display it */
295
296 #ifdef ACPI_DISASSEMBLER
297 acpi_dm_disassemble(walk_state,
298 acpi_db_get_display_op(walk_state, op),
299 ACPI_UINT32_MAX);
300 #else
301 /*
302 * The AML Disassembler is not configured - at least we can
303 * display the opcode value and name
304 */
305 acpi_os_printf("AML Opcode: %4.4X %s\n", op->common.aml_opcode,
306 acpi_ps_get_opcode_name(op->common.aml_opcode));
307 #endif
308
309 if ((op->common.aml_opcode == AML_IF_OP) ||
310 (op->common.aml_opcode == AML_WHILE_OP)) {
311 if (walk_state->control_state->common.value) {
312 acpi_os_printf
313 ("Predicate = [True], IF block was executed\n");
314 } else {
315 acpi_os_printf
316 ("Predicate = [False], Skipping IF block\n");
317 }
318 } else if (op->common.aml_opcode == AML_ELSE_OP) {
319 acpi_os_printf
320 ("Predicate = [False], ELSE block was executed\n");
321 }
322
323 /* Restore everything */
324
325 op->common.next = next;
326 acpi_os_printf("\n");
327 if ((acpi_gbl_db_output_to_file) ||
328 (acpi_dbg_level & ACPI_LV_PARSE)) {
329 acpi_os_printf("\n");
330 }
331 acpi_dbg_level = original_debug_level;
332 }
333
334 /* If we are not single stepping, just continue executing the method */
335
336 if (!acpi_gbl_cm_single_step) {
337 return (AE_OK);
338 }
339
340 /*
341 * If we are executing a step-to-call command,
342 * Check if this is a method call.
343 */
344 if (acpi_gbl_step_to_next_call) {
345 if (op->common.aml_opcode != AML_INT_METHODCALL_OP) {
346
347 /* Not a method call, just keep executing */
348
349 return (AE_OK);
350 }
351
352 /* Found a method call, stop executing */
353
354 acpi_gbl_step_to_next_call = FALSE;
355 }
356
357 /*
358 * If the next opcode is a method call, we will "step over" it
359 * by default.
360 */
361 if (op->common.aml_opcode == AML_INT_METHODCALL_OP) {
362
363 /* Force no more single stepping while executing called method */
364
365 acpi_gbl_cm_single_step = FALSE;
366
367 /*
368 * Set the breakpoint on/before the call, it will stop execution
369 * as soon as we return
370 */
371 walk_state->method_breakpoint = 1; /* Must be non-zero! */
372 }
373
374 acpi_ex_exit_interpreter();
375 status = acpi_db_start_command(walk_state, op);
376 acpi_ex_enter_interpreter();
377
378 /* User commands complete, continue execution of the interrupted method */
379
380 return (status);
381 }
382
383 /*******************************************************************************
384 *
385 * FUNCTION: acpi_initialize_debugger
386 *
387 * PARAMETERS: None
388 *
389 * RETURN: Status
390 *
391 * DESCRIPTION: Init and start debugger
392 *
393 ******************************************************************************/
394
395 acpi_status acpi_initialize_debugger(void)
396 {
397 acpi_status status;
398
399 ACPI_FUNCTION_TRACE(acpi_initialize_debugger);
400
401 /* Init globals */
402
403 acpi_gbl_db_buffer = NULL;
404 acpi_gbl_db_filename = NULL;
405 acpi_gbl_db_output_to_file = FALSE;
406
407 acpi_gbl_db_debug_level = ACPI_LV_VERBOSITY2;
408 acpi_gbl_db_console_debug_level = ACPI_NORMAL_DEFAULT | ACPI_LV_TABLES;
409 acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
410
411 acpi_gbl_db_opt_no_ini_methods = FALSE;
412
413 acpi_gbl_db_buffer = acpi_os_allocate(ACPI_DEBUG_BUFFER_SIZE);
414 if (!acpi_gbl_db_buffer) {
415 return_ACPI_STATUS(AE_NO_MEMORY);
416 }
417 memset(acpi_gbl_db_buffer, 0, ACPI_DEBUG_BUFFER_SIZE);
418
419 /* Initial scope is the root */
420
421 acpi_gbl_db_scope_buf[0] = AML_ROOT_PREFIX;
422 acpi_gbl_db_scope_buf[1] = 0;
423 acpi_gbl_db_scope_node = acpi_gbl_root_node;
424
425 /* Initialize user commands loop */
426
427 acpi_gbl_db_terminate_loop = FALSE;
428
429 /*
430 * If configured for multi-thread support, the debug executor runs in
431 * a separate thread so that the front end can be in another address
432 * space, environment, or even another machine.
433 */
434 if (acpi_gbl_debugger_configuration & DEBUGGER_MULTI_THREADED) {
435
436 /* These were created with one unit, grab it */
437
438 status = acpi_os_initialize_debugger();
439 if (ACPI_FAILURE(status)) {
440 acpi_os_printf("Could not get debugger mutex\n");
441 return_ACPI_STATUS(status);
442 }
443
444 /* Create the debug execution thread to execute commands */
445
446 acpi_gbl_db_threads_terminated = FALSE;
447 status = acpi_os_execute(OSL_DEBUGGER_MAIN_THREAD,
448 acpi_db_execute_thread, NULL);
449 if (ACPI_FAILURE(status)) {
450 ACPI_EXCEPTION((AE_INFO, status,
451 "Could not start debugger thread"));
452 acpi_gbl_db_threads_terminated = TRUE;
453 return_ACPI_STATUS(status);
454 }
455 } else {
456 acpi_gbl_db_thread_id = acpi_os_get_thread_id();
457 }
458
459 return_ACPI_STATUS(AE_OK);
460 }
461
462 ACPI_EXPORT_SYMBOL(acpi_initialize_debugger)
463
464 /*******************************************************************************
465 *
466 * FUNCTION: acpi_terminate_debugger
467 *
468 * PARAMETERS: None
469 *
470 * RETURN: None
471 *
472 * DESCRIPTION: Stop debugger
473 *
474 ******************************************************************************/
475 void acpi_terminate_debugger(void)
476 {
477
478 /* Terminate the AML Debugger */
479
480 acpi_gbl_db_terminate_loop = TRUE;
481
482 if (acpi_gbl_debugger_configuration & DEBUGGER_MULTI_THREADED) {
483
484 /* Wait the AML Debugger threads */
485
486 while (!acpi_gbl_db_threads_terminated) {
487 acpi_os_sleep(100);
488 }
489
490 acpi_os_terminate_debugger();
491 }
492
493 if (acpi_gbl_db_buffer) {
494 acpi_os_free(acpi_gbl_db_buffer);
495 acpi_gbl_db_buffer = NULL;
496 }
497
498 /* Ensure that debug output is now disabled */
499
500 acpi_gbl_db_output_flags = ACPI_DB_DISABLE_OUTPUT;
501 }
502
503 ACPI_EXPORT_SYMBOL(acpi_terminate_debugger)
504
505 /*******************************************************************************
506 *
507 * FUNCTION: acpi_set_debugger_thread_id
508 *
509 * PARAMETERS: thread_id - Debugger thread ID
510 *
511 * RETURN: None
512 *
513 * DESCRIPTION: Set debugger thread ID
514 *
515 ******************************************************************************/
516 void acpi_set_debugger_thread_id(acpi_thread_id thread_id)
517 {
518 acpi_gbl_db_thread_id = thread_id;
519 }
520
521 ACPI_EXPORT_SYMBOL(acpi_set_debugger_thread_id)