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