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