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  *      internal 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_fn(     unsigned long,  ip              )
  65                 __field_fn(     unsigned long,  parent_ip       )
  66         ),
  67
  68         F_printk(" %ps <-- %ps",
  69                  (void *)__entry->ip, (void *)__entry->parent_ip),
  70
  71         perf_ftrace_event_register
  72 );
  73
  74 /* Function call entry */
  75 FTRACE_ENTRY_PACKED(funcgraph_entry, ftrace_graph_ent_entry,
  76
  77         TRACE_GRAPH_ENT,
  78
  79         F_STRUCT(
  80                 __field_struct( struct ftrace_graph_ent,        graph_ent       )
  81                 __field_packed( unsigned long,  graph_ent,      func            )
  82                 __field_packed( int,            graph_ent,      depth           )
  83         ),
  84
  85         F_printk("--> %ps (%d)", (void *)__entry->func, __entry->depth)
  86 );
  87
  88 /* Function return entry */
  89 FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry,
  90
  91         TRACE_GRAPH_RET,
  92
  93         F_STRUCT(
  94                 __field_struct( struct ftrace_graph_ret,        ret     )
  95                 __field_packed( unsigned long,  ret,            func    )
  96                 __field_packed( int,            ret,            depth   )
  97                 __field_packed( unsigned int,   ret,            overrun )
  98                 __field_packed( unsigned long long, ret,        calltime)
  99                 __field_packed( unsigned long long, ret,        rettime )
 100         ),
 101
 102         F_printk("<-- %ps (%d) (start: %llx  end: %llx) over: %d",
 103                  (void *)__entry->func, __entry->depth,
 104                  __entry->calltime, __entry->rettime,
 105                  __entry->depth)
 106 );
 107
 108 /*
 109  * Context switch trace entry - which task (and prio) we switched from/to:
 110  *
 111  * This is used for both wakeup and context switches. We only want
 112  * to create one structure, but we need two outputs for it.
 113  */
 114 #define FTRACE_CTX_FIELDS                                       \
 115         __field(        unsigned int,   prev_pid        )       \
 116         __field(        unsigned int,   next_pid        )       \
 117         __field(        unsigned int,   next_cpu        )       \
 118         __field(        unsigned char,  prev_prio       )       \
 119         __field(        unsigned char,  prev_state      )       \
 120         __field(        unsigned char,  next_prio       )       \
 121         __field(        unsigned char,  next_state      )
 122
 123 FTRACE_ENTRY(context_switch, ctx_switch_entry,
 124
 125         TRACE_CTX,
 126
 127         F_STRUCT(
 128                 FTRACE_CTX_FIELDS
 129         ),
 130
 131         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 132                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 133                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 134                  __entry->next_cpu)
 135 );
 136
 137 /*
 138  * FTRACE_ENTRY_DUP only creates the format file, it will not
 139  *  create another structure.
 140  */
 141 FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 142
 143         TRACE_WAKE,
 144
 145         F_STRUCT(
 146                 FTRACE_CTX_FIELDS
 147         ),
 148
 149         F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
 150                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 151                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 152                  __entry->next_cpu)
 153 );
 154
 155 /*
 156  * Stack-trace entry:
 157  */
 158
 159 #define FTRACE_STACK_ENTRIES    8
 160
 161 FTRACE_ENTRY(kernel_stack, stack_entry,
 162
 163         TRACE_STACK,
 164
 165         F_STRUCT(
 166                 __field(        int,            size    )
 167                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 168         ),
 169
 170         F_printk("\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 171                  "\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 172                  "\t=> %ps\n\t=> %ps\n",
 173                  (void *)__entry->caller[0], (void *)__entry->caller[1],
 174                  (void *)__entry->caller[2], (void *)__entry->caller[3],
 175                  (void *)__entry->caller[4], (void *)__entry->caller[5],
 176                  (void *)__entry->caller[6], (void *)__entry->caller[7])
 177 );
 178
 179 FTRACE_ENTRY(user_stack, userstack_entry,
 180
 181         TRACE_USER_STACK,
 182
 183         F_STRUCT(
 184                 __field(        unsigned int,   tgid    )
 185                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 186         ),
 187
 188         F_printk("\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 189                  "\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 190                  "\t=> %ps\n\t=> %ps\n",
 191                  (void *)__entry->caller[0], (void *)__entry->caller[1],
 192                  (void *)__entry->caller[2], (void *)__entry->caller[3],
 193                  (void *)__entry->caller[4], (void *)__entry->caller[5],
 194                  (void *)__entry->caller[6], (void *)__entry->caller[7])
 195 );
 196
 197 /*
 198  * trace_printk entry:
 199  */
 200 FTRACE_ENTRY(bprint, bprint_entry,
 201
 202         TRACE_BPRINT,
 203
 204         F_STRUCT(
 205                 __field(        unsigned long,  ip      )
 206                 __field(        const char *,   fmt     )
 207                 __dynamic_array(        u32,    buf     )
 208         ),
 209
 210         F_printk("%ps: %s",
 211                  (void *)__entry->ip, __entry->fmt)
 212 );
 213
 214 FTRACE_ENTRY_REG(print, print_entry,
 215
 216         TRACE_PRINT,
 217
 218         F_STRUCT(
 219                 __field(        unsigned long,  ip      )
 220                 __dynamic_array(        char,   buf     )
 221         ),
 222
 223         F_printk("%ps: %s",
 224                  (void *)__entry->ip, __entry->buf),
 225
 226         ftrace_event_register
 227 );
 228
 229 FTRACE_ENTRY(raw_data, raw_data_entry,
 230
 231         TRACE_RAW_DATA,
 232
 233         F_STRUCT(
 234                 __field(        unsigned int,   id      )
 235                 __dynamic_array(        char,   buf     )
 236         ),
 237
 238         F_printk("id:%04x %08x",
 239                  __entry->id, (int)__entry->buf[0])
 240 );
 241
 242 FTRACE_ENTRY(bputs, bputs_entry,
 243
 244         TRACE_BPUTS,
 245
 246         F_STRUCT(
 247                 __field(        unsigned long,  ip      )
 248                 __field(        const char *,   str     )
 249         ),
 250
 251         F_printk("%ps: %s",
 252                  (void *)__entry->ip, __entry->str)
 253 );
 254
 255 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 256
 257         TRACE_MMIO_RW,
 258
 259         F_STRUCT(
 260                 __field_struct( struct mmiotrace_rw,    rw      )
 261                 __field_desc(   resource_size_t, rw,    phys    )
 262                 __field_desc(   unsigned long,  rw,     value   )
 263                 __field_desc(   unsigned long,  rw,     pc      )
 264                 __field_desc(   int,            rw,     map_id  )
 265                 __field_desc(   unsigned char,  rw,     opcode  )
 266                 __field_desc(   unsigned char,  rw,     width   )
 267         ),
 268
 269         F_printk("%lx %lx %lx %d %x %x",
 270                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
 271                  __entry->map_id, __entry->opcode, __entry->width)
 272 );
 273
 274 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 275
 276         TRACE_MMIO_MAP,
 277
 278         F_STRUCT(
 279                 __field_struct( struct mmiotrace_map,   map     )
 280                 __field_desc(   resource_size_t, map,   phys    )
 281                 __field_desc(   unsigned long,  map,    virt    )
 282                 __field_desc(   unsigned long,  map,    len     )
 283                 __field_desc(   int,            map,    map_id  )
 284                 __field_desc(   unsigned char,  map,    opcode  )
 285         ),
 286
 287         F_printk("%lx %lx %lx %d %x",
 288                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
 289                  __entry->map_id, __entry->opcode)
 290 );
 291
 292
 293 #define TRACE_FUNC_SIZE 30
 294 #define TRACE_FILE_SIZE 20
 295
 296 FTRACE_ENTRY(branch, trace_branch,
 297
 298         TRACE_BRANCH,
 299
 300         F_STRUCT(
 301                 __field(        unsigned int,   line                            )
 302                 __array(        char,           func,   TRACE_FUNC_SIZE+1       )
 303                 __array(        char,           file,   TRACE_FILE_SIZE+1       )
 304                 __field(        char,           correct                         )
 305                 __field(        char,           constant                        )
 306         ),
 307
 308         F_printk("%u:%s:%s (%u)%s",
 309                  __entry->line,
 310                  __entry->func, __entry->file, __entry->correct,
 311                  __entry->constant ? " CONSTANT" : "")
 312 );
 313
 314
 315 FTRACE_ENTRY(hwlat, hwlat_entry,
 316
 317         TRACE_HWLAT,
 318
 319         F_STRUCT(
 320                 __field(        u64,                    duration        )
 321                 __field(        u64,                    outer_duration  )
 322                 __field(        u64,                    nmi_total_ts    )
 323                 __field_struct( struct timespec64,      timestamp       )
 324                 __field_desc(   s64,    timestamp,      tv_sec          )
 325                 __field_desc(   long,   timestamp,      tv_nsec         )
 326                 __field(        unsigned int,           nmi_count       )
 327                 __field(        unsigned int,           seqnum          )
 328                 __field(        unsigned int,           count           )
 329         ),
 330
 331         F_printk("cnt:%u\tts:%010llu.%010lu\tinner:%llu\touter:%llu\tcount:%d\tnmi-ts:%llu\tnmi-count:%u\n",
 332                  __entry->seqnum,
 333                  __entry->tv_sec,
 334                  __entry->tv_nsec,
 335                  __entry->duration,
 336                  __entry->outer_duration,
 337                  __entry->count,
 338                  __entry->nmi_total_ts,
 339                  __entry->nmi_count)
 340 );
 341
 342 #define FUNC_REPEATS_GET_DELTA_TS(entry)                                \
 343         (((u64)(entry)->top_delta_ts << 32) | (entry)->bottom_delta_ts) \
 344
 345 FTRACE_ENTRY(func_repeats, func_repeats_entry,
 346
 347         TRACE_FUNC_REPEATS,
 348
 349         F_STRUCT(
 350                 __field(        unsigned long,  ip              )
 351                 __field(        unsigned long,  parent_ip       )
 352                 __field(        u16     ,       count           )
 353                 __field(        u16     ,       top_delta_ts    )
 354                 __field(        u32     ,       bottom_delta_ts )
 355         ),
 356
 357         F_printk(" %ps <-%ps\t(repeats:%u  delta: -%llu)",
 358                  (void *)__entry->ip,
 359                  (void *)__entry->parent_ip,
 360                  __entry->count,
 361                  FUNC_REPEATS_GET_DELTA_TS(__entry))
 362 );
 363
 364 FTRACE_ENTRY(osnoise, osnoise_entry,
 365
 366         TRACE_OSNOISE,
 367
 368         F_STRUCT(
 369                 __field(        u64,                    noise           )
 370                 __field(        u64,                    runtime         )
 371                 __field(        u64,                    max_sample      )
 372                 __field(        unsigned int,           hw_count        )
 373                 __field(        unsigned int,           nmi_count       )
 374                 __field(        unsigned int,           irq_count       )
 375                 __field(        unsigned int,           softirq_count   )
 376                 __field(        unsigned int,           thread_count    )
 377         ),
 378
 379         F_printk("noise:%llu\tmax_sample:%llu\thw:%u\tnmi:%u\tirq:%u\tsoftirq:%u\tthread:%u\n",
 380                  __entry->noise,
 381                  __entry->max_sample,
 382                  __entry->hw_count,
 383                  __entry->nmi_count,
 384                  __entry->irq_count,
 385                  __entry->softirq_count,
 386                  __entry->thread_count)
 387 );
 388
 389 FTRACE_ENTRY(timerlat, timerlat_entry,
 390
 391         TRACE_TIMERLAT,
 392
 393         F_STRUCT(
 394                 __field(        unsigned int,           seqnum          )
 395                 __field(        int,                    context         )
 396                 __field(        u64,                    timer_latency   )
 397         ),
 398
 399         F_printk("seq:%u\tcontext:%d\ttimer_latency:%llu\n",
 400                  __entry->seqnum,
 401                  __entry->context,
 402                  __entry->timer_latency)
 403 );