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