| //===-- sanitizer_common_syscalls.inc ---------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Common syscalls handlers for tools like AddressSanitizer, |
| // ThreadSanitizer, MemorySanitizer, etc. |
| // |
| // This file should be included into the tool's interceptor file, |
| // which has to define it's own macros: |
| // COMMON_SYSCALL_PRE_READ_RANGE |
| // Called in prehook for regions that will be read by the kernel and |
| // must be initialized. |
| // COMMON_SYSCALL_PRE_WRITE_RANGE |
| // Called in prehook for regions that will be written to by the kernel |
| // and must be addressable. The actual write range may be smaller than |
| // reported in the prehook. See POST_WRITE_RANGE. |
| // COMMON_SYSCALL_POST_READ_RANGE |
| // Called in posthook for regions that were read by the kernel. Does |
| // not make much sense. |
| // COMMON_SYSCALL_POST_WRITE_RANGE |
| // Called in posthook for regions that were written to by the kernel |
| // and are now initialized. |
| // COMMON_SYSCALL_ACQUIRE(addr) |
| // Acquire memory visibility from addr. |
| // COMMON_SYSCALL_RELEASE(addr) |
| // Release memory visibility to addr. |
| // COMMON_SYSCALL_FD_CLOSE(fd) |
| // Called before closing file descriptor fd. |
| // COMMON_SYSCALL_FD_ACQUIRE(fd) |
| // Acquire memory visibility from fd. |
| // COMMON_SYSCALL_FD_RELEASE(fd) |
| // Release memory visibility to fd. |
| // COMMON_SYSCALL_PRE_FORK() |
| // Called before fork syscall. |
| // COMMON_SYSCALL_POST_FORK(long res) |
| // Called after fork syscall. |
| //===----------------------------------------------------------------------===// |
| |
| #include "sanitizer_platform.h" |
| #if SANITIZER_LINUX |
| |
| # include "sanitizer_libc.h" |
| |
| # define PRE_SYSCALL(name) \ |
| SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_pre_impl_##name |
| # define PRE_READ(p, s) COMMON_SYSCALL_PRE_READ_RANGE(p, s) |
| # define PRE_WRITE(p, s) COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) |
| |
| # define POST_SYSCALL(name) \ |
| SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_post_impl_##name |
| # define POST_READ(p, s) COMMON_SYSCALL_POST_READ_RANGE(p, s) |
| # define POST_WRITE(p, s) COMMON_SYSCALL_POST_WRITE_RANGE(p, s) |
| |
| # ifndef COMMON_SYSCALL_ACQUIRE |
| # define COMMON_SYSCALL_ACQUIRE(addr) ((void)(addr)) |
| # endif |
| |
| # ifndef COMMON_SYSCALL_RELEASE |
| # define COMMON_SYSCALL_RELEASE(addr) ((void)(addr)) |
| # endif |
| |
| # ifndef COMMON_SYSCALL_FD_CLOSE |
| # define COMMON_SYSCALL_FD_CLOSE(fd) ((void)(fd)) |
| # endif |
| |
| # ifndef COMMON_SYSCALL_FD_ACQUIRE |
| # define COMMON_SYSCALL_FD_ACQUIRE(fd) ((void)(fd)) |
| # endif |
| |
| # ifndef COMMON_SYSCALL_FD_RELEASE |
| # define COMMON_SYSCALL_FD_RELEASE(fd) ((void)(fd)) |
| # endif |
| |
| # ifndef COMMON_SYSCALL_PRE_FORK |
| # define COMMON_SYSCALL_PRE_FORK() \ |
| {} |
| # endif |
| |
| # ifndef COMMON_SYSCALL_POST_FORK |
| # define COMMON_SYSCALL_POST_FORK(res) \ |
| {} |
| # endif |
| |
| // FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such). |
| |
| extern "C" { |
| struct sanitizer_kernel_iovec { |
| void *iov_base; |
| unsigned long iov_len; |
| }; |
| |
| struct sanitizer_kernel_msghdr { |
| void *msg_name; |
| int msg_namelen; |
| struct sanitizer_kernel_iovec *msg_iov; |
| unsigned long msg_iovlen; |
| void *msg_control; |
| unsigned long msg_controllen; |
| unsigned msg_flags; |
| }; |
| |
| struct sanitizer_kernel_mmsghdr { |
| struct sanitizer_kernel_msghdr msg_hdr; |
| unsigned msg_len; |
| }; |
| |
| struct sanitizer_kernel_timespec { |
| long tv_sec; |
| long tv_nsec; |
| }; |
| |
| struct sanitizer_kernel_timeval { |
| long tv_sec; |
| long tv_usec; |
| }; |
| |
| struct sanitizer_kernel_rusage { |
| struct sanitizer_kernel_timeval ru_timeval[2]; |
| long ru_long[14]; |
| }; |
| |
| struct sanitizer_kernel_sockaddr { |
| unsigned short sa_family; |
| char sa_data[14]; |
| }; |
| |
| // Real sigset size is always passed as a syscall argument. |
| // Declare it "void" to catch sizeof(kernel_sigset_t). |
| typedef void kernel_sigset_t; |
| |
| static void kernel_write_iovec(const __sanitizer_iovec *iovec, SIZE_T iovlen, |
| SIZE_T maxlen) { |
| for (SIZE_T i = 0; i < iovlen && maxlen; ++i) { |
| SSIZE_T sz = Min(iovec[i].iov_len, maxlen); |
| POST_WRITE(iovec[i].iov_base, sz); |
| maxlen -= sz; |
| } |
| } |
| |
| // This functions uses POST_READ, because it needs to run after syscall to know |
| // the real read range. |
| static void kernel_read_iovec(const __sanitizer_iovec *iovec, SIZE_T iovlen, |
| SIZE_T maxlen) { |
| POST_READ(iovec, sizeof(*iovec) * iovlen); |
| for (SIZE_T i = 0; i < iovlen && maxlen; ++i) { |
| SSIZE_T sz = Min(iovec[i].iov_len, maxlen); |
| POST_READ(iovec[i].iov_base, sz); |
| maxlen -= sz; |
| } |
| } |
| |
| PRE_SYSCALL(recvmsg)(long sockfd, sanitizer_kernel_msghdr *msg, long flags) { |
| PRE_READ(msg, sizeof(*msg)); |
| } |
| |
| POST_SYSCALL(recvmsg) |
| (long res, long sockfd, sanitizer_kernel_msghdr *msg, long flags) { |
| if (res >= 0) { |
| if (msg) { |
| for (unsigned long i = 0; i < msg->msg_iovlen; ++i) { |
| POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len); |
| } |
| POST_WRITE(msg->msg_control, msg->msg_controllen); |
| } |
| } |
| } |
| |
| PRE_SYSCALL(recvmmsg) |
| (long fd, sanitizer_kernel_mmsghdr *msg, long vlen, long flags, void *timeout) { |
| PRE_READ(msg, vlen * sizeof(*msg)); |
| } |
| |
| POST_SYSCALL(recvmmsg) |
| (long res, long fd, sanitizer_kernel_mmsghdr *msg, long vlen, long flags, |
| void *timeout) { |
| if (res >= 0) { |
| if (msg) { |
| for (unsigned long i = 0; i < msg->msg_hdr.msg_iovlen; ++i) { |
| POST_WRITE(msg->msg_hdr.msg_iov[i].iov_base, |
| msg->msg_hdr.msg_iov[i].iov_len); |
| } |
| POST_WRITE(msg->msg_hdr.msg_control, msg->msg_hdr.msg_controllen); |
| POST_WRITE(&msg->msg_len, sizeof(msg->msg_len)); |
| } |
| if (timeout) |
| POST_WRITE(timeout, struct_timespec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(read)(long fd, void *buf, uptr count) { |
| if (buf) { |
| PRE_WRITE(buf, count); |
| } |
| } |
| |
| POST_SYSCALL(read)(long res, long fd, void *buf, uptr count) { |
| if (res > 0 && buf) { |
| POST_WRITE(buf, res); |
| } |
| } |
| |
| PRE_SYSCALL(time)(void *tloc) {} |
| |
| POST_SYSCALL(time)(long res, void *tloc) { |
| if (res >= 0) { |
| if (tloc) |
| POST_WRITE(tloc, sizeof(long)); |
| } |
| } |
| |
| PRE_SYSCALL(stime)(void *tptr) {} |
| |
| POST_SYSCALL(stime)(long res, void *tptr) { |
| if (res >= 0) { |
| if (tptr) |
| POST_WRITE(tptr, sizeof(long)); |
| } |
| } |
| |
| PRE_SYSCALL(gettimeofday)(void *tv, void *tz) {} |
| |
| POST_SYSCALL(gettimeofday)(long res, void *tv, void *tz) { |
| if (res >= 0) { |
| if (tv) |
| POST_WRITE(tv, timeval_sz); |
| if (tz) |
| POST_WRITE(tz, struct_timezone_sz); |
| } |
| } |
| |
| PRE_SYSCALL(settimeofday)(void *tv, void *tz) {} |
| |
| POST_SYSCALL(settimeofday)(long res, void *tv, void *tz) { |
| if (res >= 0) { |
| if (tv) |
| POST_WRITE(tv, timeval_sz); |
| if (tz) |
| POST_WRITE(tz, struct_timezone_sz); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(adjtimex)(void *txc_p) {} |
| |
| POST_SYSCALL(adjtimex)(long res, void *txc_p) { |
| if (res >= 0) { |
| if (txc_p) |
| POST_WRITE(txc_p, struct_timex_sz); |
| } |
| } |
| # endif |
| |
| PRE_SYSCALL(times)(void *tbuf) {} |
| |
| POST_SYSCALL(times)(long res, void *tbuf) { |
| if (res >= 0) { |
| if (tbuf) |
| POST_WRITE(tbuf, struct_tms_sz); |
| } |
| } |
| |
| PRE_SYSCALL(gettid)() {} |
| |
| POST_SYSCALL(gettid)(long res) {} |
| |
| PRE_SYSCALL(nanosleep)(void *rqtp, void *rmtp) {} |
| |
| POST_SYSCALL(nanosleep)(long res, void *rqtp, void *rmtp) { |
| if (res >= 0) { |
| if (rqtp) |
| POST_WRITE(rqtp, struct_timespec_sz); |
| if (rmtp) |
| POST_WRITE(rmtp, struct_timespec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(alarm)(long seconds) {} |
| |
| POST_SYSCALL(alarm)(long res, long seconds) {} |
| |
| PRE_SYSCALL(getpid)() {} |
| |
| POST_SYSCALL(getpid)(long res) {} |
| |
| PRE_SYSCALL(getppid)() {} |
| |
| POST_SYSCALL(getppid)(long res) {} |
| |
| PRE_SYSCALL(getuid)() {} |
| |
| POST_SYSCALL(getuid)(long res) {} |
| |
| PRE_SYSCALL(geteuid)() {} |
| |
| POST_SYSCALL(geteuid)(long res) {} |
| |
| PRE_SYSCALL(getgid)() {} |
| |
| POST_SYSCALL(getgid)(long res) {} |
| |
| PRE_SYSCALL(getegid)() {} |
| |
| POST_SYSCALL(getegid)(long res) {} |
| |
| PRE_SYSCALL(getresuid)(void *ruid, void *euid, void *suid) {} |
| |
| POST_SYSCALL(getresuid)(long res, void *ruid, void *euid, void *suid) { |
| if (res >= 0) { |
| if (ruid) |
| POST_WRITE(ruid, sizeof(unsigned)); |
| if (euid) |
| POST_WRITE(euid, sizeof(unsigned)); |
| if (suid) |
| POST_WRITE(suid, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(getresgid)(void *rgid, void *egid, void *sgid) {} |
| |
| POST_SYSCALL(getresgid)(long res, void *rgid, void *egid, void *sgid) { |
| if (res >= 0) { |
| if (rgid) |
| POST_WRITE(rgid, sizeof(unsigned)); |
| if (egid) |
| POST_WRITE(egid, sizeof(unsigned)); |
| if (sgid) |
| POST_WRITE(sgid, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(getpgid)(long pid) {} |
| |
| POST_SYSCALL(getpgid)(long res, long pid) {} |
| |
| PRE_SYSCALL(getpgrp)() {} |
| |
| POST_SYSCALL(getpgrp)(long res) {} |
| |
| PRE_SYSCALL(getsid)(long pid) {} |
| |
| POST_SYSCALL(getsid)(long res, long pid) {} |
| |
| PRE_SYSCALL(getgroups)(long gidsetsize, void *grouplist) {} |
| |
| POST_SYSCALL(getgroups) |
| (long res, long gidsetsize, __sanitizer___kernel_gid_t *grouplist) { |
| if (res >= 0) { |
| if (grouplist) |
| POST_WRITE(grouplist, res * sizeof(*grouplist)); |
| } |
| } |
| |
| PRE_SYSCALL(setregid)(long rgid, long egid) {} |
| |
| POST_SYSCALL(setregid)(long res, long rgid, long egid) {} |
| |
| PRE_SYSCALL(setgid)(long gid) {} |
| |
| POST_SYSCALL(setgid)(long res, long gid) {} |
| |
| PRE_SYSCALL(setreuid)(long ruid, long euid) {} |
| |
| POST_SYSCALL(setreuid)(long res, long ruid, long euid) {} |
| |
| PRE_SYSCALL(setuid)(long uid) {} |
| |
| POST_SYSCALL(setuid)(long res, long uid) {} |
| |
| PRE_SYSCALL(setresuid)(long ruid, long euid, long suid) {} |
| |
| POST_SYSCALL(setresuid)(long res, long ruid, long euid, long suid) {} |
| |
| PRE_SYSCALL(setresgid)(long rgid, long egid, long sgid) {} |
| |
| POST_SYSCALL(setresgid)(long res, long rgid, long egid, long sgid) {} |
| |
| PRE_SYSCALL(setfsuid)(long uid) {} |
| |
| POST_SYSCALL(setfsuid)(long res, long uid) {} |
| |
| PRE_SYSCALL(setfsgid)(long gid) {} |
| |
| POST_SYSCALL(setfsgid)(long res, long gid) {} |
| |
| PRE_SYSCALL(setpgid)(long pid, long pgid) {} |
| |
| POST_SYSCALL(setpgid)(long res, long pid, long pgid) {} |
| |
| PRE_SYSCALL(setsid)() {} |
| |
| POST_SYSCALL(setsid)(long res) {} |
| |
| PRE_SYSCALL(setgroups)(long gidsetsize, __sanitizer___kernel_gid_t *grouplist) { |
| if (grouplist) |
| POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist)); |
| } |
| |
| POST_SYSCALL(setgroups) |
| (long res, long gidsetsize, __sanitizer___kernel_gid_t *grouplist) {} |
| |
| PRE_SYSCALL(acct)(const void *name) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(acct)(long res, const void *name) {} |
| |
| PRE_SYSCALL(capget)(void *header, void *dataptr) { |
| if (header) |
| PRE_READ(header, __user_cap_header_struct_sz); |
| } |
| |
| POST_SYSCALL(capget)(long res, void *header, void *dataptr) { |
| if (res >= 0) |
| if (dataptr) |
| POST_WRITE(dataptr, __user_cap_data_struct_sz); |
| } |
| |
| PRE_SYSCALL(capset)(void *header, const void *data) { |
| if (header) |
| PRE_READ(header, __user_cap_header_struct_sz); |
| if (data) |
| PRE_READ(data, __user_cap_data_struct_sz); |
| } |
| |
| POST_SYSCALL(capset)(long res, void *header, const void *data) {} |
| |
| PRE_SYSCALL(personality)(long personality) {} |
| |
| POST_SYSCALL(personality)(long res, long personality) {} |
| |
| PRE_SYSCALL(sigpending)(void *set) {} |
| |
| POST_SYSCALL(sigpending)(long res, void *set) { |
| if (res >= 0) { |
| if (set) |
| POST_WRITE(set, old_sigset_t_sz); |
| } |
| } |
| |
| PRE_SYSCALL(sigprocmask)(long how, void *set, void *oset) {} |
| |
| POST_SYSCALL(sigprocmask)(long res, long how, void *set, void *oset) { |
| if (res >= 0) { |
| if (set) |
| POST_WRITE(set, old_sigset_t_sz); |
| if (oset) |
| POST_WRITE(oset, old_sigset_t_sz); |
| } |
| } |
| |
| PRE_SYSCALL(getitimer)(long which, void *value) {} |
| |
| POST_SYSCALL(getitimer)(long res, long which, void *value) { |
| if (res >= 0) { |
| if (value) |
| POST_WRITE(value, struct_itimerval_sz); |
| } |
| } |
| |
| PRE_SYSCALL(setitimer)(long which, void *value, void *ovalue) {} |
| |
| POST_SYSCALL(setitimer)(long res, long which, void *value, void *ovalue) { |
| if (res >= 0) { |
| if (value) |
| POST_WRITE(value, struct_itimerval_sz); |
| if (ovalue) |
| POST_WRITE(ovalue, struct_itimerval_sz); |
| } |
| } |
| |
| PRE_SYSCALL(timer_create) |
| (long which_clock, void *timer_event_spec, void *created_timer_id) {} |
| |
| POST_SYSCALL(timer_create) |
| (long res, long which_clock, void *timer_event_spec, void *created_timer_id) { |
| if (res >= 0) { |
| if (timer_event_spec) |
| POST_WRITE(timer_event_spec, struct_sigevent_sz); |
| if (created_timer_id) |
| POST_WRITE(created_timer_id, sizeof(long)); |
| } |
| } |
| |
| PRE_SYSCALL(timer_gettime)(long timer_id, void *setting) {} |
| |
| POST_SYSCALL(timer_gettime)(long res, long timer_id, void *setting) { |
| if (res >= 0) { |
| if (setting) |
| POST_WRITE(setting, struct_itimerspec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(timer_getoverrun)(long timer_id) {} |
| |
| POST_SYSCALL(timer_getoverrun)(long res, long timer_id) {} |
| |
| PRE_SYSCALL(timer_settime) |
| (long timer_id, long flags, const void *new_setting, void *old_setting) { |
| if (new_setting) |
| PRE_READ(new_setting, struct_itimerspec_sz); |
| } |
| |
| POST_SYSCALL(timer_settime) |
| (long res, long timer_id, long flags, const void *new_setting, |
| void *old_setting) { |
| if (res >= 0) { |
| if (old_setting) |
| POST_WRITE(old_setting, struct_itimerspec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(timer_delete)(long timer_id) {} |
| |
| POST_SYSCALL(timer_delete)(long res, long timer_id) {} |
| |
| PRE_SYSCALL(clock_settime)(long which_clock, const void *tp) { |
| if (tp) |
| PRE_READ(tp, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(clock_settime)(long res, long which_clock, const void *tp) {} |
| |
| PRE_SYSCALL(clock_gettime)(long which_clock, void *tp) {} |
| |
| POST_SYSCALL(clock_gettime)(long res, long which_clock, void *tp) { |
| if (res >= 0) { |
| if (tp) |
| POST_WRITE(tp, struct_timespec_sz); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(clock_adjtime)(long which_clock, void *tx) {} |
| |
| POST_SYSCALL(clock_adjtime)(long res, long which_clock, void *tx) { |
| if (res >= 0) { |
| if (tx) |
| POST_WRITE(tx, struct_timex_sz); |
| } |
| } |
| # endif |
| |
| PRE_SYSCALL(clock_getres)(long which_clock, void *tp) {} |
| |
| POST_SYSCALL(clock_getres)(long res, long which_clock, void *tp) { |
| if (res >= 0) { |
| if (tp) |
| POST_WRITE(tp, struct_timespec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(clock_nanosleep) |
| (long which_clock, long flags, const void *rqtp, void *rmtp) { |
| if (rqtp) |
| PRE_READ(rqtp, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(clock_nanosleep) |
| (long res, long which_clock, long flags, const void *rqtp, void *rmtp) { |
| if (res >= 0) { |
| if (rmtp) |
| POST_WRITE(rmtp, struct_timespec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(nice)(long increment) {} |
| |
| POST_SYSCALL(nice)(long res, long increment) {} |
| |
| PRE_SYSCALL(sched_setscheduler)(long pid, long policy, void *param) {} |
| |
| POST_SYSCALL(sched_setscheduler)(long res, long pid, long policy, void *param) { |
| if (res >= 0) { |
| if (param) |
| POST_WRITE(param, struct_sched_param_sz); |
| } |
| } |
| |
| PRE_SYSCALL(sched_setparam)(long pid, void *param) { |
| if (param) |
| PRE_READ(param, struct_sched_param_sz); |
| } |
| |
| POST_SYSCALL(sched_setparam)(long res, long pid, void *param) {} |
| |
| PRE_SYSCALL(sched_getscheduler)(long pid) {} |
| |
| POST_SYSCALL(sched_getscheduler)(long res, long pid) {} |
| |
| PRE_SYSCALL(sched_getparam)(long pid, void *param) {} |
| |
| POST_SYSCALL(sched_getparam)(long res, long pid, void *param) { |
| if (res >= 0) { |
| if (param) |
| POST_WRITE(param, struct_sched_param_sz); |
| } |
| } |
| |
| PRE_SYSCALL(sched_setaffinity)(long pid, long len, void *user_mask_ptr) { |
| if (user_mask_ptr) |
| PRE_READ(user_mask_ptr, len); |
| } |
| |
| POST_SYSCALL(sched_setaffinity) |
| (long res, long pid, long len, void *user_mask_ptr) {} |
| |
| PRE_SYSCALL(sched_getaffinity)(long pid, long len, void *user_mask_ptr) {} |
| |
| POST_SYSCALL(sched_getaffinity) |
| (long res, long pid, long len, void *user_mask_ptr) { |
| if (res >= 0) { |
| if (user_mask_ptr) |
| POST_WRITE(user_mask_ptr, len); |
| } |
| } |
| |
| PRE_SYSCALL(sched_yield)() {} |
| |
| POST_SYSCALL(sched_yield)(long res) {} |
| |
| PRE_SYSCALL(sched_get_priority_max)(long policy) {} |
| |
| POST_SYSCALL(sched_get_priority_max)(long res, long policy) {} |
| |
| PRE_SYSCALL(sched_get_priority_min)(long policy) {} |
| |
| POST_SYSCALL(sched_get_priority_min)(long res, long policy) {} |
| |
| PRE_SYSCALL(sched_rr_get_interval)(long pid, void *interval) {} |
| |
| POST_SYSCALL(sched_rr_get_interval)(long res, long pid, void *interval) { |
| if (res >= 0) { |
| if (interval) |
| POST_WRITE(interval, struct_timespec_sz); |
| } |
| } |
| |
| PRE_SYSCALL(setpriority)(long which, long who, long niceval) {} |
| |
| POST_SYSCALL(setpriority)(long res, long which, long who, long niceval) {} |
| |
| PRE_SYSCALL(getpriority)(long which, long who) {} |
| |
| POST_SYSCALL(getpriority)(long res, long which, long who) {} |
| |
| PRE_SYSCALL(shutdown)(long arg0, long arg1) {} |
| |
| POST_SYSCALL(shutdown)(long res, long arg0, long arg1) {} |
| |
| PRE_SYSCALL(reboot)(long magic1, long magic2, long cmd, void *arg) {} |
| |
| POST_SYSCALL(reboot)(long res, long magic1, long magic2, long cmd, void *arg) {} |
| |
| PRE_SYSCALL(restart_syscall)() {} |
| |
| POST_SYSCALL(restart_syscall)(long res) {} |
| |
| PRE_SYSCALL(kexec_load) |
| (long entry, long nr_segments, void *segments, long flags) {} |
| |
| POST_SYSCALL(kexec_load) |
| (long res, long entry, long nr_segments, void *segments, long flags) { |
| if (res >= 0) { |
| if (segments) |
| POST_WRITE(segments, struct_kexec_segment_sz); |
| } |
| } |
| |
| PRE_SYSCALL(exit)(long error_code) {} |
| |
| POST_SYSCALL(exit)(long res, long error_code) {} |
| |
| PRE_SYSCALL(exit_group)(long error_code) {} |
| |
| POST_SYSCALL(exit_group)(long res, long error_code) {} |
| |
| PRE_SYSCALL(wait4)(long pid, void *stat_addr, long options, void *ru) {} |
| |
| POST_SYSCALL(wait4) |
| (long res, long pid, void *stat_addr, long options, void *ru) { |
| if (res >= 0) { |
| if (stat_addr) |
| POST_WRITE(stat_addr, sizeof(int)); |
| if (ru) |
| POST_WRITE(ru, struct_rusage_sz); |
| } |
| } |
| |
| PRE_SYSCALL(waitid) |
| (long which, long pid, void *infop, long options, void *ru) {} |
| |
| POST_SYSCALL(waitid) |
| (long res, long which, long pid, void *infop, long options, void *ru) { |
| if (res >= 0) { |
| if (infop) |
| POST_WRITE(infop, siginfo_t_sz); |
| if (ru) |
| POST_WRITE(ru, struct_rusage_sz); |
| } |
| } |
| |
| PRE_SYSCALL(waitpid)(long pid, void *stat_addr, long options) {} |
| |
| POST_SYSCALL(waitpid)(long res, long pid, void *stat_addr, long options) { |
| if (res >= 0) { |
| if (stat_addr) |
| POST_WRITE(stat_addr, sizeof(int)); |
| } |
| } |
| |
| PRE_SYSCALL(set_tid_address)(void *tidptr) {} |
| |
| POST_SYSCALL(set_tid_address)(long res, void *tidptr) { |
| if (res >= 0) { |
| if (tidptr) |
| POST_WRITE(tidptr, sizeof(int)); |
| } |
| } |
| |
| PRE_SYSCALL(init_module)(void *umod, long len, const void *uargs) { |
| if (uargs) |
| PRE_READ(uargs, __sanitizer::internal_strlen((const char *)uargs) + 1); |
| } |
| |
| POST_SYSCALL(init_module)(long res, void *umod, long len, const void *uargs) {} |
| |
| PRE_SYSCALL(delete_module)(const void *name_user, long flags) { |
| if (name_user) |
| PRE_READ(name_user, |
| __sanitizer::internal_strlen((const char *)name_user) + 1); |
| } |
| |
| POST_SYSCALL(delete_module)(long res, const void *name_user, long flags) {} |
| |
| PRE_SYSCALL(rt_sigprocmask)(long how, void *set, void *oset, long sigsetsize) {} |
| |
| POST_SYSCALL(rt_sigprocmask) |
| (long res, long how, kernel_sigset_t *set, kernel_sigset_t *oset, |
| long sigsetsize) { |
| if (res >= 0) { |
| if (set) |
| POST_WRITE(set, sigsetsize); |
| if (oset) |
| POST_WRITE(oset, sigsetsize); |
| } |
| } |
| |
| PRE_SYSCALL(rt_sigpending)(void *set, long sigsetsize) {} |
| |
| POST_SYSCALL(rt_sigpending)(long res, kernel_sigset_t *set, long sigsetsize) { |
| if (res >= 0) { |
| if (set) |
| POST_WRITE(set, sigsetsize); |
| } |
| } |
| |
| PRE_SYSCALL(rt_sigtimedwait) |
| (const kernel_sigset_t *uthese, void *uinfo, const void *uts, long sigsetsize) { |
| if (uthese) |
| PRE_READ(uthese, sigsetsize); |
| if (uts) |
| PRE_READ(uts, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(rt_sigtimedwait) |
| (long res, const void *uthese, void *uinfo, const void *uts, long sigsetsize) { |
| if (res >= 0) { |
| if (uinfo) |
| POST_WRITE(uinfo, siginfo_t_sz); |
| } |
| } |
| |
| PRE_SYSCALL(rt_tgsigqueueinfo)(long tgid, long pid, long sig, void *uinfo) {} |
| |
| POST_SYSCALL(rt_tgsigqueueinfo) |
| (long res, long tgid, long pid, long sig, void *uinfo) { |
| if (res >= 0) { |
| if (uinfo) |
| POST_WRITE(uinfo, siginfo_t_sz); |
| } |
| } |
| |
| PRE_SYSCALL(kill)(long pid, long sig) {} |
| |
| POST_SYSCALL(kill)(long res, long pid, long sig) {} |
| |
| PRE_SYSCALL(tgkill)(long tgid, long pid, long sig) {} |
| |
| POST_SYSCALL(tgkill)(long res, long tgid, long pid, long sig) {} |
| |
| PRE_SYSCALL(tkill)(long pid, long sig) {} |
| |
| POST_SYSCALL(tkill)(long res, long pid, long sig) {} |
| |
| PRE_SYSCALL(rt_sigqueueinfo)(long pid, long sig, void *uinfo) {} |
| |
| POST_SYSCALL(rt_sigqueueinfo)(long res, long pid, long sig, void *uinfo) { |
| if (res >= 0) { |
| if (uinfo) |
| POST_WRITE(uinfo, siginfo_t_sz); |
| } |
| } |
| |
| PRE_SYSCALL(sgetmask)() {} |
| |
| POST_SYSCALL(sgetmask)(long res) {} |
| |
| PRE_SYSCALL(ssetmask)(long newmask) {} |
| |
| POST_SYSCALL(ssetmask)(long res, long newmask) {} |
| |
| PRE_SYSCALL(signal)(long sig, long handler) {} |
| |
| POST_SYSCALL(signal)(long res, long sig, long handler) {} |
| |
| PRE_SYSCALL(pause)() {} |
| |
| POST_SYSCALL(pause)(long res) {} |
| |
| PRE_SYSCALL(sync)() {} |
| |
| POST_SYSCALL(sync)(long res) {} |
| |
| PRE_SYSCALL(fsync)(long fd) {} |
| |
| POST_SYSCALL(fsync)(long res, long fd) {} |
| |
| PRE_SYSCALL(fdatasync)(long fd) {} |
| |
| POST_SYSCALL(fdatasync)(long res, long fd) {} |
| |
| PRE_SYSCALL(bdflush)(long func, long data) {} |
| |
| POST_SYSCALL(bdflush)(long res, long func, long data) {} |
| |
| PRE_SYSCALL(mount) |
| (void *dev_name, void *dir_name, void *type, long flags, void *data) {} |
| |
| POST_SYSCALL(mount) |
| (long res, void *dev_name, void *dir_name, void *type, long flags, void *data) { |
| if (res >= 0) { |
| if (dev_name) |
| POST_WRITE(dev_name, |
| __sanitizer::internal_strlen((const char *)dev_name) + 1); |
| if (dir_name) |
| POST_WRITE(dir_name, |
| __sanitizer::internal_strlen((const char *)dir_name) + 1); |
| if (type) |
| POST_WRITE(type, __sanitizer::internal_strlen((const char *)type) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(umount)(void *name, long flags) {} |
| |
| POST_SYSCALL(umount)(long res, void *name, long flags) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(oldumount)(void *name) {} |
| |
| POST_SYSCALL(oldumount)(long res, void *name) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(truncate)(const void *path, long length) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(truncate)(long res, const void *path, long length) {} |
| |
| PRE_SYSCALL(ftruncate)(long fd, long length) {} |
| |
| POST_SYSCALL(ftruncate)(long res, long fd, long length) {} |
| |
| PRE_SYSCALL(stat)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(stat)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct___old_kernel_stat_sz); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(statfs)(const void *path, void *buf) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(statfs)(long res, const void *path, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, struct_statfs_sz); |
| } |
| } |
| |
| PRE_SYSCALL(statfs64)(const void *path, long sz, void *buf) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(statfs64)(long res, const void *path, long sz, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, struct_statfs64_sz); |
| } |
| } |
| |
| PRE_SYSCALL(fstatfs)(long fd, void *buf) {} |
| |
| POST_SYSCALL(fstatfs)(long res, long fd, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, struct_statfs_sz); |
| } |
| } |
| |
| PRE_SYSCALL(fstatfs64)(long fd, long sz, void *buf) {} |
| |
| POST_SYSCALL(fstatfs64)(long res, long fd, long sz, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, struct_statfs64_sz); |
| } |
| } |
| # endif // !SANITIZER_ANDROID |
| |
| PRE_SYSCALL(lstat)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(lstat)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct___old_kernel_stat_sz); |
| } |
| } |
| |
| PRE_SYSCALL(fstat)(long fd, void *statbuf) {} |
| |
| POST_SYSCALL(fstat)(long res, long fd, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct___old_kernel_stat_sz); |
| } |
| } |
| |
| PRE_SYSCALL(newstat)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(newstat)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat_sz); |
| } |
| } |
| |
| PRE_SYSCALL(newlstat)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(newlstat)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat_sz); |
| } |
| } |
| |
| PRE_SYSCALL(newfstat)(long fd, void *statbuf) {} |
| |
| POST_SYSCALL(newfstat)(long res, long fd, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat_sz); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(ustat)(long dev, void *ubuf) {} |
| |
| POST_SYSCALL(ustat)(long res, long dev, void *ubuf) { |
| if (res >= 0) { |
| if (ubuf) |
| POST_WRITE(ubuf, struct_ustat_sz); |
| } |
| } |
| # endif // !SANITIZER_ANDROID |
| |
| PRE_SYSCALL(stat64)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(stat64)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat64_sz); |
| } |
| } |
| |
| PRE_SYSCALL(fstat64)(long fd, void *statbuf) {} |
| |
| POST_SYSCALL(fstat64)(long res, long fd, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat64_sz); |
| } |
| } |
| |
| PRE_SYSCALL(lstat64)(const void *filename, void *statbuf) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(lstat64)(long res, const void *filename, void *statbuf) { |
| if (res >= 0) { |
| if (statbuf) |
| POST_WRITE(statbuf, struct_kernel_stat64_sz); |
| } |
| } |
| |
| PRE_SYSCALL(setxattr) |
| (const void *path, const void *name, const void *value, long size, long flags) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| if (value) |
| PRE_READ(value, size); |
| } |
| |
| POST_SYSCALL(setxattr) |
| (long res, const void *path, const void *name, const void *value, long size, |
| long flags) {} |
| |
| PRE_SYSCALL(lsetxattr) |
| (const void *path, const void *name, const void *value, long size, long flags) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| if (value) |
| PRE_READ(value, size); |
| } |
| |
| POST_SYSCALL(lsetxattr) |
| (long res, const void *path, const void *name, const void *value, long size, |
| long flags) {} |
| |
| PRE_SYSCALL(fsetxattr) |
| (long fd, const void *name, const void *value, long size, long flags) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| if (value) |
| PRE_READ(value, size); |
| } |
| |
| POST_SYSCALL(fsetxattr) |
| (long res, long fd, const void *name, const void *value, long size, |
| long flags) {} |
| |
| PRE_SYSCALL(getxattr) |
| (const void *path, const void *name, void *value, long size) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(getxattr) |
| (long res, const void *path, const void *name, void *value, long size) { |
| if (size && res > 0) { |
| if (value) |
| POST_WRITE(value, res); |
| } |
| } |
| |
| PRE_SYSCALL(lgetxattr) |
| (const void *path, const void *name, void *value, long size) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(lgetxattr) |
| (long res, const void *path, const void *name, void *value, long size) { |
| if (size && res > 0) { |
| if (value) |
| POST_WRITE(value, res); |
| } |
| } |
| |
| PRE_SYSCALL(fgetxattr)(long fd, const void *name, void *value, long size) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(fgetxattr) |
| (long res, long fd, const void *name, void *value, long size) { |
| if (size && res > 0) { |
| if (value) |
| POST_WRITE(value, res); |
| } |
| } |
| |
| PRE_SYSCALL(listxattr)(const void *path, void *list, long size) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(listxattr)(long res, const void *path, void *list, long size) { |
| if (size && res > 0) { |
| if (list) |
| POST_WRITE(list, res); |
| } |
| } |
| |
| PRE_SYSCALL(llistxattr)(const void *path, void *list, long size) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(llistxattr)(long res, const void *path, void *list, long size) { |
| if (size && res > 0) { |
| if (list) |
| POST_WRITE(list, res); |
| } |
| } |
| |
| PRE_SYSCALL(flistxattr)(long fd, void *list, long size) {} |
| |
| POST_SYSCALL(flistxattr)(long res, long fd, void *list, long size) { |
| if (size && res > 0) { |
| if (list) |
| POST_WRITE(list, res); |
| } |
| } |
| |
| PRE_SYSCALL(removexattr)(const void *path, const void *name) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(removexattr)(long res, const void *path, const void *name) {} |
| |
| PRE_SYSCALL(lremovexattr)(const void *path, const void *name) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(lremovexattr)(long res, const void *path, const void *name) {} |
| |
| PRE_SYSCALL(fremovexattr)(long fd, const void *name) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(fremovexattr)(long res, long fd, const void *name) {} |
| |
| PRE_SYSCALL(brk)(long brk) {} |
| |
| POST_SYSCALL(brk)(long res, long brk) {} |
| |
| PRE_SYSCALL(mprotect)(long start, long len, long prot) {} |
| |
| POST_SYSCALL(mprotect)(long res, long start, long len, long prot) {} |
| |
| PRE_SYSCALL(mremap) |
| (long addr, long old_len, long new_len, long flags, long new_addr) {} |
| |
| POST_SYSCALL(mremap) |
| (long res, long addr, long old_len, long new_len, long flags, long new_addr) {} |
| |
| PRE_SYSCALL(remap_file_pages) |
| (long start, long size, long prot, long pgoff, long flags) {} |
| |
| POST_SYSCALL(remap_file_pages) |
| (long res, long start, long size, long prot, long pgoff, long flags) {} |
| |
| PRE_SYSCALL(msync)(long start, long len, long flags) {} |
| |
| POST_SYSCALL(msync)(long res, long start, long len, long flags) {} |
| |
| PRE_SYSCALL(munmap)(long addr, long len) {} |
| |
| POST_SYSCALL(munmap)(long res, long addr, long len) {} |
| |
| PRE_SYSCALL(mlock)(long start, long len) {} |
| |
| POST_SYSCALL(mlock)(long res, long start, long len) {} |
| |
| PRE_SYSCALL(munlock)(long start, long len) {} |
| |
| POST_SYSCALL(munlock)(long res, long start, long len) {} |
| |
| PRE_SYSCALL(mlockall)(long flags) {} |
| |
| POST_SYSCALL(mlockall)(long res, long flags) {} |
| |
| PRE_SYSCALL(munlockall)() {} |
| |
| POST_SYSCALL(munlockall)(long res) {} |
| |
| PRE_SYSCALL(madvise)(long start, long len, long behavior) {} |
| |
| POST_SYSCALL(madvise)(long res, long start, long len, long behavior) {} |
| |
| PRE_SYSCALL(mincore)(long start, long len, void *vec) {} |
| |
| POST_SYSCALL(mincore)(long res, long start, long len, void *vec) { |
| if (res >= 0) { |
| if (vec) { |
| POST_WRITE(vec, (len + GetPageSizeCached() - 1) / GetPageSizeCached()); |
| } |
| } |
| } |
| |
| PRE_SYSCALL(pivot_root)(const void *new_root, const void *put_old) { |
| if (new_root) |
| PRE_READ(new_root, |
| __sanitizer::internal_strlen((const char *)new_root) + 1); |
| if (put_old) |
| PRE_READ(put_old, __sanitizer::internal_strlen((const char *)put_old) + 1); |
| } |
| |
| POST_SYSCALL(pivot_root)(long res, const void *new_root, const void *put_old) {} |
| |
| PRE_SYSCALL(chroot)(const void *filename) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(chroot)(long res, const void *filename) {} |
| |
| PRE_SYSCALL(mknod)(const void *filename, long mode, long dev) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(mknod)(long res, const void *filename, long mode, long dev) {} |
| |
| PRE_SYSCALL(link)(const void *oldname, const void *newname) { |
| if (oldname) |
| PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1); |
| if (newname) |
| PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1); |
| } |
| |
| POST_SYSCALL(link)(long res, const void *oldname, const void *newname) {} |
| |
| PRE_SYSCALL(symlink)(const void *old, const void *new_) { |
| if (old) |
| PRE_READ(old, __sanitizer::internal_strlen((const char *)old) + 1); |
| if (new_) |
| PRE_READ(new_, __sanitizer::internal_strlen((const char *)new_) + 1); |
| } |
| |
| POST_SYSCALL(symlink)(long res, const void *old, const void *new_) {} |
| |
| PRE_SYSCALL(unlink)(const void *pathname) { |
| if (pathname) |
| PRE_READ(pathname, |
| __sanitizer::internal_strlen((const char *)pathname) + 1); |
| } |
| |
| POST_SYSCALL(unlink)(long res, const void *pathname) {} |
| |
| PRE_SYSCALL(rename)(const void *oldname, const void *newname) { |
| if (oldname) |
| PRE_READ(oldname, __sanitizer::internal_strlen((const char *)oldname) + 1); |
| if (newname) |
| PRE_READ(newname, __sanitizer::internal_strlen((const char *)newname) + 1); |
| } |
| |
| POST_SYSCALL(rename)(long res, const void *oldname, const void *newname) {} |
| |
| PRE_SYSCALL(chmod)(const void *filename, long mode) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(chmod)(long res, const void *filename, long mode) {} |
| |
| PRE_SYSCALL(fchmod)(long fd, long mode) {} |
| |
| POST_SYSCALL(fchmod)(long res, long fd, long mode) {} |
| |
| PRE_SYSCALL(fcntl)(long fd, long cmd, long arg) {} |
| |
| POST_SYSCALL(fcntl)(long res, long fd, long cmd, long arg) {} |
| |
| PRE_SYSCALL(fcntl64)(long fd, long cmd, long arg) {} |
| |
| POST_SYSCALL(fcntl64)(long res, long fd, long cmd, long arg) {} |
| |
| PRE_SYSCALL(pipe)(void *fildes) {} |
| |
| POST_SYSCALL(pipe)(long res, void *fildes) { |
| if (res >= 0) |
| if (fildes) |
| POST_WRITE(fildes, sizeof(int) * 2); |
| } |
| |
| PRE_SYSCALL(pipe2)(void *fildes, long flags) {} |
| |
| POST_SYSCALL(pipe2)(long res, void *fildes, long flags) { |
| if (res >= 0) |
| if (fildes) |
| POST_WRITE(fildes, sizeof(int) * 2); |
| } |
| |
| PRE_SYSCALL(dup)(long fildes) {} |
| |
| POST_SYSCALL(dup)(long res, long fildes) {} |
| |
| PRE_SYSCALL(dup2)(long oldfd, long newfd) {} |
| |
| POST_SYSCALL(dup2)(long res, long oldfd, long newfd) {} |
| |
| PRE_SYSCALL(dup3)(long oldfd, long newfd, long flags) {} |
| |
| POST_SYSCALL(dup3)(long res, long oldfd, long newfd, long flags) {} |
| |
| PRE_SYSCALL(ioperm)(long from, long num, long on) {} |
| |
| POST_SYSCALL(ioperm)(long res, long from, long num, long on) {} |
| |
| PRE_SYSCALL(ioctl)(long fd, long cmd, long arg) {} |
| |
| POST_SYSCALL(ioctl)(long res, long fd, long cmd, long arg) {} |
| |
| PRE_SYSCALL(flock)(long fd, long cmd) {} |
| |
| POST_SYSCALL(flock)(long res, long fd, long cmd) {} |
| |
| PRE_SYSCALL(io_setup)(long nr_reqs, void **ctx) { |
| if (ctx) |
| PRE_WRITE(ctx, sizeof(*ctx)); |
| } |
| |
| POST_SYSCALL(io_setup)(long res, long nr_reqs, void **ctx) { |
| if (res >= 0) { |
| if (ctx) |
| POST_WRITE(ctx, sizeof(*ctx)); |
| // (*ctx) is actually a pointer to a kernel mapped page, and there are |
| // people out there who are crazy enough to peek into that page's 32-byte |
| // header. |
| if (*ctx) |
| POST_WRITE(*ctx, 32); |
| } |
| } |
| |
| PRE_SYSCALL(io_destroy)(long ctx) {} |
| |
| POST_SYSCALL(io_destroy)(long res, long ctx) {} |
| |
| PRE_SYSCALL(io_getevents) |
| (long ctx_id, long min_nr, long nr, __sanitizer_io_event *ioevpp, |
| void *timeout) { |
| if (timeout) |
| PRE_READ(timeout, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(io_getevents) |
| (long res, long ctx_id, long min_nr, long nr, __sanitizer_io_event *ioevpp, |
| void *timeout) { |
| if (res >= 0) { |
| if (ioevpp) |
| POST_WRITE(ioevpp, res * sizeof(*ioevpp)); |
| if (timeout) |
| POST_WRITE(timeout, struct_timespec_sz); |
| } |
| for (long i = 0; i < res; i++) { |
| // We synchronize io_submit -> io_getevents/io_cancel using the |
| // user-provided data context. Data is not necessary a pointer, it can be |
| // an int, 0 or whatever; acquire/release will correctly handle this. |
| // This scheme can lead to false negatives, e.g. when all operations |
| // synchronize on 0. But there does not seem to be a better solution |
| // (except wrapping all operations in own context, which is unreliable). |
| // We can not reliably extract fildes in io_getevents. |
| COMMON_SYSCALL_ACQUIRE((void *)ioevpp[i].data); |
| } |
| } |
| |
| PRE_SYSCALL(io_submit)(long ctx_id, long nr, __sanitizer_iocb **iocbpp) { |
| for (long i = 0; i < nr; ++i) { |
| uptr op = iocbpp[i]->aio_lio_opcode; |
| void *data = (void *)iocbpp[i]->aio_data; |
| void *buf = (void *)iocbpp[i]->aio_buf; |
| uptr len = (uptr)iocbpp[i]->aio_nbytes; |
| if (op == iocb_cmd_pwrite && buf && len) { |
| PRE_READ(buf, len); |
| } else if (op == iocb_cmd_pread && buf && len) { |
| POST_WRITE(buf, len); |
| } else if (op == iocb_cmd_pwritev) { |
| __sanitizer_iovec *iovec = (__sanitizer_iovec *)buf; |
| for (uptr v = 0; v < len; v++) |
| PRE_READ(iovec[v].iov_base, iovec[v].iov_len); |
| } else if (op == iocb_cmd_preadv) { |
| __sanitizer_iovec *iovec = (__sanitizer_iovec *)buf; |
| for (uptr v = 0; v < len; v++) |
| POST_WRITE(iovec[v].iov_base, iovec[v].iov_len); |
| } |
| // See comment in io_getevents. |
| COMMON_SYSCALL_RELEASE(data); |
| } |
| } |
| |
| POST_SYSCALL(io_submit) |
| (long res, long ctx_id, long nr, __sanitizer_iocb **iocbpp) {} |
| |
| PRE_SYSCALL(io_cancel) |
| (long ctx_id, __sanitizer_iocb *iocb, __sanitizer_io_event *result) {} |
| |
| POST_SYSCALL(io_cancel) |
| (long res, long ctx_id, __sanitizer_iocb *iocb, __sanitizer_io_event *result) { |
| if (res == 0) { |
| if (result) { |
| // See comment in io_getevents. |
| COMMON_SYSCALL_ACQUIRE((void *)result->data); |
| POST_WRITE(result, sizeof(*result)); |
| } |
| if (iocb) |
| POST_WRITE(iocb, sizeof(*iocb)); |
| } |
| } |
| |
| PRE_SYSCALL(sendfile)(long out_fd, long in_fd, void *offset, long count) {} |
| |
| POST_SYSCALL(sendfile) |
| (long res, long out_fd, long in_fd, __sanitizer___kernel_off_t *offset, |
| long count) { |
| if (res >= 0) { |
| if (offset) |
| POST_WRITE(offset, sizeof(*offset)); |
| } |
| } |
| |
| PRE_SYSCALL(sendfile64)(long out_fd, long in_fd, void *offset, long count) {} |
| |
| POST_SYSCALL(sendfile64) |
| (long res, long out_fd, long in_fd, __sanitizer___kernel_loff_t *offset, |
| long count) { |
| if (res >= 0) { |
| if (offset) |
| POST_WRITE(offset, sizeof(*offset)); |
| } |
| } |
| |
| PRE_SYSCALL(readlink)(const void *path, void *buf, long bufsiz) { |
| if (path) |
| PRE_READ(path, __sanitizer::internal_strlen((const char *)path) + 1); |
| } |
| |
| POST_SYSCALL(readlink)(long res, const void *path, void *buf, long bufsiz) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(creat)(const void *pathname, long mode) { |
| if (pathname) |
| PRE_READ(pathname, |
| __sanitizer::internal_strlen((const char *)pathname) + 1); |
| } |
| |
| POST_SYSCALL(creat)(long res, const void *pathname, long mode) {} |
| |
| PRE_SYSCALL(open)(const void *filename, long flags, long mode) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(open)(long res, const void *filename, long flags, long mode) {} |
| |
| PRE_SYSCALL(close)(long fd) { COMMON_SYSCALL_FD_CLOSE((int)fd); } |
| |
| POST_SYSCALL(close)(long res, long fd) {} |
| |
| PRE_SYSCALL(access)(const void *filename, long mode) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(access)(long res, const void *filename, long mode) {} |
| |
| PRE_SYSCALL(vhangup)() {} |
| |
| POST_SYSCALL(vhangup)(long res) {} |
| |
| PRE_SYSCALL(chown)(const void *filename, long user, long group) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(chown)(long res, const void *filename, long user, long group) {} |
| |
| PRE_SYSCALL(lchown)(const void *filename, long user, long group) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(lchown)(long res, const void *filename, long user, long group) {} |
| |
| PRE_SYSCALL(fchown)(long fd, long user, long group) {} |
| |
| POST_SYSCALL(fchown)(long res, long fd, long user, long group) {} |
| |
| # if SANITIZER_USES_UID16_SYSCALLS |
| PRE_SYSCALL(chown16)(const void *filename, long user, long group) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(chown16)(long res, const void *filename, long user, long group) {} |
| |
| PRE_SYSCALL(lchown16)(const void *filename, long user, long group) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(lchown16)(long res, const void *filename, long user, long group) {} |
| |
| PRE_SYSCALL(fchown16)(long fd, long user, long group) {} |
| |
| POST_SYSCALL(fchown16)(long res, long fd, long user, long group) {} |
| |
| PRE_SYSCALL(setregid16)(long rgid, long egid) {} |
| |
| POST_SYSCALL(setregid16)(long res, long rgid, long egid) {} |
| |
| PRE_SYSCALL(setgid16)(long gid) {} |
| |
| POST_SYSCALL(setgid16)(long res, long gid) {} |
| |
| PRE_SYSCALL(setreuid16)(long ruid, long euid) {} |
| |
| POST_SYSCALL(setreuid16)(long res, long ruid, long euid) {} |
| |
| PRE_SYSCALL(setuid16)(long uid) {} |
| |
| POST_SYSCALL(setuid16)(long res, long uid) {} |
| |
| PRE_SYSCALL(setresuid16)(long ruid, long euid, long suid) {} |
| |
| POST_SYSCALL(setresuid16)(long res, long ruid, long euid, long suid) {} |
| |
| PRE_SYSCALL(getresuid16)(void *ruid, void *euid, void *suid) {} |
| |
| POST_SYSCALL(getresuid16) |
| (long res, __sanitizer___kernel_old_uid_t *ruid, |
| __sanitizer___kernel_old_uid_t *euid, __sanitizer___kernel_old_uid_t *suid) { |
| if (res >= 0) { |
| if (ruid) |
| POST_WRITE(ruid, sizeof(*ruid)); |
| if (euid) |
| POST_WRITE(euid, sizeof(*euid)); |
| if (suid) |
| POST_WRITE(suid, sizeof(*suid)); |
| } |
| } |
| |
| PRE_SYSCALL(setresgid16)(long rgid, long egid, long sgid) {} |
| |
| POST_SYSCALL(setresgid16)(long res, long rgid, long egid, long sgid) {} |
| |
| PRE_SYSCALL(getresgid16)(void *rgid, void *egid, void *sgid) {} |
| |
| POST_SYSCALL(getresgid16) |
| (long res, __sanitizer___kernel_old_gid_t *rgid, |
| __sanitizer___kernel_old_gid_t *egid, __sanitizer___kernel_old_gid_t *sgid) { |
| if (res >= 0) { |
| if (rgid) |
| POST_WRITE(rgid, sizeof(*rgid)); |
| if (egid) |
| POST_WRITE(egid, sizeof(*egid)); |
| if (sgid) |
| POST_WRITE(sgid, sizeof(*sgid)); |
| } |
| } |
| |
| PRE_SYSCALL(setfsuid16)(long uid) {} |
| |
| POST_SYSCALL(setfsuid16)(long res, long uid) {} |
| |
| PRE_SYSCALL(setfsgid16)(long gid) {} |
| |
| POST_SYSCALL(setfsgid16)(long res, long gid) {} |
| |
| PRE_SYSCALL(getgroups16) |
| (long gidsetsize, __sanitizer___kernel_old_gid_t *grouplist) {} |
| |
| POST_SYSCALL(getgroups16) |
| (long res, long gidsetsize, __sanitizer___kernel_old_gid_t *grouplist) { |
| if (res >= 0) { |
| if (grouplist) |
| POST_WRITE(grouplist, res * sizeof(*grouplist)); |
| } |
| } |
| |
| PRE_SYSCALL(setgroups16) |
| (long gidsetsize, __sanitizer___kernel_old_gid_t *grouplist) { |
| if (grouplist) |
| POST_WRITE(grouplist, gidsetsize * sizeof(*grouplist)); |
| } |
| |
| POST_SYSCALL(setgroups16) |
| (long res, long gidsetsize, __sanitizer___kernel_old_gid_t *grouplist) {} |
| |
| PRE_SYSCALL(getuid16)() {} |
| |
| POST_SYSCALL(getuid16)(long res) {} |
| |
| PRE_SYSCALL(geteuid16)() {} |
| |
| POST_SYSCALL(geteuid16)(long res) {} |
| |
| PRE_SYSCALL(getgid16)() {} |
| |
| POST_SYSCALL(getgid16)(long res) {} |
| |
| PRE_SYSCALL(getegid16)() {} |
| |
| POST_SYSCALL(getegid16)(long res) {} |
| # endif // SANITIZER_USES_UID16_SYSCALLS |
| |
| PRE_SYSCALL(utime)(void *filename, void *times) {} |
| |
| POST_SYSCALL(utime)(long res, void *filename, void *times) { |
| if (res >= 0) { |
| if (filename) |
| POST_WRITE(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| if (times) |
| POST_WRITE(times, struct_utimbuf_sz); |
| } |
| } |
| |
| PRE_SYSCALL(utimes)(void *filename, void *utimes) {} |
| |
| POST_SYSCALL(utimes)(long res, void *filename, void *utimes) { |
| if (res >= 0) { |
| if (filename) |
| POST_WRITE(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| if (utimes) |
| POST_WRITE(utimes, timeval_sz); |
| } |
| } |
| |
| PRE_SYSCALL(lseek)(long fd, long offset, long origin) {} |
| |
| POST_SYSCALL(lseek)(long res, long fd, long offset, long origin) {} |
| |
| PRE_SYSCALL(llseek) |
| (long fd, long offset_high, long offset_low, void *result, long origin) {} |
| |
| POST_SYSCALL(llseek) |
| (long res, long fd, long offset_high, long offset_low, void *result, |
| long origin) { |
| if (res >= 0) { |
| if (result) |
| POST_WRITE(result, sizeof(long long)); |
| } |
| } |
| |
| PRE_SYSCALL(readv)(long fd, const __sanitizer_iovec *vec, long vlen) {} |
| |
| POST_SYSCALL(readv) |
| (long res, long fd, const __sanitizer_iovec *vec, long vlen) { |
| if (res >= 0) { |
| if (vec) |
| kernel_write_iovec(vec, vlen, res); |
| } |
| } |
| |
| PRE_SYSCALL(write)(long fd, const void *buf, long count) { |
| if (buf) |
| PRE_READ(buf, count); |
| } |
| |
| POST_SYSCALL(write)(long res, long fd, const void *buf, long count) {} |
| |
| PRE_SYSCALL(writev)(long fd, const __sanitizer_iovec *vec, long vlen) {} |
| |
| POST_SYSCALL(writev) |
| (long res, long fd, const __sanitizer_iovec *vec, long vlen) { |
| if (res >= 0) { |
| if (vec) |
| kernel_read_iovec(vec, vlen, res); |
| } |
| } |
| |
| # ifdef _LP64 |
| PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos) {} |
| |
| POST_SYSCALL(pread64)(long res, long fd, void *buf, long count, long pos) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, res); |
| } |
| } |
| |
| PRE_SYSCALL(pwrite64)(long fd, const void *buf, long count, long pos) { |
| if (buf) |
| PRE_READ(buf, count); |
| } |
| |
| POST_SYSCALL(pwrite64) |
| (long res, long fd, const void *buf, long count, long pos) {} |
| # else |
| PRE_SYSCALL(pread64)(long fd, void *buf, long count, long pos0, long pos1) {} |
| |
| POST_SYSCALL(pread64) |
| (long res, long fd, void *buf, long count, long pos0, long pos1) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, res); |
| } |
| } |
| |
| PRE_SYSCALL(pwrite64) |
| (long fd, const void *buf, long count, long pos0, long pos1) { |
| if (buf) |
| PRE_READ(buf, count); |
| } |
| |
| POST_SYSCALL(pwrite64) |
| (long res, long fd, const void *buf, long count, long pos0, long pos1) {} |
| # endif |
| |
| PRE_SYSCALL(preadv) |
| (long fd, const __sanitizer_iovec *vec, long vlen, long pos_l, long pos_h) {} |
| |
| POST_SYSCALL(preadv) |
| (long res, long fd, const __sanitizer_iovec *vec, long vlen, long pos_l, |
| long pos_h) { |
| if (res >= 0) { |
| if (vec) |
| kernel_write_iovec(vec, vlen, res); |
| } |
| } |
| |
| PRE_SYSCALL(pwritev) |
| (long fd, const __sanitizer_iovec *vec, long vlen, long pos_l, long pos_h) {} |
| |
| POST_SYSCALL(pwritev) |
| (long res, long fd, const __sanitizer_iovec *vec, long vlen, long pos_l, |
| long pos_h) { |
| if (res >= 0) { |
| if (vec) |
| kernel_read_iovec(vec, vlen, res); |
| } |
| } |
| |
| PRE_SYSCALL(getcwd)(void *buf, long size) {} |
| |
| POST_SYSCALL(getcwd)(long res, void *buf, long size) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(mkdir)(const void *pathname, long mode) { |
| if (pathname) |
| PRE_READ(pathname, |
| __sanitizer::internal_strlen((const char *)pathname) + 1); |
| } |
| |
| POST_SYSCALL(mkdir)(long res, const void *pathname, long mode) {} |
| |
| PRE_SYSCALL(chdir)(const void *filename) { |
| if (filename) |
| PRE_READ(filename, |
| __sanitizer::internal_strlen((const char *)filename) + 1); |
| } |
| |
| POST_SYSCALL(chdir)(long res, const void *filename) {} |
| |
| PRE_SYSCALL(fchdir)(long fd) {} |
| |
| POST_SYSCALL(fchdir)(long res, long fd) {} |
| |
| PRE_SYSCALL(rmdir)(const void *pathname) { |
| if (pathname) |
| PRE_READ(pathname, |
| __sanitizer::internal_strlen((const char *)pathname) + 1); |
| } |
| |
| POST_SYSCALL(rmdir)(long res, const void *pathname) {} |
| |
| PRE_SYSCALL(lookup_dcookie)(u64 cookie64, void *buf, long len) {} |
| |
| POST_SYSCALL(lookup_dcookie)(long res, u64 cookie64, void *buf, long len) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(quotactl)(long cmd, const void *special, long id, void *addr) { |
| if (special) |
| PRE_READ(special, __sanitizer::internal_strlen((const char *)special) + 1); |
| } |
| |
| POST_SYSCALL(quotactl) |
| (long res, long cmd, const void *special, long id, void *addr) {} |
| |
| PRE_SYSCALL(getdents)(long fd, void *dirent, long count) {} |
| |
| POST_SYSCALL(getdents)(long res, long fd, void *dirent, long count) { |
| if (res >= 0) { |
| if (dirent) |
| POST_WRITE(dirent, res); |
| } |
| } |
| |
| PRE_SYSCALL(getdents64)(long fd, void *dirent, long count) {} |
| |
| POST_SYSCALL(getdents64)(long res, long fd, void *dirent, long count) { |
| if (res >= 0) { |
| if (dirent) |
| POST_WRITE(dirent, res); |
| } |
| } |
| |
| PRE_SYSCALL(setsockopt) |
| (long fd, long level, long optname, void *optval, long optlen) {} |
| |
| POST_SYSCALL(setsockopt) |
| (long res, long fd, long level, long optname, void *optval, long optlen) { |
| if (res >= 0) { |
| if (optval) |
| POST_WRITE(optval, |
| __sanitizer::internal_strlen((const char *)optval) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(getsockopt) |
| (long fd, long level, long optname, void *optval, void *optlen) {} |
| |
| POST_SYSCALL(getsockopt) |
| (long res, long fd, long level, long optname, void *optval, void *optlen) { |
| if (res >= 0) { |
| if (optval) |
| POST_WRITE(optval, |
| __sanitizer::internal_strlen((const char *)optval) + 1); |
| if (optlen) |
| POST_WRITE(optlen, sizeof(int)); |
| } |
| } |
| |
| PRE_SYSCALL(bind)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {} |
| |
| POST_SYSCALL(bind) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| } |
| } |
| |
| PRE_SYSCALL(connect)(long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) {} |
| |
| POST_SYSCALL(connect) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, long arg2) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| } |
| } |
| |
| PRE_SYSCALL(accept)(long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {} |
| |
| POST_SYSCALL(accept) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| if (arg2) |
| POST_WRITE(arg2, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(accept4) |
| (long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2, long arg3) {} |
| |
| POST_SYSCALL(accept4) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2, long arg3) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| if (arg2) |
| POST_WRITE(arg2, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(getsockname) |
| (long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {} |
| |
| POST_SYSCALL(getsockname) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| if (arg2) |
| POST_WRITE(arg2, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(getpeername) |
| (long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) {} |
| |
| POST_SYSCALL(getpeername) |
| (long res, long arg0, sanitizer_kernel_sockaddr *arg1, void *arg2) { |
| if (res >= 0) { |
| if (arg1) |
| POST_WRITE(arg1, sizeof(*arg1)); |
| if (arg2) |
| POST_WRITE(arg2, sizeof(unsigned)); |
| } |
| } |
| |
| PRE_SYSCALL(send)(long arg0, void *arg1, long arg2, long arg3) {} |
| |
| POST_SYSCALL(send)(long res, long arg0, void *arg1, long arg2, long arg3) { |
| if (res) { |
| if (arg1) |
| POST_READ(arg1, res); |
| } |
| } |
| |
| PRE_SYSCALL(sendto) |
| (long arg0, void *arg1, long arg2, long arg3, sanitizer_kernel_sockaddr *arg4, |
| long arg5) {} |
| |
| POST_SYSCALL(sendto) |
| (long res, long arg0, void *arg1, long arg2, long arg3, |
| sanitizer_kernel_sockaddr *arg4, long arg5) { |
| if (res >= 0) { |
| if (arg1) |
| POST_READ(arg1, res); |
| if (arg4) |
| POST_WRITE(arg4, sizeof(*arg4)); |
| } |
| } |
| |
| PRE_SYSCALL(sendmsg)(long fd, void *msg, long flags) {} |
| |
| POST_SYSCALL(sendmsg)(long res, long fd, void *msg, long flags) { |
| // FIXME: POST_READ |
| } |
| |
| PRE_SYSCALL(sendmmsg)(long fd, void *msg, long vlen, long flags) {} |
| |
| POST_SYSCALL(sendmmsg)(long res, long fd, void *msg, long vlen, long flags) { |
| // FIXME: POST_READ |
| } |
| |
| PRE_SYSCALL(recv)(long arg0, void *buf, long len, long flags) {} |
| |
| POST_SYSCALL(recv)(long res, void *buf, long len, long flags) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, res); |
| } |
| } |
| |
| PRE_SYSCALL(recvfrom) |
| (long arg0, void *buf, long len, long flags, sanitizer_kernel_sockaddr *arg4, |
| void *arg5) {} |
| |
| POST_SYSCALL(recvfrom) |
| (long res, long arg0, void *buf, long len, long flags, |
| sanitizer_kernel_sockaddr *arg4, void *arg5) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, res); |
| if (arg4) |
| POST_WRITE(arg4, sizeof(*arg4)); |
| if (arg5) |
| POST_WRITE(arg5, sizeof(int)); |
| } |
| } |
| |
| PRE_SYSCALL(socket)(long arg0, long arg1, long arg2) {} |
| |
| POST_SYSCALL(socket)(long res, long arg0, long arg1, long arg2) {} |
| |
| PRE_SYSCALL(socketpair)(long arg0, long arg1, long arg2, int *sv) {} |
| |
| POST_SYSCALL(socketpair)(long res, long arg0, long arg1, long arg2, int *sv) { |
| if (res >= 0) |
| if (sv) |
| POST_WRITE(sv, sizeof(int) * 2); |
| } |
| |
| PRE_SYSCALL(socketcall)(long call, void *args) {} |
| |
| POST_SYSCALL(socketcall)(long res, long call, void *args) { |
| if (res >= 0) { |
| if (args) |
| POST_WRITE(args, sizeof(long)); |
| } |
| } |
| |
| PRE_SYSCALL(listen)(long arg0, long arg1) {} |
| |
| POST_SYSCALL(listen)(long res, long arg0, long arg1) {} |
| |
| PRE_SYSCALL(poll)(void *ufds, long nfds, long timeout) {} |
| |
| POST_SYSCALL(poll) |
| (long res, __sanitizer_pollfd *ufds, long nfds, long timeout) { |
| if (res >= 0) { |
| if (ufds) |
| POST_WRITE(ufds, nfds * sizeof(*ufds)); |
| } |
| } |
| |
| PRE_SYSCALL(select) |
| (long n, __sanitizer___kernel_fd_set *inp, __sanitizer___kernel_fd_set *outp, |
| __sanitizer___kernel_fd_set *exp, void *tvp) {} |
| |
| POST_SYSCALL(select) |
| (long res, long n, __sanitizer___kernel_fd_set *inp, |
| __sanitizer___kernel_fd_set *outp, __sanitizer___kernel_fd_set *exp, |
| void *tvp) { |
| if (res >= 0) { |
| if (inp) |
| POST_WRITE(inp, sizeof(*inp)); |
| if (outp) |
| POST_WRITE(outp, sizeof(*outp)); |
| if (exp) |
| POST_WRITE(exp, sizeof(*exp)); |
| if (tvp) |
| POST_WRITE(tvp, timeval_sz); |
| } |
| } |
| |
| PRE_SYSCALL(old_select)(void *arg) {} |
| |
| POST_SYSCALL(old_select)(long res, void *arg) {} |
| |
| PRE_SYSCALL(epoll_create)(long size) {} |
| |
| POST_SYSCALL(epoll_create)(long res, long size) {} |
| |
| PRE_SYSCALL(epoll_create1)(long flags) {} |
| |
| POST_SYSCALL(epoll_create1)(long res, long flags) {} |
| |
| PRE_SYSCALL(epoll_ctl)(long epfd, long op, long fd, void *event) {} |
| |
| POST_SYSCALL(epoll_ctl)(long res, long epfd, long op, long fd, void *event) { |
| if (res >= 0) { |
| if (event) |
| POST_WRITE(event, struct_epoll_event_sz); |
| } |
| } |
| |
| PRE_SYSCALL(epoll_wait) |
| (long epfd, void *events, long maxevents, long timeout) {} |
| |
| POST_SYSCALL(epoll_wait) |
| (long res, long epfd, void *events, long maxevents, long timeout) { |
| if (res >= 0) { |
| if (events) |
| POST_WRITE(events, res * struct_epoll_event_sz); |
| } |
| } |
| |
| PRE_SYSCALL(epoll_pwait) |
| (long epfd, void *events, long maxevents, long timeout, |
| const kernel_sigset_t *sigmask, long sigsetsize) { |
| if (sigmask) |
| PRE_READ(sigmask, sigsetsize); |
| } |
| |
| POST_SYSCALL(epoll_pwait) |
| (long res, long epfd, void *events, long maxevents, long timeout, |
| const void *sigmask, long sigsetsize) { |
| if (res >= 0) { |
| if (events) |
| POST_WRITE(events, res * struct_epoll_event_sz); |
| } |
| } |
| |
| PRE_SYSCALL(epoll_pwait2) |
| (long epfd, void *events, long maxevents, |
| const sanitizer_kernel_timespec *timeout, const kernel_sigset_t *sigmask, |
| long sigsetsize) { |
| if (timeout) |
| PRE_READ(timeout, sizeof(timeout)); |
| if (sigmask) |
| PRE_READ(sigmask, sigsetsize); |
| } |
| |
| POST_SYSCALL(epoll_pwait2) |
| (long res, long epfd, void *events, long maxevents, |
| const sanitizer_kernel_timespec *timeout, const void *sigmask, |
| long sigsetsize) { |
| if (res >= 0) { |
| if (events) |
| POST_WRITE(events, res * struct_epoll_event_sz); |
| } |
| } |
| |
| PRE_SYSCALL(gethostname)(void *name, long len) {} |
| |
| POST_SYSCALL(gethostname)(long res, void *name, long len) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(sethostname)(void *name, long len) {} |
| |
| POST_SYSCALL(sethostname)(long res, void *name, long len) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(setdomainname)(void *name, long len) {} |
| |
| POST_SYSCALL(setdomainname)(long res, void *name, long len) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(newuname)(void *name) {} |
| |
| POST_SYSCALL(newuname)(long res, void *name) { |
| if (res >= 0) { |
| if (name) |
| POST_WRITE(name, struct_new_utsname_sz); |
| } |
| } |
| |
| PRE_SYSCALL(uname)(void *arg0) {} |
| |
| POST_SYSCALL(uname)(long res, void *arg0) { |
| if (res >= 0) { |
| if (arg0) |
| POST_WRITE(arg0, struct_old_utsname_sz); |
| } |
| } |
| |
| PRE_SYSCALL(olduname)(void *arg0) {} |
| |
| POST_SYSCALL(olduname)(long res, void *arg0) { |
| if (res >= 0) { |
| if (arg0) |
| POST_WRITE(arg0, struct_oldold_utsname_sz); |
| } |
| } |
| |
| PRE_SYSCALL(getrlimit)(long resource, void *rlim) {} |
| |
| POST_SYSCALL(getrlimit)(long res, long resource, void *rlim) { |
| if (res >= 0) { |
| if (rlim) |
| POST_WRITE(rlim, struct_rlimit_sz); |
| } |
| } |
| |
| PRE_SYSCALL(old_getrlimit)(long resource, void *rlim) {} |
| |
| POST_SYSCALL(old_getrlimit)(long res, long resource, void *rlim) { |
| if (res >= 0) { |
| if (rlim) |
| POST_WRITE(rlim, struct_rlimit_sz); |
| } |
| } |
| |
| PRE_SYSCALL(setrlimit)(long resource, void *rlim) {} |
| |
| POST_SYSCALL(setrlimit)(long res, long resource, void *rlim) { |
| if (res >= 0) { |
| if (rlim) |
| POST_WRITE(rlim, struct_rlimit_sz); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(prlimit64) |
| (long pid, long resource, const void *new_rlim, void *old_rlim) { |
| if (new_rlim) |
| PRE_READ(new_rlim, struct_rlimit64_sz); |
| } |
| |
| POST_SYSCALL(prlimit64) |
| (long res, long pid, long resource, const void *new_rlim, void *old_rlim) { |
| if (res >= 0) { |
| if (old_rlim) |
| POST_WRITE(old_rlim, struct_rlimit64_sz); |
| } |
| } |
| # endif |
| |
| PRE_SYSCALL(getrusage)(long who, void *ru) {} |
| |
| POST_SYSCALL(getrusage)(long res, long who, void *ru) { |
| if (res >= 0) { |
| if (ru) |
| POST_WRITE(ru, struct_rusage_sz); |
| } |
| } |
| |
| PRE_SYSCALL(umask)(long mask) {} |
| |
| POST_SYSCALL(umask)(long res, long mask) {} |
| |
| PRE_SYSCALL(msgget)(long key, long msgflg) {} |
| |
| POST_SYSCALL(msgget)(long res, long key, long msgflg) {} |
| |
| PRE_SYSCALL(msgsnd)(long msqid, void *msgp, long msgsz, long msgflg) { |
| if (msgp) |
| PRE_READ(msgp, msgsz); |
| } |
| |
| POST_SYSCALL(msgsnd) |
| (long res, long msqid, void *msgp, long msgsz, long msgflg) {} |
| |
| PRE_SYSCALL(msgrcv) |
| (long msqid, void *msgp, long msgsz, long msgtyp, long msgflg) {} |
| |
| POST_SYSCALL(msgrcv) |
| (long res, long msqid, void *msgp, long msgsz, long msgtyp, long msgflg) { |
| if (res >= 0) { |
| if (msgp) |
| POST_WRITE(msgp, res); |
| } |
| } |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(msgctl)(long msqid, long cmd, void *buf) {} |
| |
| POST_SYSCALL(msgctl)(long res, long msqid, long cmd, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, struct_msqid_ds_sz); |
| } |
| } |
| # endif |
| |
| PRE_SYSCALL(semget)(long key, long nsems, long semflg) {} |
| |
| POST_SYSCALL(semget)(long res, long key, long nsems, long semflg) {} |
| |
| PRE_SYSCALL(semop)(long semid, void *sops, long nsops) {} |
| |
| POST_SYSCALL(semop)(long res, long semid, void *sops, long nsops) {} |
| |
| PRE_SYSCALL(semctl)(long semid, long semnum, long cmd, void *arg) {} |
| |
| POST_SYSCALL(semctl)(long res, long semid, long semnum, long cmd, void *arg) {} |
| |
| PRE_SYSCALL(semtimedop) |
| (long semid, void *sops, long nsops, const void *timeout) { |
| if (timeout) |
| PRE_READ(timeout, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(semtimedop) |
| (long res, long semid, void *sops, long nsops, const void *timeout) {} |
| |
| PRE_SYSCALL(shmat)(long shmid, void *shmaddr, long shmflg) {} |
| |
| POST_SYSCALL(shmat)(long res, long shmid, void *shmaddr, long shmflg) { |
| if (res >= 0) { |
| if (shmaddr) |
| POST_WRITE(shmaddr, |
| __sanitizer::internal_strlen((const char *)shmaddr) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(shmget)(long key, long size, long flag) {} |
| |
| POST_SYSCALL(shmget)(long res, long key, long size, long flag) {} |
| |
| PRE_SYSCALL(shmdt)(void *shmaddr) {} |
| |
| POST_SYSCALL(shmdt)(long res, void *shmaddr) { |
| if (res >= 0) { |
| if (shmaddr) |
| POST_WRITE(shmaddr, |
| __sanitizer::internal_strlen((const char *)shmaddr) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(ipc) |
| (long call, long first, long second, long third, void *ptr, long fifth) {} |
| |
| POST_SYSCALL(ipc) |
| (long res, long call, long first, long second, long third, void *ptr, |
| long fifth) {} |
| |
| # if !SANITIZER_ANDROID |
| PRE_SYSCALL(shmctl)(long shmid, long cmd, void *buf) {} |
| |
| POST_SYSCALL(shmctl)(long res, long shmid, long cmd, void *buf) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, sizeof(__sanitizer_shmid_ds)); |
| } |
| } |
| |
| PRE_SYSCALL(mq_open)(const void *name, long oflag, long mode, void *attr) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(mq_open) |
| (long res, const void *name, long oflag, long mode, void *attr) { |
| if (res >= 0) { |
| if (attr) |
| POST_WRITE(attr, struct_mq_attr_sz); |
| } |
| } |
| |
| PRE_SYSCALL(mq_unlink)(const void *name) { |
| if (name) |
| PRE_READ(name, __sanitizer::internal_strlen((const char *)name) + 1); |
| } |
| |
| POST_SYSCALL(mq_unlink)(long res, const void *name) {} |
| |
| PRE_SYSCALL(mq_timedsend) |
| (long mqdes, const void *msg_ptr, long msg_len, long msg_prio, |
| const void *abs_timeout) { |
| if (msg_ptr) |
| PRE_READ(msg_ptr, msg_len); |
| if (abs_timeout) |
| PRE_READ(abs_timeout, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(mq_timedsend) |
| (long res, long mqdes, const void *msg_ptr, long msg_len, long msg_prio, |
| const void *abs_timeout) {} |
| |
| PRE_SYSCALL(mq_timedreceive) |
| (long mqdes, void *msg_ptr, long msg_len, void *msg_prio, |
| const void *abs_timeout) { |
| if (abs_timeout) |
| PRE_READ(abs_timeout, struct_timespec_sz); |
| } |
| |
| POST_SYSCALL(mq_timedreceive) |
| (long res, long mqdes, void *msg_ptr, long msg_len, int *msg_prio, |
| const void *abs_timeout) { |
| if (res >= 0) { |
| if (msg_ptr) |
| POST_WRITE(msg_ptr, res); |
| if (msg_prio) |
| POST_WRITE(msg_prio, sizeof(*msg_prio)); |
| } |
| } |
| |
| PRE_SYSCALL(mq_notify)(long mqdes, const void *notification) { |
| if (notification) |
| PRE_READ(notification, struct_sigevent_sz); |
| } |
| |
| POST_SYSCALL(mq_notify)(long res, long mqdes, const void *notification) {} |
| |
| PRE_SYSCALL(mq_getsetattr)(long mqdes, const void *mqstat, void *omqstat) { |
| if (mqstat) |
| PRE_READ(mqstat, struct_mq_attr_sz); |
| } |
| |
| POST_SYSCALL(mq_getsetattr) |
| (long res, long mqdes, const void *mqstat, void *omqstat) { |
| if (res >= 0) { |
| if (omqstat) |
| POST_WRITE(omqstat, struct_mq_attr_sz); |
| } |
| } |
| # endif // SANITIZER_ANDROID |
| |
| PRE_SYSCALL(pciconfig_iobase)(long which, long bus, long devfn) {} |
| |
| POST_SYSCALL(pciconfig_iobase)(long res, long which, long bus, long devfn) {} |
| |
| PRE_SYSCALL(pciconfig_read) |
| (long bus, long dfn, long off, long len, void *buf) {} |
| |
| POST_SYSCALL(pciconfig_read) |
| (long res, long bus, long dfn, long off, long len, void *buf) {} |
| |
| PRE_SYSCALL(pciconfig_write) |
| (long bus, long dfn, long off, long len, void *buf) {} |
| |
| POST_SYSCALL(pciconfig_write) |
| (long res, long bus, long dfn, long off, long len, void *buf) {} |
| |
| PRE_SYSCALL(swapon)(const void *specialfile, long swap_flags) { |
| if (specialfile) |
| PRE_READ(specialfile, |
| __sanitizer::internal_strlen((const char *)specialfile) + 1); |
| } |
| |
| POST_SYSCALL(swapon)(long res, const void *specialfile, long swap_flags) {} |
| |
| PRE_SYSCALL(swapoff)(const void *specialfile) { |
| if (specialfile) |
| PRE_READ(specialfile, |
| __sanitizer::internal_strlen((const char *)specialfile) + 1); |
| } |
| |
| POST_SYSCALL(swapoff)(long res, const void *specialfile) {} |
| |
| PRE_SYSCALL(sysctl)(__sanitizer___sysctl_args *args) { |
| if (args) { |
| if (args->name) |
| PRE_READ(args->name, args->nlen * sizeof(*args->name)); |
| if (args->newval) |
| PRE_READ(args->name, args->newlen); |
| } |
| } |
| |
| POST_SYSCALL(sysctl)(long res, __sanitizer___sysctl_args *args) { |
| if (res >= 0) { |
| if (args && args->oldval && args->oldlenp) { |
| POST_WRITE(args->oldlenp, sizeof(*args->oldlenp)); |
| POST_WRITE(args->oldval, *args->oldlenp); |
| } |
| } |
| } |
| |
| PRE_SYSCALL(sysinfo)(void *info) {} |
| |
| POST_SYSCALL(sysinfo)(long res, void *info) { |
| if (res >= 0) { |
| if (info) |
| POST_WRITE(info, struct_sysinfo_sz); |
| } |
| } |
| |
| PRE_SYSCALL(sysfs)(long option, long arg1, long arg2) {} |
| |
| POST_SYSCALL(sysfs)(long res, long option, long arg1, long arg2) {} |
| |
| PRE_SYSCALL(syslog)(long type, void *buf, long len) {} |
| |
| POST_SYSCALL(syslog)(long res, long type, void *buf, long len) { |
| if (res >= 0) { |
| if (buf) |
| POST_WRITE(buf, __sanitizer::internal_strlen((const char *)buf) + 1); |
| } |
| } |
| |
| PRE_SYSCALL(uselib)(const void *library) { |
| if (library) |
| PRE_READ(library, __sanitizer::internal_strlen((const char *)library) + 1); |
| } |
| |
| POST_SYSCALL(uselib)(long res, const void *library) {} |
| |
| PRE_SYSCALL(ni_syscall)() {} |
| |
| POST_SYSCALL(ni_syscall)(long res) {} |
| |
| PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) { |
| # if !SANITIZER_ANDROID && \ |
| (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ |
| defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \ |
| SANITIZER_RISCV64) |
| if (data) { |
| if (request == ptrace_setregs) { |
| PRE_READ((void *)data, struct_user_regs_struct_sz); |
| } else if (request == ptrace_setfpregs) { |
| PRE_READ((void *)data, struct_user_fpregs_struct_sz); |
| } else if (request == ptrace_setfpxregs) { |
| PRE_READ((void *)data, struct_user_fpxregs_struct_sz); |
| } else if (request == ptrace_setsiginfo) { |
| PRE_READ((void *)data, siginfo_t_sz); |
| } else if (request == ptrace_setregset) { |
| __sanitizer_iovec *iov = (__sanitizer_iovec *)data; |
| PRE_READ(iov->iov_base, iov->iov_len); |
| } |
| } |
| # endif |
| } |
| |
| POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) { |
| # if !SANITIZER_ANDROID && \ |
| (defined(__i386) || defined(__x86_64) || defined(__mips64) || \ |
| defined(__powerpc64__) || defined(__aarch64__) || defined(__s390__) || \ |
| SANITIZER_RISCV64) |
| if (res >= 0 && data) { |
| // Note that this is different from the interceptor in |
| // sanitizer_common_interceptors.inc. |
| // PEEK* requests return resulting values through data pointer. |
| if (request == ptrace_getregs) { |
| POST_WRITE((void *)data, struct_user_regs_struct_sz); |
| } else if (request == ptrace_getfpregs) { |
| POST_WRITE((void *)data, struct_user_fpregs_struct_sz); |
| } else if (request == ptrace_getfpxregs) { |
| POST_WRITE((void *)data, struct_user_fpxregs_struct_sz); |
| } else if (request == ptrace_getsiginfo) { |
| POST_WRITE((void *)data, siginfo_t_sz); |
| } else if (request == ptrace_getregset) { |
| __sanitizer_iovec *iov = (__sanitizer_iovec *)data; |
| POST_WRITE(iov->iov_base, iov->iov_len); |
| } else if (request == ptrace_peekdata || request == ptrace_peektext || |
| request == ptrace_peekuser) { |
| POST_WRITE((void *)data, sizeof(void *)); |
| } |
| } |
| # endif |
| } |
| |
| PRE_SYSCALL(add_key) |
| (const void *_type, const void *_description, const void *_payload, long plen, |
| long destringid) { |
| if (_type) |
| PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1); |
| if (_description) |
| PRE_READ(_description, |
| __sanitizer::internal_strlen((const char *)_description) + 1); |
| } |
| |
| POST_SYSCALL(add_key) |
| (long res, const void *_type, const void *_description, const void *_payload, |
| long plen, long destringid) {} |
| |
| PRE_SYSCALL(request_key) |
| (const void *_type, const void *_description, const void *_callout_info, |
| long destringid) { |
| if (_type) |
| PRE_READ(_type, __sanitizer::internal_strlen((const char *)_type) + 1); |
| if (_description) |
| PRE_READ(_description, |
| __sanitizer::internal_strlen((const char *)_description) + 1); |
| if (_callout_info) |
| PRE_READ(_callout_info, |
| __sanitizer::internal_strlen((const char *)_callout_info) + 1); |
| } |
| |
| POST_SYSCALL(request_key) |
| (long res, const void *_type, const void *_description, |
| const void *_callout_info, long destringid) {} |
| |
| PRE_SYSCALL(keyctl)(long cmd, long arg2, long arg3, long arg4, long arg5) {} |
| |
| POST_SYSCALL(keyctl) |
| (long res, long cmd, long arg2, long arg3, long arg4, long arg5) {} |
| |
| PRE_SYSCALL(ioprio_set)(long which, long who, long ioprio) {} |
| |
| POST_SYSCALL(ioprio_set)(long res, long which, long who, long ioprio) {} |
| |
| PRE_SYSCALL(ioprio_get)(long which, long who) {} |
| |
| POST_SYSCALL(ioprio_get)(long res, long which, long who) {} |
| |
| PRE_SYSCALL(set_mempolicy)(long mode, void *nmask, long maxnode) {} |
| |
| POST_SYSCALL(set_mempolicy)(long res, long mode, void *nmask, long maxnode) { |
| if (res >= 0) { |
| if (nmask) |
| POST_WRITE(nmask, sizeof(long)); |
| } |
| } |
| |
| PRE_SYSCALL(migrate_pages) |
| (long pid, long maxnode, const void *from, const void *to) { |
| if (from) |
| PRE_READ(from, sizeof(long)); |
| if (to) |
| PRE_READ(to, sizeof(long)); |
| } |
| |
| POST_SYSCALL(migrate_pages) |
| (long res, long pid, long maxnode, const void *from, const void *to) {} |
| |
| PRE_SYSCALL(move_pages) |
| (long pid, long nr_pages, const void **pages, const int *nodes, int *status, |
| long flags) { |
| if (pages) |
| PRE_READ(pages, nr_pages * sizeof(*pages)); |
| if (nodes) |
| PRE_READ(nodes, nr_pages * sizeof(*nodes)); |
| } |
| |
| POST_SYSCALL(move_pages) |
| (long res, long pid, long nr_pages, const void **pages, const int *nodes, |
| int *status, long flags) { |
| if (res >= 0) { |
| if (status) |
| POST_WRITE(status, nr_pages * sizeof(*status)); |
| } |
| } |
| |
| PRE_SYSCALL(mbind) |
| (long start, long len, long mode, void *
|