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