Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/heap-profiler.cc

 // 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
@@ skipping 15 matching lines @@
 // 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.
 
 // ---
 // Author: Sanjay Ghemawat
 //
 // TODO: Log large allocations
 
 #include <config.h>
-
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
 #ifdef HAVE_FCNTL_H
 #include <fcntl.h>    // for open()
@@ skipping 128 matching lines @@
 // Profile generation
 //----------------------------------------------------------------------
 
 enum AddOrRemove { ADD, REMOVE };
 
 // Add or remove all MMap-allocated regions to/from *heap_profile.
 // Assumes heap_lock is held.
 static void AddRemoveMMapDataLocked(AddOrRemove mode) {
   RAW_DCHECK(heap_lock.IsHeld(), "");
   if (!FLAGS_mmap_profile || !is_on) return;
-  if (!FLAGS_mmap_log) MemoryRegionMap::CheckMallocHooks();
   // MemoryRegionMap maintained all the data we need for all
   // mmap-like allocations, so we just use it here:
   MemoryRegionMap::LockHolder l;
   for (MemoryRegionMap::RegionIterator r = MemoryRegionMap::BeginRegionLocked();
        r != MemoryRegionMap::EndRegionLocked(); ++r) {
     if (mode == ADD) {
       heap_profile->RecordAllocWithStack(
         reinterpret_cast<const void*>(r->start_addr),
         r->end_addr - r->start_addr,
         r->call_stack_depth, r->call_stack);
     } else {
       heap_profile->RecordFree(reinterpret_cast<void*>(r->start_addr));
     }
   }
 }
 
 // Input must be a buffer of size at least 1MB.
 static char* DoGetHeapProfileLocked(char* buf, int buflen) {
   // We used to be smarter about estimating the required memory and
   // then capping it to 1MB and generating the profile into that.
   if (buf == NULL || buflen < 1)
     return NULL;
 
   RAW_DCHECK(heap_lock.IsHeld(), "");
   int bytes_written = 0;
   if (is_on) {
     HeapProfileTable::Stats const stats = heap_profile->total();
+    (void)stats;   // avoid an unused-variable warning in non-debug mode.
     AddRemoveMMapDataLocked(ADD);
     bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
     // FillOrderedProfile should not reduce the set of active mmap-ed regions,
     // hence MemoryRegionMap will let us remove everything we've added above:
     AddRemoveMMapDataLocked(REMOVE);
     RAW_DCHECK(stats.Equivalent(heap_profile->total()), "");
     // if this fails, we somehow removed by AddRemoveMMapDataLocked
     // more than we have added.
   }
   buf[bytes_written] = '\0';
@@ skipping 14 matching lines @@
 static void DeleteHook(const void* ptr);
 
 // Helper for HeapProfilerDump.
 static void DumpProfileLocked(const char* reason) {
   RAW_DCHECK(heap_lock.IsHeld(), "");
   RAW_DCHECK(is_on, "");
   RAW_DCHECK(!dumping, "");
 
   if (filename_prefix == NULL) return;  // we do not yet need dumping
 
-  if (FLAGS_only_mmap_profile == false) {
-    if (MallocHook::GetNewHook() != NewHook  ||
-        MallocHook::GetDeleteHook() != DeleteHook) {
-      RAW_LOG(FATAL, "Had our new/delete MallocHook-s replaced. "
-                     "Are you using another MallocHook client? "
-                     "Do not use --heap_profile=... to avoid this conflict.");
-    }
-  }
-
   dumping = true;
 
   // Make file name
   char file_name[1000];
   dump_count++;
   snprintf(file_name, sizeof(file_name), "%s.%05d.%04d%s",
            filename_prefix, getpid(), dump_count, HeapProfileTable::kFileExt);
 
   // Dump the profile
   RAW_VLOG(0, "Dumping heap profile to %s (%s)", file_name, reason);
@@ skipping 98 matching lines @@
 }
 
 // TODO(jandrews): Re-enable stack tracing
 #ifdef TODO_REENABLE_STACK_TRACING
 static void RawInfoStackDumper(const char* message, void*) {
   RAW_LOG(INFO, "%.*s", static_cast<int>(strlen(message) - 1), message);
   // -1 is to chop the \n which will be added by RAW_LOG
 }
 #endif
 
-// Saved MemoryRegionMap's hooks to daisy-chain calls to.
-MallocHook::MmapHook saved_mmap_hook = NULL;
-MallocHook::MremapHook saved_mremap_hook = NULL;
-MallocHook::MunmapHook saved_munmap_hook = NULL;
-MallocHook::SbrkHook saved_sbrk_hook = NULL;
-
 static void MmapHook(const void* result, const void* start, size_t size,
                      int prot, int flags, int fd, off_t offset) {
   if (FLAGS_mmap_log) {  // log it
     // We use PRIxS not just '%p' to avoid deadlocks
     // in pretty-printing of NULL as "nil".
     // TODO(maxim): instead should use a safe snprintf reimplementation
     RAW_LOG(INFO,
             "mmap(start=0x%"PRIxPTR", len=%"PRIuS", prot=0x%x, flags=0x%x, "
             "fd=%d, offset=0x%x) = 0x%"PRIxPTR"",
             (uintptr_t) start, size, prot, flags, fd, (unsigned int) offset,
             (uintptr_t) result);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
-  if (saved_mmap_hook) {
-    // Call MemoryRegionMap's hook: it will record needed info about the mmap
-    // for us w/o deadlocks:
-    (*saved_mmap_hook)(result, start, size, prot, flags, fd, offset);
-  }
 }
 
 static void MremapHook(const void* result, const void* old_addr,
                        size_t old_size, size_t new_size,
                        int flags, const void* new_addr) {
   if (FLAGS_mmap_log) {  // log it
     // We use PRIxS not just '%p' to avoid deadlocks
     // in pretty-printing of NULL as "nil".
     // TODO(maxim): instead should use a safe snprintf reimplementation
     RAW_LOG(INFO,
             "mremap(old_addr=0x%"PRIxPTR", old_size=%"PRIuS", "
             "new_size=%"PRIuS", flags=0x%x, new_addr=0x%"PRIxPTR") = "
             "0x%"PRIxPTR"",
             (uintptr_t) old_addr, old_size, new_size, flags,
             (uintptr_t) new_addr, (uintptr_t) result);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
-  if (saved_mremap_hook) {  // call MemoryRegionMap's hook
-    (*saved_mremap_hook)(result, old_addr, old_size, new_size, flags, new_addr);
-  }
 }
 
 static void MunmapHook(const void* ptr, size_t size) {
   if (FLAGS_mmap_log) {  // log it
     // We use PRIxS not just '%p' to avoid deadlocks
     // in pretty-printing of NULL as "nil".
     // TODO(maxim): instead should use a safe snprintf reimplementation
     RAW_LOG(INFO, "munmap(start=0x%"PRIxPTR", len=%"PRIuS")",
                   (uintptr_t) ptr, size);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
-  if (saved_munmap_hook) {  // call MemoryRegionMap's hook
-    (*saved_munmap_hook)(ptr, size);
-  }
 }
 
 static void SbrkHook(const void* result, std::ptrdiff_t increment) {
   if (FLAGS_mmap_log) {  // log it
     RAW_LOG(INFO, "sbrk(inc=%"PRIdS") = 0x%"PRIxPTR"",
                   increment, (uintptr_t) result);
 #ifdef TODO_REENABLE_STACK_TRACING
     DumpStackTrace(1, RawInfoStackDumper, NULL);
 #endif
   }
-  if (saved_sbrk_hook) {  // call MemoryRegionMap's hook
-    (*saved_sbrk_hook)(result, increment);
-  }
 }
 
 //----------------------------------------------------------------------
 // Starting/stopping/dumping
 //----------------------------------------------------------------------
 
 extern "C" void HeapProfilerStart(const char* prefix) {
   SpinLockHolder l(&heap_lock);
 
   if (is_on) return;
@@ skipping 10 matching lines @@
     FLAGS_mmap_profile = true;
   }
 
   if (FLAGS_mmap_profile) {
     // Ask MemoryRegionMap to record all mmap, mremap, and sbrk
     // call stack traces of at least size kMaxStackDepth:
     MemoryRegionMap::Init(HeapProfileTable::kMaxStackDepth);
   }
 
   if (FLAGS_mmap_log) {
-    // Install our hooks to do the logging
-    // and maybe save MemoryRegionMap's hooks to call:
-    saved_mmap_hook = MallocHook::SetMmapHook(MmapHook);
-    saved_mremap_hook = MallocHook::SetMremapHook(MremapHook);
-    saved_munmap_hook = MallocHook::SetMunmapHook(MunmapHook);
-    saved_sbrk_hook = MallocHook::SetSbrkHook(SbrkHook);
+    // Install our hooks to do the logging:
+    RAW_CHECK(MallocHook::AddMmapHook(&MmapHook), "");
+    RAW_CHECK(MallocHook::AddMremapHook(&MremapHook), "");
+    RAW_CHECK(MallocHook::AddMunmapHook(&MunmapHook), "");
+    RAW_CHECK(MallocHook::AddSbrkHook(&SbrkHook), "");
   }
 
   heap_profiler_memory =
     LowLevelAlloc::NewArena(0, LowLevelAlloc::DefaultArena());
 
   // Reserve space now for the heap profiler, so we can still write a
   // heap profile even if the application runs out of memory.
   global_profiler_buffer =
       reinterpret_cast<char*>(ProfilerMalloc(kProfileBufferSize));
 
   heap_profile = new(ProfilerMalloc(sizeof(HeapProfileTable)))
                    HeapProfileTable(ProfilerMalloc, ProfilerFree);
 
   last_dump_alloc = 0;
   last_dump_free = 0;
   high_water_mark = 0;
 
   // We do not reset dump_count so if the user does a sequence of
   // HeapProfilerStart/HeapProfileStop, we will get a continuous
   // sequence of profiles.
 
   if (FLAGS_only_mmap_profile == false) {
-    // Now set the hooks that capture new/delete and malloc/free
-    // and check that these are the only hooks:
-    if (MallocHook::SetNewHook(NewHook) != NULL  ||
-        MallocHook::SetDeleteHook(DeleteHook) != NULL) {
-      RAW_LOG(FATAL, "Had other new/delete MallocHook-s set. "
-                     "Are you using the heap leak checker? "
-                     "Use --heap_check=\"\" to avoid this conflict.");
-    }
+    // Now set the hooks that capture new/delete and malloc/free.
+    RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
+    RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
   }
 
   // Copy filename prefix
   RAW_DCHECK(filename_prefix == NULL, "");
   const int prefix_length = strlen(prefix);
   filename_prefix = reinterpret_cast<char*>(ProfilerMalloc(prefix_length + 1));
   memcpy(filename_prefix, prefix, prefix_length);
   filename_prefix[prefix_length] = '\0';
 }
 
 extern "C" int IsHeapProfilerRunning() {
   SpinLockHolder l(&heap_lock);
   return is_on ? 1 : 0;   // return an int, because C code doesn't have bool
 }
 
 extern "C" void HeapProfilerStop() {
   SpinLockHolder l(&heap_lock);
 
   if (!is_on) return;
 
   if (FLAGS_only_mmap_profile == false) {
-    // Unset our new/delete hooks, checking they were the ones set:
-    if (MallocHook::SetNewHook(NULL) != NewHook  ||
-        MallocHook::SetDeleteHook(NULL) != DeleteHook) {
-      RAW_LOG(FATAL, "Had our new/delete MallocHook-s replaced. "
-                     "Are you using another MallocHook client? "
-                     "Do not use --heap_profile=... to avoid this conflict.");
-    }
+    // Unset our new/delete hooks, checking they were set:
+    RAW_CHECK(MallocHook::RemoveNewHook(&NewHook), "");
+    RAW_CHECK(MallocHook::RemoveDeleteHook(&DeleteHook), "");
   }
   if (FLAGS_mmap_log) {
-    // Restore mmap/sbrk hooks, checking that our hooks were the ones set:
-    if (MallocHook::SetMmapHook(saved_mmap_hook) != MmapHook  ||
-        MallocHook::SetMremapHook(saved_mremap_hook) != MremapHook  ||
-        MallocHook::SetMunmapHook(saved_munmap_hook) != MunmapHook  ||
-        MallocHook::SetSbrkHook(saved_sbrk_hook) != SbrkHook) {
-      RAW_LOG(FATAL, "Had our mmap/mremap/munmap/sbrk MallocHook-s replaced. "
-                     "Are you using another MallocHook client? "
-                     "Do not use --heap_profile=... to avoid this conflict.");
-    }
+    // Restore mmap/sbrk hooks, checking that our hooks were set:
+    RAW_CHECK(MallocHook::RemoveMmapHook(&MmapHook), "");
+    RAW_CHECK(MallocHook::RemoveMremapHook(&MremapHook), "");
+    RAW_CHECK(MallocHook::RemoveSbrkHook(&SbrkHook), "");
+    RAW_CHECK(MallocHook::RemoveMunmapHook(&MunmapHook), "");
   }
 
   // free profile
   heap_profile->~HeapProfileTable();
   ProfilerFree(heap_profile);
   heap_profile = NULL;
 
   // free output-buffer memory
   ProfilerFree(global_profiler_buffer);
 
@@ skipping 46 matching lines @@
 
 // class used for finalization -- dumps the heap-profile at program exit
 struct HeapProfileEndWriter {
   ~HeapProfileEndWriter() { HeapProfilerDump("Exiting"); }
 };
 
 // We want to make sure tcmalloc is up and running before starting the profiler
 static const TCMallocGuard tcmalloc_initializer;
 REGISTER_MODULE_INITIALIZER(heapprofiler, HeapProfilerInit());
 static HeapProfileEndWriter heap_profile_end_writer;