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