tracing: replace TP<var> with TP_<var>
[linux-2.6.git] / kernel / trace / trace_events_stage_3.h
1 /*
2  * Stage 3 of the trace events.
3  *
4  * Override the macros in <trace/trace_event_types.h> to include the following:
5  *
6  * static void ftrace_event_<call>(proto)
7  * {
8  *      event_trace_printk(_RET_IP_, "<call>: " <fmt>);
9  * }
10  *
11  * static int ftrace_reg_event_<call>(void)
12  * {
13  *      int ret;
14  *
15  *      ret = register_trace_<call>(ftrace_event_<call>);
16  *      if (!ret)
17  *              pr_info("event trace: Could not activate trace point "
18  *                      "probe to  <call>");
19  *      return ret;
20  * }
21  *
22  * static void ftrace_unreg_event_<call>(void)
23  * {
24  *      unregister_trace_<call>(ftrace_event_<call>);
25  * }
26  *
27  * For those macros defined with TRACE_FORMAT:
28  *
29  * static struct ftrace_event_call __used
30  * __attribute__((__aligned__(4)))
31  * __attribute__((section("_ftrace_events"))) event_<call> = {
32  *      .name                   = "<call>",
33  *      .regfunc                = ftrace_reg_event_<call>,
34  *      .unregfunc              = ftrace_unreg_event_<call>,
35  * }
36  *
37  *
38  * For those macros defined with TRACE_EVENT_FORMAT:
39  *
40  * static struct ftrace_event_call event_<call>;
41  *
42  * static void ftrace_raw_event_<call>(proto)
43  * {
44  *      struct ring_buffer_event *event;
45  *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
46  *      unsigned long irq_flags;
47  *      int pc;
48  *
49  *      local_save_flags(irq_flags);
50  *      pc = preempt_count();
51  *
52  *      event = trace_current_buffer_lock_reserve(event_<call>.id,
53  *                                sizeof(struct ftrace_raw_<call>),
54  *                                irq_flags, pc);
55  *      if (!event)
56  *              return;
57  *      entry   = ring_buffer_event_data(event);
58  *
59  *      <tstruct>;  <-- Here we assign the entries by the TRACE_FIELD.
60  *
61  *      trace_current_buffer_unlock_commit(event, irq_flags, pc);
62  * }
63  *
64  * static int ftrace_raw_reg_event_<call>(void)
65  * {
66  *      int ret;
67  *
68  *      ret = register_trace_<call>(ftrace_raw_event_<call>);
69  *      if (!ret)
70  *              pr_info("event trace: Could not activate trace point "
71  *                      "probe to <call>");
72  *      return ret;
73  * }
74  *
75  * static void ftrace_unreg_event_<call>(void)
76  * {
77  *      unregister_trace_<call>(ftrace_raw_event_<call>);
78  * }
79  *
80  * static struct trace_event ftrace_event_type_<call> = {
81  *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
82  * };
83  *
84  * static int ftrace_raw_init_event_<call>(void)
85  * {
86  *      int id;
87  *
88  *      id = register_ftrace_event(&ftrace_event_type_<call>);
89  *      if (!id)
90  *              return -ENODEV;
91  *      event_<call>.id = id;
92  *      return 0;
93  * }
94  *
95  * static struct ftrace_event_call __used
96  * __attribute__((__aligned__(4)))
97  * __attribute__((section("_ftrace_events"))) event_<call> = {
98  *      .name                   = "<call>",
99  *      .regfunc                = ftrace_reg_event_<call>,
100  *      .unregfunc              = ftrace_unreg_event_<call>,
101  *      .raw_init               = ftrace_raw_init_event_<call>,
102  *      .raw_reg                = ftrace_raw_reg_event_<call>,
103  *      .raw_unreg              = ftrace_raw_unreg_event_<call>,
104  *      .show_format            = ftrace_format_<call>,
105  * }
106  *
107  */
108
109 #undef TP_FMT
110 #define TP_FMT(fmt, args...)    fmt "\n", ##args
111
112 #define _TRACE_FORMAT(call, proto, args, fmt)                           \
113 static void ftrace_event_##call(proto)                                  \
114 {                                                                       \
115         event_trace_printk(_RET_IP_, #call ": " fmt);                   \
116 }                                                                       \
117                                                                         \
118 static int ftrace_reg_event_##call(void)                                \
119 {                                                                       \
120         int ret;                                                        \
121                                                                         \
122         ret = register_trace_##call(ftrace_event_##call);               \
123         if (ret)                                                        \
124                 pr_info("event trace: Could not activate trace point "  \
125                         "probe to " #call "\n");                        \
126         return ret;                                                     \
127 }                                                                       \
128                                                                         \
129 static void ftrace_unreg_event_##call(void)                             \
130 {                                                                       \
131         unregister_trace_##call(ftrace_event_##call);                   \
132 }                                                                       \
133
134
135 #undef TRACE_FORMAT
136 #define TRACE_FORMAT(call, proto, args, fmt)                            \
137 _TRACE_FORMAT(call, PARAMS(proto), PARAMS(args), PARAMS(fmt))           \
138 static struct ftrace_event_call __used                                  \
139 __attribute__((__aligned__(4)))                                         \
140 __attribute__((section("_ftrace_events"))) event_##call = {             \
141         .name                   = #call,                                \
142         .system                 = STR(TRACE_SYSTEM),                    \
143         .regfunc                = ftrace_reg_event_##call,              \
144         .unregfunc              = ftrace_unreg_event_##call,            \
145 }
146
147 #undef TRACE_FIELD
148 #define TRACE_FIELD(type, item, assign)\
149         entry->item = assign;
150
151 #undef TRACE_FIELD
152 #define TRACE_FIELD(type, item, assign)\
153         entry->item = assign;
154
155 #undef TP_CMD
156 #define TP_CMD(cmd...)  cmd
157
158 #undef TRACE_ENTRY
159 #define TRACE_ENTRY     entry
160
161 #undef TRACE_FIELD_SPECIAL
162 #define TRACE_FIELD_SPECIAL(type_item, item, cmd) \
163         cmd;
164
165 #undef TRACE_EVENT_FORMAT
166 #define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
167 _TRACE_FORMAT(call, PARAMS(proto), PARAMS(args), PARAMS(fmt))           \
168                                                                         \
169 static struct ftrace_event_call event_##call;                           \
170                                                                         \
171 static void ftrace_raw_event_##call(proto)                              \
172 {                                                                       \
173         struct ring_buffer_event *event;                                \
174         struct ftrace_raw_##call *entry;                                \
175         unsigned long irq_flags;                                        \
176         int pc;                                                         \
177                                                                         \
178         local_save_flags(irq_flags);                                    \
179         pc = preempt_count();                                           \
180                                                                         \
181         event = trace_current_buffer_lock_reserve(event_##call.id,      \
182                                   sizeof(struct ftrace_raw_##call),     \
183                                   irq_flags, pc);                       \
184         if (!event)                                                     \
185                 return;                                                 \
186         entry   = ring_buffer_event_data(event);                        \
187                                                                         \
188         tstruct;                                                        \
189                                                                         \
190         trace_current_buffer_unlock_commit(event, irq_flags, pc);       \
191 }                                                                       \
192                                                                         \
193 static int ftrace_raw_reg_event_##call(void)                            \
194 {                                                                       \
195         int ret;                                                        \
196                                                                         \
197         ret = register_trace_##call(ftrace_raw_event_##call);           \
198         if (ret)                                                        \
199                 pr_info("event trace: Could not activate trace point "  \
200                         "probe to " #call "\n");                        \
201         return ret;                                                     \
202 }                                                                       \
203                                                                         \
204 static void ftrace_raw_unreg_event_##call(void)                         \
205 {                                                                       \
206         unregister_trace_##call(ftrace_raw_event_##call);               \
207 }                                                                       \
208                                                                         \
209 static struct trace_event ftrace_event_type_##call = {                  \
210         .trace                  = ftrace_raw_output_##call,             \
211 };                                                                      \
212                                                                         \
213 static int ftrace_raw_init_event_##call(void)                           \
214 {                                                                       \
215         int id;                                                         \
216                                                                         \
217         id = register_ftrace_event(&ftrace_event_type_##call);          \
218         if (!id)                                                        \
219                 return -ENODEV;                                         \
220         event_##call.id = id;                                           \
221         return 0;                                                       \
222 }                                                                       \
223                                                                         \
224 static struct ftrace_event_call __used                                  \
225 __attribute__((__aligned__(4)))                                         \
226 __attribute__((section("_ftrace_events"))) event_##call = {             \
227         .name                   = #call,                                \
228         .system                 = STR(TRACE_SYSTEM),                    \
229         .regfunc                = ftrace_reg_event_##call,              \
230         .unregfunc              = ftrace_unreg_event_##call,            \
231         .raw_init               = ftrace_raw_init_event_##call,         \
232         .raw_reg                = ftrace_raw_reg_event_##call,          \
233         .raw_unreg              = ftrace_raw_unreg_event_##call,        \
234         .show_format            = ftrace_format_##call,                 \
235 }