1 //===-- asan_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 AddressSanitizer, an address sanity checker. 11 // 12 // Linux-specific details. 13 //===----------------------------------------------------------------------===// 14 15 #include "sanitizer_common/sanitizer_platform.h" 16 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ 17 SANITIZER_SOLARIS 18 19 #include "asan_interceptors.h" 20 #include "asan_internal.h" 21 #include "asan_premap_shadow.h" 22 #include "asan_thread.h" 23 #include "sanitizer_common/sanitizer_flags.h" 24 #include "sanitizer_common/sanitizer_freebsd.h" 25 #include "sanitizer_common/sanitizer_libc.h" 26 #include "sanitizer_common/sanitizer_procmaps.h" 27 28 #include <sys/time.h> 29 #include <sys/resource.h> 30 #include <sys/mman.h> 31 #include <sys/syscall.h> 32 #include <sys/types.h> 33 #include <dlfcn.h> 34 #include <fcntl.h> 35 #include <limits.h> 36 #include <pthread.h> 37 #include <stdio.h> 38 #include <unistd.h> 39 #include <unwind.h> 40 41 #if SANITIZER_FREEBSD 42 #include <sys/link_elf.h> 43 #endif 44 45 #if SANITIZER_SOLARIS 46 #include <link.h> 47 #endif 48 49 #if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS 50 #include <ucontext.h> 51 extern "C" void* _DYNAMIC; 52 #elif SANITIZER_NETBSD 53 #include <link_elf.h> 54 #include <ucontext.h> 55 extern Elf_Dyn _DYNAMIC; 56 #else 57 #include <sys/ucontext.h> 58 #include <link.h> 59 #endif 60 61 // x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in 62 // 32-bit mode. 63 #if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \ 64 __FreeBSD_version <= 902001 // v9.2 65 #define ucontext_t xucontext_t 66 #endif 67 68 typedef enum { 69 ASAN_RT_VERSION_UNDEFINED = 0, 70 ASAN_RT_VERSION_DYNAMIC, 71 ASAN_RT_VERSION_STATIC, 72 } asan_rt_version_t; 73 74 // FIXME: perhaps also store abi version here? 75 extern "C" { 76 SANITIZER_INTERFACE_ATTRIBUTE 77 asan_rt_version_t __asan_rt_version; 78 } 79 80 namespace __asan { 81 82 void InitializePlatformInterceptors() {} 83 void InitializePlatformExceptionHandlers() {} 84 bool IsSystemHeapAddress (uptr addr) { return false; } 85 86 void *AsanDoesNotSupportStaticLinkage() { 87 // This will fail to link with -static. 88 return &_DYNAMIC; // defined in link.h 89 } 90 91 static void UnmapFromTo(uptr from, uptr to) { 92 CHECK(to >= from); 93 if (to == from) return; 94 uptr res = internal_munmap(reinterpret_cast<void *>(from), to - from); 95 if (UNLIKELY(internal_iserror(res))) { 96 Report( 97 "ERROR: AddresSanitizer failed to unmap 0x%zx (%zd) bytes at address " 98 "%p\n", 99 to - from, to - from, from); 100 CHECK("unable to unmap" && 0); 101 } 102 } 103 104 #if ASAN_PREMAP_SHADOW 105 uptr FindPremappedShadowStart() { 106 uptr granularity = GetMmapGranularity(); 107 uptr shadow_start = reinterpret_cast<uptr>(&__asan_shadow); 108 uptr premap_shadow_size = PremapShadowSize(); 109 uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity); 110 // We may have mapped too much. Release extra memory. 111 UnmapFromTo(shadow_start + shadow_size, shadow_start + premap_shadow_size); 112 return shadow_start; 113 } 114 #endif 115 116 uptr FindDynamicShadowStart() { 117 #if ASAN_PREMAP_SHADOW 118 if (!PremapShadowFailed()) 119 return FindPremappedShadowStart(); 120 #endif 121 122 uptr granularity = GetMmapGranularity(); 123 uptr alignment = granularity * 8; 124 uptr left_padding = granularity; 125 uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity); 126 uptr map_size = shadow_size + left_padding + alignment; 127 128 uptr map_start = (uptr)MmapNoAccess(map_size); 129 CHECK_NE(map_start, ~(uptr)0); 130 131 uptr shadow_start = RoundUpTo(map_start + left_padding, alignment); 132 UnmapFromTo(map_start, shadow_start - left_padding); 133 UnmapFromTo(shadow_start + shadow_size, map_start + map_size); 134 135 return shadow_start; 136 } 137 138 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) { 139 UNIMPLEMENTED(); 140 } 141 142 #if SANITIZER_ANDROID 143 // FIXME: should we do anything for Android? 144 void AsanCheckDynamicRTPrereqs() {} 145 void AsanCheckIncompatibleRT() {} 146 #else 147 static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size, 148 void *data) { 149 VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n", 150 info->dlpi_name, info->dlpi_addr); 151 152 // Continue until the first dynamic library is found 153 if (!info->dlpi_name || info->dlpi_name[0] == 0) 154 return 0; 155 156 // Ignore vDSO 157 if (internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0) 158 return 0; 159 160 #if SANITIZER_FREEBSD || SANITIZER_NETBSD 161 // Ignore first entry (the main program) 162 char **p = (char **)data; 163 if (!(*p)) { 164 *p = (char *)-1; 165 return 0; 166 } 167 #endif 168 169 #if SANITIZER_SOLARIS 170 // Ignore executable on Solaris 171 if (info->dlpi_addr == 0) 172 return 0; 173 #endif 174 175 *(const char **)data = info->dlpi_name; 176 return 1; 177 } 178 179 static bool IsDynamicRTName(const char *libname) { 180 return internal_strstr(libname, "libclang_rt.asan") || 181 internal_strstr(libname, "libasan.so"); 182 } 183 184 static void ReportIncompatibleRT() { 185 Report("Your application is linked against incompatible ASan runtimes.\n"); 186 Die(); 187 } 188 189 void AsanCheckDynamicRTPrereqs() { 190 if (!ASAN_DYNAMIC || !flags()->verify_asan_link_order) 191 return; 192 193 // Ensure that dynamic RT is the first DSO in the list 194 const char *first_dso_name = nullptr; 195 dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name); 196 if (first_dso_name && !IsDynamicRTName(first_dso_name)) { 197 Report("ASan runtime does not come first in initial library list; " 198 "you should either link runtime to your application or " 199 "manually preload it with LD_PRELOAD.\n"); 200 Die(); 201 } 202 } 203 204 void AsanCheckIncompatibleRT() { 205 if (ASAN_DYNAMIC) { 206 if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { 207 __asan_rt_version = ASAN_RT_VERSION_DYNAMIC; 208 } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) { 209 ReportIncompatibleRT(); 210 } 211 } else { 212 if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { 213 // Ensure that dynamic runtime is not present. We should detect it 214 // as early as possible, otherwise ASan interceptors could bind to 215 // the functions in dynamic ASan runtime instead of the functions in 216 // system libraries, causing crashes later in ASan initialization. 217 MemoryMappingLayout proc_maps(/*cache_enabled*/true); 218 char filename[PATH_MAX]; 219 MemoryMappedSegment segment(filename, sizeof(filename)); 220 while (proc_maps.Next(&segment)) { 221 if (IsDynamicRTName(segment.filename)) { 222 Report("Your application is linked against " 223 "incompatible ASan runtimes.\n"); 224 Die(); 225 } 226 } 227 __asan_rt_version = ASAN_RT_VERSION_STATIC; 228 } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) { 229 ReportIncompatibleRT(); 230 } 231 } 232 } 233 #endif // SANITIZER_ANDROID 234 235 #if !SANITIZER_ANDROID 236 void ReadContextStack(void *context, uptr *stack, uptr *ssize) { 237 ucontext_t *ucp = (ucontext_t*)context; 238 *stack = (uptr)ucp->uc_stack.ss_sp; 239 *ssize = ucp->uc_stack.ss_size; 240 } 241 #else 242 void ReadContextStack(void *context, uptr *stack, uptr *ssize) { 243 UNIMPLEMENTED(); 244 } 245 #endif 246 247 void *AsanDlSymNext(const char *sym) { 248 return dlsym(RTLD_NEXT, sym); 249 } 250 251 bool HandleDlopenInit() { 252 // Not supported on this platform. 253 static_assert(!SANITIZER_SUPPORTS_INIT_FOR_DLOPEN, 254 "Expected SANITIZER_SUPPORTS_INIT_FOR_DLOPEN to be false"); 255 return false; 256 } 257 258 } // namespace __asan 259 260 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || 261 // SANITIZER_SOLARIS 262
Indexes created Sat Sep 20 22:09:52 GMT 2025