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

headers/private/libroot/libroot_private.h

@@ -36 +36 @@
 void __init_env_post_heap(void);
 status_t __init_heap(void);
 void __heap_terminate_after(void);
+void __heap_before_fork(void);
+void __heap_after_fork_child(void);
+void __heap_after_fork_parent(void);
 
 void __init_time(addr_t commPageTable);
 void __arch_init_time(struct real_time_data *data, bool setDefaults);

headers/private/libroot/user_thread.h

@@ -12 +12 @@
 #include <user_thread_defs.h>
 
 
-static inline user_thread*
+static inline struct user_thread*
 get_user_thread()
 {
-    return (user_thread*)tls_get(TLS_USER_THREAD_SLOT);
+    return (struct user_thread*)tls_get(TLS_USER_THREAD_SLOT);
 }
 
 
@@ -29 +29 @@
 static void inline
 undefer_signals()
 {
-    user_thread* thread = get_user_thread();
+    struct user_thread* thread = get_user_thread();
     if (--thread->defer_signals == 0 && thread->pending_signals != 0) {
         // signals shall no longer be deferred -- call a dummy syscall to handle
         // the pending ones

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

@@ -67 +67 @@
 static free_chunk *sFreeChunks;
 
 
-static void
-init_after_fork(void)
+void
+__init_after_fork(void)
 {
     // find the heap area
     sHeapArea = area_for((void*)sFreeHeapBase);
@@ -110 +110 @@
 
     hoardLockInit(sHeapLock, "heap");
 
-    atfork(&init_after_fork);
-        // 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 @@
 }
 
 
+extern "C" 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);
+
+extern "C" 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();
+}
+
+
+extern "C" 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
 
 

src/system/libroot/posix/malloc_debug/malloc_debug_api.cpp

@@ -202 +202 @@
 }
 
 
+extern "C" void
+__heap_before_fork(void)
+{
+}
+
+
+extern "C" void
+__heap_after_fork_child(void)
+{
+}
+
+
+extern "C" void
+__heap_after_fork_parent(void)
+{
+}
+
+
 // #pragma mark - Public API
 
 

src/system/libroot/posix/unistd/fork.c

@@ -16 +16 @@
 #include <pthread_private.h>
 #include <runtime_loader.h>
 #include <syscalls.h>
+#include <user_thread.h>
 
 
 typedef struct fork_hook {
@@ -105 +106 @@
 status_t
 __register_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void))
 {
+    defer_signals();
+
     status_t status = mutex_lock(&sForkLock);
-    if (status != B_OK)
+    if (status != B_OK) {
+        undefer_signals();
         return status;
+    }
 
     if (prepare)
         status = add_fork_hook(&sPrepareHooks, NULL, prepare);
@@ -119 +124 @@
         status = add_fork_hook(&sChildHooks, &sLastChildHook, child);
 
     mutex_unlock(&sForkLock);
+
+    undefer_signals();
+
     return status;
 }
 
@@ -129 +137 @@
     thread_id thread;
     status_t status;
 
+    defer_signals();
+
     status = mutex_lock(&sForkLock);
-    if (status != B_OK)
+    if (status != B_OK) {
+        undefer_signals();
         return status;
+    }
 
     // call preparation hooks
     call_fork_hooks(sPrepareHooks);
+    __heap_before_fork();
 
     thread = _kern_fork();
     if (thread < 0) {
         // something went wrong
+        undefer_signals();
         mutex_unlock(&sForkLock);
         __set_errno(thread);
         return -1;
@@ -155 +169 @@
             // process we should make sure that it is in a consistent state when
             // calling the kernel.
         __gRuntimeLoader->reinit_after_fork();
+        __heap_after_fork_child();
         __reinit_pwd_backend_after_fork();
 
         call_fork_hooks(sChildHooks);
     } else {
         // we are the parent
+        __heap_after_fork_parent();
         call_fork_hooks(sParentHooks);
         mutex_unlock(&sForkLock);
     }
 
+    undefer_signals();
+
     return thread;
 }