blob: f130dacfeef46cd69bc38ac303189f6ee0fd5c91 [file] [log] [blame]
Frederic Weisbecker47788c52009-04-08 20:40:59 +02001#include <trace/syscall.h>
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +01002#include <linux/kernel.h>
Jason Baronfb34a082009-08-10 16:52:47 -04003#include <linux/ftrace.h>
Jason Baronf4b5ffc2009-08-10 16:53:02 -04004#include <linux/perf_counter.h>
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +01005#include <asm/syscall.h>
6
7#include "trace_output.h"
8#include "trace.h"
9
Frederic Weisbecker5be71b62009-03-15 22:10:37 +010010static DEFINE_MUTEX(syscall_trace_lock);
Jason Baronfb34a082009-08-10 16:52:47 -040011static int sys_refcount_enter;
12static int sys_refcount_exit;
13static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
14static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +010015
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010016enum print_line_t
17print_syscall_enter(struct trace_iterator *iter, int flags)
18{
19 struct trace_seq *s = &iter->seq;
20 struct trace_entry *ent = iter->ent;
21 struct syscall_trace_enter *trace;
22 struct syscall_metadata *entry;
23 int i, ret, syscall;
24
Jason Baron64c12e02009-08-10 16:52:53 -040025 trace = (typeof(trace))ent;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010026 syscall = trace->nr;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010027 entry = syscall_nr_to_meta(syscall);
Jason Baron64c12e02009-08-10 16:52:53 -040028
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010029 if (!entry)
30 goto end;
31
Jason Baron64c12e02009-08-10 16:52:53 -040032 if (entry->enter_id != ent->type) {
33 WARN_ON_ONCE(1);
34 goto end;
35 }
36
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010037 ret = trace_seq_printf(s, "%s(", entry->name);
38 if (!ret)
39 return TRACE_TYPE_PARTIAL_LINE;
40
41 for (i = 0; i < entry->nb_args; i++) {
42 /* parameter types */
Li Zefanba8b3a42009-08-17 16:55:18 +080043 if (trace_flags & TRACE_ITER_VERBOSE) {
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010044 ret = trace_seq_printf(s, "%s ", entry->types[i]);
45 if (!ret)
46 return TRACE_TYPE_PARTIAL_LINE;
47 }
48 /* parameter values */
49 ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
50 trace->args[i],
51 i == entry->nb_args - 1 ? ")" : ",");
52 if (!ret)
53 return TRACE_TYPE_PARTIAL_LINE;
54 }
55
56end:
57 trace_seq_printf(s, "\n");
58 return TRACE_TYPE_HANDLED;
59}
60
61enum print_line_t
62print_syscall_exit(struct trace_iterator *iter, int flags)
63{
64 struct trace_seq *s = &iter->seq;
65 struct trace_entry *ent = iter->ent;
66 struct syscall_trace_exit *trace;
67 int syscall;
68 struct syscall_metadata *entry;
69 int ret;
70
Jason Baron64c12e02009-08-10 16:52:53 -040071 trace = (typeof(trace))ent;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010072 syscall = trace->nr;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010073 entry = syscall_nr_to_meta(syscall);
Jason Baron64c12e02009-08-10 16:52:53 -040074
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010075 if (!entry) {
76 trace_seq_printf(s, "\n");
77 return TRACE_TYPE_HANDLED;
78 }
79
Jason Baron64c12e02009-08-10 16:52:53 -040080 if (entry->exit_id != ent->type) {
81 WARN_ON_ONCE(1);
82 return TRACE_TYPE_UNHANDLED;
83 }
84
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +010085 ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
86 trace->ret);
87 if (!ret)
88 return TRACE_TYPE_PARTIAL_LINE;
89
90 return TRACE_TYPE_HANDLED;
91}
92
Frederic Weisbeckerdc4ddb42009-08-11 19:03:54 +020093int ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s)
94{
95 int i;
96 int nr;
97 int ret = 0;
98 struct syscall_metadata *entry;
99 int offset = sizeof(struct trace_entry);
100
101 nr = syscall_name_to_nr((char *)call->data);
102 entry = syscall_nr_to_meta(nr);
103
104 if (!entry)
105 return ret;
106
107 for (i = 0; i < entry->nb_args; i++) {
108 ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
109 entry->args[i]);
110 if (!ret)
111 return 0;
112 ret = trace_seq_printf(s, "\toffset:%d;\tsize:%lu;\n", offset,
113 sizeof(unsigned long));
114 if (!ret)
115 return 0;
116 offset += sizeof(unsigned long);
117 }
118
119 trace_seq_printf(s, "\nprint fmt: \"");
120 for (i = 0; i < entry->nb_args; i++) {
121 ret = trace_seq_printf(s, "%s: 0x%%0%lulx%s", entry->args[i],
122 sizeof(unsigned long),
123 i == entry->nb_args - 1 ? "\", " : ", ");
124 if (!ret)
125 return 0;
126 }
127
128 for (i = 0; i < entry->nb_args; i++) {
129 ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
130 entry->args[i],
131 i == entry->nb_args - 1 ? "\n" : ", ");
132 if (!ret)
133 return 0;
134 }
135
136 return ret;
137}
138
Jason Baronfb34a082009-08-10 16:52:47 -0400139void ftrace_syscall_enter(struct pt_regs *regs, long id)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100140{
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100141 struct syscall_trace_enter *entry;
142 struct syscall_metadata *sys_data;
143 struct ring_buffer_event *event;
144 int size;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100145 int syscall_nr;
146
147 syscall_nr = syscall_get_nr(current, regs);
Jason Baronfb34a082009-08-10 16:52:47 -0400148 if (!test_bit(syscall_nr, enabled_enter_syscalls))
149 return;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100150
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100151 sys_data = syscall_nr_to_meta(syscall_nr);
152 if (!sys_data)
153 return;
154
155 size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
156
Jason Baron64c12e02009-08-10 16:52:53 -0400157 event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100158 0, 0);
159 if (!event)
160 return;
161
162 entry = ring_buffer_event_data(event);
163 entry->nr = syscall_nr;
164 syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
165
166 trace_current_buffer_unlock_commit(event, 0, 0);
167 trace_wake_up();
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100168}
169
Jason Baronfb34a082009-08-10 16:52:47 -0400170void ftrace_syscall_exit(struct pt_regs *regs, long ret)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100171{
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100172 struct syscall_trace_exit *entry;
173 struct syscall_metadata *sys_data;
174 struct ring_buffer_event *event;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100175 int syscall_nr;
176
177 syscall_nr = syscall_get_nr(current, regs);
Jason Baronfb34a082009-08-10 16:52:47 -0400178 if (!test_bit(syscall_nr, enabled_exit_syscalls))
179 return;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100180
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100181 sys_data = syscall_nr_to_meta(syscall_nr);
182 if (!sys_data)
183 return;
184
Jason Baron64c12e02009-08-10 16:52:53 -0400185 event = trace_current_buffer_lock_reserve(sys_data->exit_id,
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100186 sizeof(*entry), 0, 0);
187 if (!event)
188 return;
189
190 entry = ring_buffer_event_data(event);
191 entry->nr = syscall_nr;
192 entry->ret = syscall_get_return_value(current, regs);
193
194 trace_current_buffer_unlock_commit(event, 0, 0);
195 trace_wake_up();
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100196}
197
Jason Baronfb34a082009-08-10 16:52:47 -0400198int reg_event_syscall_enter(void *ptr)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100199{
Jason Baronfb34a082009-08-10 16:52:47 -0400200 int ret = 0;
201 int num;
202 char *name;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100203
Jason Baronfb34a082009-08-10 16:52:47 -0400204 name = (char *)ptr;
205 num = syscall_name_to_nr(name);
206 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
207 return -ENOSYS;
208 mutex_lock(&syscall_trace_lock);
209 if (!sys_refcount_enter)
210 ret = register_trace_syscall_enter(ftrace_syscall_enter);
211 if (ret) {
212 pr_info("event trace: Could not activate"
213 "syscall entry trace point");
214 } else {
215 set_bit(num, enabled_enter_syscalls);
216 sys_refcount_enter++;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100217 }
Jason Baronfb34a082009-08-10 16:52:47 -0400218 mutex_unlock(&syscall_trace_lock);
219 return ret;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100220}
Jason Baronfb34a082009-08-10 16:52:47 -0400221
222void unreg_event_syscall_enter(void *ptr)
223{
224 int num;
225 char *name;
226
227 name = (char *)ptr;
228 num = syscall_name_to_nr(name);
229 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
230 return;
231 mutex_lock(&syscall_trace_lock);
232 sys_refcount_enter--;
233 clear_bit(num, enabled_enter_syscalls);
234 if (!sys_refcount_enter)
235 unregister_trace_syscall_enter(ftrace_syscall_enter);
236 mutex_unlock(&syscall_trace_lock);
237}
238
239int reg_event_syscall_exit(void *ptr)
240{
241 int ret = 0;
242 int num;
243 char *name;
244
245 name = (char *)ptr;
246 num = syscall_name_to_nr(name);
247 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
248 return -ENOSYS;
249 mutex_lock(&syscall_trace_lock);
250 if (!sys_refcount_exit)
251 ret = register_trace_syscall_exit(ftrace_syscall_exit);
252 if (ret) {
253 pr_info("event trace: Could not activate"
254 "syscall exit trace point");
255 } else {
256 set_bit(num, enabled_exit_syscalls);
257 sys_refcount_exit++;
258 }
259 mutex_unlock(&syscall_trace_lock);
260 return ret;
261}
262
263void unreg_event_syscall_exit(void *ptr)
264{
265 int num;
266 char *name;
267
268 name = (char *)ptr;
269 num = syscall_name_to_nr(name);
270 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
271 return;
272 mutex_lock(&syscall_trace_lock);
273 sys_refcount_exit--;
274 clear_bit(num, enabled_exit_syscalls);
275 if (!sys_refcount_exit)
276 unregister_trace_syscall_exit(ftrace_syscall_exit);
277 mutex_unlock(&syscall_trace_lock);
278}
279
280struct trace_event event_syscall_enter = {
281 .trace = print_syscall_enter,
Jason Baronfb34a082009-08-10 16:52:47 -0400282};
283
284struct trace_event event_syscall_exit = {
285 .trace = print_syscall_exit,
Jason Baronfb34a082009-08-10 16:52:47 -0400286};
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400287
288#ifdef CONFIG_EVENT_PROFILE
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200289
290struct syscall_enter_record {
291 struct trace_entry entry;
292 unsigned long args[0];
293};
294
295struct syscall_exit_record {
296 struct trace_entry entry;
297 unsigned long ret;
298};
299
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400300static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
301static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
302static int sys_prof_refcount_enter;
303static int sys_prof_refcount_exit;
304
305static void prof_syscall_enter(struct pt_regs *regs, long id)
306{
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200307 struct syscall_enter_record *rec;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400308 struct syscall_metadata *sys_data;
309 int syscall_nr;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200310 int size;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400311
312 syscall_nr = syscall_get_nr(current, regs);
313 if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
314 return;
315
316 sys_data = syscall_nr_to_meta(syscall_nr);
317 if (!sys_data)
318 return;
319
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200320 /* get the size after alignment with the u32 buffer size field */
321 size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
322 size = ALIGN(size + sizeof(u32), sizeof(u64));
323 size -= sizeof(u32);
324
325 do {
326 char raw_data[size];
327
328 /* zero the dead bytes from align to not leak stack to user */
329 *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
330
331 rec = (struct syscall_enter_record *) raw_data;
332 tracing_generic_entry_update(&rec->entry, 0, 0);
333 rec->entry.type = sys_data->enter_id;
334 syscall_get_arguments(current, regs, 0, sys_data->nb_args,
335 (unsigned long *)&rec->args);
336 perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
337 } while(0);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400338}
339
340int reg_prof_syscall_enter(char *name)
341{
342 int ret = 0;
343 int num;
344
345 num = syscall_name_to_nr(name);
346 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
347 return -ENOSYS;
348
349 mutex_lock(&syscall_trace_lock);
350 if (!sys_prof_refcount_enter)
351 ret = register_trace_syscall_enter(prof_syscall_enter);
352 if (ret) {
353 pr_info("event trace: Could not activate"
354 "syscall entry trace point");
355 } else {
356 set_bit(num, enabled_prof_enter_syscalls);
357 sys_prof_refcount_enter++;
358 }
359 mutex_unlock(&syscall_trace_lock);
360 return ret;
361}
362
363void unreg_prof_syscall_enter(char *name)
364{
365 int num;
366
367 num = syscall_name_to_nr(name);
368 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
369 return;
370
371 mutex_lock(&syscall_trace_lock);
372 sys_prof_refcount_enter--;
373 clear_bit(num, enabled_prof_enter_syscalls);
374 if (!sys_prof_refcount_enter)
375 unregister_trace_syscall_enter(prof_syscall_enter);
376 mutex_unlock(&syscall_trace_lock);
377}
378
379static void prof_syscall_exit(struct pt_regs *regs, long ret)
380{
381 struct syscall_metadata *sys_data;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200382 struct syscall_exit_record rec;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400383 int syscall_nr;
384
385 syscall_nr = syscall_get_nr(current, regs);
386 if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
387 return;
388
389 sys_data = syscall_nr_to_meta(syscall_nr);
390 if (!sys_data)
391 return;
392
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200393 tracing_generic_entry_update(&rec.entry, 0, 0);
394 rec.entry.type = sys_data->exit_id;
395 rec.ret = syscall_get_return_value(current, regs);
396
397 perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400398}
399
400int reg_prof_syscall_exit(char *name)
401{
402 int ret = 0;
403 int num;
404
405 num = syscall_name_to_nr(name);
406 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
407 return -ENOSYS;
408
409 mutex_lock(&syscall_trace_lock);
410 if (!sys_prof_refcount_exit)
411 ret = register_trace_syscall_exit(prof_syscall_exit);
412 if (ret) {
413 pr_info("event trace: Could not activate"
414 "syscall entry trace point");
415 } else {
416 set_bit(num, enabled_prof_exit_syscalls);
417 sys_prof_refcount_exit++;
418 }
419 mutex_unlock(&syscall_trace_lock);
420 return ret;
421}
422
423void unreg_prof_syscall_exit(char *name)
424{
425 int num;
426
427 num = syscall_name_to_nr(name);
428 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
429 return;
430
431 mutex_lock(&syscall_trace_lock);
432 sys_prof_refcount_exit--;
433 clear_bit(num, enabled_prof_exit_syscalls);
434 if (!sys_prof_refcount_exit)
435 unregister_trace_syscall_exit(prof_syscall_exit);
436 mutex_unlock(&syscall_trace_lock);
437}
438
439#endif
440
441