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(uptr, execve, const char *filename, 164 char *const argv[], char *const envp[]) { 165 return _REAL(execve)(filename, argv, envp); 166 } 167 168 DECLARE__REAL_AND_INTERNAL(uptr, waitpid, int pid, int *status, int options) { 169 return _REAL(waitpid)(pid, status, options); 170 } 171 172 DECLARE__REAL_AND_INTERNAL(uptr, getpid, void) { 173 return _REAL(getpid)(); 174 } 175 176 // FIXME: This might be wrong: _getdents doesn't take a struct linux_dirent *. 177 DECLARE__REAL_AND_INTERNAL64(uptr, getdents, fd_t fd, struct linux_dirent *dirp, 178 unsigned int count) { 179 return _REAL64(getdents)(fd, dirp, count); 180 } 181 182 DECLARE__REAL_AND_INTERNAL64(uptr, lseek, fd_t fd, OFF_T offset, int whence) { 183 return _REAL64(lseek)(fd, offset, whence); 184 } 185 186 // FIXME: This might be wrong: _sigfillset doesn't take a 187 // __sanitizer_sigset_t *. 188 DECLARE__REAL_AND_INTERNAL(void, sigfillset, __sanitizer_sigset_t *set) { 189 _REAL(sigfillset)(set); 190 } 191 192 // FIXME: This might be wrong: _sigprocmask doesn't take __sanitizer_sigset_t *. 193 DECLARE__REAL_AND_INTERNAL(uptr, sigprocmask, int how, 194 __sanitizer_sigset_t *set, 195 __sanitizer_sigset_t *oldset) { 196 return _REAL(sigprocmask)(how, set, oldset); 197 } 198 199 DECLARE__REAL_AND_INTERNAL(int, fork, void) { 200 // TODO(glider): this may call user's pthread_atfork() handlers which is bad. 201 return _REAL(fork)(); 202 } 203 204 u64 NanoTime() { 205 return gethrtime(); 206 } 207 208 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) { 209 // FIXME: No internal variant. 210 return clock_gettime(clk_id, (timespec *)tp); 211 } 212 213 // ----------------- sanitizer_common.h 214 BlockingMutex::BlockingMutex() { 215 CHECK(sizeof(mutex_t) <= sizeof(opaque_storage_)); 216 internal_memset(this, 0, sizeof(*this)); 217 CHECK_EQ(mutex_init((mutex_t *)&opaque_storage_, USYNC_THREAD, NULL), 0); 218 } 219 220 void BlockingMutex::Lock() { 221 CHECK(sizeof(mutex_t) <= sizeof(opaque_storage_)); 222 CHECK_NE(owner_, (uptr)thr_self()); 223 CHECK_EQ(mutex_lock((mutex_t *)&opaque_storage_), 0); 224 CHECK(!owner_); 225 owner_ = (uptr)thr_self(); 226 } 227 228 void BlockingMutex::Unlock() { 229 CHECK(owner_ == (uptr)thr_self()); 230 owner_ = 0; 231 CHECK_EQ(mutex_unlock((mutex_t *)&opaque_storage_), 0); 232 } 233 234 void BlockingMutex::CheckLocked() { 235 CHECK_EQ((uptr)thr_self(), owner_); 236 } 237 238 } // namespace __sanitizer 239 240 #endif // SANITIZER_SOLARIS 241