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

   1 // Copyright (c) 2005, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 // ---
  31 // Author: Sanjay Ghemawat
  32 //
  33 // TODO: Log large allocations
  34
  35 #include <config.h>
  36 #include <stddef.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #ifdef HAVE_UNISTD_H
  40 #include <unistd.h>
  41 #endif
  42 #ifdef HAVE_INTTYPES_H
  43 #include <inttypes.h>
  44 #endif
  45 #ifdef HAVE_FCNTL_H
  46 #include <fcntl.h>    // for open()
  47 #endif
  48 #ifdef HAVE_MMAP
  49 #include <sys/mman.h>
  50 #endif
  51 #include <errno.h>
  52 #include <assert.h>
  53 #include <sys/types.h>
  54
  55 #include <algorithm>
  56 #include <string>
  57
  58 #include <gperftools/heap-profiler.h>
  59
  60 #include "base/logging.h"
  61 #include "base/basictypes.h"   // for PRId64, among other things
  62 #include "base/googleinit.h"
  63 #include "base/commandlineflags.h"
  64 #include "malloc_hook-inl.h"
  65 #include "tcmalloc_guard.h"
  66 #include <gperftools/malloc_hook.h>
  67 #include <gperftools/malloc_extension.h>
  68 #include "base/spinlock.h"
  69 #include "base/low_level_alloc.h"
  70 #include "base/sysinfo.h"      // for GetUniquePathFromEnv()
  71 #include "deep-heap-profile.h"
  72 #include "heap-profile-table.h"
  73 #include "memory_region_map.h"
  74
  75
  76 #ifndef PATH_MAX
  77 #ifdef MAXPATHLEN
  78 #define PATH_MAX        MAXPATHLEN
  79 #else
  80 #define PATH_MAX        4096         // seems conservative for max filename len!
  81 #endif
  82 #endif
  83
  84 #if defined(__ANDROID__) || defined(ANDROID)
  85 // On android, there are no environment variables.
  86 // Instead, we use system properties, set via:
  87 //   adb shell setprop prop_name prop_value
  88 // From <sys/system_properties.h>,
  89 //   PROP_NAME_MAX   32
  90 //   PROP_VALUE_MAX  92
  91 #define HEAPPROFILE "heapprof"
  92 #define HEAP_PROFILE_ALLOCATION_INTERVAL "heapprof.allocation_interval"
  93 #define HEAP_PROFILE_DEALLOCATION_INTERVAL "heapprof.deallocation_interval"
  94 #define HEAP_PROFILE_INUSE_INTERVAL "heapprof.inuse_interval"
  95 #define HEAP_PROFILE_TIME_INTERVAL "heapprof.time_interval"
  96 #define HEAP_PROFILE_MMAP_LOG "heapprof.mmap_log"
  97 #define HEAP_PROFILE_MMAP "heapprof.mmap"
  98 #define HEAP_PROFILE_ONLY_MMAP "heapprof.only_mmap"
  99 #define DEEP_HEAP_PROFILE "heapprof.deep_heap_profile"
 100 #define DEEP_HEAP_PROFILE_PAGEFRAME "heapprof.deep.pageframe"
 101 #define HEAP_PROFILE_TYPE_STATISTICS "heapprof.type_statistics"
 102 #else  // defined(__ANDROID__) || defined(ANDROID)
 103 #define HEAPPROFILE "HEAPPROFILE"
 104 #define HEAP_PROFILE_ALLOCATION_INTERVAL "HEAP_PROFILE_ALLOCATION_INTERVAL"
 105 #define HEAP_PROFILE_DEALLOCATION_INTERVAL "HEAP_PROFILE_DEALLOCATION_INTERVAL"
 106 #define HEAP_PROFILE_INUSE_INTERVAL "HEAP_PROFILE_INUSE_INTERVAL"
 107 #define HEAP_PROFILE_TIME_INTERVAL "HEAP_PROFILE_TIME_INTERVAL"
 108 #define HEAP_PROFILE_MMAP_LOG "HEAP_PROFILE_MMAP_LOG"
 109 #define HEAP_PROFILE_MMAP "HEAP_PROFILE_MMAP"
 110 #define HEAP_PROFILE_ONLY_MMAP "HEAP_PROFILE_ONLY_MMAP"
 111 #define DEEP_HEAP_PROFILE "DEEP_HEAP_PROFILE"
 112 #define DEEP_HEAP_PROFILE_PAGEFRAME "DEEP_HEAP_PROFILE_PAGEFRAME"
 113 #define HEAP_PROFILE_TYPE_STATISTICS "HEAP_PROFILE_TYPE_STATISTICS"
 114 #endif  // defined(__ANDROID__) || defined(ANDROID)
 115
 116 using STL_NAMESPACE::string;
 117 using STL_NAMESPACE::sort;
 118
 119 //----------------------------------------------------------------------
 120 // Flags that control heap-profiling
 121 //
 122 // The thread-safety of the profiler depends on these being immutable
 123 // after main starts, so don't change them.
 124 //----------------------------------------------------------------------
 125
 126 DEFINE_int64(heap_profile_allocation_interval,
 127              EnvToInt64(HEAP_PROFILE_ALLOCATION_INTERVAL, 1 << 30 /*1GB*/),
 128              "If non-zero, dump heap profiling information once every "
 129              "specified number of bytes allocated by the program since "
 130              "the last dump.");
 131 DEFINE_int64(heap_profile_deallocation_interval,
 132              EnvToInt64(HEAP_PROFILE_DEALLOCATION_INTERVAL, 0),
 133              "If non-zero, dump heap profiling information once every "
 134              "specified number of bytes deallocated by the program "
 135              "since the last dump.");
 136 // We could also add flags that report whenever inuse_bytes changes by
 137 // X or -X, but there hasn't been a need for that yet, so we haven't.
 138 DEFINE_int64(heap_profile_inuse_interval,
 139              EnvToInt64(HEAP_PROFILE_INUSE_INTERVAL, 100 << 20 /*100MB*/),
 140              "If non-zero, dump heap profiling information whenever "
 141              "the high-water memory usage mark increases by the specified "
 142              "number of bytes.");
 143 DEFINE_int64(heap_profile_time_interval,
 144              EnvToInt64(HEAP_PROFILE_TIME_INTERVAL, 0),
 145              "If non-zero, dump heap profiling information once every "
 146              "specified number of seconds since the last dump.");
 147 DEFINE_bool(mmap_log,
 148             EnvToBool(HEAP_PROFILE_MMAP_LOG, false),
 149             "Should mmap/munmap calls be logged?");
 150 DEFINE_bool(mmap_profile,
 151             EnvToBool(HEAP_PROFILE_MMAP, false),
 152             "If heap-profiling is on, also profile mmap, mremap, and sbrk)");
 153 DEFINE_bool(only_mmap_profile,
 154             EnvToBool(HEAP_PROFILE_ONLY_MMAP, false),
 155             "If heap-profiling is on, only profile mmap, mremap, and sbrk; "
 156             "do not profile malloc/new/etc");
 157 DEFINE_bool(deep_heap_profile,
 158             EnvToBool(DEEP_HEAP_PROFILE, false),
 159             "If heap-profiling is on, profile deeper (Linux and Android)");
 160 DEFINE_int32(deep_heap_profile_pageframe,
 161              EnvToInt(DEEP_HEAP_PROFILE_PAGEFRAME, 0),
 162              "Needs deeper profile. If 1, dump page frame numbers (PFNs). "
 163              "If 2, dump page counts (/proc/kpagecount) with PFNs.");
 164 #if defined(TYPE_PROFILING)
 165 DEFINE_bool(heap_profile_type_statistics,
 166             EnvToBool(HEAP_PROFILE_TYPE_STATISTICS, false),
 167             "If heap-profiling is on, dump type statistics.");
 168 #endif  // defined(TYPE_PROFILING)
 169
 170
 171 //----------------------------------------------------------------------
 172 // Locking
 173 //----------------------------------------------------------------------
 174
 175 // A pthread_mutex has way too much lock contention to be used here.
 176 //
 177 // I would like to use Mutex, but it can call malloc(),
 178 // which can cause us to fall into an infinite recursion.
 179 //
 180 // So we use a simple spinlock.
 181 static SpinLock heap_lock(SpinLock::LINKER_INITIALIZED);
 182
 183 //----------------------------------------------------------------------
 184 // Simple allocator for heap profiler's internal memory
 185 //----------------------------------------------------------------------
 186
 187 static LowLevelAlloc::Arena *heap_profiler_memory;
 188
 189 static void* ProfilerMalloc(size_t bytes) {
 190   return LowLevelAlloc::AllocWithArena(bytes, heap_profiler_memory);
 191 }
 192 static void ProfilerFree(void* p) {
 193   LowLevelAlloc::Free(p);
 194 }
 195
 196 // We use buffers of this size in DoGetHeapProfile.
 197 static const int kProfileBufferSize = 1 << 20;
 198
 199 // This is a last-ditch buffer we use in DumpProfileLocked in case we
 200 // can't allocate more memory from ProfilerMalloc.  We expect this
 201 // will be used by HeapProfileEndWriter when the application has to
 202 // exit due to out-of-memory.  This buffer is allocated in
 203 // HeapProfilerStart.  Access to this must be protected by heap_lock.
 204 static char* global_profiler_buffer = NULL;
 205
 206
 207 //----------------------------------------------------------------------
 208 // Profiling control/state data
 209 //----------------------------------------------------------------------
 210
 211 // Access to all of these is protected by heap_lock.
 212 static bool  is_on = false;           // If are on as a subsytem.
 213 static bool  dumping = false;         // Dumping status to prevent recursion
 214 static char* filename_prefix = NULL;  // Prefix used for profile file names
 215                                       // (NULL if no need for dumping yet)
 216 static int   dump_count = 0;          // How many dumps so far
 217 static int64 last_dump_alloc = 0;     // alloc_size when did we last dump
 218 static int64 last_dump_free = 0;      // free_size when did we last dump
 219 static int64 high_water_mark = 0;     // In-use-bytes at last high-water dump
 220 static int64 last_dump_time = 0;      // The time of the last dump
 221
 222 static HeapProfileTable* heap_profile = NULL;  // the heap profile table
 223 static DeepHeapProfile* deep_profile = NULL;  // deep memory profiler
 224
 225 // Callback to generate a stack trace for an allocation. May be overriden
 226 // by an application to provide its own pseudo-stacks.
 227 static StackGeneratorFunction stack_generator_function =
 228     HeapProfileTable::GetCallerStackTrace;
 229
 230 //----------------------------------------------------------------------
 231 // Profile generation
 232 //----------------------------------------------------------------------
 233
 234 // Input must be a buffer of size at least 1MB.
 235 static char* DoGetHeapProfileLocked(char* buf, int buflen) {
 236   // We used to be smarter about estimating the required memory and
 237   // then capping it to 1MB and generating the profile into that.
 238   if (buf == NULL || buflen < 1)
 239     return NULL;
 240
 241   RAW_DCHECK(heap_lock.IsHeld(), "");
 242   int bytes_written = 0;
 243   if (is_on) {
 244     HeapProfileTable::Stats const stats = heap_profile->total();
 245     (void)stats;   // avoid an unused-variable warning in non-debug mode.
 246     bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
 247     // FillOrderedProfile should not reduce the set of active mmap-ed regions,
 248     // hence MemoryRegionMap will let us remove everything we've added above:
 249     RAW_DCHECK(stats.Equivalent(heap_profile->total()), "");
 250     // if this fails, we somehow removed by FillOrderedProfile
 251     // more than we have added.
 252   }
 253   buf[bytes_written] = '\0';
 254   RAW_DCHECK(bytes_written == strlen(buf), "");
 255
 256   return buf;
 257 }
 258
 259 extern "C" char* GetHeapProfile() {
 260   // Use normal malloc: we return the profile to the user to free it:
 261   char* buffer = reinterpret_cast<char*>(malloc(kProfileBufferSize));
 262   SpinLockHolder l(&heap_lock);
 263   return DoGetHeapProfileLocked(buffer, kProfileBufferSize);
 264 }
 265
 266 // defined below
 267 static void NewHook(const void* ptr, size_t size);
 268 static void DeleteHook(const void* ptr);
 269
 270 // Helper for HeapProfilerDump.
 271 static void DumpProfileLocked(const char* reason) {
 272   RAW_DCHECK(heap_lock.IsHeld(), "");
 273   RAW_DCHECK(is_on, "");
 274   RAW_DCHECK(!dumping, "");
 275
 276   if (filename_prefix == NULL) return;  // we do not yet need dumping
 277
 278   dumping = true;
 279
 280   // Make file name
 281   char file_name[1000];
 282   dump_count++;
 283   snprintf(file_name, sizeof(file_name), "%s.%05d.%04d%s",
 284            filename_prefix, getpid(), dump_count, HeapProfileTable::kFileExt);
 285
 286   // Dump the profile
 287   RAW_VLOG(0, "Dumping heap profile to %s (%s)", file_name, reason);
 288   // We must use file routines that don't access memory, since we hold
 289   // a memory lock now.
 290   RawFD fd = RawOpenForWriting(file_name);
 291   if (fd == kIllegalRawFD) {
 292     RAW_LOG(ERROR, "Failed dumping heap profile to %s", file_name);
 293     dumping = false;
 294     return;
 295   }
 296
 297   // This case may be impossible, but it's best to be safe.
 298   // It's safe to use the global buffer: we're protected by heap_lock.
 299   if (global_profiler_buffer == NULL) {
 300     global_profiler_buffer =
 301         reinterpret_cast<char*>(ProfilerMalloc(kProfileBufferSize));
 302   }
 303
 304   if (deep_profile) {
 305     deep_profile->DumpOrderedProfile(reason, global_profiler_buffer,
 306                                      kProfileBufferSize, fd);
 307   } else {
 308     char* profile = DoGetHeapProfileLocked(global_profiler_buffer,
 309                                            kProfileBufferSize);
 310     RawWrite(fd, profile, strlen(profile));
 311   }
 312   RawClose(fd);
 313
 314 #if defined(TYPE_PROFILING)
 315   if (FLAGS_heap_profile_type_statistics) {
 316     snprintf(file_name, sizeof(file_name), "%s.%05d.%04d.type",
 317              filename_prefix, getpid(), dump_count);
 318     RAW_VLOG(0, "Dumping type statistics to %s", file_name);
 319     heap_profile->DumpTypeStatistics(file_name);
 320   }
 321 #endif  // defined(TYPE_PROFILING)
 322
 323   dumping = false;
 324 }
 325
 326 //----------------------------------------------------------------------
 327 // Profile collection
 328 //----------------------------------------------------------------------
 329
 330 // Dump a profile after either an allocation or deallocation, if
 331 // the memory use has changed enough since the last dump.
 332 static void MaybeDumpProfileLocked() {
 333   if (!dumping) {
 334     const HeapProfileTable::Stats& total = heap_profile->total();
 335     const int64 inuse_bytes = total.alloc_size - total.free_size;
 336     bool need_to_dump = false;
 337     char buf[128];
 338     int64 current_time = time(NULL);
 339     if (FLAGS_heap_profile_allocation_interval > 0 &&
 340         total.alloc_size >=
 341         last_dump_alloc + FLAGS_heap_profile_allocation_interval) {
 342       snprintf(buf, sizeof(buf), ("%" PRId64 " MB allocated cumulatively, "
 343                                   "%" PRId64 " MB currently in use"),
 344                total.alloc_size >> 20, inuse_bytes >> 20);
 345       need_to_dump = true;
 346     } else if (FLAGS_heap_profile_deallocation_interval > 0 &&
 347                total.free_size >=
 348                last_dump_free + FLAGS_heap_profile_deallocation_interval) {
 349       snprintf(buf, sizeof(buf), ("%" PRId64 " MB freed cumulatively, "
 350                                   "%" PRId64 " MB currently in use"),
 351                total.free_size >> 20, inuse_bytes >> 20);
 352       need_to_dump = true;
 353     } else if (FLAGS_heap_profile_inuse_interval > 0 &&
 354                inuse_bytes >
 355                high_water_mark + FLAGS_heap_profile_inuse_interval) {
 356       snprintf(buf, sizeof(buf), "%" PRId64 " MB currently in use",
 357                inuse_bytes >> 20);
 358       need_to_dump = true;
 359     } else if (FLAGS_heap_profile_time_interval > 0 &&
 360                current_time - last_dump_time >=
 361                FLAGS_heap_profile_time_interval) {
 362       snprintf(buf, sizeof(buf), "%" PRId64 " sec since the last dump",
 363                current_time - last_dump_time);
 364       need_to_dump = true;
 365       last_dump_time = current_time;
 366     }
 367     if (need_to_dump) {
 368       DumpProfileLocked(buf);
 369
 370       last_dump_alloc = total.alloc_size;
 371       last_dump_free = total.free_size;
 372       if (inuse_bytes > high_water_mark)
 373         high_water_mark = inuse_bytes;
 374     }
 375   }
 376 }
 377
 378 // Record an allocation in the profile.
 379 static void RecordAlloc(const void* ptr, size_t bytes, int skip_count) {
 380   // Take the stack trace outside the critical section.
 381   void* stack[HeapProfileTable::kMaxStackDepth];
 382   int depth = stack_generator_function(skip_count + 1, stack);
 383   SpinLockHolder l(&heap_lock);
 384   if (is_on) {
 385     heap_profile->RecordAlloc(ptr, bytes, depth, stack);
 386     MaybeDumpProfileLocked();
 387   }
 388 }
 389
 390 // Record a deallocation in the profile.
 391 static void RecordFree(const void* ptr) {
 392   SpinLockHolder l(&heap_lock);
 393   if (is_on) {
 394     heap_profile->RecordFree(ptr);
 395     MaybeDumpProfileLocked();
 396   }
 397 }
 398
 399 //----------------------------------------------------------------------
 400 // Allocation/deallocation hooks for MallocHook
 401 //----------------------------------------------------------------------
 402
 403 // static
 404 void NewHook(const void* ptr, size_t size) {
 405   if (ptr != NULL) RecordAlloc(ptr, size, 0);
 406 }
 407
 408 // static
 409 void DeleteHook(const void* ptr) {
 410   if (ptr != NULL) RecordFree(ptr);
 411 }
 412
 413 // TODO(jandrews): Re-enable stack tracing
 414 #ifdef TODO_REENABLE_STACK_TRACING
 415 static void RawInfoStackDumper(const char* message, void*) {
 416   RAW_LOG(INFO, "%.*s", static_cast<int>(strlen(message) - 1), message);
 417   // -1 is to chop the \n which will be added by RAW_LOG
 418 }
 419 #endif
 420
 421 static void MmapHook(const void* result, const void* start, size_t size,
 422                      int prot, int flags, int fd, off_t offset) {
 423   if (FLAGS_mmap_log) {  // log it
 424     // We use PRIxS not just '%p' to avoid deadlocks
 425     // in pretty-printing of NULL as "nil".
 426     // TODO(maxim): instead should use a safe snprintf reimplementation
 427     RAW_LOG(INFO,
 428             "mmap(start=0x%" PRIxPTR ", len=%" PRIuS ", prot=0x%x, flags=0x%x, "
 429             "fd=%d, offset=0x%x) = 0x%" PRIxPTR,
 430             (uintptr_t) start, size, prot, flags, fd, (unsigned int) offset,
 431             (uintptr_t) result);
 432 #ifdef TODO_REENABLE_STACK_TRACING
 433     DumpStackTrace(1, RawInfoStackDumper, NULL);
 434 #endif
 435   }
 436 }
 437
 438 static void MremapHook(const void* result, const void* old_addr,
 439                        size_t old_size, size_t new_size,
 440                        int flags, const void* new_addr) {
 441   if (FLAGS_mmap_log) {  // log it
 442     // We use PRIxS not just '%p' to avoid deadlocks
 443     // in pretty-printing of NULL as "nil".
 444     // TODO(maxim): instead should use a safe snprintf reimplementation
 445     RAW_LOG(INFO,
 446             "mremap(old_addr=0x%" PRIxPTR ", old_size=%" PRIuS ", "
 447             "new_size=%" PRIuS ", flags=0x%x, new_addr=0x%" PRIxPTR ") = "
 448             "0x%" PRIxPTR,
 449             (uintptr_t) old_addr, old_size, new_size, flags,
 450             (uintptr_t) new_addr, (uintptr_t) result);
 451 #ifdef TODO_REENABLE_STACK_TRACING
 452     DumpStackTrace(1, RawInfoStackDumper, NULL);
 453 #endif
 454   }
 455 }
 456
 457 static void MunmapHook(const void* ptr, size_t size) {
 458   if (FLAGS_mmap_log) {  // log it
 459     // We use PRIxS not just '%p' to avoid deadlocks
 460     // in pretty-printing of NULL as "nil".
 461     // TODO(maxim): instead should use a safe snprintf reimplementation
 462     RAW_LOG(INFO, "munmap(start=0x%" PRIxPTR ", len=%" PRIuS ")",
 463                   (uintptr_t) ptr, size);
 464 #ifdef TODO_REENABLE_STACK_TRACING
 465     DumpStackTrace(1, RawInfoStackDumper, NULL);
 466 #endif
 467   }
 468 }
 469
 470 static void SbrkHook(const void* result, ptrdiff_t increment) {
 471   if (FLAGS_mmap_log) {  // log it
 472     RAW_LOG(INFO, "sbrk(inc=%" PRIdS ") = 0x%" PRIxPTR,
 473                   increment, (uintptr_t) result);
 474 #ifdef TODO_REENABLE_STACK_TRACING
 475     DumpStackTrace(1, RawInfoStackDumper, NULL);
 476 #endif
 477   }
 478 }
 479
 480 //----------------------------------------------------------------------
 481 // Starting/stopping/dumping
 482 //----------------------------------------------------------------------
 483
 484 extern "C" void HeapProfilerStart(const char* prefix) {
 485   SpinLockHolder l(&heap_lock);
 486
 487   if (is_on) return;
 488
 489   is_on = true;
 490
 491   RAW_VLOG(0, "Starting tracking the heap");
 492
 493   // This should be done before the hooks are set up, since it should
 494   // call new, and we want that to be accounted for correctly.
 495   MallocExtension::Initialize();
 496
 497   if (FLAGS_only_mmap_profile) {
 498     FLAGS_mmap_profile = true;
 499   }
 500
 501   if (FLAGS_mmap_profile) {
 502     // Ask MemoryRegionMap to record all mmap, mremap, and sbrk
 503     // call stack traces of at least size kMaxStackDepth:
 504     MemoryRegionMap::Init(HeapProfileTable::kMaxStackDepth,
 505                           /* use_buckets */ true);
 506   }
 507
 508   if (FLAGS_mmap_log) {
 509     // Install our hooks to do the logging:
 510     RAW_CHECK(MallocHook::AddMmapHook(&MmapHook), "");
 511     RAW_CHECK(MallocHook::AddMremapHook(&MremapHook), "");
 512     RAW_CHECK(MallocHook::AddMunmapHook(&MunmapHook), "");
 513     RAW_CHECK(MallocHook::AddSbrkHook(&SbrkHook), "");
 514   }
 515
 516   heap_profiler_memory =
 517     LowLevelAlloc::NewArena(0, LowLevelAlloc::DefaultArena());
 518
 519   // Reserve space now for the heap profiler, so we can still write a
 520   // heap profile even if the application runs out of memory.
 521   global_profiler_buffer =
 522       reinterpret_cast<char*>(ProfilerMalloc(kProfileBufferSize));
 523
 524   heap_profile = new(ProfilerMalloc(sizeof(HeapProfileTable)))
 525       HeapProfileTable(ProfilerMalloc, ProfilerFree, FLAGS_mmap_profile);
 526
 527   last_dump_alloc = 0;
 528   last_dump_free = 0;
 529   high_water_mark = 0;
 530   last_dump_time = 0;
 531
 532   if (FLAGS_deep_heap_profile) {
 533     // Initialize deep memory profiler
 534     RAW_VLOG(0, "[%d] Starting a deep memory profiler", getpid());
 535     deep_profile = new(ProfilerMalloc(sizeof(DeepHeapProfile)))
 536         DeepHeapProfile(heap_profile, prefix, DeepHeapProfile::PageFrameType(
 537             FLAGS_deep_heap_profile_pageframe));
 538   }
 539
 540   // We do not reset dump_count so if the user does a sequence of
 541   // HeapProfilerStart/HeapProfileStop, we will get a continuous
 542   // sequence of profiles.
 543
 544   if (FLAGS_only_mmap_profile == false) {
 545     // Now set the hooks that capture new/delete and malloc/free.
 546     RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
 547     RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
 548   }
 549
 550   // Copy filename prefix only if provided.
 551   if (!prefix)
 552     return;
 553   RAW_DCHECK(filename_prefix == NULL, "");
 554   const int prefix_length = strlen(prefix);
 555   filename_prefix = reinterpret_cast<char*>(ProfilerMalloc(prefix_length + 1));
 556   memcpy(filename_prefix, prefix, prefix_length);
 557   filename_prefix[prefix_length] = '\0';
 558 }
 559
 560 extern "C" void HeapProfilerWithPseudoStackStart(
 561     StackGeneratorFunction callback) {
 562   {
 563     // Ensure the callback is set before allocations can be recorded.
 564     SpinLockHolder l(&heap_lock);
 565     stack_generator_function = callback;
 566   }
 567   HeapProfilerStart(NULL);
 568 }
 569
 570 extern "C" void IterateAllocatedObjects(AddressVisitor visitor, void* data) {
 571   SpinLockHolder l(&heap_lock);
 572
 573   if (!is_on) return;
 574
 575   heap_profile->IterateAllocationAddresses(visitor, data);
 576 }
 577
 578 extern "C" int IsHeapProfilerRunning() {
 579   SpinLockHolder l(&heap_lock);
 580   return is_on ? 1 : 0;   // return an int, because C code doesn't have bool
 581 }
 582
 583 extern "C" void HeapProfilerStop() {
 584   SpinLockHolder l(&heap_lock);
 585
 586   if (!is_on) return;
 587
 588   if (FLAGS_only_mmap_profile == false) {
 589     // Unset our new/delete hooks, checking they were set:
 590     RAW_CHECK(MallocHook::RemoveNewHook(&NewHook), "");
 591     RAW_CHECK(MallocHook::RemoveDeleteHook(&DeleteHook), "");
 592   }
 593   if (FLAGS_mmap_log) {
 594     // Restore mmap/sbrk hooks, checking that our hooks were set:
 595     RAW_CHECK(MallocHook::RemoveMmapHook(&MmapHook), "");
 596     RAW_CHECK(MallocHook::RemoveMremapHook(&MremapHook), "");
 597     RAW_CHECK(MallocHook::RemoveSbrkHook(&SbrkHook), "");
 598     RAW_CHECK(MallocHook::RemoveMunmapHook(&MunmapHook), "");
 599   }
 600
 601   if (deep_profile) {
 602     // free deep memory profiler
 603     deep_profile->~DeepHeapProfile();
 604     ProfilerFree(deep_profile);
 605     deep_profile = NULL;
 606   }
 607
 608   // free profile
 609   heap_profile->~HeapProfileTable();
 610   ProfilerFree(heap_profile);
 611   heap_profile = NULL;
 612
 613   // free output-buffer memory
 614   ProfilerFree(global_profiler_buffer);
 615
 616   // free prefix
 617   ProfilerFree(filename_prefix);
 618   filename_prefix = NULL;
 619
 620   if (!LowLevelAlloc::DeleteArena(heap_profiler_memory)) {
 621     RAW_LOG(FATAL, "Memory leak in HeapProfiler:");
 622   }
 623
 624   if (FLAGS_mmap_profile) {
 625     MemoryRegionMap::Shutdown();
 626   }
 627
 628   is_on = false;
 629 }
 630
 631 extern "C" void HeapProfilerDump(const char* reason) {
 632   SpinLockHolder l(&heap_lock);
 633   if (is_on && !dumping) {
 634     DumpProfileLocked(reason);
 635   }
 636 }
 637
 638 extern "C" void HeapProfilerMarkBaseline() {
 639   SpinLockHolder l(&heap_lock);
 640
 641   if (!is_on) return;
 642
 643   heap_profile->MarkCurrentAllocations(HeapProfileTable::MARK_ONE);
 644 }
 645
 646 extern "C" void HeapProfilerMarkInteresting() {
 647   SpinLockHolder l(&heap_lock);
 648
 649   if (!is_on) return;
 650
 651   heap_profile->MarkUnmarkedAllocations(HeapProfileTable::MARK_TWO);
 652 }
 653
 654 extern "C" void HeapProfilerDumpAliveObjects(const char* filename) {
 655   SpinLockHolder l(&heap_lock);
 656
 657   if (!is_on) return;
 658
 659   heap_profile->DumpMarkedObjects(HeapProfileTable::MARK_TWO, filename);
 660 }
 661
 662 //----------------------------------------------------------------------
 663 // Initialization/finalization code
 664 //----------------------------------------------------------------------
 665 #if defined(ENABLE_PROFILING)
 666 // Initialization code
 667 static void HeapProfilerInit() {
 668   // Everything after this point is for setting up the profiler based on envvar
 669   char fname[PATH_MAX];
 670   if (!GetUniquePathFromEnv(HEAPPROFILE, fname)) {
 671     return;
 672   }
 673   // We do a uid check so we don't write out files in a setuid executable.
 674 #ifdef HAVE_GETEUID
 675   if (getuid() != geteuid()) {
 676     RAW_LOG(WARNING, ("HeapProfiler: ignoring " HEAPPROFILE " because "
 677                       "program seems to be setuid\n"));
 678     return;
 679   }
 680 #endif
 681
 682   HeapProfileTable::CleanupOldProfiles(fname);
 683
 684   HeapProfilerStart(fname);
 685 }
 686
 687 // class used for finalization -- dumps the heap-profile at program exit
 688 struct HeapProfileEndWriter {
 689   ~HeapProfileEndWriter() { HeapProfilerDump("Exiting"); }
 690 };
 691
 692 // We want to make sure tcmalloc is up and running before starting the profiler
 693 static const TCMallocGuard tcmalloc_initializer;
 694 REGISTER_MODULE_INITIALIZER(heapprofiler, HeapProfilerInit());
 695 static HeapProfileEndWriter heap_profile_end_writer;
 696 #endif   // defined(ENABLE_PROFILING)