GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: env.h Lines: 43 43 100.0 %
Date: 2022-07-29 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 PER_ISOLATE_TEMPLATE_PROPERTIES(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(get_source_map_error_source, v8::Function)                                 \
529
  V(host_import_module_dynamically_callback, v8::Function)                     \
530
  V(host_initialize_import_meta_object_callback, v8::Function)                 \
531
  V(http2session_on_altsvc_function, v8::Function)                             \
532
  V(http2session_on_error_function, v8::Function)                              \
533
  V(http2session_on_frame_error_function, v8::Function)                        \
534
  V(http2session_on_goaway_data_function, v8::Function)                        \
535
  V(http2session_on_headers_function, v8::Function)                            \
536
  V(http2session_on_origin_function, v8::Function)                             \
537
  V(http2session_on_ping_function, v8::Function)                               \
538
  V(http2session_on_priority_function, v8::Function)                           \
539
  V(http2session_on_settings_function, v8::Function)                           \
540
  V(http2session_on_stream_close_function, v8::Function)                       \
541
  V(http2session_on_stream_trailers_function, v8::Function)                    \
542
  V(internal_binding_loader, v8::Function)                                     \
543
  V(immediate_callback_function, v8::Function)                                 \
544
  V(inspector_console_extension_installer, v8::Function)                       \
545
  V(inspector_disable_async_hooks, v8::Function)                               \
546
  V(inspector_enable_async_hooks, v8::Function)                                \
547
  V(maybe_cache_generated_source_map, v8::Function)                            \
548
  V(messaging_deserialize_create_object, v8::Function)                         \
549
  V(message_port, v8::Object)                                                  \
550
  V(native_module_require, v8::Function)                                       \
551
  V(performance_entry_callback, v8::Function)                                  \
552
  V(performance_entry_template, v8::Function)                                  \
553
  V(prepare_stack_trace_callback, v8::Function)                                \
554
  V(process_object, v8::Object)                                                \
555
  V(primordials, v8::Object)                                                   \
556
  V(primordials_safe_map_prototype_object, v8::Object)                         \
557
  V(primordials_safe_set_prototype_object, v8::Object)                         \
558
  V(primordials_safe_weak_map_prototype_object, v8::Object)                    \
559
  V(primordials_safe_weak_set_prototype_object, v8::Object)                    \
560
  V(promise_hook_handler, v8::Function)                                        \
561
  V(promise_reject_callback, v8::Function)                                     \
562
  V(script_data_constructor_function, v8::Function)                            \
563
  V(snapshot_serialize_callback, v8::Function)                                 \
564
  V(snapshot_deserialize_callback, v8::Function)                               \
565
  V(snapshot_deserialize_main, v8::Function)                                   \
566
  V(source_map_cache_getter, v8::Function)                                     \
567
  V(tick_callback_function, v8::Function)                                      \
568
  V(timers_callback_function, v8::Function)                                    \
569
  V(tls_wrap_constructor_function, v8::Function)                               \
570
  V(trace_category_state_function, v8::Function)                               \
571
  V(udp_constructor_function, v8::Function)                                    \
572
  V(url_constructor_function, v8::Function)                                    \
573
  V(wasm_streaming_compilation_impl, v8::Function)                             \
574
  V(wasm_streaming_object_constructor, v8::Function)
575
576
class Environment;
577
578
typedef size_t SnapshotIndex;
579
580
struct PropInfo {
581
  std::string name;     // name for debugging
582
  size_t id;            // In the list - in case there are any empty entries
583
  SnapshotIndex index;  // In the snapshot
584
};
585
586
struct IsolateDataSerializeInfo {
587
  std::vector<SnapshotIndex> primitive_values;
588
  std::vector<PropInfo> template_values;
589
590
  friend std::ostream& operator<<(std::ostream& o,
591
                                  const IsolateDataSerializeInfo& i);
592
};
593
594
class NODE_EXTERN_PRIVATE IsolateData : public MemoryRetainer {
595
 public:
596
  IsolateData(v8::Isolate* isolate,
597
              uv_loop_t* event_loop,
598
              MultiIsolatePlatform* platform = nullptr,
599
              ArrayBufferAllocator* node_allocator = nullptr,
600
              const IsolateDataSerializeInfo* isolate_data_info = nullptr);
601
24
  SET_MEMORY_INFO_NAME(IsolateData)
602
24
  SET_SELF_SIZE(IsolateData)
603
  void MemoryInfo(MemoryTracker* tracker) const override;
604
  IsolateDataSerializeInfo Serialize(v8::SnapshotCreator* creator);
605
606
  inline uv_loop_t* event_loop() const;
607
  inline MultiIsolatePlatform* platform() const;
608
  inline std::shared_ptr<PerIsolateOptions> options();
609
  inline void set_options(std::shared_ptr<PerIsolateOptions> options);
610
611
  inline NodeArrayBufferAllocator* node_allocator() const;
612
613
  inline worker::Worker* worker_context() const;
614
  inline void set_worker_context(worker::Worker* context);
615
616
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
617
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
618
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
619
#define V(TypeName, PropertyName)                                             \
620
  inline v8::Local<TypeName> PropertyName() const;
621
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
622
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
623
  PER_ISOLATE_STRING_PROPERTIES(VS)
624
#undef V
625
#undef VY
626
#undef VS
627
#undef VP
628
629
#define V(PropertyName, TypeName)                                              \
630
  inline v8::Local<TypeName> PropertyName() const;                             \
631
  inline void set_##PropertyName(v8::Local<TypeName> value);
632
  PER_ISOLATE_TEMPLATE_PROPERTIES(V)
633
#undef V
634
635
  inline v8::Local<v8::String> async_wrap_provider(int index) const;
636
637
  size_t max_young_gen_size = 1;
638
  std::unordered_map<const char*, v8::Eternal<v8::String>> static_str_map;
639
640
  inline v8::Isolate* isolate() const;
641
  IsolateData(const IsolateData&) = delete;
642
  IsolateData& operator=(const IsolateData&) = delete;
643
  IsolateData(IsolateData&&) = delete;
644
  IsolateData& operator=(IsolateData&&) = delete;
645
646
 private:
647
  void DeserializeProperties(const IsolateDataSerializeInfo* isolate_data_info);
648
  void CreateProperties();
649
650
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
651
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
652
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
653
#define VT(PropertyName, TypeName) V(TypeName, PropertyName)
654
#define V(TypeName, PropertyName)                                             \
655
  v8::Eternal<TypeName> PropertyName ## _;
656
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
657
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
658
  PER_ISOLATE_STRING_PROPERTIES(VS)
659
  PER_ISOLATE_TEMPLATE_PROPERTIES(VT)
660
#undef V
661
#undef V
662
#undef VT
663
#undef VS
664
#undef VY
665
#undef VP
666
  // Keep a list of all Persistent strings used for AsyncWrap Provider types.
667
  std::array<v8::Eternal<v8::String>, AsyncWrap::PROVIDERS_LENGTH>
668
      async_wrap_providers_;
669
670
  v8::Isolate* const isolate_;
671
  uv_loop_t* const event_loop_;
672
  NodeArrayBufferAllocator* const node_allocator_;
673
  MultiIsolatePlatform* platform_;
674
  std::shared_ptr<PerIsolateOptions> options_;
675
  worker::Worker* worker_context_ = nullptr;
676
};
677
678
struct ContextInfo {
679
13812
  explicit ContextInfo(const std::string& name) : name(name) {}
680
  const std::string name;
681
  std::string origin;
682
  bool is_default = false;
683
};
684
685
class EnabledDebugList;
686
687
namespace per_process {
688
extern std::shared_ptr<KVStore> system_environment;
689
}
690
691
struct EnvSerializeInfo;
692
693
class AsyncHooks : public MemoryRetainer {
694
 public:
695
24
  SET_MEMORY_INFO_NAME(AsyncHooks)
696
24
  SET_SELF_SIZE(AsyncHooks)
697
  void MemoryInfo(MemoryTracker* tracker) const override;
698
699
  // Reason for both UidFields and Fields are that one is stored as a double*
700
  // and the other as a uint32_t*.
701
  enum Fields {
702
    kInit,
703
    kBefore,
704
    kAfter,
705
    kDestroy,
706
    kPromiseResolve,
707
    kTotals,
708
    kCheck,
709
    kStackLength,
710
    kUsesExecutionAsyncResource,
711
    kFieldsCount,
712
  };
713
714
  enum UidFields {
715
    kExecutionAsyncId,
716
    kTriggerAsyncId,
717
    kAsyncIdCounter,
718
    kDefaultTriggerAsyncId,
719
    kUidFieldsCount,
720
  };
721
722
  inline AliasedUint32Array& fields();
723
  inline AliasedFloat64Array& async_id_fields();
724
  inline AliasedFloat64Array& async_ids_stack();
725
  inline v8::Local<v8::Array> js_execution_async_resources();
726
  // Returns the native executionAsyncResource value at stack index `index`.
727
  // Resources provided on the JS side are not stored on the native stack,
728
  // in which case an empty `Local<>` is returned.
729
  // The `js_execution_async_resources` array contains the value in that case.
730
  inline v8::Local<v8::Object> native_execution_async_resource(size_t index);
731
732
  void SetJSPromiseHooks(v8::Local<v8::Function> init,
733
                         v8::Local<v8::Function> before,
734
                         v8::Local<v8::Function> after,
735
                         v8::Local<v8::Function> resolve);
736
737
  inline v8::Local<v8::String> provider_string(int idx);
738
739
  inline void no_force_checks();
740
  inline Environment* env();
741
742
  // NB: This call does not take (co-)ownership of `execution_async_resource`.
743
  // The lifetime of the `v8::Local<>` pointee must last until
744
  // `pop_async_context()` or `clear_async_id_stack()` are called.
745
  void push_async_context(double async_id,
746
                          double trigger_async_id,
747
                          v8::Local<v8::Object> execution_async_resource);
748
  bool pop_async_context(double async_id);
749
  void clear_async_id_stack();  // Used in fatal exceptions.
750
751
  void AddContext(v8::Local<v8::Context> ctx);
752
  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
24252
  ~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
12126
  ~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
12126
  ~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
6586
  explicit TrackingTraceStateObserver(Environment* env) : env_(env) {}
892
893
88
  void OnTraceEnabled() override {
894
88
    UpdateTraceCategoryState();
895
88
  }
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
2940180
  CleanupHookCallback(Callback fn,
928
                      void* arg,
929
                      uint64_t insertion_order_counter)
930
2940180
      : 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
typedef void (*DeserializeRequestCallback)(v8::Local<v8::Context> context,
956
                                           v8::Local<v8::Object> holder,
957
                                           int index,
958
                                           InternalFieldInfo* info);
959
struct DeserializeRequest {
960
  DeserializeRequestCallback cb;
961
  v8::Global<v8::Object> holder;
962
  int index;
963
  InternalFieldInfo* info = nullptr;  // Owned by the request
964
965
  // Move constructor
966
42248
  DeserializeRequest(DeserializeRequest&& other) = default;
967
};
968
969
struct EnvSerializeInfo {
970
  std::vector<PropInfo> bindings;
971
  std::vector<std::string> native_modules;
972
  AsyncHooks::SerializeInfo async_hooks;
973
  TickInfo::SerializeInfo tick_info;
974
  ImmediateInfo::SerializeInfo immediate_info;
975
  performance::PerformanceState::SerializeInfo performance_state;
976
  AliasedBufferIndex stream_base_state;
977
  AliasedBufferIndex should_abort_on_uncaught_toggle;
978
979
  std::vector<PropInfo> persistent_values;
980
981
  SnapshotIndex context;
982
  friend std::ostream& operator<<(std::ostream& o, const EnvSerializeInfo& i);
983
};
984
985
struct SnapshotData {
986
  enum class DataOwnership { kOwned, kNotOwned };
987
988
  static const size_t kNodeBaseContextIndex = 0;
989
  static const size_t kNodeMainContextIndex = kNodeBaseContextIndex + 1;
990
991
  DataOwnership data_ownership = DataOwnership::kOwned;
992
993
  // The result of v8::SnapshotCreator::CreateBlob() during the snapshot
994
  // building process.
995
  v8::StartupData v8_snapshot_blob_data{nullptr, 0};
996
997
  IsolateDataSerializeInfo isolate_data_info;
998
  // TODO(joyeecheung): there should be a vector of env_info once we snapshot
999
  // the worker environments.
1000
  EnvSerializeInfo env_info;
1001
  // A vector of built-in ids and v8::ScriptCompiler::CachedData, this can be
1002
  // shared across Node.js instances because they are supposed to share the
1003
  // read only space. We use native_module::CodeCacheInfo because
1004
  // v8::ScriptCompiler::CachedData is not copyable.
1005
  std::vector<native_module::CodeCacheInfo> code_cache;
1006
1007
  ~SnapshotData();
1008
1009
  SnapshotData(const SnapshotData&) = delete;
1010
  SnapshotData& operator=(const SnapshotData&) = delete;
1011
  SnapshotData(SnapshotData&&) = delete;
1012
  SnapshotData& operator=(SnapshotData&&) = delete;
1013
1014
6
  SnapshotData() = default;
1015
};
1016
1017
class Environment : public MemoryRetainer {
1018
 public:
1019
  Environment(const Environment&) = delete;
1020
  Environment& operator=(const Environment&) = delete;
1021
  Environment(Environment&&) = delete;
1022
  Environment& operator=(Environment&&) = delete;
1023
1024
24
  SET_MEMORY_INFO_NAME(Environment)
1025
1026
  inline size_t SelfSize() const override;
1027
48
  bool IsRootNode() const override { return true; }
1028
  void MemoryInfo(MemoryTracker* tracker) const override;
1029
1030
  EnvSerializeInfo Serialize(v8::SnapshotCreator* creator);
1031
  void CreateProperties();
1032
  void DeserializeProperties(const EnvSerializeInfo* info);
1033
1034
  void PrintInfoForSnapshotIfDebug();
1035
  void PrintAllBaseObjects();
1036
  void VerifyNoStrongBaseObjects();
1037
  void EnqueueDeserializeRequest(DeserializeRequestCallback cb,
1038
                                 v8::Local<v8::Object> holder,
1039
                                 int index,
1040
                                 InternalFieldInfo* info);
1041
  void RunDeserializeRequests();
1042
  // Should be called before InitializeInspector()
1043
  void InitializeDiagnostics();
1044
1045
  std::string GetCwd();
1046
1047
#if HAVE_INSPECTOR
1048
  // If the environment is created for a worker, pass parent_handle and
1049
  // the ownership if transferred into the Environment.
1050
  int InitializeInspector(
1051
      std::unique_ptr<inspector::ParentInspectorHandle> parent_handle);
1052
#endif
1053
1054
  v8::MaybeLocal<v8::Value> BootstrapInternalLoaders();
1055
  v8::MaybeLocal<v8::Value> BootstrapNode();
1056
  v8::MaybeLocal<v8::Value> RunBootstrapping();
1057
1058
  inline size_t async_callback_scope_depth() const;
1059
  inline void PushAsyncCallbackScope();
1060
  inline void PopAsyncCallbackScope();
1061
1062
  static inline Environment* GetCurrent(v8::Isolate* isolate);
1063
  static inline Environment* GetCurrent(v8::Local<v8::Context> context);
1064
  static inline Environment* GetCurrent(
1065
      const v8::FunctionCallbackInfo<v8::Value>& info);
1066
1067
  template <typename T>
1068
  static inline Environment* GetCurrent(
1069
      const v8::PropertyCallbackInfo<T>& info);
1070
1071
  // Methods created using SetMethod(), SetPrototypeMethod(), etc. inside
1072
  // this scope can access the created T* object using
1073
  // GetBindingData<T>(args) later.
1074
  template <typename T>
1075
  T* AddBindingData(v8::Local<v8::Context> context,
1076
                    v8::Local<v8::Object> target);
1077
  template <typename T, typename U>
1078
  static inline T* GetBindingData(const v8::PropertyCallbackInfo<U>& info);
1079
  template <typename T>
1080
  static inline T* GetBindingData(
1081
      const v8::FunctionCallbackInfo<v8::Value>& info);
1082
  template <typename T>
1083
  static inline T* GetBindingData(v8::Local<v8::Context> context);
1084
1085
  typedef std::unordered_map<
1086
      FastStringKey,
1087
      BaseObjectPtr<BaseObject>,
1088
      FastStringKey::Hash> BindingDataStore;
1089
1090
  // Create an Environment without initializing a main Context. Use
1091
  // InitializeMainContext() to initialize a main context for it.
1092
  Environment(IsolateData* isolate_data,
1093
              v8::Isolate* isolate,
1094
              const std::vector<std::string>& args,
1095
              const std::vector<std::string>& exec_args,
1096
              const EnvSerializeInfo* env_info,
1097
              EnvironmentFlags::Flags flags,
1098
              ThreadId thread_id);
1099
  void InitializeMainContext(v8::Local<v8::Context> context,
1100
                             const EnvSerializeInfo* env_info);
1101
  // Create an Environment and initialize the provided main context for it.
1102
  Environment(IsolateData* isolate_data,
1103
              v8::Local<v8::Context> context,
1104
              const std::vector<std::string>& args,
1105
              const std::vector<std::string>& exec_args,
1106
              const EnvSerializeInfo* env_info,
1107
              EnvironmentFlags::Flags flags,
1108
              ThreadId thread_id);
1109
  ~Environment() override;
1110
1111
  void InitializeLibuv();
1112
  inline const std::vector<std::string>& exec_argv();
1113
  inline const std::vector<std::string>& argv();
1114
  const std::string& exec_path() const;
1115
1116
  typedef void (*HandleCleanupCb)(Environment* env,
1117
                                  uv_handle_t* handle,
1118
                                  void* arg);
1119
  struct HandleCleanup {
1120
    uv_handle_t* handle_;
1121
    HandleCleanupCb cb_;
1122
    void* arg_;
1123
  };
1124
1125
  void RegisterHandleCleanups();
1126
  void CleanupHandles();
1127
  void Exit(int code);
1128
  void ExitEnv();
1129
1130
  // Register clean-up cb to be called on environment destruction.
1131
  inline void RegisterHandleCleanup(uv_handle_t* handle,
1132
                                    HandleCleanupCb cb,
1133
                                    void* arg);
1134
1135
  template <typename T, typename OnCloseCallback>
1136
  inline void CloseHandle(T* handle, OnCloseCallback callback);
1137
1138
  void AssignToContext(v8::Local<v8::Context> context, const ContextInfo& info);
1139
1140
  void StartProfilerIdleNotifier();
1141
1142
  inline v8::Isolate* isolate() const;
1143
  inline uv_loop_t* event_loop() const;
1144
  void TryLoadAddon(const char* filename,
1145
                    int flags,
1146
                    const std::function<bool(binding::DLib*)>& was_loaded);
1147
1148
  static inline Environment* from_timer_handle(uv_timer_t* handle);
1149
  inline uv_timer_t* timer_handle();
1150
1151
  static inline Environment* from_immediate_check_handle(uv_check_t* handle);
1152
  inline uv_check_t* immediate_check_handle();
1153
  inline uv_idle_t* immediate_idle_handle();
1154
1155
  inline void IncreaseWaitingRequestCounter();
1156
  inline void DecreaseWaitingRequestCounter();
1157
1158
  inline AsyncHooks* async_hooks();
1159
  inline ImmediateInfo* immediate_info();
1160
  inline TickInfo* tick_info();
1161
  inline uint64_t timer_base() const;
1162
  inline std::shared_ptr<KVStore> env_vars();
1163
  inline void set_env_vars(std::shared_ptr<KVStore> env_vars);
1164
1165
  inline IsolateData* isolate_data() const;
1166
1167
  inline bool printed_error() const;
1168
  inline void set_printed_error(bool value);
1169
1170
  void PrintSyncTrace() const;
1171
  inline void set_trace_sync_io(bool value);
1172
1173
  inline void set_force_context_aware(bool value);
1174
  inline bool force_context_aware() const;
1175
1176
  // This stores whether the --abort-on-uncaught-exception flag was passed
1177
  // to Node.
1178
  inline bool abort_on_uncaught_exception() const;
1179
  inline void set_abort_on_uncaught_exception(bool value);
1180
  // This is a pseudo-boolean that keeps track of whether an uncaught exception
1181
  // should abort the process or not if --abort-on-uncaught-exception was
1182
  // passed to Node. If the flag was not passed, it is ignored.
1183
  inline AliasedUint32Array& should_abort_on_uncaught_toggle();
1184
1185
  inline AliasedInt32Array& stream_base_state();
1186
1187
  // The necessary API for async_hooks.
1188
  inline double new_async_id();
1189
  inline double execution_async_id();
1190
  inline double trigger_async_id();
1191
  inline double get_default_trigger_async_id();
1192
1193
  // List of id's that have been destroyed and need the destroy() cb called.
1194
  inline std::vector<double>* destroy_async_id_list();
1195
1196
  std::set<struct node_module*> internal_bindings;
1197
  std::set<std::string> native_modules_with_cache;
1198
  std::set<std::string> native_modules_without_cache;
1199
  // This is only filled during deserialization. We use a vector since
1200
  // it's only used for tests.
1201
  std::vector<std::string> native_modules_in_snapshot;
1202
1203
  std::unordered_multimap<int, loader::ModuleWrap*> hash_to_module_map;
1204
  std::unordered_map<uint32_t, loader::ModuleWrap*> id_to_module_map;
1205
  std::unordered_map<uint32_t, contextify::ContextifyScript*>
1206
      id_to_script_map;
1207
  std::unordered_map<uint32_t, contextify::CompiledFnEntry*> id_to_function_map;
1208
1209
  inline uint32_t get_next_module_id();
1210
  inline uint32_t get_next_script_id();
1211
  inline uint32_t get_next_function_id();
1212
1213
1394257
  EnabledDebugList* enabled_debug_list() { return &enabled_debug_list_; }
1214
1215
  inline performance::PerformanceState* performance_state();
1216
1217
  void CollectUVExceptionInfo(v8::Local<v8::Value> context,
1218
                              int errorno,
1219
                              const char* syscall = nullptr,
1220
                              const char* message = nullptr,
1221
                              const char* path = nullptr,
1222
                              const char* dest = nullptr);
1223
1224
  // If this flag is set, calls into JS (if they would be observable
1225
  // from userland) must be avoided.  This flag does not indicate whether
1226
  // calling into JS is allowed from a VM perspective at this point.
1227
  inline bool can_call_into_js() const;
1228
  inline void set_can_call_into_js(bool can_call_into_js);
1229
1230
  // Increase or decrease a counter that manages whether this Environment
1231
  // keeps the event loop alive on its own or not. The counter starts out at 0,
1232
  // meaning it does not, and any positive value will make it keep the event
1233
  // loop alive.
1234
  // This is used by Workers to manage their own .ref()/.unref() implementation,
1235
  // as Workers aren't directly associated with their own libuv handles.
1236
  void add_refs(int64_t diff);
1237
1238
  inline bool has_run_bootstrapping_code() const;
1239
  inline void DoneBootstrapping();
1240
1241
  inline bool has_serialized_options() const;
1242
  inline void set_has_serialized_options(bool has_serialized_options);
1243
1244
  inline bool is_main_thread() const;
1245
  inline bool no_native_addons() const;
1246
  inline bool should_not_register_esm_loader() const;
1247
  inline bool should_create_inspector() const;
1248
  inline bool owns_process_state() const;
1249
  inline bool owns_inspector() const;
1250
  inline bool tracks_unmanaged_fds() const;
1251
  inline bool hide_console_windows() const;
1252
  inline bool no_global_search_paths() const;
1253
  inline bool no_browser_globals() const;
1254
  inline uint64_t thread_id() const;
1255
  inline worker::Worker* worker_context() const;
1256
  Environment* worker_parent_env() const;
1257
  inline void add_sub_worker_context(worker::Worker* context);
1258
  inline void remove_sub_worker_context(worker::Worker* context);
1259
  void stop_sub_worker_contexts();
1260
  template <typename Fn>
1261
  inline void ForEachWorker(Fn&& iterator);
1262
  inline bool is_stopping() const;
1263
  inline void set_stopping(bool value);
1264
  inline std::list<node_module>* extra_linked_bindings();
1265
  inline node_module* extra_linked_bindings_head();
1266
  inline node_module* extra_linked_bindings_tail();
1267
  inline const Mutex& extra_linked_bindings_mutex() const;
1268
1269
  inline bool filehandle_close_warning() const;
1270
  inline void set_filehandle_close_warning(bool on);
1271
1272
  inline void set_source_maps_enabled(bool on);
1273
  inline bool source_maps_enabled() const;
1274
1275
  inline void ThrowError(const char* errmsg);
1276
  inline void ThrowTypeError(const char* errmsg);
1277
  inline void ThrowRangeError(const char* errmsg);
1278
  inline void ThrowErrnoException(int errorno,
1279
                                  const char* syscall = nullptr,
1280
                                  const char* message = nullptr,
1281
                                  const char* path = nullptr);
1282
  inline void ThrowUVException(int errorno,
1283
                               const char* syscall = nullptr,
1284
                               const char* message = nullptr,
1285
                               const char* path = nullptr,
1286
                               const char* dest = nullptr);
1287
1288
  v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
1289
      v8::FunctionCallback callback,
1290
      v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
1291
      v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
1292
      v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
1293
      const v8::CFunction* c_function = nullptr);
1294
1295
  // Convenience methods for NewFunctionTemplate().
1296
  void SetMethod(v8::Local<v8::Object> that,
1297
                 const char* name,
1298
                 v8::FunctionCallback callback);
1299
1300
  void SetFastMethod(v8::Local<v8::Object> that,
1301
                     const char* name,
1302
                     v8::FunctionCallback slow_callback,
1303
                     const v8::CFunction* c_function);
1304
1305
  void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
1306
                      const char* name,
1307
                      v8::FunctionCallback callback);
1308
1309
  void SetInstanceMethod(v8::Local<v8::FunctionTemplate> that,
1310
                         const char* name,
1311
                         v8::FunctionCallback callback);
1312
1313
  // Safe variants denote the function has no side effects.
1314
  void SetMethodNoSideEffect(v8::Local<v8::Object> that,
1315
                             const char* name,
1316
                             v8::FunctionCallback callback);
1317
  void SetProtoMethodNoSideEffect(v8::Local<v8::FunctionTemplate> that,
1318
                                  const char* name,
1319
                                  v8::FunctionCallback callback);
1320
1321
  enum class SetConstructorFunctionFlag {
1322
    NONE,
1323
    SET_CLASS_NAME,
1324
  };
1325
1326
  void SetConstructorFunction(v8::Local<v8::Object> that,
1327
                              const char* name,
1328
                              v8::Local<v8::FunctionTemplate> tmpl,
1329
                              SetConstructorFunctionFlag flag =
1330
                                  SetConstructorFunctionFlag::SET_CLASS_NAME);
1331
1332
  void SetConstructorFunction(v8::Local<v8::Object> that,
1333
                              v8::Local<v8::String> name,
1334
                              v8::Local<v8::FunctionTemplate> tmpl,
1335
                              SetConstructorFunctionFlag flag =
1336
                                  SetConstructorFunctionFlag::SET_CLASS_NAME);
1337
1338
  void AtExit(void (*cb)(void* arg), void* arg);
1339
  void RunAtExitCallbacks();
1340
1341
  void RunWeakRefCleanup();
1342
1343
  v8::MaybeLocal<v8::Value> RunSnapshotSerializeCallback() const;
1344
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeCallback() const;
1345
  v8::MaybeLocal<v8::Value> RunSnapshotDeserializeMain() const;
1346
1347
  // Strings and private symbols are shared across shared contexts
1348
  // The getters simply proxy to the per-isolate primitive.
1349
#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
1350
#define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
1351
#define VS(PropertyName, StringValue) V(v8::String, PropertyName)
1352
#define V(TypeName, PropertyName)                                             \
1353
  inline v8::Local<TypeName> PropertyName() const;
1354
  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)
1355
  PER_ISOLATE_SYMBOL_PROPERTIES(VY)
1356
  PER_ISOLATE_STRING_PROPERTIES(VS)
1357
#undef V
1358
#undef VS
1359
#undef VY
1360
#undef VP
1361
1362
#define V(PropertyName, TypeName)                                             \
1363
  inline v8::Local<TypeName> PropertyName() const;                            \
1364
  inline void set_ ## PropertyName(v8::Local<TypeName> value);
1365
  PER_ISOLATE_TEMPLATE_PROPERTIES(V)
1366
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1367
#undef V
1368
1369
  inline v8::Local<v8::Context> context() const;
1370
1371
#if HAVE_INSPECTOR
1372
79950
  inline inspector::Agent* inspector_agent() const {
1373
79950
    return inspector_agent_.get();
1374
  }
1375
1376
  inline bool is_in_inspector_console_call() const;
1377
  inline void set_is_in_inspector_console_call(bool value);
1378
#endif
1379
1380
  typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;
1381
  typedef ListHead<ReqWrapBase, &ReqWrapBase::req_wrap_queue_> ReqWrapQueue;
1382
1383
61926
  inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }
1384
79931
  inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }
1385
1386
7874
  inline uint64_t time_origin() {
1387
7874
    return time_origin_;
1388
  }
1389
7858
  inline double time_origin_timestamp() {
1390
7858
    return time_origin_timestamp_;
1391
  }
1392
1393
1
  inline bool EmitProcessEnvWarning() {
1394
1
    bool current_value = emit_env_nonstring_warning_;
1395
1
    emit_env_nonstring_warning_ = false;
1396
1
    return current_value;
1397
  }
1398
1399
1
  inline bool EmitErrNameWarning() {
1400
1
    bool current_value = emit_err_name_warning_;
1401
1
    emit_err_name_warning_ = false;
1402
1
    return current_value;
1403
  }
1404
1405
  // cb will be called as cb(env) on the next event loop iteration.
1406
  // Unlike the JS setImmediate() function, nested SetImmediate() calls will
1407
  // be run without returning control to the event loop, similar to nextTick().
1408
  template <typename Fn>
1409
  inline void SetImmediate(
1410
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1411
  template <typename Fn>
1412
  // This behaves like SetImmediate() but can be called from any thread.
1413
  inline void SetImmediateThreadsafe(
1414
      Fn&& cb, CallbackFlags::Flags flags = CallbackFlags::kRefed);
1415
  // This behaves like V8's Isolate::RequestInterrupt(), but also accounts for
1416
  // the event loop (i.e. combines the V8 function with SetImmediate()).
1417
  // The passed callback may not throw exceptions.
1418
  // This function can be called from any thread.
1419
  template <typename Fn>
1420
  inline void RequestInterrupt(Fn&& cb);
1421
  // This needs to be available for the JS-land setImmediate().
1422
  void ToggleImmediateRef(bool ref);
1423
1424
  inline void PushShouldNotAbortOnUncaughtScope();
1425
  inline void PopShouldNotAbortOnUncaughtScope();
1426
  inline bool inside_should_not_abort_on_uncaught_scope() const;
1427
1428
  static inline Environment* ForAsyncHooks(AsyncHooks* hooks);
1429
1430
  v8::Local<v8::Value> GetNow();
1431
  void ScheduleTimer(int64_t duration);
1432
  void ToggleTimerRef(bool ref);
1433
1434
  using CleanupCallback = CleanupHookCallback::Callback;
1435
  inline void AddCleanupHook(CleanupCallback cb, void* arg);
1436
  inline void RemoveCleanupHook(CleanupCallback cb, void* arg);
1437
  void RunCleanup();
1438
1439
  static size_t NearHeapLimitCallback(void* data,
1440
                                      size_t current_heap_limit,
1441
                                      size_t initial_heap_limit);
1442
  static void BuildEmbedderGraph(v8::Isolate* isolate,
1443
                                 v8::EmbedderGraph* graph,
1444
                                 void* data);
1445
1446
  inline std::shared_ptr<EnvironmentOptions> options();
1447
  inline std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port();
1448
1449
  // The BaseObject count is a debugging helper that makes sure that there are
1450
  // no memory leaks caused by BaseObjects staying alive longer than expected
1451
  // (in particular, no circular BaseObjectPtr references).
1452
  inline void modify_base_object_count(int64_t delta);
1453
  inline int64_t base_object_created_after_bootstrap() const;
1454
  inline int64_t base_object_count() const;
1455
1456
3
  inline int32_t stack_trace_limit() const { return 10; }
1457
1458
#if HAVE_INSPECTOR
1459
  void set_coverage_connection(
1460
      std::unique_ptr<profiler::V8CoverageConnection> connection);
1461
  profiler::V8CoverageConnection* coverage_connection();
1462
1463
  inline void set_coverage_directory(const char* directory);
1464
  inline const std::string& coverage_directory() const;
1465
1466
  void set_cpu_profiler_connection(
1467
      std::unique_ptr<profiler::V8CpuProfilerConnection> connection);
1468
  profiler::V8CpuProfilerConnection* cpu_profiler_connection();
1469
1470
  inline void set_cpu_prof_name(const std::string& name);
1471
  inline const std::string& cpu_prof_name() const;
1472
1473
  inline void set_cpu_prof_interval(uint64_t interval);
1474
  inline uint64_t cpu_prof_interval() const;
1475
1476
  inline void set_cpu_prof_dir(const std::string& dir);
1477
  inline const std::string& cpu_prof_dir() const;
1478
1479
  void set_heap_profiler_connection(
1480
      std::unique_ptr<profiler::V8HeapProfilerConnection> connection);
1481
  profiler::V8HeapProfilerConnection* heap_profiler_connection();
1482
1483
  inline void set_heap_prof_name(const std::string& name);
1484
  inline const std::string& heap_prof_name() const;
1485
1486
  inline void set_heap_prof_dir(const std::string& dir);
1487
  inline const std::string& heap_prof_dir() const;
1488
1489
  inline void set_heap_prof_interval(uint64_t interval);
1490
  inline uint64_t heap_prof_interval() const;
1491
1492
#endif  // HAVE_INSPECTOR
1493
1494
  inline void set_main_utf16(std::unique_ptr<v8::String::Value>);
1495
  inline void set_process_exit_handler(
1496
      std::function<void(Environment*, int)>&& handler);
1497
1498
  void RunAndClearNativeImmediates(bool only_refed = false);
1499
  void RunAndClearInterrupts();
1500
1501
  uv_buf_t allocate_managed_buffer(const size_t suggested_size);
1502
  std::unique_ptr<v8::BackingStore> release_managed_buffer(const uv_buf_t& buf);
1503
1504
  void AddUnmanagedFd(int fd);
1505
  void RemoveUnmanagedFd(int fd);
1506
1507
  template <typename T>
1508
  void ForEachBindingData(T&& iterator);
1509
1510
 private:
1511
  inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
1512
                         const char* errmsg);
1513
1514
  std::list<binding::DLib> loaded_addons_;
1515
  v8::Isolate* const isolate_;
1516
  IsolateData* const isolate_data_;
1517
  uv_timer_t timer_handle_;
1518
  uv_check_t immediate_check_handle_;
1519
  uv_idle_t immediate_idle_handle_;
1520
  uv_prepare_t idle_prepare_handle_;
1521
  uv_check_t idle_check_handle_;
1522
  uv_async_t task_queues_async_;
1523
  int64_t task_queues_async_refs_ = 0;
1524
1525
  AsyncHooks async_hooks_;
1526
  ImmediateInfo immediate_info_;
1527
  TickInfo tick_info_;
1528
  const uint64_t timer_base_;
1529
  std::shared_ptr<KVStore> env_vars_;
1530
  bool printed_error_ = false;
1531
  bool trace_sync_io_ = false;
1532
  bool emit_env_nonstring_warning_ = true;
1533
  bool emit_err_name_warning_ = true;
1534
  bool emit_filehandle_warning_ = true;
1535
  bool source_maps_enabled_ = false;
1536
1537
  size_t async_callback_scope_depth_ = 0;
1538
  std::vector<double> destroy_async_id_list_;
1539
1540
#if HAVE_INSPECTOR
1541
  std::unique_ptr<profiler::V8CoverageConnection> coverage_connection_;
1542
  std::unique_ptr<profiler::V8CpuProfilerConnection> cpu_profiler_connection_;
1543
  std::string coverage_directory_;
1544
  std::string cpu_prof_dir_;
1545
  std::string cpu_prof_name_;
1546
  uint64_t cpu_prof_interval_;
1547
  std::unique_ptr<profiler::V8HeapProfilerConnection> heap_profiler_connection_;
1548
  std::string heap_prof_dir_;
1549
  std::string heap_prof_name_;
1550
  uint64_t heap_prof_interval_;
1551
#endif  // HAVE_INSPECTOR
1552
1553
  std::shared_ptr<EnvironmentOptions> options_;
1554
  // options_ contains debug options parsed from CLI arguments,
1555
  // while inspector_host_port_ stores the actual inspector host
1556
  // and port being used. For example the port is -1 by default
1557
  // and can be specified as 0 (meaning any port allocated when the
1558
  // server starts listening), but when the inspector server starts
1559
  // the inspector_host_port_->port() will be the actual port being
1560
  // used.
1561
  std::shared_ptr<ExclusiveAccess<HostPort>> inspector_host_port_;
1562
  std::vector<std::string> exec_argv_;
1563
  std::vector<std::string> argv_;
1564
  std::string exec_path_;
1565
1566
  bool is_processing_heap_limit_callback_ = false;
1567
  int64_t heap_limit_snapshot_taken_ = 0;
1568
1569
  uint32_t module_id_counter_ = 0;
1570
  uint32_t script_id_counter_ = 0;
1571
  uint32_t function_id_counter_ = 0;
1572
1573
  AliasedUint32Array should_abort_on_uncaught_toggle_;
1574
  int should_not_abort_scope_counter_ = 0;
1575
1576
  std::unique_ptr<TrackingTraceStateObserver> trace_state_observer_;
1577
1578
  AliasedInt32Array stream_base_state_;
1579
1580
  // https://w3c.github.io/hr-time/#dfn-time-origin
1581
  uint64_t time_origin_;
1582
  // https://w3c.github.io/hr-time/#dfn-get-time-origin-timestamp
1583
  double time_origin_timestamp_;
1584
  std::unique_ptr<performance::PerformanceState> performance_state_;
1585
1586
  bool has_run_bootstrapping_code_ = false;
1587
  bool has_serialized_options_ = false;
1588
1589
  std::atomic_bool can_call_into_js_ { true };
1590
  uint64_t flags_;
1591
  uint64_t thread_id_;
1592
  std::unordered_set<worker::Worker*> sub_worker_contexts_;
1593
1594
  static void* const kNodeContextTagPtr;
1595
  static int const kNodeContextTag;
1596
1597
#if HAVE_INSPECTOR
1598
  std::unique_ptr<inspector::Agent> inspector_agent_;
1599
  bool is_in_inspector_console_call_ = false;
1600
#endif
1601
1602
  std::list<DeserializeRequest> deserialize_requests_;
1603
1604
  // handle_wrap_queue_ and req_wrap_queue_ needs to be at a fixed offset from
1605
  // the start of the class because it is used by
1606
  // src/node_postmortem_metadata.cc to calculate offsets and generate debug
1607
  // symbols for Environment, which assumes that the position of members in
1608
  // memory are predictable. For more information please refer to
1609
  // `doc/contributing/node-postmortem-support.md`
1610
  friend int GenDebugSymbols();
1611
  HandleWrapQueue handle_wrap_queue_;
1612
  ReqWrapQueue req_wrap_queue_;
1613
  std::list<HandleCleanup> handle_cleanup_queue_;
1614
  int handle_cleanup_waiting_ = 0;
1615
  int request_waiting_ = 0;
1616
1617
  EnabledDebugList enabled_debug_list_;
1618
1619
  std::list<node_module> extra_linked_bindings_;
1620
  Mutex extra_linked_bindings_mutex_;
1621
1622
  static void RunTimers(uv_timer_t* handle);
1623
1624
  struct ExitCallback {
1625
    void (*cb_)(void* arg);
1626
    void* arg_;
1627
  };
1628
1629
  std::list<ExitCallback> at_exit_functions_;
1630
1631
  typedef CallbackQueue<void, Environment*> NativeImmediateQueue;
1632
  NativeImmediateQueue native_immediates_;
1633
  Mutex native_immediates_threadsafe_mutex_;
1634
  NativeImmediateQueue native_immediates_threadsafe_;
1635
  NativeImmediateQueue native_immediates_interrupts_;
1636
  // Also guarded by native_immediates_threadsafe_mutex_. This can be used when
1637
  // trying to post tasks from other threads to an Environment, as the libuv
1638
  // handle for the immediate queues (task_queues_async_) may not be initialized
1639
  // yet or already have been destroyed.
1640
  bool task_queues_async_initialized_ = false;
1641
1642
  std::atomic<Environment**> interrupt_data_ {nullptr};
1643
  void RequestInterruptFromV8();
1644
  static void CheckImmediate(uv_check_t* handle);
1645
1646
  BindingDataStore bindings_;
1647
1648
  // Use an unordered_set, so that we have efficient insertion and removal.
1649
  std::unordered_set<CleanupHookCallback,
1650
                     CleanupHookCallback::Hash,
1651
                     CleanupHookCallback::Equal> cleanup_hooks_;
1652
  uint64_t cleanup_hook_counter_ = 0;
1653
  bool started_cleanup_ = false;
1654
1655
  int64_t base_object_count_ = 0;
1656
  int64_t base_object_created_by_bootstrap_ = 0;
1657
  std::atomic_bool is_stopping_ { false };
1658
1659
  std::unordered_set<int> unmanaged_fds_;
1660
1661
  std::function<void(Environment*, int)> process_exit_handler_ {
1662
      DefaultProcessExitHandler };
1663
1664
  template <typename T>
1665
  void ForEachBaseObject(T&& iterator);
1666
1667
#define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName ## _;
1668
  ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)
1669
#undef V
1670
1671
  v8::Global<v8::Context> context_;
1672
1673
  // Keeps the main script source alive is one was passed to LoadEnvironment().
1674
  // We should probably find a way to just use plain `v8::String`s created from
1675
  // the source passed to LoadEnvironment() directly instead.
1676
  std::unique_ptr<v8::String::Value> main_utf16_;
1677
1678
  // Used by allocate_managed_buffer() and release_managed_buffer() to keep
1679
  // track of the BackingStore for a given pointer.
1680
  std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
1681
      released_allocated_buffers_;
1682
};
1683
1684
}  // namespace node
1685
1686
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
1687
1688
#endif  // SRC_ENV_H_