libsanitizer/sanitizer_common/sanitizer_coverage_mapping_libcdep.cc

   1 //===-- sanitizer_coverage_mapping.cc -------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // Mmap-based implementation of sanitizer coverage.
   9 //
  10 // This is part of the implementation of code coverage that does not require
  11 // __sanitizer_cov_dump() call. Data is stored in 2 files per process.
  12 //
  13 // $pid.sancov.map describes process memory layout in the following text-based
  14 // format:
  15 // <pointer size in bits>  // 1 line, 32 or 64
  16 // <mapping start> <mapping end> <base address> <dso name> // repeated
  17 // ...
  18 // Mapping lines are NOT sorted. This file is updated every time memory layout
  19 // is changed (i.e. in dlopen() and dlclose() interceptors).
  20 //
  21 // $pid.sancov.raw is a binary dump of PC values, sizeof(uptr) each. Again, not
  22 // sorted. This file is extended by 64Kb at a time and mapped into memory. It
  23 // contains one or more 0 words at the end, up to the next 64Kb aligned offset.
  24 //
  25 // To convert these 2 files to the usual .sancov format, run sancov.py rawunpack
  26 // $pid.sancov.raw.
  27 //
  28 //===----------------------------------------------------------------------===//
  29
  30 #include "sanitizer_allocator_internal.h"
  31 #include "sanitizer_libc.h"
  32 #include "sanitizer_procmaps.h"
  33
  34 namespace __sanitizer {
  35
  36 static const uptr kMaxNumberOfModules = 1 << 14;
  37 static const uptr kMaxTextSize = 64 * 1024;
  38
  39 struct CachedMapping {
  40  public:
  41   bool NeedsUpdate(uptr pc) {
  42     int new_pid = internal_getpid();
  43     if (last_pid == new_pid && pc && pc >= last_range_start &&
  44         pc < last_range_end)
  45       return false;
  46     last_pid = new_pid;
  47     return true;
  48   }
  49
  50   void SetModuleRange(uptr start, uptr end) {
  51     last_range_start = start;
  52     last_range_end = end;
  53   }
  54
  55  private:
  56   uptr last_range_start, last_range_end;
  57   int last_pid;
  58 };
  59
  60 static CachedMapping cached_mapping;
  61 static StaticSpinMutex mapping_mu;
  62
  63 void CovUpdateMapping(uptr caller_pc) {
  64   if (!common_flags()->coverage || !common_flags()->coverage_direct) return;
  65
  66   SpinMutexLock l(&mapping_mu);
  67
  68   if (!cached_mapping.NeedsUpdate(caller_pc))
  69     return;
  70
  71   InternalScopedString text(kMaxTextSize);
  72   InternalScopedBuffer<char> modules_data(kMaxNumberOfModules *
  73                                           sizeof(LoadedModule));
  74   LoadedModule *modules = (LoadedModule *)modules_data.data();
  75   CHECK(modules);
  76   int n_modules = GetListOfModules(modules, kMaxNumberOfModules,
  77                                    /* filter */ 0);
  78
  79   text.append("%d\n", sizeof(uptr) * 8);
  80   for (int i = 0; i < n_modules; ++i) {
  81     const char *module_name = StripModuleName(modules[i].full_name());
  82     for (unsigned j = 0; j < modules[i].n_ranges(); ++j) {
  83       if (modules[i].address_range_executable(j)) {
  84         uptr start = modules[i].address_range_start(j);
  85         uptr end = modules[i].address_range_end(j);
  86         uptr base = modules[i].base_address();
  87         text.append("%zx %zx %zx %s\n", start, end, base, module_name);
  88         if (caller_pc && caller_pc >= start && caller_pc < end)
  89           cached_mapping.SetModuleRange(start, end);
  90       }
  91     }
  92   }
  93
  94   int err;
  95   InternalScopedString tmp_path(64 +
  96                                 internal_strlen(common_flags()->coverage_dir));
  97   uptr res = internal_snprintf((char *)tmp_path.data(), tmp_path.size(),
  98                     "%s/%zd.sancov.map.tmp", common_flags()->coverage_dir,
  99                     internal_getpid());
 100   CHECK_LE(res, tmp_path.size());
 101   uptr map_fd = OpenFile(tmp_path.data(), true);
 102   if (internal_iserror(map_fd)) {
 103     Report(" Coverage: failed to open %s for writing\n", tmp_path.data());
 104     Die();
 105   }
 106
 107   res = internal_write(map_fd, text.data(), text.length());
 108   if (internal_iserror(res, &err)) {
 109     Printf("sancov.map write failed: %d\n", err);
 110     Die();
 111   }
 112   internal_close(map_fd);
 113
 114   InternalScopedString path(64 + internal_strlen(common_flags()->coverage_dir));
 115   res = internal_snprintf((char *)path.data(), path.size(), "%s/%zd.sancov.map",
 116                     common_flags()->coverage_dir, internal_getpid());
 117   CHECK_LE(res, path.size());
 118   res = internal_rename(tmp_path.data(), path.data());
 119   if (internal_iserror(res, &err)) {
 120     Printf("sancov.map rename failed: %d\n", err);
 121     Die();
 122   }
 123 }
 124
 125 }  // namespace __sanitizer