libsanitizer/asan/asan_linux.cpp

   1 //===-- asan_linux.cpp ----------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of AddressSanitizer, an address sanity checker.
  10 //
  11 // Linux-specific details.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_common/sanitizer_platform.h"
  15 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
  16     SANITIZER_SOLARIS
  17
  18 #  include <dlfcn.h>
  19 #  include <fcntl.h>
  20 #  include <limits.h>
  21 #  include <pthread.h>
  22 #  include <stdio.h>
  23 #  include <sys/mman.h>
  24 #  include <sys/resource.h>
  25 #  include <sys/syscall.h>
  26 #  include <sys/time.h>
  27 #  include <sys/types.h>
  28 #  include <unistd.h>
  29 #  include <unwind.h>
  30
  31 #  include "asan_interceptors.h"
  32 #  include "asan_internal.h"
  33 #  include "asan_premap_shadow.h"
  34 #  include "asan_thread.h"
  35 #  include "sanitizer_common/sanitizer_flags.h"
  36 #  include "sanitizer_common/sanitizer_freebsd.h"
  37 #  include "sanitizer_common/sanitizer_hash.h"
  38 #  include "sanitizer_common/sanitizer_libc.h"
  39 #  include "sanitizer_common/sanitizer_procmaps.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 <link.h>
  58 #    include <sys/ucontext.h>
  59 extern ElfW(Dyn) _DYNAMIC[];
  60 #  endif
  61
  62 // x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in
  63 // 32-bit mode.
  64 #  if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \
  65       __FreeBSD_version <= 902001  // v9.2
  66 #    define ucontext_t xucontext_t
  67 #  endif
  68
  69 typedef enum {
  70   ASAN_RT_VERSION_UNDEFINED = 0,
  71   ASAN_RT_VERSION_DYNAMIC,
  72   ASAN_RT_VERSION_STATIC,
  73 } asan_rt_version_t;
  74
  75 // FIXME: perhaps also store abi version here?
  76 extern "C" {
  77 SANITIZER_INTERFACE_ATTRIBUTE
  78 asan_rt_version_t __asan_rt_version;
  79 }
  80
  81 namespace __asan {
  82
  83 void InitializePlatformInterceptors() {}
  84 void InitializePlatformExceptionHandlers() {}
  85 bool IsSystemHeapAddress(uptr addr) { return false; }
  86
  87 void *AsanDoesNotSupportStaticLinkage() {
  88   // This will fail to link with -static.
  89   return &_DYNAMIC;
  90 }
  91
  92 #  if ASAN_PREMAP_SHADOW
  93 uptr FindPremappedShadowStart(uptr shadow_size_bytes) {
  94   uptr granularity = GetMmapGranularity();
  95   uptr shadow_start = reinterpret_cast<uptr>(&__asan_shadow);
  96   uptr premap_shadow_size = PremapShadowSize();
  97   uptr shadow_size = RoundUpTo(shadow_size_bytes, granularity);
  98   // We may have mapped too much. Release extra memory.
  99   UnmapFromTo(shadow_start + shadow_size, shadow_start + premap_shadow_size);
 100   return shadow_start;
 101 }
 102 #  endif
 103
 104 uptr FindDynamicShadowStart() {
 105   uptr shadow_size_bytes = MemToShadowSize(kHighMemEnd);
 106 #  if ASAN_PREMAP_SHADOW
 107   if (!PremapShadowFailed())
 108     return FindPremappedShadowStart(shadow_size_bytes);
 109 #  endif
 110
 111   return MapDynamicShadow(shadow_size_bytes, ASAN_SHADOW_SCALE,
 112                           /*min_shadow_base_alignment*/ 0, kHighMemEnd);
 113 }
 114
 115 void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
 116   UNIMPLEMENTED();
 117 }
 118
 119 void FlushUnneededASanShadowMemory(uptr p, uptr size) {
 120   // Since asan's mapping is compacting, the shadow chunk may be
 121   // not page-aligned, so we only flush the page-aligned portion.
 122   ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size));
 123 }
 124
 125 #  if SANITIZER_ANDROID
 126 // FIXME: should we do anything for Android?
 127 void AsanCheckDynamicRTPrereqs() {}
 128 void AsanCheckIncompatibleRT() {}
 129 #  else
 130 static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size,
 131                                 void *data) {
 132   VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n", info->dlpi_name,
 133           (void *)info->dlpi_addr);
 134
 135   const char **name = (const char **)data;
 136
 137   // Ignore first entry (the main program)
 138   if (!*name) {
 139     *name = "";
 140     return 0;
 141   }
 142
 143 #    if SANITIZER_LINUX
 144   // Ignore vDSO. glibc versions earlier than 2.15 (and some patched
 145   // by distributors) return an empty name for the vDSO entry, so
 146   // detect this as well.
 147   if (!info->dlpi_name[0] ||
 148       internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0)
 149     return 0;
 150 #    endif
 151
 152   *name = info->dlpi_name;
 153   return 1;
 154 }
 155
 156 static bool IsDynamicRTName(const char *libname) {
 157   return internal_strstr(libname, "libclang_rt.asan") ||
 158          internal_strstr(libname, "libasan.so");
 159 }
 160
 161 static void ReportIncompatibleRT() {
 162   Report("Your application is linked against incompatible ASan runtimes.\n");
 163   Die();
 164 }
 165
 166 void AsanCheckDynamicRTPrereqs() {
 167   if (!ASAN_DYNAMIC || !flags()->verify_asan_link_order)
 168     return;
 169
 170   // Ensure that dynamic RT is the first DSO in the list
 171   const char *first_dso_name = nullptr;
 172   dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name);
 173   if (first_dso_name && first_dso_name[0] && !IsDynamicRTName(first_dso_name)) {
 174     Report(
 175         "ASan runtime does not come first in initial library list; "
 176         "you should either link runtime to your application or "
 177         "manually preload it with LD_PRELOAD.\n");
 178     Die();
 179   }
 180 }
 181
 182 void AsanCheckIncompatibleRT() {
 183   if (ASAN_DYNAMIC) {
 184     if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
 185       __asan_rt_version = ASAN_RT_VERSION_DYNAMIC;
 186     } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) {
 187       ReportIncompatibleRT();
 188     }
 189   } else {
 190     if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
 191       // Ensure that dynamic runtime is not present. We should detect it
 192       // as early as possible, otherwise ASan interceptors could bind to
 193       // the functions in dynamic ASan runtime instead of the functions in
 194       // system libraries, causing crashes later in ASan initialization.
 195       MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
 196       char filename[PATH_MAX];
 197       MemoryMappedSegment segment(filename, sizeof(filename));
 198       while (proc_maps.Next(&segment)) {
 199         if (IsDynamicRTName(segment.filename)) {
 200           Report(
 201               "Your application is linked against "
 202               "incompatible ASan runtimes.\n");
 203           Die();
 204         }
 205       }
 206       __asan_rt_version = ASAN_RT_VERSION_STATIC;
 207     } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) {
 208       ReportIncompatibleRT();
 209     }
 210   }
 211 }
 212 #  endif  // SANITIZER_ANDROID
 213
 214 #  if ASAN_INTERCEPT_SWAPCONTEXT
 215 constexpr u32 kAsanContextStackFlagsMagic = 0x51260eea;
 216
 217 static int HashContextStack(const ucontext_t &ucp) {
 218   MurMur2Hash64Builder hash(kAsanContextStackFlagsMagic);
 219   hash.add(reinterpret_cast<uptr>(ucp.uc_stack.ss_sp));
 220   hash.add(ucp.uc_stack.ss_size);
 221   return static_cast<int>(hash.get());
 222 }
 223
 224 void SignContextStack(void *context) {
 225   ucontext_t *ucp = reinterpret_cast<ucontext_t *>(context);
 226   ucp->uc_stack.ss_flags = HashContextStack(*ucp);
 227 }
 228
 229 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
 230   const ucontext_t *ucp = reinterpret_cast<const ucontext_t *>(context);
 231   if (HashContextStack(*ucp) == ucp->uc_stack.ss_flags) {
 232     *stack = reinterpret_cast<uptr>(ucp->uc_stack.ss_sp);
 233     *ssize = ucp->uc_stack.ss_size;
 234     return;
 235   }
 236   *stack = 0;
 237   *ssize = 0;
 238 }
 239 #  endif  // ASAN_INTERCEPT_SWAPCONTEXT
 240
 241 void *AsanDlSymNext(const char *sym) { return dlsym(RTLD_NEXT, sym); }
 242
 243 bool HandleDlopenInit() {
 244   // Not supported on this platform.
 245   static_assert(!SANITIZER_SUPPORTS_INIT_FOR_DLOPEN,
 246                 "Expected SANITIZER_SUPPORTS_INIT_FOR_DLOPEN to be false");
 247   return false;
 248 }
 249
 250 }  // namespace __asan
 251
 252 #endif  // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ||
 253         // SANITIZER_SOLARIS