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
51extern "C" void *__mmap(void *, size_t, int, int, int, int,
52 off_t) SANITIZER_WEAK_ATTRIBUTE;
53extern "C" int __sysctl(const int *, unsigned int, void *, size_t *,
54 const void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
55extern "C" int _sys_close(int) SANITIZER_WEAK_ATTRIBUTE;
56extern "C" int _sys_open(const char *, int, ...) SANITIZER_WEAK_ATTRIBUTE;
57extern "C" ssize_t _sys_read(int, void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
58extern "C" ssize_t _sys_write(int, const void *,
59 size_t) SANITIZER_WEAK_ATTRIBUTE;
60extern "C" int __ftruncate(int, int, off_t) SANITIZER_WEAK_ATTRIBUTE;
61extern "C" ssize_t _sys_readlink(const char *, char *,
62 size_t) SANITIZER_WEAK_ATTRIBUTE;
63extern "C" int _sys_sched_yield() SANITIZER_WEAK_ATTRIBUTE;
64extern "C" int _sys___nanosleep50(const void *,
65 void *) SANITIZER_WEAK_ATTRIBUTE;
66extern "C" int _sys_execve(const char *, char *const[],
67 char *const[]) SANITIZER_WEAK_ATTRIBUTE;
68extern "C" off_t __lseek(int, int, off_t, int) SANITIZER_WEAK_ATTRIBUTE;
69extern "C" int __fork() SANITIZER_WEAK_ATTRIBUTE;
70extern "C" int _sys___sigprocmask14(int, const void *,
71 void *) SANITIZER_WEAK_ATTRIBUTE;
72extern "C" int _sys___wait450(int wpid, int *, int,
73 void *) SANITIZER_WEAK_ATTRIBUTE;
74
75namespace __sanitizer {
76
77static 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
97uptr 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
103uptr internal_munmap(void *addr, uptr length) {
104 DEFINE__REAL(int, munmap, void *a, uptr b);
105 return _REAL(munmap, addr, length);
106}
107
108uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
109 void *new_address) {
110 CHECK(false && "internal_mremap is unimplemented on NetBSD");
111 return 0;
112}
113
114int internal_mprotect(void *addr, uptr length, int prot) {
115 DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
116 return _REAL(mprotect, addr, length, prot);
117}
118
119int internal_madvise(uptr addr, uptr length, int advice) {
120 DEFINE__REAL(int, madvise, void *a, uptr b, int c);
121 return _REAL(madvise, (void *)addr, length, advice);
122}
123
124uptr internal_close(fd_t fd) {
125 CHECK(&_sys_close);
126 return _sys_close(fd);
127}
128
129uptr internal_close_range(fd_t lowfd, fd_t highfd, int flags) {
130 return -1; // Not supported.
131}
132
133uptr internal_open(const char *filename, int flags) {
134 CHECK(&_sys_open);
135 return _sys_open(filename, flags);
136}
137
138uptr internal_open(const char *filename, int flags, u32 mode) {
139 CHECK(&_sys_open);
140 return _sys_open(filename, flags, mode);
141}
142
143uptr internal_read(fd_t fd, void *buf, uptr count) {
144 sptr res;
145 CHECK(&_sys_read);
146 HANDLE_EINTR(res, (sptr)_sys_read(fd, buf, (size_t)count));
147 return res;
148}
149
150uptr internal_write(fd_t fd, const void *buf, uptr count) {
151 sptr res;
152 CHECK(&_sys_write);
153 HANDLE_EINTR(res, (sptr)_sys_write(fd, buf, count));
154 return res;
155}
156
157uptr internal_ftruncate(fd_t fd, uptr size) {
158 sptr res;
159 CHECK(&__ftruncate);
160 HANDLE_EINTR(res, __ftruncate(fd, 0, (s64)size));
161 return res;
162}
163
164uptr internal_stat(const char *path, void *buf) {
165 DEFINE__REAL(int, __stat50, const char *a, void *b);
166 return _REAL(__stat50, path, buf);
167}
168
169uptr internal_lstat(const char *path, void *buf) {
170 DEFINE__REAL(int, __lstat50, const char *a, void *b);
171 return _REAL(__lstat50, path, buf);
172}
173
174uptr internal_fstat(fd_t fd, void *buf) {
175 DEFINE__REAL(int, __fstat50, int a, void *b);
176 return _REAL(__fstat50, fd, buf);
177}
178
179uptr internal_filesize(fd_t fd) {
180 struct stat st;
181 if (internal_fstat(fd, &st))
182 return -1;
183 return (uptr)st.st_size;
184}
185
186uptr internal_dup(int oldfd) {
187 DEFINE__REAL(int, dup, int a);
188 return _REAL(dup, oldfd);
189}
190
191uptr internal_dup2(int oldfd, int newfd) {
192 DEFINE__REAL(int, dup2, int a, int b);
193 return _REAL(dup2, oldfd, newfd);
194}
195
196uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
197 CHECK(&_sys_readlink);
198 return (uptr)_sys_readlink(path, buf, bufsize);
199}
200
201uptr internal_unlink(const char *path) {
202 DEFINE__REAL(int, unlink, const char *a);
203 return _REAL(unlink, path);
204}
205
206uptr internal_rename(const char *oldpath, const char *newpath) {
207 DEFINE__REAL(int, rename, const char *a, const char *b);
208 return _REAL(rename, oldpath, newpath);
209}
210
211uptr internal_sched_yield() {
212 CHECK(&_sys_sched_yield);
213 return _sys_sched_yield();
214}
215
216void internal__exit(int exitcode) {
217 DEFINE__REAL(void, _exit, int a);
218 _REAL(_exit, exitcode);
219 Die(); // Unreachable.
220}
221
222void internal_usleep(u64 useconds) {
223 struct timespec ts;
224 ts.tv_sec = useconds / 1000000;
225 ts.tv_nsec = (useconds % 1000000) * 1000;
226 CHECK(&_sys___nanosleep50);
227 _sys___nanosleep50(&ts, &ts);
228}
229
230uptr internal_execve(const char *filename, char *const argv[],
231 char *const envp[]) {
232 CHECK(&_sys_execve);
233 return _sys_execve(filename, argv, envp);
234}
235
236ThreadID GetTid() {
237 DEFINE__REAL(int, _lwp_self);
238 return _REAL(_lwp_self);
239}
240
241int TgKill(pid_t pid, ThreadID tid, int sig) {
242 DEFINE__REAL(int, _lwp_kill, int a, int b);
243 (void)pid;
244 return _REAL(_lwp_kill, tid, sig);
245}
246
247u64 NanoTime() {
248 timeval tv;
249 DEFINE__REAL(int, __gettimeofday50, void *a, void *b);
250 internal_memset(&tv, 0, sizeof(tv));
251 _REAL(__gettimeofday50, &tv, 0);
252 return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
253}
254
255uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
256 DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
257 return _REAL(__clock_gettime50, clk_id, tp);
258}
259
260uptr internal_ptrace(int request, int pid, void *addr, int data) {
261 DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
262 return _REAL(ptrace, request, pid, addr, data);
263}
264
265uptr internal_waitpid(int pid, int *status, int options) {
266 CHECK(&_sys___wait450);
267 return _sys___wait450(pid, status, options, 0 /* rusage */);
268}
269
270uptr internal_getpid() {
271 DEFINE__REAL(int, getpid);
272 return _REAL(getpid);
273}
274
275uptr internal_getppid() {
276 DEFINE__REAL(int, getppid);
277 return _REAL(getppid);
278}
279
280int internal_dlinfo(void *handle, int request, void *p) {
281 DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
282 return _REAL(dlinfo, handle, request, p);
283}
284
285uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
286 DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
287 return _REAL(__getdents30, fd, dirp, count);
288}
289
290uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
291 CHECK(&__lseek);
292 return __lseek(fd, 0, offset, whence);
293}
294
295uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
296 Printf("internal_prctl not implemented for NetBSD");
297 Die();
298 return 0;
299}
300
301uptr internal_sigaltstack(const void *ss, void *oss) {
302 DEFINE__REAL(int, __sigaltstack14, const void *a, void *b);
303 return _REAL(__sigaltstack14, ss, oss);
304}
305
306int internal_fork() {
307 CHECK(&__fork);
308 return __fork();
309}
310
311int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
312 uptr *oldlenp, const void *newp, uptr newlen) {
313 CHECK(&__sysctl);
314 return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
315}
316
317int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
318 const void *newp, uptr newlen) {
319 DEFINE__REAL(int, sysctlbyname, const char *a, void *b, size_t *c,
320 const void *d, size_t e);
321 return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
322 (size_t)newlen);
323}
324
325uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
326 __sanitizer_sigset_t *oldset) {
327 CHECK(&_sys___sigprocmask14);
328 return _sys___sigprocmask14(how, set, oldset);
329}
330
331void internal_sigfillset(__sanitizer_sigset_t *set) {
332 DEFINE__REAL(int, __sigfillset14, const void *a);
333 (void)_REAL(__sigfillset14, set);
334}
335
336void internal_sigemptyset(__sanitizer_sigset_t *set) {
337 DEFINE__REAL(int, __sigemptyset14, const void *a);
338 (void)_REAL(__sigemptyset14, set);
339}
340
341void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
342 DEFINE__REAL(int, __sigdelset14, const void *a, int b);
343 (void)_REAL(__sigdelset14, set, signo);
344}
345
346uptr internal_clone(int (*fn)(void *), void *child_stack, int flags,
347 void *arg) {
348 DEFINE__REAL(int, clone, int (*a)(void *b), void *c, int d, void *e);
349
350 return _REAL(clone, fn, child_stack, flags, arg);
351}
352
353} // namespace __sanitizer
354
355#endif
356