Struct AlignedBuffer 

#[repr(C, align(8))]
pub struct AlignedBuffer<T, const SIZE: usize>
where
    T: ValueType,
{ /* private fields */ }

A highly optimized, aligned buffer for system call operations

This buffer provides memory-aligned storage with several key features:

• Guaranteed 8-byte alignment required by various system calls
• Zero-cost abstraction for working with raw memory
• Support for both i8 and u8 types (equivalent for byte operations)
• Safe access methods with proper bounds checking
• Lazy initialisation to avoid unnecessary memory writes

Type Parameters

• T: The element type (i8 or u8)
• SIZE: The fixed capacity of the buffer

Safety

The buffer uses MaybeUninit internally, so users must ensure proper initialisation before accessing the contents. All unsafe methods document their safety requirements.

Examples

use fdf::AlignedBuffer;

// Create a new aligned buffer
// Purposely set a non-aligned amount to show alignment is forced.
let mut buffer = AlignedBuffer::<u8, 1026>::new(); //You should really use 1024 here.

// Initialise the buffer with data
let data = b"Hello, World!";
unsafe {
    // Copy data into the buffer
    core::ptr::copy_nonoverlapping(
        data.as_ptr(),
        buffer.as_mut_ptr(),
        data.len()
    );
     
    // Access the initialised data
    let slice = buffer.get_unchecked(0..data.len());
    assert_eq!(slice, data);
     
    // Modify the buffer contents
    let mut_slice = buffer.get_unchecked_mut(0..data.len());
    mut_slice[0] = b'h'; // Change 'H' to 'h'
    assert_eq!(&mut_slice[0..5], b"hello");
}

// The buffer maintains proper alignment for syscalls
//Protip: NEVER cast a ptr to a usize unless you're extremely sure of what you're doing!
assert!((buffer.as_ptr() as usize).is_multiple_of(8),"We expect the buffer to be aligned to 8 bytes")

Implementations

impl<T, const SIZE: usize> AlignedBuffer<T, SIZE>

where T: ValueType,

pub const fn new() -> Self

pub const fn as_mut_ptr(&mut self) -> *mut T

pub const fn as_ptr(&self) -> *const T

pub const unsafe fn as_slice(&self) -> &[T]

Safety

The buffer must be initialised before calling this

pub const unsafe fn as_mut_slice(&mut self) -> &mut [T]

Safety

The buffer must be initialised before calling this

pub unsafe fn getdents(&mut self, fd: i32) -> i64

Executes the getdents64 system call using inline assembly

This method bypasses libc to directly invoke the getdents64 system call, which is necessary to avoid certain libc quirks and limitations.

Safety

This method uses inline assembly and directly interacts with the kernel. The caller must ensure:

• The file descriptor is valid and open for reading
• The buffer is properly aligned and sized
• Proper error handling is implemented

Platform Specificity

This implementation is specific to Linux on supported architectures (currently x86 and aarch64) Otherwise backing up to libc

pub unsafe fn get_unchecked<R>(&self, range: R) -> &R::Output

where R: SliceIndex<[T]>,

Returns a reference to a subslice without doing bounds checking

Safety

The caller must ensure the range is within the initialised portion of the buffer. Accessing out-of-bounds or uninitialised memory is undefined behavior.

pub unsafe fn get_unchecked_mut<R>(&mut self, range: R) -> &mut R::Output

where R: SliceIndex<[T]>,

Safety

The range must be within initialised portion of the buffer

Trait Implementations

impl<T, const SIZE: usize> Debug for AlignedBuffer<T, SIZE>

where T: ValueType + Debug,

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

Formats the value using the given formatter.

impl<T, const SIZE: usize, Idx> Index<Idx> for AlignedBuffer<T, SIZE>

where T: ValueType, Idx: SliceIndex<[T]>,

type Output = <Idx as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const SIZE: usize, Idx> IndexMut<Idx> for AlignedBuffer<T, SIZE>

where T: ValueType, Idx: SliceIndex<[T]>,

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.