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