Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Module Name: dsdebug - Parser/Interpreter interface - debugging
  4.  *
  5.  *****************************************************************************/
  6.  
  7. /*
  8.  * Copyright (C) 2000 - 2015, 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 "acdispat.h"
  47. #include "acnamesp.h"
  48. #ifdef ACPI_DISASSEMBLER
  49. #include "acdisasm.h"
  50. #endif
  51. #include "acinterp.h"
  52.  
  53. #define _COMPONENT          ACPI_DISPATCHER
  54. ACPI_MODULE_NAME("dsdebug")
  55.  
  56. #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
  57. /* Local prototypes */
  58. static void
  59. acpi_ds_print_node_pathname(struct acpi_namespace_node *node,
  60.                             const char *message);
  61.  
  62. /*******************************************************************************
  63.  *
  64.  * FUNCTION:    acpi_ds_print_node_pathname
  65.  *
  66.  * PARAMETERS:  node            - Object
  67.  *              message         - Prefix message
  68.  *
  69.  * DESCRIPTION: Print an object's full namespace pathname
  70.  *              Manages allocation/freeing of a pathname buffer
  71.  *
  72.  ******************************************************************************/
  73.  
  74. static void
  75. acpi_ds_print_node_pathname(struct acpi_namespace_node *node,
  76.                             const char *message)
  77. {
  78.         struct acpi_buffer buffer;
  79.         acpi_status status;
  80.  
  81.         ACPI_FUNCTION_TRACE(ds_print_node_pathname);
  82.  
  83.         if (!node) {
  84.                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "[NULL NAME]"));
  85.                 return_VOID;
  86.         }
  87.  
  88.         /* Convert handle to full pathname and print it (with supplied message) */
  89.  
  90.         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
  91.  
  92.         status = acpi_ns_handle_to_pathname(node, &buffer, TRUE);
  93.         if (ACPI_SUCCESS(status)) {
  94.                 if (message) {
  95.                         ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "%s ",
  96.                                               message));
  97.                 }
  98.  
  99.                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "[%s] (Node %p)",
  100.                                       (char *)buffer.pointer, node));
  101.                 ACPI_FREE(buffer.pointer);
  102.         }
  103.  
  104.         return_VOID;
  105. }
  106.  
  107. /*******************************************************************************
  108.  *
  109.  * FUNCTION:    acpi_ds_dump_method_stack
  110.  *
  111.  * PARAMETERS:  status          - Method execution status
  112.  *              walk_state      - Current state of the parse tree walk
  113.  *              op              - Executing parse op
  114.  *
  115.  * RETURN:      None
  116.  *
  117.  * DESCRIPTION: Called when a method has been aborted because of an error.
  118.  *              Dumps the method execution stack.
  119.  *
  120.  ******************************************************************************/
  121.  
  122. void
  123. acpi_ds_dump_method_stack(acpi_status status,
  124.                           struct acpi_walk_state *walk_state,
  125.                           union acpi_parse_object *op)
  126. {
  127.         union acpi_parse_object *next;
  128.         struct acpi_thread_state *thread;
  129.         struct acpi_walk_state *next_walk_state;
  130.         struct acpi_namespace_node *previous_method = NULL;
  131.         union acpi_operand_object *method_desc;
  132.  
  133.         ACPI_FUNCTION_TRACE(ds_dump_method_stack);
  134.  
  135.         /* Ignore control codes, they are not errors */
  136.  
  137.         if ((status & AE_CODE_MASK) == AE_CODE_CONTROL) {
  138.                 return_VOID;
  139.         }
  140.  
  141.         /* We may be executing a deferred opcode */
  142.  
  143.         if (walk_state->deferred_node) {
  144.                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
  145.                                   "Executing subtree for Buffer/Package/Region\n"));
  146.                 return_VOID;
  147.         }
  148.  
  149.         /*
  150.          * If there is no Thread, we are not actually executing a method.
  151.          * This can happen when the iASL compiler calls the interpreter
  152.          * to perform constant folding.
  153.          */
  154.         thread = walk_state->thread;
  155.         if (!thread) {
  156.                 return_VOID;
  157.         }
  158.  
  159.         /* Display exception and method name */
  160.  
  161.         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
  162.                           "\n**** Exception %s during execution of method ",
  163.                           acpi_format_exception(status)));
  164.         acpi_ds_print_node_pathname(walk_state->method_node, NULL);
  165.  
  166.         /* Display stack of executing methods */
  167.  
  168.         ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH,
  169.                               "\n\nMethod Execution Stack:\n"));
  170.         next_walk_state = thread->walk_state_list;
  171.  
  172.         /* Walk list of linked walk states */
  173.  
  174.         while (next_walk_state) {
  175.                 method_desc = next_walk_state->method_desc;
  176.                 if (method_desc) {
  177.                         acpi_ex_stop_trace_method((struct acpi_namespace_node *)
  178.                                                   method_desc->method.node,
  179.                                                   method_desc, walk_state);
  180.                 }
  181.  
  182.                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
  183.                                   "    Method [%4.4s] executing: ",
  184.                                   acpi_ut_get_node_name(next_walk_state->
  185.                                                         method_node)));
  186.  
  187.                 /* First method is the currently executing method */
  188.  
  189.                 if (next_walk_state == walk_state) {
  190.                         if (op) {
  191.  
  192.                                 /* Display currently executing ASL statement */
  193.  
  194.                                 next = op->common.next;
  195.                                 op->common.next = NULL;
  196.  
  197. #ifdef ACPI_DISASSEMBLER
  198.                                 acpi_dm_disassemble(next_walk_state, op,
  199.                                                     ACPI_UINT32_MAX);
  200. #endif
  201.                                 op->common.next = next;
  202.                         }
  203.                 } else {
  204.                         /*
  205.                          * This method has called another method
  206.                          * NOTE: the method call parse subtree is already deleted at this
  207.                          * point, so we cannot disassemble the method invocation.
  208.                          */
  209.                         ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH,
  210.                                               "Call to method "));
  211.                         acpi_ds_print_node_pathname(previous_method, NULL);
  212.                 }
  213.  
  214.                 previous_method = next_walk_state->method_node;
  215.                 next_walk_state = next_walk_state->next;
  216.                 ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "\n"));
  217.         }
  218.  
  219.         return_VOID;
  220. }
  221.  
  222. #else
  223. void
  224. acpi_ds_dump_method_stack(acpi_status status,
  225.                           struct acpi_walk_state *walk_state,
  226.                           union acpi_parse_object *op)
  227. {
  228.         return;
  229. }
  230.  
  231. #endif
  232.