xref: /linux/kernel/trace/trace_syscalls.c (revision d91517839e5d95adc0cf4b28caa7af62a71de526)
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 #include <asm/syscall.h>
10 
11 #include "trace_output.h"
12 #include "trace.h"
13 
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 static struct list_head *
22 syscall_get_enter_fields(struct ftrace_event_call *call)
23 {
24 	struct syscall_metadata *entry = call->data;
25 
26 	return &entry->enter_fields;
27 }
28 
29 extern struct syscall_metadata *__start_syscalls_metadata[];
30 extern struct syscall_metadata *__stop_syscalls_metadata[];
31 
32 static struct syscall_metadata **syscalls_metadata;
33 
34 #ifndef ARCH_HAS_SYSCALL_MATCH_SYM_NAME
35 static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
36 {
37 	/*
38 	 * Only compare after the "sys" prefix. Archs that use
39 	 * syscall wrappers may have syscalls symbols aliases prefixed
40 	 * with ".SyS" or ".sys" instead of "sys", leading to an unwanted
41 	 * mismatch.
42 	 */
43 	return !strcmp(sym + 3, name + 3);
44 }
45 #endif
46 
47 #ifdef ARCH_TRACE_IGNORE_COMPAT_SYSCALLS
48 /*
49  * Some architectures that allow for 32bit applications
50  * to run on a 64bit kernel, do not map the syscalls for
51  * the 32bit tasks the same as they do for 64bit tasks.
52  *
53  *     *cough*x86*cough*
54  *
55  * In such a case, instead of reporting the wrong syscalls,
56  * simply ignore them.
57  *
58  * For an arch to ignore the compat syscalls it needs to
59  * define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS as well as
60  * define the function arch_trace_is_compat_syscall() to let
61  * the tracing system know that it should ignore it.
62  */
63 static int
64 trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
65 {
66 	if (unlikely(arch_trace_is_compat_syscall(regs)))
67 		return -1;
68 
69 	return syscall_get_nr(task, regs);
70 }
71 #else
72 static inline int
73 trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
74 {
75 	return syscall_get_nr(task, regs);
76 }
77 #endif /* ARCH_TRACE_IGNORE_COMPAT_SYSCALLS */
78 
79 static __init struct syscall_metadata *
80 find_syscall_meta(unsigned long syscall)
81 {
82 	struct syscall_metadata **start;
83 	struct syscall_metadata **stop;
84 	char str[KSYM_SYMBOL_LEN];
85 
86 
87 	start = __start_syscalls_metadata;
88 	stop = __stop_syscalls_metadata;
89 	kallsyms_lookup(syscall, NULL, NULL, NULL, str);
90 
91 	if (arch_syscall_match_sym_name(str, "sys_ni_syscall"))
92 		return NULL;
93 
94 	for ( ; start < stop; start++) {
95 		if ((*start)->name && arch_syscall_match_sym_name(str, (*start)->name))
96 			return *start;
97 	}
98 	return NULL;
99 }
100 
101 static struct syscall_metadata *syscall_nr_to_meta(int nr)
102 {
103 	if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
104 		return NULL;
105 
106 	return syscalls_metadata[nr];
107 }
108 
109 static enum print_line_t
110 print_syscall_enter(struct trace_iterator *iter, int flags,
111 		    struct trace_event *event)
112 {
113 	struct trace_seq *s = &iter->seq;
114 	struct trace_entry *ent = iter->ent;
115 	struct syscall_trace_enter *trace;
116 	struct syscall_metadata *entry;
117 	int i, ret, syscall;
118 
119 	trace = (typeof(trace))ent;
120 	syscall = trace->nr;
121 	entry = syscall_nr_to_meta(syscall);
122 
123 	if (!entry)
124 		goto end;
125 
126 	if (entry->enter_event->event.type != ent->type) {
127 		WARN_ON_ONCE(1);
128 		goto end;
129 	}
130 
131 	ret = trace_seq_printf(s, "%s(", entry->name);
132 	if (!ret)
133 		return TRACE_TYPE_PARTIAL_LINE;
134 
135 	for (i = 0; i < entry->nb_args; i++) {
136 		/* parameter types */
137 		if (trace_flags & TRACE_ITER_VERBOSE) {
138 			ret = trace_seq_printf(s, "%s ", entry->types[i]);
139 			if (!ret)
140 				return TRACE_TYPE_PARTIAL_LINE;
141 		}
142 		/* 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 		if (!ret)
147 			return TRACE_TYPE_PARTIAL_LINE;
148 	}
149 
150 	ret = trace_seq_putc(s, ')');
151 	if (!ret)
152 		return TRACE_TYPE_PARTIAL_LINE;
153 
154 end:
155 	ret =  trace_seq_putc(s, '\n');
156 	if (!ret)
157 		return TRACE_TYPE_PARTIAL_LINE;
158 
159 	return TRACE_TYPE_HANDLED;
160 }
161 
162 static enum print_line_t
163 print_syscall_exit(struct trace_iterator *iter, int flags,
164 		   struct trace_event *event)
165 {
166 	struct trace_seq *s = &iter->seq;
167 	struct trace_entry *ent = iter->ent;
168 	struct syscall_trace_exit *trace;
169 	int syscall;
170 	struct syscall_metadata *entry;
171 	int ret;
172 
173 	trace = (typeof(trace))ent;
174 	syscall = trace->nr;
175 	entry = syscall_nr_to_meta(syscall);
176 
177 	if (!entry) {
178 		trace_seq_putc(s, '\n');
179 		return TRACE_TYPE_HANDLED;
180 	}
181 
182 	if (entry->exit_event->event.type != ent->type) {
183 		WARN_ON_ONCE(1);
184 		return TRACE_TYPE_UNHANDLED;
185 	}
186 
187 	ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
188 				trace->ret);
189 	if (!ret)
190 		return TRACE_TYPE_PARTIAL_LINE;
191 
192 	return TRACE_TYPE_HANDLED;
193 }
194 
195 extern char *__bad_type_size(void);
196 
197 #define SYSCALL_FIELD(type, name)					\
198 	sizeof(type) != sizeof(trace.name) ?				\
199 		__bad_type_size() :					\
200 		#type, #name, offsetof(typeof(trace), name),		\
201 		sizeof(trace.name), is_signed_type(type)
202 
203 static int __init
204 __set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
205 {
206 	int i;
207 	int pos = 0;
208 
209 	/* When len=0, we just calculate the needed length */
210 #define LEN_OR_ZERO (len ? len - pos : 0)
211 
212 	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
213 	for (i = 0; i < entry->nb_args; i++) {
214 		pos += snprintf(buf + pos, LEN_OR_ZERO, "%s: 0x%%0%zulx%s",
215 				entry->args[i], sizeof(unsigned long),
216 				i == entry->nb_args - 1 ? "" : ", ");
217 	}
218 	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
219 
220 	for (i = 0; i < entry->nb_args; i++) {
221 		pos += snprintf(buf + pos, LEN_OR_ZERO,
222 				", ((unsigned long)(REC->%s))", entry->args[i]);
223 	}
224 
225 #undef LEN_OR_ZERO
226 
227 	/* return the length of print_fmt */
228 	return pos;
229 }
230 
231 static int __init set_syscall_print_fmt(struct ftrace_event_call *call)
232 {
233 	char *print_fmt;
234 	int len;
235 	struct syscall_metadata *entry = call->data;
236 
237 	if (entry->enter_event != call) {
238 		call->print_fmt = "\"0x%lx\", REC->ret";
239 		return 0;
240 	}
241 
242 	/* First: called with 0 length to calculate the needed length */
243 	len = __set_enter_print_fmt(entry, NULL, 0);
244 
245 	print_fmt = kmalloc(len + 1, GFP_KERNEL);
246 	if (!print_fmt)
247 		return -ENOMEM;
248 
249 	/* Second: actually write the @print_fmt */
250 	__set_enter_print_fmt(entry, print_fmt, len + 1);
251 	call->print_fmt = print_fmt;
252 
253 	return 0;
254 }
255 
256 static void __init free_syscall_print_fmt(struct ftrace_event_call *call)
257 {
258 	struct syscall_metadata *entry = call->data;
259 
260 	if (entry->enter_event == call)
261 		kfree(call->print_fmt);
262 }
263 
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 	int ret;
269 	int i;
270 	int offset = offsetof(typeof(trace), args);
271 
272 	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
273 	if (ret)
274 		return ret;
275 
276 	for (i = 0; i < meta->nb_args; i++) {
277 		ret = trace_define_field(call, meta->types[i],
278 					 meta->args[i], offset,
279 					 sizeof(unsigned long), 0,
280 					 FILTER_OTHER);
281 		offset += sizeof(unsigned long);
282 	}
283 
284 	return ret;
285 }
286 
287 static int __init syscall_exit_define_fields(struct ftrace_event_call *call)
288 {
289 	struct syscall_trace_exit trace;
290 	int ret;
291 
292 	ret = trace_define_field(call, SYSCALL_FIELD(int, nr), FILTER_OTHER);
293 	if (ret)
294 		return ret;
295 
296 	ret = trace_define_field(call, SYSCALL_FIELD(long, ret),
297 				 FILTER_OTHER);
298 
299 	return ret;
300 }
301 
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 	struct syscall_trace_enter *entry;
307 	struct syscall_metadata *sys_data;
308 	struct ring_buffer_event *event;
309 	struct ring_buffer *buffer;
310 	unsigned long irq_flags;
311 	int pc;
312 	int syscall_nr;
313 	int size;
314 
315 	syscall_nr = trace_get_syscall_nr(current, regs);
316 	if (syscall_nr < 0)
317 		return;
318 
319 	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE) */
320 	ftrace_file = rcu_dereference_sched(tr->enter_syscall_files[syscall_nr]);
321 	if (!ftrace_file)
322 		return;
323 
324 	if (ftrace_trigger_soft_disabled(ftrace_file))
325 		return;
326 
327 	sys_data = syscall_nr_to_meta(syscall_nr);
328 	if (!sys_data)
329 		return;
330 
331 	size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
332 
333 	local_save_flags(irq_flags);
334 	pc = preempt_count();
335 
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 	if (!event)
340 		return;
341 
342 	entry = ring_buffer_event_data(event);
343 	entry->nr = syscall_nr;
344 	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
345 
346 	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
347 				    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 	struct syscall_trace_exit *entry;
355 	struct syscall_metadata *sys_data;
356 	struct ring_buffer_event *event;
357 	struct ring_buffer *buffer;
358 	unsigned long irq_flags;
359 	int pc;
360 	int syscall_nr;
361 
362 	syscall_nr = trace_get_syscall_nr(current, regs);
363 	if (syscall_nr < 0)
364 		return;
365 
366 	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE()) */
367 	ftrace_file = rcu_dereference_sched(tr->exit_syscall_files[syscall_nr]);
368 	if (!ftrace_file)
369 		return;
370 
371 	if (ftrace_trigger_soft_disabled(ftrace_file))
372 		return;
373 
374 	sys_data = syscall_nr_to_meta(syscall_nr);
375 	if (!sys_data)
376 		return;
377 
378 	local_save_flags(irq_flags);
379 	pc = preempt_count();
380 
381 	buffer = tr->trace_buffer.buffer;
382 	event = trace_buffer_lock_reserve(buffer,
383 			sys_data->exit_event->event.type, sizeof(*entry),
384 			irq_flags, pc);
385 	if (!event)
386 		return;
387 
388 	entry = ring_buffer_event_data(event);
389 	entry->nr = syscall_nr;
390 	entry->ret = syscall_get_return_value(current, regs);
391 
392 	event_trigger_unlock_commit(ftrace_file, buffer, event, entry,
393 				    irq_flags, pc);
394 }
395 
396 static int reg_event_syscall_enter(struct ftrace_event_file *file,
397 				   struct ftrace_event_call *call)
398 {
399 	struct trace_array *tr = file->tr;
400 	int ret = 0;
401 	int num;
402 
403 	num = ((struct syscall_metadata *)call->data)->syscall_nr;
404 	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
405 		return -ENOSYS;
406 	mutex_lock(&syscall_trace_lock);
407 	if (!tr->sys_refcount_enter)
408 		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 	mutex_unlock(&syscall_trace_lock);
414 	return ret;
415 }
416 
417 static void unreg_event_syscall_enter(struct ftrace_event_file *file,
418 				      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 		return;
426 	mutex_lock(&syscall_trace_lock);
427 	tr->sys_refcount_enter--;
428 	rcu_assign_pointer(tr->enter_syscall_files[num], NULL);
429 	if (!tr->sys_refcount_enter)
430 		unregister_trace_sys_enter(ftrace_syscall_enter, tr);
431 	mutex_unlock(&syscall_trace_lock);
432 }
433 
434 static int reg_event_syscall_exit(struct ftrace_event_file *file,
435 				  struct ftrace_event_call *call)
436 {
437 	struct trace_array *tr = file->tr;
438 	int ret = 0;
439 	int num;
440 
441 	num = ((struct syscall_metadata *)call->data)->syscall_nr;
442 	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
443 		return -ENOSYS;
444 	mutex_lock(&syscall_trace_lock);
445 	if (!tr->sys_refcount_exit)
446 		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 	mutex_unlock(&syscall_trace_lock);
452 	return ret;
453 }
454 
455 static void unreg_event_syscall_exit(struct ftrace_event_file *file,
456 				     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 		return;
464 	mutex_lock(&syscall_trace_lock);
465 	tr->sys_refcount_exit--;
466 	rcu_assign_pointer(tr->exit_syscall_files[num], NULL);
467 	if (!tr->sys_refcount_exit)
468 		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 	int num;
476 
477 	num = ((struct syscall_metadata *)call->data)->syscall_nr;
478 	if (num < 0 || num >= NR_syscalls) {
479 		pr_debug("syscall %s metadata not mapped, disabling ftrace event\n",
480 				((struct syscall_metadata *)call->data)->name);
481 		return -ENOSYS;
482 	}
483 
484 	if (set_syscall_print_fmt(call) < 0)
485 		return -ENOMEM;
486 
487 	id = trace_event_raw_init(call);
488 
489 	if (id < 0) {
490 		free_syscall_print_fmt(call);
491 		return id;
492 	}
493 
494 	return id;
495 }
496 
497 struct trace_event_functions enter_syscall_print_funcs = {
498 	.trace		= print_syscall_enter,
499 };
500 
501 struct trace_event_functions exit_syscall_print_funcs = {
502 	.trace		= print_syscall_exit,
503 };
504 
505 struct ftrace_event_class __refdata event_class_syscall_enter = {
506 	.system		= "syscalls",
507 	.reg		= syscall_enter_register,
508 	.define_fields	= syscall_enter_define_fields,
509 	.get_fields	= syscall_get_enter_fields,
510 	.raw_init	= init_syscall_trace,
511 };
512 
513 struct ftrace_event_class __refdata event_class_syscall_exit = {
514 	.system		= "syscalls",
515 	.reg		= syscall_exit_register,
516 	.define_fields	= syscall_exit_define_fields,
517 	.fields		= LIST_HEAD_INIT(event_class_syscall_exit.fields),
518 	.raw_init	= init_syscall_trace,
519 };
520 
521 unsigned long __init __weak arch_syscall_addr(int nr)
522 {
523 	return (unsigned long)sys_call_table[nr];
524 }
525 
526 static int __init init_ftrace_syscalls(void)
527 {
528 	struct syscall_metadata *meta;
529 	unsigned long addr;
530 	int i;
531 
532 	syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
533 				    GFP_KERNEL);
534 	if (!syscalls_metadata) {
535 		WARN_ON(1);
536 		return -ENOMEM;
537 	}
538 
539 	for (i = 0; i < NR_syscalls; i++) {
540 		addr = arch_syscall_addr(i);
541 		meta = find_syscall_meta(addr);
542 		if (!meta)
543 			continue;
544 
545 		meta->syscall_nr = i;
546 		syscalls_metadata[i] = meta;
547 	}
548 
549 	return 0;
550 }
551 early_initcall(init_ftrace_syscalls);
552 
553 #ifdef CONFIG_PERF_EVENTS
554 
555 static DECLARE_BITMAP(enabled_perf_enter_syscalls, NR_syscalls);
556 static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);
557 static int sys_perf_refcount_enter;
558 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 	if (syscall_nr < 0)
571 		return;
572 	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
573 		return;
574 
575 	sys_data = syscall_nr_to_meta(syscall_nr);
576 	if (!sys_data)
577 		return;
578 
579 	head = this_cpu_ptr(sys_data->enter_event->perf_events);
580 	if (hlist_empty(head))
581 		return;
582 
583 	/* get the size after alignment with the u32 buffer size field */
584 	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
585 	size = ALIGN(size + sizeof(u32), sizeof(u64));
586 	size -= sizeof(u32);
587 
588 	rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
589 				sys_data->enter_event->event.type, regs, &rctx);
590 	if (!rec)
591 		return;
592 
593 	rec->nr = syscall_nr;
594 	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
595 			       (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 	int ret = 0;
602 	int num;
603 
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 	if (ret) {
610 		pr_info("event trace: Could not activate"
611 				"syscall entry trace point");
612 	} else {
613 		set_bit(num, enabled_perf_enter_syscalls);
614 		sys_perf_refcount_enter++;
615 	}
616 	mutex_unlock(&syscall_trace_lock);
617 	return ret;
618 }
619 
620 static void perf_sysenter_disable(struct ftrace_event_call *call)
621 {
622 	int num;
623 
624 	num = ((struct syscall_metadata *)call->data)->syscall_nr;
625 
626 	mutex_lock(&syscall_trace_lock);
627 	sys_perf_refcount_enter--;
628 	clear_bit(num, enabled_perf_enter_syscalls);
629 	if (!sys_perf_refcount_enter)
630 		unregister_trace_sys_enter(perf_syscall_enter, NULL);
631 	mutex_unlock(&syscall_trace_lock);
632 }
633 
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 	if (syscall_nr < 0)
645 		return;
646 	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
647 		return;
648 
649 	sys_data = syscall_nr_to_meta(syscall_nr);
650 	if (!sys_data)
651 		return;
652 
653 	head = this_cpu_ptr(sys_data->exit_event->perf_events);
654 	if (hlist_empty(head))
655 		return;
656 
657 	/* We can probably do that at build time */
658 	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
659 	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 	if (!rec)
664 		return;
665 
666 	rec->nr = syscall_nr;
667 	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 	int ret = 0;
674 	int num;
675 
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 	if (ret) {
682 		pr_info("event trace: Could not activate"
683 				"syscall exit trace point");
684 	} else {
685 		set_bit(num, enabled_perf_exit_syscalls);
686 		sys_perf_refcount_exit++;
687 	}
688 	mutex_unlock(&syscall_trace_lock);
689 	return ret;
690 }
691 
692 static void perf_sysexit_disable(struct ftrace_event_call *call)
693 {
694 	int num;
695 
696 	num = ((struct syscall_metadata *)call->data)->syscall_nr;
697 
698 	mutex_lock(&syscall_trace_lock);
699 	sys_perf_refcount_exit--;
700 	clear_bit(num, enabled_perf_exit_syscalls);
701 	if (!sys_perf_refcount_exit)
702 		unregister_trace_sys_exit(perf_syscall_exit, NULL);
703 	mutex_unlock(&syscall_trace_lock);
704 }
705 
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 	struct ftrace_event_file *file = data;
712 
713 	switch (type) {
714 	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 		return 0;
719 
720 #ifdef CONFIG_PERF_EVENTS
721 	case TRACE_REG_PERF_REGISTER:
722 		return perf_sysenter_enable(event);
723 	case TRACE_REG_PERF_UNREGISTER:
724 		perf_sysenter_disable(event);
725 		return 0;
726 	case TRACE_REG_PERF_OPEN:
727 	case TRACE_REG_PERF_CLOSE:
728 	case TRACE_REG_PERF_ADD:
729 	case TRACE_REG_PERF_DEL:
730 		return 0;
731 #endif
732 	}
733 	return 0;
734 }
735 
736 static int syscall_exit_register(struct ftrace_event_call *event,
737 				 enum trace_reg type, void *data)
738 {
739 	struct ftrace_event_file *file = data;
740 
741 	switch (type) {
742 	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 		return 0;
747 
748 #ifdef CONFIG_PERF_EVENTS
749 	case TRACE_REG_PERF_REGISTER:
750 		return perf_sysexit_enable(event);
751 	case TRACE_REG_PERF_UNREGISTER:
752 		perf_sysexit_disable(event);
753 		return 0;
754 	case TRACE_REG_PERF_OPEN:
755 	case TRACE_REG_PERF_CLOSE:
756 	case TRACE_REG_PERF_ADD:
757 	case TRACE_REG_PERF_DEL:
758 		return 0;
759 #endif
760 	}
761 	return 0;
762 }
763