Struct PageBytes 

pub struct PageBytes {
    pub hash: CapHash,
    pub bytes: Vec<u8>,
}

One page’s bytes plus its precomputed content hash.

Sharing across DataCap CoW clones is via PageRef (= Arc), which carries its own refcount — PageBytes itself is not refcounted.

Clone and rkyv Deserialize are hand-written to preserve the PAGE_SIZE-alignment invariant of bytes: the recompiler resolves a page’s physical address from its slab pointer and direct-maps it into a ring-3 page table (pt_map_leaf requires a page-aligned PA). The derived Clone / Deserialize would Vec-allocate bytes at alignment 1, so a cloned or wire-decoded page would land mid-page and the recompiler would map the wrong physical frame. Both re-allocate through super::data::alloc_page_aligned_zeroed. (Mirrors the page-alignment discipline the legacy DataContent::Inline kept in its manual Clone.)

Fields

hash: CapHash

bytes: Vec<u8>

Implementations

impl PageBytes

pub fn from_content(content: &[u8]) -> Self

Build a PageBytes from up to PAGE_SIZE content bytes: a PAGE_SIZE-aligned slab (zero-padded tail) plus the precomputed content hash (super::data::page_content_hash). The slab alignment is load-bearing — the recompiler maps the page’s slab directly into a ring-3 page table.

pub fn from_page_copy_unhashed(src: &[u8]) -> Self

Build a PageBytes from up to PAGE_SIZE source bytes without computing the content hash: a PAGE_SIZE-aligned slab (zero-padded tail) carrying a [0u8; 32] sentinel hash.

Used by the x86 recompiler’s ring-0 copy-on-write page-fault handler, which inserts the fresh page straight into a super::data::DataCap overlay. Overlay pages are never hashed before super::data::DataCap::flush (which rebuilds each page via Self::from_content, recomputing the real hash and re-asserting the substitution invariant), so keeping SHA-256 out of the #PF path keeps the per-page CoW gas charge identical between the interpreter and the recompiler. The slab is still PAGE_SIZE-aligned — load-bearing for the direct ring-3 PT map.

Trait Implementations

impl Archive for PageBytes

where CapHash: Archive, Vec<u8>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedPageBytes

The archived representation of this type.

type Resolver = PageBytesResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for PageBytes

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PageBytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: Fallible + ?Sized> Deserialize<PageBytes, D> for ArchivedPageBytes

fn deserialize(&self, _deserializer: &mut D) -> Result<PageBytes, D::Error>

Deserializes using the given deserializer

impl Encode for PageBytes

fn is_ssz_fixed_len() -> bool

true iff this type is fixed-length (no variable-length fields).

fn ssz_fixed_len() -> usize

Number of bytes this type occupies in the fixed-length portion of a container encoding. For variable-length types this returns [BYTES_PER_LENGTH_OFFSET] (i.e. the size of the offset slot).

fn ssz_bytes_len(&self) -> usize

Total size of self when serialized.

fn ssz_append(&self, buf: &mut Vec<u8>)

Append the encoding of self to buf.

fn is_basic_type() -> bool

true for “basic” SSZ types (uintN, bool), which pack adjacent elements into shared 32-byte chunks for merkleization. Composite types (containers, lists, structs) return false (the default).

fn as_ssz_bytes(&self) -> Vec<u8>

Serialize into a fresh Vec<u8> allocated through the global allocator.

impl HashTreeRoot for PageBytes

fn hash_tree_root<D: Digest<OutputSize = U32>>(&self) -> [u8; 32]

Compute the hash tree root using D as the underlying hash.

impl<__S: Fallible + ?Sized> Serialize<__S> for PageBytes

where CapHash: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.