blob: e4b6d11bdf78f35a2a6d8e831cd3ec21d97d9c00 [file] [log] [blame]
Frederic Weisbecker47788c52009-04-08 20:40:59 +02001#include <trace/syscall.h>
Josh Stone1c569f02009-08-24 14:43:14 -07002#include <trace/events/syscalls.h>
Steven Rostedtf431b632013-02-12 16:18:59 -05003#include <linux/syscalls.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09004#include <linux/slab.h>
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +01005#include <linux/kernel.h>
Paul Gortmaker56d82e02011-05-26 17:53:52 -04006#include <linux/module.h> /* for MODULE_NAME_LEN via KSYM_SYMBOL_LEN */
Jason Baronfb34a082009-08-10 16:52:47 -04007#include <linux/ftrace.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +02008#include <linux/perf_event.h>
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +01009#include <asm/syscall.h>
10
11#include "trace_output.h"
12#include "trace.h"
13
Frederic Weisbecker5be71b62009-03-15 22:10:37 +010014static DEFINE_MUTEX(syscall_trace_lock);
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +010015
Steven Rostedt22392912010-04-21 12:27:06 -040016static int syscall_enter_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +010017 enum trace_reg type, void *data);
Steven Rostedt22392912010-04-21 12:27:06 -040018static int syscall_exit_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +010019 enum trace_reg type, void *data);
Steven Rostedt22392912010-04-21 12:27:06 -040020
Steven Rostedt2e33af02010-04-22 10:35:55 -040021static struct list_head *
22syscall_get_enter_fields(struct ftrace_event_call *call)
23{
24 struct syscall_metadata *entry = call->data;
25
26 return &entry->enter_fields;
27}
28
Steven Rostedt3d56e332011-02-02 17:06:09 -050029extern struct syscall_metadata *__start_syscalls_metadata[];
30extern struct syscall_metadata *__stop_syscalls_metadata[];
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020031
32static struct syscall_metadata **syscalls_metadata;
33
Ian Munsieb2d55492011-02-03 14:27:23 +110034#ifndef ARCH_HAS_SYSCALL_MATCH_SYM_NAME
35static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
36{
37 /*
38 * Only compare after the "sys" prefix. Archs that use
39 * syscall wrappers may have syscalls symbols aliases prefixed
zhangwei(Jovi)36a78e92013-03-11 15:13:51 +080040 * with ".SyS" or ".sys" instead of "sys", leading to an unwanted
Ian Munsieb2d55492011-02-03 14:27:23 +110041 * mismatch.
42 */
43 return !strcmp(sym + 3, name + 3);
44}
45#endif
46
Steven Rostedtf431b632013-02-12 16:18:59 -050047#ifdef ARCH_TRACE_IGNORE_COMPAT_SYSCALLS
48/*
49 * Some architectures that allow for 32bit applications
50 * to run on a 64bit kernel, do not map the syscalls for
51 * the 32bit tasks the same as they do for 64bit tasks.
52 *
53 * *cough*x86*cough*
54 *
55 * In such a case, instead of reporting the wrong syscalls,
56 * simply ignore them.
57 *
58 * For an arch to ignore the compat syscalls it needs to
59 * define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS as well as
60 * define the function arch_trace_is_compat_syscall() to let
61 * the tracing system know that it should ignore it.
62 */
63static int
64trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
65{
66 if (unlikely(arch_trace_is_compat_syscall(regs)))
67 return -1;
68
69 return syscall_get_nr(task, regs);
70}
71#else
72static inline int
73trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
74{
75 return syscall_get_nr(task, regs);
76}
77#endif /* ARCH_TRACE_IGNORE_COMPAT_SYSCALLS */
78
Steven Rostedt3d56e332011-02-02 17:06:09 -050079static __init struct syscall_metadata *
80find_syscall_meta(unsigned long syscall)
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020081{
Steven Rostedt3d56e332011-02-02 17:06:09 -050082 struct syscall_metadata **start;
83 struct syscall_metadata **stop;
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020084 char str[KSYM_SYMBOL_LEN];
85
86
Steven Rostedt3d56e332011-02-02 17:06:09 -050087 start = __start_syscalls_metadata;
88 stop = __stop_syscalls_metadata;
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020089 kallsyms_lookup(syscall, NULL, NULL, NULL, str);
90
Ian Munsieae07f552011-02-03 14:27:25 +110091 if (arch_syscall_match_sym_name(str, "sys_ni_syscall"))
92 return NULL;
93
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020094 for ( ; start < stop; start++) {
Ian Munsieb2d55492011-02-03 14:27:23 +110095 if ((*start)->name && arch_syscall_match_sym_name(str, (*start)->name))
Steven Rostedt3d56e332011-02-02 17:06:09 -050096 return *start;
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +020097 }
98 return NULL;
99}
100
101static struct syscall_metadata *syscall_nr_to_meta(int nr)
102{
103 if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
104 return NULL;
105
106 return syscalls_metadata[nr];
107}
108
Fengguang Wu6aea49c2012-11-21 15:13:47 +0800109static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400110print_syscall_enter(struct trace_iterator *iter, int flags,
111 struct trace_event *event)
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100112{
113 struct trace_seq *s = &iter->seq;
114 struct trace_entry *ent = iter->ent;
115 struct syscall_trace_enter *trace;
116 struct syscall_metadata *entry;
117 int i, ret, syscall;
118
Jason Baron64c12e02009-08-10 16:52:53 -0400119 trace = (typeof(trace))ent;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100120 syscall = trace->nr;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100121 entry = syscall_nr_to_meta(syscall);
Jason Baron64c12e02009-08-10 16:52:53 -0400122
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100123 if (!entry)
124 goto end;
125
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400126 if (entry->enter_event->event.type != ent->type) {
Jason Baron64c12e02009-08-10 16:52:53 -0400127 WARN_ON_ONCE(1);
128 goto end;
129 }
130
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100131 ret = trace_seq_printf(s, "%s(", entry->name);
132 if (!ret)
133 return TRACE_TYPE_PARTIAL_LINE;
134
135 for (i = 0; i < entry->nb_args; i++) {
136 /* parameter types */
Li Zefanba8b3a42009-08-17 16:55:18 +0800137 if (trace_flags & TRACE_ITER_VERBOSE) {
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100138 ret = trace_seq_printf(s, "%s ", entry->types[i]);
139 if (!ret)
140 return TRACE_TYPE_PARTIAL_LINE;
141 }
142 /* parameter values */
Li Zefan4539f072009-08-20 16:13:35 +0800143 ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100144 trace->args[i],
Li Zefan4539f072009-08-20 16:13:35 +0800145 i == entry->nb_args - 1 ? "" : ", ");
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100146 if (!ret)
147 return TRACE_TYPE_PARTIAL_LINE;
148 }
149
Li Zefan4539f072009-08-20 16:13:35 +0800150 ret = trace_seq_putc(s, ')');
151 if (!ret)
152 return TRACE_TYPE_PARTIAL_LINE;
153
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100154end:
Li Zefan4539f072009-08-20 16:13:35 +0800155 ret = trace_seq_putc(s, '\n');
156 if (!ret)
157 return TRACE_TYPE_PARTIAL_LINE;
158
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100159 return TRACE_TYPE_HANDLED;
160}
161
Fengguang Wu6aea49c2012-11-21 15:13:47 +0800162static enum print_line_t
Steven Rostedta9a57762010-04-22 18:46:14 -0400163print_syscall_exit(struct trace_iterator *iter, int flags,
164 struct trace_event *event)
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100165{
166 struct trace_seq *s = &iter->seq;
167 struct trace_entry *ent = iter->ent;
168 struct syscall_trace_exit *trace;
169 int syscall;
170 struct syscall_metadata *entry;
171 int ret;
172
Jason Baron64c12e02009-08-10 16:52:53 -0400173 trace = (typeof(trace))ent;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100174 syscall = trace->nr;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100175 entry = syscall_nr_to_meta(syscall);
Jason Baron64c12e02009-08-10 16:52:53 -0400176
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100177 if (!entry) {
zhangwei(Jovi)146c3442013-07-15 16:32:44 +0800178 trace_seq_putc(s, '\n');
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100179 return TRACE_TYPE_HANDLED;
180 }
181
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400182 if (entry->exit_event->event.type != ent->type) {
Jason Baron64c12e02009-08-10 16:52:53 -0400183 WARN_ON_ONCE(1);
184 return TRACE_TYPE_UNHANDLED;
185 }
186
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100187 ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
188 trace->ret);
189 if (!ret)
190 return TRACE_TYPE_PARTIAL_LINE;
191
192 return TRACE_TYPE_HANDLED;
193}
194
Li Zefane6971962009-08-19 15:52:25 +0800195extern char *__bad_type_size(void);
196
197#define SYSCALL_FIELD(type, name) \
198 sizeof(type) != sizeof(trace.name) ? \
199 __bad_type_size() : \
Tom Zanussi26a50742009-10-06 01:09:50 -0500200 #type, #name, offsetof(typeof(trace), name), \
201 sizeof(trace.name), is_signed_type(type)
Li Zefane6971962009-08-19 15:52:25 +0800202
Li Zefan3ddc77f2013-03-27 14:15:37 +0800203static int __init
204__set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
Lai Jiangshan50307a42009-12-15 15:39:45 +0800205{
206 int i;
207 int pos = 0;
208
209 /* When len=0, we just calculate the needed length */
210#define LEN_OR_ZERO (len ? len - pos : 0)
211
212 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
213 for (i = 0; i < entry->nb_args; i++) {
214 pos += snprintf(buf + pos, LEN_OR_ZERO, "%s: 0x%%0%zulx%s",
215 entry->args[i], sizeof(unsigned long),
216 i == entry->nb_args - 1 ? "" : ", ");
217 }
218 pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
219
220 for (i = 0; i < entry->nb_args; i++) {
221 pos += snprintf(buf + pos, LEN_OR_ZERO,
222 ", ((unsigned long)(REC->%s))", entry->args[i]);
223 }
224
225#undef LEN_OR_ZERO
226
227 /* return the length of print_fmt */
228 return pos;
229}
230
Li Zefan3ddc77f2013-03-27 14:15:37 +0800231static int __init set_syscall_print_fmt(struct ftrace_event_call *call)
Lai Jiangshan50307a42009-12-15 15:39:45 +0800232{
233 char *print_fmt;
234 int len;
235 struct syscall_metadata *entry = call->data;
236
237 if (entry->enter_event != call) {
238 call->print_fmt = "\"0x%lx\", REC->ret";
239 return 0;
240 }
241
242 /* First: called with 0 length to calculate the needed length */
243 len = __set_enter_print_fmt(entry, NULL, 0);
244
245 print_fmt = kmalloc(len + 1, GFP_KERNEL);
246 if (!print_fmt)
247 return -ENOMEM;
248
249 /* Second: actually write the @print_fmt */
250 __set_enter_print_fmt(entry, print_fmt, len + 1);
251 call->print_fmt = print_fmt;
252
253 return 0;
254}
255
Li Zefan3ddc77f2013-03-27 14:15:37 +0800256static void __init free_syscall_print_fmt(struct ftrace_event_call *call)
Lai Jiangshan50307a42009-12-15 15:39:45 +0800257{
258 struct syscall_metadata *entry = call->data;
259
260 if (entry->enter_event == call)
261 kfree(call->print_fmt);
262}
263
Li Zefanb8aae392013-02-21 10:33:58 +0800264static int __init syscall_enter_define_fields(struct ftrace_event_call *call)
Li Zefan540b7b82009-08-19 15:54:51 +0800265{
266 struct syscall_trace_enter trace;
Lai Jiangshan31c16b12009-12-01 16:23:30 +0800267 struct syscall_metadata *meta = call->data;
Li Zefan540b7b82009-08-19 15:54:51 +0800268 int ret;
Li Zefan540b7b82009-08-19 15:54:51 +0800269 int i;
270 int offset = offsetof(typeof(trace), args);
271
Lai Jiangshan0f1ef512009-11-26 15:49:33 +0800272 ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
273 if (ret)
274 return ret;
275
Li Zefan540b7b82009-08-19 15:54:51 +0800276 for (i = 0; i < meta->nb_args; i++) {
Frederic Weisbeckeraeaeae12009-08-27 05:09:51 +0200277 ret = trace_define_field(call, meta->types[i],
278 meta->args[i], offset,
Li Zefan43b51ea2009-08-07 10:33:22 +0800279 sizeof(unsigned long), 0,
280 FILTER_OTHER);
Li Zefan540b7b82009-08-19 15:54:51 +0800281 offset += sizeof(unsigned long);
282 }
283
284 return ret;
285}
286
Li Zefanb8aae392013-02-21 10:33:58 +0800287static int __init syscall_exit_define_fields(struct ftrace_event_call *call)
Li Zefan540b7b82009-08-19 15:54:51 +0800288{
289 struct syscall_trace_exit trace;
290 int ret;
291
Lai Jiangshan0f1ef512009-11-26 15:49:33 +0800292 ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
293 if (ret)
294 return ret;
295
Tom Zanussi26a50742009-10-06 01:09:50 -0500296 ret = trace_define_field(call, SYSCALL_FIELD(long, ret),
Li Zefan43b51ea2009-08-07 10:33:22 +0800297 FILTER_OTHER);
Li Zefan540b7b82009-08-19 15:54:51 +0800298
299 return ret;
300}
301
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400302static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100303{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400304 struct trace_array *tr = data;
Tom Zanussid562aff2013-10-24 08:34:19 -0500305 struct ftrace_event_file *ftrace_file;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100306 struct syscall_trace_enter *entry;
307 struct syscall_metadata *sys_data;
308 struct ring_buffer_event *event;
Steven Rostedte77405a2009-09-02 14:17:06 -0400309 struct ring_buffer *buffer;
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800310 unsigned long irq_flags;
311 int pc;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100312 int syscall_nr;
Steven Rostedtf431b632013-02-12 16:18:59 -0500313 int size;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100314
Steven Rostedtf431b632013-02-12 16:18:59 -0500315 syscall_nr = trace_get_syscall_nr(current, regs);
Hendrik Bruecknercd0980f2009-08-25 14:50:27 +0200316 if (syscall_nr < 0)
317 return;
Tom Zanussid562aff2013-10-24 08:34:19 -0500318
319 /* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE) */
320 ftrace_file = rcu_dereference_sched(tr->enter_syscall_files[syscall_nr]);
321 if (!ftrace_file)
322 return;
323
324 if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &ftrace_file->flags))
Jason Baronfb34a082009-08-10 16:52:47 -0400325 return;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100326
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100327 sys_data = syscall_nr_to_meta(syscall_nr);
328 if (!sys_data)
329 return;
330
331 size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
332
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800333 local_save_flags(irq_flags);
334 pc = preempt_count();
335
Steven Rostedt (Red Hat)12883ef2013-03-05 09:24:35 -0500336 buffer = tr->trace_buffer.buffer;
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400337 event = trace_buffer_lock_reserve(buffer,
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800338 sys_data->enter_event->event.type, size, irq_flags, pc);
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100339 if (!event)
340 return;
341
342 entry = ring_buffer_event_data(event);
343 entry->nr = syscall_nr;
344 syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
345
Tom Zanussid562aff2013-10-24 08:34:19 -0500346 if (!filter_check_discard(ftrace_file, entry, buffer, event))
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800347 trace_current_buffer_unlock_commit(buffer, event,
348 irq_flags, pc);
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100349}
350
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400351static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100352{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400353 struct trace_array *tr = data;
Tom Zanussid562aff2013-10-24 08:34:19 -0500354 struct ftrace_event_file *ftrace_file;
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100355 struct syscall_trace_exit *entry;
356 struct syscall_metadata *sys_data;
357 struct ring_buffer_event *event;
Steven Rostedte77405a2009-09-02 14:17:06 -0400358 struct ring_buffer *buffer;
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800359 unsigned long irq_flags;
360 int pc;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100361 int syscall_nr;
362
Steven Rostedtf431b632013-02-12 16:18:59 -0500363 syscall_nr = trace_get_syscall_nr(current, regs);
Hendrik Bruecknercd0980f2009-08-25 14:50:27 +0200364 if (syscall_nr < 0)
365 return;
Tom Zanussid562aff2013-10-24 08:34:19 -0500366
367 /* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE()) */
368 ftrace_file = rcu_dereference_sched(tr->exit_syscall_files[syscall_nr]);
369 if (!ftrace_file)
370 return;
371
372 if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &ftrace_file->flags))
Jason Baronfb34a082009-08-10 16:52:47 -0400373 return;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100374
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100375 sys_data = syscall_nr_to_meta(syscall_nr);
376 if (!sys_data)
377 return;
378
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800379 local_save_flags(irq_flags);
380 pc = preempt_count();
381
Steven Rostedt (Red Hat)12883ef2013-03-05 09:24:35 -0500382 buffer = tr->trace_buffer.buffer;
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400383 event = trace_buffer_lock_reserve(buffer,
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800384 sys_data->exit_event->event.type, sizeof(*entry),
385 irq_flags, pc);
Frederic Weisbeckerbed1ffc2009-03-13 15:42:11 +0100386 if (!event)
387 return;
388
389 entry = ring_buffer_event_data(event);
390 entry->nr = syscall_nr;
391 entry->ret = syscall_get_return_value(current, regs);
392
Tom Zanussid562aff2013-10-24 08:34:19 -0500393 if (!filter_check_discard(ftrace_file, entry, buffer, event))
zhangwei(Jovi)11034ae2013-04-10 11:26:23 +0800394 trace_current_buffer_unlock_commit(buffer, event,
395 irq_flags, pc);
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100396}
397
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400398static int reg_event_syscall_enter(struct ftrace_event_file *file,
399 struct ftrace_event_call *call)
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100400{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400401 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400402 int ret = 0;
403 int num;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100404
Lai Jiangshanc252f652009-12-01 16:23:47 +0800405 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100406 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400407 return -ENOSYS;
408 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400409 if (!tr->sys_refcount_enter)
410 ret = register_trace_sys_enter(ftrace_syscall_enter, tr);
Li Zefan3b8e4272009-12-08 11:14:52 +0800411 if (!ret) {
Tom Zanussid562aff2013-10-24 08:34:19 -0500412 rcu_assign_pointer(tr->enter_syscall_files[num], file);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400413 tr->sys_refcount_enter++;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100414 }
Jason Baronfb34a082009-08-10 16:52:47 -0400415 mutex_unlock(&syscall_trace_lock);
416 return ret;
Frederic Weisbeckeree08c6e2009-03-07 05:52:59 +0100417}
Jason Baronfb34a082009-08-10 16:52:47 -0400418
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400419static void unreg_event_syscall_enter(struct ftrace_event_file *file,
420 struct ftrace_event_call *call)
Jason Baronfb34a082009-08-10 16:52:47 -0400421{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400422 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400423 int num;
Jason Baronfb34a082009-08-10 16:52:47 -0400424
Lai Jiangshanc252f652009-12-01 16:23:47 +0800425 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100426 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400427 return;
428 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400429 tr->sys_refcount_enter--;
Tom Zanussid562aff2013-10-24 08:34:19 -0500430 rcu_assign_pointer(tr->enter_syscall_files[num], NULL);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400431 if (!tr->sys_refcount_enter)
432 unregister_trace_sys_enter(ftrace_syscall_enter, tr);
Jason Baronfb34a082009-08-10 16:52:47 -0400433 mutex_unlock(&syscall_trace_lock);
Tom Zanussid562aff2013-10-24 08:34:19 -0500434 /*
435 * Callers expect the event to be completely disabled on
436 * return, so wait for current handlers to finish.
437 */
438 synchronize_sched();
Jason Baronfb34a082009-08-10 16:52:47 -0400439}
440
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400441static int reg_event_syscall_exit(struct ftrace_event_file *file,
442 struct ftrace_event_call *call)
Jason Baronfb34a082009-08-10 16:52:47 -0400443{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400444 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400445 int ret = 0;
446 int num;
Jason Baronfb34a082009-08-10 16:52:47 -0400447
Lai Jiangshanc252f652009-12-01 16:23:47 +0800448 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100449 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400450 return -ENOSYS;
451 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400452 if (!tr->sys_refcount_exit)
453 ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
Li Zefan3b8e4272009-12-08 11:14:52 +0800454 if (!ret) {
Tom Zanussid562aff2013-10-24 08:34:19 -0500455 rcu_assign_pointer(tr->exit_syscall_files[num], file);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400456 tr->sys_refcount_exit++;
Jason Baronfb34a082009-08-10 16:52:47 -0400457 }
458 mutex_unlock(&syscall_trace_lock);
459 return ret;
460}
461
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400462static void unreg_event_syscall_exit(struct ftrace_event_file *file,
463 struct ftrace_event_call *call)
Jason Baronfb34a082009-08-10 16:52:47 -0400464{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400465 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400466 int num;
Jason Baronfb34a082009-08-10 16:52:47 -0400467
Lai Jiangshanc252f652009-12-01 16:23:47 +0800468 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100469 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400470 return;
471 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400472 tr->sys_refcount_exit--;
Tom Zanussid562aff2013-10-24 08:34:19 -0500473 rcu_assign_pointer(tr->exit_syscall_files[num], NULL);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400474 if (!tr->sys_refcount_exit)
475 unregister_trace_sys_exit(ftrace_syscall_exit, tr);
Jason Baronfb34a082009-08-10 16:52:47 -0400476 mutex_unlock(&syscall_trace_lock);
Tom Zanussid562aff2013-10-24 08:34:19 -0500477 /*
478 * Callers expect the event to be completely disabled on
479 * return, so wait for current handlers to finish.
480 */
481 synchronize_sched();
Jason Baronfb34a082009-08-10 16:52:47 -0400482}
483
Li Zefan3ddc77f2013-03-27 14:15:37 +0800484static int __init init_syscall_trace(struct ftrace_event_call *call)
Lai Jiangshana1301da2009-12-01 16:23:55 +0800485{
486 int id;
Ian Munsieba976972011-02-03 14:27:20 +1100487 int num;
488
489 num = ((struct syscall_metadata *)call->data)->syscall_nr;
490 if (num < 0 || num >= NR_syscalls) {
491 pr_debug("syscall %s metadata not mapped, disabling ftrace event\n",
492 ((struct syscall_metadata *)call->data)->name);
493 return -ENOSYS;
494 }
Lai Jiangshana1301da2009-12-01 16:23:55 +0800495
Lai Jiangshan50307a42009-12-15 15:39:45 +0800496 if (set_syscall_print_fmt(call) < 0)
497 return -ENOMEM;
498
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500499 id = trace_event_raw_init(call);
500
501 if (id < 0) {
Lai Jiangshan50307a42009-12-15 15:39:45 +0800502 free_syscall_print_fmt(call);
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500503 return id;
Lai Jiangshan50307a42009-12-15 15:39:45 +0800504 }
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500505
506 return id;
Lai Jiangshana1301da2009-12-01 16:23:55 +0800507}
508
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700509struct trace_event_functions enter_syscall_print_funcs = {
510 .trace = print_syscall_enter,
511};
512
513struct trace_event_functions exit_syscall_print_funcs = {
514 .trace = print_syscall_exit,
515};
516
Li Zefan523c8112013-03-04 14:15:59 +0800517struct ftrace_event_class __refdata event_class_syscall_enter = {
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700518 .system = "syscalls",
519 .reg = syscall_enter_register,
520 .define_fields = syscall_enter_define_fields,
521 .get_fields = syscall_get_enter_fields,
522 .raw_init = init_syscall_trace,
523};
524
Li Zefan523c8112013-03-04 14:15:59 +0800525struct ftrace_event_class __refdata event_class_syscall_exit = {
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700526 .system = "syscalls",
527 .reg = syscall_exit_register,
528 .define_fields = syscall_exit_define_fields,
529 .fields = LIST_HEAD_INIT(event_class_syscall_exit.fields),
530 .raw_init = init_syscall_trace,
531};
532
Ian Munsiec763ba02011-02-03 14:27:22 +1100533unsigned long __init __weak arch_syscall_addr(int nr)
Mike Frysingere7b8e672010-01-26 04:40:03 -0500534{
535 return (unsigned long)sys_call_table[nr];
536}
537
Fengguang Wu6aea49c2012-11-21 15:13:47 +0800538static int __init init_ftrace_syscalls(void)
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200539{
540 struct syscall_metadata *meta;
541 unsigned long addr;
542 int i;
543
Thomas Meyer47b0edc2011-11-29 22:08:00 +0100544 syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
545 GFP_KERNEL);
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200546 if (!syscalls_metadata) {
547 WARN_ON(1);
548 return -ENOMEM;
549 }
550
551 for (i = 0; i < NR_syscalls; i++) {
552 addr = arch_syscall_addr(i);
553 meta = find_syscall_meta(addr);
Lai Jiangshanc252f652009-12-01 16:23:47 +0800554 if (!meta)
555 continue;
556
557 meta->syscall_nr = i;
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200558 syscalls_metadata[i] = meta;
559 }
560
561 return 0;
562}
Ezequiel Garcia87819152012-09-12 11:47:57 -0300563early_initcall(init_ftrace_syscalls);
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200564
Li Zefan07b139c2009-12-21 14:27:35 +0800565#ifdef CONFIG_PERF_EVENTS
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200566
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100567static DECLARE_BITMAP(enabled_perf_enter_syscalls, NR_syscalls);
568static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);
569static int sys_perf_refcount_enter;
570static int sys_perf_refcount_exit;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400571
Steven Rostedt38516ab2010-04-20 17:04:50 -0400572static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400573{
574 struct syscall_metadata *sys_data;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200575 struct syscall_trace_enter *rec;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200576 struct hlist_head *head;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400577 int syscall_nr;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100578 int rctx;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200579 int size;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400580
Steven Rostedtf431b632013-02-12 16:18:59 -0500581 syscall_nr = trace_get_syscall_nr(current, regs);
Will Deacon60916a92012-08-16 18:14:14 +0100582 if (syscall_nr < 0)
583 return;
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100584 if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400585 return;
586
587 sys_data = syscall_nr_to_meta(syscall_nr);
588 if (!sys_data)
589 return;
590
Oleg Nesterov421c7862013-06-17 19:02:07 +0200591 head = this_cpu_ptr(sys_data->enter_event->perf_events);
592 if (hlist_empty(head))
593 return;
594
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200595 /* get the size after alignment with the u32 buffer size field */
596 size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
597 size = ALIGN(size + sizeof(u32), sizeof(u64));
598 size -= sizeof(u32);
599
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100600 rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
Steven Rostedtff5f1492010-05-21 11:49:57 -0400601 sys_data->enter_event->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800602 if (!rec)
603 return;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200604
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200605 rec->nr = syscall_nr;
606 syscall_get_arguments(current, regs, 0, sys_data->nb_args,
607 (unsigned long *)&rec->args);
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400608 perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400609}
610
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700611static int perf_sysenter_enable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400612{
613 int ret = 0;
614 int num;
615
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800616 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400617
618 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100619 if (!sys_perf_refcount_enter)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400620 ret = register_trace_sys_enter(perf_syscall_enter, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400621 if (ret) {
622 pr_info("event trace: Could not activate"
623 "syscall entry trace point");
624 } else {
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100625 set_bit(num, enabled_perf_enter_syscalls);
626 sys_perf_refcount_enter++;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400627 }
628 mutex_unlock(&syscall_trace_lock);
629 return ret;
630}
631
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700632static void perf_sysenter_disable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400633{
634 int num;
635
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800636 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400637
638 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100639 sys_perf_refcount_enter--;
640 clear_bit(num, enabled_perf_enter_syscalls);
641 if (!sys_perf_refcount_enter)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400642 unregister_trace_sys_enter(perf_syscall_enter, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400643 mutex_unlock(&syscall_trace_lock);
644}
645
Steven Rostedt38516ab2010-04-20 17:04:50 -0400646static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400647{
648 struct syscall_metadata *sys_data;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200649 struct syscall_trace_exit *rec;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200650 struct hlist_head *head;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400651 int syscall_nr;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100652 int rctx;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200653 int size;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400654
Steven Rostedtf431b632013-02-12 16:18:59 -0500655 syscall_nr = trace_get_syscall_nr(current, regs);
Will Deacon60916a92012-08-16 18:14:14 +0100656 if (syscall_nr < 0)
657 return;
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100658 if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400659 return;
660
661 sys_data = syscall_nr_to_meta(syscall_nr);
662 if (!sys_data)
663 return;
664
Oleg Nesterov421c7862013-06-17 19:02:07 +0200665 head = this_cpu_ptr(sys_data->exit_event->perf_events);
666 if (hlist_empty(head))
667 return;
668
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200669 /* We can probably do that at build time */
670 size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
671 size -= sizeof(u32);
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200672
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100673 rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
Steven Rostedtff5f1492010-05-21 11:49:57 -0400674 sys_data->exit_event->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800675 if (!rec)
676 return;
Frederic Weisbeckerce71b9d2009-11-22 05:26:55 +0100677
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200678 rec->nr = syscall_nr;
679 rec->ret = syscall_get_return_value(current, regs);
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400680 perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400681}
682
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700683static int perf_sysexit_enable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400684{
685 int ret = 0;
686 int num;
687
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800688 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400689
690 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100691 if (!sys_perf_refcount_exit)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400692 ret = register_trace_sys_exit(perf_syscall_exit, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400693 if (ret) {
694 pr_info("event trace: Could not activate"
Wenji Huang65746582010-02-24 15:40:22 +0800695 "syscall exit trace point");
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400696 } else {
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100697 set_bit(num, enabled_perf_exit_syscalls);
698 sys_perf_refcount_exit++;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400699 }
700 mutex_unlock(&syscall_trace_lock);
701 return ret;
702}
703
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700704static void perf_sysexit_disable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400705{
706 int num;
707
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800708 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400709
710 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100711 sys_perf_refcount_exit--;
712 clear_bit(num, enabled_perf_exit_syscalls);
713 if (!sys_perf_refcount_exit)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400714 unregister_trace_sys_exit(perf_syscall_exit, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400715 mutex_unlock(&syscall_trace_lock);
716}
717
Li Zefan07b139c2009-12-21 14:27:35 +0800718#endif /* CONFIG_PERF_EVENTS */
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400719
Steven Rostedt22392912010-04-21 12:27:06 -0400720static int syscall_enter_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100721 enum trace_reg type, void *data)
Steven Rostedt22392912010-04-21 12:27:06 -0400722{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400723 struct ftrace_event_file *file = data;
724
Steven Rostedt22392912010-04-21 12:27:06 -0400725 switch (type) {
726 case TRACE_REG_REGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400727 return reg_event_syscall_enter(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400728 case TRACE_REG_UNREGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400729 unreg_event_syscall_enter(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400730 return 0;
731
732#ifdef CONFIG_PERF_EVENTS
733 case TRACE_REG_PERF_REGISTER:
734 return perf_sysenter_enable(event);
735 case TRACE_REG_PERF_UNREGISTER:
736 perf_sysenter_disable(event);
737 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +0100738 case TRACE_REG_PERF_OPEN:
739 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +0100740 case TRACE_REG_PERF_ADD:
741 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +0100742 return 0;
Steven Rostedt22392912010-04-21 12:27:06 -0400743#endif
744 }
745 return 0;
746}
747
748static int syscall_exit_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100749 enum trace_reg type, void *data)
Steven Rostedt22392912010-04-21 12:27:06 -0400750{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400751 struct ftrace_event_file *file = data;
752
Steven Rostedt22392912010-04-21 12:27:06 -0400753 switch (type) {
754 case TRACE_REG_REGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400755 return reg_event_syscall_exit(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400756 case TRACE_REG_UNREGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400757 unreg_event_syscall_exit(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400758 return 0;
759
760#ifdef CONFIG_PERF_EVENTS
761 case TRACE_REG_PERF_REGISTER:
762 return perf_sysexit_enable(event);
763 case TRACE_REG_PERF_UNREGISTER:
764 perf_sysexit_disable(event);
765 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +0100766 case TRACE_REG_PERF_OPEN:
767 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +0100768 case TRACE_REG_PERF_ADD:
769 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +0100770 return 0;
Steven Rostedt22392912010-04-21 12:27:06 -0400771#endif
772 }
773 return 0;
774}