kernel/trace/trace_entries.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * This file defines the trace event structures that go into the ring
   4  * buffer directly. They are created via macros so that changes for them
   5  * appear in the format file. Using macros will automate this process.
   6  *
   7  * The macro used to create a ftrace data structure is:
   8  *
   9  * FTRACE_ENTRY( name, struct_name, id, structure, print )
  10  *
  11  * @name: the name used the event name, as well as the name of
  12  *   the directory that holds the format file.
  13  *
  14  * @struct_name: the name of the structure that is created.
  15  *
  16  * @id: The event identifier that is used to detect what event
  17  *    this is from the ring buffer.
  18  *
  19  * @structure: the structure layout
  20  *
  21  *  - __field(  type,   item    )
  22  *        This is equivalent to declaring
  23  *              type    item;
  24  *        in the structure.
  25  *  - __array(  type,   item,   size    )
  26  *        This is equivalent to declaring
  27  *              type    item[size];
  28  *        in the structure.
  29  *
  30  *   * for structures within structures, the format of the internal
  31  *      structure is laid out. This allows the internal structure
  32  *      to be deciphered for the format file. Although these macros
  33  *      may become out of sync with the internal structure, they
  34  *      will create a compile error if it happens. Since the
  35  *      internel structures are just tracing helpers, this is not
  36  *      an issue.
  37  *
  38  *      When an internal structure is used, it should use:
  39  *
  40  *      __field_struct( type,   item    )
  41  *
  42  *      instead of __field. This will prevent it from being shown in
  43  *      the output file. The fields in the structure should use.
  44  *
  45  *      __field_desc(   type,   container,      item            )
  46  *      __array_desc(   type,   container,      item,   len     )
  47  *
  48  *      type, item and len are the same as __field and __array, but
  49  *      container is added. This is the name of the item in
  50  *      __field_struct that this is describing.
  51  *
  52  *
  53  * @print: the print format shown to users in the format file.
  54  */
  55
  56 /*
  57  * Function trace entry - function address and parent function address:
  58  */
  59 FTRACE_ENTRY_REG(function, ftrace_entry,
  60
  61         TRACE_FN,
  62
  63         F_STRUCT(
  64                 __field(        unsigned long,  ip              )
  65                 __field(        unsigned long,  parent_ip       )
  66         ),
  67
  68         F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip),
  69
  70         FILTER_TRACE_FN,
  71
  72         perf_ftrace_event_register
  73 );
  74
  75 /* Function call entry */
  76 FTRACE_ENTRY_PACKED(funcgraph_entry, ftrace_graph_ent_entry,
  77
  78         TRACE_GRAPH_ENT,
  79
  80         F_STRUCT(
  81                 __field_struct( struct ftrace_graph_ent,        graph_ent       )
  82                 __field_desc(   unsigned long,  graph_ent,      func            )
  83                 __field_desc(   int,            graph_ent,      depth           )
  84         ),
  85
  86         F_printk("--> %lx (%d)", __entry->func, __entry->depth),
  87
  88         FILTER_OTHER
  89 );
  90
  91 /* Function return entry */
  92 FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry,
  93
  94         TRACE_GRAPH_RET,
  95
  96         F_STRUCT(
  97                 __field_struct( struct ftrace_graph_ret,        ret     )
  98                 __field_desc(   unsigned long,  ret,            func    )
  99                 __field_desc(   unsigned long long, ret,        calltime)
 100                 __field_desc(   unsigned long long, ret,        rettime )
 101                 __field_desc(   unsigned long,  ret,            overrun )
 102                 __field_desc(   int,            ret,            depth   )
 103         ),
 104
 105         F_printk("<-- %lx (%d) (start: %llx  end: %llx) over: %d",
 106                  __entry->func, __entry->depth,
 107                  __entry->calltime, __entry->rettime,
 108                  __entry->depth),
 109
 110         FILTER_OTHER
 111 );
 112
 113 /*
 114  * Context switch trace entry - which task (and prio) we switched from/to:
 115  *
 116  * This is used for both wakeup and context switches. We only want
 117  * to create one structure, but we need two outputs for it.
 118  */
 119 #define FTRACE_CTX_FIELDS                                       \
 120         __field(        unsigned int,   prev_pid        )       \
 121         __field(        unsigned int,   next_pid        )       \
 122         __field(        unsigned int,   next_cpu        )       \
 123         __field(        unsigned char,  prev_prio       )       \
 124         __field(        unsigned char,  prev_state      )       \
 125         __field(        unsigned char,  next_prio       )       \
 126         __field(        unsigned char,  next_state      )
 127
 128 FTRACE_ENTRY(context_switch, ctx_switch_entry,
 129
 130         TRACE_CTX,
 131
 132         F_STRUCT(
 133                 FTRACE_CTX_FIELDS
 134         ),
 135
 136         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 137                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 138                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 139                  __entry->next_cpu),
 140
 141         FILTER_OTHER
 142 );
 143
 144 /*
 145  * FTRACE_ENTRY_DUP only creates the format file, it will not
 146  *  create another structure.
 147  */
 148 FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 149
 150         TRACE_WAKE,
 151
 152         F_STRUCT(
 153                 FTRACE_CTX_FIELDS
 154         ),
 155
 156         F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
 157                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 158                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 159                  __entry->next_cpu),
 160
 161         FILTER_OTHER
 162 );
 163
 164 /*
 165  * Stack-trace entry:
 166  */
 167
 168 #define FTRACE_STACK_ENTRIES    8
 169
 170 #ifndef CONFIG_64BIT
 171 # define IP_FMT "%08lx"
 172 #else
 173 # define IP_FMT "%016lx"
 174 #endif
 175
 176 FTRACE_ENTRY(kernel_stack, stack_entry,
 177
 178         TRACE_STACK,
 179
 180         F_STRUCT(
 181                 __field(        int,            size    )
 182                 __dynamic_array(unsigned long,  caller  )
 183         ),
 184
 185         F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 186                  "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 187                  "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
 188                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
 189                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
 190                  __entry->caller[6], __entry->caller[7]),
 191
 192         FILTER_OTHER
 193 );
 194
 195 FTRACE_ENTRY(user_stack, userstack_entry,
 196
 197         TRACE_USER_STACK,
 198
 199         F_STRUCT(
 200                 __field(        unsigned int,   tgid    )
 201                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 202         ),
 203
 204         F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 205                  "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 206                  "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
 207                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
 208                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
 209                  __entry->caller[6], __entry->caller[7]),
 210
 211         FILTER_OTHER
 212 );
 213
 214 /*
 215  * trace_printk entry:
 216  */
 217 FTRACE_ENTRY(bprint, bprint_entry,
 218
 219         TRACE_BPRINT,
 220
 221         F_STRUCT(
 222                 __field(        unsigned long,  ip      )
 223                 __field(        const char *,   fmt     )
 224                 __dynamic_array(        u32,    buf     )
 225         ),
 226
 227         F_printk("%ps: %s",
 228                  (void *)__entry->ip, __entry->fmt),
 229
 230         FILTER_OTHER
 231 );
 232
 233 FTRACE_ENTRY(print, print_entry,
 234
 235         TRACE_PRINT,
 236
 237         F_STRUCT(
 238                 __field(        unsigned long,  ip      )
 239                 __dynamic_array(        char,   buf     )
 240         ),
 241
 242         F_printk("%ps: %s",
 243                  (void *)__entry->ip, __entry->buf),
 244
 245         FILTER_OTHER
 246 );
 247
 248 FTRACE_ENTRY(raw_data, raw_data_entry,
 249
 250         TRACE_RAW_DATA,
 251
 252         F_STRUCT(
 253                 __field(        unsigned int,   id      )
 254                 __dynamic_array(        char,   buf     )
 255         ),
 256
 257         F_printk("id:%04x %08x",
 258                  __entry->id, (int)__entry->buf[0]),
 259
 260         FILTER_OTHER
 261 );
 262
 263 FTRACE_ENTRY(bputs, bputs_entry,
 264
 265         TRACE_BPUTS,
 266
 267         F_STRUCT(
 268                 __field(        unsigned long,  ip      )
 269                 __field(        const char *,   str     )
 270         ),
 271
 272         F_printk("%ps: %s",
 273                  (void *)__entry->ip, __entry->str),
 274
 275         FILTER_OTHER
 276 );
 277
 278 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 279
 280         TRACE_MMIO_RW,
 281
 282         F_STRUCT(
 283                 __field_struct( struct mmiotrace_rw,    rw      )
 284                 __field_desc(   resource_size_t, rw,    phys    )
 285                 __field_desc(   unsigned long,  rw,     value   )
 286                 __field_desc(   unsigned long,  rw,     pc      )
 287                 __field_desc(   int,            rw,     map_id  )
 288                 __field_desc(   unsigned char,  rw,     opcode  )
 289                 __field_desc(   unsigned char,  rw,     width   )
 290         ),
 291
 292         F_printk("%lx %lx %lx %d %x %x",
 293                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
 294                  __entry->map_id, __entry->opcode, __entry->width),
 295
 296         FILTER_OTHER
 297 );
 298
 299 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 300
 301         TRACE_MMIO_MAP,
 302
 303         F_STRUCT(
 304                 __field_struct( struct mmiotrace_map,   map     )
 305                 __field_desc(   resource_size_t, map,   phys    )
 306                 __field_desc(   unsigned long,  map,    virt    )
 307                 __field_desc(   unsigned long,  map,    len     )
 308                 __field_desc(   int,            map,    map_id  )
 309                 __field_desc(   unsigned char,  map,    opcode  )
 310         ),
 311
 312         F_printk("%lx %lx %lx %d %x",
 313                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
 314                  __entry->map_id, __entry->opcode),
 315
 316         FILTER_OTHER
 317 );
 318
 319
 320 #define TRACE_FUNC_SIZE 30
 321 #define TRACE_FILE_SIZE 20
 322
 323 FTRACE_ENTRY(branch, trace_branch,
 324
 325         TRACE_BRANCH,
 326
 327         F_STRUCT(
 328                 __field(        unsigned int,   line                            )
 329                 __array(        char,           func,   TRACE_FUNC_SIZE+1       )
 330                 __array(        char,           file,   TRACE_FILE_SIZE+1       )
 331                 __field(        char,           correct                         )
 332                 __field(        char,           constant                        )
 333         ),
 334
 335         F_printk("%u:%s:%s (%u)%s",
 336                  __entry->line,
 337                  __entry->func, __entry->file, __entry->correct,
 338                  __entry->constant ? " CONSTANT" : ""),
 339
 340         FILTER_OTHER
 341 );
 342
 343
 344 FTRACE_ENTRY(hwlat, hwlat_entry,
 345
 346         TRACE_HWLAT,
 347
 348         F_STRUCT(
 349                 __field(        u64,                    duration        )
 350                 __field(        u64,                    outer_duration  )
 351                 __field(        u64,                    nmi_total_ts    )
 352                 __field_struct( struct timespec64,      timestamp       )
 353                 __field_desc(   s64,    timestamp,      tv_sec          )
 354                 __field_desc(   long,   timestamp,      tv_nsec         )
 355                 __field(        unsigned int,           nmi_count       )
 356                 __field(        unsigned int,           seqnum          )
 357         ),
 358
 359         F_printk("cnt:%u\tts:%010llu.%010lu\tinner:%llu\touter:%llunmi-ts:%llu\tnmi-count:%u\n",
 360                  __entry->seqnum,
 361                  __entry->tv_sec,
 362                  __entry->tv_nsec,
 363                  __entry->duration,
 364                  __entry->outer_duration,
 365                  __entry->nmi_total_ts,
 366                  __entry->nmi_count),
 367
 368         FILTER_OTHER
 369 );