contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

   1 //===-- sanitizer_common_syscalls.inc ---------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Common syscalls handlers for tools like AddressSanitizer,
  10 // ThreadSanitizer, MemorySanitizer, etc.
  11 //
  12 // This file should be included into the tool's interceptor file,
  13 // which has to define it's own macros:
  14 //   COMMON_SYSCALL_PRE_READ_RANGE
  15 //          Called in prehook for regions that will be read by the kernel and
  16 //          must be initialized.
  17 //   COMMON_SYSCALL_PRE_WRITE_RANGE
  18 //          Called in prehook for regions that will be written to by the kernel
  19 //          and must be addressable. The actual write range may be smaller than
  20 //          reported in the prehook. See POST_WRITE_RANGE.
  21 //   COMMON_SYSCALL_POST_READ_RANGE
  22 //          Called in posthook for regions that were read by the kernel. Does
  23 //          not make much sense.
  24 //   COMMON_SYSCALL_POST_WRITE_RANGE
  25 //          Called in posthook for regions that were written to by the kernel
  26 //          and are now initialized.
  27 //   COMMON_SYSCALL_ACQUIRE(addr)
  28 //          Acquire memory visibility from addr.
  29 //   COMMON_SYSCALL_RELEASE(addr)
  30 //          Release memory visibility to addr.
  31 //   COMMON_SYSCALL_FD_CLOSE(fd)
  32 //          Called before closing file descriptor fd.
  33 //   COMMON_SYSCALL_FD_ACQUIRE(fd)
  34 //          Acquire memory visibility from fd.
  35 //   COMMON_SYSCALL_FD_RELEASE(fd)
  36 //          Release memory visibility to fd.
  37 //   COMMON_SYSCALL_PRE_FORK()
  38 //          Called before fork syscall.
  39 //   COMMON_SYSCALL_POST_FORK(long res)
  40 //          Called after fork syscall.
  41 //===----------------------------------------------------------------------===//
  42
  43 #include "sanitizer_platform.h"
  44 #if SANITIZER_LINUX
  45
  46 #include "sanitizer_libc.h"
  47
  48 #define PRE_SYSCALL(name)                                                      \
  49   SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_pre_impl_##name
  50 #define PRE_READ(p, s) COMMON_SYSCALL_PRE_READ_RANGE(p, s)
  51 #define PRE_WRITE(p, s) COMMON_SYSCALL_PRE_WRITE_RANGE(p, s)
  52
  53 #define POST_SYSCALL(name)                                                     \
  54   SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_post_impl_##name
  55 #define POST_READ(p, s) COMMON_SYSCALL_POST_READ_RANGE(p, s)
  56 #define POST_WRITE(p, s) COMMON_SYSCALL_POST_WRITE_RANGE(p, s)
  57
  58 #ifndef COMMON_SYSCALL_ACQUIRE
  59 # define COMMON_SYSCALL_ACQUIRE(addr) ((void)(addr))
  60 #endif
  61
  62 #ifndef COMMON_SYSCALL_RELEASE
  63 # define COMMON_SYSCALL_RELEASE(addr) ((void)(addr))
  64 #endif
  65
  66 #ifndef COMMON_SYSCALL_FD_CLOSE
  67 # define COMMON_SYSCALL_FD_CLOSE(fd) ((void)(fd))
  68 #endif
  69
  70 #ifndef COMMON_SYSCALL_FD_ACQUIRE
  71 # define COMMON_SYSCALL_FD_ACQUIRE(fd) ((void)(fd))
  72 #endif
  73
  74 #ifndef COMMON_SYSCALL_FD_RELEASE
  75 # define COMMON_SYSCALL_FD_RELEASE(fd) ((void)(fd))
  76 #endif
  77
  78 #ifndef COMMON_SYSCALL_PRE_FORK
  79 # define COMMON_SYSCALL_PRE_FORK() {}
  80 #endif
  81
  82 #ifndef COMMON_SYSCALL_POST_FORK
  83 # define COMMON_SYSCALL_POST_FORK(res) {}
  84 #endif
  85
  86 // FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such).
  87
  88 extern "C" {
  89 struct sanitizer_kernel_iovec {
  90   void *iov_base;
  91   unsigned long iov_len;
  92 };
  93
  94 struct sanitizer_kernel_msghdr {
  95   void *msg_name;
  96   int msg_namelen;
  97   struct sanitizer_kernel_iovec *msg_iov;
  98   unsigned long msg_iovlen;
  99   void *msg_control;
 100   unsigned long msg_controllen;
 101   unsigned msg_flags;
 102 };
 103
 104 struct sanitizer_kernel_mmsghdr {
 105   struct sanitizer_kernel_msghdr msg_hdr;
 106   unsigned msg_len;
 107 };
 108
 109 struct sanitizer_kernel_timespec {
 110   long tv_sec;
 111   long tv_nsec;
 112 };
 113
 114 struct sanitizer_kernel_timeval {
 115   long tv_sec;
 116   long tv_usec;
 117 };
 118
 119 struct sanitizer_kernel_rusage {
 120   struct sanitizer_kernel_timeval ru_timeval[2];
 121   long ru_long[14];
 122 };
 123
 124 struct sanitizer_kernel_sockaddr {
 125   unsigned short sa_family;
 126   char sa_data[14];
 127 };
 128
 129 // Real sigset size is always passed as a syscall argument.
 130 // Declare it "void" to catch sizeof(kernel_sigset_t).
 131 typedef void kernel_sigset_t;
 132
 133 static void kernel_write_iovec(const __sanitizer_iovec *iovec,
 134                         SIZE_T iovlen, SIZE_T maxlen) {
 135   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
 136     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
 137     POST_WRITE(iovec[i].iov_base, sz);
 138     maxlen -= sz;
 139   }
 140 }
 141
 142 // This functions uses POST_READ, because it needs to run after syscall to know
 143 // the real read range.
 144 static void kernel_read_iovec(const __sanitizer_iovec *iovec,
 145                        SIZE_T iovlen, SIZE_T maxlen) {
 146   POST_READ(iovec, sizeof(*iovec) * iovlen);
 147   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
 148     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
 149     POST_READ(iovec[i].iov_base, sz);
 150     maxlen -= sz;
 151   }
 152 }
 153
 154 PRE_SYSCALL(recvmsg)(long sockfd, sanitizer_kernel_msghdr *msg, long flags) {
 155   PRE_READ(msg, sizeof(*msg));
 156 }
 157
 158 POST_SYSCALL(recvmsg)(long res, long sockfd, sanitizer_kernel_msghdr *msg,
 159                       long flags) {
 160   if (res >= 0) {
 161     if (msg) {
 162       for (unsigned long i = 0; i < msg->msg_iovlen; ++i) {
 163         POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
 164       }
 165       POST_WRITE(msg->msg_control, msg->msg_controllen);
 166     }
 167   }
 168 }
 169
 170 PRE_SYSCALL(recvmmsg)(long fd, sanitizer_kernel_mmsghdr *msg, long vlen,
 171                       long flags, void *timeout) {
 172   PRE_READ(msg, vlen * sizeof(*msg));
 173 }
 174
 175 POST_SYSCALL(recvmmsg)(long res, long fd, sanitizer_kernel_mmsghdr *msg,
 176                        long vlen, long flags, void *timeout) {
 177   if (res >= 0) {
 178     if (msg) {
 179       for (unsigned long i = 0; i < msg->msg_hdr.msg_iovlen; ++i) {
 180         POST_WRITE(msg->msg_hdr.msg_iov[i].iov_base,
 181                    msg->msg_hdr.msg_iov[i].iov_len);
 182       }
 183       POST_WRITE(msg->msg_hdr.msg_control, msg->msg_hdr.msg_controllen);
 184       POST_WRITE(&msg->msg_len, sizeof(msg->msg_len));
 185     }
 186     if (timeout) POST_WRITE(timeout, struct_timespec_sz);
 187   }
 188 }
 189
 190 PRE_SYSCALL(read)(long fd, void *buf, uptr count) {
 191   if (buf) {
 192     PRE_WRITE(buf, count);
 193   }
 194 }
 195
 196 POST_SYSCALL(read)(long res, long fd, void *buf, uptr count) {
 197   if (res > 0 && buf) {
 198     POST_WRITE(buf, res);
 199   }
 200 }
 201
 202 PRE_SYSCALL(time)(void *tloc) {}
 203
 204 POST_SYSCALL(time)(long res, void *tloc) {
 205   if (res >= 0) {
 206     if (tloc) POST_WRITE(tloc, sizeof(long));
 207   }
 208 }
 209
 210 PRE_SYSCALL(stime)(void *tptr) {}
 211
 212 POST_SYSCALL(stime)(long res, void *tptr) {
 213   if (res >= 0) {
 214     if (tptr) POST_WRITE(tptr, sizeof(long));
 215   }
 216 }
 217
 218 PRE_SYSCALL(gettimeofday)(void *tv, void *tz) {}
 219
 220 POST_SYSCALL(gettimeofday)(long res, void *tv, void *tz) {
 221   if (res >= 0) {
 222     if (tv) POST_WRITE(tv, timeval_sz);
 223     if (tz) POST_WRITE(tz, struct_timezone_sz);
 224   }
 225 }
 226
 227 PRE_SYSCALL(settimeofday)(void *tv, void *tz) {}
 228
 229 POST_SYSCALL(settimeofday)(long res, void *tv, void *tz) {
 230   if (res >= 0) {
 231     if (tv) POST_WRITE(tv, timeval_sz);
 232     if (tz) POST_WRITE(tz, struct_timezone_sz);
 233   }
 234 }
 235
 236 #if !SANITIZER_ANDROID
 237 PRE_SYSCALL(adjtimex)(void *txc_p) {}
 238
 239 POST_SYSCALL(adjtimex)(long res, void *txc_p) {
 240   if (res >= 0) {
 241     if (txc_p) POST_WRITE(txc_p, struct_timex_sz);
 242   }
 243 }
 244 #endif
 245
 246 PRE_SYSCALL(times)(void *tbuf) {}
 247
 248 POST_SYSCALL(times)(long res, void *tbuf) {
 249   if (res >= 0) {
 250     if (tbuf) POST_WRITE(tbuf, struct_tms_sz);
 251   }
 252 }
 253
 254 PRE_SYSCALL(gettid)() {}
 255
 256 POST_SYSCALL(gettid)(long res) {}
 257
 258 PRE_SYSCALL(nanosleep)(void *rqtp, void *rmtp) {}
 259
 260 POST_SYSCALL(nanosleep)(long res, void *rqtp, void *rmtp) {
 261   if (res >= 0) {
 262     if (rqtp) POST_WRITE(rqtp, struct_timespec_sz);
 263     if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
 264   }
 265 }
 266
 267 PRE_SYSCALL(alarm)(long seconds) {}
 268
 269 POST_SYSCALL(alarm)(long res, long seconds) {}
 270
 271 PRE_SYSCALL(getpid)() {}
 272
 273 POST_SYSCALL(getpid)(long res) {}
 274
 275 PRE_SYSCALL(getppid)() {}
 276
 277 POST_SYSCALL(getppid)(long res) {}
 278
 279 PRE_SYSCALL(getuid)() {}
 280
 281 POST_SYSCALL(getuid)(long res) {}
 282
 283 PRE_SYSCALL(geteuid)() {}
 284
 285 POST_SYSCALL(geteuid)(long res) {}
 286
 287 PRE_SYSCALL(getgid)() {}
 288
 289 POST_SYSCALL(getgid)(long res) {}
 290
 291 PRE_SYSCALL(getegid)() {}
 292
 293 POST_SYSCALL(getegid)(long res) {}
 294
 295 PRE_SYSCALL(getresuid)(void *ruid, void *euid, void *suid) {}
 296
 297 POST_SYSCALL(getresuid)(long res, void *ruid, void *euid, void *suid) {
 298   if (res >= 0) {
 299     if (ruid) POST_WRITE(ruid, sizeof(unsigned));
 300     if (euid) POST_WRITE(euid, sizeof(unsigned));
 301     if (suid) POST_WRITE(suid, sizeof(unsigned));
 302   }
 303 }
 304
 305 PRE_SYSCALL(getresgid)(void *rgid, void *egid, void *sgid) {}
 306
 307 POST_SYSCALL(getresgid)(long res, void *rgid, void *egid, void *sgid) {
 308   if (res >= 0) {
 309     if (rgid) POST_WRITE(rgid, sizeof(unsigned));
 310     if (egid) POST_WRITE(egid, sizeof(unsigned));
 311     if (sgid) POST_WRITE(sgid, sizeof(unsigned));
 312   }
 313 }
 314
 315 PRE_SYSCALL(getpgid)(long pid) {}
 316
 317 POST_SYSCALL(getpgid)(long res, long pid) {}
 318
 319 PRE_SYSCALL(getpgrp)() {}
 320
 321 POST_SYSCALL(getpgrp)(long res) {}
 322
 323 PRE_SYSCALL(getsid)(long pid) {}
 324
 325 POST_SYSCALL(getsid)(long res, long pid) {}
 326
 327 PRE_SYSCALL(getgroups)(long gidsetsize, void *grouplist) {}
 328
 329 POST_SYSCALL(getgroups)(long res, long gidsetsize,
 330                         __sanitizer___kernel_gid_t *grouplist) {
 331   if (res >= 0) {
 332     if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
 333   }
 334 }
 335
 336 PRE_SYSCALL(setregid)(long rgid, long egid) {}
 337
 338 POST_SYSCALL(setregid)(long res, long rgid, long egid) {}
 339
 340 PRE_SYSCALL(setgid)(long gid) {}
 341
 342 POST_SYSCALL(setgid)(long res, long gid) {}
 343
 344 PRE_SYSCALL(setreuid)(long ruid, long euid) {}
 345
 346 POST_SYSCALL(setreuid)(long res, long ruid, long euid) {}
 347
 348 PRE_SYSCALL(setuid)(long uid) {}
 349
 350 POST_SYSCALL(setuid)(long res, long uid) {}
 351
 352 PRE_SYSCALL(setresuid)(long ruid, long euid, long suid) {}
 353
 354 POST_SYSCALL(setresuid)(long res, long ruid, long euid, long suid) {}
 355
 356 PRE_SYSCALL(setresgid)(long rgid, long egid, long sgid) {}
 357
 358 POST_SYSCALL(setresgid)(long res, long rgid, long egid, long sgid) {}
 359
 360 PRE_SYSCALL(setfsuid)(long uid) {}
 361
 362 POST_SYSCALL(setfsuid)(long res, long uid) {}
 363
 364 PRE_SYSCALL(setfsgid)(long gid) {}
 365
 366 POST_SYSCALL(setfsgid)(long res, long gid) {}
 367
 368 PRE_SYSCALL(setpgid)(long pid, long pgid) {}
 369
 370 POST_SYSCALL(setpgid)(long res, long pid, long pgid) {}
 371
 372 PRE_SYSCALL(setsid)() {}
 373
 374 POST_SYSCALL(setsid)(long res) {}
 375
 376 PRE_SYSCALL(setgroups)(long gidsetsize, __sanitizer___kernel_gid_t *grouplist) {
 377   if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
 378 }
 379
 380 POST_SYSCALL(setgroups)(long res, long gidsetsize,
 381                         __sanitizer___kernel_gid_t *grouplist) {}
 382
 383 PRE_SYSCALL(acct)(const void *name) {
 384   if (name)
 385     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
 386 }
 387
 388 POST_SYSCALL(acct)(long res, const void *name) {}
 389
 390 PRE_SYSCALL(capget)(void *header, void *dataptr) {
 391   if (header) PRE_READ(header, __user_cap_header_struct_sz);
 392 }
 393
 394 POST_SYSCALL(capget)(long res, void *header, void *dataptr) {
 395   if (res >= 0)
 396     if (dataptr) POST_WRITE(dataptr, __user_cap_data_struct_sz);
 397 }
 398
 399 PRE_SYSCALL(capset)(void *header, const void *data) {
 400   if (header) PRE_READ(header, __user_cap_header_struct_sz);
 401   if (data) PRE_READ(data, __user_cap_data_struct_sz);
 402 }
 403
 404 POST_SYSCALL(capset)(long res, void *header, const void *data) {}
 405
 406 PRE_SYSCALL(personality)(long personality) {}
 407
 408 POST_SYSCALL(personality)(long res, long personality) {}
 409
 410 PRE_SYSCALL(sigpending)(void *set) {}
 411
 412 POST_SYSCALL(sigpending)(long res, void *set) {
 413   if (res >= 0) {
 414     if (set) POST_WRITE(set, old_sigset_t_sz);
 415   }
 416 }
 417
 418 PRE_SYSCALL(sigprocmask)(long how, void *set, void *oset) {}
 419
 420 POST_SYSCALL(sigprocmask)(long res, long how, void *set, void *oset) {
 421   if (res >= 0) {
 422     if (set) POST_WRITE(set, old_sigset_t_sz);
 423     if (oset) POST_WRITE(oset, old_sigset_t_sz);
 424   }
 425 }
 426
 427 PRE_SYSCALL(getitimer)(long which, void *value) {}
 428
 429 POST_SYSCALL(getitimer)(long res, long which, void *value) {
 430   if (res >= 0) {
 431     if (value) POST_WRITE(value, struct_itimerval_sz);
 432   }
 433 }
 434
 435 PRE_SYSCALL(setitimer)(long which, void *value, void *ovalue) {}
 436
 437 POST_SYSCALL(setitimer)(long res, long which, void *value, void *ovalue) {
 438   if (res >= 0) {
 439     if (value) POST_WRITE(value, struct_itimerval_sz);
 440     if (ovalue) POST_WRITE(ovalue, struct_itimerval_sz);
 441   }
 442 }
 443
 444 PRE_SYSCALL(timer_create)(long which_clock, void *timer_event_spec,
 445                           void *created_timer_id) {}
 446
 447 POST_SYSCALL(timer_create)(long res, long which_clock, void *timer_event_spec,
 448                            void *created_timer_id) {
 449   if (res >= 0) {
 450     if (timer_event_spec) POST_WRITE(timer_event_spec, struct_sigevent_sz);
 451     if (created_timer_id) POST_WRITE(created_timer_id, sizeof(long));
 452   }
 453 }
 454
 455 PRE_SYSCALL(timer_gettime)(long timer_id, void *setting) {}
 456
 457 POST_SYSCALL(timer_gettime)(long res, long timer_id, void *setting) {
 458   if (res >= 0) {
 459     if (setting) POST_WRITE(setting, struct_itimerspec_sz);
 460   }
 461 }
 462
 463 PRE_SYSCALL(timer_getoverrun)(long timer_id) {}
 464
 465 POST_SYSCALL(timer_getoverrun)(long res, long timer_id) {}
 466
 467 PRE_SYSCALL(timer_settime)(long timer_id, long flags, const void *new_setting,
 468                            void *old_setting) {
 469   if (new_setting) PRE_READ(new_setting, struct_itimerspec_sz);
 470 }
 471
 472 POST_SYSCALL(timer_settime)(long res, long timer_id, long flags,
 473                             const void *new_setting, void *old_setting) {
 474   if (res >= 0) {
 475     if (old_setting) POST_WRITE(old_setting, struct_itimerspec_sz);
 476   }
 477 }
 478
 479 PRE_SYSCALL(timer_delete)(long timer_id) {}
 480
 481 POST_SYSCALL(timer_delete)(long res, long timer_id) {}
 482
 483 PRE_SYSCALL(clock_settime)(long which_clock, const void *tp) {
 484   if (tp) PRE_READ(tp, struct_timespec_sz);
 485 }
 486
 487 POST_SYSCALL(clock_settime)(long res, long which_clock, const void *tp) {}
 488
 489 PRE_SYSCALL(clock_gettime)(long which_clock, void *tp) {}
 490
 491 POST_SYSCALL(clock_gettime)(long res, long which_clock, void *tp) {
 492   if (res >= 0) {
 493     if (tp) POST_WRITE(tp, struct_timespec_sz);
 494   }
 495 }
 496
 497 #if !SANITIZER_ANDROID
 498 PRE_SYSCALL(clock_adjtime)(long which_clock, void *tx) {}
 499
 500 POST_SYSCALL(clock_adjtime)(long res, long which_clock, void *tx) {
 501   if (res >= 0) {
 502     if (tx) POST_WRITE(tx, struct_timex_sz);
 503   }
 504 }
 505 #endif
 506
 507 PRE_SYSCALL(clock_getres)(long which_clock, void *tp) {}
 508
 509 POST_SYSCALL(clock_getres)(long res, long which_clock, void *tp) {
 510   if (res >= 0) {
 511     if (tp) POST_WRITE(tp, struct_timespec_sz);
 512   }
 513 }
 514
 515 PRE_SYSCALL(clock_nanosleep)(long which_clock, long flags, const void *rqtp,
 516                              void *rmtp) {
 517   if (rqtp) PRE_READ(rqtp, struct_timespec_sz);
 518 }
 519
 520 POST_SYSCALL(clock_nanosleep)(long res, long which_clock, long flags,
 521                               const void *rqtp, void *rmtp) {
 522   if (res >= 0) {
 523     if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
 524   }
 525 }
 526
 527 PRE_SYSCALL(nice)(long increment) {}
 528
 529 POST_SYSCALL(nice)(long res, long increment) {}
 530
 531 PRE_SYSCALL(sched_setscheduler)(long pid, long policy, void *param) {}
 532
 533 POST_SYSCALL(sched_setscheduler)(long res, long pid, long policy, void *param) {
 534   if (res >= 0) {
 535     if (param) POST_WRITE(param, struct_sched_param_sz);
 536   }
 537 }
 538
 539 PRE_SYSCALL(sched_setparam)(long pid, void *param) {
 540   if (param) PRE_READ(param, struct_sched_param_sz);
 541 }
 542
 543 POST_SYSCALL(sched_setparam)(long res, long pid, void *param) {}
 544
 545 PRE_SYSCALL(sched_getscheduler)(long pid) {}
 546
 547 POST_SYSCALL(sched_getscheduler)(long res, long pid) {}
 548
 549 PRE_SYSCALL(sched_getparam)(long pid, void *param) {}
 550
 551 POST_SYSCALL(sched_getparam)(long res, long pid, void *param) {
 552   if (res >= 0) {
 553     if (param) POST_WRITE(param, struct_sched_param_sz);
 554   }
 555 }
 556
 557 PRE_SYSCALL(sched_setaffinity)(long pid, long len, void *user_mask_ptr) {
 558   if (user_mask_ptr) PRE_READ(user_mask_ptr, len);
 559 }
 560
 561 POST_SYSCALL(sched_setaffinity)(long res, long pid, long len,
 562                                 void *user_mask_ptr) {}
 563
 564 PRE_SYSCALL(sched_getaffinity)(long pid, long len, void *user_mask_ptr) {}
 565
 566 POST_SYSCALL(sched_getaffinity)(long res, long pid, long len,
 567                                 void *user_mask_ptr) {
 568   if (res >= 0) {
 569     if (user_mask_ptr) POST_WRITE(user_mask_ptr, len);
 570   }
 571 }
 572
 573 PRE_SYSCALL(sched_yield)() {}
 574
 575 POST_SYSCALL(sched_yield)(long res) {}
 576
 577 PRE_SYSCALL(sched_get_priority_max)(long policy) {}
 578
 579 POST_SYSCALL(sched_get_priority_max)(long res, long policy) {}
 580
 581 PRE_SYSCALL(sched_get_priority_min)(long policy) {}
 582
 583 POST_SYSCALL(sched_get_priority_min)(long res, long policy) {}
 584
 585 PRE_SYSCALL(sched_rr_get_interval)(long pid, void *interval) {}
 586
 587 POST_SYSCALL(sched_rr_get_interval)(long res, long pid, void *interval) {
 588   if (res >= 0) {
 589     if (interval) POST_WRITE(interval, struct_timespec_sz);
 590   }
 591 }
 592
 593 PRE_SYSCALL(setpriority)(long which, long who, long niceval) {}
 594
 595 POST_SYSCALL(setpriority)(long res, long which, long who, long niceval) {}
 596
 597 PRE_SYSCALL(getpriority)(long which, long who) {}
 598
 599 POST_SYSCALL(getpriority)(long res, long which, long who) {}
 600
 601 PRE_SYSCALL(shutdown)(long arg0, long arg1) {}
 602
 603 POST_SYSCALL(shutdown)(long res, long arg0, long arg1) {}
 604
 605 PRE_SYSCALL(reboot)(long magic1, long magic2, long cmd, void *arg) {}
 606
 607 POST_SYSCALL(reboot)(long res, long magic1, long magic2, long cmd, void *arg) {}
 608
 609 PRE_SYSCALL(restart_syscall)() {}
 610
 611 POST_SYSCALL(restart_syscall)(long res) {}
 612
 613 PRE_SYSCALL(kexec_load)(long entry, long nr_segments, void *segments,
 614                         long flags) {}
 615
 616 POST_SYSCALL(kexec_load)(long res, long entry, long nr_segments, void *segments,
 617                          long flags) {
 618   if (res >= 0) {
 619     if (segments) POST_WRITE(segments, struct_kexec_segment_sz);
 620   }
 621 }
 622
 623 PRE_SYSCALL(exit)(long error_code) {}
 624
 625 POST_SYSCALL(exit)(long res, long error_code) {}
 626
 627 PRE_SYSCALL(exit_group)(long error_code) {}
 628
 629 POST_SYSCALL(exit_group)(long res, long error_code) {}
 630
 631 PRE_SYSCALL(wait4)(long pid, void *stat_addr, long options, void *ru) {}
 632
 633 POST_SYSCALL(wait4)(long res, long pid, void *stat_addr, long options,
 634                     void *ru) {
 635   if (res >= 0) {
 636     if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
 637     if (ru) POST_WRITE(ru, struct_rusage_sz);
 638   }
 639 }
 640
 641 PRE_SYSCALL(waitid)(long which, long pid, void *infop, long options, void *ru) {
 642 }
 643
 644 POST_SYSCALL(waitid)(long res, long which, long pid, void *infop, long options,
 645                      void *ru) {
 646   if (res >= 0) {
 647     if (infop) POST_WRITE(infop, siginfo_t_sz);
 648     if (ru) POST_WRITE(ru, struct_rusage_sz);
 649   }
 650 }
 651
 652 PRE_SYSCALL(waitpid)(long pid, void *stat_addr, long options) {}
 653
 654 POST_SYSCALL(waitpid)(long res, long pid, void *stat_addr, long options) {
 655   if (res >= 0) {
 656     if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
 657   }
 658 }
 659
 660 PRE_SYSCALL(set_tid_address)(void *tidptr) {}
 661
 662 POST_SYSCALL(set_tid_address)(long res, void *tidptr) {
 663   if (res >= 0) {
 664     if (tidptr) POST_WRITE(tidptr, sizeof(int));
 665   }
 666 }
 667
 668 PRE_SYSCALL(init_module)(void *umod, long len, const void *uargs) {
 669   if (uargs)
 670     PRE_READ(uargs, __sanitizer::internal_strlen((const char *)uargs) + 1);
 671 }
 672
 673 POST_SYSCALL(init_module)(long res, void *umod, long len, const void *uargs) {}
 674
 675 PRE_SYSCALL(delete_module)(const void *name_user, long flags) {
 676   if (name_user)
 677     PRE_READ(name_user,
 678              __sanitizer::internal_strlen((const char *)name_user) + 1);
 679 }
 680
 681 POST_SYSCALL(delete_module)(long res, const void *name_user, long flags) {}
 682
 683 PRE_SYSCALL(rt_sigprocmask)(long how, void *set, void *oset, long sigsetsize) {}
 684
 685 POST_SYSCALL(rt_sigprocmask)(long res, long how, kernel_sigset_t *set,
 686                              kernel_sigset_t *oset, long sigsetsize) {
 687   if (res >= 0) {
 688     if (set) POST_WRITE(set, sigsetsize);
 689     if (oset) POST_WRITE(oset, sigsetsize);
 690   }
 691 }
 692
 693 PRE_SYSCALL(rt_sigpending)(void *set, long sigsetsize) {}
 694
 695 POST_SYSCALL(rt_sigpending)(long res, kernel_sigset_t *set, long sigsetsize) {
 696   if (res >= 0) {
 697     if (set) POST_WRITE(set, sigsetsize);
 698   }
 699 }
 700
 701 PRE_SYSCALL(rt_sigtimedwait)(const kernel_sigset_t *uthese, void *uinfo,
 702                              const void *uts, long sigsetsize) {
 703   if (uthese) PRE_READ(uthese, sigsetsize);
 704   if (uts) PRE_READ(uts, struct_timespec_sz);
 705 }
 706
 707 POST_SYSCALL(rt_sigtimedwait)(long res, const void *uthese, void *uinfo,
 708                               const void *uts, long sigsetsize) {
 709   if (res >= 0) {
 710     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
 711   }
 712 }
 713
 714 PRE_SYSCALL(rt_tgsigqueueinfo)(long tgid, long pid, long sig, void *uinfo) {}
 715
 716 POST_SYSCALL(rt_tgsigqueueinfo)(long res, long tgid, long pid, long sig,
 717                                 void *uinfo) {
 718   if (res >= 0) {
 719     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
 720   }
 721 }
 722
 723 PRE_SYSCALL(kill)(long pid, long sig) {}
 724
 725 POST_SYSCALL(kill)(long res, long pid, long sig) {}
 726
 727 PRE_SYSCALL(tgkill)(long tgid, long pid, long sig) {}
 728
 729 POST_SYSCALL(tgkill)(long res, long tgid, long pid, long sig) {}
 730
 731 PRE_SYSCALL(tkill)(long pid, long sig) {}
 732
 733 POST_SYSCALL(tkill)(long res, long pid, long sig) {}
 734
 735 PRE_SYSCALL(rt_sigqueueinfo)(long pid, long sig, void *uinfo) {}
 736
 737 POST_SYSCALL(rt_sigqueueinfo)(long res, long pid, long sig, void *uinfo) {
 738   if (res >= 0) {
 739     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
 740   }
 741 }
 742
 743 PRE_SYSCALL(sgetmask)() {}
 744
 745 POST_SYSCALL(sgetmask)(long res) {}
 746
 747 PRE_SYSCALL(ssetmask)(long newmask) {}
 748
 749 POST_SYSCALL(ssetmask)(long res, long newmask) {}
 750
 751 PRE_SYSCALL(signal)(long sig, long handler) {}
 752
 753 POST_SYSCALL(signal)(long res, long sig, long handler) {}
 754
 755 PRE_SYSCALL(pause)() {}
 756
 757 POST_SYSCALL(pause)(long res) {}
 758
 759 PRE_SYSCALL(sync)() {}
 760
 761 POST_SYSCALL(sync)(long res) {}
 762
 763 PRE_SYSCALL(fsync)(long fd) {}
 764
 765 POST_SYSCALL(fsync)(long res, long fd) {}
 766
 767 PRE_SYSCALL(fdatasync)(long fd) {}
 768
 769 POST_SYSCALL(fdatasync)(long res, long fd) {}
 770
 771 PRE_SYSCALL(bdflush)(long func, long data) {}
 772
 773 POST_SYSCALL(bdflush)(long res, long func, long data) {}
 774
 775 PRE_SYSCALL(mount)(void *dev_name, void *dir_name, void *type, long flags,
 776                    void *data) {}
 777
 778 POST_SYSCALL(mount)(long res, void *dev_name, void *dir_name, void *type,
 779                     long flags, void *data) {
 780   if (res >= 0) {
 781     if (dev_name)
 782       POST_WRITE(dev_name,
 783                  __sanitizer::internal_strlen((const char *)dev_name) + 1);
 784     if (dir_name)
 785       POST_WRITE(dir_name,
 786                  __sanitizer::internal_strlen((const char *)dir_name) + 1);
 787     if (type)
 788       POST_WRITE(type, __sanitizer::internal_strlen((const char *)type) + 1);
 789   }
 790 }
 791
 792 PRE_SYSCALL(umount)(void *name, long flags) {}
 793
 794 POST_SYSCALL(umount)(long res, void *name, long flags) {
 795   if (res >= 0) {
 796     if (name)
 797       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
 798   }
 799 }
 800
 801 PRE_SYSCALL(oldumount)(void *name) {}
 802
 803 POST_SYSCALL(oldumount)(long res, void *name) {
 804   if (res >= 0) {
 805     if (name)
 806       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
 807   }
 808 }
 809
 810 PRE_SYSCALL(truncate)(const void *path, long length) {
 811   if (path)
 812     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
 813 }
 814
 815 POST_SYSCALL(truncate)(long res, const void *path, long length) {}
 816
 817 PRE_SYSCALL(ftruncate)(long fd, long length) {}
 818
 819 POST_SYSCALL(ftruncate)(long res, long fd, long length) {}
 820
 821 PRE_SYSCALL(stat)(const void *filename, void *statbuf) {
 822   if (filename)
 823     PRE_READ(filename,
 824              __sanitizer::internal_strlen((const char *)filename) + 1);
 825 }
 826
 827 POST_SYSCALL(stat)(long res, const void *filename, void *statbuf) {
 828   if (res >= 0) {
 829     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
 830   }
 831 }
 832
 833 #if !SANITIZER_ANDROID
 834 PRE_SYSCALL(statfs)(const void *path, void *buf) {
 835   if (path)
 836     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
 837 }
 838
 839 POST_SYSCALL(statfs)(long res, const void *path, void *buf) {
 840   if (res >= 0) {
 841     if (buf) POST_WRITE(buf, struct_statfs_sz);
 842   }
 843 }
 844
 845 PRE_SYSCALL(statfs64)(const void *path, long sz, void *buf) {
 846   if (path)
 847     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
 848 }
 849
 850 POST_SYSCALL(statfs64)(long res, const void *path, long sz, void *buf) {
 851   if (res >= 0) {
 852     if (buf) POST_WRITE(buf, struct_statfs64_sz);
 853   }
 854 }
 855
 856 PRE_SYSCALL(fstatfs)(long fd, void *buf) {}
 857
 858 POST_SYSCALL(fstatfs)(long res, long fd, void *buf) {
 859   if (res >= 0) {
 860     if (buf) POST_WRITE(buf, struct_statfs_sz);
 861   }
 862 }
 863
 864 PRE_SYSCALL(fstatfs64)(long fd, long sz, void *buf) {}
 865
 866 POST_SYSCALL(fstatfs64)(long res, long fd, long sz, void *buf) {
 867   if (res >= 0) {
 868     if (buf) POST_WRITE(buf, struct_statfs64_sz);
 869   }
 870 }
 871 #endif // !SANITIZER_ANDROID
 872
 873 PRE_SYSCALL(lstat)(const void *filename, void *statbuf) {
 874   if (filename)
 875     PRE_READ(filename,
 876              __sanitizer::internal_strlen((const char *)filename) + 1);
 877 }
 878
 879 POST_SYSCALL(lstat)(long res, const void *filename, void *statbuf) {
 880   if (res >= 0) {
 881     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
 882   }
 883 }
 884
 885 PRE_SYSCALL(fstat)(long fd, void *statbuf) {}
 886
 887 POST_SYSCALL(fstat)(long res, long fd, void *statbuf) {
 888   if (res >= 0) {
 889     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
 890   }
 891 }
 892
 893 PRE_SYSCALL(newstat)(const void *filename, void *statbuf) {
 894   if (filename)
 895     PRE_READ(filename,
 896              __sanitizer::internal_strlen((const char *)filename) + 1);
 897 }
 898
 899 POST_SYSCALL(newstat)(long res, const void *filename, void *statbuf) {
 900   if (res >= 0) {
 901     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
 902   }
 903 }
 904
 905 PRE_SYSCALL(newlstat)(const void *filename, void *statbuf) {
 906   if (filename)
 907     PRE_READ(filename,
 908              __sanitizer::internal_strlen((const char *)filename) + 1);
 909 }
 910
 911 POST_SYSCALL(newlstat)(long res, const void *filename, void *statbuf) {
 912   if (res >= 0) {
 913     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
 914   }
 915 }
 916
 917 PRE_SYSCALL(newfstat)(long fd, void *statbuf) {}
 918
 919 POST_SYSCALL(newfstat)(long res, long fd, void *statbuf) {
 920   if (res >= 0) {
 921     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
 922   }
 923 }
 924
 925 #if !SANITIZER_ANDROID
 926 PRE_SYSCALL(ustat)(long dev, void *ubuf) {}
 927
 928 POST_SYSCALL(ustat)(long res, long dev, void *ubuf) {
 929   if (res >= 0) {
 930     if (ubuf) POST_WRITE(ubuf, struct_ustat_sz);
 931   }
 932 }
 933 #endif  // !SANITIZER_ANDROID
 934
 935 PRE_SYSCALL(stat64)(const void *filename, void *statbuf) {
 936   if (filename)
 937     PRE_READ(filename,
 938              __sanitizer::internal_strlen((const char *)filename) + 1);
 939 }
 940
 941 POST_SYSCALL(stat64)(long res, const void *filename, void *statbuf) {
 942   if (res >= 0) {
 943     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
 944   }
 945 }
 946
 947 PRE_SYSCALL(fstat64)(long fd, void *statbuf) {}
 948
 949 POST_SYSCALL(fstat64)(long res, long fd, void *statbuf) {
 950   if (res >= 0) {
 951     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
 952   }
 953 }
 954
 955 PRE_SYSCALL(lstat64)(const void *filename, void *statbuf) {
 956   if (filename)
 957     PRE_READ(filename,
 958              __sanitizer::internal_strlen((const char *)filename) + 1);
 959 }
 960
 961 POST_SYSCALL(lstat64)(long res, const void *filename, void *statbuf) {
 962   if (res >= 0) {
 963     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
 964   }
 965 }
 966
 967 PRE_SYSCALL(setxattr)(const void *path, const void *name, const void *value,
 968                       long size, long flags) {
 969   if (path)
 970     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
 971   if (name)
 972     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
 973   if (value) PRE_READ(value, size);
 974 }
 975
 976 POST_SYSCALL(setxattr)(long res, const void *path, const void *name,
 977                        const void *value, long size, long flags) {}
 978
 979 PRE_SYSCALL(lsetxattr)(const void *path, const void *name, const void *value,
 980                        long size, long flags) {
 981   if (path)
 982     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
 983   if (name)
 984     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
 985   if (value) PRE_READ(value, size);
 986 }
 987
 988 POST_SYSCALL(lsetxattr)(long res, const void *path, const void *name,
 989                         const void *value, long size, long flags) {}
 990
 991 PRE_SYSCALL(fsetxattr)(long fd, const void *name, const void *value, long size,
 992                        long flags) {
 993   if (name)
 994     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
 995   if (value) PRE_READ(value, size);
 996 }
 997
 998 POST_SYSCALL(fsetxattr)(long res, long fd, const void *name, const void *value,
 999                         long size, long flags) {}
1000
1001 PRE_SYSCALL(getxattr)(const void *path, const void *name, void *value,
1002                       long size) {
1003   if (path)
1004     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1005   if (name)
1006     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1007 }
1008
1009 POST_SYSCALL(getxattr)(long res, const void *path, const void *name,
1010                        void *value, long size) {
1011   if (size && res > 0) {
1012     if (value) POST_WRITE(value, res);
1013   }
1014 }
1015
1016 PRE_SYSCALL(lgetxattr)(const void *path, const void *name, void *value,
1017                        long size) {
1018   if (path)
1019     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1020   if (name)
1021     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1022 }
1023
1024 POST_SYSCALL(lgetxattr)(long res, const void *path, const void *name,
1025                         void *value, long size) {
1026   if (size && res > 0) {
1027     if (value) POST_WRITE(value, res);
1028   }
1029 }
1030
1031 PRE_SYSCALL(fgetxattr)(long fd, const void *name, void *value, long size) {
1032   if (name)
1033     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1034 }
1035
1036 POST_SYSCALL(fgetxattr)(long res, long fd, const void *name, void *value,
1037                         long size) {
1038   if (size && res > 0) {
1039     if (value) POST_WRITE(value, res);
1040   }
1041 }
1042
1043 PRE_SYSCALL(listxattr)(const void *path, void *list, long size) {
1044   if (path)
1045     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1046 }
1047
1048 POST_SYSCALL(listxattr)(long res, const void *path, void *list, long size) {
1049   if (size && res > 0) {
1050     if (list) POST_WRITE(list, res);
1051   }
1052 }
1053
1054 PRE_SYSCALL(llistxattr)(const void *path, void *list, long size) {
1055   if (path)
1056     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1057 }
1058
1059 POST_SYSCALL(llistxattr)(long res, const void *path, void *list, long size) {
1060   if (size && res > 0) {
1061     if (list) POST_WRITE(list, res);
1062   }
1063 }
1064
1065 PRE_SYSCALL(flistxattr)(long fd, void *list, long size) {}
1066
1067 POST_SYSCALL(flistxattr)(long res, long fd, void *list, long size) {
1068   if (size && res > 0) {
1069     if (list) POST_WRITE(list, res);
1070   }
1071 }
1072
1073 PRE_SYSCALL(removexattr)(const void *path, const void *name) {
1074   if (path)
1075     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1076   if (name)
1077     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1078 }
1079
1080 POST_SYSCALL(removexattr)(long res, const void *path, const void *name) {}
1081
1082 PRE_SYSCALL(lremovexattr)(const void *path, const void *name) {
1083   if (path)
1084     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1085   if (name)
1086     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1087 }
1088
1089 POST_SYSCALL(lremovexattr)(long res, const void *path, const void *name) {}
1090
1091 PRE_SYSCALL(fremovexattr)(long fd, const void *name) {
1092   if (name)
1093     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1094 }
1095
1096 POST_SYSCALL(fremovexattr)(long res, long fd, const void *name) {}
1097
1098 PRE_SYSCALL(brk)(long brk) {}
1099
1100 POST_SYSCALL(brk)(long res, long brk) {}
1101
1102 PRE_SYSCALL(mprotect)(long start, long len, long prot) {}
1103
1104 POST_SYSCALL(mprotect)(long res, long start, long len, long prot) {}
1105
1106 PRE_SYSCALL(mremap)(long addr, long old_len, long new_len, long flags,
1107                     long new_addr) {}
1108
1109 POST_SYSCALL(mremap)(long res, long addr, long old_len, long new_len,
1110                      long flags, long new_addr) {}
1111
1112 PRE_SYSCALL(remap_file_pages)(long start, long size, long prot, long pgoff,
1113                               long flags) {}
1114
1115 POST_SYSCALL(remap_file_pages)(long res, long start, long size, long prot,
1116                                long pgoff, long flags) {}
1117
1118 PRE_SYSCALL(msync)(long start, long len, long flags) {}
1119
1120 POST_SYSCALL(msync)(long res, long start, long len, long flags) {}
1121
1122 PRE_SYSCALL(munmap)(long addr, long len) {}
1123
1124 POST_SYSCALL(munmap)(long res, long addr, long len) {}
1125
1126 PRE_SYSCALL(mlock)(long start, long len) {}
1127
1128 POST_SYSCALL(mlock)(long res, long start, long len) {}
1129
1130 PRE_SYSCALL(munlock)(long start, long len) {}
1131
1132 POST_SYSCALL(munlock)(long res, long start, long len) {}
1133
1134 PRE_SYSCALL(mlockall)(long flags) {}
1135
1136 POST_SYSCALL(mlockall)(long res, long flags) {}
1137
1138 PRE_SYSCALL(munlockall)() {}
1139
1140 POST_SYSCALL(munlockall)(long res) {}
1141
1142 PRE_SYSCALL(madvise)(long start, long len, long behavior) {}
1143
1144 POST_SYSCALL(madvise)(long res, long start, long len, long behavior) {}
1145
1146 PRE_SYSCALL(mincore)(long start, long len, void *vec) {}
1147
1148 POST_SYSCALL(mincore)(long res, long start, long len, void *vec) {
1149   if (res >= 0) {
1150     if (vec) {
1151       POST_WRITE(vec, (len + GetPageSizeCached() - 1) / GetPageSizeCached());
1152     }
1153   }
1154 }
1155
1156 PRE_SYSCALL(pivot_root)(const void *new_root, const void *put_old) {
1157   if (new_root)
1158     PRE_READ(new_root,
1159              __sanitizer::internal_strlen((const char *)new_root) + 1);
1160   if (put_old)
1161     PRE_READ(put_old, __sanitizer::internal_strlen((const char *)put_old) + 1);
1162 }
1163
1164 POST_SYSCALL(pivot_root)(long res, const void *new_root, const void *put_old) {}
1165
1166 PRE_SYSCALL(chroot)(const void *filename) {
1167   if (filename)
1168     PRE_READ(filename,
1169              __sanitizer::internal_strlen((const char *)filename) + 1);
1170 }
1171
1172 POST_SYSCALL(chroot)(long res, const void *filename) {}
1173
1174 PRE_SYSCALL(mknod)(const void *filename, long mode, long dev) {
1175   if (filename)
1176     PRE_READ(filename,
1177              __sanitizer::internal_strlen((const char *)filename) + 1);
1178 }
1179
1180 POST_SYSCALL(mknod)(long res, const void *filename, long mode, long dev) {}
1181
1182 PRE_SYSCALL(link)(const void *oldname, const void *newname) {
1183   if (oldname)
1184     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
1185   if (newname)
1186     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
1187 }
1188
1189 POST_SYSCALL(link)(long res, const void *oldname, const void *newname) {}
1190
1191 PRE_SYSCALL(symlink)(const void *old, const void *new_) {
1192   if (old) PRE_READ(old, __sanitizer::internal_strlen((const char *)old) + 1);
1193   if (new_)
1194     PRE_READ(new_, __sanitizer::internal_strlen((const char *)new_) + 1);
1195 }
1196
1197 POST_SYSCALL(symlink)(long res, const void *old, const void *new_) {}
1198
1199 PRE_SYSCALL(unlink)(const void *pathname) {
1200   if (pathname)
1201     PRE_READ(pathname,
1202              __sanitizer::internal_strlen((const char *)pathname) + 1);
1203 }
1204
1205 POST_SYSCALL(unlink)(long res, const void *pathname) {}
1206
1207 PRE_SYSCALL(rename)(const void *oldname, const void *newname) {
1208   if (oldname)
1209     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
1210   if (newname)
1211     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
1212 }
1213
1214 POST_SYSCALL(rename)(long res, const void *oldname, const void *newname) {}
1215
1216 PRE_SYSCALL(chmod)(const void *filename, long mode) {
1217   if (filename)
1218     PRE_READ(filename,
1219              __sanitizer::internal_strlen((const char *)filename) + 1);
1220 }
1221
1222 POST_SYSCALL(chmod)(long res, const void *filename, long mode) {}
1223
1224 PRE_SYSCALL(fchmod)(long fd, long mode) {}
1225
1226 POST_SYSCALL(fchmod)(long res, long fd, long mode) {}
1227
1228 PRE_SYSCALL(fcntl)(long fd, long cmd, long arg) {}
1229
1230 POST_SYSCALL(fcntl)(long res, long fd, long cmd, long arg) {}
1231
1232 PRE_SYSCALL(fcntl64)(long fd, long cmd, long arg) {}
1233
1234 POST_SYSCALL(fcntl64)(long res, long fd, long cmd, long arg) {}
1235
1236 PRE_SYSCALL(pipe)(void *fildes) {}
1237
1238 POST_SYSCALL(pipe)(long res, void *fildes) {
1239   if (res >= 0)
1240     if (fildes) POST_WRITE(fildes, sizeof(int) * 2);
1241 }
1242
1243 PRE_SYSCALL(pipe2)(void *fildes, long flags) {}
1244
1245 POST_SYSCALL(pipe2)(long res, void *fildes, long flags) {
1246   if (res >= 0)
1247     if (fildes) POST_WRITE(fildes, sizeof(int) * 2);
1248 }
1249
1250 PRE_SYSCALL(dup)(long fildes) {}
1251
1252 POST_SYSCALL(dup)(long res, long fildes) {}
1253
1254 PRE_SYSCALL(dup2)(long oldfd, long newfd) {}
1255
1256 POST_SYSCALL(dup2)(long res, long oldfd, long newfd) {}
1257
1258 PRE_SYSCALL(dup3)(long oldfd, long newfd, long flags) {}
1259
1260 POST_SYSCALL(dup3)(long res, long oldfd, long newfd, long flags) {}
1261
1262 PRE_SYSCALL(ioperm)(long from, long num, long on) {}
1263
1264 POST_SYSCALL(ioperm)(long res, long from, long num, long on) {}
1265
1266 PRE_SYSCALL(ioctl)(long fd, long cmd, long arg) {}
1267
1268 POST_SYSCALL(ioctl)(long res, long fd, long cmd, long arg) {}
1269
1270 PRE_SYSCALL(flock)(long fd, long cmd) {}
1271
1272 POST_SYSCALL(flock)(long res, long fd, long cmd) {}
1273
1274 PRE_SYSCALL(io_setup)(long nr_reqs, void **ctx) {
1275   if (ctx) PRE_WRITE(ctx, sizeof(*ctx));
1276 }
1277
1278 POST_SYSCALL(io_setup)(long res, long nr_reqs, void **ctx) {
1279   if (res >= 0) {
1280     if (ctx) POST_WRITE(ctx, sizeof(*ctx));
1281     // (*ctx) is actually a pointer to a kernel mapped page, and there are
1282     // people out there who are crazy enough to peek into that page's 32-byte
1283     // header.
1284     if (*ctx) POST_WRITE(*ctx, 32);
1285   }
1286 }
1287
1288 PRE_SYSCALL(io_destroy)(long ctx) {}
1289
1290 POST_SYSCALL(io_destroy)(long res, long ctx) {}
1291
1292 PRE_SYSCALL(io_getevents)(long ctx_id, long min_nr, long nr,
1293                           __sanitizer_io_event *ioevpp, void *timeout) {
1294   if (timeout) PRE_READ(timeout, struct_timespec_sz);
1295 }
1296
1297 POST_SYSCALL(io_getevents)(long res, long ctx_id, long min_nr, long nr,
1298                            __sanitizer_io_event *ioevpp, void *timeout) {
1299   if (res >= 0) {
1300     if (ioevpp) POST_WRITE(ioevpp, res * sizeof(*ioevpp));
1301     if (timeout) POST_WRITE(timeout, struct_timespec_sz);
1302   }
1303   for (long i = 0; i < res; i++) {
1304     // We synchronize io_submit -> io_getevents/io_cancel using the
1305     // user-provided data context. Data is not necessary a pointer, it can be
1306     // an int, 0 or whatever; acquire/release will correctly handle this.
1307     // This scheme can lead to false negatives, e.g. when all operations
1308     // synchronize on 0. But there does not seem to be a better solution
1309     // (except wrapping all operations in own context, which is unreliable).
1310     // We can not reliably extract fildes in io_getevents.
1311     COMMON_SYSCALL_ACQUIRE((void*)ioevpp[i].data);
1312   }
1313 }
1314
1315 PRE_SYSCALL(io_submit)(long ctx_id, long nr, __sanitizer_iocb **iocbpp) {
1316   for (long i = 0; i < nr; ++i) {
1317     uptr op = iocbpp[i]->aio_lio_opcode;
1318     void *data = (void*)iocbpp[i]->aio_data;
1319     void *buf = (void*)iocbpp[i]->aio_buf;
1320     uptr len = (uptr)iocbpp[i]->aio_nbytes;
1321     if (op == iocb_cmd_pwrite && buf && len) {
1322       PRE_READ(buf, len);
1323     } else if (op == iocb_cmd_pread && buf && len) {
1324       POST_WRITE(buf, len);
1325     } else if (op == iocb_cmd_pwritev) {
1326       __sanitizer_iovec *iovec = (__sanitizer_iovec*)buf;
1327       for (uptr v = 0; v < len; v++)
1328         PRE_READ(iovec[v].iov_base, iovec[v].iov_len);
1329     } else if (op == iocb_cmd_preadv) {
1330       __sanitizer_iovec *iovec = (__sanitizer_iovec*)buf;
1331       for (uptr v = 0; v < len; v++)
1332         POST_WRITE(iovec[v].iov_base, iovec[v].iov_len);
1333     }
1334     // See comment in io_getevents.
1335     COMMON_SYSCALL_RELEASE(data);
1336   }
1337 }
1338
1339 POST_SYSCALL(io_submit)(long res, long ctx_id, long nr,
1340     __sanitizer_iocb **iocbpp) {}
1341
1342 PRE_SYSCALL(io_cancel)(long ctx_id, __sanitizer_iocb *iocb,
1343     __sanitizer_io_event *result) {
1344 }
1345
1346 POST_SYSCALL(io_cancel)(long res, long ctx_id, __sanitizer_iocb *iocb,
1347     __sanitizer_io_event *result) {
1348   if (res == 0) {
1349     if (result) {
1350       // See comment in io_getevents.
1351       COMMON_SYSCALL_ACQUIRE((void*)result->data);
1352       POST_WRITE(result, sizeof(*result));
1353     }
1354     if (iocb)
1355       POST_WRITE(iocb, sizeof(*iocb));
1356   }
1357 }
1358
1359 PRE_SYSCALL(sendfile)(long out_fd, long in_fd, void *offset, long count) {}
1360
1361 POST_SYSCALL(sendfile)(long res, long out_fd, long in_fd,
1362                        __sanitizer___kernel_off_t *offset, long count) {
1363   if (res >= 0) {
1364     if (offset) POST_WRITE(offset, sizeof(*offset));
1365   }
1366 }
1367
1368 PRE_SYSCALL(sendfile64)(long out_fd, long in_fd, void *offset, long count) {}
1369
1370 POST_SYSCALL(sendfile64)(long res, long out_fd, long in_fd,
1371                          __sanitizer___kernel_loff_t *offset, long count) {
1372   if (res >= 0) {
1373     if (offset) POST_WRITE(offset, sizeof(*offset));
1374   }
1375 }
1376
1377 PRE_SYSCALL(readlink)(const void *path, void *buf, long bufsiz) {
1378   if (path)
1379     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1380 }
1381
1382 POST_SYSCALL(readlink)(long res, const void *path, void *buf, long bufsiz) {
1383   if (res >= 0) {
1384     if (buf)
1385       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1386   }
1387 }
1388
1389 PRE_SYSCALL(creat)(const void *pathname, long mode) {
1390   if (pathname)
1391     PRE_READ(pathname,
1392              __sanitizer::internal_strlen((const char *)pathname) + 1);
1393 }
1394
1395 POST_SYSCALL(creat)(long res, const void *pathname, long mode) {}
1396
1397 PRE_SYSCALL(open)(const void *filename, long flags, long mode) {
1398   if (filename)
1399     PRE_READ(filename,
1400              __sanitizer::internal_strlen((const char *)filename) + 1);
1401 }
1402
1403 POST_SYSCALL(open)(long res, const void *filename, long flags, long mode) {}
1404
1405 PRE_SYSCALL(close)(long fd) {
1406   COMMON_SYSCALL_FD_CLOSE((int)fd);
1407 }
1408
1409 POST_SYSCALL(close)(long res, long fd) {}
1410
1411 PRE_SYSCALL(access)(const void *filename, long mode) {
1412   if (filename)
1413     PRE_READ(filename,
1414              __sanitizer::internal_strlen((const char *)filename) + 1);
1415 }
1416
1417 POST_SYSCALL(access)(long res, const void *filename, long mode) {}
1418
1419 PRE_SYSCALL(vhangup)() {}
1420
1421 POST_SYSCALL(vhangup)(long res) {}
1422
1423 PRE_SYSCALL(chown)(const void *filename, long user, long group) {
1424   if (filename)
1425     PRE_READ(filename,
1426              __sanitizer::internal_strlen((const char *)filename) + 1);
1427 }
1428
1429 POST_SYSCALL(chown)(long res, const void *filename, long user, long group) {}
1430
1431 PRE_SYSCALL(lchown)(const void *filename, long user, long group) {
1432   if (filename)
1433     PRE_READ(filename,
1434              __sanitizer::internal_strlen((const char *)filename) + 1);
1435 }
1436
1437 POST_SYSCALL(lchown)(long res, const void *filename, long user, long group) {}
1438
1439 PRE_SYSCALL(fchown)(long fd, long user, long group) {}
1440
1441 POST_SYSCALL(fchown)(long res, long fd, long user, long group) {}
1442
1443 #if SANITIZER_USES_UID16_SYSCALLS
1444 PRE_SYSCALL(chown16)(const void *filename, long user, long group) {
1445   if (filename)
1446     PRE_READ(filename,
1447              __sanitizer::internal_strlen((const char *)filename) + 1);
1448 }
1449
1450 POST_SYSCALL(chown16)(long res, const void *filename, long user, long group) {}
1451
1452 PRE_SYSCALL(lchown16)(const void *filename, long user, long group) {
1453   if (filename)
1454     PRE_READ(filename,
1455              __sanitizer::internal_strlen((const char *)filename) + 1);
1456 }
1457
1458 POST_SYSCALL(lchown16)(long res, const void *filename, long user, long group) {}
1459
1460 PRE_SYSCALL(fchown16)(long fd, long user, long group) {}
1461
1462 POST_SYSCALL(fchown16)(long res, long fd, long user, long group) {}
1463
1464 PRE_SYSCALL(setregid16)(long rgid, long egid) {}
1465
1466 POST_SYSCALL(setregid16)(long res, long rgid, long egid) {}
1467
1468 PRE_SYSCALL(setgid16)(long gid) {}
1469
1470 POST_SYSCALL(setgid16)(long res, long gid) {}
1471
1472 PRE_SYSCALL(setreuid16)(long ruid, long euid) {}
1473
1474 POST_SYSCALL(setreuid16)(long res, long ruid, long euid) {}
1475
1476 PRE_SYSCALL(setuid16)(long uid) {}
1477
1478 POST_SYSCALL(setuid16)(long res, long uid) {}
1479
1480 PRE_SYSCALL(setresuid16)(long ruid, long euid, long suid) {}
1481
1482 POST_SYSCALL(setresuid16)(long res, long ruid, long euid, long suid) {}
1483
1484 PRE_SYSCALL(getresuid16)(void *ruid, void *euid, void *suid) {}
1485
1486 POST_SYSCALL(getresuid16)(long res, __sanitizer___kernel_old_uid_t *ruid,
1487                           __sanitizer___kernel_old_uid_t *euid,
1488                           __sanitizer___kernel_old_uid_t *suid) {
1489   if (res >= 0) {
1490     if (ruid) POST_WRITE(ruid, sizeof(*ruid));
1491     if (euid) POST_WRITE(euid, sizeof(*euid));
1492     if (suid) POST_WRITE(suid, sizeof(*suid));
1493   }
1494 }
1495
1496 PRE_SYSCALL(setresgid16)(long rgid, long egid, long sgid) {}
1497
1498 POST_SYSCALL(setresgid16)(long res, long rgid, long egid, long sgid) {}
1499
1500 PRE_SYSCALL(getresgid16)(void *rgid, void *egid, void *sgid) {}
1501
1502 POST_SYSCALL(getresgid16)(long res, __sanitizer___kernel_old_gid_t *rgid,
1503                           __sanitizer___kernel_old_gid_t *egid,
1504                           __sanitizer___kernel_old_gid_t *sgid) {
1505   if (res >= 0) {
1506     if (rgid) POST_WRITE(rgid, sizeof(*rgid));
1507     if (egid) POST_WRITE(egid, sizeof(*egid));
1508     if (sgid) POST_WRITE(sgid, sizeof(*sgid));
1509   }
1510 }
1511
1512 PRE_SYSCALL(setfsuid16)(long uid) {}
1513
1514 POST_SYSCALL(setfsuid16)(long res, long uid) {}
1515
1516 PRE_SYSCALL(setfsgid16)(long gid) {}
1517
1518 POST_SYSCALL(setfsgid16)(long res, long gid) {}
1519
1520 PRE_SYSCALL(getgroups16)(long gidsetsize,
1521                          __sanitizer___kernel_old_gid_t *grouplist) {}
1522
1523 POST_SYSCALL(getgroups16)(long res, long gidsetsize,
1524                           __sanitizer___kernel_old_gid_t *grouplist) {
1525   if (res >= 0) {
1526     if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
1527   }
1528 }
1529
1530 PRE_SYSCALL(setgroups16)(long gidsetsize,
1531                          __sanitizer___kernel_old_gid_t *grouplist) {
1532   if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
1533 }
1534
1535 POST_SYSCALL(setgroups16)(long res, long gidsetsize,
1536                           __sanitizer___kernel_old_gid_t *grouplist) {}
1537
1538 PRE_SYSCALL(getuid16)() {}
1539
1540 POST_SYSCALL(getuid16)(long res) {}
1541
1542 PRE_SYSCALL(geteuid16)() {}
1543
1544 POST_SYSCALL(geteuid16)(long res) {}
1545
1546 PRE_SYSCALL(getgid16)() {}
1547
1548 POST_SYSCALL(getgid16)(long res) {}
1549
1550 PRE_SYSCALL(getegid16)() {}
1551
1552 POST_SYSCALL(getegid16)(long res) {}
1553 #endif // SANITIZER_USES_UID16_SYSCALLS
1554
1555 PRE_SYSCALL(utime)(void *filename, void *times) {}
1556
1557 POST_SYSCALL(utime)(long res, void *filename, void *times) {
1558   if (res >= 0) {
1559     if (filename)
1560       POST_WRITE(filename,
1561                  __sanitizer::internal_strlen((const char *)filename) + 1);
1562     if (times) POST_WRITE(times, struct_utimbuf_sz);
1563   }
1564 }
1565
1566 PRE_SYSCALL(utimes)(void *filename, void *utimes) {}
1567
1568 POST_SYSCALL(utimes)(long res, void *filename, void *utimes) {
1569   if (res >= 0) {
1570     if (filename)
1571       POST_WRITE(filename,
1572                  __sanitizer::internal_strlen((const char *)filename) + 1);
1573     if (utimes) POST_WRITE(utimes, timeval_sz);
1574   }
1575 }
1576
1577 PRE_SYSCALL(lseek)(long fd, long offset, long origin) {}
1578
1579 POST_SYSCALL(lseek)(long res, long fd, long offset, long origin) {}
1580
1581 PRE_SYSCALL(llseek)(long fd, long offset_high, long offset_low, void *result,
1582                     long origin) {}
1583
1584 POST_SYSCALL(llseek)(long res, long fd, long offset_high, long offset_low,
1585                      void *result, long origin) {
1586   if (res >= 0) {
1587     if (result) POST_WRITE(result, sizeof(long long));
1588   }
1589 }
1590
1591 PRE_SYSCALL(readv)(long fd, const __sanitizer_iovec *vec, long vlen) {}
1592
1593 POST_SYSCALL(readv)(long res, long fd, const __sanitizer_iovec *vec,
1594                     long vlen) {
1595   if (res >= 0) {
1596     if (vec) kernel_write_iovec(vec, vlen, res);
1597   }
1598 }
1599
1600 PRE_SYSCALL(write)(long fd, const void *buf, long count) {
1601   if (buf) PRE_READ(buf, count);
1602 }
1603
1604 POST_SYSCALL(write)(long res, long fd, const void *buf, long count) {}
1605
1606 PRE_SYSCALL(writev)(long fd, const __sanitizer_iovec *vec, long vlen) {}
1607
1608 POST_SYSCALL(writev)(long res, long fd, const __sanitizer_iovec *vec,
1609                      long vlen) {
1610   if (res >= 0) {
1611     if (vec) kernel_read_iovec(vec, vlen, res);
1612   }
1613 }
1614
1615 #ifdef _LP64
1616 PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos) {}
1617
1618 POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos) {
1619   if (res >= 0) {
1620     if (buf) POST_WRITE(buf, res);
1621   }
1622 }
1623
1624 PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos) {
1625   if (buf) PRE_READ(buf, count);
1626 }
1627
1628 POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
1629                        long pos) {}
1630 #else
1631 PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos0, long pos1) {}
1632
1633 POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos0,
1634                       long pos1) {
1635   if (res >= 0) {
1636     if (buf) POST_WRITE(buf, res);
1637   }
1638 }
1639
1640 PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos0,
1641                       long pos1) {
1642   if (buf) PRE_READ(buf, count);
1643 }
1644
1645 POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
1646                        long pos0, long pos1) {}
1647 #endif
1648
1649 PRE_SYSCALL(preadv)(long fd, const __sanitizer_iovec *vec, long vlen,
1650                     long pos_l, long pos_h) {}
1651
1652 POST_SYSCALL(preadv)(long res, long fd, const __sanitizer_iovec *vec, long vlen,
1653                      long pos_l, long pos_h) {
1654   if (res >= 0) {
1655     if (vec) kernel_write_iovec(vec, vlen, res);
1656   }
1657 }
1658
1659 PRE_SYSCALL(pwritev)(long fd, const __sanitizer_iovec *vec, long vlen,
1660                      long pos_l, long pos_h) {}
1661
1662 POST_SYSCALL(pwritev)(long res, long fd, const __sanitizer_iovec *vec,
1663                       long vlen, long pos_l, long pos_h) {
1664   if (res >= 0) {
1665     if (vec) kernel_read_iovec(vec, vlen, res);
1666   }
1667 }
1668
1669 PRE_SYSCALL(getcwd)(void *buf, long size) {}
1670
1671 POST_SYSCALL(getcwd)(long res, void *buf, long size) {
1672   if (res >= 0) {
1673     if (buf)
1674       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1675   }
1676 }
1677
1678 PRE_SYSCALL(mkdir)(const void *pathname, long mode) {
1679   if (pathname)
1680     PRE_READ(pathname,
1681              __sanitizer::internal_strlen((const char *)pathname) + 1);
1682 }
1683
1684 POST_SYSCALL(mkdir)(long res, const void *pathname, long mode) {}
1685
1686 PRE_SYSCALL(chdir)(const void *filename) {
1687   if (filename)
1688     PRE_READ(filename,
1689              __sanitizer::internal_strlen((const char *)filename) + 1);
1690 }
1691
1692 POST_SYSCALL(chdir)(long res, const void *filename) {}
1693
1694 PRE_SYSCALL(fchdir)(long fd) {}
1695
1696 POST_SYSCALL(fchdir)(long res, long fd) {}
1697
1698 PRE_SYSCALL(rmdir)(const void *pathname) {
1699   if (pathname)
1700     PRE_READ(pathname,
1701              __sanitizer::internal_strlen((const char *)pathname) + 1);
1702 }
1703
1704 POST_SYSCALL(rmdir)(long res, const void *pathname) {}
1705
1706 PRE_SYSCALL(lookup_dcookie)(u64 cookie64, void *buf, long len) {}
1707
1708 POST_SYSCALL(lookup_dcookie)(long res, u64 cookie64, void *buf, long len) {
1709   if (res >= 0) {
1710     if (buf)
1711       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1712   }
1713 }
1714
1715 PRE_SYSCALL(quotactl)(long cmd, const void *special, long id, void *addr) {
1716   if (special)
1717     PRE_READ(special, __sanitizer::internal_strlen((const char *)special) + 1);
1718 }
1719
1720 POST_SYSCALL(quotactl)(long res, long cmd, const void *special, long id,
1721                        void *addr) {}
1722
1723 PRE_SYSCALL(getdents)(long fd, void *dirent, long count) {}
1724
1725 POST_SYSCALL(getdents)(long res, long fd, void *dirent, long count) {
1726   if (res >= 0) {
1727     if (dirent) POST_WRITE(dirent, res);
1728   }
1729 }
1730
1731 PRE_SYSCALL(getdents64)(long fd, void *dirent, long count) {}
1732
1733 POST_SYSCALL(getdents64)(long res, long fd, void *dirent, long count) {
1734   if (res >= 0) {
1735     if (dirent) POST_WRITE(dirent, res);
1736   }
1737 }
1738
1739 PRE_SYSCALL(setsockopt)(long fd, long level, long optname, void *optval,
1740                         long optlen) {}
1741
1742 POST_SYSCALL(setsockopt)(long res, long fd, long level, long optname,
1743                          void *optval, long optlen) {
1744   if (res >= 0) {
1745     if (optval)
1746       POST_WRITE(optval,
1747                  __sanitizer::internal_strlen((const char *)optval) + 1);
1748   }
1749 }
1750
1751 PRE_SYSCALL(getsockopt)(long fd, long level, long optname, void *optval,
1752                         void *optlen) {}
1753
1754 POST_SYSCALL(getsockopt)(long res, long fd, long level, long optname,
1755                          void *optval, void *optlen) {
1756   if (res >= 0) {
1757     if (optval)
1758       POST_WRITE(optval,
1759                  __sanitizer::internal_strlen((const char *)optval) + 1);
1760     if (optlen) POST_WRITE(optlen, sizeof(int));
1761   }
1762 }
1763
1764 PRE_SYSCALL(bind)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
1765
1766 POST_SYSCALL(bind)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1767                    long arg2) {
1768   if (res >= 0) {
1769     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1770   }
1771 }
1772
1773 PRE_SYSCALL(connect)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
1774
1775 POST_SYSCALL(connect)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1776                       long arg2) {
1777   if (res >= 0) {
1778     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1779   }
1780 }
1781
1782 PRE_SYSCALL(accept)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {}
1783
1784 POST_SYSCALL(accept)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1785                      void *arg2) {
1786   if (res >= 0) {
1787     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1788     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1789   }
1790 }
1791
1792 PRE_SYSCALL(accept4)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2,
1793                      long arg3) {}
1794
1795 POST_SYSCALL(accept4)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1796                       void *arg2, long arg3) {
1797   if (res >= 0) {
1798     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1799     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1800   }
1801 }
1802
1803 PRE_SYSCALL(getsockname)(long arg0, sanitizer_kernel_sockaddr *arg1,
1804                          void *arg2) {}
1805
1806 POST_SYSCALL(getsockname)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1807                           void *arg2) {
1808   if (res >= 0) {
1809     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1810     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1811   }
1812 }
1813
1814 PRE_SYSCALL(getpeername)(long arg0, sanitizer_kernel_sockaddr *arg1,
1815                          void *arg2) {}
1816
1817 POST_SYSCALL(getpeername)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1818                           void *arg2) {
1819   if (res >= 0) {
1820     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1821     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1822   }
1823 }
1824
1825 PRE_SYSCALL(send)(long arg0, void *arg1, long arg2, long arg3) {}
1826
1827 POST_SYSCALL(send)(long res, long arg0, void *arg1, long arg2, long arg3) {
1828   if (res) {
1829     if (arg1) POST_READ(arg1, res);
1830   }
1831 }
1832
1833 PRE_SYSCALL(sendto)(long arg0, void *arg1, long arg2, long arg3,
1834                     sanitizer_kernel_sockaddr *arg4, long arg5) {}
1835
1836 POST_SYSCALL(sendto)(long res, long arg0, void *arg1, long arg2, long arg3,
1837                      sanitizer_kernel_sockaddr *arg4, long arg5) {
1838   if (res >= 0) {
1839     if (arg1) POST_READ(arg1, res);
1840     if (arg4) POST_WRITE(arg4, sizeof(*arg4));
1841   }
1842 }
1843
1844 PRE_SYSCALL(sendmsg)(long fd, void *msg, long flags) {}
1845
1846 POST_SYSCALL(sendmsg)(long res, long fd, void *msg, long flags) {
1847   // FIXME: POST_READ
1848 }
1849
1850 PRE_SYSCALL(sendmmsg)(long fd, void *msg, long vlen, long flags) {}
1851
1852 POST_SYSCALL(sendmmsg)(long res, long fd, void *msg, long vlen, long flags) {
1853   // FIXME: POST_READ
1854 }
1855
1856 PRE_SYSCALL(recv)(long arg0, void *buf, long len, long flags) {}
1857
1858 POST_SYSCALL(recv)(long res, void *buf, long len, long flags) {
1859   if (res >= 0) {
1860     if (buf) POST_WRITE(buf, res);
1861   }
1862 }
1863
1864 PRE_SYSCALL(recvfrom)(long arg0, void *buf, long len, long flags,
1865                       sanitizer_kernel_sockaddr *arg4, void *arg5) {}
1866
1867 POST_SYSCALL(recvfrom)(long res, long arg0, void *buf, long len, long flags,
1868                        sanitizer_kernel_sockaddr *arg4, void *arg5) {
1869   if (res >= 0) {
1870     if (buf) POST_WRITE(buf, res);
1871     if (arg4) POST_WRITE(arg4, sizeof(*arg4));
1872     if (arg5) POST_WRITE(arg5, sizeof(int));
1873   }
1874 }
1875
1876 PRE_SYSCALL(socket)(long arg0, long arg1, long arg2) {}
1877
1878 POST_SYSCALL(socket)(long res, long arg0, long arg1, long arg2) {}
1879
1880 PRE_SYSCALL(socketpair)(long arg0, long arg1, long arg2, int *sv) {}
1881
1882 POST_SYSCALL(socketpair)(long res, long arg0, long arg1, long arg2, int *sv) {
1883   if (res >= 0)
1884     if (sv) POST_WRITE(sv, sizeof(int) * 2);
1885 }
1886
1887 PRE_SYSCALL(socketcall)(long call, void *args) {}
1888
1889 POST_SYSCALL(socketcall)(long res, long call, void *args) {
1890   if (res >= 0) {
1891     if (args) POST_WRITE(args, sizeof(long));
1892   }
1893 }
1894
1895 PRE_SYSCALL(listen)(long arg0, long arg1) {}
1896
1897 POST_SYSCALL(listen)(long res, long arg0, long arg1) {}
1898
1899 PRE_SYSCALL(poll)(void *ufds, long nfds, long timeout) {}
1900
1901 POST_SYSCALL(poll)(long res, __sanitizer_pollfd *ufds, long nfds,
1902                    long timeout) {
1903   if (res >= 0) {
1904     if (ufds) POST_WRITE(ufds, nfds * sizeof(*ufds));
1905   }
1906 }
1907
1908 PRE_SYSCALL(select)(long n, __sanitizer___kernel_fd_set *inp,
1909                     __sanitizer___kernel_fd_set *outp,
1910                     __sanitizer___kernel_fd_set *exp, void *tvp) {}
1911
1912 POST_SYSCALL(select)(long res, long n, __sanitizer___kernel_fd_set *inp,
1913                      __sanitizer___kernel_fd_set *outp,
1914                      __sanitizer___kernel_fd_set *exp, void *tvp) {
1915   if (res >= 0) {
1916     if (inp) POST_WRITE(inp, sizeof(*inp));
1917     if (outp) POST_WRITE(outp, sizeof(*outp));
1918     if (exp) POST_WRITE(exp, sizeof(*exp));
1919     if (tvp) POST_WRITE(tvp, timeval_sz);
1920   }
1921 }
1922
1923 PRE_SYSCALL(old_select)(void *arg) {}
1924
1925 POST_SYSCALL(old_select)(long res, void *arg) {}
1926
1927 PRE_SYSCALL(epoll_create)(long size) {}
1928
1929 POST_SYSCALL(epoll_create)(long res, long size) {}
1930
1931 PRE_SYSCALL(epoll_create1)(long flags) {}
1932
1933 POST_SYSCALL(epoll_create1)(long res, long flags) {}
1934
1935 PRE_SYSCALL(epoll_ctl)(long epfd, long op, long fd, void *event) {}
1936
1937 POST_SYSCALL(epoll_ctl)(long res, long epfd, long op, long fd, void *event) {
1938   if (res >= 0) {
1939     if (event) POST_WRITE(event, struct_epoll_event_sz);
1940   }
1941 }
1942
1943 PRE_SYSCALL(epoll_wait)(long epfd, void *events, long maxevents, long timeout) {
1944 }
1945
1946 POST_SYSCALL(epoll_wait)(long res, long epfd, void *events, long maxevents,
1947                          long timeout) {
1948   if (res >= 0) {
1949     if (events) POST_WRITE(events, struct_epoll_event_sz);
1950   }
1951 }
1952
1953 PRE_SYSCALL(epoll_pwait)(long epfd, void *events, long maxevents, long timeout,
1954                          const kernel_sigset_t *sigmask, long sigsetsize) {
1955   if (sigmask) PRE_READ(sigmask, sigsetsize);
1956 }
1957
1958 POST_SYSCALL(epoll_pwait)(long res, long epfd, void *events, long maxevents,
1959                           long timeout, const void *sigmask, long sigsetsize) {
1960   if (res >= 0) {
1961     if (events) POST_WRITE(events, struct_epoll_event_sz);
1962   }
1963 }
1964
1965 PRE_SYSCALL(gethostname)(void *name, long len) {}
1966
1967 POST_SYSCALL(gethostname)(long res, void *name, long len) {
1968   if (res >= 0) {
1969     if (name)
1970       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1971   }
1972 }
1973
1974 PRE_SYSCALL(sethostname)(void *name, long len) {}
1975
1976 POST_SYSCALL(sethostname)(long res, void *name, long len) {
1977   if (res >= 0) {
1978     if (name)
1979       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1980   }
1981 }
1982
1983 PRE_SYSCALL(setdomainname)(void *name, long len) {}
1984
1985 POST_SYSCALL(setdomainname)(long res, void *name, long len) {
1986   if (res >= 0) {
1987     if (name)
1988       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1989   }
1990 }
1991
1992 PRE_SYSCALL(newuname)(void *name) {}
1993
1994 POST_SYSCALL(newuname)(long res, void *name) {
1995   if (res >= 0) {
1996     if (name) POST_WRITE(name, struct_new_utsname_sz);
1997   }
1998 }
1999
2000 PRE_SYSCALL(uname)(void *arg0) {}
2001
2002 POST_SYSCALL(uname)(long res, void *arg0) {
2003   if (res >= 0) {
2004     if (arg0) POST_WRITE(arg0, struct_old_utsname_sz);
2005   }
2006 }
2007
2008 PRE_SYSCALL(olduname)(void *arg0) {}
2009
2010 POST_SYSCALL(olduname)(long res, void *arg0) {
2011   if (res >= 0) {
2012     if (arg0) POST_WRITE(arg0, struct_oldold_utsname_sz);
2013   }
2014 }
2015
2016 PRE_SYSCALL(getrlimit)(long resource, void *rlim) {}
2017
2018 POST_SYSCALL(getrlimit)(long res, long resource, void *rlim) {
2019   if (res >= 0) {
2020     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2021   }
2022 }
2023
2024 PRE_SYSCALL(old_getrlimit)(long resource, void *rlim) {}
2025
2026 POST_SYSCALL(old_getrlimit)(long res, long resource, void *rlim) {
2027   if (res >= 0) {
2028     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2029   }
2030 }
2031
2032 PRE_SYSCALL(setrlimit)(long resource, void *rlim) {}
2033
2034 POST_SYSCALL(setrlimit)(long res, long resource, void *rlim) {
2035   if (res >= 0) {
2036     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2037   }
2038 }
2039
2040 #if !SANITIZER_ANDROID
2041 PRE_SYSCALL(prlimit64)(long pid, long resource, const void *new_rlim,
2042                        void *old_rlim) {
2043   if (new_rlim) PRE_READ(new_rlim, struct_rlimit64_sz);
2044 }
2045
2046 POST_SYSCALL(prlimit64)(long res, long pid, long resource, const void *new_rlim,
2047                         void *old_rlim) {
2048   if (res >= 0) {
2049     if (old_rlim) POST_WRITE(old_rlim, struct_rlimit64_sz);
2050   }
2051 }
2052 #endif
2053
2054 PRE_SYSCALL(getrusage)(long who, void *ru) {}
2055
2056 POST_SYSCALL(getrusage)(long res, long who, void *ru) {
2057   if (res >= 0) {
2058     if (ru) POST_WRITE(ru, struct_rusage_sz);
2059   }
2060 }
2061
2062 PRE_SYSCALL(umask)(long mask) {}
2063
2064 POST_SYSCALL(umask)(long res, long mask) {}
2065
2066 PRE_SYSCALL(msgget)(long key, long msgflg) {}
2067
2068 POST_SYSCALL(msgget)(long res, long key, long msgflg) {}
2069
2070 PRE_SYSCALL(msgsnd)(long msqid, void *msgp, long msgsz, long msgflg) {
2071   if (msgp) PRE_READ(msgp, msgsz);
2072 }
2073
2074 POST_SYSCALL(msgsnd)(long res, long msqid, void *msgp, long msgsz,
2075                      long msgflg) {}
2076
2077 PRE_SYSCALL(msgrcv)(long msqid, void *msgp, long msgsz, long msgtyp,
2078                     long msgflg) {}
2079
2080 POST_SYSCALL(msgrcv)(long res, long msqid, void *msgp, long msgsz, long msgtyp,
2081                      long msgflg) {
2082   if (res >= 0) {
2083     if (msgp) POST_WRITE(msgp, res);
2084   }
2085 }
2086
2087 #if !SANITIZER_ANDROID
2088 PRE_SYSCALL(msgctl)(long msqid, long cmd, void *buf) {}
2089
2090 POST_SYSCALL(msgctl)(long res, long msqid, long cmd, void *buf) {
2091   if (res >= 0) {
2092     if (buf) POST_WRITE(buf, struct_msqid_ds_sz);
2093   }
2094 }
2095 #endif
2096
2097 PRE_SYSCALL(semget)(long key, long nsems, long semflg) {}
2098
2099 POST_SYSCALL(semget)(long res, long key, long nsems, long semflg) {}
2100
2101 PRE_SYSCALL(semop)(long semid, void *sops, long nsops) {}
2102
2103 POST_SYSCALL(semop)(long res, long semid, void *sops, long nsops) {}
2104
2105 PRE_SYSCALL(semctl)(long semid, long semnum, long cmd, void *arg) {}
2106
2107 POST_SYSCALL(semctl)(long res, long semid, long semnum, long cmd, void *arg) {}
2108
2109 PRE_SYSCALL(semtimedop)(long semid, void *sops, long nsops,
2110                         const void *timeout) {
2111   if (timeout) PRE_READ(timeout, struct_timespec_sz);
2112 }
2113
2114 POST_SYSCALL(semtimedop)(long res, long semid, void *sops, long nsops,
2115                          const void *timeout) {}
2116
2117 PRE_SYSCALL(shmat)(long shmid, void *shmaddr, long shmflg) {}
2118
2119 POST_SYSCALL(shmat)(long res, long shmid, void *shmaddr, long shmflg) {
2120   if (res >= 0) {
2121     if (shmaddr)
2122       POST_WRITE(shmaddr,
2123                  __sanitizer::internal_strlen((const char *)shmaddr) + 1);
2124   }
2125 }
2126
2127 PRE_SYSCALL(shmget)(long key, long size, long flag) {}
2128
2129 POST_SYSCALL(shmget)(long res, long key, long size, long flag) {}
2130
2131 PRE_SYSCALL(shmdt)(void *shmaddr) {}
2132
2133 POST_SYSCALL(shmdt)(long res, void *shmaddr) {
2134   if (res >= 0) {
2135     if (shmaddr)
2136       POST_WRITE(shmaddr,
2137                  __sanitizer::internal_strlen((const char *)shmaddr) + 1);
2138   }
2139 }
2140
2141 PRE_SYSCALL(ipc)(long call, long first, long second, long third, void *ptr,
2142                  long fifth) {}
2143
2144 POST_SYSCALL(ipc)(long res, long call, long first, long second, long third,
2145                   void *ptr, long fifth) {}
2146
2147 #if !SANITIZER_ANDROID
2148 PRE_SYSCALL(shmctl)(long shmid, long cmd, void *buf) {}
2149
2150 POST_SYSCALL(shmctl)(long res, long shmid, long cmd, void *buf) {
2151   if (res >= 0) {
2152     if (buf) POST_WRITE(buf, sizeof(__sanitizer_shmid_ds));
2153   }
2154 }
2155
2156 PRE_SYSCALL(mq_open)(const void *name, long oflag, long mode, void *attr) {
2157   if (name)
2158     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2159 }
2160
2161 POST_SYSCALL(mq_open)(long res, const void *name, long oflag, long mode,
2162                       void *attr) {
2163   if (res >= 0) {
2164     if (attr) POST_WRITE(attr, struct_mq_attr_sz);
2165   }
2166 }
2167
2168 PRE_SYSCALL(mq_unlink)(const void *name) {
2169   if (name)
2170     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2171 }
2172
2173 POST_SYSCALL(mq_unlink)(long res, const void *name) {}
2174
2175 PRE_SYSCALL(mq_timedsend)(long mqdes, const void *msg_ptr, long msg_len,
2176                           long msg_prio, const void *abs_timeout) {
2177   if (msg_ptr) PRE_READ(msg_ptr, msg_len);
2178   if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
2179 }
2180
2181 POST_SYSCALL(mq_timedsend)(long res, long mqdes, const void *msg_ptr,
2182                            long msg_len, long msg_prio,
2183                            const void *abs_timeout) {}
2184
2185 PRE_SYSCALL(mq_timedreceive)(long mqdes, void *msg_ptr, long msg_len,
2186                              void *msg_prio, const void *abs_timeout) {
2187   if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
2188 }
2189
2190 POST_SYSCALL(mq_timedreceive)(long res, long mqdes, void *msg_ptr, long msg_len,
2191                               int *msg_prio, const void *abs_timeout) {
2192   if (res >= 0) {
2193     if (msg_ptr) POST_WRITE(msg_ptr, res);
2194     if (msg_prio) POST_WRITE(msg_prio, sizeof(*msg_prio));
2195   }
2196 }
2197
2198 PRE_SYSCALL(mq_notify)(long mqdes, const void *notification) {
2199   if (notification) PRE_READ(notification, struct_sigevent_sz);
2200 }
2201
2202 POST_SYSCALL(mq_notify)(long res, long mqdes, const void *notification) {}
2203
2204 PRE_SYSCALL(mq_getsetattr)(long mqdes, const void *mqstat, void *omqstat) {
2205   if (mqstat) PRE_READ(mqstat, struct_mq_attr_sz);
2206 }
2207
2208 POST_SYSCALL(mq_getsetattr)(long res, long mqdes, const void *mqstat,
2209                             void *omqstat) {
2210   if (res >= 0) {
2211     if (omqstat) POST_WRITE(omqstat, struct_mq_attr_sz);
2212   }
2213 }
2214 #endif  // SANITIZER_ANDROID
2215
2216 PRE_SYSCALL(pciconfig_iobase)(long which, long bus, long devfn) {}
2217
2218 POST_SYSCALL(pciconfig_iobase)(long res, long which, long bus, long devfn) {}
2219
2220 PRE_SYSCALL(pciconfig_read)(long bus, long dfn, long off, long len, void *buf) {
2221 }
2222
2223 POST_SYSCALL(pciconfig_read)(long res, long bus, long dfn, long off, long len,
2224                              void *buf) {}
2225
2226 PRE_SYSCALL(pciconfig_write)(long bus, long dfn, long off, long len,
2227                              void *buf) {}
2228
2229 POST_SYSCALL(pciconfig_write)(long res, long bus, long dfn, long off, long len,
2230                               void *buf) {}
2231
2232 PRE_SYSCALL(swapon)(const void *specialfile, long swap_flags) {
2233   if (specialfile)
2234     PRE_READ(specialfile,
2235              __sanitizer::internal_strlen((const char *)specialfile) + 1);
2236 }
2237
2238 POST_SYSCALL(swapon)(long res, const void *specialfile, long swap_flags) {}
2239
2240 PRE_SYSCALL(swapoff)(const void *specialfile) {
2241   if (specialfile)
2242     PRE_READ(specialfile,
2243              __sanitizer::internal_strlen((const char *)specialfile) + 1);
2244 }
2245
2246 POST_SYSCALL(swapoff)(long res, const void *specialfile) {}
2247
2248 PRE_SYSCALL(sysctl)(__sanitizer___sysctl_args *args) {
2249   if (args) {
2250     if (args->name) PRE_READ(args->name, args->nlen * sizeof(*args->name));
2251     if (args->newval) PRE_READ(args->name, args->newlen);
2252   }
2253 }
2254
2255 POST_SYSCALL(sysctl)(long res, __sanitizer___sysctl_args *args) {
2256   if (res >= 0) {
2257     if (args && args->oldval && args->oldlenp) {
2258       POST_WRITE(args->oldlenp, sizeof(*args->oldlenp));
2259       POST_WRITE(args->oldval, *args->oldlenp);
2260     }
2261   }
2262 }
2263
2264 PRE_SYSCALL(sysinfo)(void *info) {}
2265
2266 POST_SYSCALL(sysinfo)(long res, void *info) {
2267   if (res >= 0) {
2268     if (info) POST_WRITE(info, struct_sysinfo_sz);
2269   }
2270 }
2271
2272 PRE_SYSCALL(sysfs)(long option, long arg1, long arg2) {}
2273
2274 POST_SYSCALL(sysfs)(long res, long option, long arg1, long arg2) {}
2275
2276 PRE_SYSCALL(syslog)(long type, void *buf, long len) {}
2277
2278 POST_SYSCALL(syslog)(long res, long type, void *buf, long len) {
2279   if (res >= 0) {
2280     if (buf)
2281       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
2282   }
2283 }
2284
2285 PRE_SYSCALL(uselib)(const void *library) {
2286   if (library)
2287     PRE_READ(library, __sanitizer::internal_strlen((const char *)library) + 1);
2288 }
2289
2290 POST_SYSCALL(uselib)(long res, const void *library) {}
2291
2292 PRE_SYSCALL(ni_syscall)() {}
2293
2294 POST_SYSCALL(ni_syscall)(long res) {}
2295
2296 PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) {
2297 #if !SANITIZER_ANDROID && \
2298     (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
2299      defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__))
2300   if (data) {
2301     if (request == ptrace_setregs) {
2302       PRE_READ((void *)data, struct_user_regs_struct_sz);
2303     } else if (request == ptrace_setfpregs) {
2304       PRE_READ((void *)data, struct_user_fpregs_struct_sz);
2305     } else if (request == ptrace_setfpxregs) {
2306       PRE_READ((void *)data, struct_user_fpxregs_struct_sz);
2307     } else if (request == ptrace_setsiginfo) {
2308       PRE_READ((void *)data, siginfo_t_sz);
2309     } else if (request == ptrace_setregset) {
2310       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
2311       PRE_READ(iov->iov_base, iov->iov_len);
2312     }
2313   }
2314 #endif
2315 }
2316
2317 POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) {
2318 #if !SANITIZER_ANDROID && \
2319     (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
2320      defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__))
2321   if (res >= 0 && data) {
2322     // Note that this is different from the interceptor in
2323     // sanitizer_common_interceptors.inc.
2324     // PEEK* requests return resulting values through data pointer.
2325     if (request == ptrace_getregs) {
2326       POST_WRITE((void *)data, struct_user_regs_struct_sz);
2327     } else if (request == ptrace_getfpregs) {
2328       POST_WRITE((void *)data, struct_user_fpregs_struct_sz);
2329     } else if (request == ptrace_getfpxregs) {
2330       POST_WRITE((void *)data, struct_user_fpxregs_struct_sz);
2331     } else if (request == ptrace_getsiginfo) {
2332       POST_WRITE((void *)data, siginfo_t_sz);
2333     } else if (request == ptrace_getregset) {
2334       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
2335       POST_WRITE(iov->iov_base, iov->iov_len);
2336     } else if (request == ptrace_peekdata || request == ptrace_peektext ||
2337                request == ptrace_peekuser) {
2338       POST_WRITE((void *)data, sizeof(void *));
2339     }
2340   }
2341 #endif
2342 }
2343
2344 PRE_SYSCALL(add_key)(const void *_type, const void *_description,
2345                      const void *_payload, long plen, long destringid) {
2346   if (_type)
2347     PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
2348   if (_description)
2349     PRE_READ(_description,
2350              __sanitizer::internal_strlen((const char *)_description) + 1);
2351 }
2352
2353 POST_SYSCALL(add_key)(long res, const void *_type, const void *_description,
2354                       const void *_payload, long plen, long destringid) {}
2355
2356 PRE_SYSCALL(request_key)(const void *_type, const void *_description,
2357                          const void *_callout_info, long destringid) {
2358   if (_type)
2359     PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
2360   if (_description)
2361     PRE_READ(_description,
2362              __sanitizer::internal_strlen((const char *)_description) + 1);
2363   if (_callout_info)
2364     PRE_READ(_callout_info,
2365              __sanitizer::internal_strlen((const char *)_callout_info) + 1);
2366 }
2367
2368 POST_SYSCALL(request_key)(long res, const void *_type, const void *_description,
2369                           const void *_callout_info, long destringid) {}
2370
2371 PRE_SYSCALL(keyctl)(long cmd, long arg2, long arg3, long arg4, long arg5) {}
2372
2373 POST_SYSCALL(keyctl)(long res, long cmd, long arg2, long arg3, long arg4,
2374                      long arg5) {}
2375
2376 PRE_SYSCALL(ioprio_set)(long which, long who, long ioprio) {}
2377
2378 POST_SYSCALL(ioprio_set)(long res, long which, long who, long ioprio) {}
2379
2380 PRE_SYSCALL(ioprio_get)(long which, long who) {}
2381
2382 POST_SYSCALL(ioprio_get)(long res, long which, long who) {}
2383
2384 PRE_SYSCALL(set_mempolicy)(long mode, void *nmask, long maxnode) {}
2385
2386 POST_SYSCALL(set_mempolicy)(long res, long mode, void *nmask, long maxnode) {
2387   if (res >= 0) {
2388     if (nmask) POST_WRITE(nmask, sizeof(long));
2389   }
2390 }
2391
2392 PRE_SYSCALL(migrate_pages)(long pid, long maxnode, const void *from,
2393                            const void *to) {
2394   if (from) PRE_READ(from, sizeof(long));
2395   if (to) PRE_READ(to, sizeof(long));
2396 }
2397
2398 POST_SYSCALL(migrate_pages)(long res, long pid, long maxnode, const void *from,
2399                             const void *to) {}
2400
2401 PRE_SYSCALL(move_pages)(long pid, long nr_pages, const void **pages,
2402                         const int *nodes, int *status, long flags) {
2403   if (pages) PRE_READ(pages, nr_pages * sizeof(*pages));
2404   if (nodes) PRE_READ(nodes, nr_pages * sizeof(*nodes));
2405 }
2406
2407 POST_SYSCALL(move_pages)(long res, long pid, long nr_pages, const void **pages,
2408                          const int *nodes, int *status, long flags) {
2409   if (res >= 0) {
2410     if (status) POST_WRITE(status, nr_pages * sizeof(*status));
2411   }
2412 }
2413
2414 PRE_SYSCALL(mbind)(long start, long len, long mode, void *nmask, long maxnode,
2415                    long flags) {}
2416
2417 POST_SYSCALL(mbind)(long res, long start, long len, long mode, void *nmask,
2418                     long maxnode, long flags) {
2419   if (res >= 0) {
2420     if (nmask) POST_WRITE(nmask, sizeof(long));
2421   }
2422 }
2423
2424 PRE_SYSCALL(get_mempolicy)(void *policy, void *nmask, long maxnode, long addr,
2425                            long flags) {}
2426
2427 POST_SYSCALL(get_mempolicy)(long res, void *policy, void *nmask, long maxnode,
2428                             long addr, long flags) {
2429   if (res >= 0) {
2430     if (policy) POST_WRITE(policy, sizeof(int));
2431     if (nmask) POST_WRITE(nmask, sizeof(long));
2432   }
2433 }
2434
2435 PRE_SYSCALL(inotify_init)() {}
2436
2437 POST_SYSCALL(inotify_init)(long res) {}
2438
2439 PRE_SYSCALL(inotify_init1)(long flags) {}
2440
2441 POST_SYSCALL(inotify_init1)(long res, long flags) {}
2442
2443 PRE_SYSCALL(inotify_add_watch)(long fd, const void *path, long mask) {
2444   if (path)
2445     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
2446 }
2447
2448 POST_SYSCALL(inotify_add_watch)(long res, long fd, const void *path,
2449                                 long mask) {}
2450
2451 PRE_SYSCALL(inotify_rm_watch)(long fd, long wd) {}
2452
2453 POST_SYSCALL(inotify_rm_watch)(long res, long fd, long wd) {}
2454
2455 PRE_SYSCALL(spu_run)(long fd, void *unpc, void *ustatus) {}
2456
2457 POST_SYSCALL(spu_run)(long res, long fd, unsigned *unpc, unsigned *ustatus) {
2458   if (res >= 0) {
2459     if (unpc) POST_WRITE(unpc, sizeof(*unpc));
2460     if (ustatus) POST_WRITE(ustatus, sizeof(*ustatus));
2461   }
2462 }
2463
2464 PRE_SYSCALL(spu_create)(const void *name, long flags, long mode, long fd) {
2465   if (name)
2466     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2467 }
2468
2469 POST_SYSCALL(spu_create)(long res, const void *name, long flags, long mode,
2470                          long fd) {}
2471
2472 PRE_SYSCALL(mknodat)(long dfd, const void *filename, long mode, long dev) {
2473   if (filename)
2474     PRE_READ(filename,
2475              __sanitizer::internal_strlen((const char *)filename) + 1);
2476 }
2477
2478 POST_SYSCALL(mknodat)(long res, long dfd, const void *filename, long mode,
2479                       long dev) {}
2480
2481 PRE_SYSCALL(mkdirat)(long dfd, const void *pathname, long mode) {
2482   if (pathname)
2483     PRE_READ(pathname,
2484              __sanitizer::internal_strlen((const char *)pathname) + 1);
2485 }
2486
2487 POST_SYSCALL(mkdirat)(long res, long dfd, const void *pathname, long mode) {}
2488
2489 PRE_SYSCALL(unlinkat)(long dfd, const void *pathname, long flag) {
2490   if (pathname)
2491     PRE_READ(pathname,
2492              __sanitizer::internal_strlen((const char *)pathname) + 1);
2493 }
2494
2495 POST_SYSCALL(unlinkat)(long res, long dfd, const void *pathname, long flag) {}
2496
2497 PRE_SYSCALL(symlinkat)(const void *oldname, long newdfd, const void *newname) {
2498   if (oldname)
2499     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2500   if (newname)
2501     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2502 }
2503
2504 POST_SYSCALL(symlinkat)(long res, const void *oldname, long newdfd,
2505                         const void *newname) {}
2506
2507 PRE_SYSCALL(linkat)(long olddfd, const void *oldname, long newdfd,
2508                     const void *newname, long flags) {
2509   if (oldname)
2510     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2511   if (newname)
2512     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2513 }
2514
2515 POST_SYSCALL(linkat)(long res, long olddfd, const void *oldname, long newdfd,
2516                      const void *newname, long flags) {}
2517
2518 PRE_SYSCALL(renameat)(long olddfd, const void *oldname, long newdfd,
2519                       const void *newname) {
2520   if (oldname)
2521     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2522   if (newname)
2523     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2524 }
2525
2526 POST_SYSCALL(renameat)(long res, long olddfd, const void *oldname, long newdfd,
2527                        const void *newname) {}
2528
2529 PRE_SYSCALL(futimesat)(long dfd, const void *filename, void *utimes) {
2530   if (filename)
2531     PRE_READ(filename,
2532              __sanitizer::internal_strlen((const char *)filename) + 1);
2533 }
2534
2535 POST_SYSCALL(futimesat)(long res, long dfd, const void *filename,
2536                         void *utimes) {
2537   if (res >= 0) {
2538     if (utimes) POST_WRITE(utimes, timeval_sz);
2539   }
2540 }
2541
2542 PRE_SYSCALL(faccessat)(long dfd, const void *filename, long mode) {
2543   if (filename)
2544     PRE_READ(filename,
2545              __sanitizer::internal_strlen((const char *)filename) + 1);
2546 }
2547
2548 POST_SYSCALL(faccessat)(long res, long dfd, const void *filename, long mode) {}
2549
2550 PRE_SYSCALL(fchmodat)(long dfd, const void *filename, long mode) {
2551   if (filename)
2552     PRE_READ(filename,
2553              __sanitizer::internal_strlen((const char *)filename) + 1);
2554 }
2555
2556 POST_SYSCALL(fchmodat)(long res, long dfd, const void *filename, long mode) {}
2557
2558 PRE_SYSCALL(fchownat)(long dfd, const void *filename, long user, long group,
2559                       long flag) {
2560   if (filename)
2561     PRE_READ(filename,
2562              __sanitizer::internal_strlen((const char *)filename) + 1);
2563 }
2564
2565 POST_SYSCALL(fchownat)(long res, long dfd, const void *filename, long user,
2566                        long group, long flag) {}
2567
2568 PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {
2569   if (filename)
2570     PRE_READ(filename,
2571              __sanitizer::internal_strlen((const char *)filename) + 1);
2572 }
2573
2574 POST_SYSCALL(openat)(long res, long dfd, const void *filename, long flags,
2575                      long mode) {}
2576
2577 PRE_SYSCALL(newfstatat)(long dfd, const void *filename, void *statbuf,
2578                         long flag) {
2579   if (filename)
2580     PRE_READ(filename,
2581              __sanitizer::internal_strlen((const char *)filename) + 1);
2582 }
2583
2584 POST_SYSCALL(newfstatat)(long res, long dfd, const void *filename,
2585                          void *statbuf, long flag) {
2586   if (res >= 0) {
2587     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
2588   }
2589 }
2590
2591 PRE_SYSCALL(fstatat64)(long dfd, const void *filename, void *statbuf,
2592                        long flag) {
2593   if (filename)
2594     PRE_READ(filename,
2595              __sanitizer::internal_strlen((const char *)filename) + 1);
2596 }
2597
2598 POST_SYSCALL(fstatat64)(long res, long dfd, const void *filename, void *statbuf,
2599                         long flag) {
2600   if (res >= 0) {
2601     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
2602   }
2603 }
2604
2605 PRE_SYSCALL(readlinkat)(long dfd, const void *path, void *buf, long bufsiz) {
2606   if (path)
2607     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
2608 }
2609
2610 POST_SYSCALL(readlinkat)(long res, long dfd, const void *path, void *buf,
2611                          long bufsiz) {
2612   if (res >= 0) {
2613     if (buf)
2614       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
2615   }
2616 }
2617
2618 PRE_SYSCALL(utimensat)(long dfd, const void *filename, void *utimes,
2619                        long flags) {
2620   if (filename)
2621     PRE_READ(filename,
2622              __sanitizer::internal_strlen((const char *)filename) + 1);
2623 }
2624
2625 POST_SYSCALL(utimensat)(long res, long dfd, const void *filename, void *utimes,
2626                         long flags) {
2627   if (res >= 0) {
2628     if (utimes) POST_WRITE(utimes, struct_timespec_sz);
2629   }
2630 }
2631
2632 PRE_SYSCALL(unshare)(long unshare_flags) {}
2633
2634 POST_SYSCALL(unshare)(long res, long unshare_flags) {}
2635
2636 PRE_SYSCALL(splice)(long fd_in, void *off_in, long fd_out, void *off_out,
2637                     long len, long flags) {}
2638
2639 POST_SYSCALL(splice)(long res, long fd_in, void *off_in, long fd_out,
2640                      void *off_out, long len, long flags) {
2641   if (res >= 0) {
2642     if (off_in) POST_WRITE(off_in, sizeof(long long));
2643     if (off_out) POST_WRITE(off_out, sizeof(long long));
2644   }
2645 }
2646
2647 PRE_SYSCALL(vmsplice)(long fd, const __sanitizer_iovec *iov, long nr_segs,
2648                       long flags) {}
2649
2650 POST_SYSCALL(vmsplice)(long res, long fd, const __sanitizer_iovec *iov,
2651                        long nr_segs, long flags) {
2652   if (res >= 0) {
2653     if (iov) kernel_read_iovec(iov, nr_segs, res);
2654   }
2655 }
2656
2657 PRE_SYSCALL(tee)(long fdin, long fdout, long len, long flags) {}
2658
2659 POST_SYSCALL(tee)(long res, long fdin, long fdout, long len, long flags) {}
2660
2661 PRE_SYSCALL(get_robust_list)(long pid, void *head_ptr, void *len_ptr) {}
2662
2663 POST_SYSCALL(get_robust_list)(long res, long pid, void *head_ptr,
2664                               void *len_ptr) {}
2665
2666 PRE_SYSCALL(set_robust_list)(void *head, long len) {}
2667
2668 POST_SYSCALL(set_robust_list)(long res, void *head, long len) {}
2669
2670 PRE_SYSCALL(getcpu)(void *cpu, void *node, void *cache) {}
2671
2672 POST_SYSCALL(getcpu)(long res, void *cpu, void *node, void *cache) {
2673   if (res >= 0) {
2674     if (cpu) POST_WRITE(cpu, sizeof(unsigned));
2675     if (node) POST_WRITE(node, sizeof(unsigned));
2676     // The third argument to this system call is nowadays unused.
2677   }
2678 }
2679
2680 PRE_SYSCALL(signalfd)(long ufd, void *user_mask, long sizemask) {}
2681
2682 POST_SYSCALL(signalfd)(long res, long ufd, kernel_sigset_t *user_mask,
2683                        long sizemask) {
2684   if (res >= 0) {
2685     if (user_mask) POST_WRITE(user_mask, sizemask);
2686   }
2687 }
2688
2689 PRE_SYSCALL(signalfd4)(long ufd, void *user_mask, long sizemask, long flags) {}
2690
2691 POST_SYSCALL(signalfd4)(long res, long ufd, kernel_sigset_t *user_mask,
2692                         long sizemask, long flags) {
2693   if (res >= 0) {
2694     if (user_mask) POST_WRITE(user_mask, sizemask);
2695   }
2696 }
2697
2698 PRE_SYSCALL(timerfd_create)(long clockid, long flags) {}
2699
2700 POST_SYSCALL(timerfd_create)(long res, long clockid, long flags) {}
2701
2702 PRE_SYSCALL(timerfd_settime)(long ufd, long flags, const void *utmr,
2703                              void *otmr) {
2704   if (utmr) PRE_READ(utmr, struct_itimerspec_sz);
2705 }
2706
2707 POST_SYSCALL(timerfd_settime)(long res, long ufd, long flags, const void *utmr,
2708                               void *otmr) {
2709   if (res >= 0) {
2710     if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
2711   }
2712 }
2713
2714 PRE_SYSCALL(timerfd_gettime)(long ufd, void *otmr) {}
2715
2716 POST_SYSCALL(timerfd_gettime)(long res, long ufd, void *otmr) {
2717   if (res >= 0) {
2718     if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
2719   }
2720 }
2721
2722 PRE_SYSCALL(eventfd)(long count) {}
2723
2724 POST_SYSCALL(eventfd)(long res, long count) {}
2725
2726 PRE_SYSCALL(eventfd2)(long count, long flags) {}
2727
2728 POST_SYSCALL(eventfd2)(long res, long count, long flags) {}
2729
2730 PRE_SYSCALL(old_readdir)(long arg0, void *arg1, long arg2) {}
2731
2732 POST_SYSCALL(old_readdir)(long res, long arg0, void *arg1, long arg2) {
2733   // Missing definition of 'struct old_linux_dirent'.
2734 }
2735
2736 PRE_SYSCALL(pselect6)(long arg0, __sanitizer___kernel_fd_set *arg1,
2737                       __sanitizer___kernel_fd_set *arg2,
2738                       __sanitizer___kernel_fd_set *arg3, void *arg4,
2739                       void *arg5) {}
2740
2741 POST_SYSCALL(pselect6)(long res, long arg0, __sanitizer___kernel_fd_set *arg1,
2742                        __sanitizer___kernel_fd_set *arg2,
2743                        __sanitizer___kernel_fd_set *arg3, void *arg4,
2744                        void *arg5) {
2745   if (res >= 0) {
2746     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
2747     if (arg2) POST_WRITE(arg2, sizeof(*arg2));
2748     if (arg3) POST_WRITE(arg3, sizeof(*arg3));
2749     if (arg4) POST_WRITE(arg4, struct_timespec_sz);
2750   }
2751 }
2752
2753 PRE_SYSCALL(ppoll)(__sanitizer_pollfd *arg0, long arg1, void *arg2,
2754                    const kernel_sigset_t *arg3, long arg4) {
2755   if (arg3) PRE_READ(arg3, arg4);
2756 }
2757
2758 POST_SYSCALL(ppoll)(long res, __sanitizer_pollfd *arg0, long arg1, void *arg2,
2759                     const void *arg3, long arg4) {
2760   if (res >= 0) {
2761     if (arg0) POST_WRITE(arg0, sizeof(*arg0));
2762     if (arg2) POST_WRITE(arg2, struct_timespec_sz);
2763   }
2764 }
2765
2766 PRE_SYSCALL(syncfs)(long fd) {}
2767
2768 POST_SYSCALL(syncfs)(long res, long fd) {}
2769
2770 PRE_SYSCALL(perf_event_open)(__sanitizer_perf_event_attr *attr_uptr, long pid,
2771                              long cpu, long group_fd, long flags) {
2772   if (attr_uptr) PRE_READ(attr_uptr, attr_uptr->size);
2773 }
2774
2775 POST_SYSCALL(perf_event_open)(long res, __sanitizer_perf_event_attr *attr_uptr,
2776                               long pid, long cpu, long group_fd, long flags) {}
2777
2778 PRE_SYSCALL(mmap_pgoff)(long addr, long len, long prot, long flags, long fd,
2779                         long pgoff) {}
2780
2781 POST_SYSCALL(mmap_pgoff)(long res, long addr, long len, long prot, long flags,
2782                          long fd, long pgoff) {}
2783
2784 PRE_SYSCALL(old_mmap)(void *arg) {}
2785
2786 POST_SYSCALL(old_mmap)(long res, void *arg) {}
2787
2788 PRE_SYSCALL(name_to_handle_at)(long dfd, const void *name, void *handle,
2789                                void *mnt_id, long flag) {}
2790
2791 POST_SYSCALL(name_to_handle_at)(long res, long dfd, const void *name,
2792                                 void *handle, void *mnt_id, long flag) {}
2793
2794 PRE_SYSCALL(open_by_handle_at)(long mountdirfd, void *handle, long flags) {}
2795
2796 POST_SYSCALL(open_by_handle_at)(long res, long mountdirfd, void *handle,
2797                                 long flags) {}
2798
2799 PRE_SYSCALL(setns)(long fd, long nstype) {}
2800
2801 POST_SYSCALL(setns)(long res, long fd, long nstype) {}
2802
2803 PRE_SYSCALL(process_vm_readv)(long pid, const __sanitizer_iovec *lvec,
2804                               long liovcnt, const void *rvec, long riovcnt,
2805                               long flags) {}
2806
2807 POST_SYSCALL(process_vm_readv)(long res, long pid,
2808                                const __sanitizer_iovec *lvec, long liovcnt,
2809                                const void *rvec, long riovcnt, long flags) {
2810   if (res >= 0) {
2811     if (lvec) kernel_write_iovec(lvec, liovcnt, res);
2812   }
2813 }
2814
2815 PRE_SYSCALL(process_vm_writev)(long pid, const __sanitizer_iovec *lvec,
2816                                long liovcnt, const void *rvec, long riovcnt,
2817                                long flags) {}
2818
2819 POST_SYSCALL(process_vm_writev)(long res, long pid,
2820                                 const __sanitizer_iovec *lvec, long liovcnt,
2821                                 const void *rvec, long riovcnt, long flags) {
2822   if (res >= 0) {
2823     if (lvec) kernel_read_iovec(lvec, liovcnt, res);
2824   }
2825 }
2826
2827 PRE_SYSCALL(fork)() {
2828   COMMON_SYSCALL_PRE_FORK();
2829 }
2830
2831 POST_SYSCALL(fork)(long res) {
2832   COMMON_SYSCALL_POST_FORK(res);
2833 }
2834
2835 PRE_SYSCALL(vfork)() {
2836   COMMON_SYSCALL_PRE_FORK();
2837 }
2838
2839 POST_SYSCALL(vfork)(long res) {
2840   COMMON_SYSCALL_POST_FORK(res);
2841 }
2842
2843 PRE_SYSCALL(sigaction)(long signum, const __sanitizer_kernel_sigaction_t *act,
2844                        __sanitizer_kernel_sigaction_t *oldact) {
2845   if (act) {
2846     PRE_READ(&act->sigaction, sizeof(act->sigaction));
2847     PRE_READ(&act->sa_flags, sizeof(act->sa_flags));
2848     PRE_READ(&act->sa_mask, sizeof(act->sa_mask));
2849   }
2850 }
2851
2852 POST_SYSCALL(sigaction)(long res, long signum,
2853                         const __sanitizer_kernel_sigaction_t *act,
2854                         __sanitizer_kernel_sigaction_t *oldact) {
2855   if (res >= 0 && oldact) POST_WRITE(oldact, sizeof(*oldact));
2856 }
2857
2858 PRE_SYSCALL(rt_sigaction)(long signum,
2859                           const __sanitizer_kernel_sigaction_t *act,
2860                           __sanitizer_kernel_sigaction_t *oldact, SIZE_T sz) {
2861   if (act) {
2862     PRE_READ(&act->sigaction, sizeof(act->sigaction));
2863     PRE_READ(&act->sa_flags, sizeof(act->sa_flags));
2864     PRE_READ(&act->sa_mask, sz);
2865   }
2866 }
2867
2868 POST_SYSCALL(rt_sigaction)(long res, long signum,
2869                            const __sanitizer_kernel_sigaction_t *act,
2870                            __sanitizer_kernel_sigaction_t *oldact, SIZE_T sz) {
2871   if (res >= 0 && oldact) {
2872     SIZE_T oldact_sz = ((char *)&oldact->sa_mask) - ((char *)oldact) + sz;
2873     POST_WRITE(oldact, oldact_sz);
2874   }
2875 }
2876 }  // extern "C"
2877
2878 #undef PRE_SYSCALL
2879 #undef PRE_READ
2880 #undef PRE_WRITE
2881 #undef POST_SYSCALL
2882 #undef POST_READ
2883 #undef POST_WRITE
2884
2885 #endif  // SANITIZER_LINUX