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
	if (!entry) {
178
		trace_seq_putc(s, '\n');
179 180 181
		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
static int __init
__set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
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
{
	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;
}

231
static int __init set_syscall_print_fmt(struct ftrace_event_call *call)
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
{
	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;
}

256
static void __init free_syscall_print_fmt(struct ftrace_event_call *call)
257 258 259 260 261 262 263
{
	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 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
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
	if (hlist_empty(head))
		return;

573 574 575 576 577
	/* 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);

578
	rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
S
Steven Rostedt 已提交
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
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
587 588
}

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

594
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
595 596

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

610
static void perf_sysenter_disable(struct ftrace_event_call *call)
611 612 613
{
	int num;

614
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
615 616

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

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

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

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

643 644 645 646
	head = this_cpu_ptr(sys_data->exit_event->perf_events);
	if (hlist_empty(head))
		return;

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

651
	rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
S
Steven Rostedt 已提交
652
				sys_data->exit_event->event.type, regs, &rctx);
653 654
	if (!rec)
		return;
655 656 657

	rec->nr = syscall_nr;
	rec->ret = syscall_get_return_value(current, regs);
658
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
659 660
}

661
static int perf_sysexit_enable(struct ftrace_event_call *call)
662 663 664 665
{
	int ret = 0;
	int num;

666
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
667 668

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

682
static void perf_sysexit_disable(struct ftrace_event_call *call)
683 684 685
{
	int num;

686
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
687 688

	mutex_lock(&syscall_trace_lock);
689 690 691
	sys_perf_refcount_exit--;
	clear_bit(num, enabled_perf_exit_syscalls);
	if (!sys_perf_refcount_exit)
692
		unregister_trace_sys_exit(perf_syscall_exit, NULL);
693 694 695
	mutex_unlock(&syscall_trace_lock);
}

696
#endif /* CONFIG_PERF_EVENTS */
697

698
static int syscall_enter_register(struct ftrace_event_call *event,
699
				 enum trace_reg type, void *data)
700
{
701 702
	struct ftrace_event_file *file = data;

703 704
	switch (type) {
	case TRACE_REG_REGISTER:
705
		return reg_event_syscall_enter(file, event);
706
	case TRACE_REG_UNREGISTER:
707
		unreg_event_syscall_enter(file, event);
708 709 710 711 712 713 714 715
		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;
716 717
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
718 719
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
720
		return 0;
721 722 723 724 725 726
#endif
	}
	return 0;
}

static int syscall_exit_register(struct ftrace_event_call *event,
727
				 enum trace_reg type, void *data)
728
{
729 730
	struct ftrace_event_file *file = data;

731 732
	switch (type) {
	case TRACE_REG_REGISTER:
733
		return reg_event_syscall_exit(file, event);
734
	case TRACE_REG_UNREGISTER:
735
		unreg_event_syscall_exit(file, event);
736 737 738 739 740 741 742 743
		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;
744 745
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
746 747
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
748
		return 0;
749 750 751 752
#endif
	}
	return 0;
}