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_event_probe(void *__data, struct pt_regs *regs, long id);
  63 static
  64 void syscall_exit_event_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_event_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_event_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_event_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_event_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 *event_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                 .event_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 /* Event 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                 .event_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 /* Event 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                 .event_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 /* Event 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                 .event_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 /* Event 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_entry, NR_syscalls);
 373         DECLARE_BITMAP(sc_exit, NR_syscalls);
 374         DECLARE_BITMAP(sc_compat_entry, NR_compat_syscalls);
 375         DECLARE_BITMAP(sc_compat_exit, NR_compat_syscalls);
 376 };
 377
 378 static void syscall_entry_event_unknown(struct lttng_event *event,
 379         struct pt_regs *regs, unsigned int id)
 380 {
 381         unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 382
 383         lttng_syscall_get_arguments(current, regs, args);
 384         if (unlikely(in_compat_syscall()))
 385                 __event_probe__compat_syscall_entry_unknown(event, id, args);
 386         else
 387                 __event_probe__syscall_entry_unknown(event, id, args);
 388 }
 389
 390 static __always_inline
 391 void syscall_entry_call_func(void *func, unsigned int nrargs, void *data,
 392                 struct pt_regs *regs)
 393 {
 394         switch (nrargs) {
 395         case 0:
 396         {
 397                 void (*fptr)(void *__data) = func;
 398
 399                 fptr(data);
 400                 break;
 401         }
 402         case 1:
 403         {
 404                 void (*fptr)(void *__data, unsigned long arg0) = func;
 405                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 406
 407                 lttng_syscall_get_arguments(current, regs, args);
 408                 fptr(data, args[0]);
 409                 break;
 410         }
 411         case 2:
 412         {
 413                 void (*fptr)(void *__data,
 414                         unsigned long arg0,
 415                         unsigned long arg1) = func;
 416                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 417
 418                 lttng_syscall_get_arguments(current, regs, args);
 419                 fptr(data, args[0], args[1]);
 420                 break;
 421         }
 422         case 3:
 423         {
 424                 void (*fptr)(void *__data,
 425                         unsigned long arg0,
 426                         unsigned long arg1,
 427                         unsigned long arg2) = func;
 428                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 429
 430                 lttng_syscall_get_arguments(current, regs, args);
 431                 fptr(data, args[0], args[1], args[2]);
 432                 break;
 433         }
 434         case 4:
 435         {
 436                 void (*fptr)(void *__data,
 437                         unsigned long arg0,
 438                         unsigned long arg1,
 439                         unsigned long arg2,
 440                         unsigned long arg3) = func;
 441                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 442
 443                 lttng_syscall_get_arguments(current, regs, args);
 444                 fptr(data, args[0], args[1], args[2], args[3]);
 445                 break;
 446         }
 447         case 5:
 448         {
 449                 void (*fptr)(void *__data,
 450                         unsigned long arg0,
 451                         unsigned long arg1,
 452                         unsigned long arg2,
 453                         unsigned long arg3,
 454                         unsigned long arg4) = func;
 455                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 456
 457                 lttng_syscall_get_arguments(current, regs, args);
 458                 fptr(data, args[0], args[1], args[2], args[3], args[4]);
 459                 break;
 460         }
 461         case 6:
 462         {
 463                 void (*fptr)(void *__data,
 464                         unsigned long arg0,
 465                         unsigned long arg1,
 466                         unsigned long arg2,
 467                         unsigned long arg3,
 468                         unsigned long arg4,
 469                         unsigned long arg5) = func;
 470                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 471
 472                 lttng_syscall_get_arguments(current, regs, args);
 473                 fptr(data, args[0], args[1], args[2],
 474                         args[3], args[4], args[5]);
 475                 break;
 476         }
 477         default:
 478                 break;
 479         }
 480 }
 481
 482 void syscall_entry_event_probe(void *__data, struct pt_regs *regs, long id)
 483 {
 484         struct lttng_channel *chan = __data;
 485         struct lttng_event *event, *unknown_event;
 486         const struct trace_syscall_entry *table, *entry;
 487         size_t table_len;
 488
 489         if (unlikely(in_compat_syscall())) {
 490                 struct lttng_syscall_filter *filter = chan->sc_filter;
 491
 492                 if (id < 0 || id >= NR_compat_syscalls
 493                         || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_compat_entry))) {
 494                         /* System call filtered out. */
 495                         return;
 496                 }
 497                 table = compat_sc_table;
 498                 table_len = ARRAY_SIZE(compat_sc_table);
 499                 unknown_event = chan->sc_compat_unknown;
 500         } else {
 501                 struct lttng_syscall_filter *filter = chan->sc_filter;
 502
 503                 if (id < 0 || id >= NR_syscalls
 504                         || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_entry))) {
 505                         /* System call filtered out. */
 506                         return;
 507                 }
 508                 table = sc_table;
 509                 table_len = ARRAY_SIZE(sc_table);
 510                 unknown_event = chan->sc_unknown;
 511         }
 512         if (unlikely(id < 0 || id >= table_len)) {
 513                 syscall_entry_event_unknown(unknown_event, regs, id);
 514                 return;
 515         }
 516         if (unlikely(in_compat_syscall()))
 517                 event = chan->compat_sc_table[id];
 518         else
 519                 event = chan->sc_table[id];
 520         if (unlikely(!event)) {
 521                 syscall_entry_event_unknown(unknown_event, regs, id);
 522                 return;
 523         }
 524         entry = &table[id];
 525         WARN_ON_ONCE(!entry);
 526         syscall_entry_call_func(entry->event_func, entry->nrargs, event, regs);
 527 }
 528
 529 static void syscall_exit_event_unknown(struct lttng_event *event,
 530         struct pt_regs *regs, int id, long ret)
 531 {
 532         unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 533
 534         lttng_syscall_get_arguments(current, regs, args);
 535         if (unlikely(in_compat_syscall()))
 536                 __event_probe__compat_syscall_exit_unknown(event, id, ret,
 537                         args);
 538         else
 539                 __event_probe__syscall_exit_unknown(event, id, ret, args);
 540 }
 541
 542 void syscall_exit_event_probe(void *__data, struct pt_regs *regs, long ret)
 543 {
 544         struct lttng_channel *chan = __data;
 545         struct lttng_event *event, *unknown_event;
 546         const struct trace_syscall_entry *table, *entry;
 547         size_t table_len;
 548         long id;
 549
 550         id = syscall_get_nr(current, regs);
 551         if (unlikely(in_compat_syscall())) {
 552                 struct lttng_syscall_filter *filter = chan->sc_filter;
 553
 554                 if (id < 0 || id >= NR_compat_syscalls
 555                         || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_compat_exit))) {
 556                         /* System call filtered out. */
 557                         return;
 558                 }
 559                 table = compat_sc_exit_table;
 560                 table_len = ARRAY_SIZE(compat_sc_exit_table);
 561                 unknown_event = chan->compat_sc_exit_unknown;
 562         } else {
 563                 struct lttng_syscall_filter *filter = chan->sc_filter;
 564
 565                 if (id < 0 || id >= NR_syscalls
 566                         || (!READ_ONCE(chan->syscall_all) && !test_bit(id, filter->sc_exit))) {
 567                         /* System call filtered out. */
 568                         return;
 569                 }
 570                 table = sc_exit_table;
 571                 table_len = ARRAY_SIZE(sc_exit_table);
 572                 unknown_event = chan->sc_exit_unknown;
 573         }
 574         if (unlikely(id < 0 || id >= table_len)) {
 575                 syscall_exit_event_unknown(unknown_event, regs, id, ret);
 576                 return;
 577         }
 578         if (unlikely(in_compat_syscall()))
 579                 event = chan->compat_sc_exit_table[id];
 580         else
 581                 event = chan->sc_exit_table[id];
 582         if (unlikely(!event)) {
 583                 syscall_exit_event_unknown(unknown_event, regs, id, ret);
 584                 return;
 585         }
 586         entry = &table[id];
 587         WARN_ON_ONCE(!entry);
 588
 589         switch (entry->nrargs) {
 590         case 0:
 591         {
 592                 void (*fptr)(void *__data, long ret) = entry->event_func;
 593
 594                 fptr(event, ret);
 595                 break;
 596         }
 597         case 1:
 598         {
 599                 void (*fptr)(void *__data,
 600                         long ret,
 601                         unsigned long arg0) = entry->event_func;
 602                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 603
 604                 lttng_syscall_get_arguments(current, regs, args);
 605                 fptr(event, ret, args[0]);
 606                 break;
 607         }
 608         case 2:
 609         {
 610                 void (*fptr)(void *__data,
 611                         long ret,
 612                         unsigned long arg0,
 613                         unsigned long arg1) = entry->event_func;
 614                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 615
 616                 lttng_syscall_get_arguments(current, regs, args);
 617                 fptr(event, ret, args[0], args[1]);
 618                 break;
 619         }
 620         case 3:
 621         {
 622                 void (*fptr)(void *__data,
 623                         long ret,
 624                         unsigned long arg0,
 625                         unsigned long arg1,
 626                         unsigned long arg2) = entry->event_func;
 627                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 628
 629                 lttng_syscall_get_arguments(current, regs, args);
 630                 fptr(event, ret, args[0], args[1], args[2]);
 631                 break;
 632         }
 633         case 4:
 634         {
 635                 void (*fptr)(void *__data,
 636                         long ret,
 637                         unsigned long arg0,
 638                         unsigned long arg1,
 639                         unsigned long arg2,
 640                         unsigned long arg3) = entry->event_func;
 641                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 642
 643                 lttng_syscall_get_arguments(current, regs, args);
 644                 fptr(event, ret, args[0], args[1], args[2], args[3]);
 645                 break;
 646         }
 647         case 5:
 648         {
 649                 void (*fptr)(void *__data,
 650                         long ret,
 651                         unsigned long arg0,
 652                         unsigned long arg1,
 653                         unsigned long arg2,
 654                         unsigned long arg3,
 655                         unsigned long arg4) = entry->event_func;
 656                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 657
 658                 lttng_syscall_get_arguments(current, regs, args);
 659                 fptr(event, ret, args[0], args[1], args[2], args[3], args[4]);
 660                 break;
 661         }
 662         case 6:
 663         {
 664                 void (*fptr)(void *__data,
 665                         long ret,
 666                         unsigned long arg0,
 667                         unsigned long arg1,
 668                         unsigned long arg2,
 669                         unsigned long arg3,
 670                         unsigned long arg4,
 671                         unsigned long arg5) = entry->event_func;
 672                 unsigned long args[LTTNG_SYSCALL_NR_ARGS];
 673
 674                 lttng_syscall_get_arguments(current, regs, args);
 675                 fptr(event, ret, args[0], args[1], args[2],
 676                         args[3], args[4], args[5]);
 677                 break;
 678         }
 679         default:
 680                 break;
 681         }
 682 }
 683
 684 /*
 685  * noinline to diminish caller stack size.
 686  * Should be called with sessions lock held.
 687  */
 688 static
 689 int fill_event_table(const struct trace_syscall_entry *table, size_t table_len,
 690         struct lttng_event **chan_table, struct lttng_channel *chan,
 691         void *filter, enum sc_type type)
 692 {
 693         const struct lttng_event_desc *desc;
 694         unsigned int i;
 695
 696         /* Allocate events for each syscall, insert into table */
 697         for (i = 0; i < table_len; i++) {
 698                 struct lttng_kernel_event ev;
 699                 desc = table[i].desc;
 700
 701                 if (!desc) {
 702                         /* Unknown syscall */
 703                         continue;
 704                 }
 705                 /*
 706                  * Skip those already populated by previous failed
 707                  * register for this channel.
 708                  */
 709                 if (chan_table[i])
 710                         continue;
 711                 memset(&ev, 0, sizeof(ev));
 712                 switch (type) {
 713                 case SC_TYPE_ENTRY:
 714                         ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
 715                         ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
 716                         break;
 717                 case SC_TYPE_EXIT:
 718                         ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
 719                         ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
 720                         break;
 721                 case SC_TYPE_COMPAT_ENTRY:
 722                         ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
 723                         ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
 724                         break;
 725                 case SC_TYPE_COMPAT_EXIT:
 726                         ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
 727                         ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
 728                         break;
 729                 }
 730                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN - 1);
 731                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 732                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
 733                 chan_table[i] = _lttng_event_create(chan, &ev, filter,
 734                                                 desc, ev.instrumentation);
 735                 WARN_ON_ONCE(!chan_table[i]);
 736                 if (IS_ERR(chan_table[i])) {
 737                         /*
 738                          * If something goes wrong in event registration
 739                          * after the first one, we have no choice but to
 740                          * leave the previous events in there, until
 741                          * deleted by session teardown.
 742                          */
 743                         return PTR_ERR(chan_table[i]);
 744                 }
 745         }
 746         return 0;
 747 }
 748
 749 /*
 750  * Should be called with sessions lock held.
 751  */
 752 int lttng_syscalls_register_event(struct lttng_channel *chan, void *filter)
 753 {
 754         struct lttng_kernel_event ev;
 755         int ret;
 756
 757         wrapper_vmalloc_sync_mappings();
 758
 759         if (!chan->sc_table) {
 760                 /* create syscall table mapping syscall to events */
 761                 chan->sc_table = kzalloc(sizeof(struct lttng_event *)
 762                                         * ARRAY_SIZE(sc_table), GFP_KERNEL);
 763                 if (!chan->sc_table)
 764                         return -ENOMEM;
 765         }
 766         if (!chan->sc_exit_table) {
 767                 /* create syscall table mapping syscall to events */
 768                 chan->sc_exit_table = kzalloc(sizeof(struct lttng_event *)
 769                                         * ARRAY_SIZE(sc_exit_table), GFP_KERNEL);
 770                 if (!chan->sc_exit_table)
 771                         return -ENOMEM;
 772         }
 773
 774
 775 #ifdef CONFIG_COMPAT
 776         if (!chan->compat_sc_table) {
 777                 /* create syscall table mapping compat syscall to events */
 778                 chan->compat_sc_table = kzalloc(sizeof(struct lttng_event *)
 779                                         * ARRAY_SIZE(compat_sc_table), GFP_KERNEL);
 780                 if (!chan->compat_sc_table)
 781                         return -ENOMEM;
 782         }
 783
 784         if (!chan->compat_sc_exit_table) {
 785                 /* create syscall table mapping compat syscall to events */
 786                 chan->compat_sc_exit_table = kzalloc(sizeof(struct lttng_event *)
 787                                         * ARRAY_SIZE(compat_sc_exit_table), GFP_KERNEL);
 788                 if (!chan->compat_sc_exit_table)
 789                         return -ENOMEM;
 790         }
 791 #endif
 792         if (!chan->sc_unknown) {
 793                 const struct lttng_event_desc *desc =
 794                         &__event_desc___syscall_entry_unknown;
 795
 796                 memset(&ev, 0, sizeof(ev));
 797                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
 798                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 799                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
 800                 ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
 801                 ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
 802                 chan->sc_unknown = _lttng_event_create(chan, &ev, filter,
 803                                                 desc,
 804                                                 ev.instrumentation);
 805                 WARN_ON_ONCE(!chan->sc_unknown);
 806                 if (IS_ERR(chan->sc_unknown)) {
 807                         return PTR_ERR(chan->sc_unknown);
 808                 }
 809         }
 810
 811         if (!chan->sc_compat_unknown) {
 812                 const struct lttng_event_desc *desc =
 813                         &__event_desc___compat_syscall_entry_unknown;
 814
 815                 memset(&ev, 0, sizeof(ev));
 816                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
 817                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 818                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
 819                 ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_ENTRY;
 820                 ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
 821                 chan->sc_compat_unknown = _lttng_event_create(chan, &ev, filter,
 822                                                 desc,
 823                                                 ev.instrumentation);
 824                 WARN_ON_ONCE(!chan->sc_unknown);
 825                 if (IS_ERR(chan->sc_compat_unknown)) {
 826                         return PTR_ERR(chan->sc_compat_unknown);
 827                 }
 828         }
 829
 830         if (!chan->compat_sc_exit_unknown) {
 831                 const struct lttng_event_desc *desc =
 832                         &__event_desc___compat_syscall_exit_unknown;
 833
 834                 memset(&ev, 0, sizeof(ev));
 835                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
 836                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 837                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
 838                 ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
 839                 ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_COMPAT;
 840                 chan->compat_sc_exit_unknown = _lttng_event_create(chan, &ev,
 841                                                 filter, desc,
 842                                                 ev.instrumentation);
 843                 WARN_ON_ONCE(!chan->compat_sc_exit_unknown);
 844                 if (IS_ERR(chan->compat_sc_exit_unknown)) {
 845                         return PTR_ERR(chan->compat_sc_exit_unknown);
 846                 }
 847         }
 848
 849         if (!chan->sc_exit_unknown) {
 850                 const struct lttng_event_desc *desc =
 851                         &__event_desc___syscall_exit_unknown;
 852
 853                 memset(&ev, 0, sizeof(ev));
 854                 strncpy(ev.name, desc->name, LTTNG_KERNEL_SYM_NAME_LEN);
 855                 ev.name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 856                 ev.instrumentation = LTTNG_KERNEL_SYSCALL;
 857                 ev.u.syscall.entryexit = LTTNG_KERNEL_SYSCALL_EXIT;
 858                 ev.u.syscall.abi = LTTNG_KERNEL_SYSCALL_ABI_NATIVE;
 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_event_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_event_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_event_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_event_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
 889         if (!chan->sc_filter) {
 890                 chan->sc_filter = kzalloc(sizeof(struct lttng_syscall_filter),
 891                                 GFP_KERNEL);
 892                 if (!chan->sc_filter)
 893                         return -ENOMEM;
 894         }
 895
 896         if (!chan->sys_enter_registered) {
 897                 ret = lttng_wrapper_tracepoint_probe_register("sys_enter",
 898                                 (void *) syscall_entry_event_probe, chan);
 899                 if (ret)
 900                         return ret;
 901                 chan->sys_enter_registered = 1;
 902         }
 903         /*
 904          * We change the name of sys_exit tracepoint due to namespace
 905          * conflict with sys_exit syscall entry.
 906          */
 907         if (!chan->sys_exit_registered) {
 908                 ret = lttng_wrapper_tracepoint_probe_register("sys_exit",
 909                                 (void *) syscall_exit_event_probe, chan);
 910                 if (ret) {
 911                         WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
 912                                 (void *) syscall_entry_event_probe, chan));
 913                         return ret;
 914                 }
 915                 chan->sys_exit_registered = 1;
 916         }
 917         return ret;
 918 }
 919
 920 /*
 921  * Only called at session destruction.
 922  */
 923 int lttng_syscalls_unregister_event(struct lttng_channel *chan)
 924 {
 925         int ret;
 926
 927         if (!chan->sc_table)
 928                 return 0;
 929         if (chan->sys_enter_registered) {
 930                 ret = lttng_wrapper_tracepoint_probe_unregister("sys_enter",
 931                                 (void *) syscall_entry_event_probe, chan);
 932                 if (ret)
 933                         return ret;
 934                 chan->sys_enter_registered = 0;
 935         }
 936         if (chan->sys_exit_registered) {
 937                 ret = lttng_wrapper_tracepoint_probe_unregister("sys_exit",
 938                                 (void *) syscall_exit_event_probe, chan);
 939                 if (ret)
 940                         return ret;
 941                 chan->sys_exit_registered = 0;
 942         }
 943         return 0;
 944 }
 945
 946 int lttng_syscalls_destroy_event(struct lttng_channel *chan)
 947 {
 948         kfree(chan->sc_table);
 949         kfree(chan->sc_exit_table);
 950 #ifdef CONFIG_COMPAT
 951         kfree(chan->compat_sc_table);
 952         kfree(chan->compat_sc_exit_table);
 953 #endif
 954         kfree(chan->sc_filter);
 955         return 0;
 956 }
 957
 958 static
 959 int get_syscall_nr(const char *syscall_name)
 960 {
 961         int syscall_nr = -1;
 962         int i;
 963
 964         for (i = 0; i < ARRAY_SIZE(sc_table); i++) {
 965                 const struct trace_syscall_entry *entry;
 966                 const char *it_name;
 967
 968                 entry = &sc_table[i];
 969                 if (!entry->desc)
 970                         continue;
 971                 it_name = entry->desc->name;
 972                 it_name += strlen(SYSCALL_ENTRY_STR);
 973                 if (!strcmp(syscall_name, it_name)) {
 974                         syscall_nr = i;
 975                         break;
 976                 }
 977         }
 978         return syscall_nr;
 979 }
 980
 981 static
 982 int get_compat_syscall_nr(const char *syscall_name)
 983 {
 984         int syscall_nr = -1;
 985         int i;
 986
 987         for (i = 0; i < ARRAY_SIZE(compat_sc_table); i++) {
 988                 const struct trace_syscall_entry *entry;
 989                 const char *it_name;
 990
 991                 entry = &compat_sc_table[i];
 992                 if (!entry->desc)
 993                         continue;
 994                 it_name = entry->desc->name;
 995                 it_name += strlen(COMPAT_SYSCALL_ENTRY_STR);
 996                 if (!strcmp(syscall_name, it_name)) {
 997                         syscall_nr = i;
 998                         break;
 999                 }
1000         }
1001         return syscall_nr;
1002 }
1003
1004 static
1005 uint32_t get_sc_tables_len(void)
1006 {
1007         return ARRAY_SIZE(sc_table) + ARRAY_SIZE(compat_sc_table);
1008 }
1009
1010 static
1011 const char *get_syscall_name(struct lttng_event *event)
1012 {
1013         size_t prefix_len = 0;
1014
1015         WARN_ON_ONCE(event->instrumentation != LTTNG_KERNEL_SYSCALL);
1016
1017         switch (event->u.syscall.entryexit) {
1018         case LTTNG_SYSCALL_ENTRY:
1019                 switch (event->u.syscall.abi) {
1020                 case LTTNG_SYSCALL_ABI_NATIVE:
1021                         prefix_len = strlen(SYSCALL_ENTRY_STR);
1022                         break;
1023                 case LTTNG_SYSCALL_ABI_COMPAT:
1024                         prefix_len = strlen(COMPAT_SYSCALL_ENTRY_STR);
1025                         break;
1026                 }
1027                 break;
1028         case LTTNG_SYSCALL_EXIT:
1029                 switch (event->u.syscall.abi) {
1030                 case LTTNG_SYSCALL_ABI_NATIVE:
1031                         prefix_len = strlen(SYSCALL_EXIT_STR);
1032                         break;
1033                 case LTTNG_SYSCALL_ABI_COMPAT:
1034                         prefix_len = strlen(COMPAT_SYSCALL_EXIT_STR);
1035                         break;
1036                 }
1037                 break;
1038         }
1039         WARN_ON_ONCE(prefix_len == 0);
1040         return event->desc->name + prefix_len;
1041 }
1042
1043 int lttng_syscall_filter_enable_event(struct lttng_channel *chan,
1044                 struct lttng_event *event)
1045 {
1046         struct lttng_syscall_filter *filter = chan->sc_filter;
1047         const char *syscall_name;
1048         unsigned long *bitmap;
1049         int syscall_nr;
1050
1051         WARN_ON_ONCE(!chan->sc_table);
1052
1053         syscall_name = get_syscall_name(event);
1054
1055         switch (event->u.syscall.abi) {
1056         case LTTNG_SYSCALL_ABI_NATIVE:
1057                 syscall_nr = get_syscall_nr(syscall_name);
1058                 break;
1059         case LTTNG_SYSCALL_ABI_COMPAT:
1060                 syscall_nr = get_compat_syscall_nr(syscall_name);
1061                 break;
1062         default:
1063                 return -EINVAL;
1064         }
1065         if (syscall_nr < 0)
1066                 return -ENOENT;
1067
1068         switch (event->u.syscall.entryexit) {
1069         case LTTNG_SYSCALL_ENTRY:
1070                 switch (event->u.syscall.abi) {
1071                 case LTTNG_SYSCALL_ABI_NATIVE:
1072                         bitmap = filter->sc_entry;
1073                         break;
1074                 case LTTNG_SYSCALL_ABI_COMPAT:
1075                         bitmap = filter->sc_compat_entry;
1076                         break;
1077                 default:
1078                         return -EINVAL;
1079                 }
1080                 break;
1081         case LTTNG_SYSCALL_EXIT:
1082                 switch (event->u.syscall.abi) {
1083                 case LTTNG_SYSCALL_ABI_NATIVE:
1084                         bitmap = filter->sc_exit;
1085                         break;
1086                 case LTTNG_SYSCALL_ABI_COMPAT:
1087                         bitmap = filter->sc_compat_exit;
1088                         break;
1089                 default:
1090                         return -EINVAL;
1091                 }
1092                 break;
1093         default:
1094                 return -EINVAL;
1095         }
1096         if (test_bit(syscall_nr, bitmap))
1097                 return -EEXIST;
1098         bitmap_set(bitmap, syscall_nr, 1);
1099         return 0;
1100 }
1101
1102 int lttng_syscall_filter_disable_event(struct lttng_channel *chan,
1103                 struct lttng_event *event)
1104 {
1105         struct lttng_syscall_filter *filter = chan->sc_filter;
1106         const char *syscall_name;
1107         unsigned long *bitmap;
1108         int syscall_nr;
1109
1110         WARN_ON_ONCE(!chan->sc_table);
1111
1112         syscall_name = get_syscall_name(event);
1113
1114         switch (event->u.syscall.abi) {
1115         case LTTNG_SYSCALL_ABI_NATIVE:
1116                 syscall_nr = get_syscall_nr(syscall_name);
1117                 break;
1118         case LTTNG_SYSCALL_ABI_COMPAT:
1119                 syscall_nr = get_compat_syscall_nr(syscall_name);
1120                 break;
1121         default:
1122                 return -EINVAL;
1123         }
1124         if (syscall_nr < 0)
1125                 return -ENOENT;
1126
1127         switch (event->u.syscall.entryexit) {
1128         case LTTNG_SYSCALL_ENTRY:
1129                 switch (event->u.syscall.abi) {
1130                 case LTTNG_SYSCALL_ABI_NATIVE:
1131                         bitmap = filter->sc_entry;
1132                         break;
1133                 case LTTNG_SYSCALL_ABI_COMPAT:
1134                         bitmap = filter->sc_compat_entry;
1135                         break;
1136                 default:
1137                         return -EINVAL;
1138                 }
1139                 break;
1140         case LTTNG_SYSCALL_EXIT:
1141                 switch (event->u.syscall.abi) {
1142                 case LTTNG_SYSCALL_ABI_NATIVE:
1143                         bitmap = filter->sc_exit;
1144                         break;
1145                 case LTTNG_SYSCALL_ABI_COMPAT:
1146                         bitmap = filter->sc_compat_exit;
1147                         break;
1148                 default:
1149                         return -EINVAL;
1150                 }
1151                 break;
1152         default:
1153                 return -EINVAL;
1154         }
1155         if (!test_bit(syscall_nr, bitmap))
1156                 return -EEXIST;
1157         bitmap_clear(bitmap, syscall_nr, 1);
1158
1159         return 0;
1160 }
1161
1162 static
1163 const struct trace_syscall_entry *syscall_list_get_entry(loff_t *pos)
1164 {
1165         const struct trace_syscall_entry *entry;
1166         int iter = 0;
1167
1168         for (entry = sc_table;
1169                         entry < sc_table + ARRAY_SIZE(sc_table);
1170                          entry++) {
1171                 if (iter++ >= *pos)
1172                         return entry;
1173         }
1174         for (entry = compat_sc_table;
1175                         entry < compat_sc_table + ARRAY_SIZE(compat_sc_table);
1176                          entry++) {
1177                 if (iter++ >= *pos)
1178                         return entry;
1179         }
1180         /* End of list */
1181         return NULL;
1182 }
1183
1184 static
1185 void *syscall_list_start(struct seq_file *m, loff_t *pos)
1186 {
1187         return (void *) syscall_list_get_entry(pos);
1188 }
1189
1190 static
1191 void *syscall_list_next(struct seq_file *m, void *p, loff_t *ppos)
1192 {
1193         (*ppos)++;
1194         return (void *) syscall_list_get_entry(ppos);
1195 }
1196
1197 static
1198 void syscall_list_stop(struct seq_file *m, void *p)
1199 {
1200 }
1201
1202 static
1203 int get_sc_table(const struct trace_syscall_entry *entry,
1204                 const struct trace_syscall_entry **table,
1205                 unsigned int *bitness)
1206 {
1207         if (entry >= sc_table && entry < sc_table + ARRAY_SIZE(sc_table)) {
1208                 if (bitness)
1209                         *bitness = BITS_PER_LONG;
1210                 if (table)
1211                         *table = sc_table;
1212                 return 0;
1213         }
1214         if (!(entry >= compat_sc_table
1215                         && entry < compat_sc_table + ARRAY_SIZE(compat_sc_table))) {
1216                 return -EINVAL;
1217         }
1218         if (bitness)
1219                 *bitness = 32;
1220         if (table)
1221                 *table = compat_sc_table;
1222         return 0;
1223 }
1224
1225 static
1226 int syscall_list_show(struct seq_file *m, void *p)
1227 {
1228         const struct trace_syscall_entry *table, *entry = p;
1229         unsigned int bitness;
1230         unsigned long index;
1231         int ret;
1232         const char *name;
1233
1234         ret = get_sc_table(entry, &table, &bitness);
1235         if (ret)
1236                 return ret;
1237         if (!entry->desc)
1238                 return 0;
1239         if (table == sc_table) {
1240                 index = entry - table;
1241                 name = &entry->desc->name[strlen(SYSCALL_ENTRY_STR)];
1242         } else {
1243                 index = (entry - table) + ARRAY_SIZE(sc_table);
1244                 name = &entry->desc->name[strlen(COMPAT_SYSCALL_ENTRY_STR)];
1245         }
1246         seq_printf(m,   "syscall { index = %lu; name = %s; bitness = %u; };\n",
1247                 index, name, bitness);
1248         return 0;
1249 }
1250
1251 static
1252 const struct seq_operations lttng_syscall_list_seq_ops = {
1253         .start = syscall_list_start,
1254         .next = syscall_list_next,
1255         .stop = syscall_list_stop,
1256         .show = syscall_list_show,
1257 };
1258
1259 static
1260 int lttng_syscall_list_open(struct inode *inode, struct file *file)
1261 {
1262         return seq_open(file, &lttng_syscall_list_seq_ops);
1263 }
1264
1265 const struct file_operations lttng_syscall_list_fops = {
1266         .owner = THIS_MODULE,
1267         .open = lttng_syscall_list_open,
1268         .read = seq_read,
1269         .llseek = seq_lseek,
1270         .release = seq_release,
1271 };
1272
1273 /*
1274  * A syscall is enabled if it is traced for either entry or exit.
1275  */
1276 long lttng_channel_syscall_mask(struct lttng_channel *channel,
1277                 struct lttng_kernel_syscall_mask __user *usyscall_mask)
1278 {
1279         uint32_t len, sc_tables_len, bitmask_len;
1280         int ret = 0, bit;
1281         char *tmp_mask;
1282         struct lttng_syscall_filter *filter;
1283
1284         ret = get_user(len, &usyscall_mask->len);
1285         if (ret)
1286                 return ret;
1287         sc_tables_len = get_sc_tables_len();
1288         bitmask_len = ALIGN(sc_tables_len, 8) >> 3;
1289         if (len < sc_tables_len) {
1290                 return put_user(sc_tables_len, &usyscall_mask->len);
1291         }
1292         /* Array is large enough, we can copy array to user-space. */
1293         tmp_mask = kzalloc(bitmask_len, GFP_KERNEL);
1294         if (!tmp_mask)
1295                 return -ENOMEM;
1296         filter = channel->sc_filter;
1297
1298         for (bit = 0; bit < ARRAY_SIZE(sc_table); bit++) {
1299                 char state;
1300
1301                 if (channel->sc_table) {
1302                         if (!READ_ONCE(channel->syscall_all) && filter)
1303                                 state = test_bit(bit, filter->sc_entry)
1304                                         || test_bit(bit, filter->sc_exit);
1305                         else
1306                                 state = 1;
1307                 } else {
1308                         state = 0;
1309                 }
1310                 bt_bitfield_write_be(tmp_mask, char, bit, 1, state);
1311         }
1312         for (; bit < sc_tables_len; bit++) {
1313                 char state;
1314
1315                 if (channel->compat_sc_table) {
1316                         if (!READ_ONCE(channel->syscall_all) && filter)
1317                                 state = test_bit(bit - ARRAY_SIZE(sc_table),
1318                                                 filter->sc_compat_entry)
1319                                         || test_bit(bit - ARRAY_SIZE(sc_table),
1320                                                 filter->sc_compat_exit);
1321                         else
1322                                 state = 1;
1323                 } else {
1324                         state = 0;
1325                 }
1326                 bt_bitfield_write_be(tmp_mask, char, bit, 1, state);
1327         }
1328         if (copy_to_user(usyscall_mask->mask, tmp_mask, bitmask_len))
1329                 ret = -EFAULT;
1330         kfree(tmp_mask);
1331         return ret;
1332 }
1333
1334 int lttng_abi_syscall_list(void)
1335 {
1336         struct file *syscall_list_file;
1337         int file_fd, ret;
1338
1339         file_fd = lttng_get_unused_fd();
1340         if (file_fd < 0) {
1341                 ret = file_fd;
1342                 goto fd_error;
1343         }
1344
1345         syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
1346                                           &lttng_syscall_list_fops,
1347                                           NULL, O_RDWR);
1348         if (IS_ERR(syscall_list_file)) {
1349                 ret = PTR_ERR(syscall_list_file);
1350                 goto file_error;
1351         }
1352         ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
1353         if (ret < 0)
1354                 goto open_error;
1355         fd_install(file_fd, syscall_list_file);
1356         return file_fd;
1357
1358 open_error:
1359         fput(syscall_list_file);
1360 file_error:
1361         put_unused_fd(file_fd);
1362 fd_error:
1363         return ret;
1364 }