compiler-rt/lib/asan/asan_stats.cpp

   1 //===-- asan_stats.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 // Code related to statistics collected by AddressSanitizer.
  12 //===----------------------------------------------------------------------===//
  13 #include "asan_interceptors.h"
  14 #include "asan_internal.h"
  15 #include "asan_stats.h"
  16 #include "asan_thread.h"
  17 #include "sanitizer_common/sanitizer_allocator_interface.h"
  18 #include "sanitizer_common/sanitizer_mutex.h"
  19 #include "sanitizer_common/sanitizer_stackdepot.h"
  20
  21 namespace __asan {
  22
  23 AsanStats::AsanStats() {
  24   Clear();
  25 }
  26
  27 void AsanStats::Clear() {
  28   CHECK(REAL(memset));
  29   REAL(memset)(this, 0, sizeof(AsanStats));
  30 }
  31
  32 static void PrintMallocStatsArray(const char *prefix,
  33                                   uptr (&array)[kNumberOfSizeClasses]) {
  34   Printf("%s", prefix);
  35   for (uptr i = 0; i < kNumberOfSizeClasses; i++) {
  36     if (!array[i]) continue;
  37     Printf("%zu:%zu; ", i, array[i]);
  38   }
  39   Printf("\n");
  40 }
  41
  42 void AsanStats::Print() {
  43   Printf("Stats: %zuM malloced (%zuM for red zones) by %zu calls\n",
  44              malloced>>20, malloced_redzones>>20, mallocs);
  45   Printf("Stats: %zuM realloced by %zu calls\n", realloced>>20, reallocs);
  46   Printf("Stats: %zuM freed by %zu calls\n", freed>>20, frees);
  47   Printf("Stats: %zuM really freed by %zu calls\n",
  48              really_freed>>20, real_frees);
  49   Printf("Stats: %zuM (%zuM-%zuM) mmaped; %zu maps, %zu unmaps\n",
  50              (mmaped-munmaped)>>20, mmaped>>20, munmaped>>20,
  51              mmaps, munmaps);
  52
  53   PrintMallocStatsArray("  mallocs by size class: ", malloced_by_size);
  54   Printf("Stats: malloc large: %zu\n", malloc_large);
  55 }
  56
  57 void AsanStats::MergeFrom(const AsanStats *stats) {
  58   uptr *dst_ptr = reinterpret_cast<uptr*>(this);
  59   const uptr *src_ptr = reinterpret_cast<const uptr*>(stats);
  60   uptr num_fields = sizeof(*this) / sizeof(uptr);
  61   for (uptr i = 0; i < num_fields; i++)
  62     dst_ptr[i] += src_ptr[i];
  63 }
  64
  65 static BlockingMutex print_lock(LINKER_INITIALIZED);
  66
  67 static AsanStats unknown_thread_stats(LINKER_INITIALIZED);
  68 static AsanStats dead_threads_stats(LINKER_INITIALIZED);
  69 static BlockingMutex dead_threads_stats_lock(LINKER_INITIALIZED);
  70 // Required for malloc_zone_statistics() on OS X. This can't be stored in
  71 // per-thread AsanStats.
  72 static uptr max_malloced_memory;
  73
  74 static void MergeThreadStats(ThreadContextBase *tctx_base, void *arg) {
  75   AsanStats *accumulated_stats = reinterpret_cast<AsanStats*>(arg);
  76   AsanThreadContext *tctx = static_cast<AsanThreadContext*>(tctx_base);
  77   if (AsanThread *t = tctx->thread)
  78     accumulated_stats->MergeFrom(&t->stats());
  79 }
  80
  81 static void GetAccumulatedStats(AsanStats *stats) {
  82   stats->Clear();
  83   {
  84     ThreadRegistryLock l(&asanThreadRegistry());
  85     asanThreadRegistry()
  86         .RunCallbackForEachThreadLocked(MergeThreadStats, stats);
  87   }
  88   stats->MergeFrom(&unknown_thread_stats);
  89   {
  90     BlockingMutexLock lock(&dead_threads_stats_lock);
  91     stats->MergeFrom(&dead_threads_stats);
  92   }
  93   // This is not very accurate: we may miss allocation peaks that happen
  94   // between two updates of accumulated_stats_. For more accurate bookkeeping
  95   // the maximum should be updated on every malloc(), which is unacceptable.
  96   if (max_malloced_memory < stats->malloced) {
  97     max_malloced_memory = stats->malloced;
  98   }
  99 }
 100
 101 void FlushToDeadThreadStats(AsanStats *stats) {
 102   BlockingMutexLock lock(&dead_threads_stats_lock);
 103   dead_threads_stats.MergeFrom(stats);
 104   stats->Clear();
 105 }
 106
 107 void FillMallocStatistics(AsanMallocStats *malloc_stats) {
 108   AsanStats stats;
 109   GetAccumulatedStats(&stats);
 110   malloc_stats->blocks_in_use = stats.mallocs;
 111   malloc_stats->size_in_use = stats.malloced;
 112   malloc_stats->max_size_in_use = max_malloced_memory;
 113   malloc_stats->size_allocated = stats.mmaped;
 114 }
 115
 116 AsanStats &GetCurrentThreadStats() {
 117   AsanThread *t = GetCurrentThread();
 118   return (t) ? t->stats() : unknown_thread_stats;
 119 }
 120
 121 static void PrintAccumulatedStats() {
 122   AsanStats stats;
 123   GetAccumulatedStats(&stats);
 124   // Use lock to keep reports from mixing up.
 125   BlockingMutexLock lock(&print_lock);
 126   stats.Print();
 127   StackDepotStats *stack_depot_stats = StackDepotGetStats();
 128   Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",
 129          stack_depot_stats->n_uniq_ids, stack_depot_stats->allocated >> 20);
 130   PrintInternalAllocatorStats();
 131 }
 132
 133 }  // namespace __asan
 134
 135 // ---------------------- Interface ---------------- {{{1
 136 using namespace __asan;
 137
 138 uptr __sanitizer_get_current_allocated_bytes() {
 139   AsanStats stats;
 140   GetAccumulatedStats(&stats);
 141   uptr malloced = stats.malloced;
 142   uptr freed = stats.freed;
 143   // Return sane value if malloced < freed due to racy
 144   // way we update accumulated stats.
 145   return (malloced > freed) ? malloced - freed : 1;
 146 }
 147
 148 uptr __sanitizer_get_heap_size() {
 149   AsanStats stats;
 150   GetAccumulatedStats(&stats);
 151   return stats.mmaped - stats.munmaped;
 152 }
 153
 154 uptr __sanitizer_get_free_bytes() {
 155   AsanStats stats;
 156   GetAccumulatedStats(&stats);
 157   uptr total_free = stats.mmaped
 158                   - stats.munmaped
 159                   + stats.really_freed;
 160   uptr total_used = stats.malloced
 161                   + stats.malloced_redzones;
 162   // Return sane value if total_free < total_used due to racy
 163   // way we update accumulated stats.
 164   return (total_free > total_used) ? total_free - total_used : 1;
 165 }
 166
 167 uptr __sanitizer_get_unmapped_bytes() {
 168   return 0;
 169 }
 170
 171 void __asan_print_accumulated_stats() {
 172   PrintAccumulatedStats();
 173 }