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