node_worker.cc

#include "node_worker.h"
#include "async_wrap-inl.h"
#include "debug_utils-inl.h"
#include "histogram-inl.h"
#include "memory_tracker-inl.h"
#include "node_buffer.h"
#include "node_errors.h"
#include "node_external_reference.h"
#include "node_options-inl.h"
#include "node_perf.h"
#include "node_profiling.h"
#include "node_snapshot_builder.h"
#include "permission/permission.h"
#include "util-inl.h"
#include "v8-cppgc.h"
#include "v8-profiler.h"

#include <memory>
#include <string>
#include <vector>

using node::kAllowedInEnvvar;
using node::kDisallowedInEnvvar;
using v8::Array;
using v8::ArrayBuffer;
using v8::Boolean;
using v8::Context;
using v8::CpuProfile;
using v8::CpuProfilingResult;
using v8::CpuProfilingStatus;
using v8::DictionaryTemplate;
using v8::Float64Array;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::HeapStatistics;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Locker;
using v8::Maybe;
using v8::MaybeLocal;
using v8::NewStringType;
using v8::Null;
using v8::Number;
using v8::Object;
using v8::ObjectTemplate;
using v8::ResourceConstraints;
using v8::SealHandleScope;
using v8::String;
using v8::TryCatch;
using v8::Value;

namespace node {
namespace worker {

constexpr double kMB = 1024 * 1024;

Worker::Worker(Environment* env,
 Local<Object> wrap,
 const std::string& url,
 const std::string& name,
 std::shared_ptr<PerIsolateOptions> per_isolate_opts,
 std::vector<std::string>&& exec_argv,
 std::shared_ptr<KVStore> env_vars,
 const SnapshotData* snapshot_data,
 const bool is_internal)
 : AsyncWrap(env, wrap, AsyncWrap::PROVIDER_WORKER),
 per_isolate_opts_(per_isolate_opts),
 exec_argv_(exec_argv),
 platform_(env->isolate_data()->platform()),
 thread_id_(AllocateEnvironmentThreadId()),
 name_(name),
 env_vars_(env_vars),
 embedder_preload_(env->embedder_preload()),
 snapshot_data_(snapshot_data),
 is_internal_(is_internal) {
 Debug(this, "Creating new worker instance with thread id %llu",
 thread_id_.id);

 // Set up everything that needs to be set up in the parent environment.
 MessagePort* parent_port = MessagePort::New(env, env->context());
 if (parent_port == nullptr) {
 // This can happen e.g. because execution is terminating.
 return;
 }

 child_port_data_ = std::make_unique<MessagePortData>(nullptr);
 MessagePort::Entangle(parent_port, child_port_data_.get());

 object()
 ->Set(env->context(), env->message_port_string(), parent_port->object())
 .Check();

 object()->Set(env->context(),
 env->thread_id_string(),
 Number::New(env->isolate(), static_cast<double>(thread_id_.id)))
 .Check();

 object()
 ->Set(env->context(),
 env->thread_name_string(),
 String::NewFromUtf8(env->isolate(),
 name_.data(),
 NewStringType::kNormal,
 name_.size())
 .ToLocalChecked())
 .Check();
 // Without this check, to use the permission model with
 // workers (--allow-worker) one would need to pass --allow-inspector as well
 if (env->permission()->is_granted(
 env, node::permission::PermissionScope::kInspector)) {
 inspector_parent_handle_ =
 GetInspectorParentHandle(env, thread_id_, url, name);
 }

 argv_ = std::vector<std::string>{env->argv()[0]};
 // Mark this Worker object as weak until we actually start the thread.
 MakeWeak();

 Debug(this, "Preparation for worker %llu finished", thread_id_.id);
}

bool Worker::is_stopped() const {
 Mutex::ScopedLock lock(mutex_);
 if (env_ != nullptr)
 return env_->is_stopping();
 return stopped_;
}

void Worker::UpdateResourceConstraints(ResourceConstraints* constraints) {
 constraints->set_stack_limit(reinterpret_cast<uint32_t*>(stack_base_));

 if (resource_limits_[kMaxYoungGenerationSizeMb] > 0) {
 constraints->set_max_young_generation_size_in_bytes(
 static_cast<size_t>(resource_limits_[kMaxYoungGenerationSizeMb] * kMB));
 } else {
 resource_limits_[kMaxYoungGenerationSizeMb] =
 constraints->max_young_generation_size_in_bytes() / kMB;
 }

 if (resource_limits_[kMaxOldGenerationSizeMb] > 0) {
 constraints->set_max_old_generation_size_in_bytes(
 static_cast<size_t>(resource_limits_[kMaxOldGenerationSizeMb] * kMB));
 } else {
 resource_limits_[kMaxOldGenerationSizeMb] =
 constraints->max_old_generation_size_in_bytes() / kMB;
 }

 if (resource_limits_[kCodeRangeSizeMb] > 0) {
 constraints->set_code_range_size_in_bytes(
 static_cast<size_t>(resource_limits_[kCodeRangeSizeMb] * kMB));
 } else {
 resource_limits_[kCodeRangeSizeMb] =
 constraints->code_range_size_in_bytes() / kMB;
 }
}

// This class contains data that is only relevant to the child thread itself,
// and only while it is running.
// (Eventually, the Environment instance should probably also be moved here.)
class WorkerThreadData {
 public:
 explicit WorkerThreadData(Worker* w)
 : w_(w) {
 int ret = uv_loop_init(&loop_);
 if (ret != 0) {
 char err_buf[128];
 uv_err_name_r(ret, err_buf, sizeof(err_buf));
 // TODO(joyeecheung): maybe this should be kBootstrapFailure instead?
 w->Exit(ExitCode::kGenericUserError, "ERR_WORKER_INIT_FAILED", err_buf);
 return;
 }
 loop_init_failed_ = false;
 uv_loop_configure(&loop_, UV_METRICS_IDLE_TIME);

 std::shared_ptr<ArrayBufferAllocator> allocator =
 ArrayBufferAllocator::Create();
 Isolate::CreateParams params;
 SetIsolateCreateParamsForNode(&params);
 w->UpdateResourceConstraints(&params.constraints);
 params.array_buffer_allocator_shared = allocator;
 Isolate* isolate =
 NewIsolate(&params, &loop_, w->platform_, w->snapshot_data());
 if (isolate == nullptr) {
 // TODO(joyeecheung): maybe this should be kBootstrapFailure instead?
 w->Exit(ExitCode::kGenericUserError,
 "ERR_WORKER_INIT_FAILED",
 "Failed to create new Isolate");
 return;
 }

 SetIsolateUpForNode(isolate);

 // Be sure it's called before Environment::InitializeDiagnostics()
 // so that this callback stays when the callback of
 // --heapsnapshot-near-heap-limit gets is popped.
 isolate->AddNearHeapLimitCallback(Worker::NearHeapLimit, w);

 {
 Locker locker(isolate);
 Isolate::Scope isolate_scope(isolate);
 // V8 computes its stack limit the first time a `Locker` is used based on
 // --stack-size. Reset it to the correct value.
 isolate->SetStackLimit(w->stack_base_);

 HandleScope handle_scope(isolate);
 isolate_data_.reset(IsolateData::CreateIsolateData(
 isolate,
 &loop_,
 w_->platform_,
 allocator.get(),
 w->snapshot_data()->AsEmbedderWrapper().get(),
 std::move(w_->per_isolate_opts_)));
 CHECK(isolate_data_);
 CHECK(!isolate_data_->is_building_snapshot());
 isolate_data_->set_worker_context(w_);
 isolate_data_->max_young_gen_size =
 params.constraints.max_young_generation_size_in_bytes();
 }

 Mutex::ScopedLock lock(w_->mutex_);
 w_->isolate_ = isolate;
 }

 ~WorkerThreadData() {
 Debug(w_, "Worker %llu dispose isolate", w_->thread_id_.id);
 Isolate* isolate;
 {
 Mutex::ScopedLock lock(w_->mutex_);
 isolate = w_->isolate_;
 w_->isolate_ = nullptr;
 }

 if (isolate != nullptr) {
 CHECK(!loop_init_failed_);
 bool platform_finished = false;

 // https://github.com/nodejs/node/issues/51129 - IsolateData destructor
 // can kick off GC before teardown, so ensure the isolate is entered.
 {
 Locker locker(isolate);
 Isolate::Scope isolate_scope(isolate);
 isolate_data_.reset();
 }

 w_->platform_->AddIsolateFinishedCallback(isolate, [](void* data) {
 *static_cast<bool*>(data) = true;
 }, &platform_finished);

 w_->platform_->DisposeIsolate(isolate);

 // Wait until the platform has cleaned up all relevant resources.
 while (!platform_finished) {
 uv_run(&loop_, UV_RUN_ONCE);
 }
 }
 if (!loop_init_failed_) {
 CheckedUvLoopClose(&loop_);
 }
 }

 bool loop_is_usable() const { return !loop_init_failed_; }

 private:
 Worker* const w_;
 uv_loop_t loop_;
 bool loop_init_failed_ = true;
 DeleteFnPtr<IsolateData, FreeIsolateData> isolate_data_;
 friend class Worker;
};

size_t Worker::NearHeapLimit(void* data, size_t current_heap_limit,
 size_t initial_heap_limit) {
 Worker* worker = static_cast<Worker*>(data);
 // Give the current GC some extra leeway to let it finish rather than
 // crash hard. We are not going to perform further allocations anyway.
 constexpr size_t kExtraHeapAllowance = 16 * 1024 * 1024;
 size_t new_limit = current_heap_limit + kExtraHeapAllowance;
 Environment* env = worker->env();
 if (env != nullptr) {
 DCHECK(!env->is_in_heapsnapshot_heap_limit_callback());
 Debug(env,
 DebugCategory::DIAGNOSTICS,
 "Throwing ERR_WORKER_OUT_OF_MEMORY, "
 "new_limit=%" PRIu64 "\n",
 static_cast<uint64_t>(new_limit));
 }
 // TODO(joyeecheung): maybe this should be kV8FatalError instead?
 worker->Exit(ExitCode::kGenericUserError,
 "ERR_WORKER_OUT_OF_MEMORY",
 "JS heap out of memory");
 return new_limit;
}

void Worker::Run() {
 std::string trace_name = "[worker " + std::to_string(thread_id_.id) + "]" +
 (name_ == "" ? "" : " " + name_);
 TRACE_EVENT_METADATA1(
 "__metadata", "thread_name", "name", TRACE_STR_COPY(trace_name.c_str()));
 CHECK_NOT_NULL(platform_);

 Debug(this, "Creating isolate for worker with id %llu", thread_id_.id);

 WorkerThreadData data(this);
 if (isolate_ == nullptr) return;
 CHECK(data.loop_is_usable());

 Debug(this, "Starting worker with id %llu", thread_id_.id);
 {
 Locker locker(isolate_);
 Isolate::Scope isolate_scope(isolate_);
 SealHandleScope outer_seal(isolate_);

 DeleteFnPtr<Environment, FreeEnvironment> env_;
 auto cleanup_env = OnScopeLeave([&]() {
 // TODO(addaleax): This call is harmless but should not be necessary.
 // Figure out why V8 is raising a DCHECK() here without it
 // (in test/parallel/test-async-hooks-worker-asyncfn-terminate-4.js).
 isolate_->CancelTerminateExecution();

 if (!env_) return;
 env_->set_can_call_into_js(false);

 {
 Mutex::ScopedLock lock(mutex_);
 stopped_ = true;
 this->env_ = nullptr;
 }

 env_.reset();
 });

 if (is_stopped()) return;
 {
 HandleScope handle_scope(isolate_);
 Local<Context> context;
 {
 // We create the Context object before we have an Environment* in place
 // that we could use for error handling. If creation fails due to
 // resource constraints, we need something in place to handle it,
 // though.
 TryCatch try_catch(isolate_);
 if (snapshot_data_ != nullptr) {
 Debug(this,
 "Worker %llu uses context from snapshot %d\n",
 thread_id_.id,
 static_cast<int>(SnapshotData::kNodeBaseContextIndex));
 context = Context::FromSnapshot(isolate_,
 SnapshotData::kNodeBaseContextIndex)
 .ToLocalChecked();
 if (!context.IsEmpty() &&
 !InitializeContextRuntime(context).IsJust()) {
 context = Local<Context>();
 }
 } else {
 Debug(
 this, "Worker %llu builds context from scratch\n", thread_id_.id);
 context = NewContext(isolate_);
 }
 if (context.IsEmpty()) {
 // TODO(joyeecheung): maybe this should be kBootstrapFailure instead?
 Exit(ExitCode::kGenericUserError,
 "ERR_WORKER_INIT_FAILED",
 "Failed to create new Context");
 return;
 }
 }

 if (is_stopped()) return;
 CHECK(!context.IsEmpty());
 Context::Scope context_scope(context);
 {
#if HAVE_INSPECTOR
 environment_flags_ |= EnvironmentFlags::kNoWaitForInspectorFrontend;
#endif
 env_.reset(CreateEnvironment(
 data.isolate_data_.get(),
 context,
 std::move(argv_),
 std::move(exec_argv_),
 static_cast<EnvironmentFlags::Flags>(environment_flags_),
 thread_id_,
 std::move(inspector_parent_handle_),
 name_));
 if (is_stopped()) return;
 CHECK_NOT_NULL(env_);
 env_->set_env_vars(std::move(env_vars_));
 SetProcessExitHandler(env_.get(), [this](Environment*, int exit_code) {
 Exit(static_cast<ExitCode>(exit_code));
 });
 }
 {
 Mutex::ScopedLock lock(mutex_);
 if (stopped_) return;
 this->env_ = env_.get();
 }
 Debug(this, "Created Environment for worker with id %llu", thread_id_.id);

#if HAVE_INSPECTOR
 this->env_->WaitForInspectorFrontendByOptions();
#endif
 if (is_stopped()) return;
 {
 if (!CreateEnvMessagePort(env_.get())) {
 return;
 }

 Debug(this, "Created message port for worker %llu", thread_id_.id);
 if (LoadEnvironment(env_.get(),
 StartExecutionCallbackWithModule{},
 std::move(embedder_preload_))
 .IsEmpty()) {
 return;
 }

 Debug(this, "Loaded environment for worker %llu", thread_id_.id);
 }
 }

 {
 Maybe<ExitCode> exit_code = SpinEventLoopInternal(env_.get());
 Mutex::ScopedLock lock(mutex_);
 if (exit_code_ == ExitCode::kNoFailure && exit_code.IsJust()) {
 exit_code_ = exit_code.FromJust();
 }

 Debug(this,
 "Exiting thread for worker %llu with exit code %d",
 thread_id_.id,
 static_cast<int>(exit_code_));
 }
 }

 Debug(this, "Worker %llu thread stops", thread_id_.id);
}

bool Worker::CreateEnvMessagePort(Environment* env) {
 HandleScope handle_scope(isolate_);
 std::unique_ptr<MessagePortData> data;
 {
 Mutex::ScopedLock lock(mutex_);
 data = std::move(child_port_data_);
 }

 // Set up the message channel for receiving messages in the child.
 MessagePort* child_port = MessagePort::New(env,
 env->context(),
 std::move(data));
 // MessagePort::New() may return nullptr if execution is terminated
 // within it.
 if (child_port != nullptr)
 env->set_message_port(child_port->object(isolate_));

 return child_port;
}

void Worker::JoinThread() {
 if (!tid_.has_value())
 return;
 CHECK_EQ(uv_thread_join(&tid_.value()), 0);
 tid_.reset();

 env()->remove_sub_worker_context(this);

 // Join may happen after the worker exits and disposes the isolate
 if (!env()->can_call_into_js()) return;

 {
 HandleScope handle_scope(env()->isolate());
 Context::Scope context_scope(env()->context());

 // Reset the parent port as we're closing it now anyway.
 object()->Set(env()->context(),
 env()->message_port_string(),
 Undefined(env()->isolate())).Check();

 Local<Value> args[] = {
 Integer::New(env()->isolate(), static_cast<int>(exit_code_)),
 custom_error_ != nullptr
 ? OneByteString(env()->isolate(), custom_error_).As<Value>()
 : Null(env()->isolate()).As<Value>(),
 !custom_error_str_.empty()
 ? OneByteString(env()->isolate(), custom_error_str_.c_str())
 .As<Value>()
 : Null(env()->isolate()).As<Value>(),
 };

 MakeCallback(env()->onexit_string(), arraysize(args), args);
 }

 // If we get here, the tid_.has_value() condition at the top of the function
 // implies that the thread was running. In that case, its final action will
 // be to schedule a callback on the parent thread which will delete this
 // object, so there's nothing more to do here.
}

Worker::~Worker() {
 Mutex::ScopedLock lock(mutex_);

 CHECK(stopped_);
 CHECK_NULL(env_);
 CHECK(!tid_.has_value());
 Debug(this, "Worker %llu destroyed", thread_id_.id);
}

void Worker::New(const FunctionCallbackInfo<Value>& args) {
 Environment* env = Environment::GetCurrent(args);
 THROW_IF_INSUFFICIENT_PERMISSIONS(
 env, permission::PermissionScope::kWorkerThreads, "");
 bool is_internal = args[5]->IsTrue();
 Isolate* isolate = args.GetIsolate();

 CHECK(args.IsConstructCall());

 if (env->isolate_data()->platform() == nullptr) {
 THROW_ERR_MISSING_PLATFORM_FOR_WORKER(env);
 return;
 }
 CHECK(!env->isolate_data()->is_building_snapshot());

 std::string url;
 std::string name;
 std::shared_ptr<PerIsolateOptions> per_isolate_opts = nullptr;
 std::shared_ptr<KVStore> env_vars = nullptr;

 std::vector<std::string> exec_argv_out;

 // Argument might be a string or URL
 if (!args[0]->IsNullOrUndefined()) {
 Utf8Value value(
 isolate, args[0]->ToString(env->context()).FromMaybe(Local<String>()));
 url.append(value.out(), value.length());
 }

 if (!args[6]->IsNullOrUndefined()) {
 Utf8Value value(
 isolate, args[6]->ToString(env->context()).FromMaybe(Local<String>()));
 name.append(value.out(), value.length());
 }

 if (args[1]->IsNull()) {
 // Means worker.env = { ...process.env }.
 env_vars = env->env_vars()->Clone(isolate);
 } else if (args[1]->IsObject()) {
 // User provided env.
 env_vars = KVStore::CreateMapKVStore();
 if (env_vars
 ->AssignFromObject(isolate->GetCurrentContext(),
 args[1].As<Object>())
 .IsNothing()) {
 return;
 }
 } else {
 // Env is shared.
 env_vars = env->env_vars();
 }

 if (!env_vars) {
 THROW_ERR_OPERATION_FAILED(env, "Failed to copy environment variables");
 }

 if (args[1]->IsObject() || args[2]->IsArray()) {
 per_isolate_opts.reset(new PerIsolateOptions());

 HandleEnvOptions(per_isolate_opts->per_env, [&env_vars](const char* name) {
 return env_vars->Get(name).value_or("");
 });

#ifndef NODE_WITHOUT_NODE_OPTIONS
 std::optional<std::string> node_options = env_vars->Get("NODE_OPTIONS");
 if (node_options.has_value()) {
 std::vector<std::string> errors{};
 std::vector<std::string> env_argv =
 ParseNodeOptionsEnvVar(node_options.value(), &errors);
 // [0] is expected to be the program name, add dummy string.
 env_argv.insert(env_argv.begin(), "");
 std::vector<std::string> invalid_args{};

 std::optional<std::string> parent_node_options =
 env->env_vars()->Get("NODE_OPTIONS");

 // If the worker code passes { env: { ...process.env, ... } } or
 // the NODE_OPTIONS is otherwise character-for-character equal to the
 // original NODE_OPTIONS, allow per-process options inherited into
 // the worker since worker spawning code is not usually in charge of
 // how the NODE_OPTIONS is configured for the parent.
 // TODO(joyeecheung): a more intelligent filter may be more desirable.
 // but a string comparison is good enough(TM) for the case where the
 // worker spawning code just wants to pass the parent configuration down
 // and does not intend to modify NODE_OPTIONS.
 if (parent_node_options == node_options) {
 // Creates a wrapper per-process option over the per_isolate_opts
 // to allow per-process options copied from the parent.
 std::unique_ptr<PerProcessOptions> per_process_opts =
 std::make_unique<PerProcessOptions>();
 per_process_opts->per_isolate = per_isolate_opts;
 options_parser::Parse(&env_argv,
 nullptr,
 &invalid_args,
 per_process_opts.get(),
 kAllowedInEnvvar,
 &errors);
 } else {
 options_parser::Parse(&env_argv,
 nullptr,
 &invalid_args,
 per_isolate_opts.get(),
 kAllowedInEnvvar,
 &errors);
 }

 if (!errors.empty() && args[1]->IsObject()) {
 // Only fail for explicitly provided env, this protects from failures
 // when NODE_OPTIONS from parent's env is used (which is the default).
 Local<Value> error;
 if (!ToV8Value(env->context(), errors).ToLocal(&error)) return;
 Local<String> key =
 FIXED_ONE_BYTE_STRING(env->isolate(), "invalidNodeOptions");
 // Ignore the return value of Set() because exceptions bubble up to JS
 // when we return anyway.
 USE(args.This()->Set(env->context(), key, error));
 return;
 }
 }
#endif // NODE_WITHOUT_NODE_OPTIONS

 // The first argument is reserved for program name, but we don't need it
 // in workers.
 std::vector<std::string> exec_argv = {""};
 if (args[2]->IsArray()) {
 Local<Array> array = args[2].As<Array>();
 uint32_t length = array->Length();
 for (uint32_t i = 0; i < length; i++) {
 Local<Value> arg;
 if (!array->Get(env->context(), i).ToLocal(&arg)) {
 return;
 }
 Local<String> arg_v8;
 if (!arg->ToString(env->context()).ToLocal(&arg_v8)) {
 return;
 }
 Utf8Value arg_utf8_value(args.GetIsolate(), arg_v8);
 std::string arg_string(arg_utf8_value.out(), arg_utf8_value.length());
 exec_argv.push_back(arg_string);
 }
 } else {
 exec_argv.insert(
 exec_argv.end(), env->exec_argv().begin(), env->exec_argv().end());
 }

 std::vector<std::string> invalid_args{};
 std::vector<std::string> errors{};
 // Using invalid_args as the v8_args argument as it stores unknown
 // options for the per isolate parser.
 options_parser::Parse(&exec_argv,
 &exec_argv_out,
 &invalid_args,
 per_isolate_opts.get(),
 kDisallowedInEnvvar,
 &errors);

 // The first argument is program name.
 invalid_args.erase(invalid_args.begin());
 // Only fail for explicitly provided execArgv, this protects from failures
 // when execArgv from parent's execArgv is used (which is the default).
 if (errors.size() > 0 || (invalid_args.size() > 0 && args[2]->IsArray())) {
 Local<Value> error;
 if (!ToV8Value(env->context(), errors.size() > 0 ? errors : invalid_args)
 .ToLocal(&error)) {
 return;
 }
 Local<String> key =
 FIXED_ONE_BYTE_STRING(env->isolate(), "invalidExecArgv");
 // Ignore the return value of Set() because exceptions bubble up to JS
 // when we return anyway.
 USE(args.This()->Set(env->context(), key, error));
 return;
 }
 } else {
 // Copy the parent's execArgv.
 exec_argv_out = env->exec_argv();
 per_isolate_opts = env->isolate_data()->options()->Clone();
 }

 // Internal workers should not wait for inspector frontend to connect or
 // break on the first line of internal scripts. Module loader threads are
 // essential to load user codes and must not be blocked by the inspector
 // for internal scripts.
 // Still, `--inspect-node` can break on the first line of internal scripts.
 if (is_internal) {
 per_isolate_opts->per_env->get_debug_options()
 ->DisableWaitOrBreakFirstLine();
 }

 const SnapshotData* snapshot_data = env->isolate_data()->snapshot_data();

 Worker* worker = new Worker(env,
 args.This(),
 url,
 name,
 per_isolate_opts,
 std::move(exec_argv_out),
 env_vars,
 snapshot_data,
 is_internal);

 CHECK(args[3]->IsFloat64Array());
 Local<Float64Array> limit_info = args[3].As<Float64Array>();
 CHECK_EQ(limit_info->Length(), kTotalResourceLimitCount);
 limit_info->CopyContents(worker->resource_limits_,
 sizeof(worker->resource_limits_));

 CHECK(args[4]->IsBoolean());
 if (args[4]->IsTrue() || env->tracks_unmanaged_fds())
 worker->environment_flags_ |= EnvironmentFlags::kTrackUnmanagedFds;
 if (env->hide_console_windows())
 worker->environment_flags_ |= EnvironmentFlags::kHideConsoleWindows;
 if (env->no_native_addons())
 worker->environment_flags_ |= EnvironmentFlags::kNoNativeAddons;
 if (env->no_global_search_paths())
 worker->environment_flags_ |= EnvironmentFlags::kNoGlobalSearchPaths;
 if (env->no_browser_globals())
 worker->environment_flags_ |= EnvironmentFlags::kNoBrowserGlobals;
}

void Worker::StartThread(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 Mutex::ScopedLock lock(w->mutex_);

 w->stopped_ = false;

 if (w->resource_limits_[kStackSizeMb] > 0) {
 if (w->resource_limits_[kStackSizeMb] * kMB < kStackBufferSize) {
 w->resource_limits_[kStackSizeMb] = kStackBufferSize / kMB;
 w->stack_size_ = kStackBufferSize;
 } else {
 w->stack_size_ =
 static_cast<size_t>(w->resource_limits_[kStackSizeMb] * kMB);
 }
 } else {
 w->resource_limits_[kStackSizeMb] = w->stack_size_ / kMB;
 }

 uv_thread_options_t thread_options;
 thread_options.flags = UV_THREAD_HAS_STACK_SIZE;
 thread_options.stack_size = w->stack_size_;

 uv_thread_t* tid = &w->tid_.emplace(); // Create uv_thread_t instance
 int ret = uv_thread_create_ex(tid, &thread_options, [](void* arg) {
 // XXX: This could become a std::unique_ptr, but that makes at least
 // gcc 6.3 detect undefined behaviour when there shouldn't be any.
 // gcc 7+ handles this well.
 Worker* w = static_cast<Worker*>(arg);
 const uintptr_t stack_top = reinterpret_cast<uintptr_t>(&arg);

 uv_thread_setname(w->name_.c_str());
 // Leave a few kilobytes just to make sure we're within limits and have
 // some space to do work in C++ land.
 w->stack_base_ = stack_top - (w->stack_size_ - kStackBufferSize);

 w->Run();

 Mutex::ScopedLock lock(w->mutex_);
 w->env()->SetImmediateThreadsafe(
 [w = std::unique_ptr<Worker>(w)](Environment* env) {
 if (w->has_ref_)
 env->add_refs(-1);
 w->JoinThread();
 // implicitly delete w
 });
 }, static_cast<void*>(w));

 if (ret == 0) {
 // The object now owns the created thread and should not be garbage
 // collected until that finishes.
 w->ClearWeak();

 if (w->has_ref_)
 w->env()->add_refs(1);

 w->env()->add_sub_worker_context(w);
 } else {
 w->stopped_ = true;
 w->tid_.reset();

 char err_buf[128];
 uv_err_name_r(ret, err_buf, sizeof(err_buf));
 {
 Isolate* isolate = w->env()->isolate();
 HandleScope handle_scope(isolate);
 THROW_ERR_WORKER_INIT_FAILED(isolate, err_buf);
 }
 }
}

void Worker::StopThread(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Debug(w, "Worker %llu is getting stopped by parent", w->thread_id_.id);
 w->Exit(ExitCode::kGenericUserError);
}

void Worker::Ref(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 if (!w->has_ref_ && w->tid_.has_value()) {
 w->has_ref_ = true;
 w->env()->add_refs(1);
 }
}

void Worker::HasRef(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 args.GetReturnValue().Set(w->has_ref_);
}

void Worker::Unref(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 if (w->has_ref_ && w->tid_.has_value()) {
 w->has_ref_ = false;
 w->env()->add_refs(-1);
 }
}

class WorkerCpuUsageTaker : public AsyncWrap {
 public:
 WorkerCpuUsageTaker(Environment* env, Local<Object> obj)
 : AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERCPUUSAGE) {}

 SET_NO_MEMORY_INFO()
 SET_MEMORY_INFO_NAME(WorkerCpuUsageTaker)
 SET_SELF_SIZE(WorkerCpuUsageTaker)
};

void Worker::CpuUsage(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Environment* env = w->env();
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_cpu_usage_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 BaseObjectPtr<WorkerCpuUsageTaker> taker =
 MakeDetachedBaseObject<WorkerCpuUsageTaker>(env, wrap);

 bool scheduled = w->RequestInterrupt([taker = std::move(taker),
 env](Environment* worker_env) mutable {
 auto cpu_usage_stats = std::make_unique<uv_rusage_t>();
 int err = uv_getrusage_thread(cpu_usage_stats.get());

 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 cpu_usage_stats = std::move(cpu_usage_stats),
 err = err](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());

 Local<Value> argv[] = {
 Null(isolate),
 Undefined(isolate),
 };

 if (err) {
 argv[0] = UVException(
 isolate, err, "uv_getrusage_thread", nullptr, nullptr, nullptr);
 } else {
 auto tmpl = env->cpu_usage_template();
 if (tmpl.IsEmpty()) {
 static constexpr std::string_view names[] = {
 "user",
 "system",
 };
 tmpl = DictionaryTemplate::New(isolate, names);
 env->set_cpu_usage_template(tmpl);
 }

 MaybeLocal<Value> values[] = {
 Number::New(isolate,
 1e6 * cpu_usage_stats->ru_utime.tv_sec +
 cpu_usage_stats->ru_utime.tv_usec),
 Number::New(isolate,
 1e6 * cpu_usage_stats->ru_stime.tv_sec +
 cpu_usage_stats->ru_stime.tv_usec),
 };
 if (!NewDictionaryInstanceNullProto(env->context(), tmpl, values)
 .ToLocal(&argv[1])) {
 return;
 }
 }

 taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
 },
 CallbackFlags::kUnrefed);
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 }
}

class WorkerCpuProfileTaker final : public AsyncWrap {
 public:
 WorkerCpuProfileTaker(Environment* env, Local<Object> obj)
 : AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERCPUPROFILE) {}

 SET_NO_MEMORY_INFO()
 SET_MEMORY_INFO_NAME(WorkerCpuProfileTaker)
 SET_SELF_SIZE(WorkerCpuProfileTaker)
};

void Worker::StartCpuProfile(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 Environment* env = w->env();
 CpuProfileOptions options = ParseCpuProfileOptions(args);

 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_cpu_profile_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 BaseObjectPtr<WorkerCpuProfileTaker> taker =
 MakeDetachedBaseObject<WorkerCpuProfileTaker>(env, wrap);

 bool scheduled = w->RequestInterrupt([taker = std::move(taker), env, options](
 Environment* worker_env) mutable {
 CpuProfilingResult result = worker_env->StartCpuProfile(options);
 env->SetImmediateThreadsafe(
 [taker = std::move(taker), result = result](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());
 Local<Value> argv[] = {
 Null(isolate), // error
 Undefined(isolate), // profile id
 };
 if (result.status == CpuProfilingStatus::kErrorTooManyProfilers) {
 argv[0] = ERR_CPU_PROFILE_TOO_MANY(
 isolate, "There are too many CPU profiles");
 } else if (result.status == CpuProfilingStatus::kStarted) {
 argv[1] = Number::New(isolate, result.id);
 }
 taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
 },
 CallbackFlags::kUnrefed);
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 }
}

void Worker::StopCpuProfile(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Environment* env = w->env();
 CHECK(args[0]->IsUint32());
 uint32_t profile_id = args[0]->Uint32Value(env->context()).FromJust();

 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_cpu_profile_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 BaseObjectPtr<WorkerCpuProfileTaker> taker =
 MakeDetachedBaseObject<WorkerCpuProfileTaker>(env, wrap);

 bool scheduled = w->RequestInterrupt([taker = std::move(taker),
 profile_id = profile_id,
 env](Environment* worker_env) mutable {
 bool found = false;
 auto json_out_stream = std::make_unique<node::JSONOutputStream>();
 CpuProfile* profile = worker_env->StopCpuProfile(profile_id);
 if (profile) {
 profile->Serialize(json_out_stream.get(),
 CpuProfile::SerializationFormat::kJSON);
 profile->Delete();
 found = true;
 }
 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 json_out_stream = std::move(json_out_stream),
 found](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());
 Local<Value> argv[] = {
 Null(isolate), // error
 Undefined(isolate), // profile
 };
 if (found) {
 Local<Value> result;
 if (!ToV8Value(env->context(),
 json_out_stream->out_stream().str(),
 isolate)
 .ToLocal(&result)) {
 return;
 }
 argv[1] = result;
 } else {
 argv[0] =
 ERR_CPU_PROFILE_NOT_STARTED(isolate, "CPU profile not started");
 }
 taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
 },
 CallbackFlags::kUnrefed);
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 }
}

class WorkerHeapProfileTaker final : public AsyncWrap {
 public:
 WorkerHeapProfileTaker(Environment* env, Local<Object> obj)
 : AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERHEAPPROFILE) {}

 SET_NO_MEMORY_INFO()
 SET_MEMORY_INFO_NAME(WorkerHeapProfileTaker)
 SET_SELF_SIZE(WorkerHeapProfileTaker)
};

void Worker::StartHeapProfile(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 Environment* env = w->env();
 auto options = ParseHeapProfileOptions(args);

 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_heap_profile_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 BaseObjectPtr<WorkerHeapProfileTaker> taker =
 MakeDetachedBaseObject<WorkerHeapProfileTaker>(env, wrap);

 bool scheduled = w->RequestInterrupt([taker = std::move(taker), env, options](
 Environment* worker_env) mutable {
 v8::HeapProfiler* profiler = worker_env->isolate()->GetHeapProfiler();
 bool success = profiler->StartSamplingHeapProfiler(
 options.sample_interval, options.stack_depth, options.flags);
 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 success = success](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());
 Local<Value> argv[] = {
 Null(isolate), // error
 };
 if (!success) {
 argv[0] = ERR_HEAP_PROFILE_HAVE_BEEN_STARTED(
 isolate, "heap profiler have been started");
 }
 taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
 },
 CallbackFlags::kUnrefed);
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 }
}

void Worker::StopHeapProfile(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Environment* env = w->env();
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_heap_profile_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 BaseObjectPtr<WorkerHeapProfileTaker> taker =
 MakeDetachedBaseObject<WorkerHeapProfileTaker>(env, wrap);

 bool scheduled = w->RequestInterrupt([taker = std::move(taker),
 env](Environment* worker_env) mutable {
 std::ostringstream out_stream;
 bool success =
 node::SerializeHeapProfile(worker_env->isolate(), out_stream);
 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 out_stream = std::move(out_stream),
 success = success](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());
 Local<Value> argv[] = {
 Null(isolate), // error
 Undefined(isolate), // profile
 };
 if (success) {
 Local<Value> result;
 if (!ToV8Value(env->context(), out_stream.str(), isolate)
 .ToLocal(&result)) {
 return;
 }
 argv[1] = result;
 } else {
 argv[0] = ERR_HEAP_PROFILE_NOT_STARTED(isolate,
 "heap profile not started");
 }
 taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);
 },
 CallbackFlags::kUnrefed);
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 }
}
class WorkerHeapStatisticsTaker : public AsyncWrap {
 public:
 WorkerHeapStatisticsTaker(Environment* env, Local<Object> obj)
 : AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERHEAPSTATISTICS) {}

 SET_NO_MEMORY_INFO()
 SET_MEMORY_INFO_NAME(WorkerHeapStatisticsTaker)
 SET_SELF_SIZE(WorkerHeapStatisticsTaker)
};

void Worker::GetHeapStatistics(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Environment* env = w->env();
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_heap_statistics_taker_template()
 ->NewInstance(env->context())
 .ToLocal(&wrap)) {
 return;
 }

 // The created WorkerHeapStatisticsTaker is an object owned by main
 // thread's Isolate, it can not be accessed by worker thread
 std::unique_ptr<BaseObjectPtr<WorkerHeapStatisticsTaker>> taker =
 std::make_unique<BaseObjectPtr<WorkerHeapStatisticsTaker>>(
 MakeDetachedBaseObject<WorkerHeapStatisticsTaker>(env, wrap));

 // Interrupt the worker thread and take a snapshot, then schedule a call
 // on the parent thread that turns that snapshot into a readable stream.
 bool scheduled = w->RequestInterrupt([taker = std::move(taker),
 env](Environment* worker_env) mutable {
 // We create a unique pointer to HeapStatistics so that the actual object
 // it's not copied in the lambda, but only the pointer is.
 auto heap_stats = std::make_unique<HeapStatistics>();
 worker_env->isolate()->GetHeapStatistics(heap_stats.get());

 // Here, the worker thread temporarily owns the WorkerHeapStatisticsTaker
 // object.

 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 heap_stats = std::move(heap_stats)](Environment* env) mutable {
 Isolate* isolate = env->isolate();
 HandleScope handle_scope(isolate);
 Context::Scope context_scope(env->context());

 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker->get());

 auto tmpl = env->heap_statistics_template();
 if (tmpl.IsEmpty()) {
 std::string_view heap_stats_names[] = {
 "total_heap_size",
 "total_heap_size_executable",
 "total_physical_size",
 "total_available_size",
 "used_heap_size",
 "heap_size_limit",
 "malloced_memory",
 "peak_malloced_memory",
 "does_zap_garbage",
 "number_of_native_contexts",
 "number_of_detached_contexts",
 "total_global_handles_size",
 "used_global_handles_size",
 "external_memory",
 "total_allocated_bytes",
 };
 tmpl = DictionaryTemplate::New(isolate, heap_stats_names);
 env->set_heap_statistics_template(tmpl);
 }

 // Define an array of property values
 MaybeLocal<Value> heap_stats_values[] = {
 Number::New(isolate, heap_stats->total_heap_size()),
 Number::New(isolate, heap_stats->total_heap_size_executable()),
 Number::New(isolate, heap_stats->total_physical_size()),
 Number::New(isolate, heap_stats->total_available_size()),
 Number::New(isolate, heap_stats->used_heap_size()),
 Number::New(isolate, heap_stats->heap_size_limit()),
 Number::New(isolate, heap_stats->malloced_memory()),
 Number::New(isolate, heap_stats->peak_malloced_memory()),
 Boolean::New(isolate, heap_stats->does_zap_garbage()),
 Number::New(isolate, heap_stats->number_of_native_contexts()),
 Number::New(isolate, heap_stats->number_of_detached_contexts()),
 Number::New(isolate, heap_stats->total_global_handles_size()),
 Number::New(isolate, heap_stats->used_global_handles_size()),
 Number::New(isolate, heap_stats->external_memory()),
 Number::New(isolate, heap_stats->total_allocated_bytes())};

 Local<Object> obj;
 if (!NewDictionaryInstanceNullProto(
 env->context(), tmpl, heap_stats_values)
 .ToLocal(&obj)) {
 return;
 }
 Local<Value> args[] = {obj};
 taker->get()->MakeCallback(
 env->ondone_string(), arraysize(args), args);
 // implicitly delete `taker`
 },
 CallbackFlags::kUnrefed);

 // Now, the lambda is delivered to the main thread, as a result, the
 // WorkerHeapStatisticsTaker object is delivered to the main thread, too.
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 } else {
 args.GetReturnValue().Set(Local<Object>());
 }
}

void Worker::GetResourceLimits(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 args.GetReturnValue().Set(w->GetResourceLimits(args.GetIsolate()));
}

Local<Float64Array> Worker::GetResourceLimits(Isolate* isolate) const {
 Local<ArrayBuffer> ab = ArrayBuffer::New(isolate, sizeof(resource_limits_));

 memcpy(ab->Data(), resource_limits_, sizeof(resource_limits_));
 return Float64Array::New(ab, 0, kTotalResourceLimitCount);
}

void Worker::Exit(ExitCode code,
 const char* error_code,
 const char* error_message) {
 Mutex::ScopedLock lock(mutex_);
 Debug(this,
 "Worker %llu called Exit(%d, %s, %s)",
 thread_id_.id,
 static_cast<int>(code),
 error_code,
 error_message);

 if (error_code != nullptr) {
 custom_error_ = error_code;
 custom_error_str_ = error_message;
 }

 if (env_ != nullptr) {
 exit_code_ = code;
 Stop(env_);
 } else {
 stopped_ = true;
 }
}

bool Worker::IsNotIndicativeOfMemoryLeakAtExit() const {
 // Worker objects always stay alive as long as the child thread, regardless
 // of whether they are being referenced in the parent thread.
 return true;
}

class WorkerHeapSnapshotTaker : public AsyncWrap {
 public:
 WorkerHeapSnapshotTaker(Environment* env, Local<Object> obj)
 : AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERHEAPSNAPSHOT) {}

 SET_NO_MEMORY_INFO()
 SET_MEMORY_INFO_NAME(WorkerHeapSnapshotTaker)
 SET_SELF_SIZE(WorkerHeapSnapshotTaker)
};

void Worker::TakeHeapSnapshot(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 CHECK_EQ(args.Length(), 1);
 auto options = heap::GetHeapSnapshotOptions(args[0]);

 Debug(w, "Worker %llu taking heap snapshot", w->thread_id_.id);

 Environment* env = w->env();
 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);
 Local<Object> wrap;
 if (!env->worker_heap_snapshot_taker_template()
 ->NewInstance(env->context()).ToLocal(&wrap)) {
 return;
 }

 // The created WorkerHeapSnapshotTaker is an object owned by main
 // thread's Isolate, it can not be accessed by worker thread
 std::unique_ptr<BaseObjectPtr<WorkerHeapSnapshotTaker>> taker =
 std::make_unique<BaseObjectPtr<WorkerHeapSnapshotTaker>>(
 MakeDetachedBaseObject<WorkerHeapSnapshotTaker>(env, wrap));

 // Interrupt the worker thread and take a snapshot, then schedule a call
 // on the parent thread that turns that snapshot into a readable stream.
 bool scheduled = w->RequestInterrupt([taker = std::move(taker), env, options](
 Environment* worker_env) mutable {
 heap::HeapSnapshotPointer snapshot{
 worker_env->isolate()->GetHeapProfiler()->TakeHeapSnapshot(options)};
 CHECK(snapshot);

 // Here, the worker thread temporarily owns the WorkerHeapSnapshotTaker
 // object.

 env->SetImmediateThreadsafe(
 [taker = std::move(taker),
 snapshot = std::move(snapshot)](Environment* env) mutable {
 HandleScope handle_scope(env->isolate());
 Context::Scope context_scope(env->context());

 AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker->get());
 BaseObjectPtr<AsyncWrap> stream =
 heap::CreateHeapSnapshotStream(env, std::move(snapshot));
 Local<Value> args[] = {stream->object()};
 taker->get()->MakeCallback(
 env->ondone_string(), arraysize(args), args);
 // implicitly delete `taker`
 },
 CallbackFlags::kUnrefed);

 // Now, the lambda is delivered to the main thread, as a result, the
 // WorkerHeapSnapshotTaker object is delivered to the main thread, too.
 });

 if (scheduled) {
 args.GetReturnValue().Set(wrap);
 } else {
 args.GetReturnValue().Set(Local<Object>());
 }
}

void Worker::LoopIdleTime(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Mutex::ScopedLock lock(w->mutex_);
 // Using w->is_stopped() here leads to a deadlock, and checking is_stopped()
 // before locking the mutex is a race condition. So manually do the same
 // check.
 if (w->stopped_ || w->env_ == nullptr)
 return args.GetReturnValue().Set(-1);

 uint64_t idle_time = uv_metrics_idle_time(w->env_->event_loop());
 args.GetReturnValue().Set(1.0 * idle_time / 1e6);
}

void Worker::LoopStartTime(const FunctionCallbackInfo<Value>& args) {
 Worker* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

 Mutex::ScopedLock lock(w->mutex_);
 // Using w->is_stopped() here leads to a deadlock, and checking is_stopped()
 // before locking the mutex is a race condition. So manually do the same
 // check.
 if (w->stopped_ || w->env_ == nullptr)
 return args.GetReturnValue().Set(-1);

 double loop_start_time = w->env_->performance_state()->milestones[
 node::performance::NODE_PERFORMANCE_MILESTONE_LOOP_START];
 CHECK_GE(loop_start_time, 0);
 args.GetReturnValue().Set(loop_start_time / 1e6);
}

namespace {

// Return the MessagePort that is global for this Environment and communicates
// with the internal [kPort] port of the JS Worker class in the parent thread.
void GetEnvMessagePort(const FunctionCallbackInfo<Value>& args) {
 Environment* env = Environment::GetCurrent(args);
 Local<Object> port = env->message_port();
 CHECK_IMPLIES(!env->is_main_thread(), !port.IsEmpty());
 if (!port.IsEmpty()) {
 args.GetReturnValue().Set(port);
 }
}

void CreateWorkerPerIsolateProperties(IsolateData* isolate_data,
 Local<ObjectTemplate> target) {
 Isolate* isolate = isolate_data->isolate();

 {
 Local<FunctionTemplate> w = NewFunctionTemplate(isolate, Worker::New);

 w->InstanceTemplate()->SetInternalFieldCount(
 Worker::kInternalFieldCount);
 w->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 SetProtoMethod(isolate, w, "startThread", Worker::StartThread);
 SetProtoMethod(isolate, w, "stopThread", Worker::StopThread);
 SetProtoMethod(isolate, w, "hasRef", Worker::HasRef);
 SetProtoMethod(isolate, w, "ref", Worker::Ref);
 SetProtoMethod(isolate, w, "unref", Worker::Unref);
 SetProtoMethod(isolate, w, "getResourceLimits", Worker::GetResourceLimits);
 SetProtoMethod(isolate, w, "takeHeapSnapshot", Worker::TakeHeapSnapshot);
 SetProtoMethod(isolate, w, "loopIdleTime", Worker::LoopIdleTime);
 SetProtoMethod(isolate, w, "loopStartTime", Worker::LoopStartTime);
 SetProtoMethod(isolate, w, "getHeapStatistics", Worker::GetHeapStatistics);
 SetProtoMethod(isolate, w, "cpuUsage", Worker::CpuUsage);
 SetProtoMethod(isolate, w, "startCpuProfile", Worker::StartCpuProfile);
 SetProtoMethod(isolate, w, "stopCpuProfile", Worker::StopCpuProfile);
 SetProtoMethod(isolate, w, "startHeapProfile", Worker::StartHeapProfile);
 SetProtoMethod(isolate, w, "stopHeapProfile", Worker::StopHeapProfile);

 SetConstructorFunction(isolate, target, "Worker", w);
 }

 {
 Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

 wst->InstanceTemplate()->SetInternalFieldCount(
 WorkerHeapSnapshotTaker::kInternalFieldCount);
 wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 Local<String> wst_string =
 FIXED_ONE_BYTE_STRING(isolate, "WorkerHeapSnapshotTaker");
 wst->SetClassName(wst_string);
 isolate_data->set_worker_heap_snapshot_taker_template(
 wst->InstanceTemplate());
 }

 {
 Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

 wst->InstanceTemplate()->SetInternalFieldCount(
 WorkerHeapSnapshotTaker::kInternalFieldCount);
 wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 Local<String> wst_string =
 FIXED_ONE_BYTE_STRING(isolate, "WorkerHeapStatisticsTaker");
 wst->SetClassName(wst_string);
 isolate_data->set_worker_heap_statistics_taker_template(
 wst->InstanceTemplate());
 }

 {
 Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

 wst->InstanceTemplate()->SetInternalFieldCount(
 WorkerCpuUsageTaker::kInternalFieldCount);
 wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 Local<String> wst_string =
 FIXED_ONE_BYTE_STRING(isolate, "WorkerCpuUsageTaker");
 wst->SetClassName(wst_string);
 isolate_data->set_worker_cpu_usage_taker_template(wst->InstanceTemplate());
 }

 {
 Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

 wst->InstanceTemplate()->SetInternalFieldCount(
 WorkerCpuProfileTaker::kInternalFieldCount);
 wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 Local<String> wst_string =
 FIXED_ONE_BYTE_STRING(isolate, "WorkerCpuProfileTaker");
 wst->SetClassName(wst_string);
 isolate_data->set_worker_cpu_profile_taker_template(
 wst->InstanceTemplate());
 }

 {
 Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

 wst->InstanceTemplate()->SetInternalFieldCount(
 WorkerHeapProfileTaker::kInternalFieldCount);
 wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

 Local<String> wst_string =
 FIXED_ONE_BYTE_STRING(isolate, "WorkerHeapProfileTaker");
 wst->SetClassName(wst_string);
 isolate_data->set_worker_heap_profile_taker_template(
 wst->InstanceTemplate());
 }

 SetMethod(isolate, target, "getEnvMessagePort", GetEnvMessagePort);
}

void CreateWorkerPerContextProperties(Local<Object> target,
 Local<Value> unused,
 Local<Context> context,
 void* priv) {
 Environment* env = Environment::GetCurrent(context);
 Isolate* isolate = env->isolate();

 target
 ->Set(env->context(),
 env->thread_id_string(),
 Number::New(isolate, static_cast<double>(env->thread_id())))
 .Check();

 target
 ->Set(env->context(),
 env->thread_name_string(),
 String::NewFromUtf8(isolate,
 env->thread_name().data(),
 NewStringType::kNormal,
 env->thread_name().size())
 .ToLocalChecked())
 .Check();

 target
 ->Set(env->context(),
 FIXED_ONE_BYTE_STRING(isolate, "isMainThread"),
 Boolean::New(isolate, env->is_main_thread()))
 .Check();

 Worker* worker = env->isolate_data()->worker_context();
 bool is_internal = worker != nullptr && worker->is_internal();

 // Set the is_internal property
 target
 ->Set(env->context(),
 FIXED_ONE_BYTE_STRING(isolate, "isInternalThread"),
 Boolean::New(isolate, is_internal))
 .Check();

 target
 ->Set(env->context(),
 FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
 Boolean::New(isolate, env->owns_process_state()))
 .Check();

 if (!env->is_main_thread()) {
 target
 ->Set(env->context(),
 FIXED_ONE_BYTE_STRING(isolate, "resourceLimits"),
 env->worker_context()->GetResourceLimits(isolate))
 .Check();
 }

 NODE_DEFINE_CONSTANT(target, kMaxYoungGenerationSizeMb);
 NODE_DEFINE_CONSTANT(target, kMaxOldGenerationSizeMb);
 NODE_DEFINE_CONSTANT(target, kCodeRangeSizeMb);
 NODE_DEFINE_CONSTANT(target, kStackSizeMb);
 NODE_DEFINE_CONSTANT(target, kTotalResourceLimitCount);
}

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
 registry->Register(GetEnvMessagePort);
 registry->Register(Worker::New);
 registry->Register(Worker::StartThread);
 registry->Register(Worker::StopThread);
 registry->Register(Worker::HasRef);
 registry->Register(Worker::Ref);
 registry->Register(Worker::Unref);
 registry->Register(Worker::GetResourceLimits);
 registry->Register(Worker::TakeHeapSnapshot);
 registry->Register(Worker::LoopIdleTime);
 registry->Register(Worker::LoopStartTime);
 registry->Register(Worker::GetHeapStatistics);
 registry->Register(Worker::CpuUsage);
 registry->Register(Worker::StartCpuProfile);
 registry->Register(Worker::StopCpuProfile);
 registry->Register(Worker::StartHeapProfile);
 registry->Register(Worker::StopHeapProfile);
}

} // anonymous namespace
} // namespace worker
} // namespace node

NODE_BINDING_CONTEXT_AWARE_INTERNAL(
 worker, node::worker::CreateWorkerPerContextProperties)
NODE_BINDING_PER_ISOLATE_INIT(worker,
 node::worker::CreateWorkerPerIsolateProperties)
NODE_BINDING_EXTERNAL_REFERENCE(worker,
 node::worker::RegisterExternalReferences)