tracing: Adjust conditional expression latency formatting.
[linux-2.6.git] / 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 address:
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 int,   next_pid        )       \
113         __field(        unsigned int,   next_cpu        )       \
114         __field(        unsigned char,  prev_prio       )       \
115         __field(        unsigned char,  prev_state      )       \
116         __field(        unsigned char,  next_prio       )       \
117         __field(        unsigned char,  next_state      )
118
119 FTRACE_ENTRY(context_switch, ctx_switch_entry,
120
121         TRACE_CTX,
122
123         F_STRUCT(
124                 FTRACE_CTX_FIELDS
125         ),
126
127         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
128                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
129                  __entry->next_pid, __entry->next_prio, __entry->next_state,
130                  __entry->next_cpu
131                 )
132 );
133
134 /*
135  * FTRACE_ENTRY_DUP only creates the format file, it will not
136  *  create another structure.
137  */
138 FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
139
140         TRACE_WAKE,
141
142         F_STRUCT(
143                 FTRACE_CTX_FIELDS
144         ),
145
146         F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
147                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
148                  __entry->next_pid, __entry->next_prio, __entry->next_state,
149                  __entry->next_cpu
150                 )
151 );
152
153 /*
154  * Stack-trace entry:
155  */
156
157 #define FTRACE_STACK_ENTRIES    8
158
159 FTRACE_ENTRY(kernel_stack, stack_entry,
160
161         TRACE_STACK,
162
163         F_STRUCT(
164                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
165         ),
166
167         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
168                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
169                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
170                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
171                  __entry->caller[6], __entry->caller[7])
172 );
173
174 FTRACE_ENTRY(user_stack, userstack_entry,
175
176         TRACE_USER_STACK,
177
178         F_STRUCT(
179                 __field(        unsigned int,   tgid    )
180                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
181         ),
182
183         F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
184                  "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
185                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
186                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
187                  __entry->caller[6], __entry->caller[7])
188 );
189
190 /*
191  * trace_printk entry:
192  */
193 FTRACE_ENTRY(bprint, bprint_entry,
194
195         TRACE_BPRINT,
196
197         F_STRUCT(
198                 __field(        unsigned long,  ip      )
199                 __field(        const char *,   fmt     )
200                 __dynamic_array(        u32,    buf     )
201         ),
202
203         F_printk("%08lx fmt:%p",
204                  __entry->ip, __entry->fmt)
205 );
206
207 FTRACE_ENTRY(print, print_entry,
208
209         TRACE_PRINT,
210
211         F_STRUCT(
212                 __field(        unsigned long,  ip      )
213                 __dynamic_array(        char,   buf     )
214         ),
215
216         F_printk("%08lx %s",
217                  __entry->ip, __entry->buf)
218 );
219
220 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
221
222         TRACE_MMIO_RW,
223
224         F_STRUCT(
225                 __field_struct( struct mmiotrace_rw,    rw      )
226                 __field_desc(   resource_size_t, rw,    phys    )
227                 __field_desc(   unsigned long,  rw,     value   )
228                 __field_desc(   unsigned long,  rw,     pc      )
229                 __field_desc(   int,            rw,     map_id  )
230                 __field_desc(   unsigned char,  rw,     opcode  )
231                 __field_desc(   unsigned char,  rw,     width   )
232         ),
233
234         F_printk("%lx %lx %lx %d %x %x",
235                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
236                  __entry->map_id, __entry->opcode, __entry->width)
237 );
238
239 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
240
241         TRACE_MMIO_MAP,
242
243         F_STRUCT(
244                 __field_struct( struct mmiotrace_map,   map     )
245                 __field_desc(   resource_size_t, map,   phys    )
246                 __field_desc(   unsigned long,  map,    virt    )
247                 __field_desc(   unsigned long,  map,    len     )
248                 __field_desc(   int,            map,    map_id  )
249                 __field_desc(   unsigned char,  map,    opcode  )
250         ),
251
252         F_printk("%lx %lx %lx %d %x",
253                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
254                  __entry->map_id, __entry->opcode)
255 );
256
257
258 #define TRACE_FUNC_SIZE 30
259 #define TRACE_FILE_SIZE 20
260
261 FTRACE_ENTRY(branch, trace_branch,
262
263         TRACE_BRANCH,
264
265         F_STRUCT(
266                 __field(        unsigned int,   line                            )
267                 __array(        char,           func,   TRACE_FUNC_SIZE+1       )
268                 __array(        char,           file,   TRACE_FILE_SIZE+1       )
269                 __field(        char,           correct                         )
270         ),
271
272         F_printk("%u:%s:%s (%u)",
273                  __entry->line,
274                  __entry->func, __entry->file, __entry->correct)
275 );
276