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