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