trace_syscalls.c 18.5 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
310
	unsigned long irq_flags;
	int pc;
311
	int syscall_nr;
312
	int size;
313

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

320
321
322
323
324
325
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

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

326
327
328
	local_save_flags(irq_flags);
	pc = preempt_count();

329
	buffer = tr->trace_buffer.buffer;
330
	event = trace_buffer_lock_reserve(buffer,
331
			sys_data->enter_event->event.type, size, irq_flags, pc);
332
333
334
335
336
337
338
	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);

339
340
	if (!filter_current_check_discard(buffer, sys_data->enter_event,
					  entry, event))
341
342
		trace_current_buffer_unlock_commit(buffer, event,
						   irq_flags, pc);
343
344
}

345
static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
346
{
347
	struct trace_array *tr = data;
348
349
350
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
351
	struct ring_buffer *buffer;
352
353
	unsigned long irq_flags;
	int pc;
354
355
	int syscall_nr;

356
	syscall_nr = trace_get_syscall_nr(current, regs);
357
358
	if (syscall_nr < 0)
		return;
359
	if (!test_bit(syscall_nr, tr->enabled_exit_syscalls))
360
		return;
361

362
363
364
365
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

366
367
368
	local_save_flags(irq_flags);
	pc = preempt_count();

369
	buffer = tr->trace_buffer.buffer;
370
	event = trace_buffer_lock_reserve(buffer,
371
372
			sys_data->exit_event->event.type, sizeof(*entry),
			irq_flags, pc);
373
374
375
376
377
378
379
	if (!event)
		return;

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

380
381
	if (!filter_current_check_discard(buffer, sys_data->exit_event,
					  entry, event))
382
383
		trace_current_buffer_unlock_commit(buffer, event,
						   irq_flags, pc);
384
385
}

386
387
static int reg_event_syscall_enter(struct ftrace_event_file *file,
				   struct ftrace_event_call *call)
388
{
389
	struct trace_array *tr = file->tr;
390
391
392
	int ret = 0;
	int num;

393
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
394
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
395
396
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
397
398
	if (!tr->sys_refcount_enter)
		ret = register_trace_sys_enter(ftrace_syscall_enter, tr);
399
	if (!ret) {
400
401
		set_bit(num, tr->enabled_enter_syscalls);
		tr->sys_refcount_enter++;
402
403
404
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
405
406
}

407
408
static void unreg_event_syscall_enter(struct ftrace_event_file *file,
				      struct ftrace_event_call *call)
409
{
410
	struct trace_array *tr = file->tr;
411
	int num;
412

413
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
414
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
415
416
		return;
	mutex_lock(&syscall_trace_lock);
417
418
419
420
	tr->sys_refcount_enter--;
	clear_bit(num, tr->enabled_enter_syscalls);
	if (!tr->sys_refcount_enter)
		unregister_trace_sys_enter(ftrace_syscall_enter, tr);
421
422
	mutex_unlock(&syscall_trace_lock);
}
423

424
425
static int reg_event_syscall_exit(struct ftrace_event_file *file,
				  struct ftrace_event_call *call)
426
{
427
	struct trace_array *tr = file->tr;
428
429
430
	int ret = 0;
	int num;

431
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
432
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
433
434
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
435
436
	if (!tr->sys_refcount_exit)
		ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
437
	if (!ret) {
438
439
		set_bit(num, tr->enabled_exit_syscalls);
		tr->sys_refcount_exit++;
440
	}
441
442
443
	mutex_unlock(&syscall_trace_lock);
	return ret;
}
444

445
446
static void unreg_event_syscall_exit(struct ftrace_event_file *file,
				     struct ftrace_event_call *call)
447
{
448
	struct trace_array *tr = file->tr;
449
	int num;
450

451
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
452
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
453
454
		return;
	mutex_lock(&syscall_trace_lock);
455
456
457
458
	tr->sys_refcount_exit--;
	clear_bit(num, tr->enabled_exit_syscalls);
	if (!tr->sys_refcount_exit)
		unregister_trace_sys_exit(ftrace_syscall_exit, tr);
459
	mutex_unlock(&syscall_trace_lock);
460
}
461

462
static int init_syscall_trace(struct ftrace_event_call *call)
463
464
{
	int id;
465
466
467
468
469
470
471
472
	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;
	}
473

474
475
476
	if (set_syscall_print_fmt(call) < 0)
		return -ENOMEM;

477
478
479
	id = trace_event_raw_init(call);

	if (id < 0) {
480
		free_syscall_print_fmt(call);
481
		return id;
482
	}
483
484

	return id;
485
486
}

487
488
489
490
491
492
493
494
struct trace_event_functions enter_syscall_print_funcs = {
	.trace		= print_syscall_enter,
};

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

495
struct ftrace_event_class __refdata event_class_syscall_enter = {
496
497
498
499
500
501
502
	.system		= "syscalls",
	.reg		= syscall_enter_register,
	.define_fields	= syscall_enter_define_fields,
	.get_fields	= syscall_get_enter_fields,
	.raw_init	= init_syscall_trace,
};

503
struct ftrace_event_class __refdata event_class_syscall_exit = {
504
505
506
507
508
509
510
	.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,
};

511
unsigned long __init __weak arch_syscall_addr(int nr)
512
513
514
515
{
	return (unsigned long)sys_call_table[nr];
}

516
static int __init init_ftrace_syscalls(void)
517
518
519
520
521
{
	struct syscall_metadata *meta;
	unsigned long addr;
	int i;

522
523
	syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
				    GFP_KERNEL);
524
525
526
527
528
529
530
531
	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);
532
533
534
535
		if (!meta)
			continue;

		meta->syscall_nr = i;
536
537
538
539
540
		syscalls_metadata[i] = meta;
	}

	return 0;
}
541
early_initcall(init_ftrace_syscalls);
542

543
#ifdef CONFIG_PERF_EVENTS
544

545
546
547
548
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;
549

550
static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
551
552
{
	struct syscall_metadata *sys_data;
553
	struct syscall_trace_enter *rec;
554
	struct hlist_head *head;
555
	int syscall_nr;
556
	int rctx;
557
	int size;
558

559
	syscall_nr = trace_get_syscall_nr(current, regs);
560
561
	if (syscall_nr < 0)
		return;
562
	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
563
564
565
566
567
568
		return;

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

569
570
571
572
573
	/* 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);

574
575
	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
		      "perf buffer not large enough"))
576
577
		return;

578
	rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
579
				sys_data->enter_event->event.type, regs, &rctx);
580
581
	if (!rec)
		return;
582
583
584
585

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

587
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
588
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
589
590
}

591
static int perf_sysenter_enable(struct ftrace_event_call *call)
592
593
594
595
{
	int ret = 0;
	int num;

596
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
597
598

	mutex_lock(&syscall_trace_lock);
599
	if (!sys_perf_refcount_enter)
600
		ret = register_trace_sys_enter(perf_syscall_enter, NULL);
601
602
603
604
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
605
606
		set_bit(num, enabled_perf_enter_syscalls);
		sys_perf_refcount_enter++;
607
608
609
610
611
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

612
static void perf_sysenter_disable(struct ftrace_event_call *call)
613
614
615
{
	int num;

616
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
617
618

	mutex_lock(&syscall_trace_lock);
619
620
621
	sys_perf_refcount_enter--;
	clear_bit(num, enabled_perf_enter_syscalls);
	if (!sys_perf_refcount_enter)
622
		unregister_trace_sys_enter(perf_syscall_enter, NULL);
623
624
625
	mutex_unlock(&syscall_trace_lock);
}

626
static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
627
628
{
	struct syscall_metadata *sys_data;
629
	struct syscall_trace_exit *rec;
630
	struct hlist_head *head;
631
	int syscall_nr;
632
	int rctx;
633
	int size;
634

635
	syscall_nr = trace_get_syscall_nr(current, regs);
636
637
	if (syscall_nr < 0)
		return;
638
	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
639
640
641
642
643
644
		return;

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

645
646
647
	/* We can probably do that at build time */
	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);
648

649
650
651
652
	/*
	 * Impossible, but be paranoid with the future
	 * How to put this check outside runtime?
	 */
653
654
	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
		"exit event has grown above perf buffer size"))
655
656
		return;

657
	rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
658
				sys_data->exit_event->event.type, regs, &rctx);
659
660
	if (!rec)
		return;
661
662
663
664

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

665
	head = this_cpu_ptr(sys_data->exit_event->perf_events);
666
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
667
668
}

669
static int perf_sysexit_enable(struct ftrace_event_call *call)
670
671
672
673
{
	int ret = 0;
	int num;

674
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
675
676

	mutex_lock(&syscall_trace_lock);
677
	if (!sys_perf_refcount_exit)
678
		ret = register_trace_sys_exit(perf_syscall_exit, NULL);
679
680
	if (ret) {
		pr_info("event trace: Could not activate"
681
				"syscall exit trace point");
682
	} else {
683
684
		set_bit(num, enabled_perf_exit_syscalls);
		sys_perf_refcount_exit++;
685
686
687
688
689
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

690
static void perf_sysexit_disable(struct ftrace_event_call *call)
691
692
693
{
	int num;

694
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
695
696

	mutex_lock(&syscall_trace_lock);
697
698
699
	sys_perf_refcount_exit--;
	clear_bit(num, enabled_perf_exit_syscalls);
	if (!sys_perf_refcount_exit)
700
		unregister_trace_sys_exit(perf_syscall_exit, NULL);
701
702
703
	mutex_unlock(&syscall_trace_lock);
}

704
#endif /* CONFIG_PERF_EVENTS */
705

706
static int syscall_enter_register(struct ftrace_event_call *event,
707
				 enum trace_reg type, void *data)
708
{
709
710
	struct ftrace_event_file *file = data;

711
712
	switch (type) {
	case TRACE_REG_REGISTER:
713
		return reg_event_syscall_enter(file, event);
714
	case TRACE_REG_UNREGISTER:
715
		unreg_event_syscall_enter(file, event);
716
717
718
719
720
721
722
723
		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;
724
725
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
726
727
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
728
		return 0;
729
730
731
732
733
734
#endif
	}
	return 0;
}

static int syscall_exit_register(struct ftrace_event_call *event,
735
				 enum trace_reg type, void *data)
736
{
737
738
	struct ftrace_event_file *file = data;

739
740
	switch (type) {
	case TRACE_REG_REGISTER:
741
		return reg_event_syscall_exit(file, event);
742
	case TRACE_REG_UNREGISTER:
743
		unreg_event_syscall_exit(file, event);
744
745
746
747
748
749
750
751
		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;
752
753
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
754
755
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
756
		return 0;
757
758
759
760
#endif
	}
	return 0;
}