Merged third_party/tcmalloc/vendor/src(google-perftools r87) into...

third_party/tcmalloc/chromium/src/base/low_level_alloc.cc

 /* Copyright (c) 2006, 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 49 matching lines @@
 static const int kMaxLevel = 30;
 
 namespace {
   // This struct describes one allocated block, or one free block.
   struct AllocList {
     struct Header {
       intptr_t size;  // size of entire region, including this field. Must be
                       // first.  Valid in both allocated and unallocated blocks
       intptr_t magic; // kMagicAllocated or kMagicUnallocated xor this
       LowLevelAlloc::Arena *arena; // pointer to parent arena
-      void *dummy_for_alignment;   // aligns regions to 0 mod 2*sizeof(void*) 
+      void *dummy_for_alignment;   // aligns regions to 0 mod 2*sizeof(void*)
     } header;
 
     // Next two fields: in unallocated blocks: freelist skiplist data
     //                  in allocated blocks: overlaps with client data
     int levels;           // levels in skiplist used
     AllocList *next[kMaxLevel];   // actually has levels elements.
                                   // The AllocList node may not have room for
                                   // all kMaxLevel entries.  See max_fit in
                                   // LLA_SkiplistLevels()
   };
@@ skipping 109 matching lines @@
   size_t roundup;         // lowest power of 2 >= max(16,sizeof (AllocList))
                           // (init under mu, then ro)
   size_t min_size;        // smallest allocation block size
                           // (init under mu, then ro)
 };
 
 // The default arena, which is used when 0 is passed instead of an Arena
 // pointer.
 static struct LowLevelAlloc::Arena default_arena;
 
-// A non-malloc-hooked arena: used only to allocate metadata for arenas that
+// Non-malloc-hooked arenas: used only to allocate metadata for arenas that
 // do not want malloc hook reporting, so that for them there's no malloc hook
 // reporting even during arena creation.
 static struct LowLevelAlloc::Arena unhooked_arena;
+static struct LowLevelAlloc::Arena unhooked_async_sig_safe_arena;
 
 // magic numbers to identify allocated and unallocated blocks
 static const intptr_t kMagicAllocated = 0x4c833e95;
 static const intptr_t kMagicUnallocated = ~kMagicAllocated;
 
+namespace {
+  class ArenaLock {
+   public:
+    explicit ArenaLock(LowLevelAlloc::Arena *arena) :
+        left_(false), mask_valid_(false), arena_(arena) {
+      if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+      // We've decided not to support async-signal-safe arena use until
+      // there a demonstrated need.  Here's how one could do it though
+      // (would need to be made more portable).
+#if 0
+        sigset_t all;
+        sigfillset(&all);
+        this->mask_valid_ =
+            (pthread_sigmask(SIG_BLOCK, &all, &this->mask_) == 0);
+#else
+        RAW_CHECK(false, "We do not yet support async-signal-safe arena.");
+#endif
+      }
+      this->arena_->mu.Lock();
+    }
+    ~ArenaLock() { RAW_CHECK(this->left_, "haven't left Arena region"); }
+    void Leave() {
+      this->arena_->mu.Unlock();
+#if 0
+      if (this->mask_valid_) {
+        pthread_sigmask(SIG_SETMASK, &this->mask_, 0);
+      }
+#endif
+      this->left_ = true;
+    }
+   private:
+    bool left_;       // whether left region
+    bool mask_valid_;
+#if 0
+    sigset_t mask_;   // old mask of blocked signals
+#endif
+    LowLevelAlloc::Arena *arena_;
+    DISALLOW_COPY_AND_ASSIGN(ArenaLock);
+  };
+} // anonymous namespace
+
 // create an appropriate magic number for an object at "ptr"
 // "magic" should be kMagicAllocated or kMagicUnallocated
 inline static intptr_t Magic(intptr_t magic, AllocList::Header *ptr) {
   return magic ^ reinterpret_cast<intptr_t>(ptr);
 }
 
 // Initialize the fields of an Arena
 static void ArenaInit(LowLevelAlloc::Arena *arena) {
   if (arena->pagesize == 0) {
     arena->pagesize = getpagesize();
     // Round up block sizes to a power of two close to the header size.
     arena->roundup = 16;
     while (arena->roundup < sizeof (arena->freelist.header)) {
       arena->roundup += arena->roundup;
     }
     // Don't allocate blocks less than twice the roundup size to avoid tiny
     // free blocks.
     arena->min_size = 2 * arena->roundup;
     arena->freelist.header.size = 0;
     arena->freelist.header.magic =
         Magic(kMagicUnallocated, &arena->freelist.header);
     arena->freelist.header.arena = arena;
     arena->freelist.levels = 0;
     memset(arena->freelist.next, 0, sizeof (arena->freelist.next));
     arena->allocation_count = 0;
     if (arena == &default_arena) {
       // Default arena should be hooked, e.g. for heap-checker to trace
       // pointer chains through objects in the default arena.
       arena->flags = LowLevelAlloc::kCallMallocHook;
+    } else if (arena == &unhooked_async_sig_safe_arena) {
+      arena->flags = LowLevelAlloc::kAsyncSignalSafe;
     } else {
       arena->flags = 0;   // other arenas' flags may be overridden by client,
                           // but unhooked_arena will have 0 in 'flags'.
     }
   }
 }
 
 // L < meta_data_arena->mu
 LowLevelAlloc::Arena *LowLevelAlloc::NewArena(int32 flags,
                                               Arena *meta_data_arena) {
   RAW_CHECK(meta_data_arena != 0, "must pass a valid arena");
-  if (meta_data_arena == &default_arena  &&
-      (flags & LowLevelAlloc::kCallMallocHook) == 0) {
-    meta_data_arena = &unhooked_arena;
+  if (meta_data_arena == &default_arena) {
+    if ((flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+      meta_data_arena = &unhooked_async_sig_safe_arena;
+    } else if ((flags & LowLevelAlloc::kCallMallocHook) == 0) {
+      meta_data_arena = &unhooked_arena;
+    }
   }
   // Arena(0) uses the constructor for non-static contexts
   Arena *result =
     new (AllocWithArena(sizeof (*result), meta_data_arena)) Arena(0);
   ArenaInit(result);
   result->flags = flags;
   return result;
 }
 
 // L < arena->mu, L < arena->arena->mu
 bool LowLevelAlloc::DeleteArena(Arena *arena) {
   RAW_CHECK(arena != 0 && arena != &default_arena && arena != &unhooked_arena,
             "may not delete default arena");
-  arena->mu.Lock();
+  ArenaLock section(arena);
   bool empty = (arena->allocation_count == 0);
-  arena->mu.Unlock();
+  section.Leave();
   if (empty) {
     while (arena->freelist.next[0] != 0) {
       AllocList *region = arena->freelist.next[0];
       size_t size = region->header.size;
       arena->freelist.next[0] = region->next[0];
       RAW_CHECK(region->header.magic ==
                 Magic(kMagicUnallocated, &region->header),
                 "bad magic number in DeleteArena()");
       RAW_CHECK(region->header.arena == arena,
                 "bad arena pointer in DeleteArena()");
       RAW_CHECK(size % arena->pagesize == 0,
                 "empty arena has non-page-aligned block size");
       RAW_CHECK(reinterpret_cast<intptr_t>(region) % arena->pagesize == 0,
                 "empty arena has non-page-aligned block");
-      RAW_CHECK(munmap(region, size) == 0,
+      int munmap_result;
+      if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) == 0) {
+        munmap_result = munmap(region, size);
+      } else {
+        munmap_result = MallocHook::UnhookedMUnmap(region, size);
+      }
+      RAW_CHECK(munmap_result == 0,
                 "LowLevelAlloc::DeleteArena:  munmap failed address");
     }
     Free(arena);
   }
   return empty;
 }
 
 // ---------------------------------------------------------------------------
 
 // Return value rounded up to next multiple of align.
@@ skipping 63 matching lines @@
 void LowLevelAlloc::Free(void *v) {
   if (v != 0) {
     AllocList *f = reinterpret_cast<AllocList *>(
                         reinterpret_cast<char *>(v) - sizeof (f->header));
     RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
               "bad magic number in Free()");
     LowLevelAlloc::Arena *arena = f->header.arena;
     if ((arena->flags & kCallMallocHook) != 0) {
       MallocHook::InvokeDeleteHook(v);
     }
-    arena->mu.Lock();
+    ArenaLock section(arena);
     AddToFreelist(v, arena);
     RAW_CHECK(arena->allocation_count > 0, "nothing in arena to free");
     arena->allocation_count--;
-    arena->mu.Unlock();
+    section.Leave();
   }
 }
 
 // allocates and returns a block of size bytes, to be freed with Free()
 // L < arena->mu
-void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
+static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
   void *result = 0;
   if (request != 0) {
     AllocList *s;       // will point to region that satisfies request
-    arena->mu.Lock();
+    ArenaLock section(arena);
     ArenaInit(arena);
     // round up with header
     size_t req_rnd = RoundUp(request + sizeof (s->header), arena->roundup);
     for (;;) {      // loop until we find a suitable region
       // find the minimum levels that a block of this size must have
       int i = LLA_SkiplistLevels(req_rnd, arena->min_size, false) - 1;
       if (i < arena->freelist.levels) {   // potential blocks exist
         AllocList *before = &arena->freelist;  // predecessor of s
         while ((s = Next(i, before, arena)) != 0 && s->header.size < req_rnd) {
           before = s;
         }
         if (s != 0) {       // we found a region
           break;
         }
       }
       // we unlock before mmap() both because mmap() may call a callback hook,
       // and because it may be slow.
       arena->mu.Unlock();
       // mmap generous 64K chunks to decrease
       // the chances/impact of fragmentation:
       size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
-      void *new_pages = mmap(0, new_pages_size,
-                     PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+      void *new_pages;
+      if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+        new_pages = MallocHook::UnhookedMMap(0, new_pages_size,
+            PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+      } else {
+        new_pages = mmap(0, new_pages_size,
+            PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+      }
       RAW_CHECK(new_pages != MAP_FAILED, "mmap error");
       arena->mu.Lock();
       s = reinterpret_cast<AllocList *>(new_pages);
       s->header.size = new_pages_size;
       // Pretend the block is allocated; call AddToFreelist() to free it.
       s->header.magic = Magic(kMagicAllocated, &s->header);
       s->header.arena = arena;
       AddToFreelist(&s->levels, arena);  // insert new region into free list
     }
     AllocList *prev[kMaxLevel];
     LLA_SkiplistDelete(&arena->freelist, s, prev);    // remove from free list
     // s points to the first free region that's big enough
     if (req_rnd + arena->min_size <= s->header.size) {  // big enough to split
       AllocList *n = reinterpret_cast<AllocList *>
                         (req_rnd + reinterpret_cast<char *>(s));
       n->header.size = s->header.size - req_rnd;
       n->header.magic = Magic(kMagicAllocated, &n->header);
       n->header.arena = arena;
       s->header.size = req_rnd;
       AddToFreelist(&n->levels, arena);
     }
     s->header.magic = Magic(kMagicAllocated, &s->header);
     RAW_CHECK(s->header.arena == arena, "");
     arena->allocation_count++;
-    arena->mu.Unlock();
+    section.Leave();
     result = &s->levels;
   }
   ANNOTATE_NEW_MEMORY(result, request);
   return result;
 }
 
 void *LowLevelAlloc::Alloc(size_t request) {
   void *result = DoAllocWithArena(request, &default_arena);
   if ((default_arena.flags & kCallMallocHook) != 0) {
     // this call must be directly in the user-called allocator function
@@ skipping 10 matching lines @@
     // this call must be directly in the user-called allocator function
     // for MallocHook::GetCallerStackTrace to work properly
     MallocHook::InvokeNewHook(result, request);
   }
   return result;
 }
 
 LowLevelAlloc::Arena *LowLevelAlloc::DefaultArena() {
   return &default_arena;
 }