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