* include/bits/allocator.h (operator==, operator!=): Add exception
[official-gcc.git] / libsanitizer / sanitizer_common / sanitizer_common_syscalls.inc
blob75f7d1d1e89da65dbe5331ef07b58397242901ae
1 //===-- sanitizer_common_syscalls.inc ---------------------------*- C++ -*-===//
2 //
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
5 //
6 //===----------------------------------------------------------------------===//
7 //
8 // Common syscalls handlers for tools like AddressSanitizer,
9 // ThreadSanitizer, MemorySanitizer, etc.
11 // This file should be included into the tool's interceptor file,
12 // which has to define it's own macros:
13 //   COMMON_SYSCALL_PRE_READ_RANGE
14 //          Called in prehook for regions that will be read by the kernel and
15 //          must be initialized.
16 //   COMMON_SYSCALL_PRE_WRITE_RANGE
17 //          Called in prehook for regions that will be written to by the kernel
18 //          and must be addressable. The actual write range may be smaller than
19 //          reported in the prehook. See POST_WRITE_RANGE.
20 //   COMMON_SYSCALL_POST_READ_RANGE
21 //          Called in posthook for regions that were read by the kernel. Does
22 //          not make much sense.
23 //   COMMON_SYSCALL_POST_WRITE_RANGE
24 //          Called in posthook for regions that were written to by the kernel
25 //          and are now initialized.
26 //   COMMON_SYSCALL_ACQUIRE(addr)
27 //          Acquire memory visibility from addr.
28 //   COMMON_SYSCALL_RELEASE(addr)
29 //          Release memory visibility to addr.
30 //   COMMON_SYSCALL_FD_CLOSE(fd)
31 //          Called before closing file descriptor fd.
32 //   COMMON_SYSCALL_FD_ACQUIRE(fd)
33 //          Acquire memory visibility from fd.
34 //   COMMON_SYSCALL_FD_RELEASE(fd)
35 //          Release memory visibility to fd.
36 //   COMMON_SYSCALL_PRE_FORK()
37 //          Called before fork syscall.
38 //   COMMON_SYSCALL_POST_FORK(long res)
39 //          Called after fork syscall.
40 //===----------------------------------------------------------------------===//
42 #include "sanitizer_platform.h"
43 #if SANITIZER_LINUX
45 #include "sanitizer_libc.h"
47 #define PRE_SYSCALL(name)                                                      \
48   SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_pre_impl_##name
49 #define PRE_READ(p, s) COMMON_SYSCALL_PRE_READ_RANGE(p, s)
50 #define PRE_WRITE(p, s) COMMON_SYSCALL_PRE_WRITE_RANGE(p, s)
52 #define POST_SYSCALL(name)                                                     \
53   SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_post_impl_##name
54 #define POST_READ(p, s) COMMON_SYSCALL_POST_READ_RANGE(p, s)
55 #define POST_WRITE(p, s) COMMON_SYSCALL_POST_WRITE_RANGE(p, s)
57 #ifndef COMMON_SYSCALL_ACQUIRE
58 # define COMMON_SYSCALL_ACQUIRE(addr) ((void)(addr))
59 #endif
61 #ifndef COMMON_SYSCALL_RELEASE
62 # define COMMON_SYSCALL_RELEASE(addr) ((void)(addr))
63 #endif
65 #ifndef COMMON_SYSCALL_FD_CLOSE
66 # define COMMON_SYSCALL_FD_CLOSE(fd) ((void)(fd))
67 #endif
69 #ifndef COMMON_SYSCALL_FD_ACQUIRE
70 # define COMMON_SYSCALL_FD_ACQUIRE(fd) ((void)(fd))
71 #endif
73 #ifndef COMMON_SYSCALL_FD_RELEASE
74 # define COMMON_SYSCALL_FD_RELEASE(fd) ((void)(fd))
75 #endif
77 #ifndef COMMON_SYSCALL_PRE_FORK
78 # define COMMON_SYSCALL_PRE_FORK() {}
79 #endif
81 #ifndef COMMON_SYSCALL_POST_FORK
82 # define COMMON_SYSCALL_POST_FORK(res) {}
83 #endif
85 // FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such).
87 extern "C" {
88 struct sanitizer_kernel_iovec {
89   void *iov_base;
90   unsigned long iov_len;
93 struct sanitizer_kernel_msghdr {
94   void *msg_name;
95   int msg_namelen;
96   struct sanitizer_kernel_iovec *msg_iov;
97   unsigned long msg_iovlen;
98   void *msg_control;
99   unsigned long msg_controllen;
100   unsigned msg_flags;
103 struct sanitizer_kernel_mmsghdr {
104   struct sanitizer_kernel_msghdr msg_hdr;
105   unsigned msg_len;
108 struct sanitizer_kernel_timespec {
109   long tv_sec;
110   long tv_nsec;
113 struct sanitizer_kernel_timeval {
114   long tv_sec;
115   long tv_usec;
118 struct sanitizer_kernel_rusage {
119   struct sanitizer_kernel_timeval ru_timeval[2];
120   long ru_long[14];
123 struct sanitizer_kernel_sockaddr {
124   unsigned short sa_family;
125   char sa_data[14];
128 // Real sigset size is always passed as a syscall argument.
129 // Declare it "void" to catch sizeof(kernel_sigset_t).
130 typedef void kernel_sigset_t;
132 static void kernel_write_iovec(const __sanitizer_iovec *iovec,
133                         SIZE_T iovlen, SIZE_T maxlen) {
134   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
135     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
136     POST_WRITE(iovec[i].iov_base, sz);
137     maxlen -= sz;
138   }
141 // This functions uses POST_READ, because it needs to run after syscall to know
142 // the real read range.
143 static void kernel_read_iovec(const __sanitizer_iovec *iovec,
144                        SIZE_T iovlen, SIZE_T maxlen) {
145   POST_READ(iovec, sizeof(*iovec) * iovlen);
146   for (SIZE_T i = 0; i < iovlen && maxlen; ++i) {
147     SSIZE_T sz = Min(iovec[i].iov_len, maxlen);
148     POST_READ(iovec[i].iov_base, sz);
149     maxlen -= sz;
150   }
153 PRE_SYSCALL(recvmsg)(long sockfd, sanitizer_kernel_msghdr *msg, long flags) {
154   PRE_READ(msg, sizeof(*msg));
157 POST_SYSCALL(recvmsg)(long res, long sockfd, sanitizer_kernel_msghdr *msg,
158                       long flags) {
159   if (res >= 0) {
160     if (msg) {
161       for (unsigned long i = 0; i < msg->msg_iovlen; ++i) {
162         POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
163       }
164       POST_WRITE(msg->msg_control, msg->msg_controllen);
165     }
166   }
169 PRE_SYSCALL(recvmmsg)(long fd, sanitizer_kernel_mmsghdr *msg, long vlen,
170                       long flags, void *timeout) {
171   PRE_READ(msg, vlen * sizeof(*msg));
174 POST_SYSCALL(recvmmsg)(long res, long fd, sanitizer_kernel_mmsghdr *msg,
175                        long vlen, long flags, void *timeout) {
176   if (res >= 0) {
177     if (msg) {
178       for (unsigned long i = 0; i < msg->msg_hdr.msg_iovlen; ++i) {
179         POST_WRITE(msg->msg_hdr.msg_iov[i].iov_base,
180                    msg->msg_hdr.msg_iov[i].iov_len);
181       }
182       POST_WRITE(msg->msg_hdr.msg_control, msg->msg_hdr.msg_controllen);
183       POST_WRITE(&msg->msg_len, sizeof(msg->msg_len));
184     }
185     if (timeout) POST_WRITE(timeout, struct_timespec_sz);
186   }
189 PRE_SYSCALL(read)(long fd, void *buf, uptr count) {
190   if (buf) {
191     PRE_WRITE(buf, count);
192   }
195 POST_SYSCALL(read)(long res, long fd, void *buf, uptr count) {
196   if (res > 0 && buf) {
197     POST_WRITE(buf, res);
198   }
201 PRE_SYSCALL(time)(void *tloc) {}
203 POST_SYSCALL(time)(long res, void *tloc) {
204   if (res >= 0) {
205     if (tloc) POST_WRITE(tloc, sizeof(long));
206   }
209 PRE_SYSCALL(stime)(void *tptr) {}
211 POST_SYSCALL(stime)(long res, void *tptr) {
212   if (res >= 0) {
213     if (tptr) POST_WRITE(tptr, sizeof(long));
214   }
217 PRE_SYSCALL(gettimeofday)(void *tv, void *tz) {}
219 POST_SYSCALL(gettimeofday)(long res, void *tv, void *tz) {
220   if (res >= 0) {
221     if (tv) POST_WRITE(tv, timeval_sz);
222     if (tz) POST_WRITE(tz, struct_timezone_sz);
223   }
226 PRE_SYSCALL(settimeofday)(void *tv, void *tz) {}
228 POST_SYSCALL(settimeofday)(long res, void *tv, void *tz) {
229   if (res >= 0) {
230     if (tv) POST_WRITE(tv, timeval_sz);
231     if (tz) POST_WRITE(tz, struct_timezone_sz);
232   }
235 PRE_SYSCALL(adjtimex)(void *txc_p) {}
237 POST_SYSCALL(adjtimex)(long res, void *txc_p) {
238   if (res >= 0) {
239     if (txc_p) POST_WRITE(txc_p, struct_timex_sz);
240   }
243 PRE_SYSCALL(times)(void *tbuf) {}
245 POST_SYSCALL(times)(long res, void *tbuf) {
246   if (res >= 0) {
247     if (tbuf) POST_WRITE(tbuf, struct_tms_sz);
248   }
251 PRE_SYSCALL(gettid)() {}
253 POST_SYSCALL(gettid)(long res) {}
255 PRE_SYSCALL(nanosleep)(void *rqtp, void *rmtp) {}
257 POST_SYSCALL(nanosleep)(long res, void *rqtp, void *rmtp) {
258   if (res >= 0) {
259     if (rqtp) POST_WRITE(rqtp, struct_timespec_sz);
260     if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
261   }
264 PRE_SYSCALL(alarm)(long seconds) {}
266 POST_SYSCALL(alarm)(long res, long seconds) {}
268 PRE_SYSCALL(getpid)() {}
270 POST_SYSCALL(getpid)(long res) {}
272 PRE_SYSCALL(getppid)() {}
274 POST_SYSCALL(getppid)(long res) {}
276 PRE_SYSCALL(getuid)() {}
278 POST_SYSCALL(getuid)(long res) {}
280 PRE_SYSCALL(geteuid)() {}
282 POST_SYSCALL(geteuid)(long res) {}
284 PRE_SYSCALL(getgid)() {}
286 POST_SYSCALL(getgid)(long res) {}
288 PRE_SYSCALL(getegid)() {}
290 POST_SYSCALL(getegid)(long res) {}
292 PRE_SYSCALL(getresuid)(void *ruid, void *euid, void *suid) {}
294 POST_SYSCALL(getresuid)(long res, void *ruid, void *euid, void *suid) {
295   if (res >= 0) {
296     if (ruid) POST_WRITE(ruid, sizeof(unsigned));
297     if (euid) POST_WRITE(euid, sizeof(unsigned));
298     if (suid) POST_WRITE(suid, sizeof(unsigned));
299   }
302 PRE_SYSCALL(getresgid)(void *rgid, void *egid, void *sgid) {}
304 POST_SYSCALL(getresgid)(long res, void *rgid, void *egid, void *sgid) {
305   if (res >= 0) {
306     if (rgid) POST_WRITE(rgid, sizeof(unsigned));
307     if (egid) POST_WRITE(egid, sizeof(unsigned));
308     if (sgid) POST_WRITE(sgid, sizeof(unsigned));
309   }
312 PRE_SYSCALL(getpgid)(long pid) {}
314 POST_SYSCALL(getpgid)(long res, long pid) {}
316 PRE_SYSCALL(getpgrp)() {}
318 POST_SYSCALL(getpgrp)(long res) {}
320 PRE_SYSCALL(getsid)(long pid) {}
322 POST_SYSCALL(getsid)(long res, long pid) {}
324 PRE_SYSCALL(getgroups)(long gidsetsize, void *grouplist) {}
326 POST_SYSCALL(getgroups)(long res, long gidsetsize,
327                         __sanitizer___kernel_gid_t *grouplist) {
328   if (res >= 0) {
329     if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
330   }
333 PRE_SYSCALL(setregid)(long rgid, long egid) {}
335 POST_SYSCALL(setregid)(long res, long rgid, long egid) {}
337 PRE_SYSCALL(setgid)(long gid) {}
339 POST_SYSCALL(setgid)(long res, long gid) {}
341 PRE_SYSCALL(setreuid)(long ruid, long euid) {}
343 POST_SYSCALL(setreuid)(long res, long ruid, long euid) {}
345 PRE_SYSCALL(setuid)(long uid) {}
347 POST_SYSCALL(setuid)(long res, long uid) {}
349 PRE_SYSCALL(setresuid)(long ruid, long euid, long suid) {}
351 POST_SYSCALL(setresuid)(long res, long ruid, long euid, long suid) {}
353 PRE_SYSCALL(setresgid)(long rgid, long egid, long sgid) {}
355 POST_SYSCALL(setresgid)(long res, long rgid, long egid, long sgid) {}
357 PRE_SYSCALL(setfsuid)(long uid) {}
359 POST_SYSCALL(setfsuid)(long res, long uid) {}
361 PRE_SYSCALL(setfsgid)(long gid) {}
363 POST_SYSCALL(setfsgid)(long res, long gid) {}
365 PRE_SYSCALL(setpgid)(long pid, long pgid) {}
367 POST_SYSCALL(setpgid)(long res, long pid, long pgid) {}
369 PRE_SYSCALL(setsid)() {}
371 POST_SYSCALL(setsid)(long res) {}
373 PRE_SYSCALL(setgroups)(long gidsetsize, __sanitizer___kernel_gid_t *grouplist) {
374   if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
377 POST_SYSCALL(setgroups)(long res, long gidsetsize,
378                         __sanitizer___kernel_gid_t *grouplist) {}
380 PRE_SYSCALL(acct)(const void *name) {
381   if (name)
382     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
385 POST_SYSCALL(acct)(long res, const void *name) {}
387 PRE_SYSCALL(capget)(void *header, void *dataptr) {}
389 POST_SYSCALL(capget)(long res, void *header, void *dataptr) {
390   if (res >= 0) {
391     if (header) POST_WRITE(header, __user_cap_header_struct_sz);
392     if (dataptr) POST_WRITE(dataptr, __user_cap_data_struct_sz);
393   }
396 PRE_SYSCALL(capset)(void *header, const void *data) {
397   if (data) PRE_READ(data, __user_cap_data_struct_sz);
400 POST_SYSCALL(capset)(long res, void *header, const void *data) {
401   if (res >= 0) {
402     if (header) POST_WRITE(header, __user_cap_header_struct_sz);
403   }
406 PRE_SYSCALL(personality)(long personality) {}
408 POST_SYSCALL(personality)(long res, long personality) {}
410 PRE_SYSCALL(sigpending)(void *set) {}
412 POST_SYSCALL(sigpending)(long res, void *set) {
413   if (res >= 0) {
414     if (set) POST_WRITE(set, old_sigset_t_sz);
415   }
418 PRE_SYSCALL(sigprocmask)(long how, void *set, void *oset) {}
420 POST_SYSCALL(sigprocmask)(long res, long how, void *set, void *oset) {
421   if (res >= 0) {
422     if (set) POST_WRITE(set, old_sigset_t_sz);
423     if (oset) POST_WRITE(oset, old_sigset_t_sz);
424   }
427 PRE_SYSCALL(getitimer)(long which, void *value) {}
429 POST_SYSCALL(getitimer)(long res, long which, void *value) {
430   if (res >= 0) {
431     if (value) POST_WRITE(value, struct_itimerval_sz);
432   }
435 PRE_SYSCALL(setitimer)(long which, void *value, void *ovalue) {}
437 POST_SYSCALL(setitimer)(long res, long which, void *value, void *ovalue) {
438   if (res >= 0) {
439     if (value) POST_WRITE(value, struct_itimerval_sz);
440     if (ovalue) POST_WRITE(ovalue, struct_itimerval_sz);
441   }
444 PRE_SYSCALL(timer_create)(long which_clock, void *timer_event_spec,
445                           void *created_timer_id) {}
447 POST_SYSCALL(timer_create)(long res, long which_clock, void *timer_event_spec,
448                            void *created_timer_id) {
449   if (res >= 0) {
450     if (timer_event_spec) POST_WRITE(timer_event_spec, struct_sigevent_sz);
451     if (created_timer_id) POST_WRITE(created_timer_id, sizeof(long));
452   }
455 PRE_SYSCALL(timer_gettime)(long timer_id, void *setting) {}
457 POST_SYSCALL(timer_gettime)(long res, long timer_id, void *setting) {
458   if (res >= 0) {
459     if (setting) POST_WRITE(setting, struct_itimerspec_sz);
460   }
463 PRE_SYSCALL(timer_getoverrun)(long timer_id) {}
465 POST_SYSCALL(timer_getoverrun)(long res, long timer_id) {}
467 PRE_SYSCALL(timer_settime)(long timer_id, long flags, const void *new_setting,
468                            void *old_setting) {
469   if (new_setting) PRE_READ(new_setting, struct_itimerspec_sz);
472 POST_SYSCALL(timer_settime)(long res, long timer_id, long flags,
473                             const void *new_setting, void *old_setting) {
474   if (res >= 0) {
475     if (old_setting) POST_WRITE(old_setting, struct_itimerspec_sz);
476   }
479 PRE_SYSCALL(timer_delete)(long timer_id) {}
481 POST_SYSCALL(timer_delete)(long res, long timer_id) {}
483 PRE_SYSCALL(clock_settime)(long which_clock, const void *tp) {
484   if (tp) PRE_READ(tp, struct_timespec_sz);
487 POST_SYSCALL(clock_settime)(long res, long which_clock, const void *tp) {}
489 PRE_SYSCALL(clock_gettime)(long which_clock, void *tp) {}
491 POST_SYSCALL(clock_gettime)(long res, long which_clock, void *tp) {
492   if (res >= 0) {
493     if (tp) POST_WRITE(tp, struct_timespec_sz);
494   }
497 PRE_SYSCALL(clock_adjtime)(long which_clock, void *tx) {}
499 POST_SYSCALL(clock_adjtime)(long res, long which_clock, void *tx) {
500   if (res >= 0) {
501     if (tx) POST_WRITE(tx, struct_timex_sz);
502   }
505 PRE_SYSCALL(clock_getres)(long which_clock, void *tp) {}
507 POST_SYSCALL(clock_getres)(long res, long which_clock, void *tp) {
508   if (res >= 0) {
509     if (tp) POST_WRITE(tp, struct_timespec_sz);
510   }
513 PRE_SYSCALL(clock_nanosleep)(long which_clock, long flags, const void *rqtp,
514                              void *rmtp) {
515   if (rqtp) PRE_READ(rqtp, struct_timespec_sz);
518 POST_SYSCALL(clock_nanosleep)(long res, long which_clock, long flags,
519                               const void *rqtp, void *rmtp) {
520   if (res >= 0) {
521     if (rmtp) POST_WRITE(rmtp, struct_timespec_sz);
522   }
525 PRE_SYSCALL(nice)(long increment) {}
527 POST_SYSCALL(nice)(long res, long increment) {}
529 PRE_SYSCALL(sched_setscheduler)(long pid, long policy, void *param) {}
531 POST_SYSCALL(sched_setscheduler)(long res, long pid, long policy, void *param) {
532   if (res >= 0) {
533     if (param) POST_WRITE(param, struct_sched_param_sz);
534   }
537 PRE_SYSCALL(sched_setparam)(long pid, void *param) {
538   if (param) PRE_READ(param, struct_sched_param_sz);
541 POST_SYSCALL(sched_setparam)(long res, long pid, void *param) {}
543 PRE_SYSCALL(sched_getscheduler)(long pid) {}
545 POST_SYSCALL(sched_getscheduler)(long res, long pid) {}
547 PRE_SYSCALL(sched_getparam)(long pid, void *param) {}
549 POST_SYSCALL(sched_getparam)(long res, long pid, void *param) {
550   if (res >= 0) {
551     if (param) POST_WRITE(param, struct_sched_param_sz);
552   }
555 PRE_SYSCALL(sched_setaffinity)(long pid, long len, void *user_mask_ptr) {
556   if (user_mask_ptr) PRE_READ(user_mask_ptr, len);
559 POST_SYSCALL(sched_setaffinity)(long res, long pid, long len,
560                                 void *user_mask_ptr) {}
562 PRE_SYSCALL(sched_getaffinity)(long pid, long len, void *user_mask_ptr) {}
564 POST_SYSCALL(sched_getaffinity)(long res, long pid, long len,
565                                 void *user_mask_ptr) {
566   if (res >= 0) {
567     if (user_mask_ptr) POST_WRITE(user_mask_ptr, len);
568   }
571 PRE_SYSCALL(sched_yield)() {}
573 POST_SYSCALL(sched_yield)(long res) {}
575 PRE_SYSCALL(sched_get_priority_max)(long policy) {}
577 POST_SYSCALL(sched_get_priority_max)(long res, long policy) {}
579 PRE_SYSCALL(sched_get_priority_min)(long policy) {}
581 POST_SYSCALL(sched_get_priority_min)(long res, long policy) {}
583 PRE_SYSCALL(sched_rr_get_interval)(long pid, void *interval) {}
585 POST_SYSCALL(sched_rr_get_interval)(long res, long pid, void *interval) {
586   if (res >= 0) {
587     if (interval) POST_WRITE(interval, struct_timespec_sz);
588   }
591 PRE_SYSCALL(setpriority)(long which, long who, long niceval) {}
593 POST_SYSCALL(setpriority)(long res, long which, long who, long niceval) {}
595 PRE_SYSCALL(getpriority)(long which, long who) {}
597 POST_SYSCALL(getpriority)(long res, long which, long who) {}
599 PRE_SYSCALL(shutdown)(long arg0, long arg1) {}
601 POST_SYSCALL(shutdown)(long res, long arg0, long arg1) {}
603 PRE_SYSCALL(reboot)(long magic1, long magic2, long cmd, void *arg) {}
605 POST_SYSCALL(reboot)(long res, long magic1, long magic2, long cmd, void *arg) {}
607 PRE_SYSCALL(restart_syscall)() {}
609 POST_SYSCALL(restart_syscall)(long res) {}
611 PRE_SYSCALL(kexec_load)(long entry, long nr_segments, void *segments,
612                         long flags) {}
614 POST_SYSCALL(kexec_load)(long res, long entry, long nr_segments, void *segments,
615                          long flags) {
616   if (res >= 0) {
617     if (segments) POST_WRITE(segments, struct_kexec_segment_sz);
618   }
621 PRE_SYSCALL(exit)(long error_code) {}
623 POST_SYSCALL(exit)(long res, long error_code) {}
625 PRE_SYSCALL(exit_group)(long error_code) {}
627 POST_SYSCALL(exit_group)(long res, long error_code) {}
629 PRE_SYSCALL(wait4)(long pid, void *stat_addr, long options, void *ru) {}
631 POST_SYSCALL(wait4)(long res, long pid, void *stat_addr, long options,
632                     void *ru) {
633   if (res >= 0) {
634     if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
635     if (ru) POST_WRITE(ru, struct_rusage_sz);
636   }
639 PRE_SYSCALL(waitid)(long which, long pid, void *infop, long options, void *ru) {
642 POST_SYSCALL(waitid)(long res, long which, long pid, void *infop, long options,
643                      void *ru) {
644   if (res >= 0) {
645     if (infop) POST_WRITE(infop, siginfo_t_sz);
646     if (ru) POST_WRITE(ru, struct_rusage_sz);
647   }
650 PRE_SYSCALL(waitpid)(long pid, void *stat_addr, long options) {}
652 POST_SYSCALL(waitpid)(long res, long pid, void *stat_addr, long options) {
653   if (res >= 0) {
654     if (stat_addr) POST_WRITE(stat_addr, sizeof(int));
655   }
658 PRE_SYSCALL(set_tid_address)(void *tidptr) {}
660 POST_SYSCALL(set_tid_address)(long res, void *tidptr) {
661   if (res >= 0) {
662     if (tidptr) POST_WRITE(tidptr, sizeof(int));
663   }
666 PRE_SYSCALL(init_module)(void *umod, long len, const void *uargs) {
667   if (uargs)
668     PRE_READ(uargs, __sanitizer::internal_strlen((const char *)uargs) + 1);
671 POST_SYSCALL(init_module)(long res, void *umod, long len, const void *uargs) {}
673 PRE_SYSCALL(delete_module)(const void *name_user, long flags) {
674   if (name_user)
675     PRE_READ(name_user,
676              __sanitizer::internal_strlen((const char *)name_user) + 1);
679 POST_SYSCALL(delete_module)(long res, const void *name_user, long flags) {}
681 PRE_SYSCALL(rt_sigprocmask)(long how, void *set, void *oset, long sigsetsize) {}
683 POST_SYSCALL(rt_sigprocmask)(long res, long how, kernel_sigset_t *set,
684                              kernel_sigset_t *oset, long sigsetsize) {
685   if (res >= 0) {
686     if (set) POST_WRITE(set, sigsetsize);
687     if (oset) POST_WRITE(oset, sigsetsize);
688   }
691 PRE_SYSCALL(rt_sigpending)(void *set, long sigsetsize) {}
693 POST_SYSCALL(rt_sigpending)(long res, kernel_sigset_t *set, long sigsetsize) {
694   if (res >= 0) {
695     if (set) POST_WRITE(set, sigsetsize);
696   }
699 PRE_SYSCALL(rt_sigtimedwait)(const kernel_sigset_t *uthese, void *uinfo,
700                              const void *uts, long sigsetsize) {
701   if (uthese) PRE_READ(uthese, sigsetsize);
702   if (uts) PRE_READ(uts, struct_timespec_sz);
705 POST_SYSCALL(rt_sigtimedwait)(long res, const void *uthese, void *uinfo,
706                               const void *uts, long sigsetsize) {
707   if (res >= 0) {
708     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
709   }
712 PRE_SYSCALL(rt_tgsigqueueinfo)(long tgid, long pid, long sig, void *uinfo) {}
714 POST_SYSCALL(rt_tgsigqueueinfo)(long res, long tgid, long pid, long sig,
715                                 void *uinfo) {
716   if (res >= 0) {
717     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
718   }
721 PRE_SYSCALL(kill)(long pid, long sig) {}
723 POST_SYSCALL(kill)(long res, long pid, long sig) {}
725 PRE_SYSCALL(tgkill)(long tgid, long pid, long sig) {}
727 POST_SYSCALL(tgkill)(long res, long tgid, long pid, long sig) {}
729 PRE_SYSCALL(tkill)(long pid, long sig) {}
731 POST_SYSCALL(tkill)(long res, long pid, long sig) {}
733 PRE_SYSCALL(rt_sigqueueinfo)(long pid, long sig, void *uinfo) {}
735 POST_SYSCALL(rt_sigqueueinfo)(long res, long pid, long sig, void *uinfo) {
736   if (res >= 0) {
737     if (uinfo) POST_WRITE(uinfo, siginfo_t_sz);
738   }
741 PRE_SYSCALL(sgetmask)() {}
743 POST_SYSCALL(sgetmask)(long res) {}
745 PRE_SYSCALL(ssetmask)(long newmask) {}
747 POST_SYSCALL(ssetmask)(long res, long newmask) {}
749 PRE_SYSCALL(signal)(long sig, long handler) {}
751 POST_SYSCALL(signal)(long res, long sig, long handler) {}
753 PRE_SYSCALL(pause)() {}
755 POST_SYSCALL(pause)(long res) {}
757 PRE_SYSCALL(sync)() {}
759 POST_SYSCALL(sync)(long res) {}
761 PRE_SYSCALL(fsync)(long fd) {}
763 POST_SYSCALL(fsync)(long res, long fd) {}
765 PRE_SYSCALL(fdatasync)(long fd) {}
767 POST_SYSCALL(fdatasync)(long res, long fd) {}
769 PRE_SYSCALL(bdflush)(long func, long data) {}
771 POST_SYSCALL(bdflush)(long res, long func, long data) {}
773 PRE_SYSCALL(mount)(void *dev_name, void *dir_name, void *type, long flags,
774                    void *data) {}
776 POST_SYSCALL(mount)(long res, void *dev_name, void *dir_name, void *type,
777                     long flags, void *data) {
778   if (res >= 0) {
779     if (dev_name)
780       POST_WRITE(dev_name,
781                  __sanitizer::internal_strlen((const char *)dev_name) + 1);
782     if (dir_name)
783       POST_WRITE(dir_name,
784                  __sanitizer::internal_strlen((const char *)dir_name) + 1);
785     if (type)
786       POST_WRITE(type, __sanitizer::internal_strlen((const char *)type) + 1);
787   }
790 PRE_SYSCALL(umount)(void *name, long flags) {}
792 POST_SYSCALL(umount)(long res, void *name, long flags) {
793   if (res >= 0) {
794     if (name)
795       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
796   }
799 PRE_SYSCALL(oldumount)(void *name) {}
801 POST_SYSCALL(oldumount)(long res, void *name) {
802   if (res >= 0) {
803     if (name)
804       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
805   }
808 PRE_SYSCALL(truncate)(const void *path, long length) {
809   if (path)
810     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
813 POST_SYSCALL(truncate)(long res, const void *path, long length) {}
815 PRE_SYSCALL(ftruncate)(long fd, long length) {}
817 POST_SYSCALL(ftruncate)(long res, long fd, long length) {}
819 PRE_SYSCALL(stat)(const void *filename, void *statbuf) {
820   if (filename)
821     PRE_READ(filename,
822              __sanitizer::internal_strlen((const char *)filename) + 1);
825 POST_SYSCALL(stat)(long res, const void *filename, void *statbuf) {
826   if (res >= 0) {
827     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
828   }
831 PRE_SYSCALL(statfs)(const void *path, void *buf) {
832   if (path)
833     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
836 POST_SYSCALL(statfs)(long res, const void *path, void *buf) {
837   if (res >= 0) {
838     if (buf) POST_WRITE(buf, struct_statfs_sz);
839   }
842 PRE_SYSCALL(statfs64)(const void *path, long sz, void *buf) {
843   if (path)
844     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
847 POST_SYSCALL(statfs64)(long res, const void *path, long sz, void *buf) {
848   if (res >= 0) {
849     if (buf) POST_WRITE(buf, struct_statfs64_sz);
850   }
853 PRE_SYSCALL(fstatfs)(long fd, void *buf) {}
855 POST_SYSCALL(fstatfs)(long res, long fd, void *buf) {
856   if (res >= 0) {
857     if (buf) POST_WRITE(buf, struct_statfs_sz);
858   }
861 PRE_SYSCALL(fstatfs64)(long fd, long sz, void *buf) {}
863 POST_SYSCALL(fstatfs64)(long res, long fd, long sz, void *buf) {
864   if (res >= 0) {
865     if (buf) POST_WRITE(buf, struct_statfs64_sz);
866   }
869 PRE_SYSCALL(lstat)(const void *filename, void *statbuf) {
870   if (filename)
871     PRE_READ(filename,
872              __sanitizer::internal_strlen((const char *)filename) + 1);
875 POST_SYSCALL(lstat)(long res, const void *filename, void *statbuf) {
876   if (res >= 0) {
877     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
878   }
881 PRE_SYSCALL(fstat)(long fd, void *statbuf) {}
883 POST_SYSCALL(fstat)(long res, long fd, void *statbuf) {
884   if (res >= 0) {
885     if (statbuf) POST_WRITE(statbuf, struct___old_kernel_stat_sz);
886   }
889 PRE_SYSCALL(newstat)(const void *filename, void *statbuf) {
890   if (filename)
891     PRE_READ(filename,
892              __sanitizer::internal_strlen((const char *)filename) + 1);
895 POST_SYSCALL(newstat)(long res, const void *filename, void *statbuf) {
896   if (res >= 0) {
897     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
898   }
901 PRE_SYSCALL(newlstat)(const void *filename, void *statbuf) {
902   if (filename)
903     PRE_READ(filename,
904              __sanitizer::internal_strlen((const char *)filename) + 1);
907 POST_SYSCALL(newlstat)(long res, const void *filename, void *statbuf) {
908   if (res >= 0) {
909     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
910   }
913 PRE_SYSCALL(newfstat)(long fd, void *statbuf) {}
915 POST_SYSCALL(newfstat)(long res, long fd, void *statbuf) {
916   if (res >= 0) {
917     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
918   }
921 PRE_SYSCALL(ustat)(long dev, void *ubuf) {}
923 POST_SYSCALL(ustat)(long res, long dev, void *ubuf) {
924   if (res >= 0) {
925     if (ubuf) POST_WRITE(ubuf, struct_ustat_sz);
926   }
929 PRE_SYSCALL(stat64)(const void *filename, void *statbuf) {
930   if (filename)
931     PRE_READ(filename,
932              __sanitizer::internal_strlen((const char *)filename) + 1);
935 POST_SYSCALL(stat64)(long res, const void *filename, void *statbuf) {
936   if (res >= 0) {
937     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
938   }
941 PRE_SYSCALL(fstat64)(long fd, void *statbuf) {}
943 POST_SYSCALL(fstat64)(long res, long fd, void *statbuf) {
944   if (res >= 0) {
945     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
946   }
949 PRE_SYSCALL(lstat64)(const void *filename, void *statbuf) {
950   if (filename)
951     PRE_READ(filename,
952              __sanitizer::internal_strlen((const char *)filename) + 1);
955 POST_SYSCALL(lstat64)(long res, const void *filename, void *statbuf) {
956   if (res >= 0) {
957     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
958   }
961 PRE_SYSCALL(setxattr)(const void *path, const void *name, const void *value,
962                       long size, long flags) {
963   if (path)
964     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
965   if (name)
966     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
967   if (value) PRE_READ(value, size);
970 POST_SYSCALL(setxattr)(long res, const void *path, const void *name,
971                        const void *value, long size, long flags) {}
973 PRE_SYSCALL(lsetxattr)(const void *path, const void *name, const void *value,
974                        long size, long flags) {
975   if (path)
976     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
977   if (name)
978     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
979   if (value) PRE_READ(value, size);
982 POST_SYSCALL(lsetxattr)(long res, const void *path, const void *name,
983                         const void *value, long size, long flags) {}
985 PRE_SYSCALL(fsetxattr)(long fd, const void *name, const void *value, long size,
986                        long flags) {
987   if (name)
988     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
989   if (value) PRE_READ(value, size);
992 POST_SYSCALL(fsetxattr)(long res, long fd, const void *name, const void *value,
993                         long size, long flags) {}
995 PRE_SYSCALL(getxattr)(const void *path, const void *name, void *value,
996                       long size) {
997   if (path)
998     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
999   if (name)
1000     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1003 POST_SYSCALL(getxattr)(long res, const void *path, const void *name,
1004                        void *value, long size) {
1005   if (res >= 0) {
1006     if (value) POST_WRITE(value, size);
1007   }
1010 PRE_SYSCALL(lgetxattr)(const void *path, const void *name, void *value,
1011                        long size) {
1012   if (path)
1013     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1014   if (name)
1015     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1018 POST_SYSCALL(lgetxattr)(long res, const void *path, const void *name,
1019                         void *value, long size) {
1020   if (res >= 0) {
1021     if (value) POST_WRITE(value, size);
1022   }
1025 PRE_SYSCALL(fgetxattr)(long fd, const void *name, void *value, long size) {
1026   if (name)
1027     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1030 POST_SYSCALL(fgetxattr)(long res, long fd, const void *name, void *value,
1031                         long size) {
1032   if (res >= 0) {
1033     if (value) POST_WRITE(value, size);
1034   }
1037 PRE_SYSCALL(listxattr)(const void *path, void *list, long size) {
1038   if (path)
1039     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1042 POST_SYSCALL(listxattr)(long res, const void *path, void *list, long size) {
1043   if (res >= 0) {
1044     if (list) POST_WRITE(list, size);
1045   }
1048 PRE_SYSCALL(llistxattr)(const void *path, void *list, long size) {
1049   if (path)
1050     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1053 POST_SYSCALL(llistxattr)(long res, const void *path, void *list, long size) {
1054   if (res >= 0) {
1055     if (list) POST_WRITE(list, size);
1056   }
1059 PRE_SYSCALL(flistxattr)(long fd, void *list, long size) {}
1061 POST_SYSCALL(flistxattr)(long res, long fd, void *list, long size) {
1062   if (res >= 0) {
1063     if (list) POST_WRITE(list, size);
1064   }
1067 PRE_SYSCALL(removexattr)(const void *path, const void *name) {
1068   if (path)
1069     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1070   if (name)
1071     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1074 POST_SYSCALL(removexattr)(long res, const void *path, const void *name) {}
1076 PRE_SYSCALL(lremovexattr)(const void *path, const void *name) {
1077   if (path)
1078     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1079   if (name)
1080     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1083 POST_SYSCALL(lremovexattr)(long res, const void *path, const void *name) {}
1085 PRE_SYSCALL(fremovexattr)(long fd, const void *name) {
1086   if (name)
1087     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
1090 POST_SYSCALL(fremovexattr)(long res, long fd, const void *name) {}
1092 PRE_SYSCALL(brk)(long brk) {}
1094 POST_SYSCALL(brk)(long res, long brk) {}
1096 PRE_SYSCALL(mprotect)(long start, long len, long prot) {}
1098 POST_SYSCALL(mprotect)(long res, long start, long len, long prot) {}
1100 PRE_SYSCALL(mremap)(long addr, long old_len, long new_len, long flags,
1101                     long new_addr) {}
1103 POST_SYSCALL(mremap)(long res, long addr, long old_len, long new_len,
1104                      long flags, long new_addr) {}
1106 PRE_SYSCALL(remap_file_pages)(long start, long size, long prot, long pgoff,
1107                               long flags) {}
1109 POST_SYSCALL(remap_file_pages)(long res, long start, long size, long prot,
1110                                long pgoff, long flags) {}
1112 PRE_SYSCALL(msync)(long start, long len, long flags) {}
1114 POST_SYSCALL(msync)(long res, long start, long len, long flags) {}
1116 PRE_SYSCALL(munmap)(long addr, long len) {}
1118 POST_SYSCALL(munmap)(long res, long addr, long len) {}
1120 PRE_SYSCALL(mlock)(long start, long len) {}
1122 POST_SYSCALL(mlock)(long res, long start, long len) {}
1124 PRE_SYSCALL(munlock)(long start, long len) {}
1126 POST_SYSCALL(munlock)(long res, long start, long len) {}
1128 PRE_SYSCALL(mlockall)(long flags) {}
1130 POST_SYSCALL(mlockall)(long res, long flags) {}
1132 PRE_SYSCALL(munlockall)() {}
1134 POST_SYSCALL(munlockall)(long res) {}
1136 PRE_SYSCALL(madvise)(long start, long len, long behavior) {}
1138 POST_SYSCALL(madvise)(long res, long start, long len, long behavior) {}
1140 PRE_SYSCALL(mincore)(long start, long len, void *vec) {}
1142 POST_SYSCALL(mincore)(long res, long start, long len, void *vec) {
1143   if (res >= 0) {
1144     if (vec) {
1145       POST_WRITE(vec, (len + GetPageSizeCached() - 1) / GetPageSizeCached());
1146     }
1147   }
1150 PRE_SYSCALL(pivot_root)(const void *new_root, const void *put_old) {
1151   if (new_root)
1152     PRE_READ(new_root,
1153              __sanitizer::internal_strlen((const char *)new_root) + 1);
1154   if (put_old)
1155     PRE_READ(put_old, __sanitizer::internal_strlen((const char *)put_old) + 1);
1158 POST_SYSCALL(pivot_root)(long res, const void *new_root, const void *put_old) {}
1160 PRE_SYSCALL(chroot)(const void *filename) {
1161   if (filename)
1162     PRE_READ(filename,
1163              __sanitizer::internal_strlen((const char *)filename) + 1);
1166 POST_SYSCALL(chroot)(long res, const void *filename) {}
1168 PRE_SYSCALL(mknod)(const void *filename, long mode, long dev) {
1169   if (filename)
1170     PRE_READ(filename,
1171              __sanitizer::internal_strlen((const char *)filename) + 1);
1174 POST_SYSCALL(mknod)(long res, const void *filename, long mode, long dev) {}
1176 PRE_SYSCALL(link)(const void *oldname, const void *newname) {
1177   if (oldname)
1178     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
1179   if (newname)
1180     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
1183 POST_SYSCALL(link)(long res, const void *oldname, const void *newname) {}
1185 PRE_SYSCALL(symlink)(const void *old, const void *new_) {
1186   if (old) PRE_READ(old, __sanitizer::internal_strlen((const char *)old) + 1);
1187   if (new_)
1188     PRE_READ(new_, __sanitizer::internal_strlen((const char *)new_) + 1);
1191 POST_SYSCALL(symlink)(long res, const void *old, const void *new_) {}
1193 PRE_SYSCALL(unlink)(const void *pathname) {
1194   if (pathname)
1195     PRE_READ(pathname,
1196              __sanitizer::internal_strlen((const char *)pathname) + 1);
1199 POST_SYSCALL(unlink)(long res, const void *pathname) {}
1201 PRE_SYSCALL(rename)(const void *oldname, const void *newname) {
1202   if (oldname)
1203     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
1204   if (newname)
1205     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
1208 POST_SYSCALL(rename)(long res, const void *oldname, const void *newname) {}
1210 PRE_SYSCALL(chmod)(const void *filename, long mode) {
1211   if (filename)
1212     PRE_READ(filename,
1213              __sanitizer::internal_strlen((const char *)filename) + 1);
1216 POST_SYSCALL(chmod)(long res, const void *filename, long mode) {}
1218 PRE_SYSCALL(fchmod)(long fd, long mode) {}
1220 POST_SYSCALL(fchmod)(long res, long fd, long mode) {}
1222 PRE_SYSCALL(fcntl)(long fd, long cmd, long arg) {}
1224 POST_SYSCALL(fcntl)(long res, long fd, long cmd, long arg) {}
1226 PRE_SYSCALL(fcntl64)(long fd, long cmd, long arg) {}
1228 POST_SYSCALL(fcntl64)(long res, long fd, long cmd, long arg) {}
1230 PRE_SYSCALL(pipe)(void *fildes) {}
1232 POST_SYSCALL(pipe)(long res, void *fildes) {
1233   if (res >= 0) {
1234     if (fildes) POST_WRITE(fildes, sizeof(int));
1235   }
1238 PRE_SYSCALL(pipe2)(void *fildes, long flags) {}
1240 POST_SYSCALL(pipe2)(long res, void *fildes, long flags) {
1241   if (res >= 0) {
1242     if (fildes) POST_WRITE(fildes, sizeof(int));
1243   }
1246 PRE_SYSCALL(dup)(long fildes) {}
1248 POST_SYSCALL(dup)(long res, long fildes) {}
1250 PRE_SYSCALL(dup2)(long oldfd, long newfd) {}
1252 POST_SYSCALL(dup2)(long res, long oldfd, long newfd) {}
1254 PRE_SYSCALL(dup3)(long oldfd, long newfd, long flags) {}
1256 POST_SYSCALL(dup3)(long res, long oldfd, long newfd, long flags) {}
1258 PRE_SYSCALL(ioperm)(long from, long num, long on) {}
1260 POST_SYSCALL(ioperm)(long res, long from, long num, long on) {}
1262 PRE_SYSCALL(ioctl)(long fd, long cmd, long arg) {}
1264 POST_SYSCALL(ioctl)(long res, long fd, long cmd, long arg) {}
1266 PRE_SYSCALL(flock)(long fd, long cmd) {}
1268 POST_SYSCALL(flock)(long res, long fd, long cmd) {}
1270 PRE_SYSCALL(io_setup)(long nr_reqs, void **ctx) {
1271   if (ctx) PRE_WRITE(ctx, sizeof(*ctx));
1274 POST_SYSCALL(io_setup)(long res, long nr_reqs, void **ctx) {
1275   if (res >= 0) {
1276     if (ctx) POST_WRITE(ctx, sizeof(*ctx));
1277     // (*ctx) is actually a pointer to a kernel mapped page, and there are
1278     // people out there who are crazy enough to peek into that page's 32-byte
1279     // header.
1280     if (*ctx) POST_WRITE(*ctx, 32);
1281   }
1284 PRE_SYSCALL(io_destroy)(long ctx) {}
1286 POST_SYSCALL(io_destroy)(long res, long ctx) {}
1288 PRE_SYSCALL(io_getevents)(long ctx_id, long min_nr, long nr,
1289                           __sanitizer_io_event *ioevpp, void *timeout) {
1290   if (timeout) PRE_READ(timeout, struct_timespec_sz);
1293 POST_SYSCALL(io_getevents)(long res, long ctx_id, long min_nr, long nr,
1294                            __sanitizer_io_event *ioevpp, void *timeout) {
1295   if (res >= 0) {
1296     if (ioevpp) POST_WRITE(ioevpp, res * sizeof(*ioevpp));
1297     if (timeout) POST_WRITE(timeout, struct_timespec_sz);
1298   }
1299   for (long i = 0; i < res; i++) {
1300     // We synchronize io_submit -> io_getevents/io_cancel using the
1301     // user-provided data context. Data is not necessary a pointer, it can be
1302     // an int, 0 or whatever; acquire/release will correctly handle this.
1303     // This scheme can lead to false negatives, e.g. when all operations
1304     // synchronize on 0. But there does not seem to be a better solution
1305     // (except wrapping all operations in own context, which is unreliable).
1306     // We can not reliably extract fildes in io_getevents.
1307     COMMON_SYSCALL_ACQUIRE((void*)ioevpp[i].data);
1308   }
1311 PRE_SYSCALL(io_submit)(long ctx_id, long nr, __sanitizer_iocb **iocbpp) {
1312   for (long i = 0; i < nr; ++i) {
1313     uptr op = iocbpp[i]->aio_lio_opcode;
1314     void *data = (void*)iocbpp[i]->aio_data;
1315     void *buf = (void*)iocbpp[i]->aio_buf;
1316     uptr len = (uptr)iocbpp[i]->aio_nbytes;
1317     if (op == iocb_cmd_pwrite && buf && len) {
1318       PRE_READ(buf, len);
1319     } else if (op == iocb_cmd_pread && buf && len) {
1320       POST_WRITE(buf, len);
1321     } else if (op == iocb_cmd_pwritev) {
1322       __sanitizer_iovec *iovec = (__sanitizer_iovec*)iocbpp[i]->aio_buf;
1323       for (uptr v = 0; v < len; v++)
1324         PRE_READ(iovec[i].iov_base, iovec[i].iov_len);
1325     } else if (op == iocb_cmd_preadv) {
1326       __sanitizer_iovec *iovec = (__sanitizer_iovec*)iocbpp[i]->aio_buf;
1327       for (uptr v = 0; v < len; v++)
1328         POST_WRITE(iovec[i].iov_base, iovec[i].iov_len);
1329     }
1330     // See comment in io_getevents.
1331     COMMON_SYSCALL_RELEASE(data);
1332   }
1335 POST_SYSCALL(io_submit)(long res, long ctx_id, long nr,
1336     __sanitizer_iocb **iocbpp) {}
1338 PRE_SYSCALL(io_cancel)(long ctx_id, __sanitizer_iocb *iocb,
1339     __sanitizer_io_event *result) {
1342 POST_SYSCALL(io_cancel)(long res, long ctx_id, __sanitizer_iocb *iocb,
1343     __sanitizer_io_event *result) {
1344   if (res == 0) {
1345     if (result) {
1346       // See comment in io_getevents.
1347       COMMON_SYSCALL_ACQUIRE((void*)result->data);
1348       POST_WRITE(result, sizeof(*result));
1349     }
1350     if (iocb)
1351       POST_WRITE(iocb, sizeof(*iocb));
1352   }
1355 PRE_SYSCALL(sendfile)(long out_fd, long in_fd, void *offset, long count) {}
1357 POST_SYSCALL(sendfile)(long res, long out_fd, long in_fd,
1358                        __sanitizer___kernel_off_t *offset, long count) {
1359   if (res >= 0) {
1360     if (offset) POST_WRITE(offset, sizeof(*offset));
1361   }
1364 PRE_SYSCALL(sendfile64)(long out_fd, long in_fd, void *offset, long count) {}
1366 POST_SYSCALL(sendfile64)(long res, long out_fd, long in_fd,
1367                          __sanitizer___kernel_loff_t *offset, long count) {
1368   if (res >= 0) {
1369     if (offset) POST_WRITE(offset, sizeof(*offset));
1370   }
1373 PRE_SYSCALL(readlink)(const void *path, void *buf, long bufsiz) {
1374   if (path)
1375     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
1378 POST_SYSCALL(readlink)(long res, const void *path, void *buf, long bufsiz) {
1379   if (res >= 0) {
1380     if (buf)
1381       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1382   }
1385 PRE_SYSCALL(creat)(const void *pathname, long mode) {
1386   if (pathname)
1387     PRE_READ(pathname,
1388              __sanitizer::internal_strlen((const char *)pathname) + 1);
1391 POST_SYSCALL(creat)(long res, const void *pathname, long mode) {}
1393 PRE_SYSCALL(open)(const void *filename, long flags, long mode) {
1394   if (filename)
1395     PRE_READ(filename,
1396              __sanitizer::internal_strlen((const char *)filename) + 1);
1399 POST_SYSCALL(open)(long res, const void *filename, long flags, long mode) {}
1401 PRE_SYSCALL(close)(long fd) {
1402   COMMON_SYSCALL_FD_CLOSE((int)fd);
1405 POST_SYSCALL(close)(long res, long fd) {}
1407 PRE_SYSCALL(access)(const void *filename, long mode) {
1408   if (filename)
1409     PRE_READ(filename,
1410              __sanitizer::internal_strlen((const char *)filename) + 1);
1413 POST_SYSCALL(access)(long res, const void *filename, long mode) {}
1415 PRE_SYSCALL(vhangup)() {}
1417 POST_SYSCALL(vhangup)(long res) {}
1419 PRE_SYSCALL(chown)(const void *filename, long user, long group) {
1420   if (filename)
1421     PRE_READ(filename,
1422              __sanitizer::internal_strlen((const char *)filename) + 1);
1425 POST_SYSCALL(chown)(long res, const void *filename, long user, long group) {}
1427 PRE_SYSCALL(lchown)(const void *filename, long user, long group) {
1428   if (filename)
1429     PRE_READ(filename,
1430              __sanitizer::internal_strlen((const char *)filename) + 1);
1433 POST_SYSCALL(lchown)(long res, const void *filename, long user, long group) {}
1435 PRE_SYSCALL(fchown)(long fd, long user, long group) {}
1437 POST_SYSCALL(fchown)(long res, long fd, long user, long group) {}
1439 PRE_SYSCALL(chown16)(const void *filename, long user, long group) {
1440   if (filename)
1441     PRE_READ(filename,
1442              __sanitizer::internal_strlen((const char *)filename) + 1);
1445 POST_SYSCALL(chown16)(long res, const void *filename, long user, long group) {}
1447 PRE_SYSCALL(lchown16)(const void *filename, long user, long group) {
1448   if (filename)
1449     PRE_READ(filename,
1450              __sanitizer::internal_strlen((const char *)filename) + 1);
1453 POST_SYSCALL(lchown16)(long res, const void *filename, long user, long group) {}
1455 PRE_SYSCALL(fchown16)(long fd, long user, long group) {}
1457 POST_SYSCALL(fchown16)(long res, long fd, long user, long group) {}
1459 PRE_SYSCALL(setregid16)(long rgid, long egid) {}
1461 POST_SYSCALL(setregid16)(long res, long rgid, long egid) {}
1463 PRE_SYSCALL(setgid16)(long gid) {}
1465 POST_SYSCALL(setgid16)(long res, long gid) {}
1467 PRE_SYSCALL(setreuid16)(long ruid, long euid) {}
1469 POST_SYSCALL(setreuid16)(long res, long ruid, long euid) {}
1471 PRE_SYSCALL(setuid16)(long uid) {}
1473 POST_SYSCALL(setuid16)(long res, long uid) {}
1475 PRE_SYSCALL(setresuid16)(long ruid, long euid, long suid) {}
1477 POST_SYSCALL(setresuid16)(long res, long ruid, long euid, long suid) {}
1479 PRE_SYSCALL(getresuid16)(void *ruid, void *euid, void *suid) {}
1481 POST_SYSCALL(getresuid16)(long res, __sanitizer___kernel_old_uid_t *ruid,
1482                           __sanitizer___kernel_old_uid_t *euid,
1483                           __sanitizer___kernel_old_uid_t *suid) {
1484   if (res >= 0) {
1485     if (ruid) POST_WRITE(ruid, sizeof(*ruid));
1486     if (euid) POST_WRITE(euid, sizeof(*euid));
1487     if (suid) POST_WRITE(suid, sizeof(*suid));
1488   }
1491 PRE_SYSCALL(setresgid16)(long rgid, long egid, long sgid) {}
1493 POST_SYSCALL(setresgid16)(long res, long rgid, long egid, long sgid) {}
1495 PRE_SYSCALL(getresgid16)(void *rgid, void *egid, void *sgid) {}
1497 POST_SYSCALL(getresgid16)(long res, __sanitizer___kernel_old_gid_t *rgid,
1498                           __sanitizer___kernel_old_gid_t *egid,
1499                           __sanitizer___kernel_old_gid_t *sgid) {
1500   if (res >= 0) {
1501     if (rgid) POST_WRITE(rgid, sizeof(*rgid));
1502     if (egid) POST_WRITE(egid, sizeof(*egid));
1503     if (sgid) POST_WRITE(sgid, sizeof(*sgid));
1504   }
1507 PRE_SYSCALL(setfsuid16)(long uid) {}
1509 POST_SYSCALL(setfsuid16)(long res, long uid) {}
1511 PRE_SYSCALL(setfsgid16)(long gid) {}
1513 POST_SYSCALL(setfsgid16)(long res, long gid) {}
1515 PRE_SYSCALL(getgroups16)(long gidsetsize,
1516                          __sanitizer___kernel_old_gid_t *grouplist) {}
1518 POST_SYSCALL(getgroups16)(long res, long gidsetsize,
1519                           __sanitizer___kernel_old_gid_t *grouplist) {
1520   if (res >= 0) {
1521     if (grouplist) POST_WRITE(grouplist, res * sizeof(*grouplist));
1522   }
1525 PRE_SYSCALL(setgroups16)(long gidsetsize,
1526                          __sanitizer___kernel_old_gid_t *grouplist) {
1527   if (grouplist) POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist));
1530 POST_SYSCALL(setgroups16)(long res, long gidsetsize,
1531                           __sanitizer___kernel_old_gid_t *grouplist) {}
1533 PRE_SYSCALL(getuid16)() {}
1535 POST_SYSCALL(getuid16)(long res) {}
1537 PRE_SYSCALL(geteuid16)() {}
1539 POST_SYSCALL(geteuid16)(long res) {}
1541 PRE_SYSCALL(getgid16)() {}
1543 POST_SYSCALL(getgid16)(long res) {}
1545 PRE_SYSCALL(getegid16)() {}
1547 POST_SYSCALL(getegid16)(long res) {}
1549 PRE_SYSCALL(utime)(void *filename, void *times) {}
1551 POST_SYSCALL(utime)(long res, void *filename, void *times) {
1552   if (res >= 0) {
1553     if (filename)
1554       POST_WRITE(filename,
1555                  __sanitizer::internal_strlen((const char *)filename) + 1);
1556     if (times) POST_WRITE(times, struct_utimbuf_sz);
1557   }
1560 PRE_SYSCALL(utimes)(void *filename, void *utimes) {}
1562 POST_SYSCALL(utimes)(long res, void *filename, void *utimes) {
1563   if (res >= 0) {
1564     if (filename)
1565       POST_WRITE(filename,
1566                  __sanitizer::internal_strlen((const char *)filename) + 1);
1567     if (utimes) POST_WRITE(utimes, timeval_sz);
1568   }
1571 PRE_SYSCALL(lseek)(long fd, long offset, long origin) {}
1573 POST_SYSCALL(lseek)(long res, long fd, long offset, long origin) {}
1575 PRE_SYSCALL(llseek)(long fd, long offset_high, long offset_low, void *result,
1576                     long origin) {}
1578 POST_SYSCALL(llseek)(long res, long fd, long offset_high, long offset_low,
1579                      void *result, long origin) {
1580   if (res >= 0) {
1581     if (result) POST_WRITE(result, sizeof(long long));
1582   }
1585 PRE_SYSCALL(readv)(long fd, const __sanitizer_iovec *vec, long vlen) {}
1587 POST_SYSCALL(readv)(long res, long fd, const __sanitizer_iovec *vec,
1588                     long vlen) {
1589   if (res >= 0) {
1590     if (vec) kernel_write_iovec(vec, vlen, res);
1591   }
1594 PRE_SYSCALL(write)(long fd, const void *buf, long count) {
1595   if (buf) PRE_READ(buf, count);
1598 POST_SYSCALL(write)(long res, long fd, const void *buf, long count) {}
1600 PRE_SYSCALL(writev)(long fd, const __sanitizer_iovec *vec, long vlen) {}
1602 POST_SYSCALL(writev)(long res, long fd, const __sanitizer_iovec *vec,
1603                      long vlen) {
1604   if (res >= 0) {
1605     if (vec) kernel_read_iovec(vec, vlen, res);
1606   }
1609 #ifdef _LP64
1610 PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos) {}
1612 POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos) {
1613   if (res >= 0) {
1614     if (buf) POST_WRITE(buf, res);
1615   }
1618 PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos) {
1619   if (buf) PRE_READ(buf, count);
1622 POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
1623                        long pos) {}
1624 #else
1625 PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos0, long pos1) {}
1627 POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos0,
1628                       long pos1) {
1629   if (res >= 0) {
1630     if (buf) POST_WRITE(buf, res);
1631   }
1634 PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos0,
1635                       long pos1) {
1636   if (buf) PRE_READ(buf, count);
1639 POST_SYSCALL(pwrite64)(long res, long fd, const void *buf, long count,
1640                        long pos0, long pos1) {}
1641 #endif
1643 PRE_SYSCALL(preadv)(long fd, const __sanitizer_iovec *vec, long vlen,
1644                     long pos_l, long pos_h) {}
1646 POST_SYSCALL(preadv)(long res, long fd, const __sanitizer_iovec *vec, long vlen,
1647                      long pos_l, long pos_h) {
1648   if (res >= 0) {
1649     if (vec) kernel_write_iovec(vec, vlen, res);
1650   }
1653 PRE_SYSCALL(pwritev)(long fd, const __sanitizer_iovec *vec, long vlen,
1654                      long pos_l, long pos_h) {}
1656 POST_SYSCALL(pwritev)(long res, long fd, const __sanitizer_iovec *vec,
1657                       long vlen, long pos_l, long pos_h) {
1658   if (res >= 0) {
1659     if (vec) kernel_read_iovec(vec, vlen, res);
1660   }
1663 PRE_SYSCALL(getcwd)(void *buf, long size) {}
1665 POST_SYSCALL(getcwd)(long res, void *buf, long size) {
1666   if (res >= 0) {
1667     if (buf)
1668       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1669   }
1672 PRE_SYSCALL(mkdir)(const void *pathname, long mode) {
1673   if (pathname)
1674     PRE_READ(pathname,
1675              __sanitizer::internal_strlen((const char *)pathname) + 1);
1678 POST_SYSCALL(mkdir)(long res, const void *pathname, long mode) {}
1680 PRE_SYSCALL(chdir)(const void *filename) {
1681   if (filename)
1682     PRE_READ(filename,
1683              __sanitizer::internal_strlen((const char *)filename) + 1);
1686 POST_SYSCALL(chdir)(long res, const void *filename) {}
1688 PRE_SYSCALL(fchdir)(long fd) {}
1690 POST_SYSCALL(fchdir)(long res, long fd) {}
1692 PRE_SYSCALL(rmdir)(const void *pathname) {
1693   if (pathname)
1694     PRE_READ(pathname,
1695              __sanitizer::internal_strlen((const char *)pathname) + 1);
1698 POST_SYSCALL(rmdir)(long res, const void *pathname) {}
1700 PRE_SYSCALL(lookup_dcookie)(u64 cookie64, void *buf, long len) {}
1702 POST_SYSCALL(lookup_dcookie)(long res, u64 cookie64, void *buf, long len) {
1703   if (res >= 0) {
1704     if (buf)
1705       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
1706   }
1709 PRE_SYSCALL(quotactl)(long cmd, const void *special, long id, void *addr) {
1710   if (special)
1711     PRE_READ(special, __sanitizer::internal_strlen((const char *)special) + 1);
1714 POST_SYSCALL(quotactl)(long res, long cmd, const void *special, long id,
1715                        void *addr) {}
1717 PRE_SYSCALL(getdents)(long fd, void *dirent, long count) {}
1719 POST_SYSCALL(getdents)(long res, long fd, void *dirent, long count) {
1720   if (res >= 0) {
1721     if (dirent) POST_WRITE(dirent, res);
1722   }
1725 PRE_SYSCALL(getdents64)(long fd, void *dirent, long count) {}
1727 POST_SYSCALL(getdents64)(long res, long fd, void *dirent, long count) {
1728   if (res >= 0) {
1729     if (dirent) POST_WRITE(dirent, res);
1730   }
1733 PRE_SYSCALL(setsockopt)(long fd, long level, long optname, void *optval,
1734                         long optlen) {}
1736 POST_SYSCALL(setsockopt)(long res, long fd, long level, long optname,
1737                          void *optval, long optlen) {
1738   if (res >= 0) {
1739     if (optval)
1740       POST_WRITE(optval,
1741                  __sanitizer::internal_strlen((const char *)optval) + 1);
1742   }
1745 PRE_SYSCALL(getsockopt)(long fd, long level, long optname, void *optval,
1746                         void *optlen) {}
1748 POST_SYSCALL(getsockopt)(long res, long fd, long level, long optname,
1749                          void *optval, void *optlen) {
1750   if (res >= 0) {
1751     if (optval)
1752       POST_WRITE(optval,
1753                  __sanitizer::internal_strlen((const char *)optval) + 1);
1754     if (optlen) POST_WRITE(optlen, sizeof(int));
1755   }
1758 PRE_SYSCALL(bind)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
1760 POST_SYSCALL(bind)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1761                    long arg2) {
1762   if (res >= 0) {
1763     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1764   }
1767 PRE_SYSCALL(connect)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {}
1769 POST_SYSCALL(connect)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1770                       long arg2) {
1771   if (res >= 0) {
1772     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1773   }
1776 PRE_SYSCALL(accept)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {}
1778 POST_SYSCALL(accept)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1779                      void *arg2) {
1780   if (res >= 0) {
1781     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1782     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1783   }
1786 PRE_SYSCALL(accept4)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2,
1787                      long arg3) {}
1789 POST_SYSCALL(accept4)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1790                       void *arg2, long arg3) {
1791   if (res >= 0) {
1792     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1793     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1794   }
1797 PRE_SYSCALL(getsockname)(long arg0, sanitizer_kernel_sockaddr *arg1,
1798                          void *arg2) {}
1800 POST_SYSCALL(getsockname)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1801                           void *arg2) {
1802   if (res >= 0) {
1803     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1804     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1805   }
1808 PRE_SYSCALL(getpeername)(long arg0, sanitizer_kernel_sockaddr *arg1,
1809                          void *arg2) {}
1811 POST_SYSCALL(getpeername)(long res, long arg0, sanitizer_kernel_sockaddr *arg1,
1812                           void *arg2) {
1813   if (res >= 0) {
1814     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
1815     if (arg2) POST_WRITE(arg2, sizeof(unsigned));
1816   }
1819 PRE_SYSCALL(send)(long arg0, void *arg1, long arg2, long arg3) {}
1821 POST_SYSCALL(send)(long res, long arg0, void *arg1, long arg2, long arg3) {
1822   if (res) {
1823     if (arg1) POST_READ(arg1, res);
1824   }
1827 PRE_SYSCALL(sendto)(long arg0, void *arg1, long arg2, long arg3,
1828                     sanitizer_kernel_sockaddr *arg4, long arg5) {}
1830 POST_SYSCALL(sendto)(long res, long arg0, void *arg1, long arg2, long arg3,
1831                      sanitizer_kernel_sockaddr *arg4, long arg5) {
1832   if (res >= 0) {
1833     if (arg1) POST_READ(arg1, res);
1834     if (arg4) POST_WRITE(arg4, sizeof(*arg4));
1835   }
1838 PRE_SYSCALL(sendmsg)(long fd, void *msg, long flags) {}
1840 POST_SYSCALL(sendmsg)(long res, long fd, void *msg, long flags) {
1841   // FIXME: POST_READ
1844 PRE_SYSCALL(sendmmsg)(long fd, void *msg, long vlen, long flags) {}
1846 POST_SYSCALL(sendmmsg)(long res, long fd, void *msg, long vlen, long flags) {
1847   // FIXME: POST_READ
1850 PRE_SYSCALL(recv)(long arg0, void *buf, long len, long flags) {}
1852 POST_SYSCALL(recv)(long res, void *buf, long len, long flags) {
1853   if (res >= 0) {
1854     if (buf) POST_WRITE(buf, res);
1855   }
1858 PRE_SYSCALL(recvfrom)(long arg0, void *buf, long len, long flags,
1859                       sanitizer_kernel_sockaddr *arg4, void *arg5) {}
1861 POST_SYSCALL(recvfrom)(long res, long arg0, void *buf, long len, long flags,
1862                        sanitizer_kernel_sockaddr *arg4, void *arg5) {
1863   if (res >= 0) {
1864     if (buf) POST_WRITE(buf, res);
1865     if (arg4) POST_WRITE(arg4, sizeof(*arg4));
1866     if (arg5) POST_WRITE(arg5, sizeof(int));
1867   }
1870 PRE_SYSCALL(socket)(long arg0, long arg1, long arg2) {}
1872 POST_SYSCALL(socket)(long res, long arg0, long arg1, long arg2) {}
1874 PRE_SYSCALL(socketpair)(long arg0, long arg1, long arg2, void *arg3) {}
1876 POST_SYSCALL(socketpair)(long res, long arg0, long arg1, long arg2,
1877                          void *arg3) {
1878   if (res >= 0) {
1879     if (arg3) POST_WRITE(arg3, sizeof(int));
1880   }
1883 PRE_SYSCALL(socketcall)(long call, void *args) {}
1885 POST_SYSCALL(socketcall)(long res, long call, void *args) {
1886   if (res >= 0) {
1887     if (args) POST_WRITE(args, sizeof(long));
1888   }
1891 PRE_SYSCALL(listen)(long arg0, long arg1) {}
1893 POST_SYSCALL(listen)(long res, long arg0, long arg1) {}
1895 PRE_SYSCALL(poll)(void *ufds, long nfds, long timeout) {}
1897 POST_SYSCALL(poll)(long res, __sanitizer_pollfd *ufds, long nfds,
1898                    long timeout) {
1899   if (res >= 0) {
1900     if (ufds) POST_WRITE(ufds, nfds * sizeof(*ufds));
1901   }
1904 PRE_SYSCALL(select)(long n, __sanitizer___kernel_fd_set *inp,
1905                     __sanitizer___kernel_fd_set *outp,
1906                     __sanitizer___kernel_fd_set *exp, void *tvp) {}
1908 POST_SYSCALL(select)(long res, long n, __sanitizer___kernel_fd_set *inp,
1909                      __sanitizer___kernel_fd_set *outp,
1910                      __sanitizer___kernel_fd_set *exp, void *tvp) {
1911   if (res >= 0) {
1912     if (inp) POST_WRITE(inp, sizeof(*inp));
1913     if (outp) POST_WRITE(outp, sizeof(*outp));
1914     if (exp) POST_WRITE(exp, sizeof(*exp));
1915     if (tvp) POST_WRITE(tvp, timeval_sz);
1916   }
1919 PRE_SYSCALL(old_select)(void *arg) {}
1921 POST_SYSCALL(old_select)(long res, void *arg) {}
1923 PRE_SYSCALL(epoll_create)(long size) {}
1925 POST_SYSCALL(epoll_create)(long res, long size) {}
1927 PRE_SYSCALL(epoll_create1)(long flags) {}
1929 POST_SYSCALL(epoll_create1)(long res, long flags) {}
1931 PRE_SYSCALL(epoll_ctl)(long epfd, long op, long fd, void *event) {}
1933 POST_SYSCALL(epoll_ctl)(long res, long epfd, long op, long fd, void *event) {
1934   if (res >= 0) {
1935     if (event) POST_WRITE(event, struct_epoll_event_sz);
1936   }
1939 PRE_SYSCALL(epoll_wait)(long epfd, void *events, long maxevents, long timeout) {
1942 POST_SYSCALL(epoll_wait)(long res, long epfd, void *events, long maxevents,
1943                          long timeout) {
1944   if (res >= 0) {
1945     if (events) POST_WRITE(events, struct_epoll_event_sz);
1946   }
1949 PRE_SYSCALL(epoll_pwait)(long epfd, void *events, long maxevents, long timeout,
1950                          const kernel_sigset_t *sigmask, long sigsetsize) {
1951   if (sigmask) PRE_READ(sigmask, sigsetsize);
1954 POST_SYSCALL(epoll_pwait)(long res, long epfd, void *events, long maxevents,
1955                           long timeout, const void *sigmask, long sigsetsize) {
1956   if (res >= 0) {
1957     if (events) POST_WRITE(events, struct_epoll_event_sz);
1958   }
1961 PRE_SYSCALL(gethostname)(void *name, long len) {}
1963 POST_SYSCALL(gethostname)(long res, void *name, long len) {
1964   if (res >= 0) {
1965     if (name)
1966       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1967   }
1970 PRE_SYSCALL(sethostname)(void *name, long len) {}
1972 POST_SYSCALL(sethostname)(long res, void *name, long len) {
1973   if (res >= 0) {
1974     if (name)
1975       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1976   }
1979 PRE_SYSCALL(setdomainname)(void *name, long len) {}
1981 POST_SYSCALL(setdomainname)(long res, void *name, long len) {
1982   if (res >= 0) {
1983     if (name)
1984       POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1);
1985   }
1988 PRE_SYSCALL(newuname)(void *name) {}
1990 POST_SYSCALL(newuname)(long res, void *name) {
1991   if (res >= 0) {
1992     if (name) POST_WRITE(name, struct_new_utsname_sz);
1993   }
1996 PRE_SYSCALL(uname)(void *arg0) {}
1998 POST_SYSCALL(uname)(long res, void *arg0) {
1999   if (res >= 0) {
2000     if (arg0) POST_WRITE(arg0, struct_old_utsname_sz);
2001   }
2004 PRE_SYSCALL(olduname)(void *arg0) {}
2006 POST_SYSCALL(olduname)(long res, void *arg0) {
2007   if (res >= 0) {
2008     if (arg0) POST_WRITE(arg0, struct_oldold_utsname_sz);
2009   }
2012 PRE_SYSCALL(getrlimit)(long resource, void *rlim) {}
2014 POST_SYSCALL(getrlimit)(long res, long resource, void *rlim) {
2015   if (res >= 0) {
2016     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2017   }
2020 PRE_SYSCALL(old_getrlimit)(long resource, void *rlim) {}
2022 POST_SYSCALL(old_getrlimit)(long res, long resource, void *rlim) {
2023   if (res >= 0) {
2024     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2025   }
2028 PRE_SYSCALL(setrlimit)(long resource, void *rlim) {}
2030 POST_SYSCALL(setrlimit)(long res, long resource, void *rlim) {
2031   if (res >= 0) {
2032     if (rlim) POST_WRITE(rlim, struct_rlimit_sz);
2033   }
2036 #if !SANITIZER_ANDROID
2037 PRE_SYSCALL(prlimit64)(long pid, long resource, const void *new_rlim,
2038                        void *old_rlim) {
2039   if (new_rlim) PRE_READ(new_rlim, struct_rlimit64_sz);
2042 POST_SYSCALL(prlimit64)(long res, long pid, long resource, const void *new_rlim,
2043                         void *old_rlim) {
2044   if (res >= 0) {
2045     if (old_rlim) POST_WRITE(old_rlim, struct_rlimit64_sz);
2046   }
2048 #endif
2050 PRE_SYSCALL(getrusage)(long who, void *ru) {}
2052 POST_SYSCALL(getrusage)(long res, long who, void *ru) {
2053   if (res >= 0) {
2054     if (ru) POST_WRITE(ru, struct_rusage_sz);
2055   }
2058 PRE_SYSCALL(umask)(long mask) {}
2060 POST_SYSCALL(umask)(long res, long mask) {}
2062 PRE_SYSCALL(msgget)(long key, long msgflg) {}
2064 POST_SYSCALL(msgget)(long res, long key, long msgflg) {}
2066 PRE_SYSCALL(msgsnd)(long msqid, void *msgp, long msgsz, long msgflg) {
2067   if (msgp) PRE_READ(msgp, msgsz);
2070 POST_SYSCALL(msgsnd)(long res, long msqid, void *msgp, long msgsz,
2071                      long msgflg) {}
2073 PRE_SYSCALL(msgrcv)(long msqid, void *msgp, long msgsz, long msgtyp,
2074                     long msgflg) {}
2076 POST_SYSCALL(msgrcv)(long res, long msqid, void *msgp, long msgsz, long msgtyp,
2077                      long msgflg) {
2078   if (res >= 0) {
2079     if (msgp) POST_WRITE(msgp, res);
2080   }
2083 PRE_SYSCALL(msgctl)(long msqid, long cmd, void *buf) {}
2085 POST_SYSCALL(msgctl)(long res, long msqid, long cmd, void *buf) {
2086   if (res >= 0) {
2087     if (buf) POST_WRITE(buf, struct_msqid_ds_sz);
2088   }
2091 PRE_SYSCALL(semget)(long key, long nsems, long semflg) {}
2093 POST_SYSCALL(semget)(long res, long key, long nsems, long semflg) {}
2095 PRE_SYSCALL(semop)(long semid, void *sops, long nsops) {}
2097 POST_SYSCALL(semop)(long res, long semid, void *sops, long nsops) {}
2099 PRE_SYSCALL(semctl)(long semid, long semnum, long cmd, void *arg) {}
2101 POST_SYSCALL(semctl)(long res, long semid, long semnum, long cmd, void *arg) {}
2103 PRE_SYSCALL(semtimedop)(long semid, void *sops, long nsops,
2104                         const void *timeout) {
2105   if (timeout) PRE_READ(timeout, struct_timespec_sz);
2108 POST_SYSCALL(semtimedop)(long res, long semid, void *sops, long nsops,
2109                          const void *timeout) {}
2111 PRE_SYSCALL(shmat)(long shmid, void *shmaddr, long shmflg) {}
2113 POST_SYSCALL(shmat)(long res, long shmid, void *shmaddr, long shmflg) {
2114   if (res >= 0) {
2115     if (shmaddr)
2116       POST_WRITE(shmaddr,
2117                  __sanitizer::internal_strlen((const char *)shmaddr) + 1);
2118   }
2121 PRE_SYSCALL(shmget)(long key, long size, long flag) {}
2123 POST_SYSCALL(shmget)(long res, long key, long size, long flag) {}
2125 PRE_SYSCALL(shmdt)(void *shmaddr) {}
2127 POST_SYSCALL(shmdt)(long res, void *shmaddr) {
2128   if (res >= 0) {
2129     if (shmaddr)
2130       POST_WRITE(shmaddr,
2131                  __sanitizer::internal_strlen((const char *)shmaddr) + 1);
2132   }
2135 PRE_SYSCALL(ipc)(long call, long first, long second, long third, void *ptr,
2136                  long fifth) {}
2138 POST_SYSCALL(ipc)(long res, long call, long first, long second, long third,
2139                   void *ptr, long fifth) {}
2141 #if !SANITIZER_ANDROID
2142 PRE_SYSCALL(shmctl)(long shmid, long cmd, void *buf) {}
2144 POST_SYSCALL(shmctl)(long res, long shmid, long cmd, void *buf) {
2145   if (res >= 0) {
2146     if (buf) POST_WRITE(buf, sizeof(__sanitizer_shmid_ds));
2147   }
2150 PRE_SYSCALL(mq_open)(const void *name, long oflag, long mode, void *attr) {
2151   if (name)
2152     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2155 POST_SYSCALL(mq_open)(long res, const void *name, long oflag, long mode,
2156                       void *attr) {
2157   if (res >= 0) {
2158     if (attr) POST_WRITE(attr, struct_mq_attr_sz);
2159   }
2162 PRE_SYSCALL(mq_unlink)(const void *name) {
2163   if (name)
2164     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2167 POST_SYSCALL(mq_unlink)(long res, const void *name) {}
2169 PRE_SYSCALL(mq_timedsend)(long mqdes, const void *msg_ptr, long msg_len,
2170                           long msg_prio, const void *abs_timeout) {
2171   if (msg_ptr) PRE_READ(msg_ptr, msg_len);
2172   if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
2175 POST_SYSCALL(mq_timedsend)(long res, long mqdes, const void *msg_ptr,
2176                            long msg_len, long msg_prio,
2177                            const void *abs_timeout) {}
2179 PRE_SYSCALL(mq_timedreceive)(long mqdes, void *msg_ptr, long msg_len,
2180                              void *msg_prio, const void *abs_timeout) {
2181   if (abs_timeout) PRE_READ(abs_timeout, struct_timespec_sz);
2184 POST_SYSCALL(mq_timedreceive)(long res, long mqdes, void *msg_ptr, long msg_len,
2185                               int *msg_prio, const void *abs_timeout) {
2186   if (res >= 0) {
2187     if (msg_ptr) POST_WRITE(msg_ptr, res);
2188     if (msg_prio) POST_WRITE(msg_prio, sizeof(*msg_prio));
2189   }
2192 PRE_SYSCALL(mq_notify)(long mqdes, const void *notification) {
2193   if (notification) PRE_READ(notification, struct_sigevent_sz);
2196 POST_SYSCALL(mq_notify)(long res, long mqdes, const void *notification) {}
2198 PRE_SYSCALL(mq_getsetattr)(long mqdes, const void *mqstat, void *omqstat) {
2199   if (mqstat) PRE_READ(mqstat, struct_mq_attr_sz);
2202 POST_SYSCALL(mq_getsetattr)(long res, long mqdes, const void *mqstat,
2203                             void *omqstat) {
2204   if (res >= 0) {
2205     if (omqstat) POST_WRITE(omqstat, struct_mq_attr_sz);
2206   }
2208 #endif  // SANITIZER_ANDROID
2210 PRE_SYSCALL(pciconfig_iobase)(long which, long bus, long devfn) {}
2212 POST_SYSCALL(pciconfig_iobase)(long res, long which, long bus, long devfn) {}
2214 PRE_SYSCALL(pciconfig_read)(long bus, long dfn, long off, long len, void *buf) {
2217 POST_SYSCALL(pciconfig_read)(long res, long bus, long dfn, long off, long len,
2218                              void *buf) {}
2220 PRE_SYSCALL(pciconfig_write)(long bus, long dfn, long off, long len,
2221                              void *buf) {}
2223 POST_SYSCALL(pciconfig_write)(long res, long bus, long dfn, long off, long len,
2224                               void *buf) {}
2226 PRE_SYSCALL(swapon)(const void *specialfile, long swap_flags) {
2227   if (specialfile)
2228     PRE_READ(specialfile,
2229              __sanitizer::internal_strlen((const char *)specialfile) + 1);
2232 POST_SYSCALL(swapon)(long res, const void *specialfile, long swap_flags) {}
2234 PRE_SYSCALL(swapoff)(const void *specialfile) {
2235   if (specialfile)
2236     PRE_READ(specialfile,
2237              __sanitizer::internal_strlen((const char *)specialfile) + 1);
2240 POST_SYSCALL(swapoff)(long res, const void *specialfile) {}
2242 PRE_SYSCALL(sysctl)(__sanitizer___sysctl_args *args) {
2243   if (args) {
2244     if (args->name) PRE_READ(args->name, args->nlen * sizeof(*args->name));
2245     if (args->newval) PRE_READ(args->name, args->newlen);
2246   }
2249 POST_SYSCALL(sysctl)(long res, __sanitizer___sysctl_args *args) {
2250   if (res >= 0) {
2251     if (args && args->oldval && args->oldlenp) {
2252       POST_WRITE(args->oldlenp, sizeof(*args->oldlenp));
2253       POST_WRITE(args->oldval, *args->oldlenp);
2254     }
2255   }
2258 PRE_SYSCALL(sysinfo)(void *info) {}
2260 POST_SYSCALL(sysinfo)(long res, void *info) {
2261   if (res >= 0) {
2262     if (info) POST_WRITE(info, struct_sysinfo_sz);
2263   }
2266 PRE_SYSCALL(sysfs)(long option, long arg1, long arg2) {}
2268 POST_SYSCALL(sysfs)(long res, long option, long arg1, long arg2) {}
2270 PRE_SYSCALL(syslog)(long type, void *buf, long len) {}
2272 POST_SYSCALL(syslog)(long res, long type, void *buf, long len) {
2273   if (res >= 0) {
2274     if (buf)
2275       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
2276   }
2279 PRE_SYSCALL(uselib)(const void *library) {
2280   if (library)
2281     PRE_READ(library, __sanitizer::internal_strlen((const char *)library) + 1);
2284 POST_SYSCALL(uselib)(long res, const void *library) {}
2286 PRE_SYSCALL(ni_syscall)() {}
2288 POST_SYSCALL(ni_syscall)(long res) {}
2290 PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) {
2291 #if defined(__i386) || defined (__x86_64)
2292   if (data) {
2293     if (request == ptrace_setregs) {
2294       PRE_READ((void *)data, struct_user_regs_struct_sz);
2295     } else if (request == ptrace_setfpregs) {
2296       PRE_READ((void *)data, struct_user_fpregs_struct_sz);
2297     } else if (request == ptrace_setfpxregs) {
2298       PRE_READ((void *)data, struct_user_fpxregs_struct_sz);
2299     } else if (request == ptrace_setsiginfo) {
2300       PRE_READ((void *)data, siginfo_t_sz);
2301     } else if (request == ptrace_setregset) {
2302       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
2303       PRE_READ(iov->iov_base, iov->iov_len);
2304     }
2305   }
2306 #endif
2309 POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) {
2310 #if defined(__i386) || defined (__x86_64)
2311   if (res >= 0 && data) {
2312     // Note that this is different from the interceptor in
2313     // sanitizer_common_interceptors.inc.
2314     // PEEK* requests return resulting values through data pointer.
2315     if (request == ptrace_getregs) {
2316       POST_WRITE((void *)data, struct_user_regs_struct_sz);
2317     } else if (request == ptrace_getfpregs) {
2318       POST_WRITE((void *)data, struct_user_fpregs_struct_sz);
2319     } else if (request == ptrace_getfpxregs) {
2320       POST_WRITE((void *)data, struct_user_fpxregs_struct_sz);
2321     } else if (request == ptrace_getsiginfo) {
2322       POST_WRITE((void *)data, siginfo_t_sz);
2323     } else if (request == ptrace_getregset) {
2324       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
2325       POST_WRITE(iov->iov_base, iov->iov_len);
2326     } else if (request == ptrace_peekdata || request == ptrace_peektext ||
2327                request == ptrace_peekuser) {
2328       POST_WRITE((void *)data, sizeof(void *));
2329     }
2330   }
2331 #endif
2334 PRE_SYSCALL(add_key)(const void *_type, const void *_description,
2335                      const void *_payload, long plen, long destringid) {
2336   if (_type)
2337     PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
2338   if (_description)
2339     PRE_READ(_description,
2340              __sanitizer::internal_strlen((const char *)_description) + 1);
2343 POST_SYSCALL(add_key)(long res, const void *_type, const void *_description,
2344                       const void *_payload, long plen, long destringid) {}
2346 PRE_SYSCALL(request_key)(const void *_type, const void *_description,
2347                          const void *_callout_info, long destringid) {
2348   if (_type)
2349     PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1);
2350   if (_description)
2351     PRE_READ(_description,
2352              __sanitizer::internal_strlen((const char *)_description) + 1);
2353   if (_callout_info)
2354     PRE_READ(_callout_info,
2355              __sanitizer::internal_strlen((const char *)_callout_info) + 1);
2358 POST_SYSCALL(request_key)(long res, const void *_type, const void *_description,
2359                           const void *_callout_info, long destringid) {}
2361 PRE_SYSCALL(keyctl)(long cmd, long arg2, long arg3, long arg4, long arg5) {}
2363 POST_SYSCALL(keyctl)(long res, long cmd, long arg2, long arg3, long arg4,
2364                      long arg5) {}
2366 PRE_SYSCALL(ioprio_set)(long which, long who, long ioprio) {}
2368 POST_SYSCALL(ioprio_set)(long res, long which, long who, long ioprio) {}
2370 PRE_SYSCALL(ioprio_get)(long which, long who) {}
2372 POST_SYSCALL(ioprio_get)(long res, long which, long who) {}
2374 PRE_SYSCALL(set_mempolicy)(long mode, void *nmask, long maxnode) {}
2376 POST_SYSCALL(set_mempolicy)(long res, long mode, void *nmask, long maxnode) {
2377   if (res >= 0) {
2378     if (nmask) POST_WRITE(nmask, sizeof(long));
2379   }
2382 PRE_SYSCALL(migrate_pages)(long pid, long maxnode, const void *from,
2383                            const void *to) {
2384   if (from) PRE_READ(from, sizeof(long));
2385   if (to) PRE_READ(to, sizeof(long));
2388 POST_SYSCALL(migrate_pages)(long res, long pid, long maxnode, const void *from,
2389                             const void *to) {}
2391 PRE_SYSCALL(move_pages)(long pid, long nr_pages, const void **pages,
2392                         const int *nodes, int *status, long flags) {
2393   if (pages) PRE_READ(pages, nr_pages * sizeof(*pages));
2394   if (nodes) PRE_READ(nodes, nr_pages * sizeof(*nodes));
2397 POST_SYSCALL(move_pages)(long res, long pid, long nr_pages, const void **pages,
2398                          const int *nodes, int *status, long flags) {
2399   if (res >= 0) {
2400     if (status) POST_WRITE(status, nr_pages * sizeof(*status));
2401   }
2404 PRE_SYSCALL(mbind)(long start, long len, long mode, void *nmask, long maxnode,
2405                    long flags) {}
2407 POST_SYSCALL(mbind)(long res, long start, long len, long mode, void *nmask,
2408                     long maxnode, long flags) {
2409   if (res >= 0) {
2410     if (nmask) POST_WRITE(nmask, sizeof(long));
2411   }
2414 PRE_SYSCALL(get_mempolicy)(void *policy, void *nmask, long maxnode, long addr,
2415                            long flags) {}
2417 POST_SYSCALL(get_mempolicy)(long res, void *policy, void *nmask, long maxnode,
2418                             long addr, long flags) {
2419   if (res >= 0) {
2420     if (policy) POST_WRITE(policy, sizeof(int));
2421     if (nmask) POST_WRITE(nmask, sizeof(long));
2422   }
2425 PRE_SYSCALL(inotify_init)() {}
2427 POST_SYSCALL(inotify_init)(long res) {}
2429 PRE_SYSCALL(inotify_init1)(long flags) {}
2431 POST_SYSCALL(inotify_init1)(long res, long flags) {}
2433 PRE_SYSCALL(inotify_add_watch)(long fd, const void *path, long mask) {
2434   if (path)
2435     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
2438 POST_SYSCALL(inotify_add_watch)(long res, long fd, const void *path,
2439                                 long mask) {}
2441 PRE_SYSCALL(inotify_rm_watch)(long fd, long wd) {}
2443 POST_SYSCALL(inotify_rm_watch)(long res, long fd, long wd) {}
2445 PRE_SYSCALL(spu_run)(long fd, void *unpc, void *ustatus) {}
2447 POST_SYSCALL(spu_run)(long res, long fd, unsigned *unpc, unsigned *ustatus) {
2448   if (res >= 0) {
2449     if (unpc) POST_WRITE(unpc, sizeof(*unpc));
2450     if (ustatus) POST_WRITE(ustatus, sizeof(*ustatus));
2451   }
2454 PRE_SYSCALL(spu_create)(const void *name, long flags, long mode, long fd) {
2455   if (name)
2456     PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1);
2459 POST_SYSCALL(spu_create)(long res, const void *name, long flags, long mode,
2460                          long fd) {}
2462 PRE_SYSCALL(mknodat)(long dfd, const void *filename, long mode, long dev) {
2463   if (filename)
2464     PRE_READ(filename,
2465              __sanitizer::internal_strlen((const char *)filename) + 1);
2468 POST_SYSCALL(mknodat)(long res, long dfd, const void *filename, long mode,
2469                       long dev) {}
2471 PRE_SYSCALL(mkdirat)(long dfd, const void *pathname, long mode) {
2472   if (pathname)
2473     PRE_READ(pathname,
2474              __sanitizer::internal_strlen((const char *)pathname) + 1);
2477 POST_SYSCALL(mkdirat)(long res, long dfd, const void *pathname, long mode) {}
2479 PRE_SYSCALL(unlinkat)(long dfd, const void *pathname, long flag) {
2480   if (pathname)
2481     PRE_READ(pathname,
2482              __sanitizer::internal_strlen((const char *)pathname) + 1);
2485 POST_SYSCALL(unlinkat)(long res, long dfd, const void *pathname, long flag) {}
2487 PRE_SYSCALL(symlinkat)(const void *oldname, long newdfd, const void *newname) {
2488   if (oldname)
2489     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2490   if (newname)
2491     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2494 POST_SYSCALL(symlinkat)(long res, const void *oldname, long newdfd,
2495                         const void *newname) {}
2497 PRE_SYSCALL(linkat)(long olddfd, const void *oldname, long newdfd,
2498                     const void *newname, long flags) {
2499   if (oldname)
2500     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2501   if (newname)
2502     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2505 POST_SYSCALL(linkat)(long res, long olddfd, const void *oldname, long newdfd,
2506                      const void *newname, long flags) {}
2508 PRE_SYSCALL(renameat)(long olddfd, const void *oldname, long newdfd,
2509                       const void *newname) {
2510   if (oldname)
2511     PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1);
2512   if (newname)
2513     PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1);
2516 POST_SYSCALL(renameat)(long res, long olddfd, const void *oldname, long newdfd,
2517                        const void *newname) {}
2519 PRE_SYSCALL(futimesat)(long dfd, const void *filename, void *utimes) {
2520   if (filename)
2521     PRE_READ(filename,
2522              __sanitizer::internal_strlen((const char *)filename) + 1);
2525 POST_SYSCALL(futimesat)(long res, long dfd, const void *filename,
2526                         void *utimes) {
2527   if (res >= 0) {
2528     if (utimes) POST_WRITE(utimes, timeval_sz);
2529   }
2532 PRE_SYSCALL(faccessat)(long dfd, const void *filename, long mode) {
2533   if (filename)
2534     PRE_READ(filename,
2535              __sanitizer::internal_strlen((const char *)filename) + 1);
2538 POST_SYSCALL(faccessat)(long res, long dfd, const void *filename, long mode) {}
2540 PRE_SYSCALL(fchmodat)(long dfd, const void *filename, long mode) {
2541   if (filename)
2542     PRE_READ(filename,
2543              __sanitizer::internal_strlen((const char *)filename) + 1);
2546 POST_SYSCALL(fchmodat)(long res, long dfd, const void *filename, long mode) {}
2548 PRE_SYSCALL(fchownat)(long dfd, const void *filename, long user, long group,
2549                       long flag) {
2550   if (filename)
2551     PRE_READ(filename,
2552              __sanitizer::internal_strlen((const char *)filename) + 1);
2555 POST_SYSCALL(fchownat)(long res, long dfd, const void *filename, long user,
2556                        long group, long flag) {}
2558 PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {
2559   if (filename)
2560     PRE_READ(filename,
2561              __sanitizer::internal_strlen((const char *)filename) + 1);
2564 POST_SYSCALL(openat)(long res, long dfd, const void *filename, long flags,
2565                      long mode) {}
2567 PRE_SYSCALL(newfstatat)(long dfd, const void *filename, void *statbuf,
2568                         long flag) {
2569   if (filename)
2570     PRE_READ(filename,
2571              __sanitizer::internal_strlen((const char *)filename) + 1);
2574 POST_SYSCALL(newfstatat)(long res, long dfd, const void *filename,
2575                          void *statbuf, long flag) {
2576   if (res >= 0) {
2577     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat_sz);
2578   }
2581 PRE_SYSCALL(fstatat64)(long dfd, const void *filename, void *statbuf,
2582                        long flag) {
2583   if (filename)
2584     PRE_READ(filename,
2585              __sanitizer::internal_strlen((const char *)filename) + 1);
2588 POST_SYSCALL(fstatat64)(long res, long dfd, const void *filename, void *statbuf,
2589                         long flag) {
2590   if (res >= 0) {
2591     if (statbuf) POST_WRITE(statbuf, struct_kernel_stat64_sz);
2592   }
2595 PRE_SYSCALL(readlinkat)(long dfd, const void *path, void *buf, long bufsiz) {
2596   if (path)
2597     PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1);
2600 POST_SYSCALL(readlinkat)(long res, long dfd, const void *path, void *buf,
2601                          long bufsiz) {
2602   if (res >= 0) {
2603     if (buf)
2604       POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1);
2605   }
2608 PRE_SYSCALL(utimensat)(long dfd, const void *filename, void *utimes,
2609                        long flags) {
2610   if (filename)
2611     PRE_READ(filename,
2612              __sanitizer::internal_strlen((const char *)filename) + 1);
2615 POST_SYSCALL(utimensat)(long res, long dfd, const void *filename, void *utimes,
2616                         long flags) {
2617   if (res >= 0) {
2618     if (utimes) POST_WRITE(utimes, struct_timespec_sz);
2619   }
2622 PRE_SYSCALL(unshare)(long unshare_flags) {}
2624 POST_SYSCALL(unshare)(long res, long unshare_flags) {}
2626 PRE_SYSCALL(splice)(long fd_in, void *off_in, long fd_out, void *off_out,
2627                     long len, long flags) {}
2629 POST_SYSCALL(splice)(long res, long fd_in, void *off_in, long fd_out,
2630                      void *off_out, long len, long flags) {
2631   if (res >= 0) {
2632     if (off_in) POST_WRITE(off_in, sizeof(long long));
2633     if (off_out) POST_WRITE(off_out, sizeof(long long));
2634   }
2637 PRE_SYSCALL(vmsplice)(long fd, const __sanitizer_iovec *iov, long nr_segs,
2638                       long flags) {}
2640 POST_SYSCALL(vmsplice)(long res, long fd, const __sanitizer_iovec *iov,
2641                        long nr_segs, long flags) {
2642   if (res >= 0) {
2643     if (iov) kernel_read_iovec(iov, nr_segs, res);
2644   }
2647 PRE_SYSCALL(tee)(long fdin, long fdout, long len, long flags) {}
2649 POST_SYSCALL(tee)(long res, long fdin, long fdout, long len, long flags) {}
2651 PRE_SYSCALL(get_robust_list)(long pid, void *head_ptr, void *len_ptr) {}
2653 POST_SYSCALL(get_robust_list)(long res, long pid, void *head_ptr,
2654                               void *len_ptr) {}
2656 PRE_SYSCALL(set_robust_list)(void *head, long len) {}
2658 POST_SYSCALL(set_robust_list)(long res, void *head, long len) {}
2660 PRE_SYSCALL(getcpu)(void *cpu, void *node, void *cache) {}
2662 POST_SYSCALL(getcpu)(long res, void *cpu, void *node, void *cache) {
2663   if (res >= 0) {
2664     if (cpu) POST_WRITE(cpu, sizeof(unsigned));
2665     if (node) POST_WRITE(node, sizeof(unsigned));
2666     // The third argument to this system call is nowadays unused.
2667   }
2670 PRE_SYSCALL(signalfd)(long ufd, void *user_mask, long sizemask) {}
2672 POST_SYSCALL(signalfd)(long res, long ufd, kernel_sigset_t *user_mask,
2673                        long sizemask) {
2674   if (res >= 0) {
2675     if (user_mask) POST_WRITE(user_mask, sizemask);
2676   }
2679 PRE_SYSCALL(signalfd4)(long ufd, void *user_mask, long sizemask, long flags) {}
2681 POST_SYSCALL(signalfd4)(long res, long ufd, kernel_sigset_t *user_mask,
2682                         long sizemask, long flags) {
2683   if (res >= 0) {
2684     if (user_mask) POST_WRITE(user_mask, sizemask);
2685   }
2688 PRE_SYSCALL(timerfd_create)(long clockid, long flags) {}
2690 POST_SYSCALL(timerfd_create)(long res, long clockid, long flags) {}
2692 PRE_SYSCALL(timerfd_settime)(long ufd, long flags, const void *utmr,
2693                              void *otmr) {
2694   if (utmr) PRE_READ(utmr, struct_itimerspec_sz);
2697 POST_SYSCALL(timerfd_settime)(long res, long ufd, long flags, const void *utmr,
2698                               void *otmr) {
2699   if (res >= 0) {
2700     if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
2701   }
2704 PRE_SYSCALL(timerfd_gettime)(long ufd, void *otmr) {}
2706 POST_SYSCALL(timerfd_gettime)(long res, long ufd, void *otmr) {
2707   if (res >= 0) {
2708     if (otmr) POST_WRITE(otmr, struct_itimerspec_sz);
2709   }
2712 PRE_SYSCALL(eventfd)(long count) {}
2714 POST_SYSCALL(eventfd)(long res, long count) {}
2716 PRE_SYSCALL(eventfd2)(long count, long flags) {}
2718 POST_SYSCALL(eventfd2)(long res, long count, long flags) {}
2720 PRE_SYSCALL(old_readdir)(long arg0, void *arg1, long arg2) {}
2722 POST_SYSCALL(old_readdir)(long res, long arg0, void *arg1, long arg2) {
2723   // Missing definition of 'struct old_linux_dirent'.
2726 PRE_SYSCALL(pselect6)(long arg0, __sanitizer___kernel_fd_set *arg1,
2727                       __sanitizer___kernel_fd_set *arg2,
2728                       __sanitizer___kernel_fd_set *arg3, void *arg4,
2729                       void *arg5) {}
2731 POST_SYSCALL(pselect6)(long res, long arg0, __sanitizer___kernel_fd_set *arg1,
2732                        __sanitizer___kernel_fd_set *arg2,
2733                        __sanitizer___kernel_fd_set *arg3, void *arg4,
2734                        void *arg5) {
2735   if (res >= 0) {
2736     if (arg1) POST_WRITE(arg1, sizeof(*arg1));
2737     if (arg2) POST_WRITE(arg2, sizeof(*arg2));
2738     if (arg3) POST_WRITE(arg3, sizeof(*arg3));
2739     if (arg4) POST_WRITE(arg4, struct_timespec_sz);
2740   }
2743 PRE_SYSCALL(ppoll)(__sanitizer_pollfd *arg0, long arg1, void *arg2,
2744                    const kernel_sigset_t *arg3, long arg4) {
2745   if (arg3) PRE_READ(arg3, arg4);
2748 POST_SYSCALL(ppoll)(long res, __sanitizer_pollfd *arg0, long arg1, void *arg2,
2749                     const void *arg3, long arg4) {
2750   if (res >= 0) {
2751     if (arg0) POST_WRITE(arg0, sizeof(*arg0));
2752     if (arg2) POST_WRITE(arg2, struct_timespec_sz);
2753   }
2756 PRE_SYSCALL(syncfs)(long fd) {}
2758 POST_SYSCALL(syncfs)(long res, long fd) {}
2760 PRE_SYSCALL(perf_event_open)(__sanitizer_perf_event_attr *attr_uptr, long pid,
2761                              long cpu, long group_fd, long flags) {
2762   if (attr_uptr) PRE_READ(attr_uptr, attr_uptr->size);
2765 POST_SYSCALL(perf_event_open)(long res, __sanitizer_perf_event_attr *attr_uptr,
2766                               long pid, long cpu, long group_fd, long flags) {}
2768 PRE_SYSCALL(mmap_pgoff)(long addr, long len, long prot, long flags, long fd,
2769                         long pgoff) {}
2771 POST_SYSCALL(mmap_pgoff)(long res, long addr, long len, long prot, long flags,
2772                          long fd, long pgoff) {}
2774 PRE_SYSCALL(old_mmap)(void *arg) {}
2776 POST_SYSCALL(old_mmap)(long res, void *arg) {}
2778 PRE_SYSCALL(name_to_handle_at)(long dfd, const void *name, void *handle,
2779                                void *mnt_id, long flag) {}
2781 POST_SYSCALL(name_to_handle_at)(long res, long dfd, const void *name,
2782                                 void *handle, void *mnt_id, long flag) {}
2784 PRE_SYSCALL(open_by_handle_at)(long mountdirfd, void *handle, long flags) {}
2786 POST_SYSCALL(open_by_handle_at)(long res, long mountdirfd, void *handle,
2787                                 long flags) {}
2789 PRE_SYSCALL(setns)(long fd, long nstype) {}
2791 POST_SYSCALL(setns)(long res, long fd, long nstype) {}
2793 PRE_SYSCALL(process_vm_readv)(long pid, const __sanitizer_iovec *lvec,
2794                               long liovcnt, const void *rvec, long riovcnt,
2795                               long flags) {}
2797 POST_SYSCALL(process_vm_readv)(long res, long pid,
2798                                const __sanitizer_iovec *lvec, long liovcnt,
2799                                const void *rvec, long riovcnt, long flags) {
2800   if (res >= 0) {
2801     if (lvec) kernel_write_iovec(lvec, liovcnt, res);
2802   }
2805 PRE_SYSCALL(process_vm_writev)(long pid, const __sanitizer_iovec *lvec,
2806                                long liovcnt, const void *rvec, long riovcnt,
2807                                long flags) {}
2809 POST_SYSCALL(process_vm_writev)(long res, long pid,
2810                                 const __sanitizer_iovec *lvec, long liovcnt,
2811                                 const void *rvec, long riovcnt, long flags) {
2812   if (res >= 0) {
2813     if (lvec) kernel_read_iovec(lvec, liovcnt, res);
2814   }
2817 PRE_SYSCALL(fork)() {
2818   COMMON_SYSCALL_PRE_FORK();
2821 POST_SYSCALL(fork)(long res) {
2822   COMMON_SYSCALL_POST_FORK(res);
2825 PRE_SYSCALL(vfork)() {
2826   COMMON_SYSCALL_PRE_FORK();
2829 POST_SYSCALL(vfork)(long res) {
2830   COMMON_SYSCALL_POST_FORK(res);
2832 }  // extern "C"
2834 #undef PRE_SYSCALL
2835 #undef PRE_READ
2836 #undef PRE_WRITE
2837 #undef POST_SYSCALL
2838 #undef POST_READ
2839 #undef POST_WRITE
2841 #endif  // SANITIZER_LINUX