SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 layed 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 addres:
  57  */
  58 FTRACE_ENTRY(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
  70 /* Function call entry */
  71 FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry,
  72
  73         TRACE_GRAPH_ENT,
  74
  75         F_STRUCT(
  76                 __field_struct( struct ftrace_graph_ent,        graph_ent       )
  77                 __field_desc(   unsigned long,  graph_ent,      func            )
  78                 __field_desc(   int,            graph_ent,      depth           )
  79         ),
  80
  81         F_printk("--> %lx (%d)", __entry->func, __entry->depth)
  82 );
  83
  84 /* Function return entry */
  85 FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry,
  86
  87         TRACE_GRAPH_RET,
  88
  89         F_STRUCT(
  90                 __field_struct( struct ftrace_graph_ret,        ret     )
  91                 __field_desc(   unsigned long,  ret,            func    )
  92                 __field_desc(   unsigned long long, ret,        calltime)
  93                 __field_desc(   unsigned long long, ret,        rettime )
  94                 __field_desc(   unsigned long,  ret,            overrun )
  95                 __field_desc(   int,            ret,            depth   )
  96         ),
  97
  98         F_printk("<-- %lx (%d) (start: %llx  end: %llx) over: %d",
  99                  __entry->func, __entry->depth,
 100                  __entry->calltime, __entry->rettime,
 101                  __entry->depth)
 102 );
 103
 104 /*
 105  * Context switch trace entry - which task (and prio) we switched from/to:
 106  *
 107  * This is used for both wakeup and context switches. We only want
 108  * to create one structure, but we need two outputs for it.
 109  */
 110 #define FTRACE_CTX_FIELDS                                       \
 111         __field(        unsigned int,   prev_pid        )       \
 112         __field(        unsigned char,  prev_prio       )       \
 113         __field(        unsigned char,  prev_state      )       \
 114         __field(        unsigned int,   next_pid        )       \
 115         __field(        unsigned char,  next_prio       )       \
 116         __field(        unsigned char,  next_state      )       \
 117         __field(        unsigned int,   next_cpu        )
 118
 119 #if 0
 120 FTRACE_ENTRY_STRUCT_ONLY(ctx_switch_entry,
 121
 122         F_STRUCT(
 123                 FTRACE_CTX_FIELDS
 124         )
 125 );
 126 #endif
 127
 128 FTRACE_ENTRY(context_switch, ctx_switch_entry,
 129
 130         TRACE_CTX,
 131
 132         F_STRUCT(
 133                 FTRACE_CTX_FIELDS
 134         ),
 135
 136         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
 137                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
 138                  __entry->next_pid, __entry->next_prio, __entry->next_state,
 139                  __entry->next_cpu
 140                 )
 141 );
 142
 143 /*
 144  * FTRACE_ENTRY_DUP only creates the format file, it will not
 145  *  create another structure.
 146  */
 147 FTRACE_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 );
 161
 162 /*
 163  * Special (free-form) trace entry:
 164  */
 165 FTRACE_ENTRY(special, special_entry,
 166
 167         TRACE_SPECIAL,
 168
 169         F_STRUCT(
 170                 __field(        unsigned long,  arg1    )
 171                 __field(        unsigned long,  arg2    )
 172                 __field(        unsigned long,  arg3    )
 173         ),
 174
 175         F_printk("(%08lx) (%08lx) (%08lx)",
 176                  __entry->arg1, __entry->arg2, __entry->arg3)
 177 );
 178
 179 /*
 180  * Stack-trace entry:
 181  */
 182
 183 #define FTRACE_STACK_ENTRIES    8
 184
 185 FTRACE_ENTRY(kernel_stack, stack_entry,
 186
 187         TRACE_STACK,
 188
 189         F_STRUCT(
 190                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 191         ),
 192
 193         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
 194                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
 195                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
 196                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
 197                  __entry->caller[6], __entry->caller[7])
 198 );
 199
 200 FTRACE_ENTRY(user_stack, userstack_entry,
 201
 202         TRACE_USER_STACK,
 203
 204         F_STRUCT(
 205                 __field(        unsigned int,   tgid    )
 206                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
 207         ),
 208
 209         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
 210                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
 211                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
 212                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
 213                  __entry->caller[6], __entry->caller[7])
 214 );
 215
 216 /*
 217  * trace_printk entry:
 218  */
 219 FTRACE_ENTRY(bprint, bprint_entry,
 220
 221         TRACE_BPRINT,
 222
 223         F_STRUCT(
 224                 __field(        unsigned long,  ip      )
 225                 __field(        const char *,   fmt     )
 226                 __dynamic_array(        u32,    buf     )
 227         ),
 228
 229         F_printk("%08lx fmt:%p",
 230                  __entry->ip, __entry->fmt)
 231 );
 232
 233 FTRACE_ENTRY(print, print_entry,
 234
 235         TRACE_PRINT,
 236
 237         F_STRUCT(
 238                 __field(        unsigned long,  ip      )
 239                 __dynamic_array(        char,   buf     )
 240         ),
 241
 242         F_printk("%08lx %s",
 243                  __entry->ip, __entry->buf)
 244 );
 245
 246 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 247
 248         TRACE_MMIO_RW,
 249
 250         F_STRUCT(
 251                 __field_struct( struct mmiotrace_rw,    rw      )
 252                 __field_desc(   resource_size_t, rw,    phys    )
 253                 __field_desc(   unsigned long,  rw,     value   )
 254                 __field_desc(   unsigned long,  rw,     pc      )
 255                 __field_desc(   int,            rw,     map_id  )
 256                 __field_desc(   unsigned char,  rw,     opcode  )
 257                 __field_desc(   unsigned char,  rw,     width   )
 258         ),
 259
 260         F_printk("%lx %lx %lx %d %x %x",
 261                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
 262                  __entry->map_id, __entry->opcode, __entry->width)
 263 );
 264
 265 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 266
 267         TRACE_MMIO_MAP,
 268
 269         F_STRUCT(
 270                 __field_struct( struct mmiotrace_map,   map     )
 271                 __field_desc(   resource_size_t, map,   phys    )
 272                 __field_desc(   unsigned long,  map,    virt    )
 273                 __field_desc(   unsigned long,  map,    len     )
 274                 __field_desc(   int,            map,    map_id  )
 275                 __field_desc(   unsigned char,  map,    opcode  )
 276         ),
 277
 278         F_printk("%lx %lx %lx %d %x",
 279                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
 280                  __entry->map_id, __entry->opcode)
 281 );
 282
 283 FTRACE_ENTRY(boot_call, trace_boot_call,
 284
 285         TRACE_BOOT_CALL,
 286
 287         F_STRUCT(
 288                 __field_struct( struct boot_trace_call, boot_call       )
 289                 __field_desc(   pid_t,  boot_call,      caller          )
 290                 __array_desc(   char,   boot_call,      func,   KSYM_SYMBOL_LEN)
 291         ),
 292
 293         F_printk("%d  %s", __entry->caller, __entry->func)
 294 );
 295
 296 FTRACE_ENTRY(boot_ret, trace_boot_ret,
 297
 298         TRACE_BOOT_RET,
 299
 300         F_STRUCT(
 301                 __field_struct( struct boot_trace_ret,  boot_ret        )
 302                 __array_desc(   char,   boot_ret,       func,   KSYM_SYMBOL_LEN)
 303                 __field_desc(   int,    boot_ret,       result          )
 304                 __field_desc(   unsigned long, boot_ret, duration       )
 305         ),
 306
 307         F_printk("%s %d %lx",
 308                  __entry->func, __entry->result, __entry->duration)
 309 );
 310
 311 #define TRACE_FUNC_SIZE 30
 312 #define TRACE_FILE_SIZE 20
 313
 314 FTRACE_ENTRY(branch, trace_branch,
 315
 316         TRACE_BRANCH,
 317
 318         F_STRUCT(
 319                 __field(        unsigned int,   line                            )
 320                 __array(        char,           func,   TRACE_FUNC_SIZE+1       )
 321                 __array(        char,           file,   TRACE_FILE_SIZE+1       )
 322                 __field(        char,           correct                         )
 323         ),
 324
 325         F_printk("%u:%s:%s (%u)",
 326                  __entry->line,
 327                  __entry->func, __entry->file, __entry->correct)
 328 );
 329
 330 FTRACE_ENTRY(hw_branch, hw_branch_entry,
 331
 332         TRACE_HW_BRANCHES,
 333
 334         F_STRUCT(
 335                 __field(        u64,    from    )
 336                 __field(        u64,    to      )
 337         ),
 338
 339         F_printk("from: %llx to: %llx", __entry->from, __entry->to)
 340 );
 341
 342 FTRACE_ENTRY(power, trace_power,
 343
 344         TRACE_POWER,
 345
 346         F_STRUCT(
 347                 __field_struct( struct power_trace,     state_data      )
 348                 __field_desc(   s64,    state_data,     stamp           )
 349                 __field_desc(   s64,    state_data,     end             )
 350                 __field_desc(   int,    state_data,     type            )
 351                 __field_desc(   int,    state_data,     state           )
 352         ),
 353
 354         F_printk("%llx->%llx type:%u state:%u",
 355                  __entry->stamp, __entry->end,
 356                  __entry->type, __entry->state)
 357 );
 358
 359 FTRACE_ENTRY(kmem_alloc, kmemtrace_alloc_entry,
 360
 361         TRACE_KMEM_ALLOC,
 362
 363         F_STRUCT(
 364                 __field(        enum kmemtrace_type_id, type_id         )
 365                 __field(        unsigned long,          call_site       )
 366                 __field(        const void *,           ptr             )
 367                 __field(        size_t,                 bytes_req       )
 368                 __field(        size_t,                 bytes_alloc     )
 369                 __field(        gfp_t,                  gfp_flags       )
 370                 __field(        int,                    node            )
 371         ),
 372
 373         F_printk("type:%u call_site:%lx ptr:%p req:%zi alloc:%zi"
 374                  " flags:%x node:%d",
 375                  __entry->type_id, __entry->call_site, __entry->ptr,
 376                  __entry->bytes_req, __entry->bytes_alloc,
 377                  __entry->gfp_flags, __entry->node)
 378 );
 379
 380 FTRACE_ENTRY(kmem_free, kmemtrace_free_entry,
 381
 382         TRACE_KMEM_FREE,
 383
 384         F_STRUCT(
 385                 __field(        enum kmemtrace_type_id, type_id         )
 386                 __field(        unsigned long,          call_site       )
 387                 __field(        const void *,           ptr             )
 388         ),
 389
 390         F_printk("type:%u call_site:%lx ptr:%p",
 391                  __entry->type_id, __entry->call_site, __entry->ptr)
 392 );