Make helper-thread spawn failures non-fatal

Source/JavaScriptCore/heap/Heap.cpp

@@ -2257,8 +2257,15 @@
     sanitizeStackForVM(vm());
 
     Locker locker { *m_threadLock };
-    if (!m_requests.isEmpty())
+    if (!m_requests.isEmpty()) {
         m_threadCondition->notifyOne(locker);
+        if (!m_thread->hasUnderlyingThread(locker)) [[unlikely]] {
+            // The collector thread couldn't spawn (pthread_create EAGAIN at a
+            // pids/thread limit). Take the conn back so the mutator drives the
+            // collection; otherwise waitForCollector() would park forever.
+            m_worldState.exchangeOr(mutatorHasConnBit);
+        }
+    }
     ParkingLot::unparkAll(&m_worldState);
 }
 

Source/JavaScriptCore/runtime/VMTraps.cpp

@@ -366,6 +366,12 @@ void VMTraps::initializeSignals()
     if (!Options::usePollingTraps()) {
         ASSERT(Options::useJIT());
         SignalSender::initializeSignals();
+        // Create the signal-sender WorkQueue (and its backing thread) now,
+        // while the process still has thread-budget headroom, instead of on
+        // the first fireTrap() which may arrive after workers have consumed
+        // every slot of a cgroup pids.max budget. RunLoop::create() cannot
+        // recover from a failed Thread::create.
+        queue();
     }
 #endif
 }

Source/WTF/wtf/AutomaticThread.cpp

@@ -180,7 +180,7 @@
         break;
     }
 
-    Thread::create(
+    RefPtr<Thread> thread = Thread::tryCreate(
         name(),
         [=, this] () {
             if (verbose)
@@ -245,7 +245,15 @@
                 }
                 RELEASE_ASSERT(result == WorkResult::Continue);
             }
-        }, m_threadType, Thread::defaultQOS, Thread::defaultSchedulingPolicy, stackSpec)->detach();
+        }, m_threadType, Thread::defaultQOS, Thread::defaultSchedulingPolicy, stackSpec);
+    if (!thread) {
+        // pthread_create/_beginthreadex refused (e.g. EAGAIN at a thread/pids
+        // limit). Stay in the no-underlying-thread state so the next notify
+        // retries instead of bringing the whole process down.
+        m_hasUnderlyingThread = false;
+        return;
+    }
+    thread->detach();
 }
 
 void AutomaticThread::threadDidStart()

Source/WTF/wtf/Threading.cpp

@@ -313,6 +313,13 @@
 }
 
 Ref<Thread> Thread::create(ASCIILiteral name, Function<void()>&& entryPoint, ThreadType threadType, QOS qos, SchedulingPolicy schedulingPolicy, StackAllocationSpecification stackSpec)
+{
+    RefPtr<Thread> thread = tryCreate(name, WTF::move(entryPoint), threadType, qos, schedulingPolicy, stackSpec);
+    RELEASE_ASSERT_WITH_MESSAGE(thread, "Failed to create thread '%s'", name.characters());
+    return thread.releaseNonNull();
+}
+
+RefPtr<Thread> Thread::tryCreate(ASCIILiteral name, Function<void()>&& entryPoint, ThreadType threadType, QOS qos, SchedulingPolicy schedulingPolicy, StackAllocationSpecification stackSpec)
 {
     WTF::initialize();
 
@@ -327,8 +334,11 @@
             if (maybeSize)
                 stackSpec = StackAllocationSpecification::RequestSize(maybeSize.value());
         }
-        bool success = thread->establishHandle(context.get(), stackSpec, qos, schedulingPolicy);
-        RELEASE_ASSERT(success);
+        if (!thread->establishHandle(context.get(), stackSpec, qos, schedulingPolicy)) {
+            // Undo the speculative +1 for Thread::entryPoint; the locker's Ref drops the rest.
+            context->deref();
+            return nullptr;
+        }
 
 #if HAVE(STACK_BOUNDS_FOR_NEW_THREAD)
         thread->m_stack = StackBounds::newThreadStackBounds(thread->m_handle);

Source/WTF/wtf/Threading.h

@@ -134,10 +134,14 @@ class WTF_CAPABILITY("is current") Thread : public ThreadSafeRefCountedAndCanMak
     static dispatch_qos_class_t dispatchQOSClass(QOS);
 #endif
 
-    // Returns nullptr if thread creation failed.
     // The thread name must be a literal since on some platforms it's passed in to the thread.
+    // Aborts if the OS refuses to create the thread (resource limit, etc.).
     WTF_EXPORT_PRIVATE static Ref<Thread> create(ASCIILiteral threadName, Function<void()>&&, ThreadType = ThreadType::Unknown, QOS = defaultQOS, SchedulingPolicy = defaultSchedulingPolicy, StackAllocationSpecification = { });
 
+    // Returns nullptr if thread creation failed. The caller still owns entryPoint
+    // resources in that case (the moved Function is destroyed, its captures drop).
+    WTF_EXPORT_PRIVATE static RefPtr<Thread> tryCreate(ASCIILiteral threadName, Function<void()>&&, ThreadType = ThreadType::Unknown, QOS = defaultQOS, SchedulingPolicy = defaultSchedulingPolicy, StackAllocationSpecification = { });
+
     // Returns Thread object.
     static Thread& currentSingleton();
 

Source/bmalloc/libpas/src/libpas/pas_scavenger.c

@@ -521,8 +521,13 @@ void pas_scavenger_notify_eligibility_if_needed(void)
         int result;
         pas_scavenger_current_state = pas_scavenger_state_polling;
         result = pthread_create(&thread, NULL, scavenger_thread_main, NULL);
-        PAS_ASSERT(!result);
-        pthread_detach(thread);
+        if (PAS_LIKELY(!result))
+            pthread_detach(thread);
+        else {
+            /* EAGAIN at a thread/pids limit: leave memory unscavenged rather
+               than killing the process. The next did_create_eligible retries. */
+            pas_scavenger_current_state = pas_scavenger_state_no_thread;
+        }
     }
 
     if (pas_scavenger_current_state == pas_scavenger_state_deep_sleep) {