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