@encharm/cws 4.5.1 → 4.5.2

package/src/headers/24/node_locks.h

@@ -0,0 +1,180 @@
+#ifndef SRC_NODE_LOCKS_H_
+#define SRC_NODE_LOCKS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <deque>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "base_object.h"
+#include "env.h"
+#include "node_mutex.h"
+#include "v8.h"
+
+namespace node::worker::locks {
+
+class Lock final {
+ public:
+  enum class Mode { Shared, Exclusive };
+
+  Lock(Environment* env,
+       const std::u16string& name,
+       Mode mode,
+       const std::string& client_id,
+       v8::Local<v8::Promise::Resolver> waiting,
+       v8::Local<v8::Promise::Resolver> released);
+  ~Lock() = default;
+
+  Lock(const Lock&) = delete;
+  Lock& operator=(const Lock&) = delete;
+
+  // Resource name for this lock as DOMString
+  const std::u16string& name() const { return name_; }
+  // Lock mode (shared or exclusive).
+  Mode mode() const { return mode_; }
+  // Client identifier string.
+  const std::string& client_id() const { return client_id_; }
+  // Environment that owns this lock.
+  Environment* env() const { return env_; }
+
+  // Returns true if this lock was stolen by another request.
+  bool is_stolen() const { return stolen_; }
+  // Marks this lock as stolen.
+  void mark_stolen() { stolen_ = true; }
+
+  // Promise that resolves when the user callback completes.
+  v8::Local<v8::Promise::Resolver> waiting_promise() {
+    return waiting_promise_.Get(env_->isolate());
+  }
+  // Promise that resolves when the lock is finally released.
+  v8::Local<v8::Promise::Resolver> released_promise() {
+    return released_promise_.Get(env_->isolate());
+  }
+
+ private:
+  Environment* env_;
+  std::u16string name_;
+  Mode mode_;
+  std::string client_id_;
+  bool stolen_ = false;
+  v8::Global<v8::Promise::Resolver> waiting_promise_;
+  v8::Global<v8::Promise::Resolver> released_promise_;
+};
+
+class LockHolder final : public BaseObject {
+ public:
+  LockHolder(Environment* env,
+             v8::Local<v8::Object> obj,
+             std::shared_ptr<Lock> lock)
+      : BaseObject(env, obj), lock_(std::move(lock)) {
+    MakeWeak();
+  }
+
+  ~LockHolder() = default;
+
+  LockHolder(const LockHolder&) = delete;
+  LockHolder& operator=(const LockHolder&) = delete;
+
+  std::shared_ptr<Lock> lock() const { return lock_; }
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(LockHolder)
+  SET_SELF_SIZE(LockHolder)
+
+  static BaseObjectPtr<LockHolder> Create(Environment* env,
+                                          std::shared_ptr<Lock> lock);
+
+ private:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  std::shared_ptr<Lock> lock_;
+};
+
+class LockRequest final {
+ public:
+  LockRequest(Environment* env,
+              v8::Local<v8::Promise::Resolver> waiting,
+              v8::Local<v8::Promise::Resolver> released,
+              v8::Local<v8::Function> callback,
+              const std::u16string& name,
+              Lock::Mode mode,
+              const std::string& client_id,
+              bool steal,
+              bool if_available);
+  ~LockRequest() = default;
+
+  LockRequest(const LockRequest&) = delete;
+  LockRequest& operator=(const LockRequest&) = delete;
+
+  const std::u16string& name() const { return name_; }
+  Lock::Mode mode() const { return mode_; }
+  const std::string& client_id() const { return client_id_; }
+  bool steal() const { return steal_; }
+  // Returns true if this is an ifAvailable request.
+  bool if_available() const { return if_available_; }
+  Environment* env() const { return env_; }
+
+  v8::Local<v8::Promise::Resolver> waiting_promise() {
+    return waiting_promise_.Get(env_->isolate());
+  }
+  v8::Local<v8::Promise::Resolver> released_promise() {
+    return released_promise_.Get(env_->isolate());
+  }
+  v8::Local<v8::Function> callback() { return callback_.Get(env_->isolate()); }
+
+ private:
+  Environment* env_;
+  std::u16string name_;
+  Lock::Mode mode_;
+  std::string client_id_;
+  bool steal_;
+  bool if_available_;
+  v8::Global<v8::Promise::Resolver> waiting_promise_;
+  v8::Global<v8::Promise::Resolver> released_promise_;
+  v8::Global<v8::Function> callback_;
+};
+
+class LockManager final {
+ public:
+  static void Request(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Query(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void ProcessQueue(Environment* env);
+  void CleanupEnvironment(Environment* env);
+
+  static void OnEnvironmentCleanup(void* arg);
+  static LockManager* GetCurrent() { return &current_; }
+  void ReleaseLockAndProcessQueue(Environment* env,
+                                  std::shared_ptr<Lock> lock,
+                                  v8::Local<v8::Value> result,
+                                  bool was_rejected = false);
+
+ private:
+  LockManager() = default;
+  ~LockManager() = default;
+
+  LockManager(const LockManager&) = delete;
+  LockManager& operator=(const LockManager&) = delete;
+
+  bool IsGrantable(const LockRequest* req) const;
+  void CleanupStolenLocks(Environment* env);
+  void ReleaseLock(Lock* lock);
+  void WakeEnvironment(Environment* env);
+
+  static LockManager current_;
+
+  mutable Mutex mutex_;
+  // All entries for a given Environment* are purged in CleanupEnvironment().
+  std::unordered_map<std::u16string, std::deque<std::shared_ptr<Lock>>>
+      held_locks_;
+  std::deque<std::unique_ptr<LockRequest>> pending_queue_;
+  std::unordered_set<Environment*> registered_envs_;
+};
+
+}  // namespace node::worker::locks
+
+#endif  // NODE_WANT_INTERNALS
+#endif  // SRC_NODE_LOCKS_H_

package/src/headers/24/node_main_instance.h

@@ -0,0 +1,67 @@
+#ifndef SRC_NODE_MAIN_INSTANCE_H_
+#define SRC_NODE_MAIN_INSTANCE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>
+#include <memory>
+
+#include "node.h"
+#include "node_exit_code.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+
+class ExternalReferenceRegistry;
+struct EnvSerializeInfo;
+struct SnapshotData;
+
+// TODO(joyeecheung): align this with the Worker/WorkerThreadData class.
+// We may be able to create an abstract class to reuse some of the routines.
+class NodeMainInstance {
+ public:
+  // Create a main instance that owns the isolate
+  NodeMainInstance(const SnapshotData* snapshot_data,
+                   uv_loop_t* event_loop,
+                   MultiIsolatePlatform* platform,
+                   const std::vector<std::string>& args,
+                   const std::vector<std::string>& exec_args);
+  ~NodeMainInstance();
+
+  // Start running the Node.js instances, return the exit code when finished.
+  ExitCode Run();
+  void Run(ExitCode* exit_code, Environment* env);
+
+  IsolateData* isolate_data() { return isolate_data_.get(); }
+
+  DeleteFnPtr<Environment, FreeEnvironment> CreateMainEnvironment(
+      ExitCode* exit_code);
+
+  NodeMainInstance(const NodeMainInstance&) = delete;
+  NodeMainInstance& operator=(const NodeMainInstance&) = delete;
+  NodeMainInstance(NodeMainInstance&&) = delete;
+  NodeMainInstance& operator=(NodeMainInstance&&) = delete;
+
+ private:
+  NodeMainInstance(v8::Isolate* isolate,
+                   uv_loop_t* event_loop,
+                   MultiIsolatePlatform* platform,
+                   const std::vector<std::string>& args,
+                   const std::vector<std::string>& exec_args);
+
+  std::vector<std::string> args_;
+  std::vector<std::string> exec_args_;
+  std::unique_ptr<ArrayBufferAllocator> array_buffer_allocator_;
+  v8::Isolate* isolate_;
+  MultiIsolatePlatform* platform_;
+  std::unique_ptr<IsolateData> isolate_data_;
+  std::unique_ptr<v8::Isolate::CreateParams> isolate_params_;
+  const SnapshotData* snapshot_data_ = nullptr;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_MAIN_INSTANCE_H_

package/src/headers/24/node_mem-inl.h

@@ -0,0 +1,112 @@
+#ifndef SRC_NODE_MEM_INL_H_
+#define SRC_NODE_MEM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_mem.h"
+#include "node_internals.h"
+
+namespace node {
+namespace mem {
+
+template <typename Class, typename AllocatorStruct>
+AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() {
+  return AllocatorStruct {
+    static_cast<void*>(static_cast<Class*>(this)),
+    MallocImpl,
+    FreeImpl,
+    CallocImpl,
+    ReallocImpl
+  };
+}
+
+template <typename Class, typename T>
+void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
+                                             size_t size,
+                                             void* user_data) {
+  Class* manager = static_cast<Class*>(user_data);
+
+  size_t previous_size = 0;
+  char* original_ptr = nullptr;
+
+  // We prepend each allocated buffer with a size_t containing the full
+  // size of the allocation.
+  if (size > 0) size += sizeof(size_t);
+
+  if (ptr != nullptr) {
+    // We are free()ing or re-allocating.
+    original_ptr = static_cast<char*>(ptr) - sizeof(size_t);
+    previous_size = *reinterpret_cast<size_t*>(original_ptr);
+    // This means we called StopTracking() on this pointer before.
+    if (previous_size == 0) {
+      // Fall back to the standard Realloc() function.
+      char* ret = UncheckedRealloc(original_ptr, size);
+      if (ret != nullptr)
+        ret += sizeof(size_t);
+      return ret;
+    }
+  }
+
+  manager->CheckAllocatedSize(previous_size);
+
+  char* mem = UncheckedRealloc(original_ptr, size);
+
+  if (mem != nullptr) {
+    // Adjust the memory info counter.
+    // TODO(addaleax): Avoid the double bookkeeping we do with
+    // current_nghttp2_memory_ + ExternalMemoryAccounter
+    // and provide versions of our memory allocation utilities that take an
+    // Environment*/Isolate* parameter and call the V8 method transparently.
+    const int64_t new_size = size - previous_size;
+    manager->IncreaseAllocatedSize(new_size);
+    manager->env()->external_memory_accounter()->Increase(
+        manager->env()->isolate(), new_size);
+    *reinterpret_cast<size_t*>(mem) = size;
+    mem += sizeof(size_t);
+  } else if (size == 0) {
+    manager->DecreaseAllocatedSize(previous_size);
+    manager->env()->external_memory_accounter()->Decrease(
+        manager->env()->isolate(), previous_size);
+  }
+  return mem;
+}
+
+template <typename Class, typename T>
+void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) {
+  return ReallocImpl(nullptr, size, user_data);
+}
+
+template <typename Class, typename T>
+void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) {
+  if (ptr == nullptr) return;
+  CHECK_NULL(ReallocImpl(ptr, 0, user_data));
+}
+
+template <typename Class, typename T>
+void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb,
+                                            size_t size,
+                                            void* user_data) {
+  size_t real_size = MultiplyWithOverflowCheck(nmemb, size);
+  void* mem = MallocImpl(real_size, user_data);
+  if (mem != nullptr)
+    memset(mem, 0, real_size);
+  return mem;
+}
+
+template <typename Class, typename T>
+void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
+  size_t* original_ptr = reinterpret_cast<size_t*>(
+      static_cast<char*>(ptr) - sizeof(size_t));
+  Class* manager = static_cast<Class*>(this);
+  manager->DecreaseAllocatedSize(*original_ptr);
+  manager->env()->external_memory_accounter()->Decrease(
+      manager->env()->isolate(), *original_ptr);
+  *original_ptr = 0;
+}
+
+}  // namespace mem
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_MEM_INL_H_

package/src/headers/24/node_mem.h

@@ -0,0 +1,45 @@
+#ifndef SRC_NODE_MEM_H_
+#define SRC_NODE_MEM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cstddef>
+
+namespace node {
+namespace mem {
+
+// nghttp2 allows custom allocators that
+// follow exactly the same structure and behavior, but
+// use different struct names. To allow for code re-use,
+// the NgLibMemoryManager template class can be used for both.
+
+struct NgLibMemoryManagerBase {
+  virtual void StopTrackingMemory(void* ptr) = 0;
+};
+
+template <typename Class, typename AllocatorStructName>
+class NgLibMemoryManager : public NgLibMemoryManagerBase {
+ public:
+  // Class needs to provide these methods:
+  // void CheckAllocatedSize(size_t previous_size) const;
+  // void IncreaseAllocatedSize(size_t size);
+  // void DecreaseAllocatedSize(size_t size);
+  // Environment* env() const;
+
+  AllocatorStructName MakeAllocator();
+
+  void StopTrackingMemory(void* ptr) override;
+
+ private:
+  static void* ReallocImpl(void* ptr, size_t size, void* user_data);
+  static void* MallocImpl(size_t size, void* user_data);
+  static void FreeImpl(void* ptr, void* user_data);
+  static void* CallocImpl(size_t nmemb, size_t size, void* user_data);
+};
+
+}  // namespace mem
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_MEM_H_