GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: env.h Lines: 40 40 100.0 %
Date: 2022-07-12 04:19:51 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
13677
  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
class KVStore {
661
 public:
662
6794
  KVStore() = default;
663
12546
  virtual ~KVStore() = default;
664
  KVStore(const KVStore&) = delete;
665
  KVStore& operator=(const KVStore&) = delete;
666
  KVStore(KVStore&&) = delete;
667
  KVStore& operator=(KVStore&&) = delete;
668
669
  virtual v8::MaybeLocal<v8::String> Get(v8::Isolate* isolate,
670
                                         v8::Local<v8::String> key) const = 0;
671
  virtual v8::Maybe<std::string> Get(const char* key) const = 0;
672
  virtual void Set(v8::Isolate* isolate,
673
                   v8::Local<v8::String> key,
674
                   v8::Local<v8::String> value) = 0;
675
  virtual int32_t Query(v8::Isolate* isolate,
676
                        v8::Local<v8::String> key) const = 0;
677
  virtual int32_t Query(const char* key) const = 0;
678
  virtual void Delete(v8::Isolate* isolate, v8::Local<v8::String> key) = 0;
679
  virtual v8::Local<v8::Array> Enumerate(v8::Isolate* isolate) const = 0;
680
681
  virtual std::shared_ptr<KVStore> Clone(v8::Isolate* isolate) const;
682
  virtual v8::Maybe<bool> AssignFromObject(v8::Local<v8::Context> context,
683
                                           v8::Local<v8::Object> entries);
684
685
  static std::shared_ptr<KVStore> CreateMapKVStore();
686
};
687
688
namespace per_process {
689
extern std::shared_ptr<KVStore> system_environment;
690
}
691
692
struct EnvSerializeInfo;
693
694
class AsyncHooks : public MemoryRetainer {
695
 public:
696
24
  SET_MEMORY_INFO_NAME(AsyncHooks)
697
24
  SET_SELF_SIZE(AsyncHooks)
698
  void MemoryInfo(MemoryTracker* tracker) const override;
699
700
  // Reason for both UidFields and Fields are that one is stored as a double*
701
  // and the other as a uint32_t*.
702
  enum Fields {
703
    kInit,
704
    kBefore,
705
    kAfter,
706
    kDestroy,
707
    kPromiseResolve,
708
    kTotals,
709
    kCheck,
710
    kStackLength,
711
    kUsesExecutionAsyncResource,
712
    kFieldsCount,
713
  };
714
715
  enum UidFields {
716
    kExecutionAsyncId,
717
    kTriggerAsyncId,
718
    kAsyncIdCounter,
719
    kDefaultTriggerAsyncId,
720
    kUidFieldsCount,
721
  };
722
723
  inline AliasedUint32Array& fields();
724
  inline AliasedFloat64Array& async_id_fields();
725
  inline AliasedFloat64Array& async_ids_stack();
726
  inline v8::Local<v8::Array> js_execution_async_resources();
727
  // Returns the native executionAsyncResource value at stack index `index`.
728
  // Resources provided on the JS side are not stored on the native stack,
729
  // in which case an empty `Local<>` is returned.
730
  // The `js_execution_async_resources` array contains the value in that case.
731
  inline v8::Local<v8::Object> native_execution_async_resource(size_t index);
732
733
  inline void SetJSPromiseHooks(v8::Local<v8::Function> init,
734
                                v8::Local<v8::Function> before,
735
                                v8::Local<v8::Function> after,
736
                                v8::Local<v8::Function> resolve);
737
738
  inline v8::Local<v8::String> provider_string(int idx);
739
740
  inline void no_force_checks();
741
  inline Environment* env();
742
743
  // NB: This call does not take (co-)ownership of `execution_async_resource`.
744
  // The lifetime of the `v8::Local<>` pointee must last until
745
  // `pop_async_context()` or `clear_async_id_stack()` are called.
746
  inline void push_async_context(double async_id, double trigger_async_id,
747
      v8::Local<v8::Object> execution_async_resource);
748
  inline bool pop_async_context(double async_id);
749
  inline void clear_async_id_stack();  // Used in fatal exceptions.
750
751
  inline void AddContext(v8::Local<v8::Context> ctx);
752
  inline void RemoveContext(v8::Local<v8::Context> ctx);
753
754
  AsyncHooks(const AsyncHooks&) = delete;
755
  AsyncHooks& operator=(const AsyncHooks&) = delete;
756
  AsyncHooks(AsyncHooks&&) = delete;
757
  AsyncHooks& operator=(AsyncHooks&&) = delete;
758
24068
  ~AsyncHooks() = default;
759
760
  // Used to set the kDefaultTriggerAsyncId in a scope. This is instead of
761
  // passing the trigger_async_id along with other constructor arguments.
762
  class DefaultTriggerAsyncIdScope {
763
   public:
764
    DefaultTriggerAsyncIdScope() = delete;
765
    explicit DefaultTriggerAsyncIdScope(Environment* env,
766
                                        double init_trigger_async_id);
767
    explicit DefaultTriggerAsyncIdScope(AsyncWrap* async_wrap);
768
    ~DefaultTriggerAsyncIdScope();
769
770
    DefaultTriggerAsyncIdScope(const DefaultTriggerAsyncIdScope&) = delete;
771
    DefaultTriggerAsyncIdScope& operator=(const DefaultTriggerAsyncIdScope&) =
772
        delete;
773
    DefaultTriggerAsyncIdScope(DefaultTriggerAsyncIdScope&&) = delete;
774
    DefaultTriggerAsyncIdScope& operator=(DefaultTriggerAsyncIdScope&&) =
775
        delete;
776
777
   private:
778
    AsyncHooks* async_hooks_;
779
    double old_default_trigger_async_id_;
780
  };
781
782
  struct SerializeInfo {
783
    AliasedBufferIndex async_ids_stack;
784
    AliasedBufferIndex fields;
785
    AliasedBufferIndex async_id_fields;
786
    SnapshotIndex js_execution_async_resources;
787
    std::vector<SnapshotIndex> native_execution_async_resources;
788
  };
789
790
  SerializeInfo Serialize(v8::Local<v8::Context> context,
791
                          v8::SnapshotCreator* creator);
792
  void Deserialize(v8::Local<v8::Context> context);
793
794
 private:
795
  friend class Environment;  // So we can call the constructor.
796
  explicit AsyncHooks(v8::Isolate* isolate, const SerializeInfo* info);
797
798
  [[noreturn]] void FailWithCorruptedAsyncStack(double expected_async_id);
799
800
  // Stores the ids of the current execution context stack.
801
  AliasedFloat64Array async_ids_stack_;
802
  // Attached to a Uint32Array that tracks the number of active hooks for
803
  // each type.
804
  AliasedUint32Array fields_;
805
  // Attached to a Float64Array that tracks the state of async resources.
806
  AliasedFloat64Array async_id_fields_;
807
808
  void grow_async_ids_stack();
809
810
  v8::Global<v8::Array> js_execution_async_resources_;
811
  std::vector<v8::Local<v8::Object>> native_execution_async_resources_;
812
813
  // Non-empty during deserialization
814
  const SerializeInfo* info_ = nullptr;
815
816
  std::vector<v8::Global<v8::Context>> contexts_;
817
818
  std::array<v8::Global<v8::Function>, 4> js_promise_hooks_;
819
};
820
821
class ImmediateInfo : public MemoryRetainer {
822
 public:
823
  inline AliasedUint32Array& fields();
824
  inline uint32_t count() const;
825
  inline uint32_t ref_count() const;
826
  inline bool has_outstanding() const;
827
  inline void ref_count_inc(uint32_t increment);
828
  inline void ref_count_dec(uint32_t decrement);
829
830
  ImmediateInfo(const ImmediateInfo&) = delete;
831
  ImmediateInfo& operator=(const ImmediateInfo&) = delete;
832
  ImmediateInfo(ImmediateInfo&&) = delete;
833
  ImmediateInfo& operator=(ImmediateInfo&&) = delete;
834
12034
  ~ImmediateInfo() = default;
835
836
24
  SET_MEMORY_INFO_NAME(ImmediateInfo)
837
24
  SET_SELF_SIZE(ImmediateInfo)
838
  void MemoryInfo(MemoryTracker* tracker) const override;
839
840
  struct SerializeInfo {
841
    AliasedBufferIndex fields;
842
  };
843
  SerializeInfo Serialize(v8::Local<v8::Context> context,
844
                          v8::SnapshotCreator* creator);
845
  void Deserialize(v8::Local<v8::Context> context);
846
847
 private:
848
  friend class Environment;  // So we can call the constructor.
849
  explicit ImmediateInfo(v8::Isolate* isolate, const SerializeInfo* info);
850
851
  enum Fields { kCount, kRefCount, kHasOutstanding, kFieldsCount };
852
853
  AliasedUint32Array fields_;
854
};
855
856
class TickInfo : public MemoryRetainer {
857
 public:
858
  inline AliasedUint8Array& fields();
859
  inline bool has_tick_scheduled() const;
860
  inline bool has_rejection_to_warn() const;
861
862
24
  SET_MEMORY_INFO_NAME(TickInfo)
863
24
  SET_SELF_SIZE(TickInfo)
864
  void MemoryInfo(MemoryTracker* tracker) const override;
865
866
  TickInfo(const TickInfo&) = delete;
867
  TickInfo& operator=(const TickInfo&) = delete;
868
  TickInfo(TickInfo&&) = delete;
869
  TickInfo& operator=(TickInfo&&) = delete;
870
12034
  ~TickInfo() = default;
871
872
  struct SerializeInfo {
873
    AliasedBufferIndex fields;
874
  };
875
  SerializeInfo Serialize(v8::Local<v8::Context> context,
876
                          v8::SnapshotCreator* creator);
877
  void Deserialize(v8::Local<v8::Context> context);
878
879
 private:
880
  friend class Environment;  // So we can call the constructor.
881
  explicit TickInfo(v8::Isolate* isolate, const SerializeInfo* info);
882
883
  enum Fields { kHasTickScheduled = 0, kHasRejectionToWarn, kFieldsCount };
884
885
  AliasedUint8Array fields_;
886
};
887
888
class TrackingTraceStateObserver :
889
    public v8::TracingController::TraceStateObserver {
890
 public:
891
6538
  explicit TrackingTraceStateObserver(Environment* env) : env_(env) {}
892
893
87
  void OnTraceEnabled() override {
894
87
    UpdateTraceCategoryState();
895
87
  }
896
897
34
  void OnTraceDisabled() override {
898
34
    UpdateTraceCategoryState();
899
34
  }
900
901
 private:
902
  void UpdateTraceCategoryState();
903
904
  Environment* env_;
905
};
906
907
class ShouldNotAbortOnUncaughtScope {
908
 public:
909
  explicit inline ShouldNotAbortOnUncaughtScope(Environment* env);
910
  inline void Close();
911
  inline ~ShouldNotAbortOnUncaughtScope();
912
  ShouldNotAbortOnUncaughtScope(const ShouldNotAbortOnUncaughtScope&) = delete;
913
  ShouldNotAbortOnUncaughtScope& operator=(
914
      const ShouldNotAbortOnUncaughtScope&) = delete;
915
  ShouldNotAbortOnUncaughtScope(ShouldNotAbortOnUncaughtScope&&) = delete;
916
  ShouldNotAbortOnUncaughtScope& operator=(ShouldNotAbortOnUncaughtScope&&) =
917
      delete;
918
919
 private:
920
  Environment* env_;
921
};
922
923
class CleanupHookCallback {
924
 public:
925
  typedef void (*Callback)(void*);
926
927
2911297
  CleanupHookCallback(Callback fn,
928
                      void* arg,
929
                      uint64_t insertion_order_counter)
930
2911297
      : fn_(fn), arg_(arg), insertion_order_counter_(insertion_order_counter) {}
931
932
  // Only hashes `arg_`, since that is usually enough to identify the hook.
933
  struct Hash {
934
    inline size_t operator()(const CleanupHookCallback& cb) const;
935
  };
936
937
  // Compares by `fn_` and `arg_` being equal.
938
  struct Equal {
939
    inline bool operator()(const CleanupHookCallback& a,
940
                           const CleanupHookCallback& b) const;
941
  };
942
943
  inline BaseObject* GetBaseObject() const;
944
945
 private:
946
  friend class Environment;
947
  Callback fn_;
948
  void* arg_;
949
950
  // We keep track of the insertion order for these objects, so that we can
951
  // call the callbacks in reverse order when we are cleaning up.
952
  uint64_t insertion_order_counter_;
953
};
954
955
struct PropInfo {
956
  std::string name;     // name for debugging
957
  size_t id;            // In the list - in case there are any empty entries
958
  SnapshotIndex index;  // In the snapshot
959
};
960
961
typedef void (*DeserializeRequestCallback)(v8::Local<v8::Context> context,
962
                                           v8::Local<v8::Object> holder,
963
                                           int index,
964
                                           InternalFieldInfo* info);
965
struct DeserializeRequest {
966
  DeserializeRequestCallback cb;
967
  v8::Global<v8::Object> holder;
968
  int index;
969
  InternalFieldInfo* info = nullptr;  // Owned by the request
970
971
  // Move constructor
972
41968
  DeserializeRequest(DeserializeRequest&& other) = default;
973
};
974
975
struct EnvSerializeInfo {
976
  std::vector<PropInfo> bindings;
977
  std::vector<std::string> native_modules;
978
  AsyncHooks::SerializeInfo async_hooks;
979
  TickInfo::SerializeInfo tick_info;
980
  ImmediateInfo::SerializeInfo immediate_info;
981
  performance::PerformanceState::SerializeInfo performance_state;
982
  AliasedBufferIndex stream_base_state;
983
  AliasedBufferIndex should_abort_on_uncaught_toggle;
984
985
  std::vector<PropInfo> persistent_templates;
986
  std::vector<PropInfo> persistent_values;
987
988
  SnapshotIndex context;
989
  friend std::ostream& operator<<(std::ostream& o, const EnvSerializeInfo& i);
990
};
991
992
struct SnapshotData {
993
  // The result of v8::SnapshotCreator::CreateBlob() during the snapshot
994
  // building process.
995
  v8::StartupData v8_snapshot_blob_data;
996
997
  static const size_t kNodeBaseContextIndex = 0;
998
  static const size_t kNodeMainContextIndex = kNodeBaseContextIndex + 1;
999
1000
  std::vector<size_t> isolate_data_indices;
1001
  // TODO(joyeecheung): there should be a vector of env_info once we snapshot
1002
  // the worker environments.
1003
  EnvSerializeInfo env_info;
1004
  // A vector of built-in ids and v8::ScriptCompiler::CachedData, this can be
1005
  // shared across Node.js instances because they are supposed to share the
1006
  // read only space. We use native_module::CodeCacheInfo because
1007
  // v8::ScriptCompiler::CachedData is not copyable.
1008
  std::vector<native_module::CodeCacheInfo> code_cache;
1009
};
1010
1011
class Environment : public MemoryRetainer {
1012
 public:
1013
  Environment(const Environment&) = delete;
1014
  Environment& operator=(const Environment&) = delete;
1015
  Environment(Environment&&) = delete;
1016
  Environment& operator=(Environment&&) = delete;
1017
1018
24
  SET_MEMORY_INFO_NAME(Environment)
1019
1020
  inline size_t SelfSize() const override;
1021
48
  bool IsRootNode() const override { return true; }
1022
  void MemoryInfo(MemoryTracker* tracker) const override;
1023
1024
  EnvSerializeInfo Serialize(v8::SnapshotCreator* creator);
1025
  void CreateProperties();
1026
  void DeserializeProperties(const EnvSerializeInfo* info);
1027
1028
  void PrintInfoForSnapshotIfDebug();
1029
  void PrintAllBaseObjects();
1030
  void VerifyNoStrongBaseObjects();
1031
  void EnqueueDeserializeRequest(DeserializeRequestCallback cb,
1032
                                 v8::Local<v8::Object> holder,
1033
                                 int index,
1034
                                 InternalFieldInfo* info);
1035
  void RunDeserializeRequests();
1036
  // Should be called before InitializeInspector()
1037
  void InitializeDiagnostics();
1038
1039
  std::string GetCwd();
1040
1041
#if HAVE_INSPECTOR
1042
  // If the environment is created for a worker, pass parent_handle and
1043
  // the ownership if transferred into the Environment.
1044
  int InitializeInspector(
1045
      std::unique_ptr<inspector::ParentInspectorHandle> parent_handle);
1046
#endif
1047
1048
  v8::MaybeLocal<v8::Value> BootstrapInternalLoaders();
1049
  v8::MaybeLocal<v8::Value> BootstrapNode();
1050
  v8::MaybeLocal<v8::Value> RunBootstrapping();
1051
1052
  inline size_t async_callback_scope_depth() const;
1053
  inline void PushAsyncCallbackScope();
1054
  inline void PopAsyncCallbackScope();
1055
1056
  static inline Environment* GetCurrent(v8::Isolate* isolate);
1057
  static inline Environment* GetCurrent(v8::Local<v8::Context> context);
1058
  static inline Environment* GetCurrent(
1059
      const v8::FunctionCallbackInfo<v8::Value>& info);
1060
1061
  template <typename T>
1062
  static inline Environment* GetCurrent(
1063
      const v8::PropertyCallbackInfo<T>& info);
1064
1065
  // Methods created using SetMethod(), SetPrototypeMethod(), etc. inside
1066
  // this scope can access the created T* object using
1067
  // GetBindingData<T>(args) later.
1068
  template <typename T>
1069
  T* AddBindingData(v8::Local<v8::Context> context,
1070
                    v8::Local<v8::Object> target);
1071
  template <typename T, typename U>
1072
  static inline T* GetBindingData(const v8::PropertyCallbackInfo<U>& info);
1073
  template <typename T>
1074
  static inline T* GetBindingData(
1075
      const v8::FunctionCallbackInfo<v8::Value>& info);
1076
  template <typename T>
1077
  static inline T* GetBindingData(v8::Local<v8::Context> context);
1078
1079
  typedef std::unordered_map<
1080
      FastStringKey,
1081
      BaseObjectPtr<BaseObject>,
1082
      FastStringKey::Hash> BindingDataStore;
1083
1084
  // Create an Environment without initializing a main Context. Use
1085
  // InitializeMainContext() to initialize a main context for it.
1086
  Environment(IsolateData* isolate_data,
1087
              v8::Isolate* isolate,
1088
              const std::vector<std::string>& args,
1089
              const std::vector<std::string>& exec_args,
1090
              const EnvSerializeInfo* env_info,
1091
              EnvironmentFlags::Flags flags,
1092
              ThreadId thread_id);
1093
  void InitializeMainContext(v8::Local<v8::Context> context,
1094
                             const EnvSerializeInfo* env_info);
1095
  // Create an Environment and initialize the provided main context for it.
1096
  Environment(IsolateData* isolate_data,
1097
              v8::Local<v8::Context> context,
1098
              const std::vector<std::string>& args,
1099
              const std::vector<std::string>& exec_args,
1100
              const EnvSerializeInfo* env_info,
1101
              EnvironmentFlags::Flags flags,
1102
              ThreadId thread_id);
1103
  ~Environment() override;
1104
1105
  void InitializeLibuv();
1106
  inline const std::vector<std::string>& exec_argv();
1107
  inline const std::vector<std::string>& argv();
1108
  const std::string& exec_path() const;
1109
1110
  typedef void (*HandleCleanupCb)(Environment* env,
1111
                                  uv_handle_t* handle,
1112
                                  void* arg);
1113
  struct HandleCleanup {
1114
    uv_handle_t* handle_;
1115
    HandleCleanupCb cb_;
1116
    void* arg_;
1117
  };
1118
1119
  void RegisterHandleCleanups();
1120
  void CleanupHandles();
1121
  void Exit(int code);
1122
  void ExitEnv();
1123
1124
  // Register clean-up cb to be called on environment destruction.
1125
  inline void RegisterHandleCleanup(uv_handle_t* handle,
1126
                                    HandleCleanupCb cb,
1127
                                    void* arg);
1128
1129
  template <typename T, typename OnCloseCallback>
1130
  inline void CloseHandle(T* handle, OnCloseCallback callback);
1131
1132
  inline void AssignToContext(v8::Local<v8::Context> context,
1133
                              const ContextInfo& info);
1134
1135
  void StartProfilerIdleNotifier();
1136
1137
  inline v8::Isolate* isolate() const;
1138
  inline uv_loop_t* event_loop() const;
1139
  inline void TryLoadAddon(
1140
      const char* filename,
1141
      int flags,
1142
      const std::function<bool(binding::DLib*)>& was_loaded);
1143
1144
  static inline Environment* from_timer_handle(uv_timer_t* handle);
1145
  inline uv_timer_t* timer_handle();
1146
1147
  static inline Environment* from_immediate_check_handle(uv_check_t* handle);
1148
  inline uv_check_t* immediate_check_handle();
1149
  inline uv_idle_t* immediate_idle_handle();
1150
1151
  inline void IncreaseWaitingRequestCounter();
1152
  inline void DecreaseWaitingRequestCounter();
1153
1154
  inline AsyncHooks* async_hooks();
1155
  inline ImmediateInfo* immediate_info();
1156
  inline TickInfo* tick_info();
1157
  inline uint64_t timer_base() const;
1158
  inline std::shared_ptr<KVStore> env_vars();
1159
  inline void set_env_vars(std::shared_ptr<KVStore> env_vars);
1160
1161
  inline IsolateData* isolate_data() const;
1162
1163
  inline bool printed_error() const;
1164
  inline void set_printed_error(bool value);
1165
1166
  void PrintSyncTrace() const;
1167
  inline void set_trace_sync_io(bool value);
1168
1169
  inline void set_force_context_aware(bool value);
1170
  inline bool force_context_aware() const;
1171
1172
  // This stores whether the --abort-on-uncaught-exception flag was passed
1173
  // to Node.
1174
  inline bool abort_on_uncaught_exception() const;
1175
  inline void set_abort_on_uncaught_exception(bool value);
1176
  // This is a pseudo-boolean that keeps track of whether an uncaught exception
1177
  // should abort the process or not if --abort-on-uncaught-exception was
1178
  // passed to Node. If the flag was not passed, it is ignored.
1179
  inline AliasedUint32Array& should_abort_on_uncaught_toggle();
1180
1181
  inline AliasedInt32Array& stream_base_state();
1182
1183
  // The necessary API for async_hooks.
1184
  inline double new_async_id();
1185
  inline double execution_async_id();
1186
  inline double trigger_async_id();
1187
  inline double get_default_trigger_async_id();
1188
1189
  // List of id's that have been destroyed and need the destroy() cb called.
1190
  inline std::vector<double>* destroy_async_id_list();
1191
1192
  std::set<struct node_module*> internal_bindings;
1193
  std::set<std::string> native_modules_with_cache;
1194
  std::set<std::string> native_modules_without_cache;
1195
  // This is only filled during deserialization. We use a vector since
1196
  // it's only used for tests.
1197
  std::vector<std::string> native_modules_in_snapshot;
1198
1199
  std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
1200
  std::unordered_map<uint32_t, loader::ModuleWrap*> id_to_module_map;
1201
  std::unordered_map<uint32_t, contextify::ContextifyScript*>
1202
      id_to_script_map;
1203
  std::unordered_map<uint32_t, contextify::CompiledFnEntry*> id_to_function_map;
1204
1205
  inline uint32_t get_next_module_id();
1206
  inline uint32_t get_next_script_id();
1207
  inline uint32_t get_next_function_id();
1208
1209
1396201
  EnabledDebugList* enabled_debug_list() { return &enabled_debug_list_; }
1210
1211
  inline performance::PerformanceState* performance_state();
1212
1213
  void CollectUVExceptionInfo(v8::Local<v8::Value> context,
1214
                              int errorno,
1215
                              const char* syscall = nullptr,
1216
                              const char* message = nullptr,
1217
                              const char* path = nullptr,
1218
                              const char* dest = nullptr);
1219
1220
  // If this flag is set, calls into JS (if they would be observable
1221
  // from userland) must be avoided.  This flag does not indicate whether
1222
  // calling into JS is allowed from a VM perspective at this point.
1223
  inline bool can_call_into_js() const;
1224
  inline void set_can_call_into_js(bool can_call_into_js);
1225
1226
  // Increase or decrease a counter that manages whether this Environment
1227
  // keeps the event loop alive on its own or not. The counter starts out at 0,
1228
  // meaning it does not, and any positive value will make it keep the event
1229
  // loop alive.
1230
  // This is used by Workers to manage their own .ref()/.unref() implementation,
1231
  // as Workers aren't directly associated with their own libuv handles.
1232
  inline void add_refs(int64_t diff);
1233
1234
  inline bool has_run_bootstrapping_code() const;
1235
  inline void DoneBootstrapping();
1236
1237
  inline bool has_serialized_options() const;
1238
  inline void set_has_serialized_options(bool has_serialized_options);
1239
1240
  inline bool is_main_thread() const;
1241
  inline bool no_native_addons() const;
1242
  inline bool should_not_register_esm_loader() const;
1243
  inline bool should_create_inspector() const;
1244
  inline bool owns_process_state() const;
1245
  inline bool owns_inspector() const;
1246
  inline bool tracks_unmanaged_fds() const;
1247
  inline bool hide_console_windows() const;
1248
  inline bool no_global_search_paths() const;
1249
  inline bool no_browser_globals() const;
1250
  inline uint64_t thread_id() const;
1251
  inline worker::Worker* worker_context() const;
1252
  Environment* worker_parent_env() const;
1253
  inline void add_sub_worker_context(worker::Worker* context);
1254
  inline void remove_sub_worker_context(worker::Worker* context);
1255
  void stop_sub_worker_contexts();
1256
  template <typename Fn>
1257
  inline void ForEachWorker(Fn&& iterator);
1258
  inline bool is_stopping() const;
1259
  inline void set_stopping(bool value);
1260
  inline std::list<node_module>* extra_linked_bindings();
1261
  inline node_module* extra_linked_bindings_head();
1262
  inline node_module* extra_linked_bindings_tail();
1263
  inline const Mutex& extra_linked_bindings_mutex() const;
1264
1265
  inline bool filehandle_close_warning() const;
1266
  inline void set_filehandle_close_warning(bool on);
1267
1268
  inline void set_source_maps_enabled(bool on);
1269
  inline bool source_maps_enabled() const;
1270
1271
  inline void ThrowError(const char* errmsg);
1272
  inline void ThrowTypeError(const char* errmsg);
1273
  inline void ThrowRangeError(const char* errmsg);
1274
  inline void ThrowErrnoException(int errorno,
1275
                                  const char* syscall = nullptr,
1276
                                  const char* message = nullptr,
1277
                                  const char* path = nullptr);
1278
  inline void ThrowUVException(int errorno,
1279
                               const char* syscall = nullptr,
1280
                               const char* message = nullptr,
1281
                               const char* path = nullptr,
1282
                               const char* dest = nullptr);
1283
1284
  inline v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
1285
      v8::FunctionCallback callback,
1286
      v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
1287
      v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
1288
      v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
1289
      const v8::CFunction* c_function = nullptr);
1290
1291
  // Convenience methods for NewFunctionTemplate().
1292
  inline void SetMethod(v8::Local<v8::Object> that,
1293
                        const char* name,
1294
                        v8::FunctionCallback callback);
1295
1296
  inline void SetFastMethod(v8::Local<v8::Object> that,
1297
                            const char* name,
1298
                            v8::FunctionCallback slow_callback,
1299
                            const v8::CFunction* c_function);
1300
1301
  inline void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
1302
                             const char* name,
1303
                             v8::FunctionCallback callback);
1304
1305
  inline void SetInstanceMethod(v8::Local<v8::FunctionTemplate> that,
1306
                                const char* name,
1307
                                v8::FunctionCallback callback);
1308
1309
1310
  // Safe variants denote the function has no side effects.
1311
  inline void SetMethodNoSideEffect(v8::Local<v8::Object> that,
1312
                                    const char* name,
1313
                                    v8::FunctionCallback callback);
1314
  inline void SetProtoMethodNoSideEffect(v8::Local<v8::FunctionTemplate> that,
1315
                                         const char* name,
1316
                                         v8::FunctionCallback callback);
1317
1318
  enum class SetConstructorFunctionFlag {
1319
    NONE,
1320
    SET_CLASS_NAME,
1321
  };
1322
1323
  inline void SetConstructorFunction(v8::Local<v8::Object> that,
1324
                          const char* name,
1325
                          v8::Local<v8::FunctionTemplate> tmpl,
1326
                          SetConstructorFunctionFlag flag =
1327
                              SetConstructorFunctionFlag::SET_CLASS_NAME);
1328
1329
  inline void SetConstructorFunction(v8::Local<v8::Object> that,
1330
                          v8::Local<v8::String> name,
1331
                          v8::Local<v8::FunctionTemplate> tmpl,
1332
                          SetConstructorFunctionFlag flag =
1333
                              SetConstructorFunctionFlag::SET_CLASS_NAME);
1334
1335
  void AtExit(void (*cb)(void* arg), void* arg);
1336
  void RunAtExitCallbacks();
1337
1338
  void RunWeakRefCleanup();
1339
1340
  v8::MaybeLocal<v8::Value> RunSnapshotSerializeCallback() const;
1341
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeCallback() const;
1342
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeMain() const;
1343
1344
  // Strings and private symbols are shared across shared contexts
1345
  // The getters simply proxy to the per-isolate primitive.
1346
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
1347
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
1348
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
1349
#define V(TypeName, PropertyName)                                             \
1350
  inline v8::Local<TypeName> PropertyName() const;
1351
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
1352
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
1353
  PER_ISOLATE_STRING_PROPERTIES(VS)
1354
#undef V
1355
#undef VS
1356
#undef VY
1357
#undef VP
1358
1359
#define V(PropertyName, TypeName)                                             \
1360
  inline v8::Local<TypeName> PropertyName() const;                            \
1361
  inline void set_ ## PropertyName(v8::Local<TypeName> value);
1362
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1363
  ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)
1364
#undef V
1365
1366
  inline v8::Local<v8::Context> context() const;
1367
1368
#if HAVE_INSPECTOR
1369
79591
  inline inspector::Agent* inspector_agent() const {
1370
79591
    return inspector_agent_.get();
1371
  }
1372
1373
  inline bool is_in_inspector_console_call() const;
1374
  inline void set_is_in_inspector_console_call(bool value);
1375
#endif
1376
1377
  typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;
1378
  typedef ListHead<ReqWrapBase, &ReqWrapBase::req_wrap_queue_> ReqWrapQueue;
1379
1380
61713
  inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }
1381
78926
  inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }
1382
1383
1
  inline bool EmitProcessEnvWarning() {
1384
1
    bool current_value = emit_env_nonstring_warning_;
1385
1
    emit_env_nonstring_warning_ = false;
1386
1
    return current_value;
1387
  }
1388
1389
1
  inline bool EmitErrNameWarning() {
1390
1
    bool current_value = emit_err_name_warning_;
1391
1
    emit_err_name_warning_ = false;
1392
1
    return current_value;
1393
  }
1394
1395
  // cb will be called as cb(env) on the next event loop iteration.
1396
  // Unlike the JS setImmediate() function, nested SetImmediate() calls will
1397
  // be run without returning control to the event loop, similar to nextTick().
1398
  template <typename Fn>
1399
  inline void SetImmediate(
1400
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1401
  template <typename Fn>
1402
  // This behaves like SetImmediate() but can be called from any thread.
1403
  inline void SetImmediateThreadsafe(
1404
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1405
  // This behaves like V8's Isolate::RequestInterrupt(), but also accounts for
1406
  // the event loop (i.e. combines the V8 function with SetImmediate()).
1407
  // The passed callback may not throw exceptions.
1408
  // This function can be called from any thread.
1409
  template <typename Fn>
1410
  inline void RequestInterrupt(Fn&& cb);
1411
  // This needs to be available for the JS-land setImmediate().
1412
  void ToggleImmediateRef(bool ref);
1413
1414
  inline void PushShouldNotAbortOnUncaughtScope();
1415
  inline void PopShouldNotAbortOnUncaughtScope();
1416
  inline bool inside_should_not_abort_on_uncaught_scope() const;
1417
1418
  static inline Environment* ForAsyncHooks(AsyncHooks* hooks);
1419
1420
  v8::Local<v8::Value> GetNow();
1421
  void ScheduleTimer(int64_t duration);
1422
  void ToggleTimerRef(bool ref);
1423
1424
  using CleanupCallback = CleanupHookCallback::Callback;
1425
  inline void AddCleanupHook(CleanupCallback cb, void* arg);
1426
  inline void RemoveCleanupHook(CleanupCallback cb, void* arg);
1427
  void RunCleanup();
1428
1429
  static size_t NearHeapLimitCallback(void* data,
1430
                                      size_t current_heap_limit,
1431
                                      size_t initial_heap_limit);
1432
  static void BuildEmbedderGraph(v8::Isolate* isolate,
1433
                                 v8::EmbedderGraph* graph,
1434
                                 void* data);
1435
1436
  inline std::shared_ptr<EnvironmentOptions> options();
1437
  inline std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port();
1438
1439
  // The BaseObject count is a debugging helper that makes sure that there are
1440
  // no memory leaks caused by BaseObjects staying alive longer than expected
1441
  // (in particular, no circular BaseObjectPtr references).
1442
  inline void modify_base_object_count(int64_t delta);
1443
  inline int64_t base_object_created_after_bootstrap() const;
1444
  inline int64_t base_object_count() const;
1445
1446
3
  inline int32_t stack_trace_limit() const { return 10; }
1447
1448
#if HAVE_INSPECTOR
1449
  void set_coverage_connection(
1450
      std::unique_ptr<profiler::V8CoverageConnection> connection);
1451
  profiler::V8CoverageConnection* coverage_connection();
1452
1453
  inline void set_coverage_directory(const char* directory);
1454
  inline const std::string& coverage_directory() const;
1455
1456
  void set_cpu_profiler_connection(
1457
      std::unique_ptr<profiler::V8CpuProfilerConnection> connection);
1458
  profiler::V8CpuProfilerConnection* cpu_profiler_connection();
1459
1460
  inline void set_cpu_prof_name(const std::string& name);
1461
  inline const std::string& cpu_prof_name() const;
1462
1463
  inline void set_cpu_prof_interval(uint64_t interval);
1464
  inline uint64_t cpu_prof_interval() const;
1465
1466
  inline void set_cpu_prof_dir(const std::string& dir);
1467
  inline const std::string& cpu_prof_dir() const;
1468
1469
  void set_heap_profiler_connection(
1470
      std::unique_ptr<profiler::V8HeapProfilerConnection> connection);
1471
  profiler::V8HeapProfilerConnection* heap_profiler_connection();
1472
1473
  inline void set_heap_prof_name(const std::string& name);
1474
  inline const std::string& heap_prof_name() const;
1475
1476
  inline void set_heap_prof_dir(const std::string& dir);
1477
  inline const std::string& heap_prof_dir() const;
1478
1479
  inline void set_heap_prof_interval(uint64_t interval);
1480
  inline uint64_t heap_prof_interval() const;
1481
1482
#endif  // HAVE_INSPECTOR
1483
1484
  inline void set_main_utf16(std::unique_ptr<v8::String::Value>);
1485
  inline void set_process_exit_handler(
1486
      std::function<void(Environment*, int)>&& handler);
1487
1488
  void RunAndClearNativeImmediates(bool only_refed = false);
1489
  void RunAndClearInterrupts();
1490
1491
  inline uv_buf_t allocate_managed_buffer(const size_t suggested_size);
1492
  inline std::unique_ptr<v8::BackingStore> release_managed_buffer(
1493
      const uv_buf_t& buf);
1494
1495
  void AddUnmanagedFd(int fd);
1496
  void RemoveUnmanagedFd(int fd);
1497
1498
  template <typename T>
1499
  void ForEachBindingData(T&& iterator);
1500
1501
 private:
1502
  inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
1503
                         const char* errmsg);
1504
1505
  std::list<binding::DLib> loaded_addons_;
1506
  v8::Isolate* const isolate_;
1507
  IsolateData* const isolate_data_;
1508
  uv_timer_t timer_handle_;
1509
  uv_check_t immediate_check_handle_;
1510
  uv_idle_t immediate_idle_handle_;
1511
  uv_prepare_t idle_prepare_handle_;
1512
  uv_check_t idle_check_handle_;
1513
  uv_async_t task_queues_async_;
1514
  int64_t task_queues_async_refs_ = 0;
1515
1516
  AsyncHooks async_hooks_;
1517
  ImmediateInfo immediate_info_;
1518
  TickInfo tick_info_;
1519
  const uint64_t timer_base_;
1520
  std::shared_ptr<KVStore> env_vars_;
1521
  bool printed_error_ = false;
1522
  bool trace_sync_io_ = false;
1523
  bool emit_env_nonstring_warning_ = true;
1524
  bool emit_err_name_warning_ = true;
1525
  bool emit_filehandle_warning_ = true;
1526
  bool source_maps_enabled_ = false;
1527
1528
  size_t async_callback_scope_depth_ = 0;
1529
  std::vector<double> destroy_async_id_list_;
1530
1531
#if HAVE_INSPECTOR
1532
  std::unique_ptr<profiler::V8CoverageConnection> coverage_connection_;
1533
  std::unique_ptr<profiler::V8CpuProfilerConnection> cpu_profiler_connection_;
1534
  std::string coverage_directory_;
1535
  std::string cpu_prof_dir_;
1536
  std::string cpu_prof_name_;
1537
  uint64_t cpu_prof_interval_;
1538
  std::unique_ptr<profiler::V8HeapProfilerConnection> heap_profiler_connection_;
1539
  std::string heap_prof_dir_;
1540
  std::string heap_prof_name_;
1541
  uint64_t heap_prof_interval_;
1542
#endif  // HAVE_INSPECTOR
1543
1544
  std::shared_ptr<EnvironmentOptions> options_;
1545
  // options_ contains debug options parsed from CLI arguments,
1546
  // while inspector_host_port_ stores the actual inspector host
1547
  // and port being used. For example the port is -1 by default
1548
  // and can be specified as 0 (meaning any port allocated when the
1549
  // server starts listening), but when the inspector server starts
1550
  // the inspector_host_port_->port() will be the actual port being
1551
  // used.
1552
  std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port_;
1553
  std::vector<std::string> exec_argv_;
1554
  std::vector<std::string> argv_;
1555
  std::string exec_path_;
1556
1557
  bool is_processing_heap_limit_callback_ = false;
1558
  int64_t heap_limit_snapshot_taken_ = 0;
1559
1560
  uint32_t module_id_counter_ = 0;
1561
  uint32_t script_id_counter_ = 0;
1562
  uint32_t function_id_counter_ = 0;
1563
1564
  AliasedUint32Array should_abort_on_uncaught_toggle_;
1565
  int should_not_abort_scope_counter_ = 0;
1566
1567
  std::unique_ptr<TrackingTraceStateObserver> trace_state_observer_;
1568
1569
  AliasedInt32Array stream_base_state_;
1570
1571
  uint64_t environment_start_time_;
1572
  std::unique_ptr<performance::PerformanceState> performance_state_;
1573
1574
  bool has_run_bootstrapping_code_ = false;
1575
  bool has_serialized_options_ = false;
1576
1577
  std::atomic_bool can_call_into_js_ { true };
1578
  uint64_t flags_;
1579
  uint64_t thread_id_;
1580
  std::unordered_set<worker::Worker*> sub_worker_contexts_;
1581
1582
  static void* const kNodeContextTagPtr;
1583
  static int const kNodeContextTag;
1584
1585
#if HAVE_INSPECTOR
1586
  std::unique_ptr<inspector::Agent> inspector_agent_;
1587
  bool is_in_inspector_console_call_ = false;
1588
#endif
1589
1590
  std::list<DeserializeRequest> deserialize_requests_;
1591
1592
  // handle_wrap_queue_ and req_wrap_queue_ needs to be at a fixed offset from
1593
  // the start of the class because it is used by
1594
  // src/node_postmortem_metadata.cc to calculate offsets and generate debug
1595
  // symbols for Environment, which assumes that the position of members in
1596
  // memory are predictable. For more information please refer to
1597
  // `doc/contributing/node-postmortem-support.md`
1598
  friend int GenDebugSymbols();
1599
  HandleWrapQueue handle_wrap_queue_;
1600
  ReqWrapQueue req_wrap_queue_;
1601
  std::list<HandleCleanup> handle_cleanup_queue_;
1602
  int handle_cleanup_waiting_ = 0;
1603
  int request_waiting_ = 0;
1604
1605
  EnabledDebugList enabled_debug_list_;
1606
1607
  std::list<node_module> extra_linked_bindings_;
1608
  Mutex extra_linked_bindings_mutex_;
1609
1610
  static void RunTimers(uv_timer_t* handle);
1611
1612
  struct ExitCallback {
1613
    void (*cb_)(void* arg);
1614
    void* arg_;
1615
  };
1616
1617
  std::list<ExitCallback> at_exit_functions_;
1618
1619
  typedef CallbackQueue<void, Environment*> NativeImmediateQueue;
1620
  NativeImmediateQueue native_immediates_;
1621
  Mutex native_immediates_threadsafe_mutex_;
1622
  NativeImmediateQueue native_immediates_threadsafe_;
1623
  NativeImmediateQueue native_immediates_interrupts_;
1624
  // Also guarded by native_immediates_threadsafe_mutex_. This can be used when
1625
  // trying to post tasks from other threads to an Environment, as the libuv
1626
  // handle for the immediate queues (task_queues_async_) may not be initialized
1627
  // yet or already have been destroyed.
1628
  bool task_queues_async_initialized_ = false;
1629
1630
  std::atomic<Environment**> interrupt_data_ {nullptr};
1631
  void RequestInterruptFromV8();
1632
  static void CheckImmediate(uv_check_t* handle);
1633
1634
  BindingDataStore bindings_;
1635
1636
  // Use an unordered_set, so that we have efficient insertion and removal.
1637
  std::unordered_set<CleanupHookCallback,
1638
                     CleanupHookCallback::Hash,
1639
                     CleanupHookCallback::Equal> cleanup_hooks_;
1640
  uint64_t cleanup_hook_counter_ = 0;
1641
  bool started_cleanup_ = false;
1642
1643
  int64_t base_object_count_ = 0;
1644
  int64_t base_object_created_by_bootstrap_ = 0;
1645
  std::atomic_bool is_stopping_ { false };
1646
1647
  std::unordered_set<int> unmanaged_fds_;
1648
1649
  std::function<void(Environment*, int)> process_exit_handler_ {
1650
      DefaultProcessExitHandler };
1651
1652
  template <typename T>
1653
  void ForEachBaseObject(T&& iterator);
1654
1655
#define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName ## _;
1656
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1657
  ENVIRONMENT_STRONG_PERSISTENT_TEMPLATES(V)
1658
#undef V
1659
1660
  v8::Global<v8::Context> context_;
1661
1662
  // Keeps the main script source alive is one was passed to LoadEnvironment().
1663
  // We should probably find a way to just use plain `v8::String`s created from
1664
  // the source passed to LoadEnvironment() directly instead.
1665
  std::unique_ptr<v8::String::Value> main_utf16_;
1666
1667
  // Used by allocate_managed_buffer() and release_managed_buffer() to keep
1668
  // track of the BackingStore for a given pointer.
1669
  std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
1670
      released_allocated_buffers_;
1671
};
1672
1673
}  // namespace node
1674
1675
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
1676
1677
#endif  // SRC_ENV_H_