src/lttng-syscalls.c

   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
  44 enum 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
  61 static
  62 void syscall_entry_probe(void *__data, struct pt_regs *regs, long id);
  63 static
  64 void syscall_exit_probe(void *__data, struct pt_regs *regs, long ret);
  65
  66 /*
  67  * Forward declarations for old kernels.
  68  */
  69 struct mmsghdr;
  70 struct rlimit64;
  71 struct oldold_utsname;
  72 struct old_utsname;
  73 struct sel_arg_struct;
  74 struct mmap_arg_struct;
  75 struct file_handle;
  76 struct user_msghdr;
  77
  78 /*
  79  * Forward declaration for kernels >= 5.6
  80  */
  81 struct timex;
  82 struct timeval;
  83 struct itimerval;
  84 struct itimerspec;
  85
  86 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,6,0))
  87 typedef __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
 286 struct 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 */
 310 static 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 */
 325 const 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 */
 347 static 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 */
 362 const 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
 371 struct lttng_syscall_filter {
 372         DECLARE_BITMAP(sc, NR_syscalls);
 373         DECLARE_BITMAP(sc_compat, NR_compat_syscalls);
 374 };
 375
 376 static 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
 388 void 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
 527 static 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
 540 void 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  */
 692 static
 693 int 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  */
 760 int 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  */
 915 int 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
 946 static
 947 int 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
 969 static
 970 int 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
 992 static
 993 uint32_t get_sc_tables_len(void)
 994 {
 995         return ARRAY_SIZE(sc_table) + ARRAY_SIZE(compat_sc_table);
 996 }
 997
 998 int 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
1056 error:
1057         if (!chan->sc_filter)
1058                 kfree(filter);
1059         return ret;
1060 }
1061
1062 int 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         }
1118 apply_filter:
1119         if (!chan->sc_filter)
1120                 rcu_assign_pointer(chan->sc_filter, filter);
1121         chan->syscall_all = 0;
1122         return 0;
1123
1124 error:
1125         if (!chan->sc_filter)
1126                 kfree(filter);
1127         return ret;
1128 }
1129
1130 static
1131 const 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
1152 static
1153 void *syscall_list_start(struct seq_file *m, loff_t *pos)
1154 {
1155         return (void *) syscall_list_get_entry(pos);
1156 }
1157
1158 static
1159 void *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
1165 static
1166 void syscall_list_stop(struct seq_file *m, void *p)
1167 {
1168 }
1169
1170 static
1171 int 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
1193 static
1194 int 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
1219 static
1220 const 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
1227 static
1228 int lttng_syscall_list_open(struct inode *inode, struct file *file)
1229 {
1230         return seq_open(file, &lttng_syscall_list_seq_ops);
1231 }
1232
1233 const 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
1241 long 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
1296 int 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
1320 open_error:
1321         fput(syscall_list_file);
1322 file_error:
1323         put_unused_fd(file_fd);
1324 fd_error:
1325         return ret;
1326 }