Struct GuardPage 

pub struct GuardPage<I: OsBacked> { /* private fields */ }

Guard-page wrapper.

At construction, inner.protect(...) marks the first and last page_size bytes of the inner region as PROT_NONE. The wrapper then allocates bump-style from the strictly-interior subrange.

Thread safety

Send when I: Send. Sync: NO — the cursor uses UnsafeCell.

Implementations

impl<I: OsBacked> GuardPage<I>

pub fn new(inner: I, page_size: usize) -> Result<Self, AllocError>

Wrap with leading + trailing guard pages of page_size bytes each.

Errors if page_size is zero / not a power of two, if inner.base_ptr() is not page_size-aligned, or if the region is too small.

pub fn inner(&self) -> &I

Borrow the inner allocator.

pub fn page_size(&self) -> usize

Guard page size in bytes.

pub fn allocated(&self) -> usize

Bytes currently allocated from the usable subrange.

Trait Implementations

impl<I: OsBacked> Allocator for GuardPage<I>

fn allocate(&self, layout: NonZeroLayout) -> Result<NonNull<[u8]>, AllocError>

Allocate a block satisfying layout. The returned slice’s length is at least layout.size() but may be larger.

fn capacity_bytes(&self) -> Option<usize>

Total bytes this allocator can issue, if bounded. None for unbounded allocators like System. Used by Watermark to compute thresholds.

fn corruption_events(&self) -> u64

Detected freelist / metadata corruption events observed by this allocator since construction.

fn allocate_zeroed( &self, layout: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Allocate a zero-initialized block.

unsafe fn grow( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Grow an allocation in place if possible, otherwise allocate-copy-free.

unsafe fn shrink( &self, ptr: NonNull<u8>, old: NonZeroLayout, new: NonZeroLayout, ) -> Result<NonNull<[u8]>, AllocError>

Shrink an allocation in place if possible, otherwise allocate-copy-free.

fn reset(&mut self) -> Result<(), AllocError>

Reclaim everything previously allocated. Default impl returns AllocError — only arena-style allocators implement a meaningful reset.

unsafe fn usable_size( &self, _ptr: NonNull<u8>, _layout: NonZeroLayout, ) -> Option<usize>

Usable size of an existing allocation, if the allocator can report it. Defaults to None — implementors that track usable size override.

impl<I: OsBacked> Deallocator for GuardPage<I>

unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: NonZeroLayout)

Release a previously allocated block.

impl<I: OsBacked> FixedRange for GuardPage<I>

fn base(&self) -> NonNull<u8>

Base of the usable subrange (not the inner region).

fn size(&self) -> usize

Usable bytes (inner region minus the two guard pages).

fn commit(&self, offset: usize, len: usize) -> Result<(), AllocError>

Ensure the bytes [offset, offset + len) (relative to base) are backed by committed, writable memory before a consumer writes through them.

fn contains(&self, ptr: NonNull<u8>) -> bool

Whether ptr lies within [base, base + size).

impl<I: OsBacked + Send> Send for GuardPage<I>