GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: env.h Lines: 43 43 100.0 %
Date: 2022-07-22 04:16:17 Branches: 1 2 50.0 %

Line Branch Exec Source
1
// Copyright Joyent, Inc. and other Node contributors.
2
//
3
// Permission is hereby granted, free of charge, to any person obtaining a
4
// copy of this software and associated documentation files (the
5
// "Software"), to deal in the Software without restriction, including
6
// without limitation the rights to use, copy, modify, merge, publish,
7
// distribute, sublicense, and/or sell copies of the Software, and to permit
8
// persons to whom the Software is furnished to do so, subject to the
9
// following conditions:
10
//
11
// The above copyright notice and this permission notice shall be included
12
// in all copies or substantial portions of the Software.
13
//
14
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20
// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22
#ifndef SRC_ENV_H_
23
#define SRC_ENV_H_
24
25
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
26
27
#include "aliased_buffer.h"
28
#if HAVE_INSPECTOR
29
#include "inspector_agent.h"
30
#include "inspector_profiler.h"
31
#endif
32
#include "callback_queue.h"
33
#include "debug_utils.h"
34
#include "handle_wrap.h"
35
#include "node.h"
36
#include "node_binding.h"
37
#include "node_main_instance.h"
38
#include "node_native_module.h"
39
#include "node_options.h"
40
#include "node_perf_common.h"
41
#include "node_snapshotable.h"
42
#include "req_wrap.h"
43
#include "util.h"
44
#include "uv.h"
45
#include "v8.h"
46
47
#include <array>
48
#include <atomic>
49
#include <cstdint>
50
#include <functional>
51
#include <list>
52
#include <memory>
53
#include <ostream>
54
#include <set>
55
#include <string>
56
#include <unordered_map>
57
#include <unordered_set>
58
#include <vector>
59
60
namespace node {
61
62
namespace contextify {
63
class ContextifyScript;
64
class CompiledFnEntry;
65
}
66
67
namespace performance {
68
class PerformanceState;
69
}
70
71
namespace tracing {
72
class AgentWriterHandle;
73
}
74
75
#if HAVE_INSPECTOR
76
namespace profiler {
77
class V8CoverageConnection;
78
class V8CpuProfilerConnection;
79
class V8HeapProfilerConnection;
80
}  // namespace profiler
81
82
namespace inspector {
83
class ParentInspectorHandle;
84
}
85
#endif  // HAVE_INSPECTOR
86
87
namespace worker {
88
class Worker;
89
}
90
91
namespace loader {
92
class ModuleWrap;
93
94
struct PackageConfig {
95
  enum class Exists { Yes, No };
96
  enum class IsValid { Yes, No };
97
  enum class HasMain { Yes, No };
98
  enum class HasName { Yes, No };
99
  enum PackageType : uint32_t { None = 0, CommonJS, Module };
100
101
  const Exists exists;
102
  const IsValid is_valid;
103
  const HasMain has_main;
104
  const std::string main;
105
  const HasName has_name;
106
  const std::string name;
107
  const PackageType type;
108
109
  v8::Global<v8::Value> exports;
110
};
111
}  // namespace loader
112
113
enum class FsStatsOffset {
114
  kDev = 0,
115
  kMode,
116
  kNlink,
117
  kUid,
118
  kGid,
119
  kRdev,
120
  kBlkSize,
121
  kIno,
122
  kSize,
123
  kBlocks,
124
  kATimeSec,
125
  kATimeNsec,
126
  kMTimeSec,
127
  kMTimeNsec,
128
  kCTimeSec,
129
  kCTimeNsec,
130
  kBirthTimeSec,
131
  kBirthTimeNsec,
132
  kFsStatsFieldsNumber
133
};
134
135
// Stat fields buffers contain twice the number of entries in an uv_stat_t
136
// because `fs.StatWatcher` needs room to store 2 `fs.Stats` instances.
137
constexpr size_t kFsStatsBufferLength =
138
    static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber) * 2;
139
140
// Disables zero-filling for ArrayBuffer allocations in this scope. This is
141
// similar to how we implement Buffer.allocUnsafe() in JS land.
142
class NoArrayBufferZeroFillScope {
143
 public:
144
  inline explicit NoArrayBufferZeroFillScope(IsolateData* isolate_data);
145
  inline ~NoArrayBufferZeroFillScope();
146
147
 private:
148
  NodeArrayBufferAllocator* node_allocator_;
149
150
  friend class Environment;
151
};
152
153
// PER_ISOLATE_* macros: We have a lot of per-isolate properties
154
// and adding and maintaining their getters and setters by hand would be
155
// difficult so let's make the preprocessor generate them for us.
156
//
157
// In each macro, `V` is expected to be the name of a macro or function which
158
// accepts the number of arguments provided in each tuple in the macro body,
159
// typically two. The named function will be invoked against each tuple.
160
//
161
// Make sure that any macro V defined for use with the PER_ISOLATE_* macros is
162
// undefined again after use.
163
164
// Private symbols are per-isolate primitives but Environment proxies them
165
// for the sake of convenience.  Strings should be ASCII-only and have a
166
// "node:" prefix to avoid name clashes with third-party code.
167
#define PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)                              \
168
  V(alpn_buffer_private_symbol, "node:alpnBuffer")                            \
169
  V(arrow_message_private_symbol, "node:arrowMessage")                        \
170
  V(contextify_context_private_symbol, "node:contextify:context")             \
171
  V(contextify_global_private_symbol, "node:contextify:global")               \
172
  V(decorated_private_symbol, "node:decorated")                               \
173
  V(napi_type_tag, "node:napi:type_tag")                                      \
174
  V(napi_wrapper, "node:napi:wrapper")                                        \
175
  V(untransferable_object_private_symbol, "node:untransferableObject")        \
176
177
// Symbols are per-isolate primitives but Environment proxies them
178
// for the sake of convenience.
179
#define PER_ISOLATE_SYMBOL_PROPERTIES(V)                                       \
180
  V(async_id_symbol, "async_id_symbol")                                        \
181
  V(handle_onclose_symbol, "handle_onclose")                                   \
182
  V(no_message_symbol, "no_message_symbol")                                    \
183
  V(messaging_deserialize_symbol, "messaging_deserialize_symbol")              \
184
  V(messaging_transfer_symbol, "messaging_transfer_symbol")                    \
185
  V(messaging_clone_symbol, "messaging_clone_symbol")                          \
186
  V(messaging_transfer_list_symbol, "messaging_transfer_list_symbol")          \
187
  V(oninit_symbol, "oninit")                                                   \
188
  V(owner_symbol, "owner_symbol")                                              \
189
  V(onpskexchange_symbol, "onpskexchange")                                     \
190
  V(resource_symbol, "resource_symbol")                                        \
191
  V(trigger_async_id_symbol, "trigger_async_id_symbol")                        \
192
193
// Strings are per-isolate primitives but Environment proxies them
194
// for the sake of convenience.  Strings should be ASCII-only.
195
#define PER_ISOLATE_STRING_PROPERTIES(V)                                       \
196
  V(ack_string, "ack")                                                         \
197
  V(address_string, "address")                                                 \
198
  V(aliases_string, "aliases")                                                 \
199
  V(args_string, "args")                                                       \
200
  V(asn1curve_string, "asn1Curve")                                             \
201
  V(async_ids_stack_string, "async_ids_stack")                                 \
202
  V(bits_string, "bits")                                                       \
203
  V(block_list_string, "blockList")                                            \
204
  V(buffer_string, "buffer")                                                   \
205
  V(bytes_parsed_string, "bytesParsed")                                        \
206
  V(bytes_read_string, "bytesRead")                                            \
207
  V(bytes_written_string, "bytesWritten")                                      \
208
  V(cached_data_produced_string, "cachedDataProduced")                         \
209
  V(cached_data_rejected_string, "cachedDataRejected")                         \
210
  V(cached_data_string, "cachedData")                                          \
211
  V(cache_key_string, "cacheKey")                                              \
212
  V(change_string, "change")                                                   \
213
  V(channel_string, "channel")                                                 \
214
  V(chunks_sent_since_last_write_string, "chunksSentSinceLastWrite")           \
215
  V(clone_unsupported_type_str, "Cannot transfer object of unsupported type.") \
216
  V(code_string, "code")                                                       \
217
  V(commonjs_string, "commonjs")                                               \
218
  V(config_string, "config")                                                   \
219
  V(constants_string, "constants")                                             \
220
  V(crypto_dh_string, "dh")                                                    \
221
  V(crypto_dsa_string, "dsa")                                                  \
222
  V(crypto_ec_string, "ec")                                                    \
223
  V(crypto_ed25519_string, "ed25519")                                          \
224
  V(crypto_ed448_string, "ed448")                                              \
225
  V(crypto_x25519_string, "x25519")                                            \
226
  V(crypto_x448_string, "x448")                                                \
227
  V(crypto_rsa_string, "rsa")                                                  \
228
  V(crypto_rsa_pss_string, "rsa-pss")                                          \
229
  V(cwd_string, "cwd")                                                         \
230
  V(data_string, "data")                                                       \
231
  V(default_is_true_string, "defaultIsTrue")                                   \
232
  V(deserialize_info_string, "deserializeInfo")                                \
233
  V(dest_string, "dest")                                                       \
234
  V(destroyed_string, "destroyed")                                             \
235
  V(detached_string, "detached")                                               \
236
  V(dh_string, "DH")                                                           \
237
  V(divisor_length_string, "divisorLength")                                    \
238
  V(dns_a_string, "A")                                                         \
239
  V(dns_aaaa_string, "AAAA")                                                   \
240
  V(dns_caa_string, "CAA")                                                     \
241
  V(dns_critical_string, "critical")                                           \
242
  V(dns_cname_string, "CNAME")                                                 \
243
  V(dns_mx_string, "MX")                                                       \
244
  V(dns_naptr_string, "NAPTR")                                                 \
245
  V(dns_ns_string, "NS")                                                       \
246
  V(dns_ptr_string, "PTR")                                                     \
247
  V(dns_soa_string, "SOA")                                                     \
248
  V(dns_srv_string, "SRV")                                                     \
249
  V(dns_txt_string, "TXT")                                                     \
250
  V(done_string, "done")                                                       \
251
  V(duration_string, "duration")                                               \
252
  V(ecdh_string, "ECDH")                                                       \
253
  V(emit_string, "emit")                                                       \
254
  V(emit_warning_string, "emitWarning")                                        \
255
  V(empty_object_string, "{}")                                                 \
256
  V(encoding_string, "encoding")                                               \
257
  V(entries_string, "entries")                                                 \
258
  V(entry_type_string, "entryType")                                            \
259
  V(env_pairs_string, "envPairs")                                              \
260
  V(env_var_settings_string, "envVarSettings")                                 \
261
  V(errno_string, "errno")                                                     \
262
  V(error_string, "error")                                                     \
263
  V(exchange_string, "exchange")                                               \
264
  V(exit_code_string, "exitCode")                                              \
265
  V(expire_string, "expire")                                                   \
266
  V(exponent_string, "exponent")                                               \
267
  V(exports_string, "exports")                                                 \
268
  V(ext_key_usage_string, "ext_key_usage")                                     \
269
  V(external_stream_string, "_externalStream")                                 \
270
  V(family_string, "family")                                                   \
271
  V(fatal_exception_string, "_fatalException")                                 \
272
  V(fd_string, "fd")                                                           \
273
  V(fields_string, "fields")                                                   \
274
  V(file_string, "file")                                                       \
275
  V(filename_string, "filename")                                               \
276
  V(fingerprint256_string, "fingerprint256")                                   \
277
  V(fingerprint512_string, "fingerprint512")                                   \
278
  V(fingerprint_string, "fingerprint")                                         \
279
  V(flags_string, "flags")                                                     \
280
  V(flowlabel_string, "flowlabel")                                             \
281
  V(fragment_string, "fragment")                                               \
282
  V(frames_received_string, "framesReceived")                                  \
283
  V(frames_sent_string, "framesSent")                                          \
284
  V(function_string, "function")                                               \
285
  V(get_data_clone_error_string, "_getDataCloneError")                         \
286
  V(get_shared_array_buffer_id_string, "_getSharedArrayBufferId")              \
287
  V(gid_string, "gid")                                                         \
288
  V(h2_string, "h2")                                                           \
289
  V(handle_string, "handle")                                                   \
290
  V(hash_algorithm_string, "hashAlgorithm")                                    \
291
  V(help_text_string, "helpText")                                              \
292
  V(homedir_string, "homedir")                                                 \
293
  V(host_string, "host")                                                       \
294
  V(hostmaster_string, "hostmaster")                                           \
295
  V(http_1_1_string, "http/1.1")                                               \
296
  V(id_string, "id")                                                           \
297
  V(identity_string, "identity")                                               \
298
  V(ignore_string, "ignore")                                                   \
299
  V(infoaccess_string, "infoAccess")                                           \
300
  V(inherit_string, "inherit")                                                 \
301
  V(input_string, "input")                                                     \
302
  V(internal_binding_string, "internalBinding")                                \
303
  V(internal_string, "internal")                                               \
304
  V(ipv4_string, "IPv4")                                                       \
305
  V(ipv6_string, "IPv6")                                                       \
306
  V(isclosing_string, "isClosing")                                             \
307
  V(issuer_string, "issuer")                                                   \
308
  V(issuercert_string, "issuerCertificate")                                    \
309
  V(jwk_crv_string, "crv")                                                     \
310
  V(jwk_d_string, "d")                                                         \
311
  V(jwk_dp_string, "dp")                                                       \
312
  V(jwk_dq_string, "dq")                                                       \
313
  V(jwk_dsa_string, "DSA")                                                     \
314
  V(jwk_e_string, "e")                                                         \
315
  V(jwk_ec_string, "EC")                                                       \
316
  V(jwk_g_string, "g")                                                         \
317
  V(jwk_k_string, "k")                                                         \
318
  V(jwk_p_string, "p")                                                         \
319
  V(jwk_q_string, "q")                                                         \
320
  V(jwk_qi_string, "qi")                                                       \
321
  V(jwk_kty_string, "kty")                                                     \
322
  V(jwk_n_string, "n")                                                         \
323
  V(jwk_oct_string, "oct")                                                     \
324
  V(jwk_okp_string, "OKP")                                                     \
325
  V(jwk_rsa_string, "RSA")                                                     \
326
  V(jwk_x_string, "x")                                                         \
327
  V(jwk_y_string, "y")                                                         \
328
  V(kill_signal_string, "killSignal")                                          \
329
  V(kind_string, "kind")                                                       \
330
  V(length_string, "length")                                                   \
331
  V(library_string, "library")                                                 \
332
  V(mac_string, "mac")                                                         \
333
  V(max_buffer_string, "maxBuffer")                                            \
334
  V(max_concurrent_streams_string, "maxConcurrentStreams")                     \
335
  V(message_port_constructor_string, "MessagePort")                            \
336
  V(message_port_string, "messagePort")                                        \
337
  V(message_string, "message")                                                 \
338
  V(messageerror_string, "messageerror")                                       \
339
  V(mgf1_hash_algorithm_string, "mgf1HashAlgorithm")                           \
340
  V(minttl_string, "minttl")                                                   \
341
  V(module_string, "module")                                                   \
342
  V(modulus_string, "modulus")                                                 \
343
  V(modulus_length_string, "modulusLength")                                    \
344
  V(name_string, "name")                                                       \
345
  V(named_curve_string, "namedCurve")                                          \
346
  V(netmask_string, "netmask")                                                 \
347
  V(next_string, "next")                                                       \
348
  V(nistcurve_string, "nistCurve")                                             \
349
  V(node_string, "node")                                                       \
350
  V(nsname_string, "nsname")                                                   \
351
  V(ocsp_request_string, "OCSPRequest")                                        \
352
  V(oncertcb_string, "oncertcb")                                               \
353
  V(onchange_string, "onchange")                                               \
354
  V(onclienthello_string, "onclienthello")                                     \
355
  V(oncomplete_string, "oncomplete")                                           \
356
  V(onconnection_string, "onconnection")                                       \
357
  V(ondone_string, "ondone")                                                   \
358
  V(onerror_string, "onerror")                                                 \
359
  V(onexit_string, "onexit")                                                   \
360
  V(onhandshakedone_string, "onhandshakedone")                                 \
361
  V(onhandshakestart_string, "onhandshakestart")                               \
362
  V(onkeylog_string, "onkeylog")                                               \
363
  V(onmessage_string, "onmessage")                                             \
364
  V(onnewsession_string, "onnewsession")                                       \
365
  V(onocspresponse_string, "onocspresponse")                                   \
366
  V(onreadstart_string, "onreadstart")                                         \
367
  V(onreadstop_string, "onreadstop")                                           \
368
  V(onshutdown_string, "onshutdown")                                           \
369
  V(onsignal_string, "onsignal")                                               \
370
  V(onunpipe_string, "onunpipe")                                               \
371
  V(onwrite_string, "onwrite")                                                 \
372
  V(openssl_error_stack, "opensslErrorStack")                                  \
373
  V(options_string, "options")                                                 \
374
  V(order_string, "order")                                                     \
375
  V(output_string, "output")                                                   \
376
  V(overlapped_string, "overlapped")                                           \
377
  V(parse_error_string, "Parse Error")                                         \
378
  V(password_string, "password")                                               \
379
  V(path_string, "path")                                                       \
380
  V(pending_handle_string, "pendingHandle")                                    \
381
  V(pid_string, "pid")                                                         \
382
  V(ping_rtt_string, "pingRTT")                                                \
383
  V(pipe_source_string, "pipeSource")                                          \
384
  V(pipe_string, "pipe")                                                       \
385
  V(pipe_target_string, "pipeTarget")                                          \
386
  V(port1_string, "port1")                                                     \
387
  V(port2_string, "port2")                                                     \
388
  V(port_string, "port")                                                       \
389
  V(preference_string, "preference")                                           \
390
  V(primordials_string, "primordials")                                         \
391
  V(priority_string, "priority")                                               \
392
  V(process_string, "process")                                                 \
393
  V(promise_string, "promise")                                                 \
394
  V(psk_string, "psk")                                                         \
395
  V(pubkey_string, "pubkey")                                                   \
396
  V(public_exponent_string, "publicExponent")                                  \
397
  V(query_string, "query")                                                     \
398
  V(rate_string, "rate")                                                       \
399
  V(raw_string, "raw")                                                         \
400
  V(read_host_object_string, "_readHostObject")                                \
401
  V(readable_string, "readable")                                               \
402
  V(reason_string, "reason")                                                   \
403
  V(refresh_string, "refresh")                                                 \
404
  V(regexp_string, "regexp")                                                   \
405
  V(rename_string, "rename")                                                   \
406
  V(replacement_string, "replacement")                                         \
407
  V(require_string, "require")                                                 \
408
  V(retry_string, "retry")                                                     \
409
  V(salt_length_string, "saltLength")                                          \
410
  V(scheme_string, "scheme")                                                   \
411
  V(scopeid_string, "scopeid")                                                 \
412
  V(serial_number_string, "serialNumber")                                      \
413
  V(serial_string, "serial")                                                   \
414
  V(servername_string, "servername")                                           \
415
  V(service_string, "service")                                                 \
416
  V(session_id_string, "sessionId")                                            \
417
  V(shell_string, "shell")                                                     \
418
  V(signal_string, "signal")                                                   \
419
  V(sink_string, "sink")                                                       \
420
  V(size_string, "size")                                                       \
421
  V(sni_context_err_string, "Invalid SNI context")                             \
422
  V(sni_context_string, "sni_context")                                         \
423
  V(source_string, "source")                                                   \
424
  V(stack_string, "stack")                                                     \
425
  V(standard_name_string, "standardName")                                      \
426
  V(start_time_string, "startTime")                                            \
427
  V(state_string, "state")                                                     \
428
  V(stats_string, "stats")                                                     \
429
  V(status_string, "status")                                                   \
430
  V(stdio_string, "stdio")                                                     \
431
  V(stream_average_duration_string, "streamAverageDuration")                   \
432
  V(stream_count_string, "streamCount")                                        \
433
  V(subject_string, "subject")                                                 \
434
  V(subjectaltname_string, "subjectaltname")                                   \
435
  V(syscall_string, "syscall")                                                 \
436
  V(target_string, "target")                                                   \
437
  V(thread_id_string, "threadId")                                              \
438
  V(ticketkeycallback_string, "onticketkeycallback")                           \
439
  V(timeout_string, "timeout")                                                 \
440
  V(time_to_first_byte_string, "timeToFirstByte")                              \
441
  V(time_to_first_byte_sent_string, "timeToFirstByteSent")                     \
442
  V(time_to_first_header_string, "timeToFirstHeader")                          \
443
  V(tls_ticket_string, "tlsTicket")                                            \
444
  V(transfer_string, "transfer")                                               \
445
  V(ttl_string, "ttl")                                                         \
446
  V(type_string, "type")                                                       \
447
  V(uid_string, "uid")                                                         \
448
  V(unknown_string, "<unknown>")                                               \
449
  V(url_special_ftp_string, "ftp:")                                            \
450
  V(url_special_file_string, "file:")                                          \
451
  V(url_special_http_string, "http:")                                          \
452
  V(url_special_https_string, "https:")                                        \
453
  V(url_special_ws_string, "ws:")                                              \
454
  V(url_special_wss_string, "wss:")                                            \
455
  V(url_string, "url")                                                         \
456
  V(username_string, "username")                                               \
457
  V(valid_from_string, "valid_from")                                           \
458
  V(valid_to_string, "valid_to")                                               \
459
  V(value_string, "value")                                                     \
460
  V(verify_error_string, "verifyError")                                        \
461
  V(version_string, "version")                                                 \
462
  V(weight_string, "weight")                                                   \
463
  V(windows_hide_string, "windowsHide")                                        \
464
  V(windows_verbatim_arguments_string, "windowsVerbatimArguments")             \
465
  V(wrap_string, "wrap")                                                       \
466
  V(writable_string, "writable")                                               \
467
  V(write_host_object_string, "_writeHostObject")                              \
468
  V(write_queue_size_string, "writeQueueSize")                                 \
469
  V(x_forwarded_string, "x-forwarded-for")                                     \
470
  V(zero_return_string, "ZERO_RETURN")
471
472
#define ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)                             \
473
  V(async_wrap_ctor_template, v8::FunctionTemplate)                            \
474
  V(async_wrap_object_ctor_template, v8::FunctionTemplate)                     \
475
  V(base_object_ctor_template, v8::FunctionTemplate)                           \
476
  V(binding_data_ctor_template, v8::FunctionTemplate)                          \
477
  V(blob_constructor_template, v8::FunctionTemplate)                           \
478
  V(blocklist_constructor_template, v8::FunctionTemplate)                      \
479
  V(compiled_fn_entry_template, v8::ObjectTemplate)                            \
480
  V(dir_instance_template, v8::ObjectTemplate)                                 \
481
  V(fd_constructor_template, v8::ObjectTemplate)                               \
482
  V(fdclose_constructor_template, v8::ObjectTemplate)                          \
483
  V(filehandlereadwrap_template, v8::ObjectTemplate)                           \
484
  V(fsreqpromise_constructor_template, v8::ObjectTemplate)                     \
485
  V(handle_wrap_ctor_template, v8::FunctionTemplate)                           \
486
  V(histogram_ctor_template, v8::FunctionTemplate)                             \
487
  V(http2settings_constructor_template, v8::ObjectTemplate)                    \
488
  V(http2stream_constructor_template, v8::ObjectTemplate)                      \
489
  V(http2ping_constructor_template, v8::ObjectTemplate)                        \
490
  V(i18n_converter_template, v8::ObjectTemplate)                               \
491
  V(intervalhistogram_constructor_template, v8::FunctionTemplate)              \
492
  V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                     \
493
  V(message_port_constructor_template, v8::FunctionTemplate)                   \
494
  V(microtask_queue_ctor_template, v8::FunctionTemplate)                       \
495
  V(pipe_constructor_template, v8::FunctionTemplate)                           \
496
  V(promise_wrap_template, v8::ObjectTemplate)                                 \
497
  V(sab_lifetimepartner_constructor_template, v8::FunctionTemplate)            \
498
  V(script_context_constructor_template, v8::FunctionTemplate)                 \
499
  V(secure_context_constructor_template, v8::FunctionTemplate)                 \
500
  V(shutdown_wrap_template, v8::ObjectTemplate)                                \
501
  V(socketaddress_constructor_template, v8::FunctionTemplate)                  \
502
  V(streambaseoutputstream_constructor_template, v8::ObjectTemplate)           \
503
  V(qlogoutputstream_constructor_template, v8::ObjectTemplate)                 \
504
  V(tcp_constructor_template, v8::FunctionTemplate)                            \
505
  V(tty_constructor_template, v8::FunctionTemplate)                            \
506
  V(write_wrap_template, v8::ObjectTemplate)                                   \
507
  V(worker_heap_snapshot_taker_template, v8::ObjectTemplate)                   \
508
  V(x509_constructor_template, v8::FunctionTemplate)
509
510
#define ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)                                \
511
  V(async_hooks_after_function, v8::Function)                                  \
512
  V(async_hooks_before_function, v8::Function)                                 \
513
  V(async_hooks_callback_trampoline, v8::Function)                             \
514
  V(async_hooks_binding, v8::Object)                                           \
515
  V(async_hooks_destroy_function, v8::Function)                                \
516
  V(async_hooks_init_function, v8::Function)                                   \
517
  V(async_hooks_promise_resolve_function, v8::Function)                        \
518
  V(buffer_prototype_object, v8::Object)                                       \
519
  V(crypto_key_object_constructor, v8::Function)                               \
520
  V(crypto_key_object_handle_constructor, v8::Function)                        \
521
  V(crypto_key_object_private_constructor, v8::Function)                       \
522
  V(crypto_key_object_public_constructor, v8::Function)                        \
523
  V(crypto_key_object_secret_constructor, v8::Function)                        \
524
  V(domexception_function, v8::Function)                                       \
525
  V(enhance_fatal_stack_after_inspector, v8::Function)                         \
526
  V(enhance_fatal_stack_before_inspector, v8::Function)                        \
527
  V(fs_use_promises_symbol, v8::Symbol)                                        \
528
  V(host_import_module_dynamically_callback, v8::Function)                     \
529
  V(host_initialize_import_meta_object_callback, v8::Function)                 \
530
  V(http2session_on_altsvc_function, v8::Function)                             \
531
  V(http2session_on_error_function, v8::Function)                              \
532
  V(http2session_on_frame_error_function, v8::Function)                        \
533
  V(http2session_on_goaway_data_function, v8::Function)                        \
534
  V(http2session_on_headers_function, v8::Function)                            \
535
  V(http2session_on_origin_function, v8::Function)                             \
536
  V(http2session_on_ping_function, v8::Function)                               \
537
  V(http2session_on_priority_function, v8::Function)                           \
538
  V(http2session_on_settings_function, v8::Function)                           \
539
  V(http2session_on_stream_close_function, v8::Function)                       \
540
  V(http2session_on_stream_trailers_function, v8::Function)                    \
541
  V(internal_binding_loader, v8::Function)                                     \
542
  V(immediate_callback_function, v8::Function)                                 \
543
  V(inspector_console_extension_installer, v8::Function)                       \
544
  V(inspector_disable_async_hooks, v8::Function)                               \
545
  V(inspector_enable_async_hooks, v8::Function)                                \
546
  V(maybe_cache_generated_source_map, v8::Function)                            \
547
  V(messaging_deserialize_create_object, v8::Function)                         \
548
  V(message_port, v8::Object)                                                  \
549
  V(native_module_require, v8::Function)                                       \
550
  V(performance_entry_callback, v8::Function)                                  \
551
  V(performance_entry_template, v8::Function)                                  \
552
  V(prepare_stack_trace_callback, v8::Function)                                \
553
  V(process_object, v8::Object)                                                \
554
  V(primordials, v8::Object)                                                   \
555
  V(primordials_safe_map_prototype_object, v8::Object)                         \
556
  V(primordials_safe_set_prototype_object, v8::Object)                         \
557
  V(primordials_safe_weak_map_prototype_object, v8::Object)                    \
558
  V(primordials_safe_weak_set_prototype_object, v8::Object)                    \
559
  V(promise_hook_handler, v8::Function)                                        \
560
  V(promise_reject_callback, v8::Function)                                     \
561
  V(script_data_constructor_function, v8::Function)                            \
562
  V(snapshot_serialize_callback, v8::Function)                                 \
563
  V(snapshot_deserialize_callback, v8::Function)                               \
564
  V(snapshot_deserialize_main, v8::Function)                                   \
565
  V(source_map_cache_getter, v8::Function)                                     \
566
  V(tick_callback_function, v8::Function)                                      \
567
  V(timers_callback_function, v8::Function)                                    \
568
  V(tls_wrap_constructor_function, v8::Function)                               \
569
  V(trace_category_state_function, v8::Function)                               \
570
  V(udp_constructor_function, v8::Function)                                    \
571
  V(url_constructor_function, v8::Function)                                    \
572
  V(wasm_streaming_compilation_impl, v8::Function)                             \
573
  V(wasm_streaming_object_constructor, v8::Function)
574
575
class Environment;
576
577
typedef size_t SnapshotIndex;
578
class NODE_EXTERN_PRIVATE IsolateData : public MemoryRetainer {
579
 public:
580
  IsolateData(v8::Isolate* isolate,
581
              uv_loop_t* event_loop,
582
              MultiIsolatePlatform* platform = nullptr,
583
              ArrayBufferAllocator* node_allocator = nullptr,
584
              const std::vector<size_t>* indexes = nullptr);
585
24
  SET_MEMORY_INFO_NAME(IsolateData)
586
24
  SET_SELF_SIZE(IsolateData)
587
  void MemoryInfo(MemoryTracker* tracker) const override;
588
  std::vector<size_t> Serialize(v8::SnapshotCreator* creator);
589
590
  inline uv_loop_t* event_loop() const;
591
  inline MultiIsolatePlatform* platform() const;
592
  inline std::shared_ptr<PerIsolateOptions> options();
593
  inline void set_options(std::shared_ptr<PerIsolateOptions> options);
594
595
  inline NodeArrayBufferAllocator* node_allocator() const;
596
597
  inline worker::Worker* worker_context() const;
598
  inline void set_worker_context(worker::Worker* context);
599
600
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
601
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
602
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
603
#define V(TypeName, PropertyName)                                             \
604
  inline v8::Local<TypeName> PropertyName() const;
605
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
606
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
607
  PER_ISOLATE_STRING_PROPERTIES(VS)
608
#undef V
609
#undef VY
610
#undef VS
611
#undef VP
612
  inline v8::Local<v8::String> async_wrap_provider(int index) const;
613
614
  size_t max_young_gen_size = 1;
615
  std::unordered_map<const char*, v8::Eternal<v8::String>> static_str_map;
616
617
  inline v8::Isolate* isolate() const;
618
  IsolateData(const IsolateData&) = delete;
619
  IsolateData& operator=(const IsolateData&) = delete;
620
  IsolateData(IsolateData&&) = delete;
621
  IsolateData& operator=(IsolateData&&) = delete;
622
623
 private:
624
  void DeserializeProperties(const std::vector<size_t>* indexes);
625
  void CreateProperties();
626
627
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
628
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
629
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
630
#define V(TypeName, PropertyName)                                             \
631
  v8::Eternal<TypeName> PropertyName ## _;
632
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
633
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
634
  PER_ISOLATE_STRING_PROPERTIES(VS)
635
#undef V
636
#undef VY
637
#undef VS
638
#undef VP
639
  // Keep a list of all Persistent strings used for AsyncWrap Provider types.
640
  std::array<v8::Eternal<v8::String>, AsyncWrap::PROVIDERS_LENGTH>
641
      async_wrap_providers_;
642
643
  v8::Isolate* const isolate_;
644
  uv_loop_t* const event_loop_;
645
  NodeArrayBufferAllocator* const node_allocator_;
646
  MultiIsolatePlatform* platform_;
647
  std::shared_ptr<PerIsolateOptions> options_;
648
  worker::Worker* worker_context_ = nullptr;
649
};
650
651
struct ContextInfo {
652
13753
  explicit ContextInfo(const std::string& name) : name(name) {}
653
  const std::string name;
654
  std::string origin;
655
  bool is_default = false;
656
};
657
658
class EnabledDebugList;
659
660
namespace per_process {
661
extern std::shared_ptr<KVStore> system_environment;
662
}
663
664
struct EnvSerializeInfo;
665
666
class AsyncHooks : public MemoryRetainer {
667
 public:
668
24
  SET_MEMORY_INFO_NAME(AsyncHooks)
669
24
  SET_SELF_SIZE(AsyncHooks)
670
  void MemoryInfo(MemoryTracker* tracker) const override;
671
672
  // Reason for both UidFields and Fields are that one is stored as a double*
673
  // and the other as a uint32_t*.
674
  enum Fields {
675
    kInit,
676
    kBefore,
677
    kAfter,
678
    kDestroy,
679
    kPromiseResolve,
680
    kTotals,
681
    kCheck,
682
    kStackLength,
683
    kUsesExecutionAsyncResource,
684
    kFieldsCount,
685
  };
686
687
  enum UidFields {
688
    kExecutionAsyncId,
689
    kTriggerAsyncId,
690
    kAsyncIdCounter,
691
    kDefaultTriggerAsyncId,
692
    kUidFieldsCount,
693
  };
694
695
  inline AliasedUint32Array& fields();
696
  inline AliasedFloat64Array& async_id_fields();
697
  inline AliasedFloat64Array& async_ids_stack();
698
  inline v8::Local<v8::Array> js_execution_async_resources();
699
  // Returns the native executionAsyncResource value at stack index `index`.
700
  // Resources provided on the JS side are not stored on the native stack,
701
  // in which case an empty `Local<>` is returned.
702
  // The `js_execution_async_resources` array contains the value in that case.
703
  inline v8::Local<v8::Object> native_execution_async_resource(size_t index);
704
705
  void SetJSPromiseHooks(v8::Local<v8::Function> init,
706
                         v8::Local<v8::Function> before,
707
                         v8::Local<v8::Function> after,
708
                         v8::Local<v8::Function> resolve);
709
710
  inline v8::Local<v8::String> provider_string(int idx);
711
712
  inline void no_force_checks();
713
  inline Environment* env();
714
715
  // NB: This call does not take (co-)ownership of `execution_async_resource`.
716
  // The lifetime of the `v8::Local<>` pointee must last until
717
  // `pop_async_context()` or `clear_async_id_stack()` are called.
718
  void push_async_context(double async_id,
719
                          double trigger_async_id,
720
                          v8::Local<v8::Object> execution_async_resource);
721
  bool pop_async_context(double async_id);
722
  void clear_async_id_stack();  // Used in fatal exceptions.
723
724
  void AddContext(v8::Local<v8::Context> ctx);
725
  void RemoveContext(v8::Local<v8::Context> ctx);
726
727
  AsyncHooks(const AsyncHooks&) = delete;
728
  AsyncHooks& operator=(const AsyncHooks&) = delete;
729
  AsyncHooks(AsyncHooks&&) = delete;
730
  AsyncHooks& operator=(AsyncHooks&&) = delete;
731
23820
  ~AsyncHooks() = default;
732
733
  // Used to set the kDefaultTriggerAsyncId in a scope. This is instead of
734
  // passing the trigger_async_id along with other constructor arguments.
735
  class DefaultTriggerAsyncIdScope {
736
   public:
737
    DefaultTriggerAsyncIdScope() = delete;
738
    explicit DefaultTriggerAsyncIdScope(Environment* env,
739
                                        double init_trigger_async_id);
740
    explicit DefaultTriggerAsyncIdScope(AsyncWrap* async_wrap);
741
    ~DefaultTriggerAsyncIdScope();
742
743
    DefaultTriggerAsyncIdScope(const DefaultTriggerAsyncIdScope&) = delete;
744
    DefaultTriggerAsyncIdScope& operator=(const DefaultTriggerAsyncIdScope&) =
745
        delete;
746
    DefaultTriggerAsyncIdScope(DefaultTriggerAsyncIdScope&&) = delete;
747
    DefaultTriggerAsyncIdScope& operator=(DefaultTriggerAsyncIdScope&&) =
748
        delete;
749
750
   private:
751
    AsyncHooks* async_hooks_;
752
    double old_default_trigger_async_id_;
753
  };
754
755
  struct SerializeInfo {
756
    AliasedBufferIndex async_ids_stack;
757
    AliasedBufferIndex fields;
758
    AliasedBufferIndex async_id_fields;
759
    SnapshotIndex js_execution_async_resources;
760
    std::vector<SnapshotIndex> native_execution_async_resources;
761
  };
762
763
  SerializeInfo Serialize(v8::Local<v8::Context> context,
764
                          v8::SnapshotCreator* creator);
765
  void Deserialize(v8::Local<v8::Context> context);
766
767
 private:
768
  friend class Environment;  // So we can call the constructor.
769
  explicit AsyncHooks(v8::Isolate* isolate, const SerializeInfo* info);
770
771
  [[noreturn]] void FailWithCorruptedAsyncStack(double expected_async_id);
772
773
  // Stores the ids of the current execution context stack.
774
  AliasedFloat64Array async_ids_stack_;
775
  // Attached to a Uint32Array that tracks the number of active hooks for
776
  // each type.
777
  AliasedUint32Array fields_;
778
  // Attached to a Float64Array that tracks the state of async resources.
779
  AliasedFloat64Array async_id_fields_;
780
781
  void grow_async_ids_stack();
782
783
  v8::Global<v8::Array> js_execution_async_resources_;
784
  std::vector<v8::Local<v8::Object>> native_execution_async_resources_;
785
786
  // Non-empty during deserialization
787
  const SerializeInfo* info_ = nullptr;
788
789
  std::vector<v8::Global<v8::Context>> contexts_;
790
791
  std::array<v8::Global<v8::Function>, 4> js_promise_hooks_;
792
};
793
794
class ImmediateInfo : public MemoryRetainer {
795
 public:
796
  inline AliasedUint32Array& fields();
797
  inline uint32_t count() const;
798
  inline uint32_t ref_count() const;
799
  inline bool has_outstanding() const;
800
  inline void ref_count_inc(uint32_t increment);
801
  inline void ref_count_dec(uint32_t decrement);
802
803
  ImmediateInfo(const ImmediateInfo&) = delete;
804
  ImmediateInfo& operator=(const ImmediateInfo&) = delete;
805
  ImmediateInfo(ImmediateInfo&&) = delete;
806
  ImmediateInfo& operator=(ImmediateInfo&&) = delete;
807
11910
  ~ImmediateInfo() = default;
808
809
24
  SET_MEMORY_INFO_NAME(ImmediateInfo)
810
24
  SET_SELF_SIZE(ImmediateInfo)
811
  void MemoryInfo(MemoryTracker* tracker) const override;
812
813
  struct SerializeInfo {
814
    AliasedBufferIndex fields;
815
  };
816
  SerializeInfo Serialize(v8::Local<v8::Context> context,
817
                          v8::SnapshotCreator* creator);
818
  void Deserialize(v8::Local<v8::Context> context);
819
820
 private:
821
  friend class Environment;  // So we can call the constructor.
822
  explicit ImmediateInfo(v8::Isolate* isolate, const SerializeInfo* info);
823
824
  enum Fields { kCount, kRefCount, kHasOutstanding, kFieldsCount };
825
826
  AliasedUint32Array fields_;
827
};
828
829
class TickInfo : public MemoryRetainer {
830
 public:
831
  inline AliasedUint8Array& fields();
832
  inline bool has_tick_scheduled() const;
833
  inline bool has_rejection_to_warn() const;
834
835
24
  SET_MEMORY_INFO_NAME(TickInfo)
836
24
  SET_SELF_SIZE(TickInfo)
837
  void MemoryInfo(MemoryTracker* tracker) const override;
838
839
  TickInfo(const TickInfo&) = delete;
840
  TickInfo& operator=(const TickInfo&) = delete;
841
  TickInfo(TickInfo&&) = delete;
842
  TickInfo& operator=(TickInfo&&) = delete;
843
11910
  ~TickInfo() = default;
844
845
  struct SerializeInfo {
846
    AliasedBufferIndex fields;
847
  };
848
  SerializeInfo Serialize(v8::Local<v8::Context> context,
849
                          v8::SnapshotCreator* creator);
850
  void Deserialize(v8::Local<v8::Context> context);
851
852
 private:
853
  friend class Environment;  // So we can call the constructor.
854
  explicit TickInfo(v8::Isolate* isolate, const SerializeInfo* info);
855
856
  enum Fields { kHasTickScheduled = 0, kHasRejectionToWarn, kFieldsCount };
857
858
  AliasedUint8Array fields_;
859
};
860
861
class TrackingTraceStateObserver :
862
    public v8::TracingController::TraceStateObserver {
863
 public:
864
6564
  explicit TrackingTraceStateObserver(Environment* env) : env_(env) {}
865
866
87
  void OnTraceEnabled() override {
867
87
    UpdateTraceCategoryState();
868
87
  }
869
870
34
  void OnTraceDisabled() override {
871
34
    UpdateTraceCategoryState();
872
34
  }
873
874
 private:
875
  void UpdateTraceCategoryState();
876
877
  Environment* env_;
878
};
879
880
class ShouldNotAbortOnUncaughtScope {
881
 public:
882
  explicit inline ShouldNotAbortOnUncaughtScope(Environment* env);
883
  inline void Close();
884
  inline ~ShouldNotAbortOnUncaughtScope();
885
  ShouldNotAbortOnUncaughtScope(const ShouldNotAbortOnUncaughtScope&) = delete;
886
  ShouldNotAbortOnUncaughtScope& operator=(
887
      const ShouldNotAbortOnUncaughtScope&) = delete;
888
  ShouldNotAbortOnUncaughtScope(ShouldNotAbortOnUncaughtScope&&) = delete;
889
  ShouldNotAbortOnUncaughtScope& operator=(ShouldNotAbortOnUncaughtScope&&) =
890
      delete;
891
892
 private:
893
  Environment* env_;
894
};
895
896
class CleanupHookCallback {
897
 public:
898
  typedef void (*Callback)(void*);
899
900
3121533
  CleanupHookCallback(Callback fn,
901
                      void* arg,
902
                      uint64_t insertion_order_counter)
903
3121533
      : fn_(fn), arg_(arg), insertion_order_counter_(insertion_order_counter) {}
904
905
  // Only hashes `arg_`, since that is usually enough to identify the hook.
906
  struct Hash {
907
    inline size_t operator()(const CleanupHookCallback& cb) const;
908
  };
909
910
  // Compares by `fn_` and `arg_` being equal.
911
  struct Equal {
912
    inline bool operator()(const CleanupHookCallback& a,
913
                           const CleanupHookCallback& b) const;
914
  };
915
916
  inline BaseObject* GetBaseObject() const;
917
918
 private:
919
  friend class Environment;
920
  Callback fn_;
921
  void* arg_;
922
923
  // We keep track of the insertion order for these objects, so that we can
924
  // call the callbacks in reverse order when we are cleaning up.
925
  uint64_t insertion_order_counter_;
926
};
927
928
struct PropInfo {
929
  std::string name;     // name for debugging
930
  size_t id;            // In the list - in case there are any empty entries
931
  SnapshotIndex index;  // In the snapshot
932
};
933
934
typedef void (*DeserializeRequestCallback)(v8::Local<v8::Context> context,
935
                                           v8::Local<v8::Object> holder,
936
                                           int index,
937
                                           InternalFieldInfo* info);
938
struct DeserializeRequest {
939
  DeserializeRequestCallback cb;
940
  v8::Global<v8::Object> holder;
941
  int index;
942
  InternalFieldInfo* info = nullptr;  // Owned by the request
943
944
  // Move constructor
945
42088
  DeserializeRequest(DeserializeRequest&& other) = default;
946
};
947
948
struct EnvSerializeInfo {
949
  std::vector<PropInfo> bindings;
950
  std::vector<std::string> native_modules;
951
  AsyncHooks::SerializeInfo async_hooks;
952
  TickInfo::SerializeInfo tick_info;
953
  ImmediateInfo::SerializeInfo immediate_info;
954
  performance::PerformanceState::SerializeInfo performance_state;
955
  AliasedBufferIndex stream_base_state;
956
  AliasedBufferIndex should_abort_on_uncaught_toggle;
957
958
  std::vector<PropInfo> persistent_templates;
959
  std::vector<PropInfo> persistent_values;
960
961
  SnapshotIndex context;
962
  friend std::ostream& operator<<(std::ostream& o, const EnvSerializeInfo& i);
963
};
964
965
struct SnapshotData {
966
  enum class DataOwnership { kOwned, kNotOwned };
967
968
  static const size_t kNodeBaseContextIndex = 0;
969
  static const size_t kNodeMainContextIndex = kNodeBaseContextIndex + 1;
970
971
  DataOwnership data_ownership = DataOwnership::kOwned;
972
973
  // The result of v8::SnapshotCreator::CreateBlob() during the snapshot
974
  // building process.
975
  v8::StartupData v8_snapshot_blob_data{nullptr, 0};
976
977
  std::vector<size_t> isolate_data_indices;
978
  // TODO(joyeecheung): there should be a vector of env_info once we snapshot
979
  // the worker environments.
980
  EnvSerializeInfo env_info;
981
  // A vector of built-in ids and v8::ScriptCompiler::CachedData, this can be
982
  // shared across Node.js instances because they are supposed to share the
983
  // read only space. We use native_module::CodeCacheInfo because
984
  // v8::ScriptCompiler::CachedData is not copyable.
985
  std::vector<native_module::CodeCacheInfo> code_cache;
986
987
  ~SnapshotData();
988
989
  SnapshotData(const SnapshotData&) = delete;
990
  SnapshotData& operator=(const SnapshotData&) = delete;
991
  SnapshotData(SnapshotData&&) = delete;
992
  SnapshotData& operator=(SnapshotData&&) = delete;
993
994
6
  SnapshotData() = default;
995
};
996
997
class Environment : public MemoryRetainer {
998
 public:
999
  Environment(const Environment&) = delete;
1000
  Environment& operator=(const Environment&) = delete;
1001
  Environment(Environment&&) = delete;
1002
  Environment& operator=(Environment&&) = delete;
1003
1004
24
  SET_MEMORY_INFO_NAME(Environment)
1005
1006
  inline size_t SelfSize() const override;
1007
48
  bool IsRootNode() const override { return true; }
1008
  void MemoryInfo(MemoryTracker* tracker) const override;
1009
1010
  EnvSerializeInfo Serialize(v8::SnapshotCreator* creator);
1011
  void CreateProperties();
1012
  void DeserializeProperties(const EnvSerializeInfo* info);
1013
1014
  void PrintInfoForSnapshotIfDebug();
1015
  void PrintAllBaseObjects();
1016
  void VerifyNoStrongBaseObjects();
1017
  void EnqueueDeserializeRequest(DeserializeRequestCallback cb,
1018
                                 v8::Local<v8::Object> holder,
1019
                                 int index,
1020
                                 InternalFieldInfo* info);
1021
  void RunDeserializeRequests();
1022
  // Should be called before InitializeInspector()
1023
  void InitializeDiagnostics();
1024
1025
  std::string GetCwd();
1026
1027
#if HAVE_INSPECTOR
1028
  // If the environment is created for a worker, pass parent_handle and
1029
  // the ownership if transferred into the Environment.
1030
  int InitializeInspector(
1031
      std::unique_ptr<inspector::ParentInspectorHandle> parent_handle);
1032
#endif
1033
1034
  v8::MaybeLocal<v8::Value> BootstrapInternalLoaders();
1035
  v8::MaybeLocal<v8::Value> BootstrapNode();
1036
  v8::MaybeLocal<v8::Value> RunBootstrapping();
1037
1038
  inline size_t async_callback_scope_depth() const;
1039
  inline void PushAsyncCallbackScope();
1040
  inline void PopAsyncCallbackScope();
1041
1042
  static inline Environment* GetCurrent(v8::Isolate* isolate);
1043
  static inline Environment* GetCurrent(v8::Local<v8::Context> context);
1044
  static inline Environment* GetCurrent(
1045
      const v8::FunctionCallbackInfo<v8::Value>& info);
1046
1047
  template <typename T>
1048
  static inline Environment* GetCurrent(
1049
      const v8::PropertyCallbackInfo<T>& info);
1050
1051
  // Methods created using SetMethod(), SetPrototypeMethod(), etc. inside
1052
  // this scope can access the created T* object using
1053
  // GetBindingData<T>(args) later.
1054
  template <typename T>
1055
  T* AddBindingData(v8::Local<v8::Context> context,
1056
                    v8::Local<v8::Object> target);
1057
  template <typename T, typename U>
1058
  static inline T* GetBindingData(const v8::PropertyCallbackInfo<U>& info);
1059
  template <typename T>
1060
  static inline T* GetBindingData(
1061
      const v8::FunctionCallbackInfo<v8::Value>& info);
1062
  template <typename T>
1063
  static inline T* GetBindingData(v8::Local<v8::Context> context);
1064
1065
  typedef std::unordered_map<
1066
      FastStringKey,
1067
      BaseObjectPtr<BaseObject>,
1068
      FastStringKey::Hash> BindingDataStore;
1069
1070
  // Create an Environment without initializing a main Context. Use
1071
  // InitializeMainContext() to initialize a main context for it.
1072
  Environment(IsolateData* isolate_data,
1073
              v8::Isolate* isolate,
1074
              const std::vector<std::string>& args,
1075
              const std::vector<std::string>& exec_args,
1076
              const EnvSerializeInfo* env_info,
1077
              EnvironmentFlags::Flags flags,
1078
              ThreadId thread_id);
1079
  void InitializeMainContext(v8::Local<v8::Context> context,
1080
                             const EnvSerializeInfo* env_info);
1081
  // Create an Environment and initialize the provided main context for it.
1082
  Environment(IsolateData* isolate_data,
1083
              v8::Local<v8::Context> context,
1084
              const std::vector<std::string>& args,
1085
              const std::vector<std::string>& exec_args,
1086
              const EnvSerializeInfo* env_info,
1087
              EnvironmentFlags::Flags flags,
1088
              ThreadId thread_id);
1089
  ~Environment() override;
1090
1091
  void InitializeLibuv();
1092
  inline const std::vector<std::string>& exec_argv();
1093
  inline const std::vector<std::string>& argv();
1094
  const std::string& exec_path() const;
1095
1096
  typedef void (*HandleCleanupCb)(Environment* env,
1097
                                  uv_handle_t* handle,
1098
                                  void* arg);
1099
  struct HandleCleanup {
1100
    uv_handle_t* handle_;
1101
    HandleCleanupCb cb_;
1102
    void* arg_;
1103
  };
1104
1105
  void RegisterHandleCleanups();
1106
  void CleanupHandles();
1107
  void Exit(int code);
1108
  void ExitEnv();
1109
1110
  // Register clean-up cb to be called on environment destruction.
1111
  inline void RegisterHandleCleanup(uv_handle_t* handle,
1112
                                    HandleCleanupCb cb,
1113
                                    void* arg);
1114
1115
  template <typename T, typename OnCloseCallback>
1116
  inline void CloseHandle(T* handle, OnCloseCallback callback);
1117
1118
  void AssignToContext(v8::Local<v8::Context> context, const ContextInfo& info);
1119
1120
  void StartProfilerIdleNotifier();
1121
1122
  inline v8::Isolate* isolate() const;
1123
  inline uv_loop_t* event_loop() const;
1124
  void TryLoadAddon(const char* filename,
1125
                    int flags,
1126
                    const std::function<bool(binding::DLib*)>& was_loaded);
1127
1128
  static inline Environment* from_timer_handle(uv_timer_t* handle);
1129
  inline uv_timer_t* timer_handle();
1130
1131
  static inline Environment* from_immediate_check_handle(uv_check_t* handle);
1132
  inline uv_check_t* immediate_check_handle();
1133
  inline uv_idle_t* immediate_idle_handle();
1134
1135
  inline void IncreaseWaitingRequestCounter();
1136
  inline void DecreaseWaitingRequestCounter();
1137
1138
  inline AsyncHooks* async_hooks();
1139
  inline ImmediateInfo* immediate_info();
1140
  inline TickInfo* tick_info();
1141
  inline uint64_t timer_base() const;
1142
  inline std::shared_ptr<KVStore> env_vars();
1143
  inline void set_env_vars(std::shared_ptr<KVStore> env_vars);
1144
1145
  inline IsolateData* isolate_data() const;
1146
1147
  inline bool printed_error() const;
1148
  inline void set_printed_error(bool value);
1149
1150
  void PrintSyncTrace() const;
1151
  inline void set_trace_sync_io(bool value);
1152
1153
  inline void set_force_context_aware(bool value);
1154
  inline bool force_context_aware() const;
1155
1156
  // This stores whether the --abort-on-uncaught-exception flag was passed
1157
  // to Node.
1158
  inline bool abort_on_uncaught_exception() const;
1159
  inline void set_abort_on_uncaught_exception(bool value);
1160
  // This is a pseudo-boolean that keeps track of whether an uncaught exception
1161
  // should abort the process or not if --abort-on-uncaught-exception was
1162
  // passed to Node. If the flag was not passed, it is ignored.
1163
  inline AliasedUint32Array& should_abort_on_uncaught_toggle();
1164
1165
  inline AliasedInt32Array& stream_base_state();
1166
1167
  // The necessary API for async_hooks.
1168
  inline double new_async_id();
1169
  inline double execution_async_id();
1170
  inline double trigger_async_id();
1171
  inline double get_default_trigger_async_id();
1172
1173
  // List of id's that have been destroyed and need the destroy() cb called.
1174
  inline std::vector<double>* destroy_async_id_list();
1175
1176
  std::set<struct node_module*> internal_bindings;
1177
  std::set<std::string> native_modules_with_cache;
1178
  std::set<std::string> native_modules_without_cache;
1179
  // This is only filled during deserialization. We use a vector since
1180
  // it's only used for tests.
1181
  std::vector<std::string> native_modules_in_snapshot;
1182
1183
  std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
1184
  std::unordered_map<uint32_t, loader::ModuleWrap*> id_to_module_map;
1185
  std::unordered_map<uint32_t, contextify::ContextifyScript*>
1186
      id_to_script_map;
1187
  std::unordered_map<uint32_t, contextify::CompiledFnEntry*> id_to_function_map;
1188
1189
  inline uint32_t get_next_module_id();
1190
  inline uint32_t get_next_script_id();
1191
  inline uint32_t get_next_function_id();
1192
1193
1400546
  EnabledDebugList* enabled_debug_list() { return &enabled_debug_list_; }
1194
1195
  inline performance::PerformanceState* performance_state();
1196
1197
  void CollectUVExceptionInfo(v8::Local<v8::Value> context,
1198
                              int errorno,
1199
                              const char* syscall = nullptr,
1200
                              const char* message = nullptr,
1201
                              const char* path = nullptr,
1202
                              const char* dest = nullptr);
1203
1204
  // If this flag is set, calls into JS (if they would be observable
1205
  // from userland) must be avoided.  This flag does not indicate whether
1206
  // calling into JS is allowed from a VM perspective at this point.
1207
  inline bool can_call_into_js() const;
1208
  inline void set_can_call_into_js(bool can_call_into_js);
1209
1210
  // Increase or decrease a counter that manages whether this Environment
1211
  // keeps the event loop alive on its own or not. The counter starts out at 0,
1212
  // meaning it does not, and any positive value will make it keep the event
1213
  // loop alive.
1214
  // This is used by Workers to manage their own .ref()/.unref() implementation,
1215
  // as Workers aren't directly associated with their own libuv handles.
1216
  void add_refs(int64_t diff);
1217
1218
  inline bool has_run_bootstrapping_code() const;
1219
  inline void DoneBootstrapping();
1220
1221
  inline bool has_serialized_options() const;
1222
  inline void set_has_serialized_options(bool has_serialized_options);
1223
1224
  inline bool is_main_thread() const;
1225
  inline bool no_native_addons() const;
1226
  inline bool should_not_register_esm_loader() const;
1227
  inline bool should_create_inspector() const;
1228
  inline bool owns_process_state() const;
1229
  inline bool owns_inspector() const;
1230
  inline bool tracks_unmanaged_fds() const;
1231
  inline bool hide_console_windows() const;
1232
  inline bool no_global_search_paths() const;
1233
  inline bool no_browser_globals() const;
1234
  inline uint64_t thread_id() const;
1235
  inline worker::Worker* worker_context() const;
1236
  Environment* worker_parent_env() const;
1237
  inline void add_sub_worker_context(worker::Worker* context);
1238
  inline void remove_sub_worker_context(worker::Worker* context);
1239
  void stop_sub_worker_contexts();
1240
  template <typename Fn>
1241
  inline void ForEachWorker(Fn&& iterator);
1242
  inline bool is_stopping() const;
1243
  inline void set_stopping(bool value);
1244
  inline std::list<node_module>* extra_linked_bindings();
1245
  inline node_module* extra_linked_bindings_head();
1246
  inline node_module* extra_linked_bindings_tail();
1247
  inline const Mutex& extra_linked_bindings_mutex() const;
1248
1249
  inline bool filehandle_close_warning() const;
1250
  inline void set_filehandle_close_warning(bool on);
1251
1252
  inline void set_source_maps_enabled(bool on);
1253
  inline bool source_maps_enabled() const;
1254
1255
  inline void ThrowError(const char* errmsg);
1256
  inline void ThrowTypeError(const char* errmsg);
1257
  inline void ThrowRangeError(const char* errmsg);
1258
  inline void ThrowErrnoException(int errorno,
1259
                                  const char* syscall = nullptr,
1260
                                  const char* message = nullptr,
1261
                                  const char* path = nullptr);
1262
  inline void ThrowUVException(int errorno,
1263
                               const char* syscall = nullptr,
1264
                               const char* message = nullptr,
1265
                               const char* path = nullptr,
1266
                               const char* dest = nullptr);
1267
1268
  v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
1269
      v8::FunctionCallback callback,
1270
      v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
1271
      v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
1272
      v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
1273
      const v8::CFunction* c_function = nullptr);
1274
1275
  // Convenience methods for NewFunctionTemplate().
1276
  void SetMethod(v8::Local<v8::Object> that,
1277
                 const char* name,
1278
                 v8::FunctionCallback callback);
1279
1280
  void SetFastMethod(v8::Local<v8::Object> that,
1281
                     const char* name,
1282
                     v8::FunctionCallback slow_callback,
1283
                     const v8::CFunction* c_function);
1284
1285
  void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
1286
                      const char* name,
1287
                      v8::FunctionCallback callback);
1288
1289
  void SetInstanceMethod(v8::Local<v8::FunctionTemplate> that,
1290
                         const char* name,
1291
                         v8::FunctionCallback callback);
1292
1293
  // Safe variants denote the function has no side effects.
1294
  void SetMethodNoSideEffect(v8::Local<v8::Object> that,
1295
                             const char* name,
1296
                             v8::FunctionCallback callback);
1297
  void SetProtoMethodNoSideEffect(v8::Local<v8::FunctionTemplate> that,
1298
                                  const char* name,
1299
                                  v8::FunctionCallback callback);
1300
1301
  enum class SetConstructorFunctionFlag {
1302
    NONE,
1303
    SET_CLASS_NAME,
1304
  };
1305
1306
  void SetConstructorFunction(v8::Local<v8::Object> that,
1307
                              const char* name,
1308
                              v8::Local<v8::FunctionTemplate> tmpl,
1309
                              SetConstructorFunctionFlag flag =
1310
                                  SetConstructorFunctionFlag::SET_CLASS_NAME);
1311
1312
  void SetConstructorFunction(v8::Local<v8::Object> that,
1313
                              v8::Local<v8::String> name,
1314
                              v8::Local<v8::FunctionTemplate> tmpl,
1315
                              SetConstructorFunctionFlag flag =
1316
                                  SetConstructorFunctionFlag::SET_CLASS_NAME);
1317
1318
  void AtExit(void (*cb)(void* arg), void* arg);
1319
  void RunAtExitCallbacks();
1320
1321
  void RunWeakRefCleanup();
1322
1323
  v8::MaybeLocal<v8::Value> RunSnapshotSerializeCallback() const;
1324
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeCallback() const;
1325
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeMain() const;
1326
1327
  // Strings and private symbols are shared across shared contexts
1328
  // The getters simply proxy to the per-isolate primitive.
1329
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
1330
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
1331
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
1332
#define V(TypeName, PropertyName)                                             \
1333
  inline v8::Local<TypeName> PropertyName() const;
1334
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
1335
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
1336
  PER_ISOLATE_STRING_PROPERTIES(VS)
1337
#undef V
1338
#undef VS
1339
#undef VY
1340
#undef VP
1341
1342
#define V(PropertyName, TypeName)                                             \
1343
  inline v8::Local<TypeName> PropertyName() const;                            \
1344
  inline void set_ ## PropertyName(v8::Local<TypeName> value);
1345
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1346
  ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)
1347
#undef V
1348
1349
  inline v8::Local<v8::Context> context() const;
1350
1351
#if HAVE_INSPECTOR
1352
79882
  inline inspector::Agent* inspector_agent() const {
1353
79882
    return inspector_agent_.get();
1354
  }
1355
1356
  inline bool is_in_inspector_console_call() const;
1357
  inline void set_is_in_inspector_console_call(bool value);
1358
#endif
1359
1360
  typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;
1361
  typedef ListHead<ReqWrapBase, &ReqWrapBase::req_wrap_queue_> ReqWrapQueue;
1362
1363
61640
  inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }
1364
79241
  inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }
1365
1366
7850
  inline uint64_t time_origin() {
1367
7850
    return time_origin_;
1368
  }
1369
7834
  inline double time_origin_timestamp() {
1370
7834
    return time_origin_timestamp_;
1371
  }
1372
1373
1
  inline bool EmitProcessEnvWarning() {
1374
1
    bool current_value = emit_env_nonstring_warning_;
1375
1
    emit_env_nonstring_warning_ = false;
1376
1
    return current_value;
1377
  }
1378
1379
1
  inline bool EmitErrNameWarning() {
1380
1
    bool current_value = emit_err_name_warning_;
1381
1
    emit_err_name_warning_ = false;
1382
1
    return current_value;
1383
  }
1384
1385
  // cb will be called as cb(env) on the next event loop iteration.
1386
  // Unlike the JS setImmediate() function, nested SetImmediate() calls will
1387
  // be run without returning control to the event loop, similar to nextTick().
1388
  template <typename Fn>
1389
  inline void SetImmediate(
1390
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1391
  template <typename Fn>
1392
  // This behaves like SetImmediate() but can be called from any thread.
1393
  inline void SetImmediateThreadsafe(
1394
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1395
  // This behaves like V8's Isolate::RequestInterrupt(), but also accounts for
1396
  // the event loop (i.e. combines the V8 function with SetImmediate()).
1397
  // The passed callback may not throw exceptions.
1398
  // This function can be called from any thread.
1399
  template <typename Fn>
1400
  inline void RequestInterrupt(Fn&& cb);
1401
  // This needs to be available for the JS-land setImmediate().
1402
  void ToggleImmediateRef(bool ref);
1403
1404
  inline void PushShouldNotAbortOnUncaughtScope();
1405
  inline void PopShouldNotAbortOnUncaughtScope();
1406
  inline bool inside_should_not_abort_on_uncaught_scope() const;
1407
1408
  static inline Environment* ForAsyncHooks(AsyncHooks* hooks);
1409
1410
  v8::Local<v8::Value> GetNow();
1411
  void ScheduleTimer(int64_t duration);
1412
  void ToggleTimerRef(bool ref);
1413
1414
  using CleanupCallback = CleanupHookCallback::Callback;
1415
  inline void AddCleanupHook(CleanupCallback cb, void* arg);
1416
  inline void RemoveCleanupHook(CleanupCallback cb, void* arg);
1417
  void RunCleanup();
1418
1419
  static size_t NearHeapLimitCallback(void* data,
1420
                                      size_t current_heap_limit,
1421
                                      size_t initial_heap_limit);
1422
  static void BuildEmbedderGraph(v8::Isolate* isolate,
1423
                                 v8::EmbedderGraph* graph,
1424
                                 void* data);
1425
1426
  inline std::shared_ptr<EnvironmentOptions> options();
1427
  inline std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port();
1428
1429
  // The BaseObject count is a debugging helper that makes sure that there are
1430
  // no memory leaks caused by BaseObjects staying alive longer than expected
1431
  // (in particular, no circular BaseObjectPtr references).
1432
  inline void modify_base_object_count(int64_t delta);
1433
  inline int64_t base_object_created_after_bootstrap() const;
1434
  inline int64_t base_object_count() const;
1435
1436
3
  inline int32_t stack_trace_limit() const { return 10; }
1437
1438
#if HAVE_INSPECTOR
1439
  void set_coverage_connection(
1440
      std::unique_ptr<profiler::V8CoverageConnection> connection);
1441
  profiler::V8CoverageConnection* coverage_connection();
1442
1443
  inline void set_coverage_directory(const char* directory);
1444
  inline const std::string& coverage_directory() const;
1445
1446
  void set_cpu_profiler_connection(
1447
      std::unique_ptr<profiler::V8CpuProfilerConnection> connection);
1448
  profiler::V8CpuProfilerConnection* cpu_profiler_connection();
1449
1450
  inline void set_cpu_prof_name(const std::string& name);
1451
  inline const std::string& cpu_prof_name() const;
1452
1453
  inline void set_cpu_prof_interval(uint64_t interval);
1454
  inline uint64_t cpu_prof_interval() const;
1455
1456
  inline void set_cpu_prof_dir(const std::string& dir);
1457
  inline const std::string& cpu_prof_dir() const;
1458
1459
  void set_heap_profiler_connection(
1460
      std::unique_ptr<profiler::V8HeapProfilerConnection> connection);
1461
  profiler::V8HeapProfilerConnection* heap_profiler_connection();
1462
1463
  inline void set_heap_prof_name(const std::string& name);
1464
  inline const std::string& heap_prof_name() const;
1465
1466
  inline void set_heap_prof_dir(const std::string& dir);
1467
  inline const std::string& heap_prof_dir() const;
1468
1469
  inline void set_heap_prof_interval(uint64_t interval);
1470
  inline uint64_t heap_prof_interval() const;
1471
1472
#endif  // HAVE_INSPECTOR
1473
1474
  inline void set_main_utf16(std::unique_ptr<v8::String::Value>);
1475
  inline void set_process_exit_handler(
1476
      std::function<void(Environment*, int)>&& handler);
1477
1478
  void RunAndClearNativeImmediates(bool only_refed = false);
1479
  void RunAndClearInterrupts();
1480
1481
  uv_buf_t allocate_managed_buffer(const size_t suggested_size);
1482
  std::unique_ptr<v8::BackingStore> release_managed_buffer(const uv_buf_t& buf);
1483
1484
  void AddUnmanagedFd(int fd);
1485
  void RemoveUnmanagedFd(int fd);
1486
1487
  template <typename T>
1488
  void ForEachBindingData(T&& iterator);
1489
1490
 private:
1491
  inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
1492
                         const char* errmsg);
1493
1494
  std::list<binding::DLib> loaded_addons_;
1495
  v8::Isolate* const isolate_;
1496
  IsolateData* const isolate_data_;
1497
  uv_timer_t timer_handle_;
1498
  uv_check_t immediate_check_handle_;
1499
  uv_idle_t immediate_idle_handle_;
1500
  uv_prepare_t idle_prepare_handle_;
1501
  uv_check_t idle_check_handle_;
1502
  uv_async_t task_queues_async_;
1503
  int64_t task_queues_async_refs_ = 0;
1504
1505
  AsyncHooks async_hooks_;
1506
  ImmediateInfo immediate_info_;
1507
  TickInfo tick_info_;
1508
  const uint64_t timer_base_;
1509
  std::shared_ptr<KVStore> env_vars_;
1510
  bool printed_error_ = false;
1511
  bool trace_sync_io_ = false;
1512
  bool emit_env_nonstring_warning_ = true;
1513
  bool emit_err_name_warning_ = true;
1514
  bool emit_filehandle_warning_ = true;
1515
  bool source_maps_enabled_ = false;
1516
1517
  size_t async_callback_scope_depth_ = 0;
1518
  std::vector<double> destroy_async_id_list_;
1519
1520
#if HAVE_INSPECTOR
1521
  std::unique_ptr<profiler::V8CoverageConnection> coverage_connection_;
1522
  std::unique_ptr<profiler::V8CpuProfilerConnection> cpu_profiler_connection_;
1523
  std::string coverage_directory_;
1524
  std::string cpu_prof_dir_;
1525
  std::string cpu_prof_name_;
1526
  uint64_t cpu_prof_interval_;
1527
  std::unique_ptr<profiler::V8HeapProfilerConnection> heap_profiler_connection_;
1528
  std::string heap_prof_dir_;
1529
  std::string heap_prof_name_;
1530
  uint64_t heap_prof_interval_;
1531
#endif  // HAVE_INSPECTOR
1532
1533
  std::shared_ptr<EnvironmentOptions> options_;
1534
  // options_ contains debug options parsed from CLI arguments,
1535
  // while inspector_host_port_ stores the actual inspector host
1536
  // and port being used. For example the port is -1 by default
1537
  // and can be specified as 0 (meaning any port allocated when the
1538
  // server starts listening), but when the inspector server starts
1539
  // the inspector_host_port_->port() will be the actual port being
1540
  // used.
1541
  std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port_;
1542
  std::vector<std::string> exec_argv_;
1543
  std::vector<std::string> argv_;
1544
  std::string exec_path_;
1545
1546
  bool is_processing_heap_limit_callback_ = false;
1547
  int64_t heap_limit_snapshot_taken_ = 0;
1548
1549
  uint32_t module_id_counter_ = 0;
1550
  uint32_t script_id_counter_ = 0;
1551
  uint32_t function_id_counter_ = 0;
1552
1553
  AliasedUint32Array should_abort_on_uncaught_toggle_;
1554
  int should_not_abort_scope_counter_ = 0;
1555
1556
  std::unique_ptr<TrackingTraceStateObserver> trace_state_observer_;
1557
1558
  AliasedInt32Array stream_base_state_;
1559
1560
  // https://w3c.github.io/hr-time/#dfn-time-origin
1561
  uint64_t time_origin_;
1562
  // https://w3c.github.io/hr-time/#dfn-get-time-origin-timestamp
1563
  double time_origin_timestamp_;
1564
  std::unique_ptr<performance::PerformanceState> performance_state_;
1565
1566
  bool has_run_bootstrapping_code_ = false;
1567
  bool has_serialized_options_ = false;
1568
1569
  std::atomic_bool can_call_into_js_ { true };
1570
  uint64_t flags_;
1571
  uint64_t thread_id_;
1572
  std::unordered_set<worker::Worker*> sub_worker_contexts_;
1573
1574
  static void* const kNodeContextTagPtr;
1575
  static int const kNodeContextTag;
1576
1577
#if HAVE_INSPECTOR
1578
  std::unique_ptr<inspector::Agent> inspector_agent_;
1579
  bool is_in_inspector_console_call_ = false;
1580
#endif
1581
1582
  std::list<DeserializeRequest> deserialize_requests_;
1583
1584
  // handle_wrap_queue_ and req_wrap_queue_ needs to be at a fixed offset from
1585
  // the start of the class because it is used by
1586
  // src/node_postmortem_metadata.cc to calculate offsets and generate debug
1587
  // symbols for Environment, which assumes that the position of members in
1588
  // memory are predictable. For more information please refer to
1589
  // `doc/contributing/node-postmortem-support.md`
1590
  friend int GenDebugSymbols();
1591
  HandleWrapQueue handle_wrap_queue_;
1592
  ReqWrapQueue req_wrap_queue_;
1593
  std::list<HandleCleanup> handle_cleanup_queue_;
1594
  int handle_cleanup_waiting_ = 0;
1595
  int request_waiting_ = 0;
1596
1597
  EnabledDebugList enabled_debug_list_;
1598
1599
  std::list<node_module> extra_linked_bindings_;
1600
  Mutex extra_linked_bindings_mutex_;
1601
1602
  static void RunTimers(uv_timer_t* handle);
1603
1604
  struct ExitCallback {
1605
    void (*cb_)(void* arg);
1606
    void* arg_;
1607
  };
1608
1609
  std::list<ExitCallback> at_exit_functions_;
1610
1611
  typedef CallbackQueue<void, Environment*> NativeImmediateQueue;
1612
  NativeImmediateQueue native_immediates_;
1613
  Mutex native_immediates_threadsafe_mutex_;
1614
  NativeImmediateQueue native_immediates_threadsafe_;
1615
  NativeImmediateQueue native_immediates_interrupts_;
1616
  // Also guarded by native_immediates_threadsafe_mutex_. This can be used when
1617
  // trying to post tasks from other threads to an Environment, as the libuv
1618
  // handle for the immediate queues (task_queues_async_) may not be initialized
1619
  // yet or already have been destroyed.
1620
  bool task_queues_async_initialized_ = false;
1621
1622
  std::atomic<Environment**> interrupt_data_ {nullptr};
1623
  void RequestInterruptFromV8();
1624
  static void CheckImmediate(uv_check_t* handle);
1625
1626
  BindingDataStore bindings_;
1627
1628
  // Use an unordered_set, so that we have efficient insertion and removal.
1629
  std::unordered_set<CleanupHookCallback,
1630
                     CleanupHookCallback::Hash,
1631
                     CleanupHookCallback::Equal> cleanup_hooks_;
1632
  uint64_t cleanup_hook_counter_ = 0;
1633
  bool started_cleanup_ = false;
1634
1635
  int64_t base_object_count_ = 0;
1636
  int64_t base_object_created_by_bootstrap_ = 0;
1637
  std::atomic_bool is_stopping_ { false };
1638
1639
  std::unordered_set<int> unmanaged_fds_;
1640
1641
  std::function<void(Environment*, int)> process_exit_handler_ {
1642
      DefaultProcessExitHandler };
1643
1644
  template <typename T>
1645
  void ForEachBaseObject(T&& iterator);
1646
1647
#define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName ## _;
1648
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1649
  ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)
1650
#undef V
1651
1652
  v8::Global<v8::Context> context_;
1653
1654
  // Keeps the main script source alive is one was passed to LoadEnvironment().
1655
  // We should probably find a way to just use plain `v8::String`s created from
1656
  // the source passed to LoadEnvironment() directly instead.
1657
  std::unique_ptr<v8::String::Value> main_utf16_;
1658
1659
  // Used by allocate_managed_buffer() and release_managed_buffer() to keep
1660
  // track of the BackingStore for a given pointer.
1661
  std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
1662
      released_allocated_buffers_;
1663
};
1664
1665
}  // namespace node
1666
1667
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
1668
1669
#endif  // SRC_ENV_H_