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