LCOV - code coverage report
Current view: top level - drivers/acpi/acpica - extrace.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 38 64 59.4 %
Date: 2022-03-28 16:04:14 Functions: 5 6 83.3 %
Branches: 7 34 20.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
       2                 :            : /******************************************************************************
       3                 :            :  *
       4                 :            :  * Module Name: extrace - Support for interpreter execution tracing
       5                 :            :  *
       6                 :            :  * Copyright (C) 2000 - 2020, Intel Corp.
       7                 :            :  *
       8                 :            :  *****************************************************************************/
       9                 :            : 
      10                 :            : #include <acpi/acpi.h>
      11                 :            : #include "accommon.h"
      12                 :            : #include "acnamesp.h"
      13                 :            : #include "acinterp.h"
      14                 :            : 
      15                 :            : #define _COMPONENT          ACPI_EXECUTER
      16                 :            : ACPI_MODULE_NAME("extrace")
      17                 :            : 
      18                 :            : static union acpi_operand_object *acpi_gbl_trace_method_object = NULL;
      19                 :            : 
      20                 :            : /* Local prototypes */
      21                 :            : 
      22                 :            : #ifdef ACPI_DEBUG_OUTPUT
      23                 :            : static const char *acpi_ex_get_trace_event_name(acpi_trace_event_type type);
      24                 :            : #endif
      25                 :            : 
      26                 :            : /*******************************************************************************
      27                 :            :  *
      28                 :            :  * FUNCTION:    acpi_ex_interpreter_trace_enabled
      29                 :            :  *
      30                 :            :  * PARAMETERS:  name                - Whether method name should be matched,
      31                 :            :  *                                    this should be checked before starting
      32                 :            :  *                                    the tracer
      33                 :            :  *
      34                 :            :  * RETURN:      TRUE if interpreter trace is enabled.
      35                 :            :  *
      36                 :            :  * DESCRIPTION: Check whether interpreter trace is enabled
      37                 :            :  *
      38                 :            :  ******************************************************************************/
      39                 :            : 
      40                 :       1313 : static u8 acpi_ex_interpreter_trace_enabled(char *name)
      41                 :            : {
      42                 :            : 
      43                 :            :         /* Check if tracing is enabled */
      44                 :            : 
      45         [ -  + ]:       1313 :         if (!(acpi_gbl_trace_flags & ACPI_TRACE_ENABLED)) {
      46                 :            :                 return (FALSE);
      47                 :            :         }
      48                 :            : 
      49                 :            :         /*
      50                 :            :          * Check if tracing is filtered:
      51                 :            :          *
      52                 :            :          * 1. If the tracer is started, acpi_gbl_trace_method_object should have
      53                 :            :          *    been filled by the trace starter
      54                 :            :          * 2. If the tracer is not started, acpi_gbl_trace_method_name should be
      55                 :            :          *    matched if it is specified
      56                 :            :          * 3. If the tracer is oneshot style, acpi_gbl_trace_method_name should
      57                 :            :          *    not be cleared by the trace stopper during the first match
      58                 :            :          */
      59         [ #  # ]:          0 :         if (acpi_gbl_trace_method_object) {
      60                 :            :                 return (TRUE);
      61                 :            :         }
      62                 :            : 
      63         [ #  # ]:          0 :         if (name &&
      64         [ #  # ]:          0 :             (acpi_gbl_trace_method_name &&
      65         [ #  # ]:          0 :              strcmp(acpi_gbl_trace_method_name, name))) {
      66                 :            :                 return (FALSE);
      67                 :            :         }
      68                 :            : 
      69         [ #  # ]:          0 :         if ((acpi_gbl_trace_flags & ACPI_TRACE_ONESHOT) &&
      70         [ #  # ]:          0 :             !acpi_gbl_trace_method_name) {
      71                 :          0 :                 return (FALSE);
      72                 :            :         }
      73                 :            : 
      74                 :            :         return (TRUE);
      75                 :            : }
      76                 :            : 
      77                 :            : /*******************************************************************************
      78                 :            :  *
      79                 :            :  * FUNCTION:    acpi_ex_get_trace_event_name
      80                 :            :  *
      81                 :            :  * PARAMETERS:  type            - Trace event type
      82                 :            :  *
      83                 :            :  * RETURN:      Trace event name.
      84                 :            :  *
      85                 :            :  * DESCRIPTION: Used to obtain the full trace event name.
      86                 :            :  *
      87                 :            :  ******************************************************************************/
      88                 :            : 
      89                 :            : #ifdef ACPI_DEBUG_OUTPUT
      90                 :            : 
      91                 :            : static const char *acpi_ex_get_trace_event_name(acpi_trace_event_type type)
      92                 :            : {
      93                 :            : 
      94                 :            :         switch (type) {
      95                 :            :         case ACPI_TRACE_AML_METHOD:
      96                 :            : 
      97                 :            :                 return "Method";
      98                 :            : 
      99                 :            :         case ACPI_TRACE_AML_OPCODE:
     100                 :            : 
     101                 :            :                 return "Opcode";
     102                 :            : 
     103                 :            :         case ACPI_TRACE_AML_REGION:
     104                 :            : 
     105                 :            :                 return "Region";
     106                 :            : 
     107                 :            :         default:
     108                 :            : 
     109                 :            :                 return "";
     110                 :            :         }
     111                 :            : }
     112                 :            : 
     113                 :            : #endif
     114                 :            : 
     115                 :            : /*******************************************************************************
     116                 :            :  *
     117                 :            :  * FUNCTION:    acpi_ex_trace_point
     118                 :            :  *
     119                 :            :  * PARAMETERS:  type                - Trace event type
     120                 :            :  *              begin               - TRUE if before execution
     121                 :            :  *              aml                 - Executed AML address
     122                 :            :  *              pathname            - Object path
     123                 :            :  *
     124                 :            :  * RETURN:      None
     125                 :            :  *
     126                 :            :  * DESCRIPTION: Internal interpreter execution trace.
     127                 :            :  *
     128                 :            :  ******************************************************************************/
     129                 :            : 
     130                 :            : void
     131                 :          0 : acpi_ex_trace_point(acpi_trace_event_type type,
     132                 :            :                     u8 begin, u8 *aml, char *pathname)
     133                 :            : {
     134                 :            : 
     135                 :          0 :         ACPI_FUNCTION_NAME(ex_trace_point);
     136                 :            : 
     137                 :          0 :         if (pathname) {
     138                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
     139                 :            :                                   "%s %s [0x%p:%s] execution.\n",
     140                 :            :                                   acpi_ex_get_trace_event_name(type),
     141                 :            :                                   begin ? "Begin" : "End", aml, pathname));
     142                 :            :         } else {
     143                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_TRACE_POINT,
     144                 :            :                                   "%s %s [0x%p] execution.\n",
     145                 :            :                                   acpi_ex_get_trace_event_name(type),
     146                 :          0 :                                   begin ? "Begin" : "End", aml));
     147                 :            :         }
     148                 :          0 : }
     149                 :            : 
     150                 :            : /*******************************************************************************
     151                 :            :  *
     152                 :            :  * FUNCTION:    acpi_ex_start_trace_method
     153                 :            :  *
     154                 :            :  * PARAMETERS:  method_node         - Node of the method
     155                 :            :  *              obj_desc            - The method object
     156                 :            :  *              walk_state          - current state, NULL if not yet executing
     157                 :            :  *                                    a method.
     158                 :            :  *
     159                 :            :  * RETURN:      None
     160                 :            :  *
     161                 :            :  * DESCRIPTION: Start control method execution trace
     162                 :            :  *
     163                 :            :  ******************************************************************************/
     164                 :            : 
     165                 :            : void
     166                 :       1313 : acpi_ex_start_trace_method(struct acpi_namespace_node *method_node,
     167                 :            :                            union acpi_operand_object *obj_desc,
     168                 :            :                            struct acpi_walk_state *walk_state)
     169                 :            : {
     170                 :       1313 :         char *pathname = NULL;
     171                 :       1313 :         u8 enabled = FALSE;
     172                 :            : 
     173                 :       1313 :         ACPI_FUNCTION_NAME(ex_start_trace_method);
     174                 :            : 
     175         [ +  - ]:       1313 :         if (method_node) {
     176                 :       1313 :                 pathname = acpi_ns_get_normalized_pathname(method_node, TRUE);
     177                 :            :         }
     178                 :            : 
     179                 :       1313 :         enabled = acpi_ex_interpreter_trace_enabled(pathname);
     180   [ -  +  -  - ]:       1313 :         if (enabled && !acpi_gbl_trace_method_object) {
     181                 :          0 :                 acpi_gbl_trace_method_object = obj_desc;
     182                 :          0 :                 acpi_gbl_original_dbg_level = acpi_dbg_level;
     183                 :          0 :                 acpi_gbl_original_dbg_layer = acpi_dbg_layer;
     184                 :          0 :                 acpi_dbg_level = ACPI_TRACE_LEVEL_ALL;
     185                 :          0 :                 acpi_dbg_layer = ACPI_TRACE_LAYER_ALL;
     186                 :            : 
     187         [ #  # ]:          0 :                 if (acpi_gbl_trace_dbg_level) {
     188                 :          0 :                         acpi_dbg_level = acpi_gbl_trace_dbg_level;
     189                 :            :                 }
     190                 :            : 
     191         [ #  # ]:          0 :                 if (acpi_gbl_trace_dbg_layer) {
     192                 :          0 :                         acpi_dbg_layer = acpi_gbl_trace_dbg_layer;
     193                 :            :                 }
     194                 :            :         }
     195                 :            : 
     196                 :       1313 :         if (enabled) {
     197                 :            :                 ACPI_TRACE_POINT(ACPI_TRACE_AML_METHOD, TRUE,
     198                 :            :                                  obj_desc ? obj_desc->method.aml_start : NULL,
     199                 :       1313 :                                  pathname);
     200                 :            :         }
     201                 :            : 
     202         [ +  - ]:       1313 :         if (pathname) {
     203                 :       1313 :                 ACPI_FREE(pathname);
     204                 :            :         }
     205                 :       1313 : }
     206                 :            : 
     207                 :            : /*******************************************************************************
     208                 :            :  *
     209                 :            :  * FUNCTION:    acpi_ex_stop_trace_method
     210                 :            :  *
     211                 :            :  * PARAMETERS:  method_node         - Node of the method
     212                 :            :  *              obj_desc            - The method object
     213                 :            :  *              walk_state          - current state, NULL if not yet executing
     214                 :            :  *                                    a method.
     215                 :            :  *
     216                 :            :  * RETURN:      None
     217                 :            :  *
     218                 :            :  * DESCRIPTION: Stop control method execution trace
     219                 :            :  *
     220                 :            :  ******************************************************************************/
     221                 :            : 
     222                 :            : void
     223                 :       1313 : acpi_ex_stop_trace_method(struct acpi_namespace_node *method_node,
     224                 :            :                           union acpi_operand_object *obj_desc,
     225                 :            :                           struct acpi_walk_state *walk_state)
     226                 :            : {
     227                 :       1313 :         char *pathname = NULL;
     228                 :       1313 :         u8 enabled;
     229                 :            : 
     230                 :       1313 :         ACPI_FUNCTION_NAME(ex_stop_trace_method);
     231                 :            : 
     232         [ +  - ]:       1313 :         if (method_node) {
     233                 :       1313 :                 pathname = acpi_ns_get_normalized_pathname(method_node, TRUE);
     234                 :            :         }
     235                 :            : 
     236                 :       1313 :         enabled = acpi_ex_interpreter_trace_enabled(NULL);
     237                 :            : 
     238                 :       1313 :         if (enabled) {
     239                 :            :                 ACPI_TRACE_POINT(ACPI_TRACE_AML_METHOD, FALSE,
     240                 :            :                                  obj_desc ? obj_desc->method.aml_start : NULL,
     241                 :       1313 :                                  pathname);
     242                 :            :         }
     243                 :            : 
     244                 :            :         /* Check whether the tracer should be stopped */
     245                 :            : 
     246         [ -  + ]:       1313 :         if (acpi_gbl_trace_method_object == obj_desc) {
     247                 :            : 
     248                 :            :                 /* Disable further tracing if type is one-shot */
     249                 :            : 
     250         [ #  # ]:          0 :                 if (acpi_gbl_trace_flags & ACPI_TRACE_ONESHOT) {
     251                 :          0 :                         acpi_gbl_trace_method_name = NULL;
     252                 :            :                 }
     253                 :            : 
     254                 :          0 :                 acpi_dbg_level = acpi_gbl_original_dbg_level;
     255                 :          0 :                 acpi_dbg_layer = acpi_gbl_original_dbg_layer;
     256                 :          0 :                 acpi_gbl_trace_method_object = NULL;
     257                 :            :         }
     258                 :            : 
     259         [ +  - ]:       1313 :         if (pathname) {
     260                 :       1313 :                 ACPI_FREE(pathname);
     261                 :            :         }
     262                 :       1313 : }
     263                 :            : 
     264                 :            : /*******************************************************************************
     265                 :            :  *
     266                 :            :  * FUNCTION:    acpi_ex_start_trace_opcode
     267                 :            :  *
     268                 :            :  * PARAMETERS:  op                  - The parser opcode object
     269                 :            :  *              walk_state          - current state, NULL if not yet executing
     270                 :            :  *                                    a method.
     271                 :            :  *
     272                 :            :  * RETURN:      None
     273                 :            :  *
     274                 :            :  * DESCRIPTION: Start opcode execution trace
     275                 :            :  *
     276                 :            :  ******************************************************************************/
     277                 :            : 
     278                 :            : void
     279                 :     232323 : acpi_ex_start_trace_opcode(union acpi_parse_object *op,
     280                 :            :                            struct acpi_walk_state *walk_state)
     281                 :            : {
     282                 :            : 
     283                 :     232323 :         ACPI_FUNCTION_NAME(ex_start_trace_opcode);
     284                 :            : 
     285                 :     232323 :         if (acpi_ex_interpreter_trace_enabled(NULL) &&
     286                 :            :             (acpi_gbl_trace_flags & ACPI_TRACE_OPCODE)) {
     287                 :            :                 ACPI_TRACE_POINT(ACPI_TRACE_AML_OPCODE, TRUE,
     288                 :     232323 :                                  op->common.aml, op->common.aml_op_name);
     289                 :            :         }
     290                 :     232323 : }
     291                 :            : 
     292                 :            : /*******************************************************************************
     293                 :            :  *
     294                 :            :  * FUNCTION:    acpi_ex_stop_trace_opcode
     295                 :            :  *
     296                 :            :  * PARAMETERS:  op                  - The parser opcode object
     297                 :            :  *              walk_state          - current state, NULL if not yet executing
     298                 :            :  *                                    a method.
     299                 :            :  *
     300                 :            :  * RETURN:      None
     301                 :            :  *
     302                 :            :  * DESCRIPTION: Stop opcode execution trace
     303                 :            :  *
     304                 :            :  ******************************************************************************/
     305                 :            : 
     306                 :            : void
     307                 :     232349 : acpi_ex_stop_trace_opcode(union acpi_parse_object *op,
     308                 :            :                           struct acpi_walk_state *walk_state)
     309                 :            : {
     310                 :            : 
     311                 :     232349 :         ACPI_FUNCTION_NAME(ex_stop_trace_opcode);
     312                 :            : 
     313                 :     232349 :         if (acpi_ex_interpreter_trace_enabled(NULL) &&
     314                 :            :             (acpi_gbl_trace_flags & ACPI_TRACE_OPCODE)) {
     315                 :            :                 ACPI_TRACE_POINT(ACPI_TRACE_AML_OPCODE, FALSE,
     316                 :     232349 :                                  op->common.aml, op->common.aml_op_name);
     317                 :            :         }
     318                 :     232349 : }

Generated by: LCOV version 1.14