GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: env.h Lines: 40 40 100.0 %
Date: 2022-07-14 04:20:11 Branches: 1 2 50.0 %

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