1 //===-- sanitizer_netbsd.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 Sanitizer run-time libraries and implements
10 // NetBSD-specific functions from sanitizer_libc.h.
11 //===----------------------------------------------------------------------===//
12 
13 #include "sanitizer_platform.h"
14 
15 #if SANITIZER_NETBSD
16 
17 #include "sanitizer_common.h"
18 #include "sanitizer_flags.h"
19 #include "sanitizer_getauxval.h"
20 #include "sanitizer_internal_defs.h"
21 #include "sanitizer_libc.h"
22 #include "sanitizer_linux.h"
23 #include "sanitizer_mutex.h"
24 #include "sanitizer_placement_new.h"
25 #include "sanitizer_procmaps.h"
26 
27 #include <sys/param.h>
28 #include <sys/types.h>
29 
30 #include <sys/exec.h>
31 #include <sys/mman.h>
32 #include <sys/ptrace.h>
33 #include <sys/resource.h>
34 #include <sys/stat.h>
35 #include <sys/syscall.h>
36 #include <sys/sysctl.h>
37 #include <sys/time.h>
38 
39 #include <dlfcn.h>
40 #include <errno.h>
41 #include <fcntl.h>
42 #include <limits.h>
43 #include <link.h>
44 #include <lwp.h>
45 #include <pthread.h>
46 #include <sched.h>
47 #include <signal.h>
48 #include <ucontext.h>
49 #include <unistd.h>
50 
51 extern "C" void *__mmap(void *, size_t, int, int, int, int,
52                         off_t) SANITIZER_WEAK_ATTRIBUTE;
53 extern "C" int __sysctl(const int *, unsigned int, void *, size_t *,
54                         const void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
55 extern "C" int _sys_close(int) SANITIZER_WEAK_ATTRIBUTE;
56 extern "C" int _sys_open(const char *, int, ...) SANITIZER_WEAK_ATTRIBUTE;
57 extern "C" ssize_t _sys_read(int, void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
58 extern "C" ssize_t _sys_write(int, const void *,
59                               size_t) SANITIZER_WEAK_ATTRIBUTE;
60 extern "C" int __ftruncate(int, int, off_t) SANITIZER_WEAK_ATTRIBUTE;
61 extern "C" ssize_t _sys_readlink(const char *, char *,
62                                  size_t) SANITIZER_WEAK_ATTRIBUTE;
63 extern "C" int _sys_sched_yield() SANITIZER_WEAK_ATTRIBUTE;
64 extern "C" int _sys___nanosleep50(const void *,
65                                   void *) SANITIZER_WEAK_ATTRIBUTE;
66 extern "C" int _sys_execve(const char *, char *const[],
67                            char *const[]) SANITIZER_WEAK_ATTRIBUTE;
68 extern "C" off_t __lseek(int, int, off_t, int) SANITIZER_WEAK_ATTRIBUTE;
69 extern "C" int __fork() SANITIZER_WEAK_ATTRIBUTE;
70 extern "C" int _sys___sigprocmask14(int, const void *,
71                                     void *) SANITIZER_WEAK_ATTRIBUTE;
72 extern "C" int _sys___wait450(int wpid, int *, int,
73                               void *) SANITIZER_WEAK_ATTRIBUTE;
74 
75 namespace __sanitizer {
76 
77 static void *GetRealLibcAddress(const char *symbol) {
78   void *real = dlsym(RTLD_NEXT, symbol);
79   if (!real)
80     real = dlsym(RTLD_DEFAULT, symbol);
81   if (!real) {
82     Printf("GetRealLibcAddress failed for symbol=%s", symbol);
83     Die();
84   }
85   return real;
86 }
87 
88 #define _REAL(func, ...) real##_##func(__VA_ARGS__)
89 #define DEFINE__REAL(ret_type, func, ...)                              \
90   static ret_type (*real_##func)(__VA_ARGS__) = NULL;                  \
91   if (!real_##func) {                                                  \
92     real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
93   }                                                                    \
94   CHECK(real_##func);
95 
96 // --------------- sanitizer_libc.h
97 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
98                    u64 offset) {
99   CHECK(&__mmap);
100   return (uptr)__mmap(addr, length, prot, flags, fd, 0, offset);
101 }
102 
103 uptr internal_munmap(void *addr, uptr length) {
104   DEFINE__REAL(int, munmap, void *a, uptr b);
105   return _REAL(munmap, addr, length);
106 }
107 
108 int internal_mprotect(void *addr, uptr length, int prot) {
109   DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
110   return _REAL(mprotect, addr, length, prot);
111 }
112 
113 int internal_madvise(uptr addr, uptr length, int advice) {
114   DEFINE__REAL(int, madvise, void *a, uptr b, int c);
115   return _REAL(madvise, (void *)addr, length, advice);
116 }
117 
118 uptr internal_close(fd_t fd) {
119   CHECK(&_sys_close);
120   return _sys_close(fd);
121 }
122 
123 uptr internal_open(const char *filename, int flags) {
124   CHECK(&_sys_open);
125   return _sys_open(filename, flags);
126 }
127 
128 uptr internal_open(const char *filename, int flags, u32 mode) {
129   CHECK(&_sys_open);
130   return _sys_open(filename, flags, mode);
131 }
132 
133 uptr internal_read(fd_t fd, void *buf, uptr count) {
134   sptr res;
135   CHECK(&_sys_read);
136   HANDLE_EINTR(res, (sptr)_sys_read(fd, buf, (size_t)count));
137   return res;
138 }
139 
140 uptr internal_write(fd_t fd, const void *buf, uptr count) {
141   sptr res;
142   CHECK(&_sys_write);
143   HANDLE_EINTR(res, (sptr)_sys_write(fd, buf, count));
144   return res;
145 }
146 
147 uptr internal_ftruncate(fd_t fd, uptr size) {
148   sptr res;
149   CHECK(&__ftruncate);
150   HANDLE_EINTR(res, __ftruncate(fd, 0, (s64)size));
151   return res;
152 }
153 
154 uptr internal_stat(const char *path, void *buf) {
155   DEFINE__REAL(int, __stat50, const char *a, void *b);
156   return _REAL(__stat50, path, buf);
157 }
158 
159 uptr internal_lstat(const char *path, void *buf) {
160   DEFINE__REAL(int, __lstat50, const char *a, void *b);
161   return _REAL(__lstat50, path, buf);
162 }
163 
164 uptr internal_fstat(fd_t fd, void *buf) {
165   DEFINE__REAL(int, __fstat50, int a, void *b);
166   return _REAL(__fstat50, fd, buf);
167 }
168 
169 uptr internal_filesize(fd_t fd) {
170   struct stat st;
171   if (internal_fstat(fd, &st))
172     return -1;
173   return (uptr)st.st_size;
174 }
175 
176 uptr internal_dup(int oldfd) {
177   DEFINE__REAL(int, dup, int a);
178   return _REAL(dup, oldfd);
179 }
180 
181 uptr internal_dup2(int oldfd, int newfd) {
182   DEFINE__REAL(int, dup2, int a, int b);
183   return _REAL(dup2, oldfd, newfd);
184 }
185 
186 uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
187   CHECK(&_sys_readlink);
188   return (uptr)_sys_readlink(path, buf, bufsize);
189 }
190 
191 uptr internal_unlink(const char *path) {
192   DEFINE__REAL(int, unlink, const char *a);
193   return _REAL(unlink, path);
194 }
195 
196 uptr internal_rename(const char *oldpath, const char *newpath) {
197   DEFINE__REAL(int, rename, const char *a, const char *b);
198   return _REAL(rename, oldpath, newpath);
199 }
200 
201 uptr internal_sched_yield() {
202   CHECK(&_sys_sched_yield);
203   return _sys_sched_yield();
204 }
205 
206 void internal__exit(int exitcode) {
207   DEFINE__REAL(void, _exit, int a);
208   _REAL(_exit, exitcode);
209   Die();  // Unreachable.
210 }
211 
212 unsigned int internal_sleep(unsigned int seconds) {
213   struct timespec ts;
214   ts.tv_sec = seconds;
215   ts.tv_nsec = 0;
216   CHECK(&_sys___nanosleep50);
217   int res = _sys___nanosleep50(&ts, &ts);
218   if (res)
219     return ts.tv_sec;
220   return 0;
221 }
222 
223 uptr internal_execve(const char *filename, char *const argv[],
224                      char *const envp[]) {
225   CHECK(&_sys_execve);
226   return _sys_execve(filename, argv, envp);
227 }
228 
229 tid_t GetTid() {
230   DEFINE__REAL(int, _lwp_self);
231   return _REAL(_lwp_self);
232 }
233 
234 int TgKill(pid_t pid, tid_t tid, int sig) {
235   DEFINE__REAL(int, _lwp_kill, int a, int b);
236   (void)pid;
237   return _REAL(_lwp_kill, tid, sig);
238 }
239 
240 u64 NanoTime() {
241   timeval tv;
242   DEFINE__REAL(int, __gettimeofday50, void *a, void *b);
243   internal_memset(&tv, 0, sizeof(tv));
244   _REAL(__gettimeofday50, &tv, 0);
245   return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
246 }
247 
248 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
249   DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
250   return _REAL(__clock_gettime50, clk_id, tp);
251 }
252 
253 uptr internal_ptrace(int request, int pid, void *addr, int data) {
254   DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
255   return _REAL(ptrace, request, pid, addr, data);
256 }
257 
258 uptr internal_waitpid(int pid, int *status, int options) {
259   CHECK(&_sys___wait450);
260   return _sys___wait450(pid, status, options, 0 /* rusage */);
261 }
262 
263 uptr internal_getpid() {
264   DEFINE__REAL(int, getpid);
265   return _REAL(getpid);
266 }
267 
268 uptr internal_getppid() {
269   DEFINE__REAL(int, getppid);
270   return _REAL(getppid);
271 }
272 
273 int internal_dlinfo(void *handle, int request, void *p) {
274   DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
275   return _REAL(dlinfo, handle, request, p);
276 }
277 
278 uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
279   DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
280   return _REAL(__getdents30, fd, dirp, count);
281 }
282 
283 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
284   CHECK(&__lseek);
285   return __lseek(fd, 0, offset, whence);
286 }
287 
288 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
289   Printf("internal_prctl not implemented for NetBSD");
290   Die();
291   return 0;
292 }
293 
294 uptr internal_sigaltstack(const void *ss, void *oss) {
295   DEFINE__REAL(int, __sigaltstack14, const void *a, void *b);
296   return _REAL(__sigaltstack14, ss, oss);
297 }
298 
299 int internal_fork() {
300   CHECK(&__fork);
301   return __fork();
302 }
303 
304 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
305                     uptr *oldlenp, const void *newp, uptr newlen) {
306   CHECK(&__sysctl);
307   return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
308 }
309 
310 int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
311                           const void *newp, uptr newlen) {
312   DEFINE__REAL(int, sysctlbyname, const char *a, void *b, size_t *c,
313                const void *d, size_t e);
314   return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
315                (size_t)newlen);
316 }
317 
318 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
319                           __sanitizer_sigset_t *oldset) {
320   CHECK(&_sys___sigprocmask14);
321   return _sys___sigprocmask14(how, set, oldset);
322 }
323 
324 void internal_sigfillset(__sanitizer_sigset_t *set) {
325   DEFINE__REAL(int, __sigfillset14, const void *a);
326   (void)_REAL(__sigfillset14, set);
327 }
328 
329 void internal_sigemptyset(__sanitizer_sigset_t *set) {
330   DEFINE__REAL(int, __sigemptyset14, const void *a);
331   (void)_REAL(__sigemptyset14, set);
332 }
333 
334 void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
335   DEFINE__REAL(int, __sigdelset14, const void *a, int b);
336   (void)_REAL(__sigdelset14, set, signo);
337 }
338 
339 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags,
340                     void *arg) {
341   DEFINE__REAL(int, clone, int (*a)(void *b), void *c, int d, void *e);
342 
343   return _REAL(clone, fn, child_stack, flags, arg);
344 }
345 
346 }  // namespace __sanitizer
347 
348 #endif
349