]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
1 | //===-- sanitizer_posix.cc ------------------------------------------------===// |
2 | // | |
3 | // The LLVM Compiler Infrastructure | |
4 | // | |
5 | // This file is distributed under the University of Illinois Open Source | |
6 | // License. See LICENSE.TXT for details. | |
7 | // | |
8 | //===----------------------------------------------------------------------===// | |
9 | // | |
10 | // This file is shared between AddressSanitizer and ThreadSanitizer | |
11 | // run-time libraries and implements POSIX-specific functions from | |
92a42be0 | 12 | // sanitizer_posix.h. |
1a4d82fc JJ |
13 | //===----------------------------------------------------------------------===// |
14 | ||
15 | #include "sanitizer_platform.h" | |
92a42be0 | 16 | |
1a4d82fc JJ |
17 | #if SANITIZER_POSIX |
18 | ||
19 | #include "sanitizer_common.h" | |
20 | #include "sanitizer_libc.h" | |
92a42be0 | 21 | #include "sanitizer_posix.h" |
1a4d82fc JJ |
22 | #include "sanitizer_procmaps.h" |
23 | #include "sanitizer_stacktrace.h" | |
24 | ||
92a42be0 SL |
25 | #include <fcntl.h> |
26 | #include <signal.h> | |
1a4d82fc JJ |
27 | #include <sys/mman.h> |
28 | ||
29 | #if SANITIZER_LINUX | |
30 | #include <sys/utsname.h> | |
31 | #endif | |
32 | ||
92a42be0 SL |
33 | #if SANITIZER_LINUX && !SANITIZER_ANDROID |
34 | #include <sys/personality.h> | |
35 | #endif | |
36 | ||
37 | #if SANITIZER_FREEBSD | |
38 | // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before | |
39 | // that, it was never implemented. So just define it to zero. | |
40 | #undef MAP_NORESERVE | |
41 | #define MAP_NORESERVE 0 | |
42 | #endif | |
43 | ||
1a4d82fc JJ |
44 | namespace __sanitizer { |
45 | ||
46 | // ------------- sanitizer_common.h | |
47 | uptr GetMmapGranularity() { | |
48 | return GetPageSize(); | |
49 | } | |
50 | ||
51 | #if SANITIZER_WORDSIZE == 32 | |
92a42be0 SL |
52 | // Take care of unusable kernel area in top gigabyte. |
53 | static uptr GetKernelAreaSize() { | |
54 | #if SANITIZER_LINUX && !SANITIZER_X32 | |
55 | const uptr gbyte = 1UL << 30; | |
56 | ||
57 | // Firstly check if there are writable segments | |
58 | // mapped to top gigabyte (e.g. stack). | |
59 | MemoryMappingLayout proc_maps(/*cache_enabled*/true); | |
60 | uptr end, prot; | |
61 | while (proc_maps.Next(/*start*/nullptr, &end, | |
62 | /*offset*/nullptr, /*filename*/nullptr, | |
63 | /*filename_size*/0, &prot)) { | |
64 | if ((end >= 3 * gbyte) | |
65 | && (prot & MemoryMappingLayout::kProtectionWrite) != 0) | |
66 | return 0; | |
67 | } | |
68 | ||
69 | #if !SANITIZER_ANDROID | |
70 | // Even if nothing is mapped, top Gb may still be accessible | |
71 | // if we are running on 64-bit kernel. | |
72 | // Uname may report misleading results if personality type | |
73 | // is modified (e.g. under schroot) so check this as well. | |
1a4d82fc | 74 | struct utsname uname_info; |
92a42be0 SL |
75 | int pers = personality(0xffffffffUL); |
76 | if (!(pers & PER_MASK) | |
77 | && uname(&uname_info) == 0 | |
78 | && internal_strstr(uname_info.machine, "64")) | |
79 | return 0; | |
80 | #endif // SANITIZER_ANDROID | |
81 | ||
82 | // Top gigabyte is reserved for kernel. | |
83 | return gbyte; | |
1a4d82fc JJ |
84 | #else |
85 | return 0; | |
92a42be0 | 86 | #endif // SANITIZER_LINUX && !SANITIZER_X32 |
1a4d82fc JJ |
87 | } |
88 | #endif // SANITIZER_WORDSIZE == 32 | |
89 | ||
90 | uptr GetMaxVirtualAddress() { | |
91 | #if SANITIZER_WORDSIZE == 64 | |
5bcae85e SL |
92 | # if defined(__aarch64__) && SANITIZER_IOS && !SANITIZER_IOSSIM |
93 | // Ideally, we would derive the upper bound from MACH_VM_MAX_ADDRESS. The | |
94 | // upper bound can change depending on the device. | |
95 | return 0x200000000 - 1; | |
96 | # elif defined(__powerpc64__) || defined(__aarch64__) | |
1a4d82fc JJ |
97 | // On PowerPC64 we have two different address space layouts: 44- and 46-bit. |
98 | // We somehow need to figure out which one we are using now and choose | |
99 | // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL. | |
100 | // Note that with 'ulimit -s unlimited' the stack is moved away from the top | |
101 | // of the address space, so simply checking the stack address is not enough. | |
92a42be0 SL |
102 | // This should (does) work for both PowerPC64 Endian modes. |
103 | // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit. | |
104 | return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1; | |
105 | # elif defined(__mips64) | |
106 | return (1ULL << 40) - 1; // 0x000000ffffffffffUL; | |
5bcae85e SL |
107 | # elif defined(__s390x__) |
108 | return (1ULL << 53) - 1; // 0x001fffffffffffffUL; | |
1a4d82fc JJ |
109 | # else |
110 | return (1ULL << 47) - 1; // 0x00007fffffffffffUL; | |
111 | # endif | |
112 | #else // SANITIZER_WORDSIZE == 32 | |
5bcae85e SL |
113 | # if defined(__s390__) |
114 | return (1ULL << 31) - 1; // 0x7fffffff; | |
115 | # else | |
1a4d82fc | 116 | uptr res = (1ULL << 32) - 1; // 0xffffffff; |
92a42be0 SL |
117 | if (!common_flags()->full_address_space) |
118 | res -= GetKernelAreaSize(); | |
1a4d82fc JJ |
119 | CHECK_LT(reinterpret_cast<uptr>(&res), res); |
120 | return res; | |
5bcae85e | 121 | # endif |
1a4d82fc JJ |
122 | #endif // SANITIZER_WORDSIZE |
123 | } | |
124 | ||
3157f602 | 125 | void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) { |
1a4d82fc | 126 | size = RoundUpTo(size, GetPageSizeCached()); |
92a42be0 SL |
127 | uptr res = internal_mmap(nullptr, size, |
128 | PROT_READ | PROT_WRITE, | |
129 | MAP_PRIVATE | MAP_ANON, -1, 0); | |
1a4d82fc | 130 | int reserrno; |
92a42be0 | 131 | if (internal_iserror(res, &reserrno)) |
3157f602 | 132 | ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report); |
1a4d82fc JJ |
133 | IncreaseTotalMmap(size); |
134 | return (void *)res; | |
135 | } | |
136 | ||
137 | void UnmapOrDie(void *addr, uptr size) { | |
138 | if (!addr || !size) return; | |
139 | uptr res = internal_munmap(addr, size); | |
140 | if (internal_iserror(res)) { | |
141 | Report("ERROR: %s failed to deallocate 0x%zx (%zd) bytes at address %p\n", | |
142 | SanitizerToolName, size, size, addr); | |
143 | CHECK("unable to unmap" && 0); | |
144 | } | |
145 | DecreaseTotalMmap(size); | |
146 | } | |
147 | ||
5bcae85e SL |
148 | // We want to map a chunk of address space aligned to 'alignment'. |
149 | // We do it by maping a bit more and then unmaping redundant pieces. | |
150 | // We probably can do it with fewer syscalls in some OS-dependent way. | |
151 | void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) { | |
152 | CHECK(IsPowerOfTwo(size)); | |
153 | CHECK(IsPowerOfTwo(alignment)); | |
154 | uptr map_size = size + alignment; | |
155 | uptr map_res = (uptr)MmapOrDie(map_size, mem_type); | |
156 | uptr map_end = map_res + map_size; | |
157 | uptr res = map_res; | |
158 | if (res & (alignment - 1)) // Not aligned. | |
159 | res = (map_res + alignment) & ~(alignment - 1); | |
160 | uptr end = res + size; | |
161 | if (res != map_res) | |
162 | UnmapOrDie((void*)map_res, res - map_res); | |
163 | if (end != map_end) | |
164 | UnmapOrDie((void*)end, map_end - end); | |
165 | return (void*)res; | |
166 | } | |
167 | ||
1a4d82fc JJ |
168 | void *MmapNoReserveOrDie(uptr size, const char *mem_type) { |
169 | uptr PageSize = GetPageSizeCached(); | |
92a42be0 SL |
170 | uptr p = internal_mmap(nullptr, |
171 | RoundUpTo(size, PageSize), | |
172 | PROT_READ | PROT_WRITE, | |
173 | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, | |
174 | -1, 0); | |
1a4d82fc JJ |
175 | int reserrno; |
176 | if (internal_iserror(p, &reserrno)) | |
92a42be0 | 177 | ReportMmapFailureAndDie(size, mem_type, "allocate noreserve", reserrno); |
1a4d82fc JJ |
178 | IncreaseTotalMmap(size); |
179 | return (void *)p; | |
180 | } | |
181 | ||
182 | void *MmapFixedOrDie(uptr fixed_addr, uptr size) { | |
183 | uptr PageSize = GetPageSizeCached(); | |
184 | uptr p = internal_mmap((void*)(fixed_addr & ~(PageSize - 1)), | |
185 | RoundUpTo(size, PageSize), | |
186 | PROT_READ | PROT_WRITE, | |
187 | MAP_PRIVATE | MAP_ANON | MAP_FIXED, | |
188 | -1, 0); | |
189 | int reserrno; | |
190 | if (internal_iserror(p, &reserrno)) { | |
92a42be0 SL |
191 | char mem_type[30]; |
192 | internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx", | |
193 | fixed_addr); | |
194 | ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno); | |
1a4d82fc JJ |
195 | } |
196 | IncreaseTotalMmap(size); | |
197 | return (void *)p; | |
198 | } | |
199 | ||
92a42be0 SL |
200 | bool MprotectNoAccess(uptr addr, uptr size) { |
201 | return 0 == internal_mprotect((void*)addr, size, PROT_NONE); | |
202 | } | |
203 | ||
5bcae85e SL |
204 | bool MprotectReadOnly(uptr addr, uptr size) { |
205 | return 0 == internal_mprotect((void *)addr, size, PROT_READ); | |
206 | } | |
207 | ||
92a42be0 SL |
208 | fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) { |
209 | int flags; | |
210 | switch (mode) { | |
211 | case RdOnly: flags = O_RDONLY; break; | |
212 | case WrOnly: flags = O_WRONLY | O_CREAT; break; | |
213 | case RdWr: flags = O_RDWR | O_CREAT; break; | |
214 | } | |
215 | fd_t res = internal_open(filename, flags, 0660); | |
216 | if (internal_iserror(res, errno_p)) | |
217 | return kInvalidFd; | |
218 | return res; | |
219 | } | |
220 | ||
221 | void CloseFile(fd_t fd) { | |
222 | internal_close(fd); | |
223 | } | |
224 | ||
225 | bool ReadFromFile(fd_t fd, void *buff, uptr buff_size, uptr *bytes_read, | |
226 | error_t *error_p) { | |
227 | uptr res = internal_read(fd, buff, buff_size); | |
228 | if (internal_iserror(res, error_p)) | |
229 | return false; | |
230 | if (bytes_read) | |
231 | *bytes_read = res; | |
232 | return true; | |
233 | } | |
234 | ||
235 | bool WriteToFile(fd_t fd, const void *buff, uptr buff_size, uptr *bytes_written, | |
236 | error_t *error_p) { | |
237 | uptr res = internal_write(fd, buff, buff_size); | |
238 | if (internal_iserror(res, error_p)) | |
239 | return false; | |
240 | if (bytes_written) | |
241 | *bytes_written = res; | |
242 | return true; | |
243 | } | |
244 | ||
245 | bool RenameFile(const char *oldpath, const char *newpath, error_t *error_p) { | |
246 | uptr res = internal_rename(oldpath, newpath); | |
247 | return !internal_iserror(res, error_p); | |
1a4d82fc JJ |
248 | } |
249 | ||
250 | void *MapFileToMemory(const char *file_name, uptr *buff_size) { | |
92a42be0 SL |
251 | fd_t fd = OpenFile(file_name, RdOnly); |
252 | CHECK(fd != kInvalidFd); | |
1a4d82fc JJ |
253 | uptr fsize = internal_filesize(fd); |
254 | CHECK_NE(fsize, (uptr)-1); | |
255 | CHECK_GT(fsize, 0); | |
256 | *buff_size = RoundUpTo(fsize, GetPageSizeCached()); | |
92a42be0 SL |
257 | uptr map = internal_mmap(nullptr, *buff_size, PROT_READ, MAP_PRIVATE, fd, 0); |
258 | return internal_iserror(map) ? nullptr : (void *)map; | |
1a4d82fc JJ |
259 | } |
260 | ||
92a42be0 SL |
261 | void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) { |
262 | uptr flags = MAP_SHARED; | |
263 | if (addr) flags |= MAP_FIXED; | |
264 | uptr p = internal_mmap(addr, size, PROT_READ | PROT_WRITE, flags, fd, offset); | |
265 | int mmap_errno = 0; | |
266 | if (internal_iserror(p, &mmap_errno)) { | |
267 | Printf("could not map writable file (%d, %lld, %zu): %zd, errno: %d\n", | |
268 | fd, (long long)offset, size, p, mmap_errno); | |
269 | return nullptr; | |
270 | } | |
271 | return (void *)p; | |
272 | } | |
1a4d82fc JJ |
273 | |
274 | static inline bool IntervalsAreSeparate(uptr start1, uptr end1, | |
275 | uptr start2, uptr end2) { | |
276 | CHECK(start1 <= end1); | |
277 | CHECK(start2 <= end2); | |
278 | return (end1 < start2) || (end2 < start1); | |
279 | } | |
280 | ||
281 | // FIXME: this is thread-unsafe, but should not cause problems most of the time. | |
282 | // When the shadow is mapped only a single thread usually exists (plus maybe | |
283 | // several worker threads on Mac, which aren't expected to map big chunks of | |
284 | // memory). | |
285 | bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) { | |
286 | MemoryMappingLayout proc_maps(/*cache_enabled*/true); | |
287 | uptr start, end; | |
288 | while (proc_maps.Next(&start, &end, | |
92a42be0 SL |
289 | /*offset*/nullptr, /*filename*/nullptr, |
290 | /*filename_size*/0, /*protection*/nullptr)) { | |
291 | if (start == end) continue; // Empty range. | |
292 | CHECK_NE(0, end); | |
293 | if (!IntervalsAreSeparate(start, end - 1, range_start, range_end)) | |
1a4d82fc JJ |
294 | return false; |
295 | } | |
296 | return true; | |
297 | } | |
298 | ||
299 | void DumpProcessMap() { | |
300 | MemoryMappingLayout proc_maps(/*cache_enabled*/true); | |
301 | uptr start, end; | |
302 | const sptr kBufSize = 4095; | |
303 | char *filename = (char*)MmapOrDie(kBufSize, __func__); | |
304 | Report("Process memory map follows:\n"); | |
92a42be0 SL |
305 | while (proc_maps.Next(&start, &end, /* file_offset */nullptr, |
306 | filename, kBufSize, /* protection */nullptr)) { | |
1a4d82fc JJ |
307 | Printf("\t%p-%p\t%s\n", (void*)start, (void*)end, filename); |
308 | } | |
309 | Report("End of process memory map.\n"); | |
310 | UnmapOrDie(filename, kBufSize); | |
311 | } | |
312 | ||
313 | const char *GetPwd() { | |
314 | return GetEnv("PWD"); | |
315 | } | |
316 | ||
92a42be0 SL |
317 | bool IsPathSeparator(const char c) { |
318 | return c == '/'; | |
1a4d82fc JJ |
319 | } |
320 | ||
92a42be0 SL |
321 | bool IsAbsolutePath(const char *path) { |
322 | return path != nullptr && IsPathSeparator(path[0]); | |
1a4d82fc JJ |
323 | } |
324 | ||
92a42be0 SL |
325 | void ReportFile::Write(const char *buffer, uptr length) { |
326 | SpinMutexLock l(mu); | |
327 | static const char *kWriteError = | |
328 | "ReportFile::Write() can't output requested buffer!\n"; | |
329 | ReopenIfNecessary(); | |
330 | if (length != internal_write(fd, buffer, length)) { | |
331 | internal_write(fd, kWriteError, internal_strlen(kWriteError)); | |
1a4d82fc JJ |
332 | Die(); |
333 | } | |
334 | } | |
335 | ||
336 | bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end) { | |
337 | uptr s, e, off, prot; | |
92a42be0 | 338 | InternalScopedString buff(kMaxPathLength); |
1a4d82fc JJ |
339 | MemoryMappingLayout proc_maps(/*cache_enabled*/false); |
340 | while (proc_maps.Next(&s, &e, &off, buff.data(), buff.size(), &prot)) { | |
341 | if ((prot & MemoryMappingLayout::kProtectionExecute) != 0 | |
342 | && internal_strcmp(module, buff.data()) == 0) { | |
343 | *start = s; | |
344 | *end = e; | |
345 | return true; | |
346 | } | |
347 | } | |
348 | return false; | |
349 | } | |
350 | ||
92a42be0 | 351 | SignalContext SignalContext::Create(void *siginfo, void *context) { |
5bcae85e SL |
352 | auto si = (siginfo_t *)siginfo; |
353 | uptr addr = (uptr)si->si_addr; | |
92a42be0 SL |
354 | uptr pc, sp, bp; |
355 | GetPcSpBp(context, &pc, &sp, &bp); | |
5bcae85e SL |
356 | WriteFlag write_flag = GetWriteFlag(context); |
357 | bool is_memory_access = si->si_signo == SIGSEGV; | |
358 | return SignalContext(context, addr, pc, sp, bp, is_memory_access, write_flag); | |
92a42be0 SL |
359 | } |
360 | ||
92a42be0 | 361 | } // namespace __sanitizer |
1a4d82fc | 362 | |
92a42be0 | 363 | #endif // SANITIZER_POSIX |