Commit 77fdeb6fa08 for nodejs
commit 77fdeb6fa089b1261c34c1576056f3f4ae1680b5
Author: Manzoor Wani <manzoorwani.jk@gmail.com>
Date: Sat Nov 21 02:35:09 2026 +0530
src: fix hang when joining workers in process.exit()
V8 background jobs, such as concurrent Sparkplug and Maglev compiles,
can run into the heap limit. They then post a GC request to the main
thread and park in CollectionBarrier::AwaitCollectionBackground()
until the main thread collects garbage or the isolate is torn down.
process.exit() does neither. DefaultProcessExitHandlerInternal()
calls DisposePlatform() while the isolate is still alive and not
running JS, and NodePlatform::Shutdown() joins the worker threads.
A worker that is parked at that point never wakes up, and the join
hangs forever.
Pass the exiting isolate down to NodePlatform::Shutdown(). While the
workers finish their current tasks, the main thread checks every
10ms whether a foreground task was posted for that isolate. If so,
it drops the queued tasks, which would never run on this path, and
performs a GC so that the parked workers can finish. Normal exits
dispose the isolate before the platform and are not affected.
Fixes: https://github.com/nodejs/node/issues/64274
Signed-off-by: Manzoor Wani <manzoorwani.jk@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/66171
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
diff --git a/src/api/environment.cc b/src/api/environment.cc
index 4a7b70168e6..841cb805acc 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -1179,7 +1179,8 @@ void DefaultProcessExitHandlerInternal(Environment* env, ExitCode exit_code) {
// And make sure V8Platform don not call into Libuv threadpool, see Dispose
// in node_v8_platform-inl.h
uv_library_shutdown();
- DisposePlatform();
+ // The isolate is not disposed on this path, see NodePlatform::Shutdown().
+ DisposePlatform(env->isolate());
#if HAVE_OPENSSL
crypto::CleanupCachedRootCertificates();
diff --git a/src/node_platform.cc b/src/node_platform.cc
index ff4b139a72e..5dfa8c85118 100644
--- a/src/node_platform.cc
+++ b/src/node_platform.cc
@@ -22,6 +22,9 @@ struct PlatformWorkerData {
Mutex* platform_workers_mutex;
ConditionVariable* platform_workers_ready;
int* pending_platform_workers;
+ Mutex* running_workers_mutex;
+ ConditionVariable* worker_exited;
+ int* running_workers;
int id;
PlatformDebugLogLevel debug_log_level;
};
@@ -83,6 +86,11 @@ static void PlatformWorkerThread(void* data) {
pending_worker_tasks->Lock().NotifyOfOutstandingCompletion();
}
}
+
+ // See WorkerThreadsTaskRunner::Shutdown().
+ Mutex::ScopedLock lock(*worker_data->running_workers_mutex);
+ (*worker_data->running_workers)--;
+ worker_data->worker_exited->Signal(lock);
}
static int GetActualThreadPoolSize(int thread_pool_size) {
@@ -261,6 +269,9 @@ WorkerThreadsTaskRunner::WorkerThreadsTaskRunner(
&platform_workers_mutex,
&platform_workers_ready,
&pending_platform_workers,
+ &running_workers_mutex_,
+ &worker_exited_,
+ &running_workers_,
i,
debug_log_level_});
std::unique_ptr<uv_thread_t> t { new uv_thread_t() };
@@ -270,6 +281,8 @@ WorkerThreadsTaskRunner::WorkerThreadsTaskRunner(
}
worker_data.release();
threads_.push_back(std::move(t));
+ Mutex::ScopedLock running_lock(running_workers_mutex_);
+ running_workers_++;
}
// Wait for platform workers to initialize before continuing with the
@@ -300,9 +313,22 @@ void WorkerThreadsTaskRunner::BlockingDrain() {
pending_worker_tasks_.Lock().BlockingDrain();
}
-void WorkerThreadsTaskRunner::Shutdown() {
+void WorkerThreadsTaskRunner::Shutdown(
+ const std::function<void()>& on_stalled) {
pending_worker_tasks_.Lock().Stop();
delayed_task_scheduler_->Stop();
+ if (on_stalled) {
+ /* Workers take no new tasks after Stop(), so this only waits for the
+ * tasks that are already running. */
+ constexpr uint64_t kStalledTimeoutNs = 10 * 1000 * 1000;
+ Mutex::ScopedLock lock(running_workers_mutex_);
+ while (running_workers_ > 0) {
+ if (worker_exited_.TimedWait(lock, kStalledTimeoutNs) == UV_ETIMEDOUT) {
+ Mutex::ScopedUnlock unlock(lock);
+ on_stalled();
+ }
+ }
+ }
for (size_t i = 0; i < threads_.size(); i++) {
CHECK_EQ(0, uv_thread_join(threads_[i].get()));
}
@@ -523,10 +549,27 @@ void NodePlatform::AddIsolateFinishedCallback(Isolate* isolate,
it->second.second->AddShutdownCallback(cb, data);
}
-void NodePlatform::Shutdown() {
+void NodePlatform::Shutdown(Isolate* isolate) {
if (has_shut_down_) return;
has_shut_down_ = true;
- worker_thread_task_runner_->Shutdown();
+ std::shared_ptr<PerIsolatePlatformData> per_isolate;
+ if (isolate != nullptr) {
+ Mutex::ScopedLock lock(per_isolate_mutex_);
+ auto it = per_isolate_.find(isolate);
+ if (it != per_isolate_.end()) per_isolate = it->second.second;
+ }
+ if (per_isolate) {
+ worker_thread_task_runner_->Shutdown([&]() {
+ /* V8 posts a foreground task when a worker has to wait for a GC, but
+ * the isolate will not run its tasks or be torn down anymore, so do the
+ * GC here. Discarding the tasks lets the next request be told apart. */
+ if (per_isolate->DiscardForegroundTasks()) {
+ isolate->LowMemoryNotification();
+ }
+ });
+ } else {
+ worker_thread_task_runner_->Shutdown();
+ }
{
Mutex::ScopedLock lock(per_isolate_mutex_);
@@ -604,6 +647,13 @@ void NodePlatform::DrainTasks(Isolate* isolate) {
} while (per_isolate->FlushForegroundTasksInternal());
}
+bool PerIsolatePlatformData::DiscardForegroundTasks() {
+ // Destroy the tasks after releasing the queue lock.
+ std::vector<std::unique_ptr<TaskQueueEntry>> tasks =
+ foreground_tasks_.Lock().PopAll();
+ return !tasks.empty();
+}
+
bool PerIsolatePlatformData::FlushForegroundTasksInternal() {
bool did_work = false;
diff --git a/src/node_platform.h b/src/node_platform.h
index 52e3e629bc0..2e89d1facb7 100644
--- a/src/node_platform.h
+++ b/src/node_platform.h
@@ -134,6 +134,8 @@ class PerIsolatePlatformData
// posted during flushing of the queue are postponed until the next
// flushing.
bool FlushForegroundTasksInternal();
+ // Drops the queued foreground tasks. Returns true if there were any.
+ bool DiscardForegroundTasks();
const uv_loop_t* event_loop() const { return loop_; }
@@ -202,7 +204,9 @@ class WorkerThreadsTaskRunner {
double delay_in_seconds);
void BlockingDrain();
- void Shutdown();
+ /* `on_stalled` runs on the calling thread whenever the workers have not
+ * finished their current tasks for a while. */
+ void Shutdown(const std::function<void()>& on_stalled = nullptr);
int NumberOfWorkerThreads() const;
@@ -221,6 +225,10 @@ class WorkerThreadsTaskRunner {
std::unique_ptr<DelayedTaskScheduler> delayed_task_scheduler_;
std::vector<std::unique_ptr<uv_thread_t>> threads_;
+ // Number of platform worker threads that have not exited yet.
+ Mutex running_workers_mutex_;
+ ConditionVariable worker_exited_;
+ int running_workers_ = 0;
PlatformDebugLogLevel debug_log_level_ = PlatformDebugLogLevel::kNone;
};
@@ -232,7 +240,9 @@ class NodePlatform : public MultiIsolatePlatform {
~NodePlatform() override;
void DrainTasks(v8::Isolate* isolate) override;
- void Shutdown();
+ /* Pass the isolate that the calling thread is running when it will not be
+ * disposed first, so that tasks waiting for it to collect garbage can end. */
+ void Shutdown(v8::Isolate* isolate = nullptr);
// v8::Platform implementation.
int NumberOfWorkerThreads() override;
diff --git a/src/node_v8_platform-inl.h b/src/node_v8_platform-inl.h
index 0538b5feeb5..82539c846af 100644
--- a/src/node_v8_platform-inl.h
+++ b/src/node_v8_platform-inl.h
@@ -32,12 +32,12 @@ struct V8Platform {
}
// Make sure V8Platform don not call into Libuv threadpool,
// see DefaultProcessExitHandlerInternal in environment.cc
- inline void Dispose() {
+ inline void Dispose(v8::Isolate* isolate = nullptr) {
if (!initialized_)
return;
initialized_ = false;
StopTracingAgent();
- platform_->Shutdown();
+ platform_->Shutdown(isolate);
platform_.reset();
// Destroy tracing after the platform (and platform threads) have been
// stopped.
@@ -67,7 +67,7 @@ struct V8Platform {
std::unique_ptr<NodePlatform> platform_;
#else // !NODE_USE_V8_PLATFORM
inline void Initialize(int thread_pool_size) {}
- inline void Dispose() {}
+ inline void Dispose(v8::Isolate* isolate = nullptr) {}
inline void DrainVMTasks(v8::Isolate* isolate) {}
inline void StartTracingAgent() {
if (!per_process::cli_options->trace_event_categories.empty()) {
@@ -86,8 +86,9 @@ namespace per_process {
extern struct V8Platform v8_platform;
}
-inline void DisposePlatform() {
- per_process::v8_platform.Dispose();
+// See NodePlatform::Shutdown() for `isolate`.
+inline void DisposePlatform(v8::Isolate* isolate = nullptr) {
+ per_process::v8_platform.Dispose(isolate);
}
} // namespace node
diff --git a/test/parallel/test-process-exit-background-gc.js b/test/parallel/test-process-exit-background-gc.js
new file mode 100644
index 00000000000..5e88c290333
--- /dev/null
+++ b/test/parallel/test-process-exit-background-gc.js
@@ -0,0 +1,32 @@
+// Flags: --stress-concurrent-allocation
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto) { common.skip('missing crypto'); }
+
+// Regression test for https://github.com/nodejs/node/issues/64274.
+// process.exit() joined the V8 platform workers while one was parked
+// waiting for a GC that the main thread no longer performs.
+
+const { pbkdf2, pbkdf2Sync } = require('crypto');
+
+// A small live set keeps the old generation limit low.
+const keep = [];
+for (let i = 0; i < 1e5; i++) keep.push({ i });
+
+// Pick an iteration count that keeps the threadpool busy for about a second.
+const probeIterations = 2e5;
+const start = process.hrtime.bigint();
+pbkdf2Sync('a', 'b', probeIterations, 64, 'sha512');
+const nsPerIteration = Number(process.hrtime.bigint() - start) /
+ probeIterations;
+const iterations = Math.ceil(1e9 / nsPerIteration);
+
+setTimeout(() => {
+ // uv_library_shutdown() waits for this job, so the main thread stays out of
+ // JS and cannot serve the GC that the stress allocation task asks for.
+ pbkdf2('a', 'b', iterations, 64, 'sha512', () => {});
+ // Use up the old generation budget, so that the next background allocation
+ // fails and parks that task in CollectionBarrier.
+ for (let i = 0; i < 40; i++) new Array(1e5).fill(i);
+ process.exit(0);
+}, 300);