From 63f0e77f1ebaef803c18ed458b05f8e3d74af419 Mon Sep 17 00:00:00 2001
From: Ali Ijaz Sheikh <ofrobots@google.com>
Date: Wed, 26 Sep 2018 15:58:45 -0700
Subject: [PATCH] src: ready background workers before bootstrap

Make sure background workers are ready before proceeding with the
bootstrap or post-bootstrap execution of any code that may trigger
`process.exit()`.

Fixes: https://github.com/nodejs/node/issues/23065

PR-URL: https://github.com/nodejs/node/pull/23233
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_platform.cc | 36 ++++++++++++++++++++++++++++++++++--
 src/node_platform.h  |  5 +++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/node_platform.cc b/src/node_platform.cc
index 2dcd7320426dad..03ef07eb1c65a6 100644
--- a/src/node_platform.cc
+++ b/src/node_platform.cc
@@ -16,10 +16,28 @@ using v8::Platform;
 using v8::Task;
 using v8::TracingController;
 
+struct PlatformWorkerData {
+  TaskQueue<Task>* task_queue;
+  Mutex* platform_workers_mutex;
+  ConditionVariable* platform_workers_ready;
+  int* pending_platform_workers;
+  int id;
+};
+
 static void BackgroundRunner(void* data) {
+  std::unique_ptr<PlatformWorkerData>
+      worker_data(static_cast<PlatformWorkerData*>(data));
   TRACE_EVENT_METADATA1("__metadata", "thread_name", "name",
                         "BackgroundTaskRunner");
-  TaskQueue<Task> *background_tasks = static_cast<TaskQueue<Task> *>(data);
+
+  // Notify the main thread that the platform worker is ready.
+  {
+    Mutex::ScopedLock lock(*worker_data->platform_workers_mutex);
+    (*worker_data->pending_platform_workers)--;
+    worker_data->platform_workers_ready->Signal(lock);
+  }
+
+  TaskQueue<Task>* background_tasks = worker_data->task_queue;
   while (std::unique_ptr<Task> task = background_tasks->BlockingPop()) {
     task->Run();
     background_tasks->NotifyOfCompletion();
@@ -144,15 +162,29 @@ class BackgroundTaskRunner::DelayedTaskScheduler {
 };
 
 BackgroundTaskRunner::BackgroundTaskRunner(int thread_pool_size) {
+  Mutex::ScopedLock lock(platform_workers_mutex_);
+  pending_platform_workers_ = thread_pool_size;
+
   delayed_task_scheduler_.reset(
       new DelayedTaskScheduler(&background_tasks_));
   threads_.push_back(delayed_task_scheduler_->Start());
+
   for (int i = 0; i < thread_pool_size; i++) {
+    PlatformWorkerData* worker_data = new PlatformWorkerData{
+      &background_tasks_, &platform_workers_mutex_,
+      &platform_workers_ready_, &pending_platform_workers_, i
+    };
     std::unique_ptr<uv_thread_t> t { new uv_thread_t() };
-    if (uv_thread_create(t.get(), BackgroundRunner, &background_tasks_) != 0)
+    if (uv_thread_create(t.get(), BackgroundRunner, worker_data) != 0)
       break;
     threads_.push_back(std::move(t));
   }
+
+  // Wait for platform workers to initialize before continuing with the
+  // bootstrap.
+  while (pending_platform_workers_ > 0) {
+    platform_workers_ready_.Wait(lock);
+  }
 }
 
 void BackgroundTaskRunner::PostTask(std::unique_ptr<Task> task) {
diff --git a/src/node_platform.h b/src/node_platform.h
index c2b5d6a5f9c704..8359119c2f0c7b 100644
--- a/src/node_platform.h
+++ b/src/node_platform.h
@@ -110,6 +110,7 @@ class BackgroundTaskRunner : public v8::TaskRunner {
   void Shutdown();
 
   size_t NumberOfAvailableBackgroundThreads() const;
+
  private:
   TaskQueue<v8::Task> background_tasks_;
 
@@ -117,6 +118,10 @@ class BackgroundTaskRunner : public v8::TaskRunner {
   std::unique_ptr<DelayedTaskScheduler> delayed_task_scheduler_;
 
   std::vector<std::unique_ptr<uv_thread_t>> threads_;
+
+  Mutex platform_workers_mutex_;
+  ConditionVariable platform_workers_ready_;
+  int pending_platform_workers_;
 };
 
 class NodePlatform : public MultiIsolatePlatform {