You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by hb...@apache.org on 2017/01/17 19:31:11 UTC
[17/51] [partial] incubator-quickstep git commit: Added shell script
to download prerequisite third party libs
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/gperftools/src/heap-checker.cc
----------------------------------------------------------------------
diff --git a/third_party/gperftools/src/heap-checker.cc b/third_party/gperftools/src/heap-checker.cc
deleted file mode 100755
index 9c82dea..0000000
--- a/third_party/gperftools/src/heap-checker.cc
+++ /dev/null
@@ -1,2388 +0,0 @@
-// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright (c) 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-// All Rights Reserved.
-//
-// Author: Maxim Lifantsev
-//
-
-#include "config.h"
-
-#include <fcntl.h> // for O_RDONLY (we use syscall to do actual reads)
-#include <string.h>
-#include <errno.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#endif
-#ifdef HAVE_PTHREAD
-#include <pthread.h>
-#endif
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
-#include <assert.h>
-
-#if defined(HAVE_LINUX_PTRACE_H)
-#include <linux/ptrace.h>
-#endif
-#ifdef HAVE_SYS_SYSCALL_H
-#include <sys/syscall.h>
-#endif
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__) || defined(__MINGW32__)
-#include <wtypes.h>
-#include <winbase.h>
-#undef ERROR // windows defines these as macros, which can cause trouble
-#undef max
-#undef min
-#endif
-
-#include <string>
-#include <vector>
-#include <map>
-#include <set>
-#include <algorithm>
-#include <functional>
-
-#include <gperftools/heap-checker.h>
-
-#include "base/basictypes.h"
-#include "base/googleinit.h"
-#include "base/logging.h"
-#include <gperftools/stacktrace.h>
-#include "base/commandlineflags.h"
-#include "base/elfcore.h" // for i386_regs
-#include "base/thread_lister.h"
-#include "heap-profile-table.h"
-#include "base/low_level_alloc.h"
-#include "malloc_hook-inl.h"
-#include <gperftools/malloc_hook.h>
-#include <gperftools/malloc_extension.h>
-#include "maybe_threads.h"
-#include "memory_region_map.h"
-#include "base/spinlock.h"
-#include "base/sysinfo.h"
-#include "base/stl_allocator.h"
-
-using std::string;
-using std::basic_string;
-using std::pair;
-using std::map;
-using std::set;
-using std::vector;
-using std::swap;
-using std::make_pair;
-using std::min;
-using std::max;
-using std::less;
-using std::char_traits;
-
-// If current process is being ptrace()d, 'TracerPid' in /proc/self/status
-// will be non-zero.
-static bool IsDebuggerAttached(void) { // only works under linux, probably
- char buf[256]; // TracerPid comes relatively earlier in status output
- int fd = open("/proc/self/status", O_RDONLY);
- if (fd == -1) {
- return false; // Can't tell for sure.
- }
- const int len = read(fd, buf, sizeof(buf));
- bool rc = false;
- if (len > 0) {
- const char *const kTracerPid = "TracerPid:\t";
- buf[len - 1] = '\0';
- const char *p = strstr(buf, kTracerPid);
- if (p != NULL) {
- rc = (strncmp(p + strlen(kTracerPid), "0\n", 2) != 0);
- }
- }
- close(fd);
- return rc;
-}
-
-// This is the default if you don't link in -lprofiler
-extern "C" {
-ATTRIBUTE_WEAK PERFTOOLS_DLL_DECL bool ProfilingIsEnabledForAllThreads();
-bool ProfilingIsEnabledForAllThreads() { return false; }
-}
-
-//----------------------------------------------------------------------
-// Flags that control heap-checking
-//----------------------------------------------------------------------
-
-DEFINE_string(heap_check,
- EnvToString("HEAPCHECK", ""),
- "The heap leak checking to be done over the whole executable: "
- "\"minimal\", \"normal\", \"strict\", "
- "\"draconian\", \"as-is\", and \"local\" "
- " or the empty string are the supported choices. "
- "(See HeapLeakChecker_InternalInitStart for details.)");
-
-DEFINE_bool(heap_check_report, true, "Obsolete");
-
-DEFINE_bool(heap_check_before_constructors,
- true,
- "deprecated; pretty much always true now");
-
-DEFINE_bool(heap_check_after_destructors,
- EnvToBool("HEAP_CHECK_AFTER_DESTRUCTORS", false),
- "If overall heap check is to end after global destructors "
- "or right after all REGISTER_HEAPCHECK_CLEANUP's");
-
-DEFINE_bool(heap_check_strict_check, true, "Obsolete");
-
-DEFINE_bool(heap_check_ignore_global_live,
- EnvToBool("HEAP_CHECK_IGNORE_GLOBAL_LIVE", true),
- "If overall heap check is to ignore heap objects reachable "
- "from the global data");
-
-DEFINE_bool(heap_check_identify_leaks,
- EnvToBool("HEAP_CHECK_IDENTIFY_LEAKS", false),
- "If heap check should generate the addresses of the leaked "
- "objects in the memory leak profiles. This may be useful "
- "in tracking down leaks where only a small fraction of "
- "objects allocated at the same stack trace are leaked.");
-
-DEFINE_bool(heap_check_ignore_thread_live,
- EnvToBool("HEAP_CHECK_IGNORE_THREAD_LIVE", true),
- "If set to true, objects reachable from thread stacks "
- "and registers are not reported as leaks");
-
-DEFINE_bool(heap_check_test_pointer_alignment,
- EnvToBool("HEAP_CHECK_TEST_POINTER_ALIGNMENT", false),
- "Set to true to check if the found leak can be due to "
- "use of unaligned pointers");
-
-// Alignment at which all pointers in memory are supposed to be located;
-// use 1 if any alignment is ok.
-// heap_check_test_pointer_alignment flag guides if we try the value of 1.
-// The larger it can be, the lesser is the chance of missing real leaks.
-static const size_t kPointerSourceAlignment = sizeof(void*);
-DEFINE_int32(heap_check_pointer_source_alignment,
- EnvToInt("HEAP_CHECK_POINTER_SOURCE_ALIGNMENT",
- kPointerSourceAlignment),
- "Alignment at which all pointers in memory are supposed to be "
- "located. Use 1 if any alignment is ok.");
-
-// A reasonable default to handle pointers inside of typical class objects:
-// Too low and we won't be able to traverse pointers to normally-used
-// nested objects and base parts of multiple-inherited objects.
-// Too high and it will both slow down leak checking (FindInsideAlloc
-// in HaveOnHeapLocked will get slower when there are large on-heap objects)
-// and make it probabilistically more likely to miss leaks
-// of large-sized objects.
-static const int64 kHeapCheckMaxPointerOffset = 1024;
-DEFINE_int64(heap_check_max_pointer_offset,
- EnvToInt("HEAP_CHECK_MAX_POINTER_OFFSET",
- kHeapCheckMaxPointerOffset),
- "Largest pointer offset for which we traverse "
- "pointers going inside of heap allocated objects. "
- "Set to -1 to use the actual largest heap object size.");
-
-DEFINE_bool(heap_check_run_under_gdb,
- EnvToBool("HEAP_CHECK_RUN_UNDER_GDB", false),
- "If false, turns off heap-checking library when running under gdb "
- "(normally, set to 'true' only when debugging the heap-checker)");
-
-DEFINE_int32(heap_check_delay_seconds, 0,
- "Number of seconds to delay on-exit heap checking."
- " If you set this flag,"
- " you may also want to set exit_timeout_seconds in order to"
- " avoid exit timeouts.\n"
- "NOTE: This flag is to be used only to help diagnose issues"
- " where it is suspected that the heap checker is reporting"
- " false leaks that will disappear if the heap checker delays"
- " its checks. Report any such issues to the heap-checker"
- " maintainer(s).");
-
-//----------------------------------------------------------------------
-
-DEFINE_string(heap_profile_pprof,
- EnvToString("PPROF_PATH", "pprof"),
- "OBSOLETE; not used");
-
-DEFINE_string(heap_check_dump_directory,
- EnvToString("HEAP_CHECK_DUMP_DIRECTORY", "/tmp"),
- "Directory to put heap-checker leak dump information");
-
-
-//----------------------------------------------------------------------
-// HeapLeakChecker global data
-//----------------------------------------------------------------------
-
-// Global lock for all the global data of this module.
-static SpinLock heap_checker_lock(SpinLock::LINKER_INITIALIZED);
-
-//----------------------------------------------------------------------
-
-// Heap profile prefix for leak checking profiles.
-// Gets assigned once when leak checking is turned on, then never modified.
-static const string* profile_name_prefix = NULL;
-
-// Whole-program heap leak checker.
-// Gets assigned once when leak checking is turned on,
-// then main_heap_checker is never deleted.
-static HeapLeakChecker* main_heap_checker = NULL;
-
-// Whether we will use main_heap_checker to do a check at program exit
-// automatically. In any case user can ask for more checks on main_heap_checker
-// via GlobalChecker().
-static bool do_main_heap_check = false;
-
-// The heap profile we use to collect info about the heap.
-// This is created in HeapLeakChecker::BeforeConstructorsLocked
-// together with setting heap_checker_on (below) to true
-// and registering our new/delete malloc hooks;
-// similarly all are unset in HeapLeakChecker::TurnItselfOffLocked.
-static HeapProfileTable* heap_profile = NULL;
-
-// If we are doing (or going to do) any kind of heap-checking.
-static bool heap_checker_on = false;
-
-// pid of the process that does whole-program heap leak checking
-static pid_t heap_checker_pid = 0;
-
-// If we did heap profiling during global constructors execution
-static bool constructor_heap_profiling = false;
-
-// RAW_VLOG level we dump key INFO messages at. If you want to turn
-// off these messages, set the environment variable PERFTOOLS_VERBOSE=-1.
-static const int heap_checker_info_level = 0;
-
-//----------------------------------------------------------------------
-// HeapLeakChecker's own memory allocator that is
-// independent of the normal program allocator.
-//----------------------------------------------------------------------
-
-// Wrapper of LowLevelAlloc for STL_Allocator and direct use.
-// We always access this class under held heap_checker_lock,
-// this allows us to in particular protect the period when threads are stopped
-// at random spots with TCMalloc_ListAllProcessThreads by heap_checker_lock,
-// w/o worrying about the lock in LowLevelAlloc::Arena.
-// We rely on the fact that we use an own arena with an own lock here.
-class HeapLeakChecker::Allocator {
- public:
- static void Init() {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- RAW_DCHECK(arena_ == NULL, "");
- arena_ = LowLevelAlloc::NewArena(0, LowLevelAlloc::DefaultArena());
- }
- static void Shutdown() {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- if (!LowLevelAlloc::DeleteArena(arena_) || alloc_count_ != 0) {
- RAW_LOG(FATAL, "Internal heap checker leak of %d objects", alloc_count_);
- }
- }
- static int alloc_count() {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- return alloc_count_;
- }
- static void* Allocate(size_t n) {
- RAW_DCHECK(arena_ && heap_checker_lock.IsHeld(), "");
- void* p = LowLevelAlloc::AllocWithArena(n, arena_);
- if (p) alloc_count_ += 1;
- return p;
- }
- static void Free(void* p) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- if (p) alloc_count_ -= 1;
- LowLevelAlloc::Free(p);
- }
- static void Free(void* p, size_t /* n */) {
- Free(p);
- }
- // destruct, free, and make *p to be NULL
- template<typename T> static void DeleteAndNull(T** p) {
- (*p)->~T();
- Free(*p);
- *p = NULL;
- }
- template<typename T> static void DeleteAndNullIfNot(T** p) {
- if (*p != NULL) DeleteAndNull(p);
- }
- private:
- static LowLevelAlloc::Arena* arena_;
- static int alloc_count_;
-};
-
-LowLevelAlloc::Arena* HeapLeakChecker::Allocator::arena_ = NULL;
-int HeapLeakChecker::Allocator::alloc_count_ = 0;
-
-//----------------------------------------------------------------------
-// HeapLeakChecker live object tracking components
-//----------------------------------------------------------------------
-
-// Cases of live object placement we distinguish
-enum ObjectPlacement {
- MUST_BE_ON_HEAP, // Must point to a live object of the matching size in the
- // heap_profile map of the heap when we get to it
- IGNORED_ON_HEAP, // Is a live (ignored) object on heap
- MAYBE_LIVE, // Is a piece of writable memory from /proc/self/maps
- IN_GLOBAL_DATA, // Is part of global data region of the executable
- THREAD_DATA, // Part of a thread stack and a thread descriptor with TLS
- THREAD_REGISTERS, // Values in registers of some thread
-};
-
-// Information about an allocated object
-struct AllocObject {
- const void* ptr; // the object
- uintptr_t size; // its size
- ObjectPlacement place; // where ptr points to
-
- AllocObject(const void* p, size_t s, ObjectPlacement l)
- : ptr(p), size(s), place(l) { }
-};
-
-// All objects (memory ranges) ignored via HeapLeakChecker::IgnoreObject
-// Key is the object's address; value is its size.
-typedef map<uintptr_t, size_t, less<uintptr_t>,
- STL_Allocator<pair<const uintptr_t, size_t>,
- HeapLeakChecker::Allocator>
- > IgnoredObjectsMap;
-static IgnoredObjectsMap* ignored_objects = NULL;
-
-// All objects (memory ranges) that we consider to be the sources of pointers
-// to live (not leaked) objects.
-// At different times this holds (what can be reached from) global data regions
-// and the objects we've been told to ignore.
-// For any AllocObject::ptr "live_objects" is supposed to contain at most one
-// record at any time. We maintain this by checking with the heap_profile map
-// of the heap and removing the live heap objects we've handled from it.
-// This vector is maintained as a stack and the frontier of reachable
-// live heap objects in our flood traversal of them.
-typedef vector<AllocObject,
- STL_Allocator<AllocObject, HeapLeakChecker::Allocator>
- > LiveObjectsStack;
-static LiveObjectsStack* live_objects = NULL;
-
-// A special string type that uses my allocator
-typedef basic_string<char, char_traits<char>,
- STL_Allocator<char, HeapLeakChecker::Allocator>
- > HCL_string;
-
-// A placeholder to fill-in the starting values for live_objects
-// for each library so we can keep the library-name association for logging.
-typedef map<HCL_string, LiveObjectsStack, less<HCL_string>,
- STL_Allocator<pair<const HCL_string, LiveObjectsStack>,
- HeapLeakChecker::Allocator>
- > LibraryLiveObjectsStacks;
-static LibraryLiveObjectsStacks* library_live_objects = NULL;
-
-// Value stored in the map of disabled address ranges;
-// its key is the end of the address range.
-// We'll ignore allocations with a return address in a disabled range
-// if the address occurs at 'max_depth' or less in the stack trace.
-struct HeapLeakChecker::RangeValue {
- uintptr_t start_address; // the start of the range
- int max_depth; // the maximal stack depth to disable at
-};
-typedef map<uintptr_t, HeapLeakChecker::RangeValue, less<uintptr_t>,
- STL_Allocator<pair<const uintptr_t, HeapLeakChecker::RangeValue>,
- HeapLeakChecker::Allocator>
- > DisabledRangeMap;
-// The disabled program counter address ranges for profile dumping
-// that are registered with HeapLeakChecker::DisableChecksFromToLocked.
-static DisabledRangeMap* disabled_ranges = NULL;
-
-// Set of stack tops.
-// These are used to consider live only appropriate chunks of the memory areas
-// that are used for stacks (and maybe thread-specific data as well)
-// so that we do not treat pointers from outdated stack frames as live.
-typedef set<uintptr_t, less<uintptr_t>,
- STL_Allocator<uintptr_t, HeapLeakChecker::Allocator>
- > StackTopSet;
-static StackTopSet* stack_tops = NULL;
-
-// A map of ranges of code addresses for the system libraries
-// that can mmap/mremap/sbrk-allocate memory regions for stacks
-// and thread-local storage that we want to consider as live global data.
-// Maps from the end address to the start address.
-typedef map<uintptr_t, uintptr_t, less<uintptr_t>,
- STL_Allocator<pair<const uintptr_t, uintptr_t>,
- HeapLeakChecker::Allocator>
- > GlobalRegionCallerRangeMap;
-static GlobalRegionCallerRangeMap* global_region_caller_ranges = NULL;
-
-// TODO(maxim): make our big data structs into own modules
-
-// Disabler is implemented by keeping track of a per-thread count
-// of active Disabler objects. Any objects allocated while the
-// count > 0 are not reported.
-
-#ifdef HAVE_TLS
-
-static __thread int thread_disable_counter
-// The "inital exec" model is faster than the default TLS model, at
-// the cost you can't dlopen this library. But dlopen on heap-checker
-// doesn't work anyway -- it must run before main -- so this is a good
-// trade-off.
-# ifdef HAVE___ATTRIBUTE__
- __attribute__ ((tls_model ("initial-exec")))
-# endif
- ;
-inline int get_thread_disable_counter() {
- return thread_disable_counter;
-}
-inline void set_thread_disable_counter(int value) {
- thread_disable_counter = value;
-}
-
-#else // #ifdef HAVE_TLS
-
-static pthread_key_t thread_disable_counter_key;
-static int main_thread_counter; // storage for use before main()
-static bool use_main_thread_counter = true;
-
-// TODO(csilvers): this is called from NewHook, in the middle of malloc().
-// If perftools_pthread_getspecific calls malloc, that will lead to an
-// infinite loop. I don't know how to fix that, so I hope it never happens!
-inline int get_thread_disable_counter() {
- if (use_main_thread_counter) // means we're running really early
- return main_thread_counter;
- void* p = perftools_pthread_getspecific(thread_disable_counter_key);
- return (intptr_t)p; // kinda evil: store the counter directly in the void*
-}
-
-inline void set_thread_disable_counter(int value) {
- if (use_main_thread_counter) { // means we're running really early
- main_thread_counter = value;
- return;
- }
- intptr_t pointer_sized_value = value;
- // kinda evil: store the counter directly in the void*
- void* p = (void*)pointer_sized_value;
- // NOTE: this may call malloc, which will call NewHook which will call
- // get_thread_disable_counter() which will call pthread_getspecific(). I
- // don't know if anything bad can happen if we call getspecific() in the
- // middle of a setspecific() call. It seems to work ok in practice...
- perftools_pthread_setspecific(thread_disable_counter_key, p);
-}
-
-// The idea here is that this initializer will run pretty late: after
-// pthreads have been totally set up. At this point we can call
-// pthreads routines, so we set those up.
-class InitThreadDisableCounter {
- public:
- InitThreadDisableCounter() {
- perftools_pthread_key_create(&thread_disable_counter_key, NULL);
- // Set up the main thread's value, which we have a special variable for.
- void* p = (void*)main_thread_counter; // store the counter directly
- perftools_pthread_setspecific(thread_disable_counter_key, p);
- use_main_thread_counter = false;
- }
-};
-InitThreadDisableCounter init_thread_disable_counter;
-
-#endif // #ifdef HAVE_TLS
-
-HeapLeakChecker::Disabler::Disabler() {
- // It is faster to unconditionally increment the thread-local
- // counter than to check whether or not heap-checking is on
- // in a thread-safe manner.
- int counter = get_thread_disable_counter();
- set_thread_disable_counter(counter + 1);
- RAW_VLOG(10, "Increasing thread disable counter to %d", counter + 1);
-}
-
-HeapLeakChecker::Disabler::~Disabler() {
- int counter = get_thread_disable_counter();
- RAW_DCHECK(counter > 0, "");
- if (counter > 0) {
- set_thread_disable_counter(counter - 1);
- RAW_VLOG(10, "Decreasing thread disable counter to %d", counter);
- } else {
- RAW_VLOG(0, "Thread disable counter underflow : %d", counter);
- }
-}
-
-//----------------------------------------------------------------------
-
-// The size of the largest heap object allocated so far.
-static size_t max_heap_object_size = 0;
-// The possible range of addresses that can point
-// into one of the elements of heap_objects.
-static uintptr_t min_heap_address = uintptr_t(-1LL);
-static uintptr_t max_heap_address = 0;
-
-//----------------------------------------------------------------------
-
-// Simple casting helpers for uintptr_t and void*:
-template<typename T>
-inline static const void* AsPtr(T addr) {
- return reinterpret_cast<void*>(addr);
-}
-inline static uintptr_t AsInt(const void* ptr) {
- return reinterpret_cast<uintptr_t>(ptr);
-}
-
-//----------------------------------------------------------------------
-
-// We've seen reports that strstr causes heap-checker crashes in some
-// libc's (?):
-// http://code.google.com/p/gperftools/issues/detail?id=263
-// It's simple enough to use our own. This is not in time-critical code.
-static const char* hc_strstr(const char* s1, const char* s2) {
- const size_t len = strlen(s2);
- RAW_CHECK(len > 0, "Unexpected empty string passed to strstr()");
- for (const char* p = strchr(s1, *s2); p != NULL; p = strchr(p+1, *s2)) {
- if (strncmp(p, s2, len) == 0) {
- return p;
- }
- }
- return NULL;
-}
-
-//----------------------------------------------------------------------
-
-// Our hooks for MallocHook
-static void NewHook(const void* ptr, size_t size) {
- if (ptr != NULL) {
- const int counter = get_thread_disable_counter();
- const bool ignore = (counter > 0);
- RAW_VLOG(16, "Recording Alloc: %p of %" PRIuS "; %d", ptr, size,
- int(counter));
-
- // Fetch the caller's stack trace before acquiring heap_checker_lock.
- void* stack[HeapProfileTable::kMaxStackDepth];
- int depth = HeapProfileTable::GetCallerStackTrace(0, stack);
-
- { SpinLockHolder l(&heap_checker_lock);
- if (size > max_heap_object_size) max_heap_object_size = size;
- uintptr_t addr = AsInt(ptr);
- if (addr < min_heap_address) min_heap_address = addr;
- addr += size;
- if (addr > max_heap_address) max_heap_address = addr;
- if (heap_checker_on) {
- heap_profile->RecordAlloc(ptr, size, depth, stack);
- if (ignore) {
- heap_profile->MarkAsIgnored(ptr);
- }
- }
- }
- RAW_VLOG(17, "Alloc Recorded: %p of %" PRIuS "", ptr, size);
- }
-}
-
-static void DeleteHook(const void* ptr) {
- if (ptr != NULL) {
- RAW_VLOG(16, "Recording Free %p", ptr);
- { SpinLockHolder l(&heap_checker_lock);
- if (heap_checker_on) heap_profile->RecordFree(ptr);
- }
- RAW_VLOG(17, "Free Recorded: %p", ptr);
- }
-}
-
-//----------------------------------------------------------------------
-
-enum StackDirection {
- GROWS_TOWARDS_HIGH_ADDRESSES,
- GROWS_TOWARDS_LOW_ADDRESSES,
- UNKNOWN_DIRECTION
-};
-
-// Determine which way the stack grows:
-
-static StackDirection ATTRIBUTE_NOINLINE GetStackDirection(
- const uintptr_t *const ptr) {
- uintptr_t x;
- if (&x < ptr)
- return GROWS_TOWARDS_LOW_ADDRESSES;
- if (ptr < &x)
- return GROWS_TOWARDS_HIGH_ADDRESSES;
-
- RAW_CHECK(0, ""); // Couldn't determine the stack direction.
-
- return UNKNOWN_DIRECTION;
-}
-
-// Direction of stack growth (will initialize via GetStackDirection())
-static StackDirection stack_direction = UNKNOWN_DIRECTION;
-
-// This routine is called for every thread stack we know about to register it.
-static void RegisterStackLocked(const void* top_ptr) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- RAW_DCHECK(MemoryRegionMap::LockIsHeld(), "");
- RAW_VLOG(10, "Thread stack at %p", top_ptr);
- uintptr_t top = AsInt(top_ptr);
- stack_tops->insert(top); // add for later use
-
- // make sure stack_direction is initialized
- if (stack_direction == UNKNOWN_DIRECTION) {
- stack_direction = GetStackDirection(&top);
- }
-
- // Find memory region with this stack
- MemoryRegionMap::Region region;
- if (MemoryRegionMap::FindAndMarkStackRegion(top, ®ion)) {
- // Make the proper portion of the stack live:
- if (stack_direction == GROWS_TOWARDS_LOW_ADDRESSES) {
- RAW_VLOG(11, "Live stack at %p of %" PRIuPTR " bytes",
- top_ptr, region.end_addr - top);
- live_objects->push_back(AllocObject(top_ptr, region.end_addr - top,
- THREAD_DATA));
- } else { // GROWS_TOWARDS_HIGH_ADDRESSES
- RAW_VLOG(11, "Live stack at %p of %" PRIuPTR " bytes",
- AsPtr(region.start_addr),
- top - region.start_addr);
- live_objects->push_back(AllocObject(AsPtr(region.start_addr),
- top - region.start_addr,
- THREAD_DATA));
- }
- // not in MemoryRegionMap, look in library_live_objects:
- } else if (FLAGS_heap_check_ignore_global_live) {
- for (LibraryLiveObjectsStacks::iterator lib = library_live_objects->begin();
- lib != library_live_objects->end(); ++lib) {
- for (LiveObjectsStack::iterator span = lib->second.begin();
- span != lib->second.end(); ++span) {
- uintptr_t start = AsInt(span->ptr);
- uintptr_t end = start + span->size;
- if (start <= top && top < end) {
- RAW_VLOG(11, "Stack at %p is inside /proc/self/maps chunk %p..%p",
- top_ptr, AsPtr(start), AsPtr(end));
- // Shrink start..end region by chopping away the memory regions in
- // MemoryRegionMap that land in it to undo merging of regions
- // in /proc/self/maps, so that we correctly identify what portion
- // of start..end is actually the stack region.
- uintptr_t stack_start = start;
- uintptr_t stack_end = end;
- // can optimize-away this loop, but it does not run often
- RAW_DCHECK(MemoryRegionMap::LockIsHeld(), "");
- for (MemoryRegionMap::RegionIterator r =
- MemoryRegionMap::BeginRegionLocked();
- r != MemoryRegionMap::EndRegionLocked(); ++r) {
- if (top < r->start_addr && r->start_addr < stack_end) {
- stack_end = r->start_addr;
- }
- if (stack_start < r->end_addr && r->end_addr <= top) {
- stack_start = r->end_addr;
- }
- }
- if (stack_start != start || stack_end != end) {
- RAW_VLOG(11, "Stack at %p is actually inside memory chunk %p..%p",
- top_ptr, AsPtr(stack_start), AsPtr(stack_end));
- }
- // Make the proper portion of the stack live:
- if (stack_direction == GROWS_TOWARDS_LOW_ADDRESSES) {
- RAW_VLOG(11, "Live stack at %p of %" PRIuPTR " bytes",
- top_ptr, stack_end - top);
- live_objects->push_back(
- AllocObject(top_ptr, stack_end - top, THREAD_DATA));
- } else { // GROWS_TOWARDS_HIGH_ADDRESSES
- RAW_VLOG(11, "Live stack at %p of %" PRIuPTR " bytes",
- AsPtr(stack_start), top - stack_start);
- live_objects->push_back(
- AllocObject(AsPtr(stack_start), top - stack_start, THREAD_DATA));
- }
- lib->second.erase(span); // kill the rest of the region
- // Put the non-stack part(s) of the region back:
- if (stack_start != start) {
- lib->second.push_back(AllocObject(AsPtr(start), stack_start - start,
- MAYBE_LIVE));
- }
- if (stack_end != end) {
- lib->second.push_back(AllocObject(AsPtr(stack_end), end - stack_end,
- MAYBE_LIVE));
- }
- return;
- }
- }
- }
- RAW_LOG(ERROR, "Memory region for stack at %p not found. "
- "Will likely report false leak positives.", top_ptr);
- }
-}
-
-// Iterator for heap allocation map data to make ignored objects "live"
-// (i.e., treated as roots for the mark-and-sweep phase)
-static void MakeIgnoredObjectsLiveCallbackLocked(
- const void* ptr, const HeapProfileTable::AllocInfo& info) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- if (info.ignored) {
- live_objects->push_back(AllocObject(ptr, info.object_size,
- MUST_BE_ON_HEAP));
- }
-}
-
-// Iterator for heap allocation map data to make objects allocated from
-// disabled regions of code to be live.
-static void MakeDisabledLiveCallbackLocked(
- const void* ptr, const HeapProfileTable::AllocInfo& info) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- bool stack_disable = false;
- bool range_disable = false;
- for (int depth = 0; depth < info.stack_depth; depth++) {
- uintptr_t addr = AsInt(info.call_stack[depth]);
- if (disabled_ranges) {
- DisabledRangeMap::const_iterator iter
- = disabled_ranges->upper_bound(addr);
- if (iter != disabled_ranges->end()) {
- RAW_DCHECK(iter->first > addr, "");
- if (iter->second.start_address < addr &&
- iter->second.max_depth > depth) {
- range_disable = true; // in range; dropping
- break;
- }
- }
- }
- }
- if (stack_disable || range_disable) {
- uintptr_t start_address = AsInt(ptr);
- uintptr_t end_address = start_address + info.object_size;
- StackTopSet::const_iterator iter
- = stack_tops->lower_bound(start_address);
- if (iter != stack_tops->end()) {
- RAW_DCHECK(*iter >= start_address, "");
- if (*iter < end_address) {
- // We do not disable (treat as live) whole allocated regions
- // if they are used to hold thread call stacks
- // (i.e. when we find a stack inside).
- // The reason is that we'll treat as live the currently used
- // stack portions anyway (see RegisterStackLocked),
- // and the rest of the region where the stack lives can well
- // contain outdated stack variables which are not live anymore,
- // hence should not be treated as such.
- RAW_VLOG(11, "Not %s-disabling %" PRIuS " bytes at %p"
- ": have stack inside: %p",
- (stack_disable ? "stack" : "range"),
- info.object_size, ptr, AsPtr(*iter));
- return;
- }
- }
- RAW_VLOG(11, "%s-disabling %" PRIuS " bytes at %p",
- (stack_disable ? "Stack" : "Range"), info.object_size, ptr);
- live_objects->push_back(AllocObject(ptr, info.object_size,
- MUST_BE_ON_HEAP));
- }
-}
-
-static const char kUnnamedProcSelfMapEntry[] = "UNNAMED";
-
-// This function takes some fields from a /proc/self/maps line:
-//
-// start_address start address of a memory region.
-// end_address end address of a memory region
-// permissions rwx + private/shared bit
-// filename filename of the mapped file
-//
-// If the region is not writeable, then it cannot have any heap
-// pointers in it, otherwise we record it as a candidate live region
-// to get filtered later.
-static void RecordGlobalDataLocked(uintptr_t start_address,
- uintptr_t end_address,
- const char* permissions,
- const char* filename) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- // Ignore non-writeable regions.
- if (strchr(permissions, 'w') == NULL) return;
- if (filename == NULL || *filename == '\0') {
- filename = kUnnamedProcSelfMapEntry;
- }
- RAW_VLOG(11, "Looking into %s: 0x%" PRIxPTR "..0x%" PRIxPTR,
- filename, start_address, end_address);
- (*library_live_objects)[filename].
- push_back(AllocObject(AsPtr(start_address),
- end_address - start_address,
- MAYBE_LIVE));
-}
-
-// See if 'library' from /proc/self/maps has base name 'library_base'
-// i.e. contains it and has '.' or '-' after it.
-static bool IsLibraryNamed(const char* library, const char* library_base) {
- const char* p = hc_strstr(library, library_base);
- size_t sz = strlen(library_base);
- return p != NULL && (p[sz] == '.' || p[sz] == '-');
-}
-
-// static
-void HeapLeakChecker::DisableLibraryAllocsLocked(const char* library,
- uintptr_t start_address,
- uintptr_t end_address) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- int depth = 0;
- // TODO(maxim): maybe this should be extended to also use objdump
- // and pick the text portion of the library more precisely.
- if (IsLibraryNamed(library, "/libpthread") ||
- // libpthread has a lot of small "system" leaks we don't care about.
- // In particular it allocates memory to store data supplied via
- // pthread_setspecific (which can be the only pointer to a heap object).
- IsLibraryNamed(library, "/libdl") ||
- // library loaders leak some "system" heap that we don't care about
- IsLibraryNamed(library, "/libcrypto") ||
- // Sometimes libcrypto of OpenSSH is compiled with -fomit-frame-pointer
- // (any library can be, of course, but this one often is because speed
- // is so important for making crypto usable). We ignore all its
- // allocations because we can't see the call stacks. We'd prefer
- // to ignore allocations done in files/symbols that match
- // "default_malloc_ex|default_realloc_ex"
- // but that doesn't work when the end-result binary is stripped.
- IsLibraryNamed(library, "/libjvm") ||
- // JVM has a lot of leaks we don't care about.
- IsLibraryNamed(library, "/libzip")
- // The JVM leaks java.util.zip.Inflater after loading classes.
- ) {
- depth = 1; // only disable allocation calls directly from the library code
- } else if (IsLibraryNamed(library, "/ld")
- // library loader leaks some "system" heap
- // (e.g. thread-local storage) that we don't care about
- ) {
- depth = 2; // disable allocation calls directly from the library code
- // and at depth 2 from it.
- // We need depth 2 here solely because of a libc bug that
- // forces us to jump through __memalign_hook and MemalignOverride hoops
- // in tcmalloc.cc.
- // Those buggy __libc_memalign() calls are in ld-linux.so and happen for
- // thread-local storage allocations that we want to ignore here.
- // We go with the depth-2 hack as a workaround for this libc bug:
- // otherwise we'd need to extend MallocHook interface
- // so that correct stack depth adjustment can be propagated from
- // the exceptional case of MemalignOverride.
- // Using depth 2 here should not mask real leaks because ld-linux.so
- // does not call user code.
- }
- if (depth) {
- RAW_VLOG(10, "Disabling allocations from %s at depth %d:", library, depth);
- DisableChecksFromToLocked(AsPtr(start_address), AsPtr(end_address), depth);
- if (IsLibraryNamed(library, "/libpthread") ||
- IsLibraryNamed(library, "/libdl") ||
- IsLibraryNamed(library, "/ld")) {
- RAW_VLOG(10, "Global memory regions made by %s will be live data",
- library);
- if (global_region_caller_ranges == NULL) {
- global_region_caller_ranges =
- new(Allocator::Allocate(sizeof(GlobalRegionCallerRangeMap)))
- GlobalRegionCallerRangeMap;
- }
- global_region_caller_ranges
- ->insert(make_pair(end_address, start_address));
- }
- }
-}
-
-// static
-HeapLeakChecker::ProcMapsResult HeapLeakChecker::UseProcMapsLocked(
- ProcMapsTask proc_maps_task) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- // Need to provide own scratch memory to ProcMapsIterator:
- ProcMapsIterator::Buffer buffer;
- ProcMapsIterator it(0, &buffer);
- if (!it.Valid()) {
- int errsv = errno;
- RAW_LOG(ERROR, "Could not open /proc/self/maps: errno=%d. "
- "Libraries will not be handled correctly.", errsv);
- return CANT_OPEN_PROC_MAPS;
- }
- uint64 start_address, end_address, file_offset;
- int64 inode;
- char *permissions, *filename;
- bool saw_shared_lib = false;
- bool saw_nonzero_inode = false;
- bool saw_shared_lib_with_nonzero_inode = false;
- while (it.Next(&start_address, &end_address, &permissions,
- &file_offset, &inode, &filename)) {
- if (start_address >= end_address) {
- // Warn if a line we can be interested in is ill-formed:
- if (inode != 0) {
- RAW_LOG(ERROR, "Errors reading /proc/self/maps. "
- "Some global memory regions will not "
- "be handled correctly.");
- }
- // Silently skip other ill-formed lines: some are possible
- // probably due to the interplay of how /proc/self/maps is updated
- // while we read it in chunks in ProcMapsIterator and
- // do things in this loop.
- continue;
- }
- // Determine if any shared libraries are present (this is the same
- // list of extensions as is found in pprof). We want to ignore
- // 'fake' libraries with inode 0 when determining. However, some
- // systems don't share inodes via /proc, so we turn off this check
- // if we don't see any evidence that we're getting inode info.
- if (inode != 0) {
- saw_nonzero_inode = true;
- }
- if ((hc_strstr(filename, "lib") && hc_strstr(filename, ".so")) ||
- hc_strstr(filename, ".dll") ||
- // not all .dylib filenames start with lib. .dylib is big enough
- // that we are unlikely to get false matches just checking that.
- hc_strstr(filename, ".dylib") || hc_strstr(filename, ".bundle")) {
- saw_shared_lib = true;
- if (inode != 0) {
- saw_shared_lib_with_nonzero_inode = true;
- }
- }
-
- switch (proc_maps_task) {
- case DISABLE_LIBRARY_ALLOCS:
- // All lines starting like
- // "401dc000-4030f000 r??p 00132000 03:01 13991972 lib/bin"
- // identify a data and code sections of a shared library or our binary
- if (inode != 0 && strncmp(permissions, "r-xp", 4) == 0) {
- DisableLibraryAllocsLocked(filename, start_address, end_address);
- }
- break;
- case RECORD_GLOBAL_DATA:
- RecordGlobalDataLocked(start_address, end_address,
- permissions, filename);
- break;
- default:
- RAW_CHECK(0, "");
- }
- }
- // If /proc/self/maps is reporting inodes properly (we saw a
- // non-zero inode), then we only say we saw a shared lib if we saw a
- // 'real' one, with a non-zero inode.
- if (saw_nonzero_inode) {
- saw_shared_lib = saw_shared_lib_with_nonzero_inode;
- }
- if (!saw_shared_lib) {
- RAW_LOG(ERROR, "No shared libs detected. Will likely report false leak "
- "positives for statically linked executables.");
- return NO_SHARED_LIBS_IN_PROC_MAPS;
- }
- return PROC_MAPS_USED;
-}
-
-// Total number and size of live objects dropped from the profile;
-// (re)initialized in IgnoreAllLiveObjectsLocked.
-static int64 live_objects_total;
-static int64 live_bytes_total;
-
-// pid of the thread that is doing the current leak check
-// (protected by our lock; IgnoreAllLiveObjectsLocked sets it)
-static pid_t self_thread_pid = 0;
-
-// Status of our thread listing callback execution
-// (protected by our lock; used from within IgnoreAllLiveObjectsLocked)
-static enum {
- CALLBACK_NOT_STARTED,
- CALLBACK_STARTED,
- CALLBACK_COMPLETED,
-} thread_listing_status = CALLBACK_NOT_STARTED;
-
-// Ideally to avoid deadlocks this function should not result in any libc
-// or other function calls that might need to lock a mutex:
-// It is called when all threads of a process are stopped
-// at arbitrary points thus potentially holding those locks.
-//
-// In practice we are calling some simple i/o and sprintf-type library functions
-// for logging messages, but use only our own LowLevelAlloc::Arena allocator.
-//
-// This is known to be buggy: the library i/o function calls are able to cause
-// deadlocks when they request a lock that a stopped thread happens to hold.
-// This issue as far as we know have so far not resulted in any deadlocks
-// in practice, so for now we are taking our chance that the deadlocks
-// have insignificant frequency.
-//
-// If such deadlocks become a problem we should make the i/o calls
-// into appropriately direct system calls (or eliminate them),
-// in particular write() is not safe and vsnprintf() is potentially dangerous
-// due to reliance on locale functions (these are called through RAW_LOG
-// and in other ways).
-//
-
-#if defined(HAVE_LINUX_PTRACE_H) && defined(HAVE_SYS_SYSCALL_H) && defined(DUMPER)
-# if (defined(__i386__) || defined(__x86_64))
-# define THREAD_REGS i386_regs
-# elif defined(__PPC__)
-# define THREAD_REGS ppc_regs
-# endif
-#endif
-
-/*static*/ int HeapLeakChecker::IgnoreLiveThreadsLocked(void* parameter,
- int num_threads,
- pid_t* thread_pids,
- va_list /*ap*/) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- thread_listing_status = CALLBACK_STARTED;
- RAW_VLOG(11, "Found %d threads (from pid %d)", num_threads, getpid());
-
- if (FLAGS_heap_check_ignore_global_live) {
- UseProcMapsLocked(RECORD_GLOBAL_DATA);
- }
-
- // We put the registers from other threads here
- // to make pointers stored in them live.
- vector<void*, STL_Allocator<void*, Allocator> > thread_registers;
-
- int failures = 0;
- for (int i = 0; i < num_threads; ++i) {
- // the leak checking thread itself is handled
- // specially via self_thread_stack, not here:
- if (thread_pids[i] == self_thread_pid) continue;
- RAW_VLOG(11, "Handling thread with pid %d", thread_pids[i]);
-#ifdef THREAD_REGS
- THREAD_REGS thread_regs;
-#define sys_ptrace(r, p, a, d) syscall(SYS_ptrace, (r), (p), (a), (d))
- // We use sys_ptrace to avoid thread locking
- // because this is called from TCMalloc_ListAllProcessThreads
- // when all but this thread are suspended.
- if (sys_ptrace(PTRACE_GETREGS, thread_pids[i], NULL, &thread_regs) == 0) {
- // Need to use SP to get all the data from the very last stack frame:
- COMPILE_ASSERT(sizeof(thread_regs.SP) == sizeof(void*),
- SP_register_does_not_look_like_a_pointer);
- RegisterStackLocked(reinterpret_cast<void*>(thread_regs.SP));
- // Make registers live (just in case PTRACE_ATTACH resulted in some
- // register pointers still being in the registers and not on the stack):
- for (void** p = reinterpret_cast<void**>(&thread_regs);
- p < reinterpret_cast<void**>(&thread_regs + 1); ++p) {
- RAW_VLOG(12, "Thread register %p", *p);
- thread_registers.push_back(*p);
- }
- } else {
- failures += 1;
- }
-#else
- failures += 1;
-#endif
- }
- // Use all the collected thread (stack) liveness sources:
- IgnoreLiveObjectsLocked("threads stack data", "");
- if (thread_registers.size()) {
- // Make thread registers be live heap data sources.
- // we rely here on the fact that vector is in one memory chunk:
- RAW_VLOG(11, "Live registers at %p of %" PRIuS " bytes",
- &thread_registers[0], thread_registers.size() * sizeof(void*));
- live_objects->push_back(AllocObject(&thread_registers[0],
- thread_registers.size() * sizeof(void*),
- THREAD_REGISTERS));
- IgnoreLiveObjectsLocked("threads register data", "");
- }
- // Do all other liveness walking while all threads are stopped:
- IgnoreNonThreadLiveObjectsLocked();
- // Can now resume the threads:
- TCMalloc_ResumeAllProcessThreads(num_threads, thread_pids);
- thread_listing_status = CALLBACK_COMPLETED;
- return failures;
-}
-
-// Stack top of the thread that is doing the current leak check
-// (protected by our lock; IgnoreAllLiveObjectsLocked sets it)
-static const void* self_thread_stack_top;
-
-// static
-void HeapLeakChecker::IgnoreNonThreadLiveObjectsLocked() {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- RAW_DCHECK(MemoryRegionMap::LockIsHeld(), "");
- RAW_VLOG(11, "Handling self thread with pid %d", self_thread_pid);
- // Register our own stack:
-
- // Important that all stack ranges (including the one here)
- // are known before we start looking at them
- // in MakeDisabledLiveCallbackLocked:
- RegisterStackLocked(self_thread_stack_top);
- IgnoreLiveObjectsLocked("stack data", "");
-
- // Make objects we were told to ignore live:
- if (ignored_objects) {
- for (IgnoredObjectsMap::const_iterator object = ignored_objects->begin();
- object != ignored_objects->end(); ++object) {
- const void* ptr = AsPtr(object->first);
- RAW_VLOG(11, "Ignored live object at %p of %" PRIuS " bytes",
- ptr, object->second);
- live_objects->
- push_back(AllocObject(ptr, object->second, MUST_BE_ON_HEAP));
- // we do this liveness check for ignored_objects before doing any
- // live heap walking to make sure it does not fail needlessly:
- size_t object_size;
- if (!(heap_profile->FindAlloc(ptr, &object_size) &&
- object->second == object_size)) {
- RAW_LOG(FATAL, "Object at %p of %" PRIuS " bytes from an"
- " IgnoreObject() has disappeared", ptr, object->second);
- }
- }
- IgnoreLiveObjectsLocked("ignored objects", "");
- }
-
- // Treat objects that were allocated when a Disabler was live as
- // roots. I.e., if X was allocated while a Disabler was active,
- // and Y is reachable from X, arrange that neither X nor Y are
- // treated as leaks.
- heap_profile->IterateAllocs(MakeIgnoredObjectsLiveCallbackLocked);
- IgnoreLiveObjectsLocked("disabled objects", "");
-
- // Make code-address-disabled objects live and ignored:
- // This in particular makes all thread-specific data live
- // because the basic data structure to hold pointers to thread-specific data
- // is allocated from libpthreads and we have range-disabled that
- // library code with UseProcMapsLocked(DISABLE_LIBRARY_ALLOCS);
- // so now we declare all thread-specific data reachable from there as live.
- heap_profile->IterateAllocs(MakeDisabledLiveCallbackLocked);
- IgnoreLiveObjectsLocked("disabled code", "");
-
- // Actually make global data live:
- if (FLAGS_heap_check_ignore_global_live) {
- bool have_null_region_callers = false;
- for (LibraryLiveObjectsStacks::iterator l = library_live_objects->begin();
- l != library_live_objects->end(); ++l) {
- RAW_CHECK(live_objects->empty(), "");
- // Process library_live_objects in l->second
- // filtering them by MemoryRegionMap:
- // It's safe to iterate over MemoryRegionMap
- // w/o locks here as we are inside MemoryRegionMap::Lock():
- RAW_DCHECK(MemoryRegionMap::LockIsHeld(), "");
- // The only change to MemoryRegionMap possible in this loop
- // is region addition as a result of allocating more memory
- // for live_objects. This won't invalidate the RegionIterator
- // or the intent of the loop.
- // --see the comment by MemoryRegionMap::BeginRegionLocked().
- for (MemoryRegionMap::RegionIterator region =
- MemoryRegionMap::BeginRegionLocked();
- region != MemoryRegionMap::EndRegionLocked(); ++region) {
- // "region" from MemoryRegionMap is to be subtracted from
- // (tentatively live) regions in l->second
- // if it has a stack inside or it was allocated by
- // a non-special caller (not one covered by a range
- // in global_region_caller_ranges).
- // This will in particular exclude all memory chunks used
- // by the heap itself as well as what's been allocated with
- // any allocator on top of mmap.
- bool subtract = true;
- if (!region->is_stack && global_region_caller_ranges) {
- if (region->caller() == static_cast<uintptr_t>(NULL)) {
- have_null_region_callers = true;
- } else {
- GlobalRegionCallerRangeMap::const_iterator iter
- = global_region_caller_ranges->upper_bound(region->caller());
- if (iter != global_region_caller_ranges->end()) {
- RAW_DCHECK(iter->first > region->caller(), "");
- if (iter->second < region->caller()) { // in special region
- subtract = false;
- }
- }
- }
- }
- if (subtract) {
- // The loop puts the result of filtering l->second into live_objects:
- for (LiveObjectsStack::const_iterator i = l->second.begin();
- i != l->second.end(); ++i) {
- // subtract *region from *i
- uintptr_t start = AsInt(i->ptr);
- uintptr_t end = start + i->size;
- if (region->start_addr <= start && end <= region->end_addr) {
- // full deletion due to subsumption
- } else if (start < region->start_addr &&
- region->end_addr < end) { // cutting-out split
- live_objects->push_back(AllocObject(i->ptr,
- region->start_addr - start,
- IN_GLOBAL_DATA));
- live_objects->push_back(AllocObject(AsPtr(region->end_addr),
- end - region->end_addr,
- IN_GLOBAL_DATA));
- } else if (region->end_addr > start &&
- region->start_addr <= start) { // cut from start
- live_objects->push_back(AllocObject(AsPtr(region->end_addr),
- end - region->end_addr,
- IN_GLOBAL_DATA));
- } else if (region->start_addr > start &&
- region->start_addr < end) { // cut from end
- live_objects->push_back(AllocObject(i->ptr,
- region->start_addr - start,
- IN_GLOBAL_DATA));
- } else { // pass: no intersection
- live_objects->push_back(AllocObject(i->ptr, i->size,
- IN_GLOBAL_DATA));
- }
- }
- // Move live_objects back into l->second
- // for filtering by the next region.
- live_objects->swap(l->second);
- live_objects->clear();
- }
- }
- // Now get and use live_objects from the final version of l->second:
- if (VLOG_IS_ON(11)) {
- for (LiveObjectsStack::const_iterator i = l->second.begin();
- i != l->second.end(); ++i) {
- RAW_VLOG(11, "Library live region at %p of %" PRIuPTR " bytes",
- i->ptr, i->size);
- }
- }
- live_objects->swap(l->second);
- IgnoreLiveObjectsLocked("in globals of\n ", l->first.c_str());
- }
- if (have_null_region_callers) {
- RAW_LOG(ERROR, "Have memory regions w/o callers: "
- "might report false leaks");
- }
- Allocator::DeleteAndNull(&library_live_objects);
- }
-}
-
-// Callback for TCMalloc_ListAllProcessThreads in IgnoreAllLiveObjectsLocked below
-// to test/verify that we have just the one main thread, in which case
-// we can do everything in that main thread,
-// so that CPU profiler can collect all its samples.
-// Returns the number of threads in the process.
-static int IsOneThread(void* parameter, int num_threads,
- pid_t* thread_pids, va_list ap) {
- if (num_threads != 1) {
- RAW_LOG(WARNING, "Have threads: Won't CPU-profile the bulk of leak "
- "checking work happening in IgnoreLiveThreadsLocked!");
- }
- TCMalloc_ResumeAllProcessThreads(num_threads, thread_pids);
- return num_threads;
-}
-
-// Dummy for IgnoreAllLiveObjectsLocked below.
-// Making it global helps with compiler warnings.
-static va_list dummy_ap;
-
-// static
-void HeapLeakChecker::IgnoreAllLiveObjectsLocked(const void* self_stack_top) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- RAW_CHECK(live_objects == NULL, "");
- live_objects = new(Allocator::Allocate(sizeof(LiveObjectsStack)))
- LiveObjectsStack;
- stack_tops = new(Allocator::Allocate(sizeof(StackTopSet))) StackTopSet;
- // reset the counts
- live_objects_total = 0;
- live_bytes_total = 0;
- // Reduce max_heap_object_size to FLAGS_heap_check_max_pointer_offset
- // for the time of leak check.
- // FLAGS_heap_check_max_pointer_offset caps max_heap_object_size
- // to manage reasonably low chances of random bytes
- // appearing to be pointing into large actually leaked heap objects.
- const size_t old_max_heap_object_size = max_heap_object_size;
- max_heap_object_size = (
- FLAGS_heap_check_max_pointer_offset != -1
- ? min(size_t(FLAGS_heap_check_max_pointer_offset), max_heap_object_size)
- : max_heap_object_size);
- // Record global data as live:
- if (FLAGS_heap_check_ignore_global_live) {
- library_live_objects =
- new(Allocator::Allocate(sizeof(LibraryLiveObjectsStacks)))
- LibraryLiveObjectsStacks;
- }
- // Ignore all thread stacks:
- thread_listing_status = CALLBACK_NOT_STARTED;
- bool need_to_ignore_non_thread_objects = true;
- self_thread_pid = getpid();
- self_thread_stack_top = self_stack_top;
- if (FLAGS_heap_check_ignore_thread_live) {
- // In case we are doing CPU profiling we'd like to do all the work
- // in the main thread, not in the special thread created by
- // TCMalloc_ListAllProcessThreads, so that CPU profiler can
- // collect all its samples. The machinery of
- // TCMalloc_ListAllProcessThreads conflicts with the CPU profiler
- // by also relying on signals and ::sigaction. We can do this
- // (run everything in the main thread) safely only if there's just
- // the main thread itself in our process. This variable reflects
- // these two conditions:
- bool want_and_can_run_in_main_thread =
- ProfilingIsEnabledForAllThreads() &&
- TCMalloc_ListAllProcessThreads(NULL, IsOneThread) == 1;
- // When the normal path of TCMalloc_ListAllProcessThreads below is taken,
- // we fully suspend the threads right here before any liveness checking
- // and keep them suspended for the whole time of liveness checking
- // inside of the IgnoreLiveThreadsLocked callback.
- // (The threads can't (de)allocate due to lock on the delete hook but
- // if not suspended they could still mess with the pointer
- // graph while we walk it).
- int r = want_and_can_run_in_main_thread
- ? IgnoreLiveThreadsLocked(NULL, 1, &self_thread_pid, dummy_ap)
- : TCMalloc_ListAllProcessThreads(NULL, IgnoreLiveThreadsLocked);
- need_to_ignore_non_thread_objects = r < 0;
- if (r < 0) {
- RAW_LOG(WARNING, "Thread finding failed with %d errno=%d", r, errno);
- if (thread_listing_status == CALLBACK_COMPLETED) {
- RAW_LOG(INFO, "Thread finding callback "
- "finished ok; hopefully everything is fine");
- need_to_ignore_non_thread_objects = false;
- } else if (thread_listing_status == CALLBACK_STARTED) {
- RAW_LOG(FATAL, "Thread finding callback was "
- "interrupted or crashed; can't fix this");
- } else { // CALLBACK_NOT_STARTED
- RAW_LOG(ERROR, "Could not find thread stacks. "
- "Will likely report false leak positives.");
- }
- } else if (r != 0) {
- RAW_LOG(ERROR, "Thread stacks not found for %d threads. "
- "Will likely report false leak positives.", r);
- } else {
- RAW_VLOG(11, "Thread stacks appear to be found for all threads");
- }
- } else {
- RAW_LOG(WARNING, "Not looking for thread stacks; "
- "objects reachable only from there "
- "will be reported as leaks");
- }
- // Do all other live data ignoring here if we did not do it
- // within thread listing callback with all threads stopped.
- if (need_to_ignore_non_thread_objects) {
- if (FLAGS_heap_check_ignore_global_live) {
- UseProcMapsLocked(RECORD_GLOBAL_DATA);
- }
- IgnoreNonThreadLiveObjectsLocked();
- }
- if (live_objects_total) {
- RAW_VLOG(10, "Ignoring %" PRId64 " reachable objects of %" PRId64 " bytes",
- live_objects_total, live_bytes_total);
- }
- // Free these: we made them here and heap_profile never saw them
- Allocator::DeleteAndNull(&live_objects);
- Allocator::DeleteAndNull(&stack_tops);
- max_heap_object_size = old_max_heap_object_size; // reset this var
-}
-
-// Alignment at which we should consider pointer positions
-// in IgnoreLiveObjectsLocked. Will normally use the value of
-// FLAGS_heap_check_pointer_source_alignment.
-static size_t pointer_source_alignment = kPointerSourceAlignment;
-// Global lock for HeapLeakChecker::DoNoLeaks
-// to protect pointer_source_alignment.
-static SpinLock alignment_checker_lock(SpinLock::LINKER_INITIALIZED);
-
-// This function changes the live bits in the heap_profile-table's state:
-// we only record the live objects to be skipped.
-//
-// When checking if a byte sequence points to a heap object we use
-// HeapProfileTable::FindInsideAlloc to handle both pointers to
-// the start and inside of heap-allocated objects.
-// The "inside" case needs to be checked to support
-// at least the following relatively common cases:
-// - C++ arrays allocated with new FooClass[size] for classes
-// with destructors have their size recorded in a sizeof(int) field
-// before the place normal pointers point to.
-// - basic_string<>-s for e.g. the C++ library of gcc 3.4
-// have the meta-info in basic_string<...>::_Rep recorded
-// before the place normal pointers point to.
-// - Multiple-inherited objects have their pointers when cast to
-// different base classes pointing inside of the actually
-// allocated object.
-// - Sometimes reachability pointers point to member objects of heap objects,
-// and then those member objects point to the full heap object.
-// - Third party UnicodeString: it stores a 32-bit refcount
-// (in both 32-bit and 64-bit binaries) as the first uint32
-// in the allocated memory and a normal pointer points at
-// the second uint32 behind the refcount.
-// By finding these additional objects here
-// we slightly increase the chance to mistake random memory bytes
-// for a pointer and miss a leak in a particular run of a binary.
-//
-/*static*/ void HeapLeakChecker::IgnoreLiveObjectsLocked(const char* name,
- const char* name2) {
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- int64 live_object_count = 0;
- int64 live_byte_count = 0;
- while (!live_objects->empty()) {
- const char* object =
- reinterpret_cast<const char*>(live_objects->back().ptr);
- size_t size = live_objects->back().size;
- const ObjectPlacement place = live_objects->back().place;
- live_objects->pop_back();
- if (place == MUST_BE_ON_HEAP && heap_profile->MarkAsLive(object)) {
- live_object_count += 1;
- live_byte_count += size;
- }
- RAW_VLOG(13, "Looking for heap pointers in %p of %" PRIuS " bytes",
- object, size);
- const char* const whole_object = object;
- size_t const whole_size = size;
- // Try interpretting any byte sequence in object,size as a heap pointer:
- const size_t remainder = AsInt(object) % pointer_source_alignment;
- if (remainder) {
- object += pointer_source_alignment - remainder;
- if (size >= pointer_source_alignment - remainder) {
- size -= pointer_source_alignment - remainder;
- } else {
- size = 0;
- }
- }
- if (size < sizeof(void*)) continue;
-
-#ifdef NO_FRAME_POINTER
- // Frame pointer omission requires us to use libunwind, which uses direct
- // mmap and munmap system calls, and that needs special handling.
- if (name2 == kUnnamedProcSelfMapEntry) {
- static const uintptr_t page_mask = ~(getpagesize() - 1);
- const uintptr_t addr = reinterpret_cast<uintptr_t>(object);
- if ((addr & page_mask) == 0 && (size & page_mask) == 0) {
- // This is an object we slurped from /proc/self/maps.
- // It may or may not be readable at this point.
- //
- // In case all the above conditions made a mistake, and the object is
- // not related to libunwind, we also verify that it's not readable
- // before ignoring it.
- if (msync(const_cast<char*>(object), size, MS_ASYNC) != 0) {
- // Skip unreadable object, so we don't crash trying to sweep it.
- RAW_VLOG(0, "Ignoring inaccessible object [%p, %p) "
- "(msync error %d (%s))",
- object, object + size, errno, strerror(errno));
- continue;
- }
- }
- }
-#endif
-
- const char* const max_object = object + size - sizeof(void*);
- while (object <= max_object) {
- // potentially unaligned load:
- const uintptr_t addr = *reinterpret_cast<const uintptr_t*>(object);
- // Do fast check before the more expensive HaveOnHeapLocked lookup:
- // this code runs for all memory words that are potentially pointers:
- const bool can_be_on_heap =
- // Order tests by the likelyhood of the test failing in 64/32 bit modes.
- // Yes, this matters: we either lose 5..6% speed in 32 bit mode
- // (which is already slower) or by a factor of 1.5..1.91 in 64 bit mode.
- // After the alignment test got dropped the above performance figures
- // must have changed; might need to revisit this.
-#if defined(__x86_64__)
- addr <= max_heap_address && // <= is for 0-sized object with max addr
- min_heap_address <= addr;
-#else
- min_heap_address <= addr &&
- addr <= max_heap_address; // <= is for 0-sized object with max addr
-#endif
- if (can_be_on_heap) {
- const void* ptr = reinterpret_cast<const void*>(addr);
- // Too expensive (inner loop): manually uncomment when debugging:
- // RAW_VLOG(17, "Trying pointer to %p at %p", ptr, object);
- size_t object_size;
- if (HaveOnHeapLocked(&ptr, &object_size) &&
- heap_profile->MarkAsLive(ptr)) {
- // We take the (hopefully low) risk here of encountering by accident
- // a byte sequence in memory that matches an address of
- // a heap object which is in fact leaked.
- // I.e. in very rare and probably not repeatable/lasting cases
- // we might miss some real heap memory leaks.
- RAW_VLOG(14, "Found pointer to %p of %" PRIuS " bytes at %p "
- "inside %p of size %" PRIuS "",
- ptr, object_size, object, whole_object, whole_size);
- if (VLOG_IS_ON(15)) {
- // log call stacks to help debug how come something is not a leak
- HeapProfileTable::AllocInfo alloc;
- if (!heap_profile->FindAllocDetails(ptr, &alloc)) {
- RAW_LOG(FATAL, "FindAllocDetails failed on ptr %p", ptr);
- }
- RAW_LOG(INFO, "New live %p object's alloc stack:", ptr);
- for (int i = 0; i < alloc.stack_depth; ++i) {
- RAW_LOG(INFO, " @ %p", alloc.call_stack[i]);
- }
- }
- live_object_count += 1;
- live_byte_count += object_size;
- live_objects->push_back(AllocObject(ptr, object_size,
- IGNORED_ON_HEAP));
- }
- }
- object += pointer_source_alignment;
- }
- }
- live_objects_total += live_object_count;
- live_bytes_total += live_byte_count;
- if (live_object_count) {
- RAW_VLOG(10, "Removed %" PRId64 " live heap objects of %" PRId64 " bytes: %s%s",
- live_object_count, live_byte_count, name, name2);
- }
-}
-
-//----------------------------------------------------------------------
-// HeapLeakChecker leak check disabling components
-//----------------------------------------------------------------------
-
-// static
-void HeapLeakChecker::DisableChecksIn(const char* pattern) {
- RAW_LOG(WARNING, "DisableChecksIn(%s) is ignored", pattern);
-}
-
-// static
-void HeapLeakChecker::DoIgnoreObject(const void* ptr) {
- SpinLockHolder l(&heap_checker_lock);
- if (!heap_checker_on) return;
- size_t object_size;
- if (!HaveOnHeapLocked(&ptr, &object_size)) {
- RAW_LOG(ERROR, "No live heap object at %p to ignore", ptr);
- } else {
- RAW_VLOG(10, "Going to ignore live object at %p of %" PRIuS " bytes",
- ptr, object_size);
- if (ignored_objects == NULL) {
- ignored_objects = new(Allocator::Allocate(sizeof(IgnoredObjectsMap)))
- IgnoredObjectsMap;
- }
- if (!ignored_objects->insert(make_pair(AsInt(ptr), object_size)).second) {
- RAW_LOG(WARNING, "Object at %p is already being ignored", ptr);
- }
- }
-}
-
-// static
-void HeapLeakChecker::UnIgnoreObject(const void* ptr) {
- SpinLockHolder l(&heap_checker_lock);
- if (!heap_checker_on) return;
- size_t object_size;
- if (!HaveOnHeapLocked(&ptr, &object_size)) {
- RAW_LOG(FATAL, "No live heap object at %p to un-ignore", ptr);
- } else {
- bool found = false;
- if (ignored_objects) {
- IgnoredObjectsMap::iterator object = ignored_objects->find(AsInt(ptr));
- if (object != ignored_objects->end() && object_size == object->second) {
- ignored_objects->erase(object);
- found = true;
- RAW_VLOG(10, "Now not going to ignore live object "
- "at %p of %" PRIuS " bytes", ptr, object_size);
- }
- }
- if (!found) RAW_LOG(FATAL, "Object at %p has not been ignored", ptr);
- }
-}
-
-//----------------------------------------------------------------------
-// HeapLeakChecker non-static functions
-//----------------------------------------------------------------------
-
-char* HeapLeakChecker::MakeProfileNameLocked() {
- RAW_DCHECK(lock_->IsHeld(), "");
- RAW_DCHECK(heap_checker_lock.IsHeld(), "");
- const int len = profile_name_prefix->size() + strlen(name_) + 5 +
- strlen(HeapProfileTable::kFileExt) + 1;
- char* file_name = reinterpret_cast<char*>(Allocator::Allocate(len));
- snprintf(file_name, len, "%s.%s-end%s",
- profile_name_prefix->c_str(), name_,
- HeapProfileTable::kFileExt);
- return file_name;
-}
-
-void HeapLeakChecker::Create(const char *name, bool make_start_snapshot) {
- SpinLockHolder l(lock_);
- name_ = NULL; // checker is inactive
- start_snapshot_ = NULL;
- has_checked_ = false;
- inuse_bytes_increase_ = 0;
- inuse_allocs_increase_ = 0;
- keep_profiles_ = false;
- char* n = new char[strlen(name) + 1]; // do this before we lock
- IgnoreObject(n); // otherwise it might be treated as live due to our stack
- { // Heap activity in other threads is paused for this whole scope.
- SpinLockHolder al(&alignment_checker_lock);
- SpinLockHolder hl(&heap_checker_lock);
- MemoryRegionMap::LockHolder ml;
- if (heap_checker_on && profile_name_prefix != NULL) {
- RAW_DCHECK(strchr(name, '/') == NULL, "must be a simple name");
- memcpy(n, name, strlen(name) + 1);
- name_ = n; // checker is active
- if (make_start_snapshot) {
- start_snapshot_ = heap_profile->TakeSnapshot();
- }
-
- const HeapProfileTable::Stats& t = heap_profile->total();
- const size_t start_inuse_bytes = t.alloc_size - t.free_size;
- const size_t start_inuse_allocs = t.allocs - t.frees;
- RAW_VLOG(10, "Start check \"%s\" profile: %" PRIuS " bytes "
- "in %" PRIuS " objects",
- name_, start_inuse_bytes, start_inuse_allocs);
- } else {
- RAW_LOG(WARNING, "Heap checker is not active, "
- "hence checker \"%s\" will do nothing!", name);
- RAW_LOG(WARNING, "To activate set the HEAPCHECK environment variable.\n");
- }
- }
- if (name_ == NULL) {
- UnIgnoreObject(n);
- delete[] n; // must be done after we unlock
- }
-}
-
-HeapLeakChecker::HeapLeakChecker(const char *name) : lock_(new SpinLock) {
- RAW_DCHECK(strcmp(name, "_main_") != 0, "_main_ is reserved");
- Create(name, true/*create start_snapshot_*/);
-}
-
-HeapLeakChecker::HeapLeakChecker() : lock_(new SpinLock) {
- if (FLAGS_heap_check_before_constructors) {
- // We want to check for leaks of objects allocated during global
- // constructors (i.e., objects allocated already). So we do not
- // create a baseline snapshot and hence check for leaks of objects
- // that may have already been created.
- Create("_main_", false);
- } else {
- // We want to ignore leaks of objects allocated during global
- // constructors (i.e., objects allocated already). So we snapshot
- // the current heap contents and use them as a baseline that is
- // not reported by the leak checker.
- Create("_main_", true);
- }
-}
-
-ssize_t HeapLeakChecker::BytesLeaked() const {
- SpinLockHolder l(lock_);
- if (!has_checked_) {
- RAW_LOG(FATAL, "*NoLeaks|SameHeap must execute before this call");
- }
- return inuse_bytes_increase_;
-}
-
-ssize_t HeapLeakChecker::ObjectsLeaked() const {
- SpinLockHolder l(lock_);
- if (!has_checked_) {
- RAW_LOG(FATAL, "*NoLeaks|SameHeap must execute before this call");
- }
- return inuse_allocs_increase_;
-}
-
-// Save pid of main thread for using in naming dump files
-static int32 main_thread_pid = getpid();
-#ifdef HAVE_PROGRAM_INVOCATION_NAME
-#ifdef __UCLIBC__
-extern const char* program_invocation_name;
-extern const char* program_invocation_short_name;
-#else
-extern char* program_invocation_name;
-extern char* program_invocation_short_name;
-#endif
-static const char* invocation_name() { return program_invocation_short_name; }
-static string invocation_path() { return program_invocation_name; }
-#else
-static const char* invocation_name() { return "<your binary>"; }
-static string invocation_path() { return "<your binary>"; }
-#endif
-
-// Prints commands that users can run to get more information
-// about the reported leaks.
-static void SuggestPprofCommand(const char* pprof_file_arg) {
- // Extra help information to print for the user when the test is
- // being run in a way where the straightforward pprof command will
- // not suffice.
- string extra_help;
-
- // Common header info to print for remote runs
- const string remote_header =
- "This program is being executed remotely and therefore the pprof\n"
- "command printed above will not work. Either run this program\n"
- "locally, or adjust the pprof command as follows to allow it to\n"
- "work on your local machine:\n";
-
- // Extra command for fetching remote data
- string fetch_cmd;
-
- RAW_LOG(WARNING,
- "\n\n"
- "If the preceding stack traces are not enough to find "
- "the leaks, try running THIS shell command:\n\n"
- "%s%s %s \"%s\" --inuse_objects --lines --heapcheck "
- " --edgefraction=1e-10 --nodefraction=1e-10 --gv\n"
- "\n"
- "%s"
- "If you are still puzzled about why the leaks are "
- "there, try rerunning this program with "
- "HEAP_CHECK_TEST_POINTER_ALIGNMENT=1 and/or with "
- "HEAP_CHECK_MAX_POINTER_OFFSET=-1\n"
- "If the leak report occurs in a small fraction of runs, "
- "try running with TCMALLOC_MAX_FREE_QUEUE_SIZE of few hundred MB "
- "or with TCMALLOC_RECLAIM_MEMORY=false, " // only works for debugalloc
- "it might help find leaks more repeatably\n",
- fetch_cmd.c_str(),
- "pprof", // works as long as pprof is on your path
- invocation_path().c_str(),
- pprof_file_arg,
- extra_help.c_str()
- );
-}
-
-bool HeapLeakChecker::DoNoLeaks(ShouldSymbolize should_symbolize) {
- SpinLockHolder l(lock_);
- // The locking also helps us keep the messages
- // for the two checks close together.
- SpinLockHolder al(&alignment_checker_lock);
-
- // thread-safe: protected by alignment_checker_lock
- static bool have_disabled_hooks_for_symbolize = false;
- // Once we've checked for leaks and symbolized the results once, it's
- // not safe to do it again. This is because in order to symbolize
- // safely, we had to disable all the malloc hooks here, so we no
- // longer can be confident we've collected all the data we need.
- if (have_disabled_hooks_for_symbolize) {
- RAW_LOG(FATAL, "Must not call heap leak checker manually after "
- " program-exit's automatic check.");
- }
-
- HeapProfileTable::Snapshot* leaks = NULL;
- char* pprof_file = NULL;
-
- {
- // Heap activity in other threads is paused during this function
- // (i.e. until we got all profile difference info).
- SpinLockHolder hl(&heap_checker_lock);
- if (heap_checker_on == false) {
- if (name_ != NULL) { // leak checking enabled when created the checker
- RAW_LOG(WARNING, "Heap leak checker got turned off after checker "
- "\"%s\" has been created, no leak check is being done for it!",
- name_);
- }
- return true;
- }
-
- // Update global_region_caller_ranges. They may need to change since
- // e.g. initialization because shared libraries might have been loaded or
- // unloaded.
- Allocator::DeleteAndNullIfNot(&global_region_caller_ranges);
- ProcMapsResult pm_result = UseProcMapsLocked(DISABLE_LIBRARY_ALLOCS);
- RAW_CHECK(pm_result == PROC_MAPS_USED, "");
-
- // Keep track of number of internally allocated objects so we
- // can detect leaks in the heap-leak-checket itself
- const int initial_allocs = Allocator::alloc_count();
-
- if (name_ == NULL) {
- RAW_LOG(FATAL, "Heap leak checker must not be turned on "
- "after construction of a HeapLeakChecker");
- }
-
- MemoryRegionMap::LockHolder ml;
- int a_local_var; // Use our stack ptr to make stack data live:
-
- // Make the heap profile, other threads are locked out.
- HeapProfileTable::Snapshot* base =
- reinterpret_cast<HeapProfileTable::Snapshot*>(start_snapshot_);
- RAW_DCHECK(FLAGS_heap_check_pointer_source_alignment > 0, "");
- pointer_source_alignment = FLAGS_heap_check_pointer_source_alignment;
- IgnoreAllLiveObjectsLocked(&a_local_var);
- leaks = heap_profile->NonLiveSnapshot(base);
-
- inuse_bytes_increase_ = static_cast<ssize_t>(leaks->total().alloc_size);
- inuse_allocs_increase_ = static_cast<ssize_t>(leaks->total().allocs);
- if (leaks->Empty()) {
- heap_profile->ReleaseSnapshot(leaks);
- leaks = NULL;
-
- // We can only check for internal leaks along the no-user-leak
- // path since in the leak path we temporarily release
- // heap_checker_lock and another thread can come in and disturb
- // allocation counts.
- if (Allocator::alloc_count() != initial_allocs) {
- RAW_LOG(FATAL, "Internal HeapChecker leak of %d objects ; %d -> %d",
- Allocator::alloc_count() - initial_allocs,
- initial_allocs, Allocator::alloc_count());
- }
- } else if (FLAGS_heap_check_test_pointer_alignment) {
- if (pointer_source_alignment == 1) {
- RAW_LOG(WARNING, "--heap_check_test_pointer_alignment has no effect: "
- "--heap_check_pointer_source_alignment was already set to 1");
- } else {
- // Try with reduced pointer aligment
- pointer_source_alignment = 1;
- IgnoreAllLiveObjectsLocked(&a_local_var);
- HeapProfileTable::Snapshot* leaks_wo_align =
- heap_profile->NonLiveSnapshot(base);
- pointer_source_alignment = FLAGS_heap_check_pointer_source_alignment;
- if (leaks_wo_align->Empty()) {
- RAW_LOG(WARNING, "Found no leaks without pointer alignment: "
- "something might be placing pointers at "
- "unaligned addresses! This needs to be fixed.");
- } else {
- RAW_LOG(INFO, "Found leaks without pointer alignment as well: "
- "unaligned pointers must not be the cause of leaks.");
- RAW_LOG(INFO, "--heap_check_test_pointer_alignment did not help "
- "to diagnose the leaks.");
- }
- heap_profile->ReleaseSnapshot(leaks_wo_align);
- }
- }
-
- if (leaks != NULL) {
- pprof_file = MakeProfileNameLocked();
- }
- }
-
- has_checked_ = true;
- if (leaks == NULL) {
- if (FLAGS_heap_check_max_pointer_offset == -1) {
- RAW_LOG(WARNING,
- "Found no leaks without max_pointer_offset restriction: "
- "it's possible that the default value of "
- "heap_check_max_pointer_offset flag is too low. "
- "Do you use pointers with larger than that offsets "
- "pointing in the middle of heap-allocated objects?");
- }
- const HeapProfileTable::Stats& stats = heap_profile->total();
- RAW_VLOG(heap_checker_info_level,
- "No leaks found for check \"%s\" "
- "(but no 100%% guarantee that there aren't any): "
- "found %" PRId64 " reachable heap objects of %" PRId64 " bytes",
- name_,
- int64(stats.allocs - stats.frees),
- int64(stats.alloc_size - stats.free_size));
- } else {
- if (should_symbolize == SYMBOLIZE) {
- // To turn addresses into symbols, we need to fork, which is a
- // problem if both parent and child end up trying to call the
- // same malloc-hooks we've set up, at the same time. To avoid
- // trouble, we turn off the hooks before symbolizing. Note that
- // this makes it unsafe to ever leak-report again! Luckily, we
- // typically only want to report once in a program's run, at the
- // very end.
- if (MallocHook::GetNewHook() == NewHook)
- MallocHook::SetNewHook(NULL);
- if (MallocHook::GetDeleteHook() == DeleteHook)
- MallocHook::SetDeleteHook(NULL);
- MemoryRegionMap::Shutdown();
- // Make sure all the hooks really got unset:
- RAW_CHECK(MallocHook::GetNewHook() == NULL, "");
- RAW_CHECK(MallocHook::GetDeleteHook() == NULL, "");
- RAW_CHECK(MallocHook::GetMmapHook() == NULL, "");
- RAW_CHECK(MallocHook::GetSbrkHook() == NULL, "");
- have_disabled_hooks_for_symbolize = true;
- leaks->ReportLeaks(name_, pprof_file, true); // true = should_symbolize
- } else {
- leaks->ReportLeaks(name_, pprof_file, false);
- }
- if (FLAGS_heap_check_identify_leaks) {
- leaks->ReportIndividualObjects();
- }
-
- SuggestPprofCommand(pprof_file);
-
- {
- SpinLockHolder hl(&heap_checker_lock);
- heap_profile->ReleaseSnapshot(leaks);
- Allocator::Free(pprof_file);
- }
- }
-
- return (leaks == NULL);
-}
-
-HeapLeakChecker::~HeapLeakChecker() {
- if (name_ != NULL) { // had leak checking enabled when created the checker
- if (!has_checked_) {
- RAW_LOG(FATAL, "Some *NoLeaks|SameHeap method"
- " must be called on any created HeapLeakChecker");
- }
-
- // Deallocate any snapshot taken at start
- if (start_snapshot_ != NULL) {
- SpinLockHolder l(&heap_checker_lock);
- heap_profile->ReleaseSnapshot(
- reinterpret_cast<HeapProfileTable::Snapshot*>(start_snapshot_));
- }
-
- UnIgnoreObject(name_);
- delete[] name_;
- name_ = NULL;
- }
- delete lock_;
-}
-
-//----------------------------------------------------------------------
-// HeapLeakChecker overall heap check components
-//----------------------------------------------------------------------
-
-// static
-bool HeapLeakChecker::IsActive() {
- SpinLockHolder l(&heap_checker_lock);
- return heap_checker_on;
-}
-
-vector<HeapCleaner::void_function>* HeapCleaner::heap_cleanups_ = NULL;
-
-// When a HeapCleaner object is intialized, add its function to the static list
-// of cleaners to be run before leaks checking.
-HeapCleaner::HeapCleaner(void_function f) {
- if (heap_cleanups_ == NULL)
- heap_cleanups_ = new vector<HeapCleaner::void_function>;
- heap_cleanups_->push_back(f);
-}
-
-// Run all of the cleanup functions and delete the vector.
-void HeapCleaner::RunHeapCleanups() {
- if (!heap_cleanups_)
- return;
- for (int i = 0; i < heap_cleanups_->size(); i++) {
- void (*f)(void) = (*heap_cleanups_)[i];
- f();
- }
- delete heap_cleanups_;
- heap_cleanups_ = NULL;
-}
-
-// Program exit heap cleanup registered as a module object destructor.
-// Will not get executed when we crash on a signal.
-//
-void HeapLeakChecker_RunHeapCleanups() {
- if (FLAGS_heap_check == "local") // don't check heap in this mode
- return;
- { SpinLockHolder l(&heap_checker_lock);
- // can get here (via forks?) with other pids
- if (heap_checker_pid != getpid()) return;
- }
- HeapCleaner::RunHeapCleanups();
- if (!FLAGS_heap_check_after_destructors) HeapLeakChecker::DoMainHeapCheck();
-}
-
-static bool internal_init_start_has_run = false;
-
-// Called exactly once, before main() (but hopefully just before).
-// This picks a good unique name for the dumped leak checking heap profiles.
-//
-// Because we crash when InternalInitStart is called more than once,
-// it's fine that we hold heap_checker_lock only around pieces of
-// this function: this is still enough for thread-safety w.r.t. other functions
-// of this module.
-// We can't hold heap_checker_lock throughout because it would deadlock
-// on a memory allocation since our new/delete hooks can be on.
-//
-void HeapLeakChecker_InternalInitStart() {
- { SpinLockHolder l(&heap_checker_lock);
- RAW_CHECK(!internal_init_start_has_run,
- "Heap-check constructor called twice. Perhaps you both linked"
- " in the heap checker, and also used LD_PRELOAD to load it?");
- internal_init_start_has_run = true;
-
-#ifdef ADDRESS_SANITIZER
- // AddressSanitizer's custom malloc conflicts with HeapChecker.
- FLAGS_heap_check = "";
-#endif
-
- if (FLAGS_heap_check.empty()) {
- // turns out we do not need checking in the end; can stop profiling
- HeapLeakChecker::TurnItselfOffLocked();
- return;
- } else if (RunningOnValgrind()) {
- // There is no point in trying -- we'll just fail.
- RAW_LOG(WARNING, "Can't run under Valgrind; will turn itself off");
- HeapLeakChecker::TurnItselfOffLocked();
- return;
- }
- }
-
- // Changing this to false can be useful when debugging heap-checker itself:
- if (!FLAGS_heap_check_run_under_gdb && IsDebuggerAttached()) {
- RAW_LOG(WARNING, "Someone is ptrace()ing us; will turn itself off");
- SpinLockHolder l(&heap_checker_lock);
- HeapLeakChecker::TurnItselfOffLocked();
- return;
- }
-
- { SpinLockHolder l(&heap_checker_lock);
- if (!constructor_heap_profiling) {
- RAW_LOG(FATAL, "Can not start so late. You have to enable heap checking "
- "with HEAPCHECK=<mode>.");
- }
- }
-
- // Set all flags
- RAW_DCHECK(FLAGS_heap_check_pointer_source_alignment > 0, "");
- if (FLAGS_heap_check == "minimal") {
- // The least we can check.
- FLAGS_heap_check_before_constructors = false; // from after main
- // (ignore more)
- FLAGS_heap_check_after_destructors = false; // to after cleanup
- // (most data is live)
- FLAGS_heap_check_ignore_thread_live = true; // ignore all live
- FLAGS_heap_check_ignore_global_live = true; // ignore all live
- } else if (FLAGS_heap_check == "normal") {
- // Faster than 'minimal' and not much stricter.
- FLAGS_heap_check_before_constructors = true; // from no profile (fast)
- FLAGS_heap_check_after_destructors = false; // to after cleanup
- // (most data is live)
- FLAGS_heap_check_ignore_thread_live = true; // ignore all live
- FLAGS_heap_check_ignore_global_live = true; // ignore all live
- } else if (FLAGS_heap_check == "strict") {
- // A bit stricter than 'normal': global destructors must fully clean up
- // after themselves if they are present.
- FLAGS_heap_check_before_constructors = true; // from no profile (fast)
- FLAGS_heap_check_after_destructors = true; // to after destructors
- // (less data live)
- FLAGS_heap_check_ignore_thread_live = true; // ignore all live
- FLAGS_heap_check_ignore_global_live = true; // ignore all live
- } else if (FLAGS_heap_check == "draconian") {
- // Drop not very portable and not very exact live heap flooding.
- FLAGS_heap_check_before_constructors = true; // from no profile (fast)
- FLAGS_heap_check_after_destructors = true; // to after destructors
- // (need them)
- FLAGS_heap_check_ignore_thread_live = false; // no live flood (stricter)
- FLAGS_heap_check_ignore_global_live = false; // no live flood (stricter)
- } else if (FLAGS_heap_check == "as-is") {
- // do nothing: use other flags as is
- } else if (FLAGS_heap_check == "local") {
- // do nothing
- } else {
- RAW_LOG(FATAL, "Unsupported heap_check flag: %s",
- FLAGS_heap_check.c_str());
- }
- // FreeBSD doesn't seem to honor atexit execution order:
- // http://code.google.com/p/gperftools/issues/detail?id=375
- // Since heap-checking before destructors depends on atexit running
- // at the right time, on FreeBSD we always check after, even in the
- // less strict modes. This just means FreeBSD is always a bit
- // stricter in its checking than other OSes.
- // This now appears to be the case in other OSes as well;
- // so always check afterwards.
- FLAGS_heap_check_after_destructors = true;
-
- { SpinLockHolder l(&heap_checker_lock);
- RAW_DCHECK(heap_checker_pid == getpid(), "");
- heap_checker_on = true;
- RAW_DCHECK(heap_profile, "");
- HeapLeakChecker::ProcMapsResult pm_result = HeapLeakChecker::UseProcMapsLocked(HeapLeakChecker::DISABLE_LIBRARY_ALLOCS);
- // might neeed to do this more than once
- // if one later dynamically loads libraries that we want disabled
- if (pm_result != HeapLeakChecker::PROC_MAPS_USED) { // can't function
- HeapLeakChecker::TurnItselfOffLocked();
- return;
- }
- }
-
- // make a good place and name for heap profile leak dumps
- string* profile_prefix =
- new string(FLAGS_heap_check_dump_directory + "/" + invocation_name());
-
- // Finalize prefix for dumping leak checking profiles.
- const int32 our_pid = getpid(); // safest to call getpid() outside lock
-
<TRUNCATED>