1//===-- sanitizer_haiku.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// Haiku-specific functions from sanitizer_libc.h.
11//===----------------------------------------------------------------------===//
12
13#include "sanitizer_platform.h"
14
15#if SANITIZER_HAIKU
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/mman.h>
31# include <sys/resource.h>
32# include <sys/stat.h>
33# include <sys/time.h>
34
35# include <dlfcn.h>
36# include <errno.h>
37# include <fcntl.h>
38# include <limits.h>
39# include <link.h>
40# include <pthread.h>
41# include <sched.h>
42# include <signal.h>
43# include <unistd.h>
44
45# include "system/vm_defs.h"
46# include "system/syscalls.h"
47# include "shared/syscall_utils.h"
48
49namespace __sanitizer {
50
51static void *GetRealLibcAddress(const char *symbol) {
52 void *real = dlsym(RTLD_NEXT, symbol);
53 if (!real)
54 real = dlsym(RTLD_DEFAULT, symbol);
55 if (!real) {
56 Printf("GetRealLibcAddress failed for symbol=%s", symbol);
57 Die();
58 }
59 return real;
60}
61
62# define _REAL(func, ...) real##_##func(__VA_ARGS__)
63# define DEFINE__REAL(ret_type, func, ...) \
64 static ret_type (*real_##func)(__VA_ARGS__) = NULL; \
65 if (!real_##func) { \
66 real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
67 } \
68 CHECK(real_##func);
69
70// --------------- sanitizer_libc.h
71uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
72 u64 offset) {
73 if ((flags & MAP_ANONYMOUS) != 0)
74 fd = -1;
75
76 int mapping =
77 (flags & MAP_SHARED) != 0 ? REGION_NO_PRIVATE_MAP : REGION_PRIVATE_MAP;
78
79 uint32 addressSpec;
80 if ((flags & MAP_FIXED) != 0)
81 addressSpec = B_EXACT_ADDRESS;
82 else if (addr != NULL)
83 addressSpec = B_BASE_ADDRESS;
84 else
85 addressSpec = B_RANDOMIZED_ANY_ADDRESS;
86
87 uint32 areaProtection = 0;
88 if ((prot & PROT_READ) != 0)
89 areaProtection |= B_READ_AREA;
90 if ((prot & PROT_WRITE) != 0)
91 areaProtection |= B_WRITE_AREA;
92 if ((prot & PROT_EXEC) != 0)
93 areaProtection |= B_EXECUTE_AREA;
94
95 if ((flags & MAP_NORESERVE) != 0)
96 areaProtection |= B_OVERCOMMITTING_AREA;
97
98 area_id area = _kern_map_file("sanitizer mmap", &addr, addressSpec, length,
99 areaProtection, mapping, true, fd, offset);
100 if (area < 0)
101 RETURN_AND_SET_ERRNO(area);
102 return (uptr)addr;
103}
104
105uptr internal_munmap(void *addr, uptr length) {
106 DEFINE__REAL(int, munmap, void *a, uptr b);
107 return _REAL(munmap, addr, length);
108}
109
110uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
111 void *new_address) {
112 CHECK(false && "internal_mremap is unimplemented on Haiku");
113 return 0;
114}
115
116int internal_mprotect(void *addr, uptr length, int prot) {
117 DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
118 return _REAL(mprotect, addr, length, prot);
119}
120
121int internal_madvise(uptr addr, uptr length, int advice) {
122 DEFINE__REAL(int, madvise, void *a, uptr b, int c);
123 return _REAL(madvise, (void *)addr, length, advice);
124}
125
126uptr internal_close(fd_t fd) {
127 CHECK(&_kern_close);
128 RETURN_AND_SET_ERRNO(_kern_close(fd));
129}
130
131uptr internal_close_range(fd_t lowfd, fd_t highfd, int flags) {
132 return -1; // Not supported.
133}
134
135uptr internal_open(const char *filename, int flags) {
136 CHECK(&_kern_open);
137 RETURN_AND_SET_ERRNO(_kern_open(-1, filename, flags, 0));
138}
139
140uptr internal_open(const char *filename, int flags, u32 mode) {
141 CHECK(&_kern_open);
142 RETURN_AND_SET_ERRNO(_kern_open(-1, filename, flags, mode));
143}
144
145uptr internal_read(fd_t fd, void *buf, uptr count) {
146 sptr res;
147 CHECK(&_kern_read);
148 HANDLE_EINTR(res, (sptr)_kern_read(fd, -1, buf, (size_t)count));
149 RETURN_AND_SET_ERRNO(res);
150 return res;
151}
152
153uptr internal_write(fd_t fd, const void *buf, uptr count) {
154 sptr res;
155 CHECK(&_kern_write);
156 HANDLE_EINTR(res, (sptr)_kern_write(fd, -1, buf, count));
157 RETURN_AND_SET_ERRNO(res);
158 return res;
159}
160
161uptr internal_ftruncate(fd_t fd, uptr size) {
162 sptr res;
163 DEFINE__REAL(int, ftruncate, int, off_t);
164 return _REAL(ftruncate, fd, size);
165 return res;
166}
167
168uptr internal_stat(const char *path, void *buf) {
169 DEFINE__REAL(int, _stat_current, const char *a, void *b);
170 return _REAL(_stat_current, path, buf);
171}
172
173uptr internal_lstat(const char *path, void *buf) {
174 DEFINE__REAL(int, _lstat_current, const char *a, void *b);
175 return _REAL(_lstat_current, path, buf);
176}
177
178uptr internal_fstat(fd_t fd, void *buf) {
179 DEFINE__REAL(int, _fstat_current, int a, void *b);
180 return _REAL(_fstat_current, fd, buf);
181}
182
183uptr internal_filesize(fd_t fd) {
184 struct stat st;
185 if (internal_fstat(fd, &st))
186 return -1;
187 return (uptr)st.st_size;
188}
189
190uptr internal_dup(int oldfd) {
191 DEFINE__REAL(int, dup, int a);
192 return _REAL(dup, oldfd);
193}
194
195uptr internal_dup2(int oldfd, int newfd) {
196 DEFINE__REAL(int, dup2, int a, int b);
197 return _REAL(dup2, oldfd, newfd);
198}
199
200uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
201 CHECK(&_kern_read_link);
202 RETURN_AND_SET_ERRNO(_kern_read_link(-1, path, buf, &bufsize));
203}
204
205uptr internal_unlink(const char *path) {
206 DEFINE__REAL(int, unlink, const char *a);
207 return _REAL(unlink, path);
208}
209
210uptr internal_rename(const char *oldpath, const char *newpath) {
211 DEFINE__REAL(int, rename, const char *a, const char *b);
212 return _REAL(rename, oldpath, newpath);
213}
214
215uptr internal_sched_yield() {
216 CHECK(&_kern_thread_yield);
217 _kern_thread_yield();
218 return 0;
219}
220
221void internal__exit(int exitcode) {
222 DEFINE__REAL(void, _exit, int a);
223 _REAL(_exit, exitcode);
224 Die(); // Unreachable.
225}
226
227void internal_usleep(u64 useconds) {
228 _kern_snooze_etc(useconds, B_SYSTEM_TIMEBASE, B_RELATIVE_TIMEOUT, NULL);
229}
230
231uptr internal_execve(const char *filename, char *const argv[],
232 char *const envp[]) {
233 DEFINE__REAL(int, execve, const char *, char *const[], char *const[]);
234 return _REAL(execve, filename, argv, envp);
235}
236
237# if 0
238ThreadID GetTid() {
239 DEFINE__REAL(int, _lwp_self);
240 return _REAL(_lwp_self);
241}
242
243int TgKill(pid_t pid, ThreadID tid, int sig) {
244 DEFINE__REAL(int, _lwp_kill, int a, int b);
245 (void)pid;
246 return _REAL(_lwp_kill, tid, sig);
247}
248
249u64 NanoTime() {
250 timeval tv;
251 DEFINE__REAL(int, __gettimeofday50, void *a, void *b);
252 internal_memset(&tv, 0, sizeof(tv));
253 _REAL(__gettimeofday50, &tv, 0);
254 return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
255}
256# endif
257
258uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
259 DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
260 return _REAL(__clock_gettime50, clk_id, tp);
261}
262
263uptr internal_ptrace(int request, int pid, void *addr, int data) {
264 DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
265 return _REAL(ptrace, request, pid, addr, data);
266}
267
268uptr internal_waitpid(int pid, int *status, int options) {
269 DEFINE__REAL(int, waitpid, pid_t, int *, int);
270 return _REAL(waitpid, pid, status, options);
271}
272
273uptr internal_getpid() {
274 DEFINE__REAL(int, getpid);
275 return _REAL(getpid);
276}
277
278uptr internal_getppid() {
279 DEFINE__REAL(int, getppid);
280 return _REAL(getppid);
281}
282
283int internal_dlinfo(void *handle, int request, void *p) {
284 DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
285 return _REAL(dlinfo, handle, request, p);
286}
287
288uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
289 DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
290 return _REAL(__getdents30, fd, dirp, count);
291}
292
293uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
294 CHECK(&_kern_seek);
295 off_t result = _kern_seek(fd, offset, whence);
296 if (result < 0) {
297 errno = result;
298 return -1;
299 }
300 return result;
301}
302
303uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
304 Printf("internal_prctl not implemented for Haiku");
305 Die();
306 return 0;
307}
308
309uptr internal_sigaltstack(const void *ss, void *oss) {
310 DEFINE__REAL(int, __sigaltstack14, const void *a, void *b);
311 return _REAL(__sigaltstack14, ss, oss);
312}
313
314int internal_fork() {
315 DEFINE__REAL(int, fork);
316 return _REAL(fork);
317}
318
319# if 0
320int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
321 uptr *oldlenp, const void *newp, uptr newlen) {
322 CHECK(&__sysctl);
323 return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
324}
325# endif
326
327int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
328 const void *newp, uptr newlen) {
329 DEFINE__REAL(int, sysctlbyname, const char *a, void *b, size_t *c,
330 const void *d, size_t e);
331 return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
332 (size_t)newlen);
333}
334
335uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
336 __sanitizer_sigset_t *oldset) {
337 CHECK(&_kern_set_signal_mask);
338 return _kern_set_signal_mask(how, set, oldset);
339}
340
341void internal_sigfillset(__sanitizer_sigset_t *set) {
342 DEFINE__REAL(int, __sigfillset14, const void *a);
343 (void)_REAL(__sigfillset14, set);
344}
345
346void internal_sigemptyset(__sanitizer_sigset_t *set) {
347 DEFINE__REAL(int, __sigemptyset14, const void *a);
348 (void)_REAL(__sigemptyset14, set);
349}
350
351void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
352 DEFINE__REAL(int, __sigdelset14, const void *a, int b);
353 (void)_REAL(__sigdelset14, set, signo);
354}
355
356uptr internal_clone(int (*fn)(void *), void *child_stack, int flags,
357 void *arg) {
358 DEFINE__REAL(int, clone, int (*a)(void *b), void *c, int d, void *e);
359
360 return _REAL(clone, fn, child_stack, flags, arg);
361}
362
363} // namespace __sanitizer
364
365#endif
366