LXR linux/kernel/trace/trace

   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 */
  58FTRACE_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        FILTER_TRACE_FN,
  70
  71        perf_ftrace_event_register
  72);
  73
  74/* Function call entry */
  75FTRACE_ENTRY(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_desc(   unsigned long,  graph_ent,      func            )
  82                __field_desc(   int,            graph_ent,      depth           )
  83        ),
  84
  85        F_printk("--> %lx (%d)", __entry->func, __entry->depth),
  86
  87        FILTER_OTHER
  88);
  89
  90/* Function return entry */
  91FTRACE_ENTRY(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_desc(   unsigned long,  ret,            func    )
  98                __field_desc(   unsigned long long, ret,        calltime)
  99                __field_desc(   unsigned long long, ret,        rettime )
 100                __field_desc(   unsigned long,  ret,            overrun )
 101                __field_desc(   int,            ret,            depth   )
 102        ),
 103
 104        F_printk("<-- %lx (%d) (start: %llx  end: %llx) over: %d",
 105                 __entry->func, __entry->depth,
 106                 __entry->calltime, __entry->rettime,
 107                 __entry->depth),
 108
 109        FILTER_OTHER
 110);
 111
 112/*
 113 * Context switch trace entry - which task (and prio) we switched from/to:
 114 *
 115 * This is used for both wakeup and context switches. We only want
 116 * to create one structure, but we need two outputs for it.
 117 */
 118#define FTRACE_CTX_FIELDS                                       \
 119        __field(        unsigned int,   prev_pid        )       \
 120        __field(        unsigned int,   next_pid        )       \
 121        __field(        unsigned int,   next_cpu        )       \
 122        __field(        unsigned char,  prev_prio       )       \
 123        __field(        unsigned char,  prev_state      )       \
 124        __field(        unsigned char,  next_prio       )       \
 125        __field(        unsigned char,  next_state      )
 126
 127FTRACE_ENTRY(context_switch, ctx_switch_entry,
 128
 129        TRACE_CTX,
 130
 131        F_STRUCT(
 132                FTRACE_CTX_FIELDS
 133        ),
 134
 135        F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 136                 __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 137                 __entry->next_pid, __entry->next_prio, __entry->next_state,
 138                 __entry->next_cpu),
 139
 140        FILTER_OTHER
 141);
 142
 143/*
 144 * FTRACE_ENTRY_DUP only creates the format file, it will not
 145 *  create another structure.
 146 */
 147FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 148
 149        TRACE_WAKE,
 150
 151        F_STRUCT(
 152                FTRACE_CTX_FIELDS
 153        ),
 154
 155        F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
 156                 __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 157                 __entry->next_pid, __entry->next_prio, __entry->next_state,
 158                 __entry->next_cpu),
 159
 160        FILTER_OTHER
 161);
 162
 163/*
 164 * Stack-trace entry:
 165 */
 166
 167#define FTRACE_STACK_ENTRIES    8
 168
 169#ifndef CONFIG_64BIT
 170# define IP_FMT "%08lx"
 171#else
 172# define IP_FMT "%016lx"
 173#endif
 174
 175FTRACE_ENTRY(kernel_stack, stack_entry,
 176
 177        TRACE_STACK,
 178
 179        F_STRUCT(
 180                __field(        int,            size    )
 181                __dynamic_array(unsigned long,  caller  )
 182        ),
 183
 184        F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 185                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 186                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
 187                 __entry->caller[0], __entry->caller[1], __entry->caller[2],
 188                 __entry->caller[3], __entry->caller[4], __entry->caller[5],
 189                 __entry->caller[6], __entry->caller[7]),
 190
 191        FILTER_OTHER
 192);
 193
 194FTRACE_ENTRY(user_stack, userstack_entry,
 195
 196        TRACE_USER_STACK,
 197
 198        F_STRUCT(
 199                __field(        unsigned int,   tgid    )
 200                __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 201        ),
 202
 203        F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 204                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
 205                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
 206                 __entry->caller[0], __entry->caller[1], __entry->caller[2],
 207                 __entry->caller[3], __entry->caller[4], __entry->caller[5],
 208                 __entry->caller[6], __entry->caller[7]),
 209
 210        FILTER_OTHER
 211);
 212
 213/*
 214 * trace_printk entry:
 215 */
 216FTRACE_ENTRY(bprint, bprint_entry,
 217
 218        TRACE_BPRINT,
 219
 220        F_STRUCT(
 221                __field(        unsigned long,  ip      )
 222                __field(        const char *,   fmt     )
 223                __dynamic_array(        u32,    buf     )
 224        ),
 225
 226        F_printk("%ps: %s",
 227                 (void *)__entry->ip, __entry->fmt),
 228
 229        FILTER_OTHER
 230);
 231
 232FTRACE_ENTRY(print, print_entry,
 233
 234        TRACE_PRINT,
 235
 236        F_STRUCT(
 237                __field(        unsigned long,  ip      )
 238                __dynamic_array(        char,   buf     )
 239        ),
 240
 241        F_printk("%ps: %s",
 242                 (void *)__entry->ip, __entry->buf),
 243
 244        FILTER_OTHER
 245);
 246
 247FTRACE_ENTRY(bputs, bputs_entry,
 248
 249        TRACE_BPUTS,
 250
 251        F_STRUCT(
 252                __field(        unsigned long,  ip      )
 253                __field(        const char *,   str     )
 254        ),
 255
 256        F_printk("%ps: %s",
 257                 (void *)__entry->ip, __entry->str),
 258
 259        FILTER_OTHER
 260);
 261
 262FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 263
 264        TRACE_MMIO_RW,
 265
 266        F_STRUCT(
 267                __field_struct( struct mmiotrace_rw,    rw      )
 268                __field_desc(   resource_size_t, rw,    phys    )
 269                __field_desc(   unsigned long,  rw,     value   )
 270                __field_desc(   unsigned long,  rw,     pc      )
 271                __field_desc(   int,            rw,     map_id  )
 272                __field_desc(   unsigned char,  rw,     opcode  )
 273                __field_desc(   unsigned char,  rw,     width   )
 274        ),
 275
 276        F_printk("%lx %lx %lx %d %x %x",
 277                 (unsigned long)__entry->phys, __entry->value, __entry->pc,
 278                 __entry->map_id, __entry->opcode, __entry->width),
 279
 280        FILTER_OTHER
 281);
 282
 283FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 284
 285        TRACE_MMIO_MAP,
 286
 287        F_STRUCT(
 288                __field_struct( struct mmiotrace_map,   map     )
 289                __field_desc(   resource_size_t, map,   phys    )
 290                __field_desc(   unsigned long,  map,    virt    )
 291                __field_desc(   unsigned long,  map,    len     )
 292                __field_desc(   int,            map,    map_id  )
 293                __field_desc(   unsigned char,  map,    opcode  )
 294        ),
 295
 296        F_printk("%lx %lx %lx %d %x",
 297                 (unsigned long)__entry->phys, __entry->virt, __entry->len,
 298                 __entry->map_id, __entry->opcode),
 299
 300        FILTER_OTHER
 301);
 302
 303
 304#define TRACE_FUNC_SIZE 30
 305#define TRACE_FILE_SIZE 20
 306
 307FTRACE_ENTRY(branch, trace_branch,
 308
 309        TRACE_BRANCH,
 310
 311        F_STRUCT(
 312                __field(        unsigned int,   line                            )
 313                __array(        char,           func,   TRACE_FUNC_SIZE+1       )
 314                __array(        char,           file,   TRACE_FILE_SIZE+1       )
 315                __field(        char,           correct                         )
 316        ),
 317
 318        F_printk("%u:%s:%s (%u)",
 319                 __entry->line,
 320                 __entry->func, __entry->file, __entry->correct),
 321
 322        FILTER_OTHER
 323);
 324
 325