Ticket #13111: fork-heap-locks-handling-2.patch

src/system/libroot/posix/malloc/arch-specific.cpp

@@ -67 +67 @@
 static free_chunk *sFreeChunks;
 
 
-static void
-init_after_fork(void)
+void __heap_before_fork(void);
+void __heap_after_fork_child(void);
+void __heap_after_fork_parent(void);
+
+
+void
+__init_after_fork(void)
 {
     // find the heap area
     sHeapArea = area_for((void*)sFreeHeapBase);
@@ -110 +115 @@
 
     hoardLockInit(sHeapLock, "heap");
 
-    atfork(&init_after_fork);
+    pthread_atfork(&__heap_before_fork, &__heap_after_fork_parent,
+        &__heap_after_fork_child);
         // Note: Needs malloc(). Hence we need to be fully initialized.
-        // TODO: We should actually also install a hook that is called before
-        // fork() is being executed. In a multithreaded app it would need to
-        // acquire *all* allocator locks, so that we don't fork() an
-        // inconsistent state.
 
     return B_OK;
 }

src/system/libroot/posix/malloc/heap.cpp

@@ -132 +132 @@
     , _magic(HEAP_MAGIC)
 #endif
 {
-    // Initialize the per-heap lock.
-    hoardLockInit(_lock, "hoard heap");
+    initLock();
 
     for (int i = 0; i < SUPERBLOCK_FULLNESS_GROUP; i++) {
         for (int j = 0; j < SIZE_CLASSES; j++) {

src/system/libroot/posix/malloc/heap.h

@@ -115 +115 @@
         // Unlock this heap.
         inline void unlock(void);
 
+        // Init this heap lock.
+        inline void initLock(void);
+
         // Set our index number (which heap we are).
         inline void setIndex(int i);
 
@@ -444 +447 @@
 }
 
 
+void
+hoardHeap::initLock(void)
+{
+    // Initialize the per-heap lock.
+    hoardLockInit(_lock, "hoard heap");
+}
+
+
 size_t
 hoardHeap::align(const size_t sz)
 {

src/system/libroot/posix/malloc/processheap.h

@@ -67 +67 @@
         // Get a thread heap index.
         inline int getHeapIndex(void);
 
+        // Get thread heap max.
+        inline int getMaxThreadHeaps(void);
+
         // Get the thread heap with index i.
         inline HEAPTYPE & getHeap(int i);
 
@@ -199 +202 @@
 }
 
 
+// Return the maximum number of heaps.
+
+int
+processHeap::getMaxThreadHeaps(void)
+{
+    return fMaxThreadHeaps;
+}
+
+
 superblock *
 processHeap::acquire(const int sizeclass, hoardHeap * dest)
 {

src/system/libroot/posix/malloc/wrapper.cpp

@@ -256 +256 @@
 }
 
 
+void
+__heap_before_fork(void)
+{
+    static processHeap *pHeap = getAllocator();
+    for (int i = 0; i < pHeap->getMaxThreadHeaps(); i++)
+        pHeap->getHeap(i).lock();
+}
+
+
+void __init_after_fork(void);
+
+void
+__heap_after_fork_child(void)
+{
+    __init_after_fork();
+    static processHeap *pHeap = getAllocator();
+    for (int i = 0; i < pHeap->getMaxThreadHeaps(); i++)
+        pHeap->getHeap(i).initLock();
+}
+
+
+void
+__heap_after_fork_parent(void)
+{
+    static processHeap *pHeap = getAllocator();
+    for (int i = 0; i < pHeap->getMaxThreadHeaps(); i++)
+        pHeap->getHeap(i).unlock();
+}
+
+
 //  #pragma mark - public functions