projects / lttng-modules.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Kconfig: fix dependency issue when building in-tree without CONFIG_FTRACE
[lttng-modules.git] / src / lttng-syscalls.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
2 *
3 * lttng-syscalls.c
4 *
5 * LTTng syscall probes.
6 *
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 */
9
10#include <linux/module.h>
11#include <linux/slab.h>
12#include <linux/compat.h>
13#include <linux/err.h>
14#include <linux/bitmap.h>
15#include <linux/in.h>
16#include <linux/in6.h>
17#include <linux/seq_file.h>
18#include <linux/stringify.h>
19#include <linux/file.h>
20#include <linux/anon_inodes.h>
21#include <linux/fcntl.h>
22#include <linux/mman.h>
23#include <asm/ptrace.h>
24#include <asm/syscall.h>
25
26#include <lttng/bitfield.h>
27#include <wrapper/tracepoint.h>
28#include <wrapper/file.h>
29#include <wrapper/rcu.h>
30#include <wrapper/syscall.h>
31#include <lttng/events.h>
32
33#ifndef CONFIG_COMPAT
34# ifndef is_compat_task
35# define is_compat_task() (0)
36# endif
37#endif
38
39/* in_compat_syscall appears in kernel 4.6. */
40#ifndef in_compat_syscall
41 #define in_compat_syscall() is_compat_task()
42#endif
43
44enum sc_type {
45 SC_TYPE_ENTRY,
46 SC_TYPE_EXIT,
47 SC_TYPE_COMPAT_ENTRY,
48 SC_TYPE_COMPAT_EXIT,
49};
50
51#define SYSCALL_ENTRY_TOK syscall_entry_
52#define COMPAT_SYSCALL_ENTRY_TOK compat_syscall_entry_
53#define SYSCALL_EXIT_TOK syscall_exit_
54#define COMPAT_SYSCALL_EXIT_TOK compat_syscall_exit_
55
56#define SYSCALL_ENTRY_STR __stringify(SYSCALL_ENTRY_TOK)
57#define COMPAT_SYSCALL_ENTRY_STR __stringify(COMPAT_SYSCALL_ENTRY_TOK)
58#define SYSCALL_EXIT_STR __stringify(SYSCALL_EXIT_TOK)
59#define COMPAT_SYSCALL_EXIT_STR __stringify(COMPAT_SYSCALL_EXIT_TOK)
60
61static
62void syscall_entry_probe(void *__data, struct pt_regs *regs, long id);
63static
64void syscall_exit_probe(void *__data, struct pt_regs *regs, long ret);
65
66/*
67 * Forward declarations for old kernels.
68 */
69struct mmsghdr;
70struct rlimit64;
71struct oldold_utsname;
72struct old_utsname;
73struct sel_arg_struct;
74struct mmap_arg_struct;
75struct file_handle;
76struct user_msghdr;
77
78/*
79 * Forward declaration for kernels >= 5.6
80 */
81struct timex;
82struct timeval;
83struct itimerval;
84struct itimerspec;
85
86#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
87typedef __kernel_old_time_t time_t;
88#endif
89
90#ifdef IA32_NR_syscalls
91#define NR_compat_syscalls IA32_NR_syscalls
92#else
93#define NR_compat_syscalls NR_syscalls
94#endif
95
96/*
97 * Create LTTng tracepoint probes.
98 */
99#define LTTNG_PACKAGE_BUILD
100#define CREATE_TRACE_POINTS
101#define TP_MODULE_NOINIT
102#define TRACE_INCLUDE_PATH instrumentation/syscalls/headers
103
104#define PARAMS(args...) args
105
106/* Handle unknown syscalls */
107#undef TRACE_SYSTEM
108#define TRACE_SYSTEM syscalls_unknown
109#include <instrumentation/syscalls/headers/syscalls_unknown.h>
110#undef TRACE_SYSTEM
111
112#define SC_ENTER
113
114#undef sc_exit
115#define sc_exit(...)
116#undef sc_in
117#define sc_in(...) __VA_ARGS__
118#undef sc_out
119#define sc_out(...)
120#undef sc_inout
121#define sc_inout(...) __VA_ARGS__
122
123/* Hijack probe callback for system call enter */
124#undef TP_PROBE_CB
125#define TP_PROBE_CB(_template) &syscall_entry_probe
126#define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
127 LTTNG_TRACEPOINT_EVENT(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
128 PARAMS(_fields))
129#define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
130 LTTNG_TRACEPOINT_EVENT_CODE(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
131 PARAMS(_locvar), PARAMS(_code_pre), \
132 PARAMS(_fields), PARAMS(_code_post))
133#define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
134 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_entry_##_name, PARAMS(_fields))
135#define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
136 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_entry_##_template, syscall_entry_##_name)
137/* Enumerations only defined at first inclusion. */
138#define SC_LTTNG_TRACEPOINT_ENUM(_name, _values) \
139 LTTNG_TRACEPOINT_ENUM(_name, PARAMS(_values))
140#undef TRACE_SYSTEM
141#define TRACE_SYSTEM syscall_entry_integers
142#define TRACE_INCLUDE_FILE syscalls_integers
143#include <instrumentation/syscalls/headers/syscalls_integers.h>
144#undef TRACE_INCLUDE_FILE
145#undef TRACE_SYSTEM
146#define TRACE_SYSTEM syscall_entry_pointers
147#define TRACE_INCLUDE_FILE syscalls_pointers
148#include <instrumentation/syscalls/headers/syscalls_pointers.h>
149#undef TRACE_INCLUDE_FILE
150#undef TRACE_SYSTEM
151#undef SC_LTTNG_TRACEPOINT_ENUM
152#undef SC_LTTNG_TRACEPOINT_EVENT_CODE
153#undef SC_LTTNG_TRACEPOINT_EVENT
154#undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
155#undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
156#undef TP_PROBE_CB
157#undef _TRACE_SYSCALLS_INTEGERS_H
158#undef _TRACE_SYSCALLS_POINTERS_H
159
160/* Hijack probe callback for compat system call enter */
161#define TP_PROBE_CB(_template) &syscall_entry_probe
162#define LTTNG_SC_COMPAT
163#define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
164 LTTNG_TRACEPOINT_EVENT(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
165 PARAMS(_fields))
166#define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
167 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
168 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
169#define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
170 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_entry_##_name, PARAMS(_fields))
171#define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
172 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_entry_##_template, \
173 compat_syscall_entry_##_name)
174/* Enumerations only defined at inital inclusion (not here). */
175#define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
176#define TRACE_SYSTEM compat_syscall_entry_integers
177#define TRACE_INCLUDE_FILE compat_syscalls_integers
178#include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
179#undef TRACE_INCLUDE_FILE
180#undef TRACE_SYSTEM
181#define TRACE_SYSTEM compat_syscall_entry_pointers
182#define TRACE_INCLUDE_FILE compat_syscalls_pointers
183#include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
184#undef TRACE_INCLUDE_FILE
185#undef TRACE_SYSTEM
186#undef SC_LTTNG_TRACEPOINT_ENUM
187#undef SC_LTTNG_TRACEPOINT_EVENT_CODE
188#undef SC_LTTNG_TRACEPOINT_EVENT
189#undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
190#undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
191#undef TP_PROBE_CB
192#undef _TRACE_SYSCALLS_INTEGERS_H
193#undef _TRACE_SYSCALLS_POINTERS_H
194#undef LTTNG_SC_COMPAT
195
196#undef SC_ENTER
197
198#define SC_EXIT
199
200#undef sc_exit
201#define sc_exit(...) __VA_ARGS__
202#undef sc_in
203#define sc_in(...)
204#undef sc_out
205#define sc_out(...) __VA_ARGS__
206#undef sc_inout
207#define sc_inout(...) __VA_ARGS__
208
209/* Hijack probe callback for system call exit */
210#define TP_PROBE_CB(_template) &syscall_exit_probe
211#define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
212 LTTNG_TRACEPOINT_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
213 PARAMS(_fields))
214#define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
215 LTTNG_TRACEPOINT_EVENT_CODE(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
216 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
217#define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
218 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_fields))
219#define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
220 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_exit_##_template, \
221 syscall_exit_##_name)
222/* Enumerations only defined at inital inclusion (not here). */
223#define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
224#define TRACE_SYSTEM syscall_exit_integers
225#define TRACE_INCLUDE_FILE syscalls_integers
226#include <instrumentation/syscalls/headers/syscalls_integers.h>
227#undef TRACE_INCLUDE_FILE
228#undef TRACE_SYSTEM
229#define TRACE_SYSTEM syscall_exit_pointers
230#define TRACE_INCLUDE_FILE syscalls_pointers
231#include <instrumentation/syscalls/headers/syscalls_pointers.h>
232#undef TRACE_INCLUDE_FILE
233#undef TRACE_SYSTEM
234#undef SC_LTTNG_TRACEPOINT_ENUM
235#undef SC_LTTNG_TRACEPOINT_EVENT_CODE
236#undef SC_LTTNG_TRACEPOINT_EVENT
237#undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
238#undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
239#undef TP_PROBE_CB
240#undef _TRACE_SYSCALLS_INTEGERS_H
241#undef _TRACE_SYSCALLS_POINTERS_H
242
243
244/* Hijack probe callback for compat system call exit */
245#define TP_PROBE_CB(_template) &syscall_exit_probe
246#define LTTNG_SC_COMPAT
247#define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
248 LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
249 PARAMS(_fields))
250#define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
251 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
252 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
253#define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
254 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_fields))
255#define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
256 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_exit_##_template, \
257 compat_syscall_exit_##_name)
258/* Enumerations only defined at inital inclusion (not here). */
259#define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
260#define TRACE_SYSTEM compat_syscall_exit_integers
261#define TRACE_INCLUDE_FILE compat_syscalls_integers
262#include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
263#undef TRACE_INCLUDE_FILE
264#undef TRACE_SYSTEM
265#define TRACE_SYSTEM compat_syscall_exit_pointers
266#define TRACE_INCLUDE_FILE compat_syscalls_pointers
267#include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
268#undef TRACE_INCLUDE_FILE
269#undef TRACE_SYSTEM
270#undef SC_LTTNG_TRACEPOINT_ENUM
271#undef SC_LTTNG_TRACEPOINT_EVENT_CODE
272#undef SC_LTTNG_TRACEPOINT_EVENT
273#undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
274#undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
275#undef TP_PROBE_CB
276#undef _TRACE_SYSCALLS_INTEGERS_H
277#undef _TRACE_SYSCALLS_POINTERS_H
278#undef LTTNG_SC_COMPAT
279
280#undef SC_EXIT
281
282#undef TP_MODULE_NOINIT
283#undef LTTNG_PACKAGE_BUILD
284#undef CREATE_TRACE_POINTS
285
286struct trace_syscall_entry {
287 void *func;
288 const struct lttng_event_desc *desc;
289 const struct lttng_event_field *fields;
290 unsigned int nrargs;
291};
292
293#define CREATE_SYSCALL_TABLE
294
295#define SC_ENTER
296
297#undef sc_exit
298#define sc_exit(...)
299
300#undef TRACE_SYSCALL_TABLE
301#define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
302 [ _nr ] = { \
303 .func = __event_probe__syscall_entry_##_template, \
304 .nrargs = (_nrargs), \
305 .fields = __event_fields___syscall_entry_##_template, \
306 .desc = &__event_desc___syscall_entry_##_name, \
307 },
308
309/* Syscall enter tracing table */
310static const struct trace_syscall_entry sc_table[] = {
311#include <instrumentation/syscalls/headers/syscalls_integers.h>
312#include <instrumentation/syscalls/headers/syscalls_pointers.h>
313};
314
315#undef TRACE_SYSCALL_TABLE
316#define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
317 [ _nr ] = { \
318 .func = __event_probe__compat_syscall_entry_##_template, \
319 .nrargs = (_nrargs), \
320 .fields = __event_fields___compat_syscall_entry_##_template, \
321 .desc = &__event_desc___compat_syscall_entry_##_name, \
322 },
323
324/* Compat syscall enter table */
325const struct trace_syscall_entry compat_sc_table[] = {
326#include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
327#include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
328};
329
330#undef SC_ENTER
331
332#define SC_EXIT
333
334#undef sc_exit
335#define sc_exit(...) __VA_ARGS__
336
337#undef TRACE_SYSCALL_TABLE
338#define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
339 [ _nr ] = { \
340 .func = __event_probe__syscall_exit_##_template, \
341 .nrargs = (_nrargs), \
342 .fields = __event_fields___syscall_exit_##_template, \
343 .desc = &__event_desc___syscall_exit_##_name, \
344 },
345
346/* Syscall exit table */
347static const struct trace_syscall_entry sc_exit_table[] = {
348#include <instrumentation/syscalls/headers/syscalls_integers.h>
349#include <instrumentation/syscalls/headers/syscalls_pointers.h>
350};
351
352#undef TRACE_SYSCALL_TABLE
353#define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
354 [ _nr ] = { \
355 .func = __event_probe__compat_syscall_exit_##_template, \
356 .nrargs = (_nrargs), \
357 .fields = __event_fields___compat_syscall_exit_##_template, \
358 .desc = &__event_desc___compat_syscall_exit_##_name, \
359 },
360
361/* Compat syscall exit table */
362const struct trace_syscall_entry compat_sc_exit_table[] = {
363#include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
364#include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
365};
366
367#undef SC_EXIT
368
369#undef CREATE_SYSCALL_TABLE
370
371struct lttng_syscall_filter {
372 DECLARE_BITMAP(sc, NR_syscalls);
373 DECLARE_BITMAP(sc_compat, NR_compat_syscalls);
374};
375
376static void syscall_entry_unknown(struct lttng_event *event,
377 struct pt_regs *regs, unsigned int id)
378{
379 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
380
381 lttng_syscall_get_arguments(current, regs, args);
382 if (unlikely(in_compat_syscall()))
383 __event_probe__compat_syscall_entry_unknown(event, id, args);
384 else
385 __event_probe__syscall_entry_unknown(event, id, args);
386}
387
388void syscall_entry_probe(void *__data, struct pt_regs *regs, long id)
389{
390 struct lttng_channel *chan = __data;
391 struct lttng_event *event, *unknown_event;
392 const struct trace_syscall_entry *table, *entry;
393 size_t table_len;
394
395 if (unlikely(in_compat_syscall())) {
396 struct lttng_syscall_filter *filter;
397
398 filter = lttng_rcu_dereference(chan->sc_filter);
399 if (filter) {
400 if (id < 0 || id >= NR_compat_syscalls
401 || !test_bit(id, filter->sc_compat)) {
402 /* System call filtered out. */
403 return;
404 }
405 }
406 table = compat_sc_table;
407 table_len = ARRAY_SIZE(compat_sc_table);
408 unknown_event = chan->sc_compat_unknown;
409 } else {
410 struct lttng_syscall_filter *filter;
411
412 filter = lttng_rcu_dereference(chan->sc_filter);
413 if (filter) {
414 if (id < 0 || id >= NR_syscalls
415 || !test_bit(id, filter->sc)) {
416 /* System call filtered out. */
417 return;
418 }
419 }
420 table = sc_table;
421 table_len = ARRAY_SIZE(sc_table);
422 unknown_event = chan->sc_unknown;
423 }
424 if (unlikely(id < 0 || id >= table_len)) {
425 syscall_entry_unknown(unknown_event, regs, id);
426 return;
427 }
428 if (unlikely(in_compat_syscall()))
429 event = chan->compat_sc_table[id];
430 else
431 event = chan->sc_table[id];
432 if (unlikely(!event)) {
433 syscall_entry_unknown(unknown_event, regs, id);
434 return;
435 }
436 entry = &table[id];
437 WARN_ON_ONCE(!entry);
438
439 switch (entry->nrargs) {
440 case 0:
441 {
442 void (*fptr)(void *__data) = entry->func;
443
444 fptr(event);
445 break;
446 }
447 case 1:
448 {
449 void (*fptr)(void *__data, unsigned long arg0) = entry->func;
450 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
451
452 lttng_syscall_get_arguments(current, regs, args);
453 fptr(event, args[0]);
454 break;
455 }
456 case 2:
457 {
458 void (*fptr)(void *__data,
459 unsigned long arg0,
460 unsigned long arg1) = entry->func;
461 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
462
463 lttng_syscall_get_arguments(current, regs, args);
464 fptr(event, args[0], args[1]);
465 break;
466 }
467 case 3:
468 {
469 void (*fptr)(void *__data,
470 unsigned long arg0,
471 unsigned long arg1,
472 unsigned long arg2) = entry->func;
473 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
474
475 lttng_syscall_get_arguments(current, regs, args);
476 fptr(event, args[0], args[1], args[2]);
477 break;
478 }
479 case 4:
480 {
481 void (*fptr)(void *__data,
482 unsigned long arg0,
483 unsigned long arg1,
484 unsigned long arg2,
485 unsigned long arg3) = entry->func;
486 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
487
488 lttng_syscall_get_arguments(current, regs, args);
489 fptr(event, args[0], args[1], args[2], args[3]);
490 break;
491 }
492 case 5:
493 {
494 void (*fptr)(void *__data,
495 unsigned long arg0,
496 unsigned long arg1,
497 unsigned long arg2,
498 unsigned long arg3,
499 unsigned long arg4) = entry->func;
500 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
501
502 lttng_syscall_get_arguments(current, regs, args);
503 fptr(event, args[0], args[1], args[2], args[3], args[4]);
504 break;
505 }
506 case 6:
507 {
508 void (*fptr)(void *__data,
509 unsigned long arg0,
510 unsigned long arg1,
511 unsigned long arg2,
512 unsigned long arg3,
513 unsigned long arg4,
514 unsigned long arg5) = entry->func;
515 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
516
517 lttng_syscall_get_arguments(current, regs, args);
518 fptr(event, args[0], args[1], args[2],
519 args[3], args[4], args[5]);
520 break;
521 }
522 default:
523 break;
524 }
525}
526
527static void syscall_exit_unknown(struct lttng_event *event,
528 struct pt_regs *regs, int id, long ret)
529{
530 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
531
532 lttng_syscall_get_arguments(current, regs, args);
533 if (unlikely(in_compat_syscall()))
534 __event_probe__compat_syscall_exit_unknown(event, id, ret,
535 args);
536 else
537 __event_probe__syscall_exit_unknown(event, id, ret, args);
538}
539
540void syscall_exit_probe(void *__data, struct pt_regs *regs, long ret)
541{
542 struct lttng_channel *chan = __data;
543 struct lttng_event *event, *unknown_event;
544 const struct trace_syscall_entry *table, *entry;
545 size_t table_len;
546 long id;
547
548 id = syscall_get_nr(current, regs);
549 if (unlikely(in_compat_syscall())) {
550 struct lttng_syscall_filter *filter;
551
552 filter = lttng_rcu_dereference(chan->sc_filter);
553 if (filter) {
554 if (id < 0 || id >= NR_compat_syscalls
555 || !test_bit(id, filter->sc_compat)) {
556 /* System call filtered out. */
557 return;
558 }
559 }
560 table = compat_sc_exit_table;
561 table_len = ARRAY_SIZE(compat_sc_exit_table);
562 unknown_event = chan->compat_sc_exit_unknown;
563 } else {
564 struct lttng_syscall_filter *filter;
565
566 filter = lttng_rcu_dereference(chan->sc_filter);
567 if (filter) {
568 if (id < 0 || id >= NR_syscalls
569 || !test_bit(id, filter->sc)) {
570 /* System call filtered out. */
571 return;
572 }
573 }
574 table = sc_exit_table;
575 table_len = ARRAY_SIZE(sc_exit_table);
576 unknown_event = chan->sc_exit_unknown;
577 }
578 if (unlikely(id < 0 || id >= table_len)) {
579 syscall_exit_unknown(unknown_event, regs, id, ret);
580 return;
581 }
582 if (unlikely(in_compat_syscall()))
583 event = chan->compat_sc_exit_table[id];
584 else
585 event = chan->sc_exit_table[id];
586 if (unlikely(!event)) {
587 syscall_exit_unknown(unknown_event, regs, id, ret);
588 return;
589 }
590 entry = &table[id];
591 WARN_ON_ONCE(!entry);
592
593 switch (entry->nrargs) {
594 case 0:
595 {
596 void (*fptr)(void *__data, long ret) = entry->func;
597
598 fptr(event, ret);
599 break;
600 }
601 case 1:
602 {
603 void (*fptr)(void *__data,
604 long ret,
605 unsigned long arg0) = entry->func;
606 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
607
608 lttng_syscall_get_arguments(current, regs, args);
609 fptr(event, ret, args[0]);
610 break;
611 }
612 case 2:
613 {
614 void (*fptr)(void *__data,
615 long ret,
616 unsigned long arg0,
617 unsigned long arg1) = entry->func;
618 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
619
620 lttng_syscall_get_arguments(current, regs, args);
621 fptr(event, ret, args[0], args[1]);
622 break;
623 }
624 case 3:
625 {
626 void (*fptr)(void *__data,
627 long ret,
628 unsigned long arg0,
629 unsigned long arg1,
630 unsigned long arg2) = entry->func;
631 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
632
633 lttng_syscall_get_arguments(current, regs, args);
634 fptr(event, ret, args[0], args[1], args[2]);
635 break;
636 }
637 case 4:
638 {
639 void (*fptr)(void *__data,
640 long ret,
641 unsigned long arg0,
642 unsigned long arg1,
643 unsigned long arg2,
644 unsigned long arg3) = entry->func;
645 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
646
647 lttng_syscall_get_arguments(current, regs, args);
648 fptr(event, ret, args[0], args[1], args[2], args[3]);
649 break;
650 }
651 case 5:
652 {
653 void (*fptr)(void *__data,
654 long ret,
655 unsigned long arg0,
656 unsigned long arg1,
657 unsigned long arg2,
658 unsigned long arg3,
659 unsigned long arg4) = entry->func;
660 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
661
662 lttng_syscall_get_arguments(current, regs, args);
663 fptr(event, ret, args[0], args[1], args[2], args[3], args[4]);
664 break;
665 }
666 case 6:
667 {
668 void (*fptr)(void *__data,
669 long ret,
670 unsigned long arg0,
671 unsigned long arg1,
672 unsigned long arg2,
673 unsigned long arg3,
674 unsigned long arg4,
675 unsigned long arg5) = entry->func;
676 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
677
678 lttng_syscall_get_arguments(current, regs, args);
679 fptr(event, ret, args[0], args[1], args[2],
680 args[3], args[4], args[5]);
681 break;
682 }
683 default:
684 break;
685 }
686}
687
688/*
689 * noinline to diminish caller stack size.
690 * Should be called with sessions lock held.
691 */
692static
693int fill_table(const struct trace_syscall_entry *table, size_t table_len,
694 struct lttng_event **chan_table, struct lttng_channel *chan,
695 void *filter, enum sc_type type)
696{
697 const struct lttng_event_desc *desc;
698 unsigned int i;
699
700 /* Allocate events for each syscall, insert into table */
701 for (i = 0; i < table_len; i++) {
702 struct lttng_kernel_event ev;
703 desc = table[i].desc;
704
705 if (!desc) {
706 /* Unknown syscall */
707 continue;
708 }
709 /*
710 * Skip those already populated by previous failed
711 * register for this channel.
712 */
713 if (chan_table[i])
714 continue;
715 memset(&ev, 0, sizeof(ev));
716 switch (type) {
717 case SC_TYPE_ENTRY:
718 strncpy(ev.name, SYSCALL_ENTRY_STR,
719 LTTNG_KERNEL_SYM_NAME_LEN);
720 break;
721 case SC_TYPE_EXIT:
722 strncpy(ev.name, SYSCALL_EXIT_STR,
723 LTTNG_KERNEL_SYM_NAME_LEN);
724 break;
725 case SC_TYPE_COMPAT_ENTRY:
726 strncpy(ev.name, COMPAT_SYSCALL_ENTRY_STR,
727 LTTNG_KERNEL_SYM_NAME_LEN);
728 break;
729 case SC_TYPE_COMPAT_EXIT:
730 strncpy(ev.name, COMPAT_SYSCALL_EXIT_STR,
731 LTTNG_KERNEL_SYM_NAME_LEN);
732 break;
733 default:
734 BUG_ON(1);
735 break;
736 }
737 strncat(ev.name, desc->name,
738 LTTNG_KERNEL_SYM_NAME_LEN - strlen(ev.name) - 1);
739 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
740 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
741 chan_table[i] = _lttng_event_create(chan, &ev, filter,
742 desc, ev.instrumentation);
743 WARN_ON_ONCE(!chan_table[i]);
744 if (IS_ERR(chan_table[i])) {
745 /*
746 * If something goes wrong in event registration
747 * after the first one, we have no choice but to
748 * leave the previous events in there, until
749 * deleted by session teardown.
750 */
751 return PTR_ERR(chan_table[i]);
752 }
753 }
754 return 0;
755}
756
757/*
758 * Should be called with sessions lock held.
759 */
760int lttng_syscalls_register(struct lttng_channel *chan, void *filter)
761{
762 struct lttng_kernel_event ev;
763 int ret;
764
765 wrapper_vmalloc_sync_mappings();
766
767 if (!chan->sc_table) {
768 /* create syscall table mapping syscall to events */
769 chan->sc_table = kzalloc(sizeof(struct lttng_event *)
770 * ARRAY_SIZE(sc_table), GFP_KERNEL);
771 if (!chan->sc_table)
772 return -ENOMEM;
773 }
774 if (!chan->sc_exit_table) {
775 /* create syscall table mapping syscall to events */
776 chan->sc_exit_table = kzalloc(sizeof(struct lttng_event *)
777 * ARRAY_SIZE(sc_exit_table), GFP_KERNEL);
778 if (!chan->sc_exit_table)
779 return -ENOMEM;
780 }
781
782
783#ifdef CONFIG_COMPAT
784 if (!chan->compat_sc_table) {
785 /* create syscall table mapping compat syscall to events */
786 chan->compat_sc_table = kzalloc(sizeof(struct lttng_event *)
787 * ARRAY_SIZE(compat_sc_table), GFP_KERNEL);
788 if (!chan->compat_sc_table)
789 return -ENOMEM;
790 }
791
792 if (!chan->compat_sc_exit_table) {
793 /* create syscall table mapping compat syscall to events */
794 chan->compat_sc_exit_table = kzalloc(sizeof(struct lttng_event *)
795 * ARRAY_SIZE(compat_sc_exit_table), GFP_KERNEL);
796 if (!chan->compat_sc_exit_table)
797 return -ENOMEM;
798 }
799#endif
800 if (!chan->sc_unknown) {
801 const struct lttng_event_desc *desc =
802 &__event_desc___syscall_entry_unknown;
803
804 memset(&ev, 0, sizeof(ev));
805 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
806 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
807 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
808 chan->sc_unknown = _lttng_event_create(chan, &ev, filter,
809 desc,
810 ev.instrumentation);
811 WARN_ON_ONCE(!chan->sc_unknown);
812 if (IS_ERR(chan->sc_unknown)) {
813 return PTR_ERR(chan->sc_unknown);
814 }
815 }
816
817 if (!chan->sc_compat_unknown) {
818 const struct lttng_event_desc *desc =
819 &__event_desc___compat_syscall_entry_unknown;
820
821 memset(&ev, 0, sizeof(ev));
822 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
823 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
824 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
825 chan->sc_compat_unknown = _lttng_event_create(chan, &ev, filter,
826 desc,
827 ev.instrumentation);
828 WARN_ON_ONCE(!chan->sc_unknown);
829 if (IS_ERR(chan->sc_compat_unknown)) {
830 return PTR_ERR(chan->sc_compat_unknown);
831 }
832 }
833
834 if (!chan->compat_sc_exit_unknown) {
835 const struct lttng_event_desc *desc =
836 &__event_desc___compat_syscall_exit_unknown;
837
838 memset(&ev, 0, sizeof(ev));
839 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
840 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
841 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
842 chan->compat_sc_exit_unknown = _lttng_event_create(chan, &ev,
843 filter, desc,
844 ev.instrumentation);
845 WARN_ON_ONCE(!chan->compat_sc_exit_unknown);
846 if (IS_ERR(chan->compat_sc_exit_unknown)) {
847 return PTR_ERR(chan->compat_sc_exit_unknown);
848 }
849 }
850
851 if (!chan->sc_exit_unknown) {
852 const struct lttng_event_desc *desc =
853 &__event_desc___syscall_exit_unknown;
854
855 memset(&ev, 0, sizeof(ev));
856 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
857 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
858 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
859 chan->sc_exit_unknown = _lttng_event_create(chan, &ev, filter,
860 desc, ev.instrumentation);
861 WARN_ON_ONCE(!chan->sc_exit_unknown);
862 if (IS_ERR(chan->sc_exit_unknown)) {
863 return PTR_ERR(chan->sc_exit_unknown);
864 }
865 }
866
867 ret = fill_table(sc_table, ARRAY_SIZE(sc_table),
868 chan->sc_table, chan, filter, SC_TYPE_ENTRY);
869 if (ret)
870 return ret;
871 ret = fill_table(sc_exit_table, ARRAY_SIZE(sc_exit_table),
872 chan->sc_exit_table, chan, filter, SC_TYPE_EXIT);
873 if (ret)
874 return ret;
875
876#ifdef CONFIG_COMPAT
877 ret = fill_table(compat_sc_table, ARRAY_SIZE(compat_sc_table),
878 chan->compat_sc_table, chan, filter,
879 SC_TYPE_COMPAT_ENTRY);
880 if (ret)
881 return ret;
882 ret = fill_table(compat_sc_exit_table, ARRAY_SIZE(compat_sc_exit_table),
883 chan->compat_sc_exit_table, chan, filter,
884 SC_TYPE_COMPAT_EXIT);
885 if (ret)
886 return ret;
887#endif
888 if (!chan->sys_enter_registered) {
889 ret = lttng_wrapper_tracepoint_probe_register("sys_enter",
890 (void *) syscall_entry_probe, chan);
891 if (ret)
892 return ret;
893 chan->sys_enter_registered = 1;
894 }
895 /*
896 * We change the name of sys_exit tracepoint due to namespace
897 * conflict with sys_exit syscall entry.
898 */
899 if (!chan->sys_exit_registered) {
900 ret = lttng_wrapper_tracepoint_probe_register("sys_exit",
901 (void *) syscall_exit_probe, chan);
902 if (ret) {
903 WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
904 (void *) syscall_entry_probe, chan));
905 return ret;
906 }
907 chan->sys_exit_registered = 1;
908 }
909 return ret;
910}
911
912/*
913 * Only called at session destruction.
914 */
915int lttng_syscalls_unregister(struct lttng_channel *chan)
916{
917 int ret;
918
919 if (!chan->sc_table)
920 return 0;
921 if (chan->sys_enter_registered) {
922 ret = lttng_wrapper_tracepoint_probe_unregister("sys_enter",
923 (void *) syscall_entry_probe, chan);
924 if (ret)
925 return ret;
926 chan->sys_enter_registered = 0;
927 }
928 if (chan->sys_exit_registered) {
929 ret = lttng_wrapper_tracepoint_probe_unregister("sys_exit",
930 (void *) syscall_exit_probe, chan);
931 if (ret)
932 return ret;
933 chan->sys_exit_registered = 0;
934 }
935 /* lttng_event destroy will be performed by lttng_session_destroy() */
936 kfree(chan->sc_table);
937 kfree(chan->sc_exit_table);
938#ifdef CONFIG_COMPAT
939 kfree(chan->compat_sc_table);
940 kfree(chan->compat_sc_exit_table);
941#endif
942 kfree(chan->sc_filter);
943 return 0;
944}
945
946static
947int get_syscall_nr(const char *syscall_name)
948{
949 int syscall_nr = -1;
950 int i;
951
952 for (i = 0; i < ARRAY_SIZE(sc_table); i++) {
953 const struct trace_syscall_entry *entry;
954 const char *it_name;
955
956 entry = &sc_table[i];
957 if (!entry->desc)
958 continue;
959 it_name = entry->desc->name;
960 it_name += strlen(SYSCALL_ENTRY_STR);
961 if (!strcmp(syscall_name, it_name)) {
962 syscall_nr = i;
963 break;
964 }
965 }
966 return syscall_nr;
967}
968
969static
970int get_compat_syscall_nr(const char *syscall_name)
971{
972 int syscall_nr = -1;
973 int i;
974
975 for (i = 0; i < ARRAY_SIZE(compat_sc_table); i++) {
976 const struct trace_syscall_entry *entry;
977 const char *it_name;
978
979 entry = &compat_sc_table[i];
980 if (!entry->desc)
981 continue;
982 it_name = entry->desc->name;
983 it_name += strlen(COMPAT_SYSCALL_ENTRY_STR);
984 if (!strcmp(syscall_name, it_name)) {
985 syscall_nr = i;
986 break;
987 }
988 }
989 return syscall_nr;
990}
991
992static
993uint32_t get_sc_tables_len(void)
994{
995 return ARRAY_SIZE(sc_table) + ARRAY_SIZE(compat_sc_table);
996}
997
998int lttng_syscall_filter_enable(struct lttng_channel *chan,
999 const char *name)
1000{
1001 int syscall_nr, compat_syscall_nr, ret;
1002 struct lttng_syscall_filter *filter;
1003
1004 WARN_ON_ONCE(!chan->sc_table);
1005
1006 if (!name) {
1007 /* Enable all system calls by removing filter */
1008 if (chan->sc_filter) {
1009 filter = chan->sc_filter;
1010 rcu_assign_pointer(chan->sc_filter, NULL);
1011 synchronize_trace();
1012 kfree(filter);
1013 }
1014 chan->syscall_all = 1;
1015 return 0;
1016 }
1017
1018 if (!chan->sc_filter) {
1019 if (chan->syscall_all) {
1020 /*
1021 * All syscalls are already enabled.
1022 */
1023 return -EEXIST;
1024 }
1025 filter = kzalloc(sizeof(struct lttng_syscall_filter),
1026 GFP_KERNEL);
1027 if (!filter)
1028 return -ENOMEM;
1029 } else {
1030 filter = chan->sc_filter;
1031 }
1032 syscall_nr = get_syscall_nr(name);
1033 compat_syscall_nr = get_compat_syscall_nr(name);
1034 if (syscall_nr < 0 && compat_syscall_nr < 0) {
1035 ret = -ENOENT;
1036 goto error;
1037 }
1038 if (syscall_nr >= 0) {
1039 if (test_bit(syscall_nr, filter->sc)) {
1040 ret = -EEXIST;
1041 goto error;
1042 }
1043 bitmap_set(filter->sc, syscall_nr, 1);
1044 }
1045 if (compat_syscall_nr >= 0) {
1046 if (test_bit(compat_syscall_nr, filter->sc_compat)) {
1047 ret = -EEXIST;
1048 goto error;
1049 }
1050 bitmap_set(filter->sc_compat, compat_syscall_nr, 1);
1051 }
1052 if (!chan->sc_filter)
1053 rcu_assign_pointer(chan->sc_filter, filter);
1054 return 0;
1055
1056error:
1057 if (!chan->sc_filter)
1058 kfree(filter);
1059 return ret;
1060}
1061
1062int lttng_syscall_filter_disable(struct lttng_channel *chan,
1063 const char *name)
1064{
1065 int syscall_nr, compat_syscall_nr, ret;
1066 struct lttng_syscall_filter *filter;
1067
1068 WARN_ON_ONCE(!chan->sc_table);
1069
1070 if (!chan->sc_filter) {
1071 if (!chan->syscall_all)
1072 return -EEXIST;
1073 filter = kzalloc(sizeof(struct lttng_syscall_filter),
1074 GFP_KERNEL);
1075 if (!filter)
1076 return -ENOMEM;
1077 /* Trace all system calls, then apply disable. */
1078 bitmap_set(filter->sc, 0, NR_syscalls);
1079 bitmap_set(filter->sc_compat, 0, NR_compat_syscalls);
1080 } else {
1081 filter = chan->sc_filter;
1082 }
1083
1084 if (!name) {
1085 /* Fail if all syscalls are already disabled. */
1086 if (bitmap_empty(filter->sc, NR_syscalls)
1087 && bitmap_empty(filter->sc_compat,
1088 NR_compat_syscalls)) {
1089 ret = -EEXIST;
1090 goto error;
1091 }
1092
1093 /* Disable all system calls */
1094 bitmap_clear(filter->sc, 0, NR_syscalls);
1095 bitmap_clear(filter->sc_compat, 0, NR_compat_syscalls);
1096 goto apply_filter;
1097 }
1098 syscall_nr = get_syscall_nr(name);
1099 compat_syscall_nr = get_compat_syscall_nr(name);
1100 if (syscall_nr < 0 && compat_syscall_nr < 0) {
1101 ret = -ENOENT;
1102 goto error;
1103 }
1104 if (syscall_nr >= 0) {
1105 if (!test_bit(syscall_nr, filter->sc)) {
1106 ret = -EEXIST;
1107 goto error;
1108 }
1109 bitmap_clear(filter->sc, syscall_nr, 1);
1110 }
1111 if (compat_syscall_nr >= 0) {
1112 if (!test_bit(compat_syscall_nr, filter->sc_compat)) {
1113 ret = -EEXIST;
1114 goto error;
1115 }
1116 bitmap_clear(filter->sc_compat, compat_syscall_nr, 1);
1117 }
1118apply_filter:
1119 if (!chan->sc_filter)
1120 rcu_assign_pointer(chan->sc_filter, filter);
1121 chan->syscall_all = 0;
1122 return 0;
1123
1124error:
1125 if (!chan->sc_filter)
1126 kfree(filter);
1127 return ret;
1128}
1129
1130static
1131const struct trace_syscall_entry *syscall_list_get_entry(loff_t *pos)
1132{
1133 const struct trace_syscall_entry *entry;
1134 int iter = 0;
1135
1136 for (entry = sc_table;
1137 entry < sc_table + ARRAY_SIZE(sc_table);
1138 entry++) {
1139 if (iter++ >= *pos)
1140 return entry;
1141 }
1142 for (entry = compat_sc_table;
1143 entry < compat_sc_table + ARRAY_SIZE(compat_sc_table);
1144 entry++) {
1145 if (iter++ >= *pos)
1146 return entry;
1147 }
1148 /* End of list */
1149 return NULL;
1150}
1151
1152static
1153void *syscall_list_start(struct seq_file *m, loff_t *pos)
1154{
1155 return (void *) syscall_list_get_entry(pos);
1156}
1157
1158static
1159void *syscall_list_next(struct seq_file *m, void *p, loff_t *ppos)
1160{
1161 (*ppos)++;
1162 return (void *) syscall_list_get_entry(ppos);
1163}
1164
1165static
1166void syscall_list_stop(struct seq_file *m, void *p)
1167{
1168}
1169
1170static
1171int get_sc_table(const struct trace_syscall_entry *entry,
1172 const struct trace_syscall_entry **table,
1173 unsigned int *bitness)
1174{
1175 if (entry >= sc_table && entry < sc_table + ARRAY_SIZE(sc_table)) {
1176 if (bitness)
1177 *bitness = BITS_PER_LONG;
1178 if (table)
1179 *table = sc_table;
1180 return 0;
1181 }
1182 if (!(entry >= compat_sc_table
1183 && entry < compat_sc_table + ARRAY_SIZE(compat_sc_table))) {
1184 return -EINVAL;
1185 }
1186 if (bitness)
1187 *bitness = 32;
1188 if (table)
1189 *table = compat_sc_table;
1190 return 0;
1191}
1192
1193static
1194int syscall_list_show(struct seq_file *m, void *p)
1195{
1196 const struct trace_syscall_entry *table, *entry = p;
1197 unsigned int bitness;
1198 unsigned long index;
1199 int ret;
1200 const char *name;
1201
1202 ret = get_sc_table(entry, &table, &bitness);
1203 if (ret)
1204 return ret;
1205 if (!entry->desc)
1206 return 0;
1207 if (table == sc_table) {
1208 index = entry - table;
1209 name = &entry->desc->name[strlen(SYSCALL_ENTRY_STR)];
1210 } else {
1211 index = (entry - table) + ARRAY_SIZE(sc_table);
1212 name = &entry->desc->name[strlen(COMPAT_SYSCALL_ENTRY_STR)];
1213 }
1214 seq_printf(m, "syscall { index = %lu; name = %s; bitness = %u; };\n",
1215 index, name, bitness);
1216 return 0;
1217}
1218
1219static
1220const struct seq_operations lttng_syscall_list_seq_ops = {
1221 .start = syscall_list_start,
1222 .next = syscall_list_next,
1223 .stop = syscall_list_stop,
1224 .show = syscall_list_show,
1225};
1226
1227static
1228int lttng_syscall_list_open(struct inode *inode, struct file *file)
1229{
1230 return seq_open(file, &lttng_syscall_list_seq_ops);
1231}
1232
1233const struct file_operations lttng_syscall_list_fops = {
1234 .owner = THIS_MODULE,
1235 .open = lttng_syscall_list_open,
1236 .read = seq_read,
1237 .llseek = seq_lseek,
1238 .release = seq_release,
1239};
1240
1241long lttng_channel_syscall_mask(struct lttng_channel *channel,
1242 struct lttng_kernel_syscall_mask __user *usyscall_mask)
1243{
1244 uint32_t len, sc_tables_len, bitmask_len;
1245 int ret = 0, bit;
1246 char *tmp_mask;
1247 struct lttng_syscall_filter *filter;
1248
1249 ret = get_user(len, &usyscall_mask->len);
1250 if (ret)
1251 return ret;
1252 sc_tables_len = get_sc_tables_len();
1253 bitmask_len = ALIGN(sc_tables_len, 8) >> 3;
1254 if (len < sc_tables_len) {
1255 return put_user(sc_tables_len, &usyscall_mask->len);
1256 }
1257 /* Array is large enough, we can copy array to user-space. */
1258 tmp_mask = kzalloc(bitmask_len, GFP_KERNEL);
1259 if (!tmp_mask)
1260 return -ENOMEM;
1261 filter = channel->sc_filter;
1262
1263 for (bit = 0; bit < ARRAY_SIZE(sc_table); bit++) {
1264 char state;
1265
1266 if (channel->sc_table) {
1267 if (filter)
1268 state = test_bit(bit, filter->sc);
1269 else
1270 state = 1;
1271 } else {
1272 state = 0;
1273 }
1274 bt_bitfield_write_be(tmp_mask, char, bit, 1, state);
1275 }
1276 for (; bit < sc_tables_len; bit++) {
1277 char state;
1278
1279 if (channel->compat_sc_table) {
1280 if (filter)
1281 state = test_bit(bit - ARRAY_SIZE(sc_table),
1282 filter->sc_compat);
1283 else
1284 state = 1;
1285 } else {
1286 state = 0;
1287 }
1288 bt_bitfield_write_be(tmp_mask, char, bit, 1, state);
1289 }
1290 if (copy_to_user(usyscall_mask->mask, tmp_mask, bitmask_len))
1291 ret = -EFAULT;
1292 kfree(tmp_mask);
1293 return ret;
1294}
1295
1296int lttng_abi_syscall_list(void)
1297{
1298 struct file *syscall_list_file;
1299 int file_fd, ret;
1300
1301 file_fd = lttng_get_unused_fd();
1302 if (file_fd < 0) {
1303 ret = file_fd;
1304 goto fd_error;
1305 }
1306
1307 syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
1308 &lttng_syscall_list_fops,
1309 NULL, O_RDWR);
1310 if (IS_ERR(syscall_list_file)) {
1311 ret = PTR_ERR(syscall_list_file);
1312 goto file_error;
1313 }
1314 ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
1315 if (ret < 0)
1316 goto open_error;
1317 fd_install(file_fd, syscall_list_file);
1318 return file_fd;
1319
1320open_error:
1321 fput(syscall_list_file);
1322file_error:
1323 put_unused_fd(file_fd);
1324fd_error:
1325 return ret;
1326}
LTTng 2.0/0.x modules
This page took 0.03266 seconds and 4 git commands to generate.