trace_syscalls.c 18.4 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 trace_event_call *event,
17
				 enum trace_reg type, void *data);
18
static int syscall_exit_register(struct trace_event_call *event,
19
				 enum trace_reg type, void *data);
20

21
static struct list_head *
22
syscall_get_enter_fields(struct trace_event_call *call)
23 24 25 26 27 28
{
	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 trace_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 trace_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 trace_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 trace_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 trace_event_file *trace_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
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
308
		return;
309 310

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

315
	if (trace_trigger_soft_disabled(trace_file))
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 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
	event_trigger_unlock_commit(trace_file, buffer, event, entry,
338
				    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 trace_event_file *trace_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
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
355
		return;
356 357

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

362
	if (trace_trigger_soft_disabled(trace_file))
363
		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
	event_trigger_unlock_commit(trace_file, buffer, event, entry,
384
				    irq_flags, pc);
385 386
}

387
static int reg_event_syscall_enter(struct trace_event_file *file,
388
				   struct trace_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
static void unreg_event_syscall_enter(struct trace_event_file *file,
409
				      struct trace_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
static int reg_event_syscall_exit(struct trace_event_file *file,
426
				  struct trace_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
static void unreg_event_syscall_exit(struct trace_event_file *file,
447
				     struct trace_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 trace_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 trace_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 trace_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
void __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
	if (!syscalls_metadata) {
		WARN_ON(1);
527
		return;
528 529 530 531 532
	}

	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
		syscalls_metadata[i] = meta;
	}
}

541
#ifdef CONFIG_PERF_EVENTS
542

543 544 545 546
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;
547

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

557
	syscall_nr = trace_get_syscall_nr(current, regs);
558
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
559
		return;
560
	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
561 562 563 564 565 566
		return;

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

567 568 569 570
	head = this_cpu_ptr(sys_data->enter_event->perf_events);
	if (hlist_empty(head))
		return;

571 572 573 574 575
	/* 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);

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

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

587
static int perf_sysenter_enable(struct trace_event_call *call)
588 589 590 591
{
	int ret = 0;
	int num;

592
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
593 594

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

608
static void perf_sysenter_disable(struct trace_event_call *call)
609 610 611
{
	int num;

612
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
613 614

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

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

631
	syscall_nr = trace_get_syscall_nr(current, regs);
632
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
633
		return;
634
	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
635 636 637 638 639 640
		return;

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

641 642 643 644
	head = this_cpu_ptr(sys_data->exit_event->perf_events);
	if (hlist_empty(head))
		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
	rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
650
				sys_data->exit_event->event.type, NULL, &rctx);
651 652
	if (!rec)
		return;
653 654 655

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

659
static int perf_sysexit_enable(struct trace_event_call *call)
660 661 662 663
{
	int ret = 0;
	int num;

664
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
665 666

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

680
static void perf_sysexit_disable(struct trace_event_call *call)
681 682 683
{
	int num;

684
	num = ((struct syscall_metadata *)call->data)->syscall_nr;
685 686

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

694
#endif /* CONFIG_PERF_EVENTS */
695

696
static int syscall_enter_register(struct trace_event_call *event,
697
				 enum trace_reg type, void *data)
698
{
699
	struct trace_event_file *file = data;
700

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

724
static int syscall_exit_register(struct trace_event_call *event,
725
				 enum trace_reg type, void *data)
726
{
727
	struct trace_event_file *file = data;
728

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