1 //===-- tsan_platform_posix.cc --------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is a part of ThreadSanitizer (TSan), a race detector.
12 // POSIX-specific code.
13 //===----------------------------------------------------------------------===//
15 #include "sanitizer_common/sanitizer_platform.h"
18 #include "sanitizer_common/sanitizer_common.h"
19 #include "sanitizer_common/sanitizer_libc.h"
20 #include "sanitizer_common/sanitizer_procmaps.h"
21 #include "tsan_platform.h"
27 void InitializeShadowMemory() {
30 (uptr)MmapFixedNoReserve(ShadowBeg(), ShadowEnd() - ShadowBeg(),
32 if (shadow != ShadowBeg()) {
33 Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
34 Printf("FATAL: Make sure to compile with -fPIE and "
35 "to link with -pie (%p, %p).\n", shadow, ShadowBeg());
38 // This memory range is used for thread stacks and large user mmaps.
39 // Frequently a thread uses only a small part of stack and similarly
40 // a program uses a small part of large mmap. On some programs
41 // we see 20% memory usage reduction without huge pages for this range.
42 // FIXME: don't use constants here.
43 #if defined(__x86_64__)
44 const uptr kMadviseRangeBeg = 0x7f0000000000ull;
45 const uptr kMadviseRangeSize = 0x010000000000ull;
46 #elif defined(__mips64)
47 const uptr kMadviseRangeBeg = 0xff00000000ull;
48 const uptr kMadviseRangeSize = 0x0100000000ull;
49 #elif defined(__aarch64__) && defined(__APPLE__)
50 uptr kMadviseRangeBeg = LoAppMemBeg();
51 uptr kMadviseRangeSize = LoAppMemEnd() - LoAppMemBeg();
52 #elif defined(__aarch64__)
53 uptr kMadviseRangeBeg = 0;
54 uptr kMadviseRangeSize = 0;
56 kMadviseRangeBeg = 0x7d00000000ull;
57 kMadviseRangeSize = 0x0300000000ull;
58 } else if (vmaSize == 42) {
59 kMadviseRangeBeg = 0x3f000000000ull;
60 kMadviseRangeSize = 0x01000000000ull;
64 #elif defined(__powerpc64__)
65 uptr kMadviseRangeBeg = 0;
66 uptr kMadviseRangeSize = 0;
68 kMadviseRangeBeg = 0x0f60000000ull;
69 kMadviseRangeSize = 0x0010000000ull;
70 } else if (vmaSize == 46) {
71 kMadviseRangeBeg = 0x3f0000000000ull;
72 kMadviseRangeSize = 0x010000000000ull;
77 NoHugePagesInRegion(MemToShadow(kMadviseRangeBeg),
78 kMadviseRangeSize * kShadowMultiplier);
79 // Meta shadow is compressing and we don't flush it,
80 // so it makes sense to mark it as NOHUGEPAGE to not over-allocate memory.
81 // On one program it reduces memory consumption from 5GB to 2.5GB.
82 NoHugePagesInRegion(MetaShadowBeg(), MetaShadowEnd() - MetaShadowBeg());
83 if (common_flags()->use_madv_dontdump)
84 DontDumpShadowMemory(ShadowBeg(), ShadowEnd() - ShadowBeg());
85 DPrintf("memory shadow: %zx-%zx (%zuGB)\n",
86 ShadowBeg(), ShadowEnd(),
87 (ShadowEnd() - ShadowBeg()) >> 30);
90 uptr meta_size = MetaShadowEnd() - MetaShadowBeg();
92 (uptr)MmapFixedNoReserve(MetaShadowBeg(), meta_size, "meta shadow");
93 if (meta != MetaShadowBeg()) {
94 Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
95 Printf("FATAL: Make sure to compile with -fPIE and "
96 "to link with -pie (%p, %p).\n", meta, MetaShadowBeg());
99 if (common_flags()->use_madv_dontdump)
100 DontDumpShadowMemory(meta, meta_size);
101 DPrintf("meta shadow: %zx-%zx (%zuGB)\n",
102 meta, meta + meta_size, meta_size >> 30);
104 InitializeShadowMemoryPlatform();
107 static void ProtectRange(uptr beg, uptr end) {
111 if (beg != (uptr)MmapFixedNoAccess(beg, end - beg)) {
112 Printf("FATAL: ThreadSanitizer can not protect [%zx,%zx]\n", beg, end);
113 Printf("FATAL: Make sure you are not using unlimited stack\n");
118 void CheckAndProtect() {
119 // Ensure that the binary is indeed compiled with -pie.
120 MemoryMappingLayout proc_maps(true);
121 MemoryMappedSegment segment;
122 while (proc_maps.Next(&segment)) {
123 if (IsAppMem(segment.start)) continue;
124 if (segment.start >= HeapMemEnd() && segment.start < HeapEnd()) continue;
125 if (segment.protection == 0) // Zero page or mprotected.
127 if (segment.start >= VdsoBeg()) // vdso
129 Printf("FATAL: ThreadSanitizer: unexpected memory mapping %p-%p\n",
130 segment.start, segment.end);
134 #if defined(__aarch64__) && defined(__APPLE__)
135 ProtectRange(HeapMemEnd(), ShadowBeg());
136 ProtectRange(ShadowEnd(), MetaShadowBeg());
137 ProtectRange(MetaShadowEnd(), TraceMemBeg());
139 ProtectRange(LoAppMemEnd(), ShadowBeg());
140 ProtectRange(ShadowEnd(), MetaShadowBeg());
141 #ifdef TSAN_MID_APP_RANGE
142 ProtectRange(MetaShadowEnd(), MidAppMemBeg());
143 ProtectRange(MidAppMemEnd(), TraceMemBeg());
145 ProtectRange(MetaShadowEnd(), TraceMemBeg());
147 // Memory for traces is mapped lazily in MapThreadTrace.
148 // Protect the whole range for now, so that user does not map something here.
149 ProtectRange(TraceMemBeg(), TraceMemEnd());
150 ProtectRange(TraceMemEnd(), HeapMemBeg());
151 ProtectRange(HeapEnd(), HiAppMemBeg());
156 } // namespace __tsan
158 #endif // SANITIZER_POSIX