src: split ownsProcessState off isMainThread

Embedders may want to control whether a Node.js instance
controls the current process, similar to what we currently
have with `Worker`s.

Previously, the `isMainThread` flag had a bit of a double usage,
both for indicating whether we are (not) running a Worker and
whether we can modify per-process state.

PR-URL: #25881
Reviewed-By: Colin Ihrig <[email protected]>
Reviewed-By: Joyee Cheung <[email protected]>
Reviewed-By: James M Snell <[email protected]>

Author: addaleax

lib/internal/bootstrap/node.js

@@ -14,7 +14,7 @@
 
 // This file is compiled as if it's wrapped in a function with arguments
 // passed by node::LoadEnvironment()
-/* global process, loaderExports, isMainThread */
+/* global process, loaderExports, isMainThread, ownsProcessState */
 
 const { internalBinding, NativeModule } = loaderExports;
 
@@ -51,7 +51,7 @@ const perThreadSetup = NativeModule.require('internal/process/per_thread');
 let mainThreadSetup;
 // Bootstrappers for the worker threads only
 let workerThreadSetup;
-if (isMainThread) {
+if (ownsProcessState) {
   mainThreadSetup = NativeModule.require(
     'internal/process/main_thread_only'
   );
@@ -140,7 +140,7 @@ if (credentials.implementsPosixCredentials) {
   process.getegid = credentials.getegid;
   process.getgroups = credentials.getgroups;
 
-  if (isMainThread) {
+  if (ownsProcessState) {
     const wrapped = mainThreadSetup.wrapPosixCredentialSetters(credentials);
     process.initgroups = wrapped.initgroups;
     process.setgroups = wrapped.setgroups;

lib/internal/worker.js

@@ -30,9 +30,10 @@ const { deserializeError } = require('internal/error-serdes');
 const { pathToFileURL } = require('url');
 
 const {
-  Worker: WorkerImpl,
+  ownsProcessState,
+  isMainThread,
   threadId,
-  isMainThread
+  Worker: WorkerImpl,
 } = internalBinding('worker');
 
 const kHandle = Symbol('kHandle');
@@ -251,7 +252,8 @@ function pipeWithoutWarning(source, dest) {
 }
 
 module.exports = {
+  ownsProcessState,
+  isMainThread,
   threadId,
   Worker,
-  isMainThread
 };

lib/trace_events.js

@@ -13,8 +13,8 @@ const {
   ERR_INVALID_ARG_TYPE
 } = require('internal/errors').codes;
 
-const { isMainThread } = require('internal/worker');
-if (!hasTracing || !isMainThread)
+const { ownsProcessState } = require('internal/worker');
+if (!hasTracing || !ownsProcessState)
   throw new ERR_TRACE_EVENTS_UNAVAILABLE();
 
 const { CategorySet, getEnabledCategories } = internalBinding('trace_events');

src/api/environment.cc

@@ -134,8 +134,12 @@ Environment* CreateEnvironment(IsolateData* isolate_data,
   std::vector<std::string> args(argv, argv + argc);
   std::vector<std::string> exec_args(exec_argv, exec_argv + exec_argc);
   // TODO(addaleax): Provide more sensible flags, in an embedder-accessible way.
-  Environment* env =
-      new Environment(isolate_data, context, Environment::kIsMainThread);
+  Environment* env = new Environment(
+      isolate_data,
+      context,
+      static_cast<Environment::Flags>(Environment::kIsMainThread |
+                                      Environment::kOwnsProcessState |
+                                      Environment::kOwnsInspector));
   env->Start(per_process::v8_is_profiling);
   env->ProcessCliArgs(args, exec_args);
   return env;

src/env-inl.h

@@ -650,6 +650,14 @@ inline bool Environment::is_main_thread() const {
   return flags_ & kIsMainThread;
 }
 
+inline bool Environment::owns_process_state() const {
+  return flags_ & kOwnsProcessState;
+}
+
+inline bool Environment::owns_inspector() const {
+  return flags_ & kOwnsInspector;
+}
+
 inline uint64_t Environment::thread_id() const {
   return thread_id_;
 }

src/env.cc

@@ -142,7 +142,7 @@ void InitThreadLocalOnce() {
 }
 
 void Environment::TrackingTraceStateObserver::UpdateTraceCategoryState() {
-  if (!env_->is_main_thread()) {
+  if (!env_->owns_process_state()) {
     // Ideally, we’d have a consistent story that treats all threads/Environment
     // instances equally here. However, tracing is essentially global, and this
     // callback is called from whichever thread calls `StartTracing()` or

src/env.h

@@ -597,7 +597,9 @@ class Environment {
 
   enum Flags {
     kNoFlags = 0,
-    kIsMainThread = 1
+    kIsMainThread = 1 << 0,
+    kOwnsProcessState = 1 << 1,
+    kOwnsInspector = 1 << 2,
   };
 
   static inline Environment* GetCurrent(v8::Isolate* isolate);
@@ -766,6 +768,8 @@ class Environment {
   inline void set_has_run_bootstrapping_code(bool has_run_bootstrapping_code);
 
   inline bool is_main_thread() const;
+  inline bool owns_process_state() const;
+  inline bool owns_inspector() const;
   inline uint64_t thread_id() const;
   inline worker::Worker* worker_context() const;
   inline void set_worker_context(worker::Worker* context);

src/inspector/tracing_agent.cc

@@ -141,7 +141,7 @@ DispatchResponse TracingAgent::start(
     return DispatchResponse::Error(
         "Call NodeTracing::end to stop tracing before updating the config");
   }
-  if (!env_->is_main_thread()) {
+  if (!env_->owns_process_state()) {
     return DispatchResponse::Error(
         "Tracing properties can only be changed through main thread sessions");
   }

src/inspector_agent.cc

@@ -686,7 +686,7 @@ bool Agent::Start(const std::string& path,
   host_port_ = host_port;
 
   client_ = std::make_shared<NodeInspectorClient>(parent_env_, is_main);
-  if (parent_env_->is_main_thread()) {
+  if (parent_env_->owns_inspector()) {
     CHECK_EQ(start_io_thread_async_initialized.exchange(true), false);
     CHECK_EQ(0, uv_async_init(parent_env_->event_loop(),
                               &start_io_thread_async,

src/node.cc

@@ -318,16 +318,18 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
       loader_exports_obj->Get(context, env->require_string()).ToLocalChecked();
   env->set_native_module_require(require.As<Function>());
 
-  // process, loaderExports, isMainThread
+  // process, loaderExports, isMainThread, ownsProcessState, primordials
   std::vector<Local<String>> node_params = {
       env->process_string(),
       FIXED_ONE_BYTE_STRING(isolate, "loaderExports"),
       FIXED_ONE_BYTE_STRING(isolate, "isMainThread"),
+      FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
       env->primordials_string()};
   std::vector<Local<Value>> node_args = {
       process,
       loader_exports_obj,
       Boolean::New(isolate, env->is_main_thread()),
+      Boolean::New(isolate, env->owns_process_state()),
       env->primordials()};
 
   MaybeLocal<Value> result = ExecuteBootstrapper(
@@ -756,7 +758,12 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
   HandleScope handle_scope(isolate);
   Local<Context> context = NewContext(isolate);
   Context::Scope context_scope(context);
-  Environment env(isolate_data, context, Environment::kIsMainThread);
+  Environment env(
+      isolate_data,
+      context,
+      static_cast<Environment::Flags>(Environment::kIsMainThread |
+                                      Environment::kOwnsProcessState |
+                                      Environment::kOwnsInspector));
   env.Start(per_process::v8_is_profiling);
   env.ProcessCliArgs(args, exec_args);