bmalloc: tryFastMalloc shouldn't crash
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2015 18:00:59 +0000 (18:00 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2015 18:00:59 +0000 (18:00 +0000)
https://bugs.webkit.org/show_bug.cgi?id=142443

Reviewed by Sam Weinig.

Rolling back in r181307 with a check for whether bmalloc is enabled, to
avoid crashes when running with ASan and GuardMalloc.

Source/bmalloc:

* bmalloc/Allocator.cpp:
(bmalloc::Allocator::tryAllocate):
* bmalloc/Allocator.h:
* bmalloc/Cache.cpp:
(bmalloc::Cache::tryAllocateSlowCaseNullCache):
* bmalloc/Cache.h:
(bmalloc::Cache::tryAllocate):
* bmalloc/Heap.cpp:
(bmalloc::Heap::allocateXLarge):
(bmalloc::Heap::tryAllocateXLarge):
* bmalloc/Heap.h:
* bmalloc/VMAllocate.h:
(bmalloc::tryVMAllocate):
(bmalloc::vmAllocate):
* bmalloc/bmalloc.h:
(bmalloc::api::tryMalloc):
(bmalloc::api::realloc):
(bmalloc::api::free):

Source/WTF:

* wtf/FastMalloc.cpp:
(WTF::fastMalloc):
(WTF::fastRealloc):
(WTF::fastAlignedMalloc):
(WTF::tryFastMalloc):
(WTF::tryFastRealloc): Deleted.
* wtf/FastMalloc.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@181329 268f45cc-cd09-0410-ab3c-d52691b4dbfc

12 files changed:
Source/WTF/ChangeLog
Source/WTF/wtf/FastMalloc.cpp
Source/WTF/wtf/FastMalloc.h
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc/Allocator.cpp
Source/bmalloc/bmalloc/Allocator.h
Source/bmalloc/bmalloc/Cache.cpp
Source/bmalloc/bmalloc/Cache.h
Source/bmalloc/bmalloc/Heap.cpp
Source/bmalloc/bmalloc/Heap.h
Source/bmalloc/bmalloc/VMAllocate.h
Source/bmalloc/bmalloc/bmalloc.h

index dcc8069..639937f 100644 (file)
@@ -1,3 +1,21 @@
+2015-03-10  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: tryFastMalloc shouldn't crash
+        https://bugs.webkit.org/show_bug.cgi?id=142443
+
+        Reviewed by Sam Weinig.
+
+        Rolling back in r181307 with a check for whether bmalloc is enabled, to
+        avoid crashes when running with ASan and GuardMalloc.
+
+        * wtf/FastMalloc.cpp:
+        (WTF::fastMalloc):
+        (WTF::fastRealloc):
+        (WTF::fastAlignedMalloc):
+        (WTF::tryFastMalloc):
+        (WTF::tryFastRealloc): Deleted.
+        * wtf/FastMalloc.h:
+
 2015-03-10  Michael Catanzaro  <mcatanzaro@igalia.com>
 
         GCC: CRASH() should be annotated with NORETURN
index 381951b..2e8186c 100644 (file)
@@ -150,11 +150,6 @@ void fastFree(void* p)
     free(p);
 }
 
-TryMallocReturnValue tryFastRealloc(void* p, size_t n)
-{
-    return realloc(p, n);
-}
-
 void* fastRealloc(void* p, size_t n)
 {
     void* result = realloc(p, n);
@@ -194,10 +189,7 @@ namespace WTF {
 
 void* fastMalloc(size_t size)
 {
-    void* result = bmalloc::api::malloc(size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::malloc(size);
 }
 
 void* fastCalloc(size_t numElements, size_t elementSize)
@@ -212,10 +204,7 @@ void* fastCalloc(size_t numElements, size_t elementSize)
 
 void* fastRealloc(void* object, size_t size)
 {
-    void* result = bmalloc::api::realloc(object, size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::realloc(object, size);
 }
 
 void fastFree(void* object)
@@ -239,10 +228,7 @@ size_t fastMallocGoodSize(size_t size)
 
 void* fastAlignedMalloc(size_t alignment, size_t size) 
 {
-    void* result = bmalloc::api::memalign(alignment, size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::memalign(alignment, size);
 }
 
 void fastAlignedFree(void* p) 
@@ -252,12 +238,7 @@ void fastAlignedFree(void* p)
 
 TryMallocReturnValue tryFastMalloc(size_t size)
 {
-    return bmalloc::api::malloc(size);
-}
-    
-TryMallocReturnValue tryFastRealloc(void* object, size_t size)
-{
-    return bmalloc::api::realloc(object, size);
+    return bmalloc::api::tryMalloc(size);
 }
     
 TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize)
index d099245..7151771 100644 (file)
@@ -48,7 +48,6 @@ WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t);
 TryMallocReturnValue tryFastZeroedMalloc(size_t);
 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize);
-WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void*, size_t);
 
 WTF_EXPORT_PRIVATE void fastFree(void*);
 
@@ -108,7 +107,6 @@ using WTF::fastStrDup;
 using WTF::fastZeroedMalloc;
 using WTF::tryFastCalloc;
 using WTF::tryFastMalloc;
-using WTF::tryFastRealloc;
 using WTF::tryFastZeroedMalloc;
 using WTF::fastAlignedMalloc;
 using WTF::fastAlignedFree;
index 5d3b347..16a96c4 100644 (file)
@@ -1,3 +1,32 @@
+2015-03-10  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: tryFastMalloc shouldn't crash
+        https://bugs.webkit.org/show_bug.cgi?id=142443
+
+        Reviewed by Sam Weinig.
+
+        Rolling back in r181307 with a check for whether bmalloc is enabled, to
+        avoid crashes when running with ASan and GuardMalloc.
+
+        * bmalloc/Allocator.cpp:
+        (bmalloc::Allocator::tryAllocate):
+        * bmalloc/Allocator.h:
+        * bmalloc/Cache.cpp:
+        (bmalloc::Cache::tryAllocateSlowCaseNullCache):
+        * bmalloc/Cache.h:
+        (bmalloc::Cache::tryAllocate):
+        * bmalloc/Heap.cpp:
+        (bmalloc::Heap::allocateXLarge):
+        (bmalloc::Heap::tryAllocateXLarge):
+        * bmalloc/Heap.h:
+        * bmalloc/VMAllocate.h:
+        (bmalloc::tryVMAllocate):
+        (bmalloc::vmAllocate):
+        * bmalloc/bmalloc.h:
+        (bmalloc::api::tryMalloc):
+        (bmalloc::api::realloc):
+        (bmalloc::api::free):
+
 2015-03-09  Commit Queue  <commit-queue@webkit.org>
 
         Unreviewed, rolling out r181307.
index c213e47..47fea52 100644 (file)
@@ -51,6 +51,18 @@ Allocator::~Allocator()
     scavenge();
 }
 
+void* Allocator::tryAllocate(size_t size)
+{
+    if (!m_isBmallocEnabled)
+        return malloc(size);
+
+    if (size <= largeMax)
+        return allocate(size);
+
+    std::lock_guard<StaticMutex> lock(PerProcess<Heap>::mutex());
+    return PerProcess<Heap>::get()->tryAllocateXLarge(lock, superChunkSize, roundUpToMultipleOf<xLargeAlignment>(size));
+}
+
 void* Allocator::allocate(size_t alignment, size_t size)
 {
     BASSERT(isPowerOfTwo(alignment));
index daea0c7..85b1c17 100644 (file)
@@ -41,6 +41,7 @@ public:
     Allocator(Heap*, Deallocator&);
     ~Allocator();
 
+    void* tryAllocate(size_t);
     void* allocate(size_t);
     void* allocate(size_t alignment, size_t);
     void* reallocate(void*, size_t);
index b5b00d9..2fc7036 100644 (file)
@@ -56,6 +56,11 @@ Cache::Cache()
 {
 }
 
+NO_INLINE void* Cache::tryAllocateSlowCaseNullCache(size_t size)
+{
+    return PerThread<Cache>::getSlowCase()->allocator().tryAllocate(size);
+}
+
 NO_INLINE void* Cache::allocateSlowCaseNullCache(size_t size)
 {
     return PerThread<Cache>::getSlowCase()->allocator().allocate(size);
index 472c5df..8a74343 100644 (file)
@@ -39,10 +39,12 @@ public:
     void* operator new(size_t);
     void operator delete(void*, size_t);
 
+    static void* tryAllocate(size_t);
     static void* allocate(size_t);
     static void* allocate(size_t alignment, size_t);
     static void deallocate(void*);
     static void* reallocate(void*, size_t);
+
     static void scavenge();
 
     Cache();
@@ -51,6 +53,7 @@ public:
     Deallocator& deallocator() { return m_deallocator; }
 
 private:
+    static void* tryAllocateSlowCaseNullCache(size_t);
     static void* allocateSlowCaseNullCache(size_t);
     static void* allocateSlowCaseNullCache(size_t alignment, size_t);
     static void deallocateSlowCaseNullCache(void*);
@@ -60,6 +63,14 @@ private:
     Allocator m_allocator;
 };
 
+inline void* Cache::tryAllocate(size_t size)
+{
+    Cache* cache = PerThread<Cache>::getFastCase();
+    if (!cache)
+        return tryAllocateSlowCaseNullCache(size);
+    return cache->allocator().tryAllocate(size);
+}
+
 inline void* Cache::allocate(size_t size)
 {
     Cache* cache = PerThread<Cache>::getFastCase();
index 6502a74..ae7d709 100644 (file)
@@ -281,14 +281,10 @@ void Heap::deallocateMediumLine(std::lock_guard<StaticMutex>& lock, MediumLine*
     }
 }
 
-void* Heap::allocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t size)
+void* Heap::allocateXLarge(std::lock_guard<StaticMutex>& lock, size_t alignment, size_t size)
 {
-    BASSERT(isPowerOfTwo(alignment));
-    BASSERT(alignment >= xLargeAlignment);
-    BASSERT(size == roundUpToMultipleOf<xLargeAlignment>(size));
-
-    void* result = vmAllocate(alignment, size);
-    m_xLargeObjects.push(Range(result, size));
+    void* result = tryAllocateXLarge(lock, alignment, size);
+    RELEASE_BASSERT(result);
     return result;
 }
 
@@ -297,6 +293,19 @@ void* Heap::allocateXLarge(std::lock_guard<StaticMutex>& lock, size_t size)
     return allocateXLarge(lock, superChunkSize, size);
 }
 
+void* Heap::tryAllocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t size)
+{
+    BASSERT(isPowerOfTwo(alignment));
+    BASSERT(alignment >= superChunkSize);
+    BASSERT(size == roundUpToMultipleOf<xLargeAlignment>(size));
+
+    void* result = tryVMAllocate(alignment, size);
+    if (!result)
+        return nullptr;
+    m_xLargeObjects.push(Range(result, size));
+    return result;
+}
+
 Range Heap::findXLarge(std::lock_guard<StaticMutex>&, void* object)
 {
     for (auto& range : m_xLargeObjects) {
index b3a80c0..3f61462 100644 (file)
@@ -65,6 +65,7 @@ public:
 
     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t);
     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t);
+    void* tryAllocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t);
     Range findXLarge(std::lock_guard<StaticMutex>&, void*);
     void deallocateXLarge(std::unique_lock<StaticMutex>&, void*);
 
index 31f79b4..d9d0a9c 100644 (file)
@@ -73,11 +73,19 @@ inline void vmValidate(void* p, size_t vmSize)
     BASSERT(p == mask(p, ~(getpagesize() - 1)));
 }
 
-inline void* vmAllocate(size_t vmSize)
+inline void* tryVMAllocate(size_t vmSize)
 {
     vmValidate(vmSize);
     void* result = mmap(0, vmSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, BMALLOC_VM_TAG, 0);
-    RELEASE_BASSERT(result != MAP_FAILED);
+    if (result == MAP_FAILED)
+        return nullptr;
+    return result;
+}
+
+inline void* vmAllocate(size_t vmSize)
+{
+    void* result = tryVMAllocate(vmSize);
+    RELEASE_BASSERT(result);
     return result;
 }
 
@@ -90,13 +98,15 @@ inline void vmDeallocate(void* p, size_t vmSize)
 // Allocates vmSize bytes at a specified power-of-two alignment.
 // Use this function to create maskable memory regions.
 
-inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
+inline void* tryVMAllocate(size_t vmAlignment, size_t vmSize)
 {
     vmValidate(vmSize);
     vmValidate(vmAlignment);
 
     size_t mappedSize = std::max(vmSize, vmAlignment) + vmAlignment;
-    char* mapped = static_cast<char*>(vmAllocate(mappedSize));
+    char* mapped = static_cast<char*>(tryVMAllocate(mappedSize));
+    if (!mapped)
+        return nullptr;
     char* mappedEnd = mapped + mappedSize;
 
     char* aligned = roundUpToMultipleOf(vmAlignment, mapped);
@@ -111,6 +121,13 @@ inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
     return aligned;
 }
 
+inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
+{
+    void* result = tryVMAllocate(vmAlignment, vmSize);
+    RELEASE_BASSERT(result);
+    return result;
+}
+
 inline void vmDeallocatePhysicalPages(void* p, size_t vmSize)
 {
     vmValidate(p, vmSize);
index e2861c1..db8ce26 100644 (file)
 namespace bmalloc {
 namespace api {
 
+// Returns null on failure.
+inline void* tryMalloc(size_t size)
+{
+    return Cache::tryAllocate(size);
+}
+
+// Crashes on failure.
 inline void* malloc(size_t size)
 {
     return Cache::allocate(size);
 }
 
+// Crashes on failure.
 inline void* memalign(size_t alignment, size_t size)
 {
     return Cache::allocate(alignment, size);
 }
 
-inline void free(void* object)
+// Crashes on failure.
+inline void* realloc(void* object, size_t newSize)
 {
-    Cache::deallocate(object);
+    return Cache::reallocate(object, newSize);
 }
 
-inline void* realloc(void* object, size_t newSize)
+inline void free(void* object)
 {
-    return Cache::reallocate(object, newSize);
+    Cache::deallocate(object);
 }
 
 inline void scavengeThisThread()