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