• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 = MmapFixedNoAccess(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 = MmapFixedNoAccess(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