@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/ffi/fast.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "ffi.h"
+#include "v8-fast-api-calls.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace node::ffi {
+
+struct FFIFunction;
+
+enum class FastFFIType : uint8_t {
+  kVoid,
+  kInt8,
+  kUint8,
+  kInt16,
+  kUint16,
+  kInt32,
+  kUint32,
+  kInt64,
+  kUint64,
+  kFloat32,
+  kFloat64,
+  kPointer,
+  kBuffer,
+};
+
+struct FastFFITrampoline {
+  void* code = nullptr;
+  size_t size = 0;
+};
+
+struct FastFFITrampolineConfig {
+  void* target;
+  const bool* closed;
+  v8::Isolate* isolate;
+};
+
+struct FastFFIMetadata {
+  FastFFIMetadata() = default;
+  ~FastFFIMetadata();
+
+  FastFFIMetadata(const FastFFIMetadata&) = delete;
+  FastFFIMetadata& operator=(const FastFFIMetadata&) = delete;
+
+  FastFFITrampoline trampoline;
+  std::vector<v8::CTypeInfo> arg_info;
+  std::unique_ptr<v8::CFunctionInfo> c_function_info;
+  v8::CFunction c_function;
+  bool guards_library = false;
+};
+
+// Public detection queries.
+
+// Returns true if the fast-call path is available at all on this process
+// (platform stub emitter exists + JIT memory self-test passed). Independent
+// of any particular signature — if this returns false, no signature can
+// use the fast-call path.
+bool IsFastCallSupported();
+bool IsFastLibraryGuardSupported();
+
+bool SignatureNeedsRawPointerConversions(const FFIFunction& fn);
+bool SignatureNeedsFastIntegerValidation(const FFIFunction& fn);
+bool IsPointerTypeName(const std::string& name);
+bool SignatureNeedsFastBufferInvoke(const FFIFunction& fn);
+std::shared_ptr<FFIFunction> CloneWithRawPointerArgNames(
+    const std::shared_ptr<FFIFunction>& fn);
+std::shared_ptr<FFIFunction> CloneWithFastBufferArgNames(
+    const std::shared_ptr<FFIFunction>& fn);
+std::unique_ptr<FastFFIMetadata> CreateFastFFIMetadata(const FFIFunction& fn,
+                                                       const bool* closed,
+                                                       v8::Isolate* isolate);
+
+}  // namespace node::ffi
+
+extern "C" {
+uintptr_t node_ffi_fast_buffer_data(v8::Local<v8::Value> value,
+                                    v8::FastApiCallbackOptions* options,
+                                    uint32_t index);
+void node_ffi_fast_library_closed(v8::Isolate* isolate);
+bool node_ffi_create_fast_trampoline(
+    const node::ffi::FastFFITrampolineConfig& config,
+    const node::ffi::FastFFIType* args,
+    size_t argc,
+    node::ffi::FastFFIType result,
+    node::ffi::FastFFITrampoline* out);
+void node_ffi_free_fast_trampoline(node::ffi::FastFFITrampoline* trampoline);
+}
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/26/ffi/jit_memory.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node::ffi {
+
+// Returns true if executable memory allocation (mmap + mprotect to RX) works
+// on this process. Runs a one-time self-test that allocates a tiny stub,
+// writes a ret-style instruction, and transitions it to RX. The page is not
+// executed: a successful RX transition is the support signal, and executing a
+// freshly generated probe could crash the process on systems that block it.
+//
+// Catches:
+//   - macOS MAP_JIT entitlement missing
+//   - Hardened-runtime restrictions
+//   - SELinux execmem denial
+//   - Other OS-level restrictions on executable memory
+//
+// The self-test runs exactly once (std::call_once) and the result is cached
+// process-wide. Subsequent calls return the cached value without re-running
+// the test.
+bool IsJitMemorySupported();
+
+}  // namespace node::ffi
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/26/ffi/types.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "ffi.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace node::ffi {
+
+struct FFIFunction;
+
+bool ThrowIfContainsNullBytes(Environment* env,
+                              const Utf8Value& value,
+                              std::string_view label);
+
+struct FunctionSignature {
+  ffi_type* return_type;
+  std::vector<ffi_type*> args;
+  std::string return_type_name;
+  std::vector<std::string> arg_type_names;
+};
+v8::Maybe<FunctionSignature> ParseFunctionSignature(
+    Environment* env, std::string_view name, v8::Local<v8::Object> signature);
+
+v8::Maybe<ffi_type*> ToFFIType(Environment* env, std::string_view type_str);
+
+enum class FFIArgumentCategory {
+  Regular,
+  String,
+};
+v8::Maybe<FFIArgumentCategory> ToFFIArgument(Environment* env,
+                                             unsigned int index,
+                                             ffi_type* type,
+                                             v8::Local<v8::Value> arg,
+                                             void* ret);
+
+v8::Local<v8::Value> ToJSArgument(v8::Isolate* isolate,
+                                  ffi_type* type,
+                                  void* data);
+
+bool ToJSReturnValue(Environment* env,
+                     const v8::FunctionCallbackInfo<v8::Value>& args,
+                     ffi_type* type,
+                     void* result);
+
+bool ToFFIReturnValue(v8::Local<v8::Value> result, ffi_type* type, void* ret);
+
+bool SignaturesMatch(const FFIFunction& fn,
+                     ffi_type* return_type,
+                     const std::vector<ffi_type*>& args);
+
+// Returns true if `fn` can be invoked via the V8 fast-call path. On
+// false, `*out_reason` is set to a static string describing why
+// (never null after this returns; callers may pass nullptr to ignore).
+//
+// Eligibility checks: every arg type and the return type are
+// numeric-or-pointer, no `function`-typed args/return, arg count
+// within V8 fast-call cap (8), and register-passed arg counts within
+// per-ABI limits. Trampoline emitters currently exist for AArch64
+// (≤ 7 GP + ≤ 8 FP), x86_64 SysV (≤ 6 GP + ≤ 8 FP; buffer args cap GP at 5 and
+// cannot coexist with FP args), Win64 x64 (≤ 3 register-only scalar args), and
+// PPC64LE ELFv2, LoongArch64, and RISC-V 64 (≤ 7 GP + ≤ 8 FP scalar args, no
+// narrow returns), and s390x (≤ 4 GP + ≤ 4 FP scalar args, no narrow returns).
+// Platforms without an emitter are reported ineligible so the caller falls back
+// to libffi.
+bool IsFastCallEligible(const FFIFunction& fn, const char** out_reason);
+
+// True if the FFI type can be read from / written to a raw byte buffer
+// without needing V8 operations (conversion, allocation, etc.).
+bool IsSBEligibleFFIType(ffi_type* type);
+
+// True if the signature's return type and all argument types are SB-eligible.
+bool IsSBEligibleSignature(const FFIFunction& fn);
+
+// True if any argument is pointer-typed. For these, the JS wrapper must
+// do a runtime type check to decide fast vs. slow path per call.
+bool SignatureHasPointerArgs(const FFIFunction& fn);
+
+// Read a value of the given FFI type from buffer at the given byte offset
+// into the output pointer (sized as uint64_t to hold any numeric type).
+void ReadFFIArgFromBuffer(ffi_type* type,
+                          const uint8_t* buffer,
+                          size_t offset,
+                          void* out);
+
+// Write a return value of the given FFI type from the ffi_call result
+// into the buffer at the given byte offset.
+void WriteFFIReturnToBuffer(ffi_type* type,
+                            const void* result,
+                            uint8_t* buffer,
+                            size_t offset);
+
+}  // namespace node::ffi
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/26/handle_wrap.h

@@ -0,0 +1,123 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_HANDLE_WRAP_H_
+#define SRC_HANDLE_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "async_wrap.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+class ExternalReferenceRegistry;
+
+// Rules:
+//
+// - Do not throw from handle methods. Set errno.
+//
+// - MakeCallback may only be made directly off the event loop.
+//   That is there can be no JavaScript stack frames underneath it.
+//   (Is there any way to assert that?)
+//
+// - No use of v8::WeakReferenceCallback. The close callback signifies that
+//   we're done with a handle - external resources can be freed.
+//
+// - Reusable?
+//
+// - The uv_close_cb is used to free the c++ object. The close callback
+//   is not made into javascript land.
+//
+// - uv_ref, uv_unref counts are managed at this layer to avoid needless
+//   js/c++ boundary crossing. At the javascript layer that should all be
+//   taken care of.
+
+class HandleWrap : public AsyncWrap {
+ public:
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static inline bool IsAlive(const HandleWrap* wrap) {
+    return wrap != nullptr &&
+        wrap->IsDoneInitializing() &&
+        wrap->state_ != kClosed;
+  }
+
+  static inline bool HasRef(const HandleWrap* wrap) {
+    return IsAlive(wrap) && uv_has_ref(wrap->GetHandle());
+  }
+
+  inline uv_handle_t* GetHandle() const { return handle_; }
+
+  virtual void Close(
+      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
+
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      IsolateData* isolate_data);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ protected:
+  HandleWrap(Environment* env,
+             v8::Local<v8::Object> object,
+             uv_handle_t* handle,
+             AsyncWrap::ProviderType provider);
+  virtual void OnClose() {}
+  void OnGCCollect() final;
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
+
+  void MarkAsInitialized();
+  void MarkAsUninitialized();
+
+  inline bool IsHandleClosing() const {
+    return state_ == kClosing || state_ == kClosed;
+  }
+
+  static void OnClose(uv_handle_t* handle);
+  enum { kInitialized, kClosing, kClosed } state_;
+
+ private:
+  friend class Environment;
+  friend void GetActiveHandles(const v8::FunctionCallbackInfo<v8::Value>&);
+
+  // handle_wrap_queue_ needs to be at a fixed offset from the start of the
+  // class because it is used by src/node_postmortem_metadata.cc to calculate
+  // offsets and generate debug symbols for HandleWrap, which assumes that the
+  // position of members in memory are predictable. For more information please
+  // refer to `doc/contributing/node-postmortem-support.md`
+  friend int GenDebugSymbols();
+  ListNode<HandleWrap> handle_wrap_queue_;
+  uv_handle_t* const handle_;
+};
+
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HANDLE_WRAP_H_

package/src/headers/26/histogram-inl.h

@@ -0,0 +1,211 @@
+#ifndef SRC_HISTOGRAM_INL_H_
+#define SRC_HISTOGRAM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "histogram.h"
+#include "base_object-inl.h"
+#include "node_internals.h"
+
+namespace node {
+
+void Histogram::UpdateEwma(double value) {
+  // Called inside a write lock. No-op when EWMA is disabled.
+  if (ewma_alpha_ <= 0) return;
+  if (!ewma_initialized_) {
+    ewma_mean_ = value;
+    ewma_variance_ = 0;
+    ewma_initialized_ = true;
+    if (threshold_ > 0) {
+      ewma_error_rate_ = (value > static_cast<double>(threshold_)) ? 1.0 : 0.0;
+    }
+    return;
+  }
+  double diff = value - ewma_mean_;
+  ewma_mean_ += ewma_alpha_ * diff;
+  ewma_variance_ =
+      (1.0 - ewma_alpha_) * (ewma_variance_ + ewma_alpha_ * diff * diff);
+
+  // Binary EWMA for SLO error rate: feed 1 if over threshold, 0 otherwise.
+  if (threshold_ > 0) {
+    double exceeded = (value > static_cast<double>(threshold_)) ? 1.0 : 0.0;
+    ewma_error_rate_ += ewma_alpha_ * (exceeded - ewma_error_rate_);
+  }
+}
+
+void Histogram::Reset() {
+  RwLock::ScopedWriteLock lock(mutex_);
+  hdr_reset(histogram_.get());
+  exceeds_ = 0;
+  prev_ = 0;
+  ewma_mean_ = 0;
+  ewma_variance_ = 0;
+  ewma_error_rate_ = 0;
+  ewma_initialized_ = false;
+}
+
+double Histogram::Add(const Histogram& other) {
+  auto do_add = [&]() {
+    exceeds_ += other.exceeds_;
+    if (other.prev_ > prev_) prev_ = other.prev_;
+    // hdr_add merges all bucket counts and total_count internally.
+    return static_cast<double>(
+        hdr_add(histogram_.get(), other.histogram_.get()));
+  };
+
+  // When adding a histogram to itself, a single write lock suffices.
+  if (this == &other) {
+    RwLock::ScopedWriteLock lock(mutex_);
+    return do_add();
+  }
+
+  // Write-lock this (modified), read-lock other (only read).
+  // Lock in pointer order to prevent deadlock.
+  if (this < &other) {
+    RwLock::ScopedWriteLock lock1(mutex_);
+    RwLock::ScopedReadLock lock2(other.mutex_);
+    return do_add();
+  }
+
+  RwLock::ScopedReadLock lock1(other.mutex_);
+  RwLock::ScopedWriteLock lock2(mutex_);
+  return do_add();
+}
+
+size_t Histogram::Count() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return static_cast<size_t>(histogram_->total_count);
+}
+
+size_t Histogram::Exceeds() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return exceeds_;
+}
+
+int64_t Histogram::Min() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_min(histogram_.get());
+}
+
+int64_t Histogram::Max() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_max(histogram_.get());
+}
+
+double Histogram::Mean() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_mean(histogram_.get());
+}
+
+double Histogram::Stddev() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_stddev(histogram_.get());
+}
+
+double Histogram::EwmaMean() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return ewma_initialized_ ? ewma_mean_ : 0;
+}
+
+double Histogram::EwmaStddev() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return ewma_initialized_ ? std::sqrt(ewma_variance_) : 0;
+}
+
+double Histogram::EwmaErrorRate() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return ewma_initialized_ ? ewma_error_rate_ : 0;
+}
+
+int64_t Histogram::Percentile(double percentile) const {
+  RwLock::ScopedReadLock lock(mutex_);
+  CHECK_GT(percentile, 0);
+  CHECK_LE(percentile, 100);
+  return hdr_value_at_percentile(histogram_.get(), percentile);
+}
+
+template <typename Iterator>
+void Histogram::Percentiles(Iterator&& fn) const {
+  RwLock::ScopedReadLock lock(mutex_);
+  hdr_iter iter;
+  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
+  while (hdr_iter_next(&iter)) {
+    double key = iter.specifics.percentiles.percentile;
+    fn(key, iter.value);
+  }
+}
+
+int64_t Histogram::CountAt(int64_t value) const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_count_at_value(histogram_.get(), value);
+}
+
+bool Histogram::RecordCorrected(int64_t value, int64_t expected_interval) {
+  RwLock::ScopedWriteLock lock(mutex_);
+  bool recorded =
+      hdr_record_corrected_value(histogram_.get(), value, expected_interval);
+  if (!recorded)
+    exceeds_++;
+  else
+    UpdateEwma(static_cast<double>(value));
+  return recorded;
+}
+
+bool Histogram::Record(int64_t value) {
+  RwLock::ScopedWriteLock lock(mutex_);
+  bool recorded = hdr_record_value(histogram_.get(), value);
+  if (!recorded)
+    exceeds_++;
+  else
+    UpdateEwma(static_cast<double>(value));
+  return recorded;
+}
+
+uint64_t Histogram::RecordDelta() {
+  RwLock::ScopedWriteLock lock(mutex_);
+  uint64_t time = uv_hrtime();
+  int64_t delta = 0;
+  if (prev_ > 0) {
+    CHECK_GE(time, prev_);
+    delta = time - prev_;
+    if (!hdr_record_value(histogram_.get(), delta))
+      exceeds_++;
+    else
+      UpdateEwma(static_cast<double>(delta));
+  }
+  prev_ = time;
+  return delta;
+}
+
+size_t Histogram::GetMemorySize() const {
+  RwLock::ScopedReadLock lock(mutex_);
+  return hdr_get_memory_size(histogram_.get());
+}
+
+template <typename Iterator>
+void Histogram::LinearBuckets(int64_t step_size, Iterator&& fn) const {
+  RwLock::ScopedReadLock lock(mutex_);
+  hdr_iter iter;
+  hdr_iter_linear_init(&iter, histogram_.get(), step_size);
+  while (hdr_iter_next(&iter)) {
+    fn(iter.value, iter.specifics.linear.count_added_in_this_iteration_step);
+  }
+}
+
+template <typename Iterator>
+void Histogram::LogBuckets(int64_t first_bucket,
+                           double log_base,
+                           Iterator&& fn) const {
+  RwLock::ScopedReadLock lock(mutex_);
+  hdr_iter iter;
+  hdr_iter_log_init(&iter, histogram_.get(), first_bucket, log_base);
+  while (hdr_iter_next(&iter)) {
+    fn(iter.value, iter.specifics.log.count_added_in_this_iteration_step);
+  }
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_HISTOGRAM_INL_H_