@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/logstream.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <async_wrap.h>
+#include <base_object.h>
+#include <env.h>
+#include <stream_base.h>
+#include <deque>
+
+namespace node::quic {
+
+// The LogStream is a utility that the QUIC impl uses to publish both QLog
+// and Keylog diagnostic data (one instance for each).
+class LogStream : public AsyncWrap, public StreamBase {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  static BaseObjectPtr<LogStream> Create(Environment* env);
+
+  LogStream(Environment* env, v8::Local<v8::Object> obj);
+
+  enum class EmitOption {
+    NONE,
+    FIN,
+  };
+
+  void Emit(const uint8_t* data,
+            size_t len,
+            EmitOption option = EmitOption::NONE);
+
+  void Emit(const std::string_view line, EmitOption option = EmitOption::NONE);
+
+  void End();
+
+  int ReadStart() override;
+
+  int ReadStop() override;
+
+  // We do not use either of these.
+  int DoShutdown(ShutdownWrap* req_wrap) override;
+  int DoWrite(WriteWrap* w,
+              uv_buf_t* bufs,
+              size_t count,
+              uv_stream_t* send_handle) override;
+
+  bool IsAlive() override;
+  bool IsClosing() override;
+  AsyncWrap* GetAsyncWrap() override;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(LogStream)
+  SET_SELF_SIZE(LogStream)
+
+ private:
+  struct Chunk {
+    // len will be <= buf.len
+    size_t len;
+    uv_buf_t buf;
+  };
+  size_t total_ = 0;
+  bool fin_seen_ = false;
+  bool ended_ = false;
+  bool reading_ = false;
+  std::deque<Chunk> buffer_;
+
+  // The value here is fairly arbitrary. Once we get everything
+  // fully implemented and start working with this, we might
+  // tune this number further.
+  static constexpr size_t kMaxLogStreamBuffer = 1024 * 10;
+
+  // The LogStream buffer enforces a maximum size of kMaxLogStreamBuffer.
+  void ensure_space(size_t amt);
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/main_thread_interface.h

@@ -0,0 +1,116 @@
+#ifndef SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+#define SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "inspector_agent.h"
+#include "node_mutex.h"
+
+#include <atomic>
+#include <deque>
+#include <memory>
+#include <unordered_map>
+
+namespace v8_inspector {
+class StringBuffer;
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+namespace inspector {
+class MainThreadInterface;
+
+class Request {
+ public:
+  virtual void Call(MainThreadInterface*) = 0;
+  virtual ~Request() = default;
+};
+
+class Deletable {
+ public:
+  virtual ~Deletable() = default;
+};
+
+std::unique_ptr<v8_inspector::StringBuffer> Utf8ToStringView(
+    const std::string_view message);
+
+using MessageQueue = std::deque<std::unique_ptr<Request>>;
+
+class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
+ public:
+  explicit MainThreadHandle(MainThreadInterface* main_thread)
+                            : main_thread_(main_thread) {
+  }
+  ~MainThreadHandle() {
+    Mutex::ScopedLock scoped_lock(block_lock_);
+    CHECK_NULL(main_thread_);  // main_thread_ should have called Reset
+  }
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+  int newObjectId() {
+    return ++next_object_id_;
+  }
+  bool Post(std::unique_ptr<Request> request);
+  std::unique_ptr<InspectorSessionDelegate> MakeDelegateThreadSafe(
+      std::unique_ptr<InspectorSessionDelegate> delegate);
+  bool Expired();
+  void SetTargetSessionId(int target_session_id) {
+    target_session_id_ = target_session_id;
+  }
+  std::optional<int> GetTargetSessionId() { return target_session_id_; }
+
+ private:
+  void Reset();
+
+  MainThreadInterface* main_thread_;
+  Mutex block_lock_;
+  int next_session_id_ = 0;
+  std::atomic_int next_object_id_ = {1};
+  std::optional<int> target_session_id_ = std::nullopt;
+
+  friend class MainThreadInterface;
+};
+
+class MainThreadInterface :
+    public std::enable_shared_from_this<MainThreadInterface> {
+ public:
+  explicit MainThreadInterface(Agent* agent);
+  ~MainThreadInterface();
+
+  void DispatchMessages();
+  void Post(std::unique_ptr<Request> request);
+  bool WaitForFrontendEvent();
+  void StopWaitingForFrontendEvent();
+  std::shared_ptr<MainThreadHandle> GetHandle();
+  Agent* inspector_agent() {
+    return agent_;
+  }
+  void AddObject(int handle, std::unique_ptr<Deletable> object);
+  Deletable* GetObject(int id);
+  Deletable* GetObjectIfExists(int id);
+  void RemoveObject(int handle);
+
+ private:
+  MessageQueue requests_;
+  Mutex requests_lock_;   // requests_ live across threads
+  // This queue is to maintain the order of the messages for the cases
+  // when we reenter the DispatchMessages function.
+  MessageQueue dispatching_message_queue_;
+  bool dispatching_messages_ = false;
+  // This flag indicates an internal request to exit the loop in
+  // WaitForFrontendEvent(). It's set to true by calling
+  // StopWaitingForFrontendEvent().
+  bool stop_waiting_for_frontend_event_requested_ = false;
+  ConditionVariable incoming_message_cond_;
+  // Used from any thread
+  Agent* const agent_;
+  std::shared_ptr<MainThreadHandle> handle_;
+  std::unordered_map<int, std::unique_ptr<Deletable>> managed_objects_;
+};
+
+}  // namespace inspector
+}  // namespace node
+#endif  // SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_

package/src/headers/{16 → 24}/memory_tracker-inl.h

@@ -3,7 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include "cppgc_helpers.h"
 #include "memory_tracker.h"
+#include "util-inl.h"
 
 namespace node {
 
@@ -27,10 +29,28 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
     CHECK_NOT_NULL(retainer_);
     v8::HandleScope handle_scope(tracker->isolate());
     v8::Local<v8::Object> obj = retainer_->WrappedObject();
-    if (!obj.IsEmpty()) wrapper_node_ = tracker->graph()->V8Node(obj);
+    if (!obj.IsEmpty())
+      wrapper_node_ = tracker->graph()->V8Node(obj.As<v8::Value>());
 
     name_ = retainer_->MemoryInfoName();
     size_ = retainer_->SelfSize();
+    detachedness_ = retainer_->GetDetachedness();
+  }
+
+  inline MemoryRetainerNode(MemoryTracker* tracker, const CppgcMixin* mixin)
+      : retainer_(mixin) {
+    // In this case, the MemoryRetainerNode is merely a wrapper
+    // to be used in the NodeMap and stack. The actual node being using to add
+    // edges is always the merged wrapper node of the cppgc-managed wrapper.
+    CHECK_NOT_NULL(retainer_);
+    v8::Isolate* isolate = tracker->isolate();
+    v8::HandleScope handle_scope(isolate);
+    v8::Local<v8::Object> obj = mixin->object(isolate);
+    wrapper_node_ = tracker->graph()->V8Node(obj.As<v8::Value>());
+
+    name_ = retainer_->MemoryInfoName();
+    size_ = 0;
+    detachedness_ = retainer_->GetDetachedness();
   }
 
   inline MemoryRetainerNode(MemoryTracker* tracker,
@@ -43,7 +63,7 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
     is_root_node_ = is_root_node;
   }
 
-  const char* Name() override { return name_.c_str(); }
+  const char* Name() override { return name_; }
   const char* NamePrefix() override { return "Node /"; }
   size_t SizeInBytes() override { return size_; }
   // TODO(addaleax): Merging this with the "official" WrapperNode() method
@@ -58,6 +78,14 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
     return is_root_node_;
   }
 
+  bool IsCppgcWrapper() const {
+    return retainer_ != nullptr && retainer_->IsCppgcWrapper();
+  }
+
+  v8::EmbedderGraph::Node::Detachedness GetDetachedness() override {
+    return detachedness_;
+  }
+
  private:
   friend class MemoryTracker;
 
@@ -71,8 +99,10 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
 
   // Otherwise (retainer == nullptr), we set these fields in an ad-hoc way
   bool is_root_node_ = false;
-  std::string name_;
+  const char* name_;
   size_t size_ = 0;
+  v8::EmbedderGraph::Node::Detachedness detachedness_ =
+      v8::EmbedderGraph::Node::Detachedness::kUnknown;
 };
 
 void MemoryTracker::TrackFieldWithSize(const char* edge_name,
@@ -86,7 +116,7 @@ void MemoryTracker::TrackInlineFieldWithSize(const char* edge_name,
                                              const char* node_name) {
   if (size > 0) AddNode(GetNodeName(node_name, edge_name), size, edge_name);
   CHECK(CurrentNode());
-  CurrentNode()->size_ -= size;
+  AdjustCurrentNodeSize(-static_cast<int>(size));
 }
 
 void MemoryTracker::TrackField(const char* edge_name,
@@ -147,7 +177,7 @@ void MemoryTracker::TrackField(const char* edge_name,
   // Fall back to edge name if node names are not provided
   if (CurrentNode() != nullptr && subtract_from_self) {
     // Shift the self size of this container out to a separate node
-    CurrentNode()->size_ -= sizeof(T);
+    AdjustCurrentNodeSize(-static_cast<int>(sizeof(T)));
   }
   PushNode(GetNodeName(node_name, edge_name), sizeof(T), edge_name);
   for (Iterator it = value.begin(); it != value.end(); ++it) {
@@ -178,7 +208,7 @@ void MemoryTracker::TrackField(const char* edge_name,
                                const T& value,
                                const char* node_name) {
   // For numbers, creating new nodes is not worth the overhead.
-  CurrentNode()->size_ += sizeof(T);
+  AdjustCurrentNodeSize(static_cast<int>(sizeof(T)));
 }
 
 template <typename T, typename U>
@@ -223,7 +253,9 @@ void MemoryTracker::TrackField(const char* edge_name,
                                const v8::Local<T>& value,
                                const char* node_name) {
   if (!value.IsEmpty())
-    graph_->AddEdge(CurrentNode(), graph_->V8Node(value), edge_name);
+    graph_->AddEdge(CurrentNode(),
+                    graph_->V8Node(value.template As<v8::Value>()),
+                    edge_name);
 }
 
 template <typename T>
@@ -263,11 +295,20 @@ void MemoryTracker::TrackInlineField(const char* name,
   TrackInlineFieldWithSize(name, sizeof(value), "uv_async_t");
 }
 
-template <class NativeT, class V8T>
-void MemoryTracker::TrackField(const char* name,
-                               const AliasedBufferBase<NativeT, V8T>& value,
-                               const char* node_name) {
-  TrackField(name, value.GetJSArray(), "AliasedBuffer");
+void MemoryTracker::Track(const CppgcMixin* retainer, const char* edge_name) {
+  v8::HandleScope handle_scope(isolate_);
+  auto it = seen_.find(retainer);
+  if (it != seen_.end()) {
+    if (CurrentNode() != nullptr) {
+      graph_->AddEdge(CurrentNode(), it->second, edge_name);
+    }
+    return;  // It has already been tracked, no need to call MemoryInfo again
+  }
+  MemoryRetainerNode* n = PushNode(retainer, edge_name);
+  retainer->MemoryInfo(this);
+  CHECK_EQ(CurrentNode(), n->JSWrapperNode());
+  // This is a dummy MemoryRetainerNode. The real graph node is wrapper_node_.
+  PopNode();
 }
 
 void MemoryTracker::Track(const MemoryRetainer* retainer,
@@ -291,12 +332,54 @@ void MemoryTracker::TrackInlineField(const MemoryRetainer* retainer,
                                      const char* edge_name) {
   Track(retainer, edge_name);
   CHECK(CurrentNode());
-  CurrentNode()->size_ -= retainer->SelfSize();
+  AdjustCurrentNodeSize(-(static_cast<int>(retainer->SelfSize())));
 }
 
-MemoryRetainerNode* MemoryTracker::CurrentNode() const {
+template <typename T>
+inline void MemoryTracker::TraitTrack(const T& retainer,
+                                      const char* edge_name) {
+  MemoryRetainerNode* n =
+      PushNode(MemoryRetainerTraits<T>::MemoryInfoName(retainer),
+               MemoryRetainerTraits<T>::SelfSize(retainer),
+               edge_name);
+  MemoryRetainerTraits<T>::MemoryInfo(this, retainer);
+  CHECK_EQ(CurrentNode(), n);
+  CHECK_NE(n->size_, 0);
+  PopNode();
+}
+
+template <typename T>
+inline void MemoryTracker::TraitTrackInline(const T& retainer,
+                                            const char* edge_name) {
+  TraitTrack(retainer, edge_name);
+  CHECK(CurrentNode());
+  AdjustCurrentNodeSize(
+      -(static_cast<int>(MemoryRetainerTraits<T>::SelfSize(retainer))));
+}
+
+v8::EmbedderGraph::Node* MemoryTracker::CurrentNode() const {
   if (node_stack_.empty()) return nullptr;
-  return node_stack_.top();
+  MemoryRetainerNode* n = node_stack_.top();
+  if (n->IsCppgcWrapper()) {
+    return n->JSWrapperNode();
+  }
+  return n;
+}
+
+MemoryRetainerNode* MemoryTracker::AddNode(const CppgcMixin* retainer,
+                                           const char* edge_name) {
+  auto it = seen_.find(retainer);
+  if (it != seen_.end()) {
+    return it->second;
+  }
+
+  MemoryRetainerNode* n = new MemoryRetainerNode(this, retainer);
+  seen_[retainer] = n;
+  if (CurrentNode() != nullptr) {
+    graph_->AddEdge(CurrentNode(), n->JSWrapperNode(), edge_name);
+  }
+
+  return n;
 }
 
 MemoryRetainerNode* MemoryTracker::AddNode(const MemoryRetainer* retainer,
@@ -312,8 +395,8 @@ MemoryRetainerNode* MemoryTracker::AddNode(const MemoryRetainer* retainer,
   if (CurrentNode() != nullptr) graph_->AddEdge(CurrentNode(), n, edge_name);
 
   if (n->JSWrapperNode() != nullptr) {
-    graph_->AddEdge(n, n->JSWrapperNode(), "wrapped");
-    graph_->AddEdge(n->JSWrapperNode(), n, "wrapper");
+    graph_->AddEdge(n, n->JSWrapperNode(), "native_to_javascript");
+    graph_->AddEdge(n->JSWrapperNode(), n, "javascript_to_native");
   }
 
   return n;
@@ -330,6 +413,13 @@ MemoryRetainerNode* MemoryTracker::AddNode(const char* node_name,
   return n;
 }
 
+MemoryRetainerNode* MemoryTracker::PushNode(const CppgcMixin* retainer,
+                                            const char* edge_name) {
+  MemoryRetainerNode* n = AddNode(retainer, edge_name);
+  node_stack_.push(n);
+  return n;
+}
+
 MemoryRetainerNode* MemoryTracker::PushNode(const MemoryRetainer* retainer,
                                             const char* edge_name) {
   MemoryRetainerNode* n = AddNode(retainer, edge_name);
@@ -349,6 +439,14 @@ void MemoryTracker::PopNode() {
   node_stack_.pop();
 }
 
+void MemoryTracker::AdjustCurrentNodeSize(int diff) {
+  if (node_stack_.empty()) return;
+  MemoryRetainerNode* n = node_stack_.top();
+  if (!n->IsCppgcWrapper()) {
+    n->size_ = static_cast<size_t>(static_cast<int>(n->size_) + diff);
+  }
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/{16 → 24}/memory_tracker.h

@@ -2,7 +2,6 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "aliased_buffer.h"
 #include "v8-profiler.h"
 
 #include <uv.h>
@@ -13,11 +12,20 @@
 #include <string>
 #include <unordered_map>
 
+namespace v8 {
+class BackingStore;
+}
+
 namespace node {
 
+class CppgcMixin;
+
+template <typename T>
+struct MallocedBuffer;
+
 // Set the node name of a MemoryRetainer to klass
 #define SET_MEMORY_INFO_NAME(Klass)                                            \
-  inline std::string MemoryInfoName() const override { return #Klass; }
+  inline const char* MemoryInfoName() const override { return #Klass; }
 
 // Set the self size of a MemoryRetainer to the stack-allocated size of a
 // certain class
@@ -68,7 +76,7 @@ class CleanupHookCallback;
  *     }
  *
  *     // Or use SET_MEMORY_INFO_NAME(ExampleRetainer)
- *     std::string MemoryInfoName() const override {
+ *     const char* MemoryInfoName() const override {
  *       return "ExampleRetainer";
  *     }
  *
@@ -119,7 +127,7 @@ class MemoryRetainer {
   // where all the edges start from the node of the current retainer,
   // and point to the nodes as specified by tracker->Track* calls.
   virtual void MemoryInfo(MemoryTracker* tracker) const = 0;
-  virtual std::string MemoryInfoName() const = 0;
+  virtual const char* MemoryInfoName() const = 0;
   virtual size_t SelfSize() const = 0;
 
   virtual v8::Local<v8::Object> WrappedObject() const {
@@ -127,8 +135,39 @@ class MemoryRetainer {
   }
 
   virtual bool IsRootNode() const { return false; }
+  virtual bool IsCppgcWrapper() const { return false; }
+  virtual v8::EmbedderGraph::Node::Detachedness GetDetachedness() const {
+    return v8::EmbedderGraph::Node::Detachedness::kUnknown;
+  }
 };
 
+/**
+ * MemoryRetainerTraits allows defining a custom memory info for a
+ * class that can not be modified to implement the MemoryRetainer interface.
+ *
+ * Example:
+ *
+ * template <>
+ * struct MemoryRetainerTraits<ExampleRetainer> {
+ *   static void MemoryInfo(MemoryTracker* tracker,
+ *                         const ExampleRetainer& value) {
+ *     tracker->TrackField("another_retainer", value.another_retainer_);
+ *   }
+ *   static const char* MemoryInfoName(const ExampleRetainer& value) {
+ *     return "ExampleRetainer";
+ *   }
+ *   static size_t SelfSize(const ExampleRetainer& value) {
+ *     return sizeof(value);
+ *   }
+ * };
+ *
+ * This creates the following graph:
+ *   Node / ExampleRetainer
+ *    |> another_retainer :: Node / AnotherRetainerClass
+ */
+template <typename T, typename = void>
+struct MemoryRetainerTraits {};
+
 class MemoryTracker {
  public:
   // Used to specify node name and size explicitly
@@ -228,13 +267,11 @@ class MemoryTracker {
   inline void TrackInlineField(const char* edge_name,
                                const uv_async_t& value,
                                const char* node_name = nullptr);
-  template <class NativeT, class V8T>
-  inline void TrackField(const char* edge_name,
-                         const AliasedBufferBase<NativeT, V8T>& value,
-                         const char* node_name = nullptr);
 
   // Put a memory container into the graph, create an edge from
   // the current node if there is one on the stack.
+  inline void Track(const CppgcMixin* retainer,
+                    const char* edge_name = nullptr);
   inline void Track(const MemoryRetainer* retainer,
                     const char* edge_name = nullptr);
 
@@ -249,6 +286,13 @@ class MemoryTracker {
   inline void TrackInlineField(const MemoryRetainer* retainer,
                                const char* edge_name = nullptr);
 
+  // MemoryRetainerTraits implementation helpers.
+  template <typename T>
+  inline void TraitTrack(const T& retainer, const char* edge_name = nullptr);
+  template <typename T>
+  inline void TraitTrackInline(const T& retainer,
+                               const char* edge_name = nullptr);
+
   inline v8::EmbedderGraph* graph() { return graph_; }
   inline v8::Isolate* isolate() { return isolate_; }
 
@@ -260,9 +304,14 @@ class MemoryTracker {
   typedef std::unordered_map<const MemoryRetainer*, MemoryRetainerNode*>
       NodeMap;
 
-  inline MemoryRetainerNode* CurrentNode() const;
+  inline void AdjustCurrentNodeSize(int diff);
+  inline v8::EmbedderGraph::Node* CurrentNode() const;
+  inline MemoryRetainerNode* AddNode(const CppgcMixin* retainer,
+                                     const char* edge_name = nullptr);
   inline MemoryRetainerNode* AddNode(const MemoryRetainer* retainer,
                                      const char* edge_name = nullptr);
+  inline MemoryRetainerNode* PushNode(const CppgcMixin* retainer,
+                                      const char* edge_name = nullptr);
   inline MemoryRetainerNode* PushNode(const MemoryRetainer* retainer,
                                       const char* edge_name = nullptr);
   inline MemoryRetainerNode* AddNode(const char* node_name,