brintos / llvm-project-archived public Read only

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