deps/v8/src/base/virtual-address-space.h - main - githubmirror/node

deps/v8/src/base/virtual-address-space.h
195 строк7 KB
Michaël Zasso
deps: update V8 to 14.6.202.33
24 апр 2026, 19:01
24 апр 2026, 19:01f1e0b83
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_BASE_VIRTUAL_ADDRESS_SPACE_H_
#define V8_BASE_VIRTUAL_ADDRESS_SPACE_H_

#include "include/v8-platform.h"
#include "src/base/base-export.h"
#include "src/base/compiler-specific.h"
#include "src/base/platform/memory-protection-key.h"
#include "src/base/platform/mutex.h"
#include "src/base/platform/platform.h"
#include "src/base/region-allocator.h"

namespace v8 {
namespace base {

using Address = uintptr_t;
constexpr Address kNullAddress = 0;

class VirtualAddressSubspace;

/*
 * Common parent class to implement deletion of subspaces.
 */
class VirtualAddressSpaceBase
    : public NON_EXPORTED_BASE(::v8::VirtualAddressSpace) {
 public:
  using VirtualAddressSpace::VirtualAddressSpace;

 private:
  friend VirtualAddressSubspace;
  // Called by a subspace during destruction. Responsible for freeing the
  // address space reservation and any other data associated with the subspace
  // in the parent space.
  virtual void FreeSubspace(VirtualAddressSubspace* subspace) = 0;
};

/*
 * The virtual address space of the current process. Conceptionally, there
 * should only be one such "root" instance. However, in practice there is no
 * issue with having multiple instances as the actual resources are managed by
 * the OS kernel.
 */
class V8_BASE_EXPORT VirtualAddressSpace : public VirtualAddressSpaceBase {
 public:
  VirtualAddressSpace();
  ~VirtualAddressSpace() override = default;

  void SetRandomSeed(int64_t seed) override;

  Address RandomPageAddress() override;

  Address AllocatePages(Address hint, size_t size, size_t alignment,
                        PagePermissions access) override;

  void FreePages(Address address, size_t size) override;

  bool SetPagePermissions(Address address, size_t size,
                          PagePermissions access) override;

  bool AllocateGuardRegion(Address address, size_t size) override;

  void FreeGuardRegion(Address address, size_t size) override;

  Address AllocateSharedPages(Address hint, size_t size,
                              PagePermissions permissions,
                              SharedMemoryHandle handle,
                              uint64_t offset) override;

  void FreeSharedPages(Address address, size_t size) override;

  std::optional<MemoryProtectionKeyId> ActiveMemoryProtectionKey() override;

  bool CanAllocateSubspaces() override;

  std::unique_ptr<v8::VirtualAddressSpace> AllocateSubspace(
      Address hint, size_t size, size_t alignment,
      PagePermissions max_page_permissions,
      std::optional<MemoryProtectionKeyId> key = std::nullopt,
      std::optional<SharedMemoryHandle> handle = std::nullopt) override;

  bool RecommitPages(Address address, size_t size,
                     PagePermissions access) override;

  bool DiscardSystemPages(Address address, size_t size) override;

  bool DecommitPages(Address address, size_t size) override;

  // It's not possible to assign a name to the root virtual address space.
  bool SetName(const std::string& name) override { return false; }

 private:
  void FreeSubspace(VirtualAddressSubspace* subspace) override;
};

/*
 * A subspace of a parent virtual address space. This represents a reserved
 * contiguous region of virtual address space in the current process.
 */
class V8_BASE_EXPORT VirtualAddressSubspace : public VirtualAddressSpaceBase {
 public:
  ~VirtualAddressSubspace() override;

  void SetRandomSeed(int64_t seed) override;

  Address RandomPageAddress() override;

  Address AllocatePages(Address hint, size_t size, size_t alignment,
                        PagePermissions permissions) override;

  void FreePages(Address address, size_t size) override;

  bool SetPagePermissions(Address address, size_t size,
                          PagePermissions permissions) override;

  bool AllocateGuardRegion(Address address, size_t size) override;

  void FreeGuardRegion(Address address, size_t size) override;

  Address AllocateSharedPages(Address hint, size_t size,
                              PagePermissions permissions,
                              SharedMemoryHandle handle,
                              uint64_t offset) override;

  void FreeSharedPages(Address address, size_t size) override;

  std::optional<MemoryProtectionKeyId> ActiveMemoryProtectionKey() override;

  bool CanAllocateSubspaces() override { return true; }

  std::unique_ptr<v8::VirtualAddressSpace> AllocateSubspace(
      Address hint, size_t size, size_t alignment,
      PagePermissions max_page_permissions,
      std::optional<MemoryProtectionKeyId> key,
      std::optional<SharedMemoryHandle> handle) override;

  bool RecommitPages(Address address, size_t size,
                     PagePermissions permissions) override;

  bool DiscardSystemPages(Address address, size_t size) override;

  bool DecommitPages(Address address, size_t size) override;

  bool SetName(const std::string& name) override;

 private:
  // The VirtualAddressSpace class creates instances of this class when
  // allocating sub spaces.
  friend class v8::base::VirtualAddressSpace;

  void FreeSubspace(VirtualAddressSubspace* subspace) override;

  VirtualAddressSubspace(AddressSpaceReservation reservation,
                         VirtualAddressSpaceBase* parent_space,
                         PagePermissions max_page_permissions,
                         std::optional<MemoryProtectionKeyId> key);

  // The address space reservation backing this subspace.
  AddressSpaceReservation reservation_;

  // Mutex guarding the non-threadsafe RegionAllocator and
  // RandomNumberGenerator.
  Mutex mutex_;

  // RegionAllocator to manage the virtual address reservation and divide it
  // into further regions as necessary.
  RegionAllocator region_allocator_;

  // Random number generator for generating random addresses.
  RandomNumberGenerator rng_;

  // Pointer to the parent space. Must be kept alive by the owner of this
  // instance during its lifetime.
  VirtualAddressSpaceBase* parent_space_;

  // Memory protection key for this virtual address subspace.
  // If set, all memory pages allocated in this subspace will use this key.
  //
  // The way this is implemented is that we initially set the key for the
  // entire backing memory and then ensure that we re-set it whenever we
  // replace pages in for example FreePages() and DecommitPages(). This way,
  // all memory pages in this space always have this key set.
  std::optional<MemoryProtectionKeyId> pkey_;

  // The name assigned to this virtual address space. Only used if SetName is
  // called and completes successfully, meaning that the OS supports names for
  // anonymous memory regions.
  std::string name_;
};

}  // namespace base
}  // namespace v8
#endif  // V8_BASE_VIRTUAL_ADDRESS_SPACE_H_