drivers/acpi/acpica/dbmethod.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /*******************************************************************************
   3  *
   4  * Module Name: dbmethod - Debug commands for control methods
   5  *
   6  ******************************************************************************/
   7
   8 #include <acpi/acpi.h>
   9 #include "accommon.h"
  10 #include "acdispat.h"
  11 #include "acnamesp.h"
  12 #include "acdebug.h"
  13 #include "acparser.h"
  14 #include "acpredef.h"
  15
  16 #define _COMPONENT          ACPI_CA_DEBUGGER
  17 ACPI_MODULE_NAME("dbmethod")
  18
  19 /* Local prototypes */
  20 static acpi_status
  21 acpi_db_walk_for_execute(acpi_handle obj_handle,
  22                          u32 nesting_level, void *context, void **return_value);
  23
  24 static acpi_status acpi_db_evaluate_object(struct acpi_namespace_node *node);
  25
  26 /*******************************************************************************
  27  *
  28  * FUNCTION:    acpi_db_set_method_breakpoint
  29  *
  30  * PARAMETERS:  location            - AML offset of breakpoint
  31  *              walk_state          - Current walk info
  32  *              op                  - Current Op (from parse walk)
  33  *
  34  * RETURN:      None
  35  *
  36  * DESCRIPTION: Set a breakpoint in a control method at the specified
  37  *              AML offset
  38  *
  39  ******************************************************************************/
  40
  41 void
  42 acpi_db_set_method_breakpoint(char *location,
  43                               struct acpi_walk_state *walk_state,
  44                               union acpi_parse_object *op)
  45 {
  46         u32 address;
  47         u32 aml_offset;
  48
  49         if (!op) {
  50                 acpi_os_printf("There is no method currently executing\n");
  51                 return;
  52         }
  53
  54         /* Get and verify the breakpoint address */
  55
  56         address = strtoul(location, NULL, 16);
  57         aml_offset = (u32)ACPI_PTR_DIFF(op->common.aml,
  58                                         walk_state->parser_state.aml_start);
  59         if (address <= aml_offset) {
  60                 acpi_os_printf("Breakpoint %X is beyond current address %X\n",
  61                                address, aml_offset);
  62         }
  63
  64         /* Save breakpoint in current walk */
  65
  66         walk_state->user_breakpoint = address;
  67         acpi_os_printf("Breakpoint set at AML offset %X\n", address);
  68 }
  69
  70 /*******************************************************************************
  71  *
  72  * FUNCTION:    acpi_db_set_method_call_breakpoint
  73  *
  74  * PARAMETERS:  op                  - Current Op (from parse walk)
  75  *
  76  * RETURN:      None
  77  *
  78  * DESCRIPTION: Set a breakpoint in a control method at the specified
  79  *              AML offset
  80  *
  81  ******************************************************************************/
  82
  83 void acpi_db_set_method_call_breakpoint(union acpi_parse_object *op)
  84 {
  85
  86         if (!op) {
  87                 acpi_os_printf("There is no method currently executing\n");
  88                 return;
  89         }
  90
  91         acpi_gbl_step_to_next_call = TRUE;
  92 }
  93
  94 /*******************************************************************************
  95  *
  96  * FUNCTION:    acpi_db_set_method_data
  97  *
  98  * PARAMETERS:  type_arg        - L for local, A for argument
  99  *              index_arg       - which one
 100  *              value_arg       - Value to set.
 101  *
 102  * RETURN:      None
 103  *
 104  * DESCRIPTION: Set a local or argument for the running control method.
 105  *              NOTE: only object supported is Number.
 106  *
 107  ******************************************************************************/
 108
 109 void acpi_db_set_method_data(char *type_arg, char *index_arg, char *value_arg)
 110 {
 111         char type;
 112         u32 index;
 113         u32 value;
 114         struct acpi_walk_state *walk_state;
 115         union acpi_operand_object *obj_desc;
 116         acpi_status status;
 117         struct acpi_namespace_node *node;
 118
 119         /* Validate type_arg */
 120
 121         acpi_ut_strupr(type_arg);
 122         type = type_arg[0];
 123         if ((type != 'L') && (type != 'A') && (type != 'N')) {
 124                 acpi_os_printf("Invalid SET operand: %s\n", type_arg);
 125                 return;
 126         }
 127
 128         value = strtoul(value_arg, NULL, 16);
 129
 130         if (type == 'N') {
 131                 node = acpi_db_convert_to_node(index_arg);
 132                 if (!node) {
 133                         return;
 134                 }
 135
 136                 if (node->type != ACPI_TYPE_INTEGER) {
 137                         acpi_os_printf("Can only set Integer nodes\n");
 138                         return;
 139                 }
 140                 obj_desc = node->object;
 141                 obj_desc->integer.value = value;
 142                 return;
 143         }
 144
 145         /* Get the index and value */
 146
 147         index = strtoul(index_arg, NULL, 16);
 148
 149         walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list);
 150         if (!walk_state) {
 151                 acpi_os_printf("There is no method currently executing\n");
 152                 return;
 153         }
 154
 155         /* Create and initialize the new object */
 156
 157         obj_desc = acpi_ut_create_integer_object((u64)value);
 158         if (!obj_desc) {
 159                 acpi_os_printf("Could not create an internal object\n");
 160                 return;
 161         }
 162
 163         /* Store the new object into the target */
 164
 165         switch (type) {
 166         case 'A':
 167
 168                 /* Set a method argument */
 169
 170                 if (index > ACPI_METHOD_MAX_ARG) {
 171                         acpi_os_printf("Arg%u - Invalid argument name\n",
 172                                        index);
 173                         goto cleanup;
 174                 }
 175
 176                 status = acpi_ds_store_object_to_local(ACPI_REFCLASS_ARG,
 177                                                        index, obj_desc,
 178                                                        walk_state);
 179                 if (ACPI_FAILURE(status)) {
 180                         goto cleanup;
 181                 }
 182
 183                 obj_desc = walk_state->arguments[index].object;
 184
 185                 acpi_os_printf("Arg%u: ", index);
 186                 acpi_db_display_internal_object(obj_desc, walk_state);
 187                 break;
 188
 189         case 'L':
 190
 191                 /* Set a method local */
 192
 193                 if (index > ACPI_METHOD_MAX_LOCAL) {
 194                         acpi_os_printf
 195                             ("Local%u - Invalid local variable name\n", index);
 196                         goto cleanup;
 197                 }
 198
 199                 status = acpi_ds_store_object_to_local(ACPI_REFCLASS_LOCAL,
 200                                                        index, obj_desc,
 201                                                        walk_state);
 202                 if (ACPI_FAILURE(status)) {
 203                         goto cleanup;
 204                 }
 205
 206                 obj_desc = walk_state->local_variables[index].object;
 207
 208                 acpi_os_printf("Local%u: ", index);
 209                 acpi_db_display_internal_object(obj_desc, walk_state);
 210                 break;
 211
 212         default:
 213
 214                 break;
 215         }
 216
 217 cleanup:
 218         acpi_ut_remove_reference(obj_desc);
 219 }
 220
 221 #ifdef ACPI_DISASSEMBLER
 222 /*******************************************************************************
 223  *
 224  * FUNCTION:    acpi_db_disassemble_aml
 225  *
 226  * PARAMETERS:  statements          - Number of statements to disassemble
 227  *              op                  - Current Op (from parse walk)
 228  *
 229  * RETURN:      None
 230  *
 231  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
 232  *              of statements specified.
 233  *
 234  ******************************************************************************/
 235
 236 void acpi_db_disassemble_aml(char *statements, union acpi_parse_object *op)
 237 {
 238         u32 num_statements = 8;
 239
 240         if (!op) {
 241                 acpi_os_printf("There is no method currently executing\n");
 242                 return;
 243         }
 244
 245         if (statements) {
 246                 num_statements = strtoul(statements, NULL, 0);
 247         }
 248
 249         acpi_dm_disassemble(NULL, op, num_statements);
 250 }
 251
 252 /*******************************************************************************
 253  *
 254  * FUNCTION:    acpi_db_disassemble_method
 255  *
 256  * PARAMETERS:  name            - Name of control method
 257  *
 258  * RETURN:      None
 259  *
 260  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
 261  *              of statements specified.
 262  *
 263  ******************************************************************************/
 264
 265 acpi_status acpi_db_disassemble_method(char *name)
 266 {
 267         acpi_status status;
 268         union acpi_parse_object *op;
 269         struct acpi_walk_state *walk_state;
 270         union acpi_operand_object *obj_desc;
 271         struct acpi_namespace_node *method;
 272
 273         method = acpi_db_convert_to_node(name);
 274         if (!method) {
 275                 return (AE_BAD_PARAMETER);
 276         }
 277
 278         if (method->type != ACPI_TYPE_METHOD) {
 279                 ACPI_ERROR((AE_INFO, "%s (%s): Object must be a control method",
 280                             name, acpi_ut_get_type_name(method->type)));
 281                 return (AE_BAD_PARAMETER);
 282         }
 283
 284         obj_desc = method->object;
 285
 286         op = acpi_ps_create_scope_op(obj_desc->method.aml_start);
 287         if (!op) {
 288                 return (AE_NO_MEMORY);
 289         }
 290
 291         /* Create and initialize a new walk state */
 292
 293         walk_state = acpi_ds_create_walk_state(0, op, NULL, NULL);
 294         if (!walk_state) {
 295                 return (AE_NO_MEMORY);
 296         }
 297
 298         status = acpi_ds_init_aml_walk(walk_state, op, NULL,
 299                                        obj_desc->method.aml_start,
 300                                        obj_desc->method.aml_length, NULL,
 301                                        ACPI_IMODE_LOAD_PASS1);
 302         if (ACPI_FAILURE(status)) {
 303                 return (status);
 304         }
 305
 306         status = acpi_ut_allocate_owner_id(&obj_desc->method.owner_id);
 307         if (ACPI_FAILURE(status)) {
 308                 return (status);
 309         }
 310
 311         walk_state->owner_id = obj_desc->method.owner_id;
 312
 313         /* Push start scope on scope stack and make it current */
 314
 315         status = acpi_ds_scope_stack_push(method, method->type, walk_state);
 316         if (ACPI_FAILURE(status)) {
 317                 return (status);
 318         }
 319
 320         /* Parse the entire method AML including deferred operators */
 321
 322         walk_state->parse_flags &= ~ACPI_PARSE_DELETE_TREE;
 323         walk_state->parse_flags |= ACPI_PARSE_DISASSEMBLE;
 324
 325         status = acpi_ps_parse_aml(walk_state);
 326         if (ACPI_FAILURE(status)) {
 327                 return (status);
 328         }
 329
 330         (void)acpi_dm_parse_deferred_ops(op);
 331
 332         /* Now we can disassemble the method */
 333
 334         acpi_gbl_dm_opt_verbose = FALSE;
 335         acpi_dm_disassemble(NULL, op, 0);
 336         acpi_gbl_dm_opt_verbose = TRUE;
 337
 338         acpi_ps_delete_parse_tree(op);
 339
 340         /* Method cleanup */
 341
 342         acpi_ns_delete_namespace_subtree(method);
 343         acpi_ns_delete_namespace_by_owner(obj_desc->method.owner_id);
 344         acpi_ut_release_owner_id(&obj_desc->method.owner_id);
 345         return (AE_OK);
 346 }
 347 #endif
 348
 349 /*******************************************************************************
 350  *
 351  * FUNCTION:    acpi_db_evaluate_object
 352  *
 353  * PARAMETERS:  node                - Namespace node for the object
 354  *
 355  * RETURN:      Status
 356  *
 357  * DESCRIPTION: Main execution function for the Evaluate/Execute/All debugger
 358  *              commands.
 359  *
 360  ******************************************************************************/
 361
 362 static acpi_status acpi_db_evaluate_object(struct acpi_namespace_node *node)
 363 {
 364         char *pathname;
 365         u32 i;
 366         struct acpi_device_info *obj_info;
 367         struct acpi_object_list param_objects;
 368         union acpi_object params[ACPI_METHOD_NUM_ARGS];
 369         struct acpi_buffer return_obj;
 370         acpi_status status;
 371
 372         pathname = acpi_ns_get_external_pathname(node);
 373         if (!pathname) {
 374                 return (AE_OK);
 375         }
 376
 377         /* Get the object info for number of method parameters */
 378
 379         status = acpi_get_object_info(node, &obj_info);
 380         if (ACPI_FAILURE(status)) {
 381                 ACPI_FREE(pathname);
 382                 return (status);
 383         }
 384
 385         param_objects.pointer = NULL;
 386         param_objects.count = 0;
 387
 388         if (obj_info->type == ACPI_TYPE_METHOD) {
 389
 390                 /* Setup default parameters */
 391
 392                 for (i = 0; i < obj_info->param_count; i++) {
 393                         params[i].type = ACPI_TYPE_INTEGER;
 394                         params[i].integer.value = 1;
 395                 }
 396
 397                 param_objects.pointer = params;
 398                 param_objects.count = obj_info->param_count;
 399         }
 400
 401         ACPI_FREE(obj_info);
 402         return_obj.pointer = NULL;
 403         return_obj.length = ACPI_ALLOCATE_BUFFER;
 404
 405         /* Do the actual method execution */
 406
 407         acpi_gbl_method_executing = TRUE;
 408
 409         status = acpi_evaluate_object(node, NULL, &param_objects, &return_obj);
 410         acpi_gbl_method_executing = FALSE;
 411
 412         acpi_os_printf("%-32s returned %s\n", pathname,
 413                        acpi_format_exception(status));
 414         if (return_obj.length) {
 415                 acpi_os_printf("Evaluation of %s returned object %p, "
 416                                "external buffer length %X\n",
 417                                pathname, return_obj.pointer,
 418                                (u32)return_obj.length);
 419
 420                 acpi_db_dump_external_object(return_obj.pointer, 1);
 421                 acpi_os_printf("\n");
 422         }
 423
 424         ACPI_FREE(pathname);
 425
 426         /* Ignore status from method execution */
 427
 428         return (AE_OK);
 429
 430         /* Update count, check if we have executed enough methods */
 431
 432 }
 433
 434 /*******************************************************************************
 435  *
 436  * FUNCTION:    acpi_db_walk_for_execute
 437  *
 438  * PARAMETERS:  Callback from walk_namespace
 439  *
 440  * RETURN:      Status
 441  *
 442  * DESCRIPTION: Batch execution function. Evaluates all "predefined" objects --
 443  *              the nameseg begins with an underscore.
 444  *
 445  ******************************************************************************/
 446
 447 static acpi_status
 448 acpi_db_walk_for_execute(acpi_handle obj_handle,
 449                          u32 nesting_level, void *context, void **return_value)
 450 {
 451         struct acpi_namespace_node *node =
 452             (struct acpi_namespace_node *)obj_handle;
 453         struct acpi_db_execute_walk *info =
 454             (struct acpi_db_execute_walk *)context;
 455         acpi_status status;
 456         const union acpi_predefined_info *predefined;
 457
 458         predefined = acpi_ut_match_predefined_method(node->name.ascii);
 459         if (!predefined) {
 460                 return (AE_OK);
 461         }
 462
 463         if (node->type == ACPI_TYPE_LOCAL_SCOPE) {
 464                 return (AE_OK);
 465         }
 466
 467         acpi_db_evaluate_object(node);
 468
 469         /* Ignore status from object evaluation */
 470
 471         status = AE_OK;
 472
 473         /* Update count, check if we have executed enough methods */
 474
 475         info->count++;
 476         if (info->count >= info->max_count) {
 477                 status = AE_CTRL_TERMINATE;
 478         }
 479
 480         return (status);
 481 }
 482
 483 /*******************************************************************************
 484  *
 485  * FUNCTION:    acpi_db_walk_for_execute_all
 486  *
 487  * PARAMETERS:  Callback from walk_namespace
 488  *
 489  * RETURN:      Status
 490  *
 491  * DESCRIPTION: Batch execution function. Evaluates all objects whose path ends
 492  *              with the nameseg "Info->NameSeg". Used for the "ALL" command.
 493  *
 494  ******************************************************************************/
 495
 496 static acpi_status
 497 acpi_db_walk_for_execute_all(acpi_handle obj_handle,
 498                              u32 nesting_level,
 499                              void *context, void **return_value)
 500 {
 501         struct acpi_namespace_node *node =
 502             (struct acpi_namespace_node *)obj_handle;
 503         struct acpi_db_execute_walk *info =
 504             (struct acpi_db_execute_walk *)context;
 505         acpi_status status;
 506
 507         if (!ACPI_COMPARE_NAMESEG(node->name.ascii, info->name_seg)) {
 508                 return (AE_OK);
 509         }
 510
 511         if (node->type == ACPI_TYPE_LOCAL_SCOPE) {
 512                 return (AE_OK);
 513         }
 514
 515         /* Now evaluate the input object (node) */
 516
 517         acpi_db_evaluate_object(node);
 518
 519         /* Ignore status from method execution */
 520
 521         status = AE_OK;
 522
 523         /* Update count of executed methods/objects */
 524
 525         info->count++;
 526         return (status);
 527 }
 528
 529 /*******************************************************************************
 530  *
 531  * FUNCTION:    acpi_db_evaluate_predefined_names
 532  *
 533  * PARAMETERS:  None
 534  *
 535  * RETURN:      None
 536  *
 537  * DESCRIPTION: Namespace batch execution. Execute predefined names in the
 538  *              namespace, up to the max count, if specified.
 539  *
 540  ******************************************************************************/
 541
 542 void acpi_db_evaluate_predefined_names(void)
 543 {
 544         struct acpi_db_execute_walk info;
 545
 546         info.count = 0;
 547         info.max_count = ACPI_UINT32_MAX;
 548
 549         /* Search all nodes in namespace */
 550
 551         (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 552                                   ACPI_UINT32_MAX, acpi_db_walk_for_execute,
 553                                   NULL, (void *)&info, NULL);
 554
 555         acpi_os_printf("Evaluated %u predefined names in the namespace\n",
 556                        info.count);
 557 }
 558
 559 /*******************************************************************************
 560  *
 561  * FUNCTION:    acpi_db_evaluate_all
 562  *
 563  * PARAMETERS:  none_acpi_gbl_db_method_info
 564  *
 565  * RETURN:      None
 566  *
 567  * DESCRIPTION: Namespace batch execution. Implements the "ALL" command.
 568  *              Execute all namepaths whose final nameseg matches the
 569  *              input nameseg.
 570  *
 571  ******************************************************************************/
 572
 573 void acpi_db_evaluate_all(char *name_seg)
 574 {
 575         struct acpi_db_execute_walk info;
 576
 577         info.count = 0;
 578         info.max_count = ACPI_UINT32_MAX;
 579         ACPI_COPY_NAMESEG(info.name_seg, name_seg);
 580         info.name_seg[ACPI_NAMESEG_SIZE] = 0;
 581
 582         /* Search all nodes in namespace */
 583
 584         (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 585                                   ACPI_UINT32_MAX, acpi_db_walk_for_execute_all,
 586                                   NULL, (void *)&info, NULL);
 587
 588         acpi_os_printf("Evaluated %u names in the namespace\n", info.count);
 589 }