1 //===-- msan_linux.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 a part of MemorySanitizer.
11 //
12 // Linux- and FreeBSD-specific code.
13 //===----------------------------------------------------------------------===//
14
15 #include "sanitizer_common/sanitizer_platform.h"
16 #if SANITIZER_FREEBSD || SANITIZER_LINUX
17
18 #include "msan.h"
19 #include "msan_thread.h"
20
21 #include <elf.h>
22 #include <link.h>
23 #include <pthread.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <signal.h>
27 #include <unistd.h>
28 #include <unwind.h>
29 #include <execinfo.h>
30 #include <sys/time.h>
31 #include <sys/resource.h>
32
33 #include "sanitizer_common/sanitizer_common.h"
34 #include "sanitizer_common/sanitizer_procmaps.h"
35
36 namespace __msan {
37
ReportMapRange(const char * descr,uptr beg,uptr size)38 void ReportMapRange(const char *descr, uptr beg, uptr size) {
39 if (size > 0) {
40 uptr end = beg + size - 1;
41 VPrintf(1, "%s : %p - %p\n", descr, beg, end);
42 }
43 }
44
CheckMemoryRangeAvailability(uptr beg,uptr size)45 static bool CheckMemoryRangeAvailability(uptr beg, uptr size) {
46 if (size > 0) {
47 uptr end = beg + size - 1;
48 if (!MemoryRangeIsAvailable(beg, end)) {
49 Printf("FATAL: Memory range %p - %p is not available.\n", beg, end);
50 return false;
51 }
52 }
53 return true;
54 }
55
ProtectMemoryRange(uptr beg,uptr size,const char * name)56 static bool ProtectMemoryRange(uptr beg, uptr size, const char *name) {
57 if (size > 0) {
58 void *addr = MmapNoAccess(beg, size, name);
59 if (beg == 0 && addr) {
60 // Depending on the kernel configuration, we may not be able to protect
61 // the page at address zero.
62 uptr gap = 16 * GetPageSizeCached();
63 beg += gap;
64 size -= gap;
65 addr = MmapNoAccess(beg, size, name);
66 }
67 if ((uptr)addr != beg) {
68 uptr end = beg + size - 1;
69 Printf("FATAL: Cannot protect memory range %p - %p.\n", beg, end);
70 return false;
71 }
72 }
73 return true;
74 }
75
CheckMemoryLayoutSanity()76 static void CheckMemoryLayoutSanity() {
77 uptr prev_end = 0;
78 for (unsigned i = 0; i < kMemoryLayoutSize; ++i) {
79 uptr start = kMemoryLayout[i].start;
80 uptr end = kMemoryLayout[i].end;
81 MappingDesc::Type type = kMemoryLayout[i].type;
82 CHECK_LT(start, end);
83 CHECK_EQ(prev_end, start);
84 CHECK(addr_is_type(start, type));
85 CHECK(addr_is_type((start + end) / 2, type));
86 CHECK(addr_is_type(end - 1, type));
87 if (type == MappingDesc::APP) {
88 uptr addr = start;
89 CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
90 CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
91 CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
92
93 addr = (start + end) / 2;
94 CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
95 CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
96 CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
97
98 addr = end - 1;
99 CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr)));
100 CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr)));
101 CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr)));
102 }
103 prev_end = end;
104 }
105 }
106
InitShadow(bool init_origins)107 bool InitShadow(bool init_origins) {
108 // Let user know mapping parameters first.
109 VPrintf(1, "__msan_init %p\n", &__msan_init);
110 for (unsigned i = 0; i < kMemoryLayoutSize; ++i)
111 VPrintf(1, "%s: %zx - %zx\n", kMemoryLayout[i].name, kMemoryLayout[i].start,
112 kMemoryLayout[i].end - 1);
113
114 CheckMemoryLayoutSanity();
115
116 if (!MEM_IS_APP(&__msan_init)) {
117 Printf("FATAL: Code %p is out of application range. Non-PIE build?\n",
118 (uptr)&__msan_init);
119 return false;
120 }
121
122 const uptr maxVirtualAddress = GetMaxVirtualAddress();
123
124 for (unsigned i = 0; i < kMemoryLayoutSize; ++i) {
125 uptr start = kMemoryLayout[i].start;
126 uptr end = kMemoryLayout[i].end;
127 uptr size= end - start;
128 MappingDesc::Type type = kMemoryLayout[i].type;
129
130 // Check if the segment should be mapped based on platform constraints.
131 if (start >= maxVirtualAddress)
132 continue;
133
134 bool map = type == MappingDesc::SHADOW ||
135 (init_origins && type == MappingDesc::ORIGIN);
136 bool protect = type == MappingDesc::INVALID ||
137 (!init_origins && type == MappingDesc::ORIGIN);
138 CHECK(!(map && protect));
139 if (!map && !protect)
140 CHECK(type == MappingDesc::APP);
141 if (map) {
142 if (!CheckMemoryRangeAvailability(start, size))
143 return false;
144 if ((uptr)MmapFixedNoReserve(start, size, kMemoryLayout[i].name) != start)
145 return false;
146 if (common_flags()->use_madv_dontdump)
147 DontDumpShadowMemory(start, size);
148 }
149 if (protect) {
150 if (!CheckMemoryRangeAvailability(start, size))
151 return false;
152 if (!ProtectMemoryRange(start, size, kMemoryLayout[i].name))
153 return false;
154 }
155 }
156
157 return true;
158 }
159
MsanAtExit(void)160 static void MsanAtExit(void) {
161 if (flags()->print_stats && (flags()->atexit || msan_report_count > 0))
162 ReportStats();
163 if (msan_report_count > 0) {
164 ReportAtExitStatistics();
165 if (common_flags()->exitcode)
166 internal__exit(common_flags()->exitcode);
167 }
168 }
169
InstallAtExitHandler()170 void InstallAtExitHandler() {
171 atexit(MsanAtExit);
172 }
173
174 // ---------------------- TSD ---------------- {{{1
175
176 static pthread_key_t tsd_key;
177 static bool tsd_key_inited = false;
178
MsanTSDInit(void (* destructor)(void * tsd))179 void MsanTSDInit(void (*destructor)(void *tsd)) {
180 CHECK(!tsd_key_inited);
181 tsd_key_inited = true;
182 CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
183 }
184
185 static THREADLOCAL MsanThread* msan_current_thread;
186
GetCurrentThread()187 MsanThread *GetCurrentThread() {
188 return msan_current_thread;
189 }
190
SetCurrentThread(MsanThread * t)191 void SetCurrentThread(MsanThread *t) {
192 // Make sure we do not reset the current MsanThread.
193 CHECK_EQ(0, msan_current_thread);
194 msan_current_thread = t;
195 // Make sure that MsanTSDDtor gets called at the end.
196 CHECK(tsd_key_inited);
197 pthread_setspecific(tsd_key, (void *)t);
198 }
199
MsanTSDDtor(void * tsd)200 void MsanTSDDtor(void *tsd) {
201 MsanThread *t = (MsanThread*)tsd;
202 if (t->destructor_iterations_ > 1) {
203 t->destructor_iterations_--;
204 CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));
205 return;
206 }
207 msan_current_thread = nullptr;
208 // Make sure that signal handler can not see a stale current thread pointer.
209 atomic_signal_fence(memory_order_seq_cst);
210 MsanThread::TSDDtor(tsd);
211 }
212
213 } // namespace __msan
214
215 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX
216