Subversion Repositories Kolibri OS

Rev

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

  1. /******************************************************************************
  2.  *
  3.  * Module Name: utdebug - Debug print/trace routines
  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. #define EXPORT_ACPI_INTERFACES
  45.  
  46. #include <acpi/acpi.h>
  47. #include "accommon.h"
  48. #include "acinterp.h"
  49.  
  50. #define _COMPONENT          ACPI_UTILITIES
  51. ACPI_MODULE_NAME("utdebug")
  52.  
  53. #ifdef ACPI_DEBUG_OUTPUT
  54. static acpi_thread_id acpi_gbl_prev_thread_id = (acpi_thread_id) 0xFFFFFFFF;
  55. static char *acpi_gbl_fn_entry_str = "----Entry";
  56. static char *acpi_gbl_fn_exit_str = "----Exit-";
  57.  
  58. /* Local prototypes */
  59.  
  60. static const char *acpi_ut_trim_function_name(const char *function_name);
  61.  
  62. /*******************************************************************************
  63.  *
  64.  * FUNCTION:    acpi_ut_init_stack_ptr_trace
  65.  *
  66.  * PARAMETERS:  None
  67.  *
  68.  * RETURN:      None
  69.  *
  70.  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
  71.  *
  72.  ******************************************************************************/
  73.  
  74. void acpi_ut_init_stack_ptr_trace(void)
  75. {
  76.         acpi_size current_sp;
  77.  
  78.         acpi_gbl_entry_stack_pointer = &current_sp;
  79. }
  80.  
  81. /*******************************************************************************
  82.  *
  83.  * FUNCTION:    acpi_ut_track_stack_ptr
  84.  *
  85.  * PARAMETERS:  None
  86.  *
  87.  * RETURN:      None
  88.  *
  89.  * DESCRIPTION: Save the current CPU stack pointer
  90.  *
  91.  ******************************************************************************/
  92.  
  93. void acpi_ut_track_stack_ptr(void)
  94. {
  95.         acpi_size current_sp;
  96.  
  97.         if (&current_sp < acpi_gbl_lowest_stack_pointer) {
  98.                 acpi_gbl_lowest_stack_pointer = &current_sp;
  99.         }
  100.  
  101.         if (acpi_gbl_nesting_level > acpi_gbl_deepest_nesting) {
  102.                 acpi_gbl_deepest_nesting = acpi_gbl_nesting_level;
  103.         }
  104. }
  105.  
  106. /*******************************************************************************
  107.  *
  108.  * FUNCTION:    acpi_ut_trim_function_name
  109.  *
  110.  * PARAMETERS:  function_name       - Ascii string containing a procedure name
  111.  *
  112.  * RETURN:      Updated pointer to the function name
  113.  *
  114.  * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
  115.  *              This allows compiler macros such as __func__ to be used
  116.  *              with no change to the debug output.
  117.  *
  118.  ******************************************************************************/
  119.  
  120. static const char *acpi_ut_trim_function_name(const char *function_name)
  121. {
  122.  
  123.         /* All Function names are longer than 4 chars, check is safe */
  124.  
  125.         if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_MIXED) {
  126.  
  127.                 /* This is the case where the original source has not been modified */
  128.  
  129.                 return (function_name + 4);
  130.         }
  131.  
  132.         if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_PREFIX_LOWER) {
  133.  
  134.                 /* This is the case where the source has been 'linuxized' */
  135.  
  136.                 return (function_name + 5);
  137.         }
  138.  
  139.         return (function_name);
  140. }
  141.  
  142. /*******************************************************************************
  143.  *
  144.  * FUNCTION:    acpi_debug_print
  145.  *
  146.  * PARAMETERS:  requested_debug_level - Requested debug print level
  147.  *              line_number         - Caller's line number (for error output)
  148.  *              function_name       - Caller's procedure name
  149.  *              module_name         - Caller's module name
  150.  *              component_id        - Caller's component ID
  151.  *              format              - Printf format field
  152.  *              ...                 - Optional printf arguments
  153.  *
  154.  * RETURN:      None
  155.  *
  156.  * DESCRIPTION: Print error message with prefix consisting of the module name,
  157.  *              line number, and component ID.
  158.  *
  159.  ******************************************************************************/
  160.  
  161. void ACPI_INTERNAL_VAR_XFACE
  162. acpi_debug_print(u32 requested_debug_level,
  163.                  u32 line_number,
  164.                  const char *function_name,
  165.                  const char *module_name,
  166.                  u32 component_id, const char *format, ...)
  167. {
  168.         acpi_thread_id thread_id;
  169.         va_list args;
  170.  
  171.         /* Check if debug output enabled */
  172.  
  173.         if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) {
  174.                 return;
  175.         }
  176.  
  177.         /*
  178.          * Thread tracking and context switch notification
  179.          */
  180.         thread_id = acpi_os_get_thread_id();
  181.         if (thread_id != acpi_gbl_prev_thread_id) {
  182.                 if (ACPI_LV_THREADS & acpi_dbg_level) {
  183.                         acpi_os_printf
  184.                             ("\n**** Context Switch from TID %u to TID %u ****\n\n",
  185.                              (u32)acpi_gbl_prev_thread_id, (u32)thread_id);
  186.                 }
  187.  
  188.                 acpi_gbl_prev_thread_id = thread_id;
  189.                 acpi_gbl_nesting_level = 0;
  190.         }
  191.  
  192.         /*
  193.          * Display the module name, current line number, thread ID (if requested),
  194.          * current procedure nesting level, and the current procedure name
  195.          */
  196.         acpi_os_printf("%9s-%04ld ", module_name, line_number);
  197.  
  198. #ifdef ACPI_APPLICATION
  199.         /*
  200.          * For acpi_exec/iASL only, emit the thread ID and nesting level.
  201.          * Note: nesting level is really only useful during a single-thread
  202.          * execution. Otherwise, multiple threads will keep resetting the
  203.          * level.
  204.          */
  205.         if (ACPI_LV_THREADS & acpi_dbg_level) {
  206.                 acpi_os_printf("[%u] ", (u32)thread_id);
  207.         }
  208.  
  209.         acpi_os_printf("[%02ld] ", acpi_gbl_nesting_level);
  210. #endif
  211.  
  212.         acpi_os_printf("%-22.22s: ", acpi_ut_trim_function_name(function_name));
  213.  
  214.         va_start(args, format);
  215.         acpi_os_vprintf(format, args);
  216.         va_end(args);
  217. }
  218.  
  219. ACPI_EXPORT_SYMBOL(acpi_debug_print)
  220.  
  221. /*******************************************************************************
  222.  *
  223.  * FUNCTION:    acpi_debug_print_raw
  224.  *
  225.  * PARAMETERS:  requested_debug_level - Requested debug print level
  226.  *              line_number         - Caller's line number
  227.  *              function_name       - Caller's procedure name
  228.  *              module_name         - Caller's module name
  229.  *              component_id        - Caller's component ID
  230.  *              format              - Printf format field
  231.  *              ...                 - Optional printf arguments
  232.  *
  233.  * RETURN:      None
  234.  *
  235.  * DESCRIPTION: Print message with no headers. Has same interface as
  236.  *              debug_print so that the same macros can be used.
  237.  *
  238.  ******************************************************************************/
  239. void ACPI_INTERNAL_VAR_XFACE
  240. acpi_debug_print_raw(u32 requested_debug_level,
  241.                      u32 line_number,
  242.                      const char *function_name,
  243.                      const char *module_name,
  244.                      u32 component_id, const char *format, ...)
  245. {
  246.         va_list args;
  247.  
  248.         /* Check if debug output enabled */
  249.  
  250.         if (!ACPI_IS_DEBUG_ENABLED(requested_debug_level, component_id)) {
  251.                 return;
  252.         }
  253.  
  254.         va_start(args, format);
  255.         acpi_os_vprintf(format, args);
  256.         va_end(args);
  257. }
  258.  
  259. ACPI_EXPORT_SYMBOL(acpi_debug_print_raw)
  260.  
  261. /*******************************************************************************
  262.  *
  263.  * FUNCTION:    acpi_ut_trace
  264.  *
  265.  * PARAMETERS:  line_number         - Caller's line number
  266.  *              function_name       - Caller's procedure name
  267.  *              module_name         - Caller's module name
  268.  *              component_id        - Caller's component ID
  269.  *
  270.  * RETURN:      None
  271.  *
  272.  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
  273.  *              set in debug_level
  274.  *
  275.  ******************************************************************************/
  276. void
  277. acpi_ut_trace(u32 line_number,
  278.               const char *function_name,
  279.               const char *module_name, u32 component_id)
  280. {
  281.  
  282.         acpi_gbl_nesting_level++;
  283.         acpi_ut_track_stack_ptr();
  284.  
  285.         /* Check if enabled up-front for performance */
  286.  
  287.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  288.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  289.                                  line_number, function_name, module_name,
  290.                                  component_id, "%s\n", acpi_gbl_fn_entry_str);
  291.         }
  292. }
  293.  
  294. ACPI_EXPORT_SYMBOL(acpi_ut_trace)
  295.  
  296. /*******************************************************************************
  297.  *
  298.  * FUNCTION:    acpi_ut_trace_ptr
  299.  *
  300.  * PARAMETERS:  line_number         - Caller's line number
  301.  *              function_name       - Caller's procedure name
  302.  *              module_name         - Caller's module name
  303.  *              component_id        - Caller's component ID
  304.  *              pointer             - Pointer to display
  305.  *
  306.  * RETURN:      None
  307.  *
  308.  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
  309.  *              set in debug_level
  310.  *
  311.  ******************************************************************************/
  312. void
  313. acpi_ut_trace_ptr(u32 line_number,
  314.                   const char *function_name,
  315.                   const char *module_name, u32 component_id, void *pointer)
  316. {
  317.  
  318.         acpi_gbl_nesting_level++;
  319.         acpi_ut_track_stack_ptr();
  320.  
  321.         /* Check if enabled up-front for performance */
  322.  
  323.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  324.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  325.                                  line_number, function_name, module_name,
  326.                                  component_id, "%s %p\n", acpi_gbl_fn_entry_str,
  327.                                  pointer);
  328.         }
  329. }
  330.  
  331. /*******************************************************************************
  332.  *
  333.  * FUNCTION:    acpi_ut_trace_str
  334.  *
  335.  * PARAMETERS:  line_number         - Caller's line number
  336.  *              function_name       - Caller's procedure name
  337.  *              module_name         - Caller's module name
  338.  *              component_id        - Caller's component ID
  339.  *              string              - Additional string to display
  340.  *
  341.  * RETURN:      None
  342.  *
  343.  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
  344.  *              set in debug_level
  345.  *
  346.  ******************************************************************************/
  347.  
  348. void
  349. acpi_ut_trace_str(u32 line_number,
  350.                   const char *function_name,
  351.                   const char *module_name, u32 component_id, char *string)
  352. {
  353.  
  354.         acpi_gbl_nesting_level++;
  355.         acpi_ut_track_stack_ptr();
  356.  
  357.         /* Check if enabled up-front for performance */
  358.  
  359.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  360.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  361.                                  line_number, function_name, module_name,
  362.                                  component_id, "%s %s\n", acpi_gbl_fn_entry_str,
  363.                                  string);
  364.         }
  365. }
  366.  
  367. /*******************************************************************************
  368.  *
  369.  * FUNCTION:    acpi_ut_trace_u32
  370.  *
  371.  * PARAMETERS:  line_number         - Caller's line number
  372.  *              function_name       - Caller's procedure name
  373.  *              module_name         - Caller's module name
  374.  *              component_id        - Caller's component ID
  375.  *              integer             - Integer to display
  376.  *
  377.  * RETURN:      None
  378.  *
  379.  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
  380.  *              set in debug_level
  381.  *
  382.  ******************************************************************************/
  383.  
  384. void
  385. acpi_ut_trace_u32(u32 line_number,
  386.                   const char *function_name,
  387.                   const char *module_name, u32 component_id, u32 integer)
  388. {
  389.  
  390.         acpi_gbl_nesting_level++;
  391.         acpi_ut_track_stack_ptr();
  392.  
  393.         /* Check if enabled up-front for performance */
  394.  
  395.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  396.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  397.                                  line_number, function_name, module_name,
  398.                                  component_id, "%s %08X\n",
  399.                                  acpi_gbl_fn_entry_str, integer);
  400.         }
  401. }
  402.  
  403. /*******************************************************************************
  404.  *
  405.  * FUNCTION:    acpi_ut_exit
  406.  *
  407.  * PARAMETERS:  line_number         - Caller's line number
  408.  *              function_name       - Caller's procedure name
  409.  *              module_name         - Caller's module name
  410.  *              component_id        - Caller's component ID
  411.  *
  412.  * RETURN:      None
  413.  *
  414.  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
  415.  *              set in debug_level
  416.  *
  417.  ******************************************************************************/
  418.  
  419. void
  420. acpi_ut_exit(u32 line_number,
  421.              const char *function_name,
  422.              const char *module_name, u32 component_id)
  423. {
  424.  
  425.         /* Check if enabled up-front for performance */
  426.  
  427.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  428.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  429.                                  line_number, function_name, module_name,
  430.                                  component_id, "%s\n", acpi_gbl_fn_exit_str);
  431.         }
  432.  
  433.         if (acpi_gbl_nesting_level) {
  434.                 acpi_gbl_nesting_level--;
  435.         }
  436. }
  437.  
  438. ACPI_EXPORT_SYMBOL(acpi_ut_exit)
  439.  
  440. /*******************************************************************************
  441.  *
  442.  * FUNCTION:    acpi_ut_status_exit
  443.  *
  444.  * PARAMETERS:  line_number         - Caller's line number
  445.  *              function_name       - Caller's procedure name
  446.  *              module_name         - Caller's module name
  447.  *              component_id        - Caller's component ID
  448.  *              status              - Exit status code
  449.  *
  450.  * RETURN:      None
  451.  *
  452.  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
  453.  *              set in debug_level. Prints exit status also.
  454.  *
  455.  ******************************************************************************/
  456. void
  457. acpi_ut_status_exit(u32 line_number,
  458.                     const char *function_name,
  459.                     const char *module_name,
  460.                     u32 component_id, acpi_status status)
  461. {
  462.  
  463.         /* Check if enabled up-front for performance */
  464.  
  465.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  466.                 if (ACPI_SUCCESS(status)) {
  467.                         acpi_debug_print(ACPI_LV_FUNCTIONS,
  468.                                          line_number, function_name,
  469.                                          module_name, component_id, "%s %s\n",
  470.                                          acpi_gbl_fn_exit_str,
  471.                                          acpi_format_exception(status));
  472.                 } else {
  473.                         acpi_debug_print(ACPI_LV_FUNCTIONS,
  474.                                          line_number, function_name,
  475.                                          module_name, component_id,
  476.                                          "%s ****Exception****: %s\n",
  477.                                          acpi_gbl_fn_exit_str,
  478.                                          acpi_format_exception(status));
  479.                 }
  480.         }
  481.  
  482.         if (acpi_gbl_nesting_level) {
  483.                 acpi_gbl_nesting_level--;
  484.         }
  485. }
  486.  
  487. ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
  488.  
  489. /*******************************************************************************
  490.  *
  491.  * FUNCTION:    acpi_ut_value_exit
  492.  *
  493.  * PARAMETERS:  line_number         - Caller's line number
  494.  *              function_name       - Caller's procedure name
  495.  *              module_name         - Caller's module name
  496.  *              component_id        - Caller's component ID
  497.  *              value               - Value to be printed with exit msg
  498.  *
  499.  * RETURN:      None
  500.  *
  501.  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
  502.  *              set in debug_level. Prints exit value also.
  503.  *
  504.  ******************************************************************************/
  505. void
  506. acpi_ut_value_exit(u32 line_number,
  507.                    const char *function_name,
  508.                    const char *module_name, u32 component_id, u64 value)
  509. {
  510.  
  511.         /* Check if enabled up-front for performance */
  512.  
  513.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  514.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  515.                                  line_number, function_name, module_name,
  516.                                  component_id, "%s %8.8X%8.8X\n",
  517.                                  acpi_gbl_fn_exit_str,
  518.                                  ACPI_FORMAT_UINT64(value));
  519.         }
  520.  
  521.         if (acpi_gbl_nesting_level) {
  522.                 acpi_gbl_nesting_level--;
  523.         }
  524. }
  525.  
  526. ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
  527.  
  528. /*******************************************************************************
  529.  *
  530.  * FUNCTION:    acpi_ut_ptr_exit
  531.  *
  532.  * PARAMETERS:  line_number         - Caller's line number
  533.  *              function_name       - Caller's procedure name
  534.  *              module_name         - Caller's module name
  535.  *              component_id        - Caller's component ID
  536.  *              ptr                 - Pointer to display
  537.  *
  538.  * RETURN:      None
  539.  *
  540.  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
  541.  *              set in debug_level. Prints exit value also.
  542.  *
  543.  ******************************************************************************/
  544. void
  545. acpi_ut_ptr_exit(u32 line_number,
  546.                  const char *function_name,
  547.                  const char *module_name, u32 component_id, u8 *ptr)
  548. {
  549.  
  550.         /* Check if enabled up-front for performance */
  551.  
  552.         if (ACPI_IS_DEBUG_ENABLED(ACPI_LV_FUNCTIONS, component_id)) {
  553.                 acpi_debug_print(ACPI_LV_FUNCTIONS,
  554.                                  line_number, function_name, module_name,
  555.                                  component_id, "%s %p\n", acpi_gbl_fn_exit_str,
  556.                                  ptr);
  557.         }
  558.  
  559.         if (acpi_gbl_nesting_level) {
  560.                 acpi_gbl_nesting_level--;
  561.         }
  562. }
  563.  
  564. /*******************************************************************************
  565.  *
  566.  * FUNCTION:    acpi_trace_point
  567.  *
  568.  * PARAMETERS:  type                - Trace event type
  569.  *              begin               - TRUE if before execution
  570.  *              aml                 - Executed AML address
  571.  *              pathname            - Object path
  572.  *              pointer             - Pointer to the related object
  573.  *
  574.  * RETURN:      None
  575.  *
  576.  * DESCRIPTION: Interpreter execution trace.
  577.  *
  578.  ******************************************************************************/
  579.  
  580. void
  581. acpi_trace_point(acpi_trace_event_type type, u8 begin, u8 *aml, char *pathname)
  582. {
  583.  
  584.         ACPI_FUNCTION_ENTRY();
  585.  
  586.         acpi_ex_trace_point(type, begin, aml, pathname);
  587.  
  588. #ifdef ACPI_USE_SYSTEM_TRACER
  589.         acpi_os_trace_point(type, begin, aml, pathname);
  590. #endif
  591. }
  592.  
  593. ACPI_EXPORT_SYMBOL(acpi_trace_point)
  594. #endif
  595. #ifdef ACPI_APPLICATION
  596. /*******************************************************************************
  597.  *
  598.  * FUNCTION:    acpi_log_error
  599.  *
  600.  * PARAMETERS:  format              - Printf format field
  601.  *              ...                 - Optional printf arguments
  602.  *
  603.  * RETURN:      None
  604.  *
  605.  * DESCRIPTION: Print error message to the console, used by applications.
  606.  *
  607.  ******************************************************************************/
  608. void ACPI_INTERNAL_VAR_XFACE acpi_log_error(const char *format, ...)
  609. {
  610.         va_list args;
  611.  
  612.         va_start(args, format);
  613.         (void)acpi_ut_file_vprintf(ACPI_FILE_ERR, format, args);
  614.         va_end(args);
  615. }
  616.  
  617. ACPI_EXPORT_SYMBOL(acpi_log_error)
  618. #endif
  619.