Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / kernel / trace / trace_export.c
1 /*
2  * trace_export.c - export basic ftrace utilities to user space
3  *
4  * Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com>
5  */
6 #include <linux/stringify.h>
7 #include <linux/kallsyms.h>
8 #include <linux/seq_file.h>
9 #include <linux/debugfs.h>
10 #include <linux/uaccess.h>
11 #include <linux/ftrace.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/fs.h>
15
16 #include "trace_output.h"
17
18 #undef TRACE_SYSTEM
19 #define TRACE_SYSTEM    ftrace
20
21 /* not needed for this file */
22 #undef __field_struct
23 #define __field_struct(type, item)
24
25 #undef __field
26 #define __field(type, item)                             type item;
27
28 #undef __field_desc
29 #define __field_desc(type, container, item)             type item;
30
31 #undef __array
32 #define __array(type, item, size)                       type item[size];
33
34 #undef __array_desc
35 #define __array_desc(type, container, item, size)       type item[size];
36
37 #undef __dynamic_array
38 #define __dynamic_array(type, item)                     type item[];
39
40 #undef F_STRUCT
41 #define F_STRUCT(args...)                               args
42
43 #undef F_printk
44 #define F_printk(fmt, args...) fmt, args
45
46 #undef FTRACE_ENTRY
47 #define FTRACE_ENTRY(name, struct_name, id, tstruct, print)     \
48 struct ____ftrace_##name {                                      \
49         tstruct                                                 \
50 };                                                              \
51 static void __always_unused ____ftrace_check_##name(void)       \
52 {                                                               \
53         struct ____ftrace_##name *__entry = NULL;               \
54                                                                 \
55         /* force compile-time check on F_printk() */            \
56         printk(print);                                          \
57 }
58
59 #undef FTRACE_ENTRY_DUP
60 #define FTRACE_ENTRY_DUP(name, struct_name, id, tstruct, print) \
61         FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print))
62
63 #include "trace_entries.h"
64
65
66 #undef __field
67 #define __field(type, item)                                             \
68         ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
69                                "offset:%zu;\tsize:%zu;\tsigned:%u;\n",  \
70                                offsetof(typeof(field), item),           \
71                                sizeof(field.item), is_signed_type(type)); \
72         if (!ret)                                                       \
73                 return 0;
74
75 #undef __field_desc
76 #define __field_desc(type, container, item)                             \
77         ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
78                                "offset:%zu;\tsize:%zu;\tsigned:%u;\n",  \
79                                offsetof(typeof(field), container.item), \
80                                sizeof(field.container.item),            \
81                                is_signed_type(type));                   \
82         if (!ret)                                                       \
83                 return 0;
84
85 #undef __array
86 #define __array(type, item, len)                                        \
87         ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t" \
88                                "offset:%zu;\tsize:%zu;\tsigned:%u;\n",  \
89                                offsetof(typeof(field), item),           \
90                                sizeof(field.item), is_signed_type(type)); \
91         if (!ret)                                                       \
92                 return 0;
93
94 #undef __array_desc
95 #define __array_desc(type, container, item, len)                        \
96         ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t" \
97                                "offset:%zu;\tsize:%zu;\tsigned:%u;\n",  \
98                                offsetof(typeof(field), container.item), \
99                                sizeof(field.container.item),            \
100                                is_signed_type(type));                   \
101         if (!ret)                                                       \
102                 return 0;
103
104 #undef __dynamic_array
105 #define __dynamic_array(type, item)                                     \
106         ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
107                                "offset:%zu;\tsize:0;\tsigned:%u;\n",    \
108                                offsetof(typeof(field), item),           \
109                                is_signed_type(type));                   \
110         if (!ret)                                                       \
111                 return 0;
112
113 #undef F_printk
114 #define F_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)
115
116 #undef __entry
117 #define __entry REC
118
119 #undef FTRACE_ENTRY
120 #define FTRACE_ENTRY(name, struct_name, id, tstruct, print)             \
121 static int                                                              \
122 ftrace_format_##name(struct ftrace_event_call *unused,                  \
123                      struct trace_seq *s)                               \
124 {                                                                       \
125         struct struct_name field __attribute__((unused));               \
126         int ret = 0;                                                    \
127                                                                         \
128         tstruct;                                                        \
129                                                                         \
130         trace_seq_printf(s, "\nprint fmt: " print);                     \
131                                                                         \
132         return ret;                                                     \
133 }
134
135 #include "trace_entries.h"
136
137 #undef __field
138 #define __field(type, item)                                             \
139         ret = trace_define_field(event_call, #type, #item,              \
140                                  offsetof(typeof(field), item),         \
141                                  sizeof(field.item),                    \
142                                  is_signed_type(type), FILTER_OTHER);   \
143         if (ret)                                                        \
144                 return ret;
145
146 #undef __field_desc
147 #define __field_desc(type, container, item)     \
148         ret = trace_define_field(event_call, #type, #item,              \
149                                  offsetof(typeof(field),                \
150                                           container.item),              \
151                                  sizeof(field.container.item),          \
152                                  is_signed_type(type), FILTER_OTHER);   \
153         if (ret)                                                        \
154                 return ret;
155
156 #undef __array
157 #define __array(type, item, len)                                        \
158         BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
159         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
160                                  offsetof(typeof(field), item),         \
161                                  sizeof(field.item), 0, FILTER_OTHER);  \
162         if (ret)                                                        \
163                 return ret;
164
165 #undef __array_desc
166 #define __array_desc(type, container, item, len)                        \
167         BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
168         ret = trace_define_field(event_call, #type "[" #len "]", #item, \
169                                  offsetof(typeof(field),                \
170                                           container.item),              \
171                                  sizeof(field.container.item), 0,       \
172                                  FILTER_OTHER);                         \
173         if (ret)                                                        \
174                 return ret;
175
176 #undef __dynamic_array
177 #define __dynamic_array(type, item)
178
179 #undef FTRACE_ENTRY
180 #define FTRACE_ENTRY(name, struct_name, id, tstruct, print)             \
181 int                                                                     \
182 ftrace_define_fields_##name(struct ftrace_event_call *event_call)       \
183 {                                                                       \
184         struct struct_name field;                                       \
185         int ret;                                                        \
186                                                                         \
187         ret = trace_define_common_fields(event_call);                   \
188         if (ret)                                                        \
189                 return ret;                                             \
190                                                                         \
191         tstruct;                                                        \
192                                                                         \
193         return ret;                                                     \
194 }
195
196 #include "trace_entries.h"
197
198 static int ftrace_raw_init_event(struct ftrace_event_call *call)
199 {
200         INIT_LIST_HEAD(&call->fields);
201         return 0;
202 }
203
204 #undef __field
205 #define __field(type, item)
206
207 #undef __field_desc
208 #define __field_desc(type, container, item)
209
210 #undef __array
211 #define __array(type, item, len)
212
213 #undef __array_desc
214 #define __array_desc(type, container, item, len)
215
216 #undef __dynamic_array
217 #define __dynamic_array(type, item)
218
219 #undef FTRACE_ENTRY
220 #define FTRACE_ENTRY(call, struct_name, type, tstruct, print)           \
221                                                                         \
222 struct ftrace_event_call __used                                         \
223 __attribute__((__aligned__(4)))                                         \
224 __attribute__((section("_ftrace_events"))) event_##call = {             \
225         .name                   = #call,                                \
226         .id                     = type,                                 \
227         .system                 = __stringify(TRACE_SYSTEM),            \
228         .raw_init               = ftrace_raw_init_event,                \
229         .show_format            = ftrace_format_##call,                 \
230         .define_fields          = ftrace_define_fields_##call,          \
231 };                                                                      \
232
233 #include "trace_entries.h"