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