trace_syscalls.c 18.6 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
	struct ftrace_event_file *ftrace_file;
306 307 308
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
309
	struct ring_buffer *buffer;
310 311
	unsigned long irq_flags;
	int pc;
312
	int syscall_nr;
313
	int size;
314

315
	syscall_nr = trace_get_syscall_nr(current, regs);
316 317
	if (syscall_nr < 0)
		return;
318 319 320 321 322 323

	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE) */
	ftrace_file = rcu_dereference_sched(tr->enter_syscall_files[syscall_nr]);
	if (!ftrace_file)
		return;

324 325
	if (ftrace_trigger_soft_disabled(ftrace_file))
		return;
326

327 328 329 330 331 332
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

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

333 334 335
	local_save_flags(irq_flags);
	pc = preempt_count();

336
	buffer = tr->trace_buffer.buffer;
337
	event = trace_buffer_lock_reserve(buffer,
338
			sys_data->enter_event->event.type, size, irq_flags, pc);
339 340 341 342 343 344 345
	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);

346 347
	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
				    irq_flags, pc);
348 349
}

350
static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
351
{
352
	struct trace_array *tr = data;
353
	struct ftrace_event_file *ftrace_file;
354 355 356
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
357
	struct ring_buffer *buffer;
358 359
	unsigned long irq_flags;
	int pc;
360 361
	int syscall_nr;

362
	syscall_nr = trace_get_syscall_nr(current, regs);
363 364
	if (syscall_nr < 0)
		return;
365 366 367 368 369 370

	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE()) */
	ftrace_file = rcu_dereference_sched(tr->exit_syscall_files[syscall_nr]);
	if (!ftrace_file)
		return;

371 372
	if (ftrace_trigger_soft_disabled(ftrace_file))
		return;
373

374 375 376 377
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

378 379 380
	local_save_flags(irq_flags);
	pc = preempt_count();

381
	buffer = tr->trace_buffer.buffer;
382
	event = trace_buffer_lock_reserve(buffer,
383 384
			sys_data->exit_event->event.type, sizeof(*entry),
			irq_flags, pc);
385 386 387 388 389 390 391
	if (!event)
		return;

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

392 393
	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
				    irq_flags, pc);
394 395
}

396 397
static int reg_event_syscall_enter(struct ftrace_event_file *file,
				   struct ftrace_event_call *call)
398
{
399
	struct trace_array *tr = file->tr;
400 401 402
	int ret = 0;
	int num;

403
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
404
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
405 406
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
407 408
	if (!tr->sys_refcount_enter)
		ret = register_trace_sys_enter(ftrace_syscall_enter, tr);
409
	if (!ret) {
410
		rcu_assign_pointer(tr->enter_syscall_files[num], file);
411
		tr->sys_refcount_enter++;
412 413 414
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
415 416
}

417 418
static void unreg_event_syscall_enter(struct ftrace_event_file *file,
				      struct ftrace_event_call *call)
419
{
420
	struct trace_array *tr = file->tr;
421
	int num;
422

423
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
424
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
425 426
		return;
	mutex_lock(&syscall_trace_lock);
427
	tr->sys_refcount_enter--;
428
	RCU_INIT_POINTER(tr->enter_syscall_files[num], NULL);
429 430
	if (!tr->sys_refcount_enter)
		unregister_trace_sys_enter(ftrace_syscall_enter, tr);
431 432
	mutex_unlock(&syscall_trace_lock);
}
433

434 435
static int reg_event_syscall_exit(struct ftrace_event_file *file,
				  struct ftrace_event_call *call)
436
{
437
	struct trace_array *tr = file->tr;
438 439 440
	int ret = 0;
	int num;

441
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
442
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
443 444
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
445 446
	if (!tr->sys_refcount_exit)
		ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
447
	if (!ret) {
448
		rcu_assign_pointer(tr->exit_syscall_files[num], file);
449
		tr->sys_refcount_exit++;
450
	}
451 452 453
	mutex_unlock(&syscall_trace_lock);
	return ret;
}
454

455 456
static void unreg_event_syscall_exit(struct ftrace_event_file *file,
				     struct ftrace_event_call *call)
457
{
458
	struct trace_array *tr = file->tr;
459
	int num;
460

461
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
462
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
463 464
		return;
	mutex_lock(&syscall_trace_lock);
465
	tr->sys_refcount_exit--;
466
	RCU_INIT_POINTER(tr->exit_syscall_files[num], NULL);
467 468
	if (!tr->sys_refcount_exit)
		unregister_trace_sys_exit(ftrace_syscall_exit, tr);
469
	mutex_unlock(&syscall_trace_lock);
470
}
471

472
static int __init init_syscall_trace(struct ftrace_event_call *call)
473 474
{
	int id;
475 476 477 478 479 480 481 482
	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;
	}
483

484 485 486
	if (set_syscall_print_fmt(call) < 0)
		return -ENOMEM;

487 488 489
	id = trace_event_raw_init(call);

	if (id < 0) {
490
		free_syscall_print_fmt(call);
491
		return id;
492
	}
493 494

	return id;
495 496
}

497 498 499 500 501 502 503 504
struct trace_event_functions enter_syscall_print_funcs = {
	.trace		= print_syscall_enter,
};

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

505
struct ftrace_event_class __refdata event_class_syscall_enter = {
506 507 508 509 510 511 512
	.system		= "syscalls",
	.reg		= syscall_enter_register,
	.define_fields	= syscall_enter_define_fields,
	.get_fields	= syscall_get_enter_fields,
	.raw_init	= init_syscall_trace,
};

513
struct ftrace_event_class __refdata event_class_syscall_exit = {
514 515 516 517 518 519 520
	.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,
};

521
unsigned long __init __weak arch_syscall_addr(int nr)
522 523 524 525
{
	return (unsigned long)sys_call_table[nr];
}

526
static int __init init_ftrace_syscalls(void)
527 528 529 530 531
{
	struct syscall_metadata *meta;
	unsigned long addr;
	int i;

532 533
	syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
				    GFP_KERNEL);
534 535 536 537 538 539 540 541
	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);
542 543 544 545
		if (!meta)
			continue;

		meta->syscall_nr = i;
546 547 548 549 550
		syscalls_metadata[i] = meta;
	}

	return 0;
}
551
early_initcall(init_ftrace_syscalls);
552

553
#ifdef CONFIG_PERF_EVENTS
554

555 556 557 558
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;
559

560
static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
561 562
{
	struct syscall_metadata *sys_data;
563
	struct syscall_trace_enter *rec;
564
	struct hlist_head *head;
565
	int syscall_nr;
566
	int rctx;
567
	int size;
568

569
	syscall_nr = trace_get_syscall_nr(current, regs);
570 571
	if (syscall_nr < 0)
		return;
572
	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
573 574 575 576 577 578
		return;

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

579 580 581 582
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
	if (hlist_empty(head))
		return;

583 584 585 586 587
	/* 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);

588
	rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
589
				sys_data->enter_event->event.type, regs, &rctx);
590 591
	if (!rec)
		return;
592 593 594 595

	rec->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
			       (unsigned long *)&rec->args);
596
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
597 598
}

599
static int perf_sysenter_enable(struct ftrace_event_call *call)
600 601 602 603
{
	int ret = 0;
	int num;

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

	mutex_lock(&syscall_trace_lock);
607
	if (!sys_perf_refcount_enter)
608
		ret = register_trace_sys_enter(perf_syscall_enter, NULL);
609 610 611 612
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
613 614
		set_bit(num, enabled_perf_enter_syscalls);
		sys_perf_refcount_enter++;
615 616 617 618 619
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

620
static void perf_sysenter_disable(struct ftrace_event_call *call)
621 622 623
{
	int num;

624
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
625 626

	mutex_lock(&syscall_trace_lock);
627 628 629
	sys_perf_refcount_enter--;
	clear_bit(num, enabled_perf_enter_syscalls);
	if (!sys_perf_refcount_enter)
630
		unregister_trace_sys_enter(perf_syscall_enter, NULL);
631 632 633
	mutex_unlock(&syscall_trace_lock);
}

634
static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
635 636
{
	struct syscall_metadata *sys_data;
637
	struct syscall_trace_exit *rec;
638
	struct hlist_head *head;
639
	int syscall_nr;
640
	int rctx;
641
	int size;
642

643
	syscall_nr = trace_get_syscall_nr(current, regs);
644 645
	if (syscall_nr < 0)
		return;
646
	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
647 648 649 650 651 652
		return;

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

653 654 655 656
	head = this_cpu_ptr(sys_data->exit_event->perf_events);
	if (hlist_empty(head))
		return;

657 658 659
	/* We can probably do that at build time */
	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);
660

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

	rec->nr = syscall_nr;
	rec->ret = syscall_get_return_value(current, regs);
668
	perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
669 670
}

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

676
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
677 678

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

692
static void perf_sysexit_disable(struct ftrace_event_call *call)
693 694 695
{
	int num;

696
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
697 698

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

706
#endif /* CONFIG_PERF_EVENTS */
707

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

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

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

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