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
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_enter *trace;
	struct syscall_metadata *entry;
117
	int i, syscall;
118

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
	trace_seq_printf(s, "%s(", entry->name);
132 133

	for (i = 0; i < entry->nb_args; i++) {
134 135 136 137

		if (trace_seq_has_overflowed(s))
			goto end;

138
		/* parameter types */
139 140 141
		if (trace_flags & TRACE_ITER_VERBOSE)
			trace_seq_printf(s, "%s ", entry->types[i]);

142
		/* parameter values */
143 144 145
		trace_seq_printf(s, "%s: %lx%s", entry->args[i],
				 trace->args[i],
				 i == entry->nb_args - 1 ? "" : ", ");
146 147
	}

148
	trace_seq_putc(s, ')');
149
end:
150
	trace_seq_putc(s, '\n');
151

152
	return trace_handle_return(s);
153 154
}

155
static enum print_line_t
156 157
print_syscall_exit(struct trace_iterator *iter, int flags,
		   struct trace_event *event)
158 159 160 161 162 163 164
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_exit *trace;
	int syscall;
	struct syscall_metadata *entry;

165
	trace = (typeof(trace))ent;
166 167
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);
168

169
	if (!entry) {
170
		trace_seq_putc(s, '\n');
171
		goto out;
172 173
	}

174
	if (entry->exit_event->event.type != ent->type) {
175 176 177 178
		WARN_ON_ONCE(1);
		return TRACE_TYPE_UNHANDLED;
	}

179
	trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
180 181
				trace->ret);

182 183
 out:
	return trace_handle_return(s);
184 185
}

186 187 188 189 190
extern char *__bad_type_size(void);

#define SYSCALL_FIELD(type, name)					\
	sizeof(type) != sizeof(trace.name) ?				\
		__bad_type_size() :					\
191 192
		#type, #name, offsetof(typeof(trace), name),		\
		sizeof(trace.name), is_signed_type(type)
193

194 195
static int __init
__set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
{
	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;
}

222
static int __init set_syscall_print_fmt(struct ftrace_event_call *call)
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
{
	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;
}

247
static void __init free_syscall_print_fmt(struct ftrace_event_call *call)
248 249 250 251 252 253 254
{
	struct syscall_metadata *entry = call->data;

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

255
static int __init syscall_enter_define_fields(struct ftrace_event_call *call)
256 257
{
	struct syscall_trace_enter trace;
258
	struct syscall_metadata *meta = call->data;
259 260 261 262
	int ret;
	int i;
	int offset = offsetof(typeof(trace), args);

263 264 265 266
	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
	if (ret)
		return ret;

267
	for (i = 0; i < meta->nb_args; i++) {
268 269
		ret = trace_define_field(call, meta->types[i],
					 meta->args[i], offset,
270 271
					 sizeof(unsigned long), 0,
					 FILTER_OTHER);
272 273 274 275 276 277
		offset += sizeof(unsigned long);
	}

	return ret;
}

278
static int __init syscall_exit_define_fields(struct ftrace_event_call *call)
279 280 281 282
{
	struct syscall_trace_exit trace;
	int ret;

283 284 285 286
	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
	if (ret)
		return ret;

287
	ret = trace_define_field(call, SYSCALL_FIELD(long, ret),
288
				 FILTER_OTHER);
289 290 291 292

	return ret;
}

293
static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
294
{
295
	struct trace_array *tr = data;
296
	struct ftrace_event_file *ftrace_file;
297 298 299
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
300
	struct ring_buffer *buffer;
301 302
	unsigned long irq_flags;
	int pc;
303
	int syscall_nr;
304
	int size;
305

306
	syscall_nr = trace_get_syscall_nr(current, regs);
307 308
	if (syscall_nr < 0)
		return;
309 310 311 312 313 314

	/* 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;

315 316
	if (ftrace_trigger_soft_disabled(ftrace_file))
		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 325 326
	local_save_flags(irq_flags);
	pc = preempt_count();

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

337 338
	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
				    irq_flags, pc);
339 340
}

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

353
	syscall_nr = trace_get_syscall_nr(current, regs);
354 355
	if (syscall_nr < 0)
		return;
356 357 358 359 360 361

	/* 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;

362 363
	if (ftrace_trigger_soft_disabled(ftrace_file))
		return;
364

365 366 367 368
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

369 370 371
	local_save_flags(irq_flags);
	pc = preempt_count();

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

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

383 384
	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
				    irq_flags, pc);
385 386
}

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

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

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

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

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

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

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

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

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

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

478 479 480
	id = trace_event_raw_init(call);

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

	return id;
486 487
}

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

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

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

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

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

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

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

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

	return 0;
}
542
early_initcall(init_ftrace_syscalls);
543

544
#ifdef CONFIG_PERF_EVENTS
545

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

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

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

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

570 571 572 573
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
	if (hlist_empty(head))
		return;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

652
	rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
653
				sys_data->exit_event->event.type, regs, &rctx);
654 655
	if (!rec)
		return;
656 657 658

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

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

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

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

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

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

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

697
#endif /* CONFIG_PERF_EVENTS */
698

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

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

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

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