mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-08 02:26:42 +07:00
f5c1e1c5a6
ACPICA commit b2294cae776f5a66a7697414b21949d307e6856f This patch removes unwanted spaces for typedef. This solution doesn't cover function types. Note that the linuxize result of this commit is very giant and should have many conflicts against the current Linux upstream. Thus it is required to modify the linuxize result of this commit and the commits around it manually in order to have them merged to the Linux upstream. Since this is very costy, we should do this only once, and if we can't ensure to do this only once, we need to revert the Linux code to the wrong indentation result before merging the linuxize result of this commit. Lv Zheng. Link: https://github.com/acpica/acpica/commit/b2294cae Signed-off-by: Lv Zheng <lv.zheng@intel.com> Signed-off-by: Bob Moore <robert.moore@intel.com> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
517 lines
14 KiB
C
517 lines
14 KiB
C
/*******************************************************************************
|
|
*
|
|
* Module Name: dbxface - AML Debugger external interfaces
|
|
*
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* Copyright (C) 2000 - 2016, Intel Corp.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions, and the following disclaimer,
|
|
* without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* substantially similar to the "NO WARRANTY" disclaimer below
|
|
* ("Disclaimer") and any redistribution must be conditioned upon
|
|
* including a substantially similar Disclaimer requirement for further
|
|
* binary redistribution.
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
* of any contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
* Software Foundation.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
|
|
#include <acpi/acpi.h>
|
|
#include "accommon.h"
|
|
#include "amlcode.h"
|
|
#include "acdebug.h"
|
|
|
|
#define _COMPONENT ACPI_CA_DEBUGGER
|
|
ACPI_MODULE_NAME("dbxface")
|
|
|
|
/* Local prototypes */
|
|
static acpi_status
|
|
acpi_db_start_command(struct acpi_walk_state *walk_state,
|
|
union acpi_parse_object *op);
|
|
|
|
#ifdef ACPI_OBSOLETE_FUNCTIONS
|
|
void acpi_db_method_end(struct acpi_walk_state *walk_state);
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_db_start_command
|
|
*
|
|
* PARAMETERS: walk_state - Current walk
|
|
* op - Current executing Op, from AML interpreter
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Enter debugger command loop
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_db_start_command(struct acpi_walk_state *walk_state,
|
|
union acpi_parse_object *op)
|
|
{
|
|
acpi_status status;
|
|
|
|
/* TBD: [Investigate] are there namespace locking issues here? */
|
|
|
|
/* acpi_ut_release_mutex (ACPI_MTX_NAMESPACE); */
|
|
|
|
/* Go into the command loop and await next user command */
|
|
|
|
acpi_gbl_method_executing = TRUE;
|
|
status = AE_CTRL_TRUE;
|
|
|
|
while (status == AE_CTRL_TRUE) {
|
|
|
|
/* Notify the completion of the command */
|
|
|
|
status = acpi_os_notify_command_complete();
|
|
if (ACPI_FAILURE(status)) {
|
|
goto error_exit;
|
|
}
|
|
|
|
/* Wait the readiness of the command */
|
|
|
|
status = acpi_os_wait_command_ready();
|
|
if (ACPI_FAILURE(status)) {
|
|
goto error_exit;
|
|
}
|
|
|
|
status =
|
|
acpi_db_command_dispatch(acpi_gbl_db_line_buf, walk_state,
|
|
op);
|
|
}
|
|
|
|
/* acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE); */
|
|
|
|
error_exit:
|
|
if (ACPI_FAILURE(status) && status != AE_CTRL_TERMINATE) {
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
"While parsing/handling command line"));
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_db_signal_break_point
|
|
*
|
|
* PARAMETERS: walk_state - Current walk
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Called for AML_BREAK_POINT_OP
|
|
*
|
|
******************************************************************************/
|
|
|
|
void acpi_db_signal_break_point(struct acpi_walk_state *walk_state)
|
|
{
|
|
|
|
#ifndef ACPI_APPLICATION
|
|
if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Set the single-step flag. This will cause the debugger (if present)
|
|
* to break to the console within the AML debugger at the start of the
|
|
* next AML instruction.
|
|
*/
|
|
acpi_gbl_cm_single_step = TRUE;
|
|
acpi_os_printf("**break** Executed AML BreakPoint opcode\n");
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_db_single_step
|
|
*
|
|
* PARAMETERS: walk_state - Current walk
|
|
* op - Current executing op (from aml interpreter)
|
|
* opcode_class - Class of the current AML Opcode
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Called just before execution of an AML opcode.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status
|
|
acpi_db_single_step(struct acpi_walk_state *walk_state,
|
|
union acpi_parse_object *op, u32 opcode_class)
|
|
{
|
|
union acpi_parse_object *next;
|
|
acpi_status status = AE_OK;
|
|
u32 original_debug_level;
|
|
union acpi_parse_object *display_op;
|
|
union acpi_parse_object *parent_op;
|
|
u32 aml_offset;
|
|
|
|
ACPI_FUNCTION_ENTRY();
|
|
|
|
#ifndef ACPI_APPLICATION
|
|
if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) {
|
|
return (AE_OK);
|
|
}
|
|
#endif
|
|
|
|
/* Check the abort flag */
|
|
|
|
if (acpi_gbl_abort_method) {
|
|
acpi_gbl_abort_method = FALSE;
|
|
return (AE_ABORT_METHOD);
|
|
}
|
|
|
|
aml_offset = (u32)ACPI_PTR_DIFF(op->common.aml,
|
|
walk_state->parser_state.aml_start);
|
|
|
|
/* Check for single-step breakpoint */
|
|
|
|
if (walk_state->method_breakpoint &&
|
|
(walk_state->method_breakpoint <= aml_offset)) {
|
|
|
|
/* Check if the breakpoint has been reached or passed */
|
|
/* Hit the breakpoint, resume single step, reset breakpoint */
|
|
|
|
acpi_os_printf("***Break*** at AML offset %X\n", aml_offset);
|
|
acpi_gbl_cm_single_step = TRUE;
|
|
acpi_gbl_step_to_next_call = FALSE;
|
|
walk_state->method_breakpoint = 0;
|
|
}
|
|
|
|
/* Check for user breakpoint (Must be on exact Aml offset) */
|
|
|
|
else if (walk_state->user_breakpoint &&
|
|
(walk_state->user_breakpoint == aml_offset)) {
|
|
acpi_os_printf("***UserBreakpoint*** at AML offset %X\n",
|
|
aml_offset);
|
|
acpi_gbl_cm_single_step = TRUE;
|
|
acpi_gbl_step_to_next_call = FALSE;
|
|
walk_state->method_breakpoint = 0;
|
|
}
|
|
|
|
/*
|
|
* Check if this is an opcode that we are interested in --
|
|
* namely, opcodes that have arguments
|
|
*/
|
|
if (op->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
|
|
return (AE_OK);
|
|
}
|
|
|
|
switch (opcode_class) {
|
|
case AML_CLASS_UNKNOWN:
|
|
case AML_CLASS_ARGUMENT: /* constants, literals, etc. do nothing */
|
|
|
|
return (AE_OK);
|
|
|
|
default:
|
|
|
|
/* All other opcodes -- continue */
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Under certain debug conditions, display this opcode and its operands
|
|
*/
|
|
if ((acpi_gbl_db_output_to_file) ||
|
|
(acpi_gbl_cm_single_step) || (acpi_dbg_level & ACPI_LV_PARSE)) {
|
|
if ((acpi_gbl_db_output_to_file) ||
|
|
(acpi_dbg_level & ACPI_LV_PARSE)) {
|
|
acpi_os_printf
|
|
("\n[AmlDebug] Next AML Opcode to execute:\n");
|
|
}
|
|
|
|
/*
|
|
* Display this op (and only this op - zero out the NEXT field
|
|
* temporarily, and disable parser trace output for the duration of
|
|
* the display because we don't want the extraneous debug output)
|
|
*/
|
|
original_debug_level = acpi_dbg_level;
|
|
acpi_dbg_level &= ~(ACPI_LV_PARSE | ACPI_LV_FUNCTIONS);
|
|
next = op->common.next;
|
|
op->common.next = NULL;
|
|
|
|
display_op = op;
|
|
parent_op = op->common.parent;
|
|
if (parent_op) {
|
|
if ((walk_state->control_state) &&
|
|
(walk_state->control_state->common.state ==
|
|
ACPI_CONTROL_PREDICATE_EXECUTING)) {
|
|
/*
|
|
* We are executing the predicate of an IF or WHILE statement
|
|
* Search upwards for the containing IF or WHILE so that the
|
|
* entire predicate can be displayed.
|
|
*/
|
|
while (parent_op) {
|
|
if ((parent_op->common.aml_opcode ==
|
|
AML_IF_OP)
|
|
|| (parent_op->common.aml_opcode ==
|
|
AML_WHILE_OP)) {
|
|
display_op = parent_op;
|
|
break;
|
|
}
|
|
parent_op = parent_op->common.parent;
|
|
}
|
|
} else {
|
|
while (parent_op) {
|
|
if ((parent_op->common.aml_opcode ==
|
|
AML_IF_OP)
|
|
|| (parent_op->common.aml_opcode ==
|
|
AML_ELSE_OP)
|
|
|| (parent_op->common.aml_opcode ==
|
|
AML_SCOPE_OP)
|
|
|| (parent_op->common.aml_opcode ==
|
|
AML_METHOD_OP)
|
|
|| (parent_op->common.aml_opcode ==
|
|
AML_WHILE_OP)) {
|
|
break;
|
|
}
|
|
display_op = parent_op;
|
|
parent_op = parent_op->common.parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now we can display it */
|
|
|
|
#ifdef ACPI_DISASSEMBLER
|
|
acpi_dm_disassemble(walk_state, display_op, ACPI_UINT32_MAX);
|
|
#endif
|
|
|
|
if ((op->common.aml_opcode == AML_IF_OP) ||
|
|
(op->common.aml_opcode == AML_WHILE_OP)) {
|
|
if (walk_state->control_state->common.value) {
|
|
acpi_os_printf
|
|
("Predicate = [True], IF block was executed\n");
|
|
} else {
|
|
acpi_os_printf
|
|
("Predicate = [False], Skipping IF block\n");
|
|
}
|
|
} else if (op->common.aml_opcode == AML_ELSE_OP) {
|
|
acpi_os_printf
|
|
("Predicate = [False], ELSE block was executed\n");
|
|
}
|
|
|
|
/* Restore everything */
|
|
|
|
op->common.next = next;
|
|
acpi_os_printf("\n");
|
|
if ((acpi_gbl_db_output_to_file) ||
|
|
(acpi_dbg_level & ACPI_LV_PARSE)) {
|
|
acpi_os_printf("\n");
|
|
}
|
|
acpi_dbg_level = original_debug_level;
|
|
}
|
|
|
|
/* If we are not single stepping, just continue executing the method */
|
|
|
|
if (!acpi_gbl_cm_single_step) {
|
|
return (AE_OK);
|
|
}
|
|
|
|
/*
|
|
* If we are executing a step-to-call command,
|
|
* Check if this is a method call.
|
|
*/
|
|
if (acpi_gbl_step_to_next_call) {
|
|
if (op->common.aml_opcode != AML_INT_METHODCALL_OP) {
|
|
|
|
/* Not a method call, just keep executing */
|
|
|
|
return (AE_OK);
|
|
}
|
|
|
|
/* Found a method call, stop executing */
|
|
|
|
acpi_gbl_step_to_next_call = FALSE;
|
|
}
|
|
|
|
/*
|
|
* If the next opcode is a method call, we will "step over" it
|
|
* by default.
|
|
*/
|
|
if (op->common.aml_opcode == AML_INT_METHODCALL_OP) {
|
|
|
|
/* Force no more single stepping while executing called method */
|
|
|
|
acpi_gbl_cm_single_step = FALSE;
|
|
|
|
/*
|
|
* Set the breakpoint on/before the call, it will stop execution
|
|
* as soon as we return
|
|
*/
|
|
walk_state->method_breakpoint = 1; /* Must be non-zero! */
|
|
}
|
|
|
|
status = acpi_db_start_command(walk_state, op);
|
|
|
|
/* User commands complete, continue execution of the interrupted method */
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_initialize_debugger
|
|
*
|
|
* PARAMETERS: None
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Init and start debugger
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_initialize_debugger(void)
|
|
{
|
|
acpi_status status;
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_initialize_debugger);
|
|
|
|
/* Init globals */
|
|
|
|
acpi_gbl_db_buffer = NULL;
|
|
acpi_gbl_db_filename = NULL;
|
|
acpi_gbl_db_output_to_file = FALSE;
|
|
|
|
acpi_gbl_db_debug_level = ACPI_LV_VERBOSITY2;
|
|
acpi_gbl_db_console_debug_level = ACPI_NORMAL_DEFAULT | ACPI_LV_TABLES;
|
|
acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
|
|
|
|
acpi_gbl_db_opt_no_ini_methods = FALSE;
|
|
|
|
acpi_gbl_db_buffer = acpi_os_allocate(ACPI_DEBUG_BUFFER_SIZE);
|
|
if (!acpi_gbl_db_buffer) {
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
}
|
|
memset(acpi_gbl_db_buffer, 0, ACPI_DEBUG_BUFFER_SIZE);
|
|
|
|
/* Initial scope is the root */
|
|
|
|
acpi_gbl_db_scope_buf[0] = AML_ROOT_PREFIX;
|
|
acpi_gbl_db_scope_buf[1] = 0;
|
|
acpi_gbl_db_scope_node = acpi_gbl_root_node;
|
|
|
|
/* Initialize user commands loop */
|
|
|
|
acpi_gbl_db_terminate_loop = FALSE;
|
|
|
|
/*
|
|
* If configured for multi-thread support, the debug executor runs in
|
|
* a separate thread so that the front end can be in another address
|
|
* space, environment, or even another machine.
|
|
*/
|
|
if (acpi_gbl_debugger_configuration & DEBUGGER_MULTI_THREADED) {
|
|
|
|
/* These were created with one unit, grab it */
|
|
|
|
status = acpi_os_initialize_command_signals();
|
|
if (ACPI_FAILURE(status)) {
|
|
acpi_os_printf("Could not get debugger mutex\n");
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/* Create the debug execution thread to execute commands */
|
|
|
|
acpi_gbl_db_threads_terminated = FALSE;
|
|
status = acpi_os_execute(OSL_DEBUGGER_MAIN_THREAD,
|
|
acpi_db_execute_thread, NULL);
|
|
if (ACPI_FAILURE(status)) {
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
"Could not start debugger thread"));
|
|
acpi_gbl_db_threads_terminated = TRUE;
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
} else {
|
|
acpi_gbl_db_thread_id = acpi_os_get_thread_id();
|
|
}
|
|
|
|
return_ACPI_STATUS(AE_OK);
|
|
}
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_initialize_debugger)
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_terminate_debugger
|
|
*
|
|
* PARAMETERS: None
|
|
*
|
|
* RETURN: None
|
|
*
|
|
* DESCRIPTION: Stop debugger
|
|
*
|
|
******************************************************************************/
|
|
void acpi_terminate_debugger(void)
|
|
{
|
|
|
|
/* Terminate the AML Debugger */
|
|
|
|
acpi_gbl_db_terminate_loop = TRUE;
|
|
|
|
if (acpi_gbl_debugger_configuration & DEBUGGER_MULTI_THREADED) {
|
|
|
|
/* Wait the AML Debugger threads */
|
|
|
|
while (!acpi_gbl_db_threads_terminated) {
|
|
acpi_os_sleep(100);
|
|
}
|
|
|
|
acpi_os_terminate_command_signals();
|
|
}
|
|
|
|
if (acpi_gbl_db_buffer) {
|
|
acpi_os_free(acpi_gbl_db_buffer);
|
|
acpi_gbl_db_buffer = NULL;
|
|
}
|
|
|
|
/* Ensure that debug output is now disabled */
|
|
|
|
acpi_gbl_db_output_flags = ACPI_DB_DISABLE_OUTPUT;
|
|
}
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_terminate_debugger)
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_set_debugger_thread_id
|
|
*
|
|
* PARAMETERS: thread_id - Debugger thread ID
|
|
*
|
|
* RETURN: None
|
|
*
|
|
* DESCRIPTION: Set debugger thread ID
|
|
*
|
|
******************************************************************************/
|
|
void acpi_set_debugger_thread_id(acpi_thread_id thread_id)
|
|
{
|
|
acpi_gbl_db_thread_id = thread_id;
|
|
}
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_set_debugger_thread_id)
|