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
41namespace __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
64DECLARE__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
69DECLARE__REAL_AND_INTERNAL(uptr, munmap, void *addr, uptr length) {
70  return _REAL(munmap)(addr, length);
71}
72
73DECLARE__REAL_AND_INTERNAL(int, mprotect, void *addr, uptr length, int prot) {
74  return _REAL(mprotect)(addr, length, prot);
75}
76
77DECLARE__REAL_AND_INTERNAL(uptr, close, fd_t fd) {
78  return _REAL(close)(fd);
79}
80
81extern "C" int _REAL64(open)(const char *, int, ...);
82
83uptr internal_open(const char *filename, int flags) {
84  return _REAL64(open)(filename, flags);
85}
86
87uptr internal_open(const char *filename, int flags, u32 mode) {
88  return _REAL64(open)(filename, flags, mode);
89}
90
91DECLARE__REAL_AND_INTERNAL(uptr, read, fd_t fd, void *buf, uptr count) {
92  return _REAL(read)(fd, buf, count);
93}
94
95DECLARE__REAL_AND_INTERNAL(uptr, write, fd_t fd, const void *buf, uptr count) {
96  return _REAL(write)(fd, buf, count);
97}
98
99// FIXME: There's only _ftruncate64 beginning with Solaris 11.
100DECLARE__REAL_AND_INTERNAL(uptr, ftruncate, fd_t fd, uptr size) {
101  return ftruncate(fd, size);
102}
103
104DECLARE__REAL_AND_INTERNAL64(uptr, stat, const char *path, void *buf) {
105  return _REAL64(stat)(path, (struct stat *)buf);
106}
107
108DECLARE__REAL_AND_INTERNAL64(uptr, lstat, const char *path, void *buf) {
109  return _REAL64(lstat)(path, (struct stat *)buf);
110}
111
112DECLARE__REAL_AND_INTERNAL64(uptr, fstat, fd_t fd, void *buf) {
113  return _REAL64(fstat)(fd, (struct stat *)buf);
114}
115
116uptr internal_filesize(fd_t fd) {
117  struct stat st;
118  if (internal_fstat(fd, &st))
119    return -1;
120  return (uptr)st.st_size;
121}
122
123DECLARE__REAL_AND_INTERNAL(uptr, dup, int oldfd) {
124  return _REAL(dup)(oldfd);
125}
126
127DECLARE__REAL_AND_INTERNAL(uptr, dup2, int oldfd, int newfd) {
128  return _REAL(dup2)(oldfd, newfd);
129}
130
131DECLARE__REAL_AND_INTERNAL(uptr, readlink, const char *path, char *buf,
132                           uptr bufsize) {
133  return _REAL(readlink)(path, buf, bufsize);
134}
135
136DECLARE__REAL_AND_INTERNAL(uptr, unlink, const char *path) {
137  return _REAL(unlink)(path);
138}
139
140DECLARE__REAL_AND_INTERNAL(uptr, rename, const char *oldpath,
141                           const char *newpath) {
142  return _REAL(rename)(oldpath, newpath);
143}
144
145DECLARE__REAL_AND_INTERNAL(uptr, sched_yield, void) {
146  return sched_yield();
147}
148
149DECLARE__REAL_AND_INTERNAL(void, _exit, int exitcode) {
150  _exit(exitcode);
151}
152
153DECLARE__REAL_AND_INTERNAL(uptr, execve, const char *filename,
154                           char *const argv[], char *const envp[]) {
155  return _REAL(execve)(filename, argv, envp);
156}
157
158DECLARE__REAL_AND_INTERNAL(uptr, waitpid, int pid, int *status, int options) {
159  return _REAL(waitpid)(pid, status, options);
160}
161
162DECLARE__REAL_AND_INTERNAL(uptr, getpid, void) {
163  return _REAL(getpid)();
164}
165
166// FIXME: This might be wrong: _getdents doesn't take a struct linux_dirent *.
167DECLARE__REAL_AND_INTERNAL64(uptr, getdents, fd_t fd, struct linux_dirent *dirp,
168                             unsigned int count) {
169  return _REAL64(getdents)(fd, dirp, count);
170}
171
172DECLARE__REAL_AND_INTERNAL64(uptr, lseek, fd_t fd, OFF_T offset, int whence) {
173  return _REAL64(lseek)(fd, offset, whence);
174}
175
176// FIXME: This might be wrong: _sigfillset doesn't take a
177// __sanitizer_sigset_t *.
178DECLARE__REAL_AND_INTERNAL(void, sigfillset, __sanitizer_sigset_t *set) {
179  _REAL(sigfillset)(set);
180}
181
182// FIXME: This might be wrong: _sigprocmask doesn't take __sanitizer_sigset_t *.
183DECLARE__REAL_AND_INTERNAL(uptr, sigprocmask, int how,
184                           __sanitizer_sigset_t *set,
185                           __sanitizer_sigset_t *oldset) {
186  return _REAL(sigprocmask)(how, set, oldset);
187}
188
189DECLARE__REAL_AND_INTERNAL(int, fork, void) {
190  // TODO(glider): this may call user's pthread_atfork() handlers which is bad.
191  return _REAL(fork)();
192}
193
194u64 NanoTime() {
195  return gethrtime();
196}
197
198uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
199  // FIXME: No internal variant.
200  return clock_gettime(clk_id, (timespec *)tp);
201}
202
203// ----------------- sanitizer_common.h
204BlockingMutex::BlockingMutex() {
205  CHECK(sizeof(mutex_t) <= sizeof(opaque_storage_));
206  internal_memset(this, 0, sizeof(*this));
207  CHECK_EQ(mutex_init((mutex_t *)&opaque_storage_, USYNC_THREAD, NULL), 0);
208}
209
210void BlockingMutex::Lock() {
211  CHECK(sizeof(mutex_t) <= sizeof(opaque_storage_));
212  CHECK_NE(owner_, (uptr)thr_self());
213  CHECK_EQ(mutex_lock((mutex_t *)&opaque_storage_), 0);
214  CHECK(!owner_);
215  owner_ = (uptr)thr_self();
216}
217
218void BlockingMutex::Unlock() {
219  CHECK(owner_ == (uptr)thr_self());
220  owner_ = 0;
221  CHECK_EQ(mutex_unlock((mutex_t *)&opaque_storage_), 0);
222}
223
224void BlockingMutex::CheckLocked() {
225  CHECK_EQ((uptr)thr_self(), owner_);
226}
227
228}  // namespace __sanitizer
229
230#endif  // SANITIZER_SOLARIS
231