kernel/trace/trace_entries.h

   1 /*
   2  * This file defines the trace event structures that go into the ring
   3  * buffer directly. They are created via macros so that changes for them
   4  * appear in the format file. Using macros will automate this process.
   5  *
   6  * The macro used to create a ftrace data structure is:
   7  *
   8  * FTRACE_ENTRY( name, struct_name, id, structure, print )
   9  *
  10  * @name: the name used the event name, as well as the name of
  11  *   the directory that holds the format file.
  12  *
  13  * @struct_name: the name of the structure that is created.
  14  *
  15  * @id: The event identifier that is used to detect what event
  16  *    this is from the ring buffer.
  17  *
  18  * @structure: the structure layout
  19  *
  20  *  - __field(  type,   item    )
  21  *        This is equivalent to declaring
  22  *              type    item;
  23  *        in the structure.
  24  *  - __array(  type,   item,   size    )
  25  *        This is equivalent to declaring
  26  *              type    item[size];
  27  *        in the structure.
  28  *
  29  *   * for structures within structures, the format of the internal
  30  *      structure is laid out. This allows the internal structure
  31  *      to be deciphered for the format file. Although these macros
  32  *      may become out of sync with the internal structure, they
  33  *      will create a compile error if it happens. Since the
  34  *      internel structures are just tracing helpers, this is not
  35  *      an issue.
  36  *
  37  *      When an internal structure is used, it should use:
  38  *
  39  *      __field_struct( type,   item    )
  40  *
  41  *      instead of __field. This will prevent it from being shown in
  42  *      the output file. The fields in the structure should use.
  43  *
  44  *      __field_desc(   type,   container,      item            )
  45  *      __array_desc(   type,   container,      item,   len     )
  46  *
  47  *      type, item and len are the same as __field and __array, but
  48  *      container is added. This is the name of the item in
  49  *      __field_struct that this is describing.
  50  *
  51  *
  52  * @print: the print format shown to users in the format file.
  53  */
  54
  55 /*
  56  * Function trace entry - function address and parent function address:
  57  */
  58 FTRACE_ENTRY_REG(function, ftrace_entry,
  59
  60         TRACE_FN,
  61
  62         F_STRUCT(
  63                 __field(        unsigned long,  ip              )
  64                 __field(        unsigned long,  parent_ip       )
  65         ),
  66
  67         F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip),
  68
  69         perf_ftrace_event_register
  70 );
  71
  72 /* Function call entry */
  73 FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry,
  74
  75         TRACE_GRAPH_ENT,
  76
  77         F_STRUCT(
  78                 __field_struct( struct ftrace_graph_ent,        graph_ent       )
  79                 __field_desc(   unsigned long,  graph_ent,      func            )
  80                 __field_desc(   int,            graph_ent,      depth           )
  81         ),
  82
  83         F_printk("--> %lx (%d)", __entry->func, __entry->depth)
  84 );
  85
  86 /* Function return entry */
  87 FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry,
  88
  89         TRACE_GRAPH_RET,
  90
  91         F_STRUCT(
  92                 __field_struct( struct ftrace_graph_ret,        ret     )
  93                 __field_desc(   unsigned long,  ret,            func    )
  94                 __field_desc(   unsigned long long, ret,        calltime)
  95                 __field_desc(   unsigned long long, ret,        rettime )
  96                 __field_desc(   unsigned long,  ret,            overrun )
  97                 __field_desc(   int,            ret,            depth   )
  98         ),
  99
 100         F_printk("<-- %lx (%d) (start: %llx  end: %llx) over: %d",
 101                  __entry->func, __entry->depth,
 102                  __entry->calltime, __entry->rettime,
 103                  __entry->depth)
 104 );
 105
 106 /*
 107  * Context switch trace entry - which task (and prio) we switched from/to:
 108  *
 109  * This is used for both wakeup and context switches. We only want
 110  * to create one structure, but we need two outputs for it.
 111  */
 112 #define FTRACE_CTX_FIELDS                                       \
 113         __field(        unsigned int,   prev_pid        )       \
 114         __field(        unsigned int,   next_pid        )       \
 115         __field(        unsigned int,   next_cpu        )       \
 116         __field(        unsigned char,  prev_prio       )       \
 117         __field(        unsigned char,  prev_state      )       \
 118         __field(        unsigned char,  next_prio       )       \
 119         __field(        unsigned char,  next_state      )
 120
 121 FTRACE_ENTRY(context_switch, ctx_switch_entry,
 122
 123         TRACE_CTX,
 124
 125         F_STRUCT(
 126                 FTRACE_CTX_FIELDS
 127         ),
 128
 129         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 130                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 131                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 132                  __entry->next_cpu
 133                 )
 134 );
 135
 136 /*
 137  * FTRACE_ENTRY_DUP only creates the format file, it will not
 138  *  create another structure.
 139  */
 140 FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 141
 142         TRACE_WAKE,
 143
 144         F_STRUCT(
 145                 FTRACE_CTX_FIELDS
 146         ),
 147
 148         F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
 149                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 150                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 151                  __entry->next_cpu
 152                 )
 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                 __dynamic_array(unsigned long,  caller  )
 168         ),
 169
 170         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
 171                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
 172                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
 173                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
 174                  __entry->caller[6], __entry->caller[7])
 175 );
 176
 177 FTRACE_ENTRY(user_stack, userstack_entry,
 178
 179         TRACE_USER_STACK,
 180
 181         F_STRUCT(
 182                 __field(        unsigned int,   tgid    )
 183                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 184         ),
 185
 186         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
 187                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\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
 193 /*
 194  * trace_printk entry:
 195  */
 196 FTRACE_ENTRY(bprint, bprint_entry,
 197
 198         TRACE_BPRINT,
 199
 200         F_STRUCT(
 201                 __field(        unsigned long,  ip      )
 202                 __field(        const char *,   fmt     )
 203                 __dynamic_array(        u32,    buf     )
 204         ),
 205
 206         F_printk("%08lx fmt:%p",
 207                  __entry->ip, __entry->fmt)
 208 );
 209
 210 FTRACE_ENTRY(print, print_entry,
 211
 212         TRACE_PRINT,
 213
 214         F_STRUCT(
 215                 __field(        unsigned long,  ip      )
 216                 __dynamic_array(        char,   buf     )
 217         ),
 218
 219         F_printk("%08lx %s",
 220                  __entry->ip, __entry->buf)
 221 );
 222
 223 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 224
 225         TRACE_MMIO_RW,
 226
 227         F_STRUCT(
 228                 __field_struct( struct mmiotrace_rw,    rw      )
 229                 __field_desc(   resource_size_t, rw,    phys    )
 230                 __field_desc(   unsigned long,  rw,     value   )
 231                 __field_desc(   unsigned long,  rw,     pc      )
 232                 __field_desc(   int,            rw,     map_id  )
 233                 __field_desc(   unsigned char,  rw,     opcode  )
 234                 __field_desc(   unsigned char,  rw,     width   )
 235         ),
 236
 237         F_printk("%lx %lx %lx %d %x %x",
 238                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
 239                  __entry->map_id, __entry->opcode, __entry->width)
 240 );
 241
 242 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 243
 244         TRACE_MMIO_MAP,
 245
 246         F_STRUCT(
 247                 __field_struct( struct mmiotrace_map,   map     )
 248                 __field_desc(   resource_size_t, map,   phys    )
 249                 __field_desc(   unsigned long,  map,    virt    )
 250                 __field_desc(   unsigned long,  map,    len     )
 251                 __field_desc(   int,            map,    map_id  )
 252                 __field_desc(   unsigned char,  map,    opcode  )
 253         ),
 254
 255         F_printk("%lx %lx %lx %d %x",
 256                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
 257                  __entry->map_id, __entry->opcode)
 258 );
 259
 260
 261 #define TRACE_FUNC_SIZE 30
 262 #define TRACE_FILE_SIZE 20
 263
 264 FTRACE_ENTRY(branch, trace_branch,
 265
 266         TRACE_BRANCH,
 267
 268         F_STRUCT(
 269                 __field(        unsigned int,   line                            )
 270                 __array(        char,           func,   TRACE_FUNC_SIZE+1       )
 271                 __array(        char,           file,   TRACE_FILE_SIZE+1       )
 272                 __field(        char,           correct                         )
 273         ),
 274
 275         F_printk("%u:%s:%s (%u)",
 276                  __entry->line,
 277                  __entry->func, __entry->file, __entry->correct)
 278 );
 279