Home | History | Annotate | Line # | Download | only in sanitizer_common 
      1 //===-- sanitizer_solaris.cpp ---------------------------------------------===//
      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 // This file is shared between various sanitizers' runtime libraries and
     10 // implements Solaris-specific functions.
     11 //===----------------------------------------------------------------------===//
     12 
     13 #include "sanitizer_platform.h"
     14 #if SANITIZER_SOLARIS
     15 
     16 #include <stdio.h>
     17 
     18 #include "sanitizer_common.h"
     19 #include "sanitizer_flags.h"
     20 #include "sanitizer_internal_defs.h"
     21 #include "sanitizer_libc.h"
     22 #include "sanitizer_placement_new.h"
     23 #include "sanitizer_platform_limits_posix.h"
     24 #include "sanitizer_procmaps.h"
     25 
     26 #include <fcntl.h>
     27 #include <pthread.h>
     28 #include <sched.h>
     29 #include <thread.h>
     30 #include <synch.h>
     31 #include <signal.h>
     32 #include <sys/mman.h>
     33 #include <sys/resource.h>
     34 #include <sys/stat.h>
     35 #include <sys/types.h>
     36 #include <dirent.h>
     37 #include <unistd.h>
     38 #include <errno.h>
     39 #include <stdlib.h>
     40 
     41 namespace __sanitizer {
     42 
     43 //#include "sanitizer_syscall_generic.inc"
     44 
     45 #define _REAL(func) _ ## func
     46 #define DECLARE__REAL(ret_type, func, ...) \
     47   extern "C" ret_type _REAL(func)(__VA_ARGS__)
     48 #define DECLARE__REAL_AND_INTERNAL(ret_type, func, ...) \
     49   DECLARE__REAL(ret_type, func, __VA_ARGS__); \
     50   ret_type internal_ ## func(__VA_ARGS__)
     51 
     52 #if !defined(_LP64) && _FILE_OFFSET_BITS == 64
     53 #define _REAL64(func) _ ## func ## 64
     54 #else
     55 #define _REAL64(func) _REAL(func)
     56 #endif
     57 #define DECLARE__REAL64(ret_type, func, ...) \
     58   extern "C" ret_type _REAL64(func)(__VA_ARGS__)
     59 #define DECLARE__REAL_AND_INTERNAL64(ret_type, func, ...) \
     60   DECLARE__REAL64(ret_type, func, __VA_ARGS__); \
     61   ret_type internal_ ## func(__VA_ARGS__)
     62 
     63 // ---------------------- sanitizer_libc.h
     64 DECLARE__REAL_AND_INTERNAL64(uptr, mmap, void *addr, uptr /*size_t*/ length,
     65                              int prot, int flags, int fd, OFF_T offset) {
     66   return (uptr)_REAL64(mmap)(addr, length, prot, flags, fd, offset);
     67 }
     68 
     69 DECLARE__REAL_AND_INTERNAL(uptr, munmap, void *addr, uptr length) {
     70   return _REAL(munmap)(addr, length);
     71 }
     72 
     73 DECLARE__REAL_AND_INTERNAL(int, mprotect, void *addr, uptr length, int prot) {
     74   return _REAL(mprotect)(addr, length, prot);
     75 }
     76 
     77 // Illumos' declaration of madvise cannot be made visible if _XOPEN_SOURCE
     78 // is defined as g++ does on Solaris.
     79 //
     80 // This declaration is consistent with Solaris 11.4. Both Illumos and Solaris
     81 // versions older than 11.4 declared madvise with a caddr_t as the first
     82 // argument, but we don't currently support Solaris versions older than 11.4,
     83 // and as mentioned above the declaration is not visible on Illumos so we can
     84 // use any declaration we like on Illumos.
     85 extern "C" int madvise(void *, size_t, int);
     86 
     87 int internal_madvise(uptr addr, uptr length, int advice) {
     88   return madvise((void *)addr, length, advice);
     89 }
     90 
     91 DECLARE__REAL_AND_INTERNAL(uptr, close, fd_t fd) {
     92   return _REAL(close)(fd);
     93 }
     94 
     95 extern "C" int _REAL64(open)(const char *, int, ...);
     96 
     97 uptr internal_open(const char *filename, int flags) {
     98   return _REAL64(open)(filename, flags);
     99 }
    100 
    101 uptr internal_open(const char *filename, int flags, u32 mode) {
    102   return _REAL64(open)(filename, flags, mode);
    103 }
    104 
    105 DECLARE__REAL_AND_INTERNAL(uptr, read, fd_t fd, void *buf, uptr count) {
    106   return _REAL(read)(fd, buf, count);
    107 }
    108 
    109 DECLARE__REAL_AND_INTERNAL(uptr, write, fd_t fd, const void *buf, uptr count) {
    110   return _REAL(write)(fd, buf, count);
    111 }
    112 
    113 // FIXME: There's only _ftruncate64 beginning with Solaris 11.
    114 DECLARE__REAL_AND_INTERNAL(uptr, ftruncate, fd_t fd, uptr size) {
    115   return ftruncate(fd, size);
    116 }
    117 
    118 DECLARE__REAL_AND_INTERNAL64(uptr, stat, const char *path, void *buf) {
    119   return _REAL64(stat)(path, (struct stat *)buf);
    120 }
    121 
    122 DECLARE__REAL_AND_INTERNAL64(uptr, lstat, const char *path, void *buf) {
    123   return _REAL64(lstat)(path, (struct stat *)buf);
    124 }
    125 
    126 DECLARE__REAL_AND_INTERNAL64(uptr, fstat, fd_t fd, void *buf) {
    127   return _REAL64(fstat)(fd, (struct stat *)buf);
    128 }
    129 
    130 uptr internal_filesize(fd_t fd) {
    131   struct stat st;
    132   if (internal_fstat(fd, &st))
    133     return -1;
    134   return (uptr)st.st_size;
    135 }
    136 
    137 DECLARE__REAL_AND_INTERNAL(uptr, dup, int oldfd) {
    138   return _REAL(dup)(oldfd);
    139 }
    140 
    141 DECLARE__REAL_AND_INTERNAL(uptr, dup2, int oldfd, int newfd) {
    142   return _REAL(dup2)(oldfd, newfd);
    143 }
    144 
    145 DECLARE__REAL_AND_INTERNAL(uptr, readlink, const char *path, char *buf,
    146                            uptr bufsize) {
    147   return _REAL(readlink)(path, buf, bufsize);
    148 }
    149 
    150 DECLARE__REAL_AND_INTERNAL(uptr, unlink, const char *path) {
    151   return _REAL(unlink)(path);
    152 }
    153 
    154 DECLARE__REAL_AND_INTERNAL(uptr, rename, const char *oldpath,
    155                            const char *newpath) {
    156   return _REAL(rename)(oldpath, newpath);
    157 }
    158 
    159 DECLARE__REAL_AND_INTERNAL(uptr, sched_yield, void) {
    160   return sched_yield();
    161 }
    162 
    163 DECLARE__REAL_AND_INTERNAL(void, usleep, u64 useconds) {
    164   struct timespec ts;
    165   ts.tv_sec = useconds / 1000000;
    166   ts.tv_nsec = (useconds % 1000000) * 1000;
    167   nanosleep(&ts, nullptr);
    168 }
    169 
    170 DECLARE__REAL_AND_INTERNAL(uptr, execve, const char *filename,
    171                            char *const argv[], char *const envp[]) {
    172   return _REAL(execve)(filename, argv, envp);
    173 }
    174 
    175 DECLARE__REAL_AND_INTERNAL(uptr, waitpid, int pid, int *status, int options) {
    176   return _REAL(waitpid)(pid, status, options);
    177 }
    178 
    179 DECLARE__REAL_AND_INTERNAL(uptr, getpid, void) {
    180   return _REAL(getpid)();
    181 }
    182 
    183 // FIXME: This might be wrong: _getdents doesn't take a struct linux_dirent *.
    184 DECLARE__REAL_AND_INTERNAL64(uptr, getdents, fd_t fd, struct linux_dirent *dirp,
    185                              unsigned int count) {
    186   return _REAL64(getdents)(fd, dirp, count);
    187 }
    188 
    189 DECLARE__REAL_AND_INTERNAL64(uptr, lseek, fd_t fd, OFF_T offset, int whence) {
    190   return _REAL64(lseek)(fd, offset, whence);
    191 }
    192 
    193 // FIXME: This might be wrong: _sigfillset doesn't take a
    194 // __sanitizer_sigset_t *.
    195 DECLARE__REAL_AND_INTERNAL(void, sigfillset, __sanitizer_sigset_t *set) {
    196   _REAL(sigfillset)(set);
    197 }
    198 
    199 // FIXME: This might be wrong: _sigprocmask doesn't take __sanitizer_sigset_t *.
    200 DECLARE__REAL_AND_INTERNAL(uptr, sigprocmask, int how,
    201                            __sanitizer_sigset_t *set,
    202                            __sanitizer_sigset_t *oldset) {
    203   return _REAL(sigprocmask)(how, set, oldset);
    204 }
    205 
    206 DECLARE__REAL_AND_INTERNAL(int, fork, void) {
    207   // TODO(glider): this may call user's pthread_atfork() handlers which is bad.
    208   return _REAL(fork)();
    209 }
    210 
    211 u64 NanoTime() {
    212   return gethrtime();
    213 }
    214 
    215 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
    216   // FIXME: No internal variant.
    217   return clock_gettime(clk_id, (timespec *)tp);
    218 }
    219 
    220 // ----------------- sanitizer_common.h
    221 void FutexWait(atomic_uint32_t *p, u32 cmp) {
    222   // FIXME: implement actual blocking.
    223   sched_yield();
    224 }
    225 
    226 void FutexWake(atomic_uint32_t *p, u32 count) {}
    227 
    228 }  // namespace __sanitizer
    229 
    230 #endif  // SANITIZER_SOLARIS
    231