llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

//===-- sanitizer_common_syscalls.inc ---------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Common syscalls handlers for tools like AddressSanitizer,
// ThreadSanitizer, MemorySanitizer, etc.
//
// This file should be included into the tool's interceptor file,
// which has to define it's own macros:
//   COMMON_SYSCALL_PRE_READ_RANGE
//          Called in prehook for regions that will be read by the kernel and
//          must be initialized.
//   COMMON_SYSCALL_PRE_WRITE_RANGE
//          Called in prehook for regions that will be written to by the kernel
//          and must be addressable. The actual write range may be smaller than
//          reported in the prehook. See POST_WRITE_RANGE.
//   COMMON_SYSCALL_POST_READ_RANGE
//          Called in posthook for regions that were read by the kernel. Does
//          not make much sense.
//   COMMON_SYSCALL_POST_WRITE_RANGE
//          Called in posthook for regions that were written to by the kernel
//          and are now initialized.
//===----------------------------------------------------------------------===//

#define PRE_SYSCALL(name)                                                      \
  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_pre_##name
#define PRE_READ(p, s) COMMON_SYSCALL_PRE_READ_RANGE(p, s)
#define PRE_WRITE(p, s) COMMON_SYSCALL_PRE_WRITE_RANGE(p, s)

#define POST_SYSCALL(name)                                                     \
  SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_syscall_post_##name
#define POST_READ(p, s) COMMON_SYSCALL_POST_READ_RANGE(p, s)
#define POST_WRITE(p, s) COMMON_SYSCALL_POST_WRITE_RANGE(p, s)

// FIXME: do some kind of PRE_READ for all syscall arguments (int(s) and such).

extern "C" {
struct sanitizer_kernel_iovec {
  void *iov_base;
  unsigned long iov_len;
};

struct sanitizer_kernel_msghdr {
  void *msg_name;
  int msg_namelen;
  struct sanitizer_kernel_iovec *msg_iov;
  unsigned long msg_iovlen;
  void *msg_control;
  unsigned long msg_controllen;
  unsigned msg_flags;
};

struct sanitizer_kernel_timespec {
  long tv_sec;
  long tv_nsec;
};

struct sanitizer_kernel_timeval {
  long tv_sec;
  long tv_usec;
};

struct sanitizer_kernel_rusage {
  struct sanitizer_kernel_timeval ru_timeval[2];
  long ru_long[14];
};

PRE_SYSCALL(recvmsg)(int sockfd, struct sanitizer_kernel_msghdr *msg,
                     int flags) {
  PRE_READ(msg, sizeof(*msg));
}

POST_SYSCALL(recvmsg)(long res, int sockfd, struct sanitizer_kernel_msghdr *msg,
                      int flags) {
  if (res > 0)
    for (unsigned long i = 0; i < msg->msg_iovlen; ++i) {
      POST_WRITE(msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len);
    }
  POST_WRITE(msg->msg_control, msg->msg_controllen);
}

PRE_SYSCALL(rt_sigpending)(void *p, unsigned long s) { PRE_WRITE(p, s); }

POST_SYSCALL(rt_sigpending)(long res, void *p, unsigned long s) {
  if (res == 0) {
    POST_WRITE(p, s);
  }
}

PRE_SYSCALL(getdents)(int fd, void *dirp, int count) { PRE_WRITE(dirp, count); }

POST_SYSCALL(getdents)(long res, int fd, void *dirp, int count) {
  if (res > 0) {
    POST_WRITE(dirp, res);
  }
}

PRE_SYSCALL(getdents64)(int fd, void *dirp, int count) {
  PRE_WRITE(dirp, count);
}

POST_SYSCALL(getdents64)(long res, int fd, void *dirp, int count) {
  if (res > 0) {
    POST_WRITE(dirp, res);
  }
}

PRE_SYSCALL(wait4)(int pid, int *status, int options,
                   struct sanitizer_kernel_rusage *r) {
  if (status) {
    PRE_WRITE(status, sizeof(*status));
  }
  if (r) {
    PRE_WRITE(r, sizeof(*r));
  }
}

POST_SYSCALL(wait4)(long res, int pid, int *status, int options,
                    struct sanitizer_kernel_rusage *r) {
  if (res > 0) {
    if (status) {
      POST_WRITE(status, sizeof(*status));
    }
    if (r) {
      POST_WRITE(r, sizeof(*r));
    }
  }
}

PRE_SYSCALL(waitpid)(int pid, int *status, int options) {
  if (status) {
    PRE_WRITE(status, sizeof(*status));
  }
}

POST_SYSCALL(waitpid)(long res, int pid, int *status, int options) {
  if (res > 0 && status) {
    POST_WRITE(status, sizeof(*status));
  }
}

PRE_SYSCALL(clock_gettime)(int clk_id, struct sanitizer_kernel_timespec *tp) {
  if (tp) {
    PRE_WRITE(tp, sizeof(*tp));
  }
}

POST_SYSCALL(clock_gettime)(long res, int clk_id,
                            struct sanitizer_kernel_timespec *tp) {
  if (res == 0 && tp) {
    POST_WRITE(tp, sizeof(*tp));
  }
}

PRE_SYSCALL(clock_getres)(int clk_id, struct sanitizer_kernel_timespec *tp) {
  if (tp) {
    PRE_WRITE(tp, sizeof(*tp));
  }
}

POST_SYSCALL(clock_getres)(long res, int clk_id,
                           struct sanitizer_kernel_timespec *tp) {
  if (res == 0 && tp) {
    POST_WRITE(tp, sizeof(*tp));
  }
}

PRE_SYSCALL(read)(unsigned int fd, void *buf, uptr count) {
  if (buf) {
    PRE_WRITE(buf, count);
  }
}

POST_SYSCALL(read)(long res, unsigned int fd, void *buf, uptr count) {
  if (res > 0 && buf) {
    POST_WRITE(buf, res);
  }
}
}  // extern "C"

#undef PRE_SYSCALL
#undef PRE_READ
#undef PRE_WRITE
#undef POST_SYSCALL
#undef POST_READ
#undef POST_WRITE