kernel/trace/trace

/* [<][>][^][v][top][bottom][index][help] */
   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(" %ps <-- %ps",
  69                  (void *)__entry->ip, (void *)__entry->parent_ip),
  70 
  71         FILTER_TRACE_FN,
  72 
  73         perf_ftrace_event_register
  74 );
  75 
  76 /* Function call entry */
  77 FTRACE_ENTRY_PACKED(funcgraph_entry, ftrace_graph_ent_entry,
  78 
  79         TRACE_GRAPH_ENT,
  80 
  81         F_STRUCT(
  82                 __field_struct( struct ftrace_graph_ent,        graph_ent       )
  83                 __field_desc(   unsigned long,  graph_ent,      func            )
  84                 __field_desc(   int,            graph_ent,      depth           )
  85         ),
  86 
  87         F_printk("--> %ps (%d)", (void *)__entry->func, __entry->depth),
  88 
  89         FILTER_OTHER
  90 );
  91 
  92 /* Function return entry */
  93 FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry,
  94 
  95         TRACE_GRAPH_RET,
  96 
  97         F_STRUCT(
  98                 __field_struct( struct ftrace_graph_ret,        ret     )
  99                 __field_desc(   unsigned long,  ret,            func    )
 100                 __field_desc(   unsigned long long, ret,        calltime)
 101                 __field_desc(   unsigned long long, ret,        rettime )
 102                 __field_desc(   unsigned long,  ret,            overrun )
 103                 __field_desc(   int,            ret,            depth   )
 104         ),
 105 
 106         F_printk("<-- %ps (%d) (start: %llx  end: %llx) over: %d",
 107                  (void *)__entry->func, __entry->depth,
 108                  __entry->calltime, __entry->rettime,
 109                  __entry->depth),
 110 
 111         FILTER_OTHER
 112 );
 113 
 114 /*
 115  * Context switch trace entry - which task (and prio) we switched from/to:
 116  *
 117  * This is used for both wakeup and context switches. We only want
 118  * to create one structure, but we need two outputs for it.
 119  */
 120 #define FTRACE_CTX_FIELDS                                       \
 121         __field(        unsigned int,   prev_pid        )       \
 122         __field(        unsigned int,   next_pid        )       \
 123         __field(        unsigned int,   next_cpu        )       \
 124         __field(        unsigned char,  prev_prio       )       \
 125         __field(        unsigned char,  prev_state      )       \
 126         __field(        unsigned char,  next_prio       )       \
 127         __field(        unsigned char,  next_state      )
 128 
 129 FTRACE_ENTRY(context_switch, ctx_switch_entry,
 130 
 131         TRACE_CTX,
 132 
 133         F_STRUCT(
 134                 FTRACE_CTX_FIELDS
 135         ),
 136 
 137         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 138                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 139                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 140                  __entry->next_cpu),
 141 
 142         FILTER_OTHER
 143 );
 144 
 145 /*
 146  * FTRACE_ENTRY_DUP only creates the format file, it will not
 147  *  create another structure.
 148  */
 149 FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 150 
 151         TRACE_WAKE,
 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         FILTER_OTHER
 163 );
 164 
 165 /*
 166  * Stack-trace entry:
 167  */
 168 
 169 #define FTRACE_STACK_ENTRIES    8
 170 
 171 FTRACE_ENTRY(kernel_stack, stack_entry,
 172 
 173         TRACE_STACK,
 174 
 175         F_STRUCT(
 176                 __field(        int,            size    )
 177                 __dynamic_array(unsigned long,  caller  )
 178         ),
 179 
 180         F_printk("\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 181                  "\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 182                  "\t=> %ps\n\t=> %ps\n",
 183                  (void *)__entry->caller[0], (void *)__entry->caller[1],
 184                  (void *)__entry->caller[2], (void *)__entry->caller[3],
 185                  (void *)__entry->caller[4], (void *)__entry->caller[5],
 186                  (void *)__entry->caller[6], (void *)__entry->caller[7]),
 187 
 188         FILTER_OTHER
 189 );
 190 
 191 FTRACE_ENTRY(user_stack, userstack_entry,
 192 
 193         TRACE_USER_STACK,
 194 
 195         F_STRUCT(
 196                 __field(        unsigned int,   tgid    )
 197                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 198         ),
 199 
 200         F_printk("\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 201                  "\t=> %ps\n\t=> %ps\n\t=> %ps\n"
 202                  "\t=> %ps\n\t=> %ps\n",
 203                  (void *)__entry->caller[0], (void *)__entry->caller[1],
 204                  (void *)__entry->caller[2], (void *)__entry->caller[3],
 205                  (void *)__entry->caller[4], (void *)__entry->caller[5],
 206                  (void *)__entry->caller[6], (void *)__entry->caller[7]),
 207 
 208         FILTER_OTHER
 209 );
 210 
 211 /*
 212  * trace_printk entry:
 213  */
 214 FTRACE_ENTRY(bprint, bprint_entry,
 215 
 216         TRACE_BPRINT,
 217 
 218         F_STRUCT(
 219                 __field(        unsigned long,  ip      )
 220                 __field(        const char *,   fmt     )
 221                 __dynamic_array(        u32,    buf     )
 222         ),
 223 
 224         F_printk("%ps: %s",
 225                  (void *)__entry->ip, __entry->fmt),
 226 
 227         FILTER_OTHER
 228 );
 229 
 230 FTRACE_ENTRY_REG(print, print_entry,
 231 
 232         TRACE_PRINT,
 233 
 234         F_STRUCT(
 235                 __field(        unsigned long,  ip      )
 236                 __dynamic_array(        char,   buf     )
 237         ),
 238 
 239         F_printk("%ps: %s",
 240                  (void *)__entry->ip, __entry->buf),
 241 
 242         FILTER_OTHER,
 243 
 244         ftrace_event_register
 245 );
 246 
 247 FTRACE_ENTRY(raw_data, raw_data_entry,
 248 
 249         TRACE_RAW_DATA,
 250 
 251         F_STRUCT(
 252                 __field(        unsigned int,   id      )
 253                 __dynamic_array(        char,   buf     )
 254         ),
 255 
 256         F_printk("id:%04x %08x",
 257                  __entry->id, (int)__entry->buf[0]),
 258 
 259         FILTER_OTHER
 260 );
 261 
 262 FTRACE_ENTRY(bputs, bputs_entry,
 263 
 264         TRACE_BPUTS,
 265 
 266         F_STRUCT(
 267                 __field(        unsigned long,  ip      )
 268                 __field(        const char *,   str     )
 269         ),
 270 
 271         F_printk("%ps: %s",
 272                  (void *)__entry->ip, __entry->str),
 273 
 274         FILTER_OTHER
 275 );
 276 
 277 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 278 
 279         TRACE_MMIO_RW,
 280 
 281         F_STRUCT(
 282                 __field_struct( struct mmiotrace_rw,    rw      )
 283                 __field_desc(   resource_size_t, rw,    phys    )
 284                 __field_desc(   unsigned long,  rw,     value   )
 285                 __field_desc(   unsigned long,  rw,     pc      )
 286                 __field_desc(   int,            rw,     map_id  )
 287                 __field_desc(   unsigned char,  rw,     opcode  )
 288                 __field_desc(   unsigned char,  rw,     width   )
 289         ),
 290 
 291         F_printk("%lx %lx %lx %d %x %x",
 292                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
 293                  __entry->map_id, __entry->opcode, __entry->width),
 294 
 295         FILTER_OTHER
 296 );
 297 
 298 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 299 
 300         TRACE_MMIO_MAP,
 301 
 302         F_STRUCT(
 303                 __field_struct( struct mmiotrace_map,   map     )
 304                 __field_desc(   resource_size_t, map,   phys    )
 305                 __field_desc(   unsigned long,  map,    virt    )
 306                 __field_desc(   unsigned long,  map,    len     )
 307                 __field_desc(   int,            map,    map_id  )
 308                 __field_desc(   unsigned char,  map,    opcode  )
 309         ),
 310 
 311         F_printk("%lx %lx %lx %d %x",
 312                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
 313                  __entry->map_id, __entry->opcode),
 314 
 315         FILTER_OTHER
 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         FILTER_OTHER
 340 );
 341 
 342 
 343 FTRACE_ENTRY(hwlat, hwlat_entry,
 344 
 345         TRACE_HWLAT,
 346 
 347         F_STRUCT(
 348                 __field(        u64,                    duration        )
 349                 __field(        u64,                    outer_duration  )
 350                 __field(        u64,                    nmi_total_ts    )
 351                 __field_struct( struct timespec64,      timestamp       )
 352                 __field_desc(   s64,    timestamp,      tv_sec          )
 353                 __field_desc(   long,   timestamp,      tv_nsec         )
 354                 __field(        unsigned int,           nmi_count       )
 355                 __field(        unsigned int,           seqnum          )
 356         ),
 357 
 358         F_printk("cnt:%u\tts:%010llu.%010lu\tinner:%llu\touter:%llu\tnmi-ts:%llu\tnmi-count:%u\n",
 359                  __entry->seqnum,
 360                  __entry->tv_sec,
 361                  __entry->tv_nsec,
 362                  __entry->duration,
 363                  __entry->outer_duration,
 364                  __entry->nmi_total_ts,
 365                  __entry->nmi_count),
 366 
 367         FILTER_OTHER
 368 );
/* [<][>][^][v][top][bottom][index][help] */
root/kernel/trace/trace_entries.h

INCLUDED FROM
