trace_syscalls.c 18.3 KB
Newer Older
1
#include <trace/syscall.h>
2
#include <trace/events/syscalls.h>
3
#include <linux/syscalls.h>
4
#include <linux/slab.h>
5
#include <linux/kernel.h>
6
#include <linux/module.h>	/* for MODULE_NAME_LEN via KSYM_SYMBOL_LEN */
7
#include <linux/ftrace.h>
8
#include <linux/perf_event.h>
9
10
11
12
13
#include <asm/syscall.h>

#include "trace_output.h"
#include "trace.h"

14
static DEFINE_MUTEX(syscall_trace_lock);
15

16
static int syscall_enter_register(struct ftrace_event_call *event,
17
				 enum trace_reg type, void *data);
18
static int syscall_exit_register(struct ftrace_event_call *event,
19
				 enum trace_reg type, void *data);
20

21
22
23
24
25
26
27
28
static struct list_head *
syscall_get_enter_fields(struct ftrace_event_call *call)
{
	struct syscall_metadata *entry = call->data;

	return &entry->enter_fields;
}

29
30
extern struct syscall_metadata *__start_syscalls_metadata[];
extern struct syscall_metadata *__stop_syscalls_metadata[];
31
32
33

static struct syscall_metadata **syscalls_metadata;

34
35
36
37
38
39
#ifndef ARCH_HAS_SYSCALL_MATCH_SYM_NAME
static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
{
	/*
	 * Only compare after the "sys" prefix. Archs that use
	 * syscall wrappers may have syscalls symbols aliases prefixed
40
	 * with ".SyS" or ".sys" instead of "sys", leading to an unwanted
41
42
43
44
45
46
	 * mismatch.
	 */
	return !strcmp(sym + 3, name + 3);
}
#endif

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#ifdef ARCH_TRACE_IGNORE_COMPAT_SYSCALLS
/*
 * Some architectures that allow for 32bit applications
 * to run on a 64bit kernel, do not map the syscalls for
 * the 32bit tasks the same as they do for 64bit tasks.
 *
 *     *cough*x86*cough*
 *
 * In such a case, instead of reporting the wrong syscalls,
 * simply ignore them.
 *
 * For an arch to ignore the compat syscalls it needs to
 * define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS as well as
 * define the function arch_trace_is_compat_syscall() to let
 * the tracing system know that it should ignore it.
 */
static int
trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
{
	if (unlikely(arch_trace_is_compat_syscall(regs)))
		return -1;

	return syscall_get_nr(task, regs);
}
#else
static inline int
trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
{
	return syscall_get_nr(task, regs);
}
#endif /* ARCH_TRACE_IGNORE_COMPAT_SYSCALLS */

79
80
static __init struct syscall_metadata *
find_syscall_meta(unsigned long syscall)
81
{
82
83
	struct syscall_metadata **start;
	struct syscall_metadata **stop;
84
85
86
	char str[KSYM_SYMBOL_LEN];


87
88
	start = __start_syscalls_metadata;
	stop = __stop_syscalls_metadata;
89
90
	kallsyms_lookup(syscall, NULL, NULL, NULL, str);

91
92
93
	if (arch_syscall_match_sym_name(str, "sys_ni_syscall"))
		return NULL;

94
	for ( ; start < stop; start++) {
95
		if ((*start)->name && arch_syscall_match_sym_name(str, (*start)->name))
96
			return *start;
97
98
99
100
101
102
103
104
105
106
107
108
	}
	return NULL;
}

static struct syscall_metadata *syscall_nr_to_meta(int nr)
{
	if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
		return NULL;

	return syscalls_metadata[nr];
}

109
static enum print_line_t
110
111
print_syscall_enter(struct trace_iterator *iter, int flags,
		    struct trace_event *event)
112
113
114
115
116
117
118
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_enter *trace;
	struct syscall_metadata *entry;
	int i, ret, syscall;

119
	trace = (typeof(trace))ent;
120
121
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);
122

123
124
125
	if (!entry)
		goto end;

126
	if (entry->enter_event->event.type != ent->type) {
127
128
129
130
		WARN_ON_ONCE(1);
		goto end;
	}

131
132
133
134
135
136
	ret = trace_seq_printf(s, "%s(", entry->name);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	for (i = 0; i < entry->nb_args; i++) {
		/* parameter types */
137
		if (trace_flags & TRACE_ITER_VERBOSE) {
138
139
140
141
142
			ret = trace_seq_printf(s, "%s ", entry->types[i]);
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}
		/* parameter values */
143
		ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
144
				       trace->args[i],
145
				       i == entry->nb_args - 1 ? "" : ", ");
146
147
148
149
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

150
151
152
153
	ret = trace_seq_putc(s, ')');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

154
end:
155
156
157
158
	ret =  trace_seq_putc(s, '\n');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

159
160
161
	return TRACE_TYPE_HANDLED;
}

162
static enum print_line_t
163
164
print_syscall_exit(struct trace_iterator *iter, int flags,
		   struct trace_event *event)
165
166
167
168
169
170
171
172
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_exit *trace;
	int syscall;
	struct syscall_metadata *entry;
	int ret;

173
	trace = (typeof(trace))ent;
174
175
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);
176

177
178
179
180
181
	if (!entry) {
		trace_seq_printf(s, "\n");
		return TRACE_TYPE_HANDLED;
	}

182
	if (entry->exit_event->event.type != ent->type) {
183
184
185
186
		WARN_ON_ONCE(1);
		return TRACE_TYPE_UNHANDLED;
	}

187
188
189
190
191
192
193
194
	ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
				trace->ret);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

195
196
197
198
199
extern char *__bad_type_size(void);

#define SYSCALL_FIELD(type, name)					\
	sizeof(type) != sizeof(trace.name) ?				\
		__bad_type_size() :					\
200
201
		#type, #name, offsetof(typeof(trace), name),		\
		sizeof(trace.name), is_signed_type(type)
202

203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
static
int  __set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
{
	int i;
	int pos = 0;

	/* When len=0, we just calculate the needed length */
#define LEN_OR_ZERO (len ? len - pos : 0)

	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
	for (i = 0; i < entry->nb_args; i++) {
		pos += snprintf(buf + pos, LEN_OR_ZERO, "%s: 0x%%0%zulx%s",
				entry->args[i], sizeof(unsigned long),
				i == entry->nb_args - 1 ? "" : ", ");
	}
	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");

	for (i = 0; i < entry->nb_args; i++) {
		pos += snprintf(buf + pos, LEN_OR_ZERO,
				", ((unsigned long)(REC->%s))", entry->args[i]);
	}

#undef LEN_OR_ZERO

	/* return the length of print_fmt */
	return pos;
}

static int set_syscall_print_fmt(struct ftrace_event_call *call)
{
	char *print_fmt;
	int len;
	struct syscall_metadata *entry = call->data;

	if (entry->enter_event != call) {
		call->print_fmt = "\"0x%lx\", REC->ret";
		return 0;
	}

	/* First: called with 0 length to calculate the needed length */
	len = __set_enter_print_fmt(entry, NULL, 0);

	print_fmt = kmalloc(len + 1, GFP_KERNEL);
	if (!print_fmt)
		return -ENOMEM;

	/* Second: actually write the @print_fmt */
	__set_enter_print_fmt(entry, print_fmt, len + 1);
	call->print_fmt = print_fmt;

	return 0;
}

static void free_syscall_print_fmt(struct ftrace_event_call *call)
{
	struct syscall_metadata *entry = call->data;

	if (entry->enter_event == call)
		kfree(call->print_fmt);
}

264
static int __init syscall_enter_define_fields(struct ftrace_event_call *call)
265
266
{
	struct syscall_trace_enter trace;
267
	struct syscall_metadata *meta = call->data;
268
269
270
271
	int ret;
	int i;
	int offset = offsetof(typeof(trace), args);

272
273
274
275
	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
	if (ret)
		return ret;

276
	for (i = 0; i < meta->nb_args; i++) {
277
278
		ret = trace_define_field(call, meta->types[i],
					 meta->args[i], offset,
279
280
					 sizeof(unsigned long), 0,
					 FILTER_OTHER);
281
282
283
284
285
286
		offset += sizeof(unsigned long);
	}

	return ret;
}

287
static int __init syscall_exit_define_fields(struct ftrace_event_call *call)
288
289
290
291
{
	struct syscall_trace_exit trace;
	int ret;

292
293
294
295
	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
	if (ret)
		return ret;

296
	ret = trace_define_field(call, SYSCALL_FIELD(long, ret),
297
				 FILTER_OTHER);
298
299
300
301

	return ret;
}

302
static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
303
{
304
	struct trace_array *tr = data;
305
306
307
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
308
	struct ring_buffer *buffer;
309
	int syscall_nr;
310
	int size;
311

312
	syscall_nr = trace_get_syscall_nr(current, regs);
313
314
	if (syscall_nr < 0)
		return;
315
	if (!test_bit(syscall_nr, tr->enabled_enter_syscalls))
316
		return;
317

318
319
320
321
322
323
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;

324
	buffer = tr->trace_buffer.buffer;
325
	event = trace_buffer_lock_reserve(buffer,
326
			sys_data->enter_event->event.type, size, 0, 0);
327
328
329
330
331
332
333
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);

334
335
336
	if (!filter_current_check_discard(buffer, sys_data->enter_event,
					  entry, event))
		trace_current_buffer_unlock_commit(buffer, event, 0, 0);
337
338
}

339
static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
340
{
341
	struct trace_array *tr = data;
342
343
344
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
345
	struct ring_buffer *buffer;
346
347
	int syscall_nr;

348
	syscall_nr = trace_get_syscall_nr(current, regs);
349
350
	if (syscall_nr < 0)
		return;
351
	if (!test_bit(syscall_nr, tr->enabled_exit_syscalls))
352
		return;
353

354
355
356
357
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

358
	buffer = tr->trace_buffer.buffer;
359
	event = trace_buffer_lock_reserve(buffer,
360
			sys_data->exit_event->event.type, sizeof(*entry), 0, 0);
361
362
363
364
365
366
367
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	entry->ret = syscall_get_return_value(current, regs);

368
369
370
	if (!filter_current_check_discard(buffer, sys_data->exit_event,
					  entry, event))
		trace_current_buffer_unlock_commit(buffer, event, 0, 0);
371
372
}

373
374
static int reg_event_syscall_enter(struct ftrace_event_file *file,
				   struct ftrace_event_call *call)
375
{
376
	struct trace_array *tr = file->tr;
377
378
379
	int ret = 0;
	int num;

380
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
381
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
382
383
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
384
385
	if (!tr->sys_refcount_enter)
		ret = register_trace_sys_enter(ftrace_syscall_enter, tr);
386
	if (!ret) {
387
388
		set_bit(num, tr->enabled_enter_syscalls);
		tr->sys_refcount_enter++;
389
390
391
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
392
393
}

394
395
static void unreg_event_syscall_enter(struct ftrace_event_file *file,
				      struct ftrace_event_call *call)
396
{
397
	struct trace_array *tr = file->tr;
398
	int num;
399

400
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
401
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
402
403
		return;
	mutex_lock(&syscall_trace_lock);
404
405
406
407
	tr->sys_refcount_enter--;
	clear_bit(num, tr->enabled_enter_syscalls);
	if (!tr->sys_refcount_enter)
		unregister_trace_sys_enter(ftrace_syscall_enter, tr);
408
409
	mutex_unlock(&syscall_trace_lock);
}
410

411
412
static int reg_event_syscall_exit(struct ftrace_event_file *file,
				  struct ftrace_event_call *call)
413
{
414
	struct trace_array *tr = file->tr;
415
416
417
	int ret = 0;
	int num;

418
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
419
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
420
421
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
422
423
	if (!tr->sys_refcount_exit)
		ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
424
	if (!ret) {
425
426
		set_bit(num, tr->enabled_exit_syscalls);
		tr->sys_refcount_exit++;
427
	}
428
429
430
	mutex_unlock(&syscall_trace_lock);
	return ret;
}
431

432
433
static void unreg_event_syscall_exit(struct ftrace_event_file *file,
				     struct ftrace_event_call *call)
434
{
435
	struct trace_array *tr = file->tr;
436
	int num;
437

438
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
439
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
440
441
		return;
	mutex_lock(&syscall_trace_lock);
442
443
444
445
	tr->sys_refcount_exit--;
	clear_bit(num, tr->enabled_exit_syscalls);
	if (!tr->sys_refcount_exit)
		unregister_trace_sys_exit(ftrace_syscall_exit, tr);
446
	mutex_unlock(&syscall_trace_lock);
447
}
448

449
static int init_syscall_trace(struct ftrace_event_call *call)
450
451
{
	int id;
452
453
454
455
456
457
458
459
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (num < 0 || num >= NR_syscalls) {
		pr_debug("syscall %s metadata not mapped, disabling ftrace event\n",
				((struct syscall_metadata *)call->data)->name);
		return -ENOSYS;
	}
460

461
462
463
	if (set_syscall_print_fmt(call) < 0)
		return -ENOMEM;

464
465
466
	id = trace_event_raw_init(call);

	if (id < 0) {
467
		free_syscall_print_fmt(call);
468
		return id;
469
	}
470
471

	return id;
472
473
}

474
475
476
477
478
479
480
481
struct trace_event_functions enter_syscall_print_funcs = {
	.trace		= print_syscall_enter,
};

struct trace_event_functions exit_syscall_print_funcs = {
	.trace		= print_syscall_exit,
};

482
struct ftrace_event_class __refdata event_class_syscall_enter = {
483
484
485
486
487
488
489
	.system		= "syscalls",
	.reg		= syscall_enter_register,
	.define_fields	= syscall_enter_define_fields,
	.get_fields	= syscall_get_enter_fields,
	.raw_init	= init_syscall_trace,
};

490
struct ftrace_event_class __refdata event_class_syscall_exit = {
491
492
493
494
495
496
497
	.system		= "syscalls",
	.reg		= syscall_exit_register,
	.define_fields	= syscall_exit_define_fields,
	.fields		= LIST_HEAD_INIT(event_class_syscall_exit.fields),
	.raw_init	= init_syscall_trace,
};

498
unsigned long __init __weak arch_syscall_addr(int nr)
499
500
501
502
{
	return (unsigned long)sys_call_table[nr];
}

503
static int __init init_ftrace_syscalls(void)
504
505
506
507
508
{
	struct syscall_metadata *meta;
	unsigned long addr;
	int i;

509
510
	syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
				    GFP_KERNEL);
511
512
513
514
515
516
517
518
	if (!syscalls_metadata) {
		WARN_ON(1);
		return -ENOMEM;
	}

	for (i = 0; i < NR_syscalls; i++) {
		addr = arch_syscall_addr(i);
		meta = find_syscall_meta(addr);
519
520
521
522
		if (!meta)
			continue;

		meta->syscall_nr = i;
523
524
525
526
527
		syscalls_metadata[i] = meta;
	}

	return 0;
}
528
early_initcall(init_ftrace_syscalls);
529

530
#ifdef CONFIG_PERF_EVENTS
531

532
533
534
535
static DECLARE_BITMAP(enabled_perf_enter_syscalls, NR_syscalls);
static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);
static int sys_perf_refcount_enter;
static int sys_perf_refcount_exit;
536

537
static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
538
539
{
	struct syscall_metadata *sys_data;
540
	struct syscall_trace_enter *rec;
541
	struct hlist_head *head;
542
	int syscall_nr;
543
	int rctx;
544
	int size;
545

546
	syscall_nr = trace_get_syscall_nr(current, regs);
547
548
	if (syscall_nr < 0)
		return;
549
	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
550
551
552
553
554
555
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

556
557
558
559
560
	/* get the size after alignment with the u32 buffer size field */
	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	size = ALIGN(size + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);

561
562
	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
		      "perf buffer not large enough"))
563
564
		return;

565
	rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
566
				sys_data->enter_event->event.type, regs, &rctx);
567
568
	if (!rec)
		return;
569
570
571
572

	rec->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
			       (unsigned long *)&rec->args);
573

574
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
575
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
576
577
}

578
static int perf_sysenter_enable(struct ftrace_event_call *call)
579
580
581
582
{
	int ret = 0;
	int num;

583
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
584
585

	mutex_lock(&syscall_trace_lock);
586
	if (!sys_perf_refcount_enter)
587
		ret = register_trace_sys_enter(perf_syscall_enter, NULL);
588
589
590
591
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
592
593
		set_bit(num, enabled_perf_enter_syscalls);
		sys_perf_refcount_enter++;
594
595
596
597
598
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

599
static void perf_sysenter_disable(struct ftrace_event_call *call)
600
601
602
{
	int num;

603
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
604
605

	mutex_lock(&syscall_trace_lock);
606
607
608
	sys_perf_refcount_enter--;
	clear_bit(num, enabled_perf_enter_syscalls);
	if (!sys_perf_refcount_enter)
609
		unregister_trace_sys_enter(perf_syscall_enter, NULL);
610
611
612
	mutex_unlock(&syscall_trace_lock);
}

613
static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
614
615
{
	struct syscall_metadata *sys_data;
616
	struct syscall_trace_exit *rec;
617
	struct hlist_head *head;
618
	int syscall_nr;
619
	int rctx;
620
	int size;
621

622
	syscall_nr = trace_get_syscall_nr(current, regs);
623
624
	if (syscall_nr < 0)
		return;
625
	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
626
627
628
629
630
631
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

632
633
634
	/* We can probably do that at build time */
	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);
635

636
637
638
639
	/*
	 * Impossible, but be paranoid with the future
	 * How to put this check outside runtime?
	 */
640
641
	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
		"exit event has grown above perf buffer size"))
642
643
		return;

644
	rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
645
				sys_data->exit_event->event.type, regs, &rctx);
646
647
	if (!rec)
		return;
648
649
650
651

	rec->nr = syscall_nr;
	rec->ret = syscall_get_return_value(current, regs);

652
	head = this_cpu_ptr(sys_data->exit_event->perf_events);
653
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
654
655
}

656
static int perf_sysexit_enable(struct ftrace_event_call *call)
657
658
659
660
{
	int ret = 0;
	int num;

661
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
662
663

	mutex_lock(&syscall_trace_lock);
664
	if (!sys_perf_refcount_exit)
665
		ret = register_trace_sys_exit(perf_syscall_exit, NULL);
666
667
	if (ret) {
		pr_info("event trace: Could not activate"
668
				"syscall exit trace point");
669
	} else {
670
671
		set_bit(num, enabled_perf_exit_syscalls);
		sys_perf_refcount_exit++;
672
673
674
675
676
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

677
static void perf_sysexit_disable(struct ftrace_event_call *call)
678
679
680
{
	int num;

681
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
682
683

	mutex_lock(&syscall_trace_lock);
684
685
686
	sys_perf_refcount_exit--;
	clear_bit(num, enabled_perf_exit_syscalls);
	if (!sys_perf_refcount_exit)
687
		unregister_trace_sys_exit(perf_syscall_exit, NULL);
688
689
690
	mutex_unlock(&syscall_trace_lock);
}

691
#endif /* CONFIG_PERF_EVENTS */
692

693
static int syscall_enter_register(struct ftrace_event_call *event,
694
				 enum trace_reg type, void *data)
695
{
696
697
	struct ftrace_event_file *file = data;

698
699
	switch (type) {
	case TRACE_REG_REGISTER:
700
		return reg_event_syscall_enter(file, event);
701
	case TRACE_REG_UNREGISTER:
702
		unreg_event_syscall_enter(file, event);
703
704
705
706
707
708
709
710
		return 0;

#ifdef CONFIG_PERF_EVENTS
	case TRACE_REG_PERF_REGISTER:
		return perf_sysenter_enable(event);
	case TRACE_REG_PERF_UNREGISTER:
		perf_sysenter_disable(event);
		return 0;
711
712
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
713
714
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
715
		return 0;
716
717
718
719
720
721
#endif
	}
	return 0;
}

static int syscall_exit_register(struct ftrace_event_call *event,
722
				 enum trace_reg type, void *data)
723
{
724
725
	struct ftrace_event_file *file = data;

726
727
	switch (type) {
	case TRACE_REG_REGISTER:
728
		return reg_event_syscall_exit(file, event);
729
	case TRACE_REG_UNREGISTER:
730
		unreg_event_syscall_exit(file, event);
731
732
733
734
735
736
737
738
		return 0;

#ifdef CONFIG_PERF_EVENTS
	case TRACE_REG_PERF_REGISTER:
		return perf_sysexit_enable(event);
	case TRACE_REG_PERF_UNREGISTER:
		perf_sysexit_disable(event);
		return 0;
739
740
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
741
742
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
743
		return 0;
744
745
746
747
#endif
	}
	return 0;
}