blob: ea90eb5f6f1730dce05ca992c19ebb533d7085db [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);
434}
435
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400436static int reg_event_syscall_exit(struct ftrace_event_file *file,
437 struct ftrace_event_call *call)
Jason Baronfb34a082009-08-10 16:52:47 -0400438{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400439 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400440 int ret = 0;
441 int num;
Jason Baronfb34a082009-08-10 16:52:47 -0400442
Lai Jiangshanc252f652009-12-01 16:23:47 +0800443 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100444 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400445 return -ENOSYS;
446 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400447 if (!tr->sys_refcount_exit)
448 ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
Li Zefan3b8e4272009-12-08 11:14:52 +0800449 if (!ret) {
Tom Zanussid562aff2013-10-24 08:34:19 -0500450 rcu_assign_pointer(tr->exit_syscall_files[num], file);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400451 tr->sys_refcount_exit++;
Jason Baronfb34a082009-08-10 16:52:47 -0400452 }
453 mutex_unlock(&syscall_trace_lock);
454 return ret;
455}
456
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400457static void unreg_event_syscall_exit(struct ftrace_event_file *file,
458 struct ftrace_event_call *call)
Jason Baronfb34a082009-08-10 16:52:47 -0400459{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400460 struct trace_array *tr = file->tr;
Jason Baronfb34a082009-08-10 16:52:47 -0400461 int num;
Jason Baronfb34a082009-08-10 16:52:47 -0400462
Lai Jiangshanc252f652009-12-01 16:23:47 +0800463 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Ian Munsie3773b3892011-02-03 14:27:21 +1100464 if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
Jason Baronfb34a082009-08-10 16:52:47 -0400465 return;
466 mutex_lock(&syscall_trace_lock);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400467 tr->sys_refcount_exit--;
Tom Zanussid562aff2013-10-24 08:34:19 -0500468 rcu_assign_pointer(tr->exit_syscall_files[num], NULL);
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400469 if (!tr->sys_refcount_exit)
470 unregister_trace_sys_exit(ftrace_syscall_exit, tr);
Jason Baronfb34a082009-08-10 16:52:47 -0400471 mutex_unlock(&syscall_trace_lock);
472}
473
Li Zefan3ddc77f2013-03-27 14:15:37 +0800474static int __init init_syscall_trace(struct ftrace_event_call *call)
Lai Jiangshana1301da2009-12-01 16:23:55 +0800475{
476 int id;
Ian Munsieba976972011-02-03 14:27:20 +1100477 int num;
478
479 num = ((struct syscall_metadata *)call->data)->syscall_nr;
480 if (num < 0 || num >= NR_syscalls) {
481 pr_debug("syscall %s metadata not mapped, disabling ftrace event\n",
482 ((struct syscall_metadata *)call->data)->name);
483 return -ENOSYS;
484 }
Lai Jiangshana1301da2009-12-01 16:23:55 +0800485
Lai Jiangshan50307a42009-12-15 15:39:45 +0800486 if (set_syscall_print_fmt(call) < 0)
487 return -ENOMEM;
488
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500489 id = trace_event_raw_init(call);
490
491 if (id < 0) {
Lai Jiangshan50307a42009-12-15 15:39:45 +0800492 free_syscall_print_fmt(call);
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500493 return id;
Lai Jiangshan50307a42009-12-15 15:39:45 +0800494 }
Steven Rostedtc7ef3a92009-12-28 21:13:59 -0500495
496 return id;
Lai Jiangshana1301da2009-12-01 16:23:55 +0800497}
498
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700499struct trace_event_functions enter_syscall_print_funcs = {
500 .trace = print_syscall_enter,
501};
502
503struct trace_event_functions exit_syscall_print_funcs = {
504 .trace = print_syscall_exit,
505};
506
Li Zefan523c8112013-03-04 14:15:59 +0800507struct ftrace_event_class __refdata event_class_syscall_enter = {
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700508 .system = "syscalls",
509 .reg = syscall_enter_register,
510 .define_fields = syscall_enter_define_fields,
511 .get_fields = syscall_get_enter_fields,
512 .raw_init = init_syscall_trace,
513};
514
Li Zefan523c8112013-03-04 14:15:59 +0800515struct ftrace_event_class __refdata event_class_syscall_exit = {
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700516 .system = "syscalls",
517 .reg = syscall_exit_register,
518 .define_fields = syscall_exit_define_fields,
519 .fields = LIST_HEAD_INIT(event_class_syscall_exit.fields),
520 .raw_init = init_syscall_trace,
521};
522
Ian Munsiec763ba02011-02-03 14:27:22 +1100523unsigned long __init __weak arch_syscall_addr(int nr)
Mike Frysingere7b8e672010-01-26 04:40:03 -0500524{
525 return (unsigned long)sys_call_table[nr];
526}
527
Fengguang Wu6aea49c2012-11-21 15:13:47 +0800528static int __init init_ftrace_syscalls(void)
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200529{
530 struct syscall_metadata *meta;
531 unsigned long addr;
532 int i;
533
Thomas Meyer47b0edc2011-11-29 22:08:00 +0100534 syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
535 GFP_KERNEL);
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200536 if (!syscalls_metadata) {
537 WARN_ON(1);
538 return -ENOMEM;
539 }
540
541 for (i = 0; i < NR_syscalls; i++) {
542 addr = arch_syscall_addr(i);
543 meta = find_syscall_meta(addr);
Lai Jiangshanc252f652009-12-01 16:23:47 +0800544 if (!meta)
545 continue;
546
547 meta->syscall_nr = i;
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200548 syscalls_metadata[i] = meta;
549 }
550
551 return 0;
552}
Ezequiel Garcia87819152012-09-12 11:47:57 -0300553early_initcall(init_ftrace_syscalls);
Frederic Weisbeckerc44fc772009-09-19 06:50:42 +0200554
Li Zefan07b139c2009-12-21 14:27:35 +0800555#ifdef CONFIG_PERF_EVENTS
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200556
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100557static DECLARE_BITMAP(enabled_perf_enter_syscalls, NR_syscalls);
558static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);
559static int sys_perf_refcount_enter;
560static int sys_perf_refcount_exit;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400561
Steven Rostedt38516ab2010-04-20 17:04:50 -0400562static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400563{
564 struct syscall_metadata *sys_data;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200565 struct syscall_trace_enter *rec;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200566 struct hlist_head *head;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400567 int syscall_nr;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100568 int rctx;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200569 int size;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400570
Steven Rostedtf431b632013-02-12 16:18:59 -0500571 syscall_nr = trace_get_syscall_nr(current, regs);
Will Deacon60916a92012-08-16 18:14:14 +0100572 if (syscall_nr < 0)
573 return;
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100574 if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400575 return;
576
577 sys_data = syscall_nr_to_meta(syscall_nr);
578 if (!sys_data)
579 return;
580
Oleg Nesterov421c7862013-06-17 19:02:07 +0200581 head = this_cpu_ptr(sys_data->enter_event->perf_events);
582 if (hlist_empty(head))
583 return;
584
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200585 /* get the size after alignment with the u32 buffer size field */
586 size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
587 size = ALIGN(size + sizeof(u32), sizeof(u64));
588 size -= sizeof(u32);
589
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100590 rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
Steven Rostedtff5f1492010-05-21 11:49:57 -0400591 sys_data->enter_event->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800592 if (!rec)
593 return;
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200594
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200595 rec->nr = syscall_nr;
596 syscall_get_arguments(current, regs, 0, sys_data->nb_args,
597 (unsigned long *)&rec->args);
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400598 perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400599}
600
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700601static int perf_sysenter_enable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400602{
603 int ret = 0;
604 int num;
605
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800606 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400607
608 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100609 if (!sys_perf_refcount_enter)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400610 ret = register_trace_sys_enter(perf_syscall_enter, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400611 if (ret) {
612 pr_info("event trace: Could not activate"
613 "syscall entry trace point");
614 } else {
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100615 set_bit(num, enabled_perf_enter_syscalls);
616 sys_perf_refcount_enter++;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400617 }
618 mutex_unlock(&syscall_trace_lock);
619 return ret;
620}
621
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700622static void perf_sysenter_disable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400623{
624 int num;
625
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800626 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400627
628 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100629 sys_perf_refcount_enter--;
630 clear_bit(num, enabled_perf_enter_syscalls);
631 if (!sys_perf_refcount_enter)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400632 unregister_trace_sys_enter(perf_syscall_enter, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400633 mutex_unlock(&syscall_trace_lock);
634}
635
Steven Rostedt38516ab2010-04-20 17:04:50 -0400636static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400637{
638 struct syscall_metadata *sys_data;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200639 struct syscall_trace_exit *rec;
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200640 struct hlist_head *head;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400641 int syscall_nr;
Peter Zijlstra4ed7c922009-11-23 11:37:29 +0100642 int rctx;
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200643 int size;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400644
Steven Rostedtf431b632013-02-12 16:18:59 -0500645 syscall_nr = trace_get_syscall_nr(current, regs);
Will Deacon60916a92012-08-16 18:14:14 +0100646 if (syscall_nr < 0)
647 return;
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100648 if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400649 return;
650
651 sys_data = syscall_nr_to_meta(syscall_nr);
652 if (!sys_data)
653 return;
654
Oleg Nesterov421c7862013-06-17 19:02:07 +0200655 head = this_cpu_ptr(sys_data->exit_event->perf_events);
656 if (hlist_empty(head))
657 return;
658
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200659 /* We can probably do that at build time */
660 size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
661 size -= sizeof(u32);
Frederic Weisbecker19007a62009-08-11 20:22:53 +0200662
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100663 rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
Steven Rostedtff5f1492010-05-21 11:49:57 -0400664 sys_data->exit_event->event.type, regs, &rctx);
Xiao Guangrong430ad5a2010-01-28 09:32:29 +0800665 if (!rec)
666 return;
Frederic Weisbeckerce71b9d2009-11-22 05:26:55 +0100667
Frederic Weisbecker20ab44252009-09-18 06:10:28 +0200668 rec->nr = syscall_nr;
669 rec->ret = syscall_get_return_value(current, regs);
Andrew Vagine6dab5f2012-07-11 18:14:58 +0400670 perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400671}
672
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700673static int perf_sysexit_enable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400674{
675 int ret = 0;
676 int num;
677
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800678 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400679
680 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100681 if (!sys_perf_refcount_exit)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400682 ret = register_trace_sys_exit(perf_syscall_exit, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400683 if (ret) {
684 pr_info("event trace: Could not activate"
Wenji Huang65746582010-02-24 15:40:22 +0800685 "syscall exit trace point");
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400686 } else {
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100687 set_bit(num, enabled_perf_exit_syscalls);
688 sys_perf_refcount_exit++;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400689 }
690 mutex_unlock(&syscall_trace_lock);
691 return ret;
692}
693
Vaibhav Nagarnaik6f86ab92012-06-07 16:46:25 -0700694static void perf_sysexit_disable(struct ftrace_event_call *call)
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400695{
696 int num;
697
Lai Jiangshan3bbe84e2009-12-01 16:24:01 +0800698 num = ((struct syscall_metadata *)call->data)->syscall_nr;
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400699
700 mutex_lock(&syscall_trace_lock);
Frederic Weisbecker97d5a222010-03-05 05:35:37 +0100701 sys_perf_refcount_exit--;
702 clear_bit(num, enabled_perf_exit_syscalls);
703 if (!sys_perf_refcount_exit)
Steven Rostedt38516ab2010-04-20 17:04:50 -0400704 unregister_trace_sys_exit(perf_syscall_exit, NULL);
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400705 mutex_unlock(&syscall_trace_lock);
706}
707
Li Zefan07b139c2009-12-21 14:27:35 +0800708#endif /* CONFIG_PERF_EVENTS */
Jason Baronf4b5ffc2009-08-10 16:53:02 -0400709
Steven Rostedt22392912010-04-21 12:27:06 -0400710static int syscall_enter_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100711 enum trace_reg type, void *data)
Steven Rostedt22392912010-04-21 12:27:06 -0400712{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400713 struct ftrace_event_file *file = data;
714
Steven Rostedt22392912010-04-21 12:27:06 -0400715 switch (type) {
716 case TRACE_REG_REGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400717 return reg_event_syscall_enter(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400718 case TRACE_REG_UNREGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400719 unreg_event_syscall_enter(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400720 return 0;
721
722#ifdef CONFIG_PERF_EVENTS
723 case TRACE_REG_PERF_REGISTER:
724 return perf_sysenter_enable(event);
725 case TRACE_REG_PERF_UNREGISTER:
726 perf_sysenter_disable(event);
727 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +0100728 case TRACE_REG_PERF_OPEN:
729 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +0100730 case TRACE_REG_PERF_ADD:
731 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +0100732 return 0;
Steven Rostedt22392912010-04-21 12:27:06 -0400733#endif
734 }
735 return 0;
736}
737
738static int syscall_exit_register(struct ftrace_event_call *event,
Jiri Olsaceec0b62012-02-15 15:51:49 +0100739 enum trace_reg type, void *data)
Steven Rostedt22392912010-04-21 12:27:06 -0400740{
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400741 struct ftrace_event_file *file = data;
742
Steven Rostedt22392912010-04-21 12:27:06 -0400743 switch (type) {
744 case TRACE_REG_REGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400745 return reg_event_syscall_exit(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400746 case TRACE_REG_UNREGISTER:
Steven Rostedt12ab74e2012-08-08 14:48:20 -0400747 unreg_event_syscall_exit(file, event);
Steven Rostedt22392912010-04-21 12:27:06 -0400748 return 0;
749
750#ifdef CONFIG_PERF_EVENTS
751 case TRACE_REG_PERF_REGISTER:
752 return perf_sysexit_enable(event);
753 case TRACE_REG_PERF_UNREGISTER:
754 perf_sysexit_disable(event);
755 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +0100756 case TRACE_REG_PERF_OPEN:
757 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +0100758 case TRACE_REG_PERF_ADD:
759 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +0100760 return 0;
Steven Rostedt22392912010-04-21 12:27:06 -0400761#endif
762 }
763 return 0;
764}