Struct Raw 

pub struct Raw<S: Storage + 'static> {
    inner: S,
    writable: bool,
    size: AtomicU64,
    resize_lock: Mutex<u64>,
}

Wraps a storage object without any translation.

Fields

inner: S

Wrapped storage object.

writable: bool

Whether this image may be modified.

size: AtomicU64

Disk size, which is the file size when this object was created.

Copy of the value in resize_lock, for lock-free reading. Must only be changed via Raw::set_size().

resize_lock: Mutex<u64>

Disk size, for resize operations.

Every resize path (growing and shrinking) must hold this lock throughout, and change the size only via Raw::set_size(). This serializes resizes, so a resize to a smaller size cannot overtake one to a larger size and shrink the storage below the image size.

Implementations

impl<S: Storage + 'static> Raw<S>

pub fn builder(image: S) -> RawOpenBuilder<S>

Create a new FormatDriverBuilder instance for the given image.

pub fn builder_path<P: AsRef<Path>>(image_path: P) -> RawOpenBuilder<S>

Create a new FormatDriverBuilder instance for an image under the given path.

pub fn create_builder(image: S) -> RawCreateBuilder<S>

Create a new FormatCreateBuilder instance for the given file.

pub async fn open_image(inner: S, writable: bool) -> Result<Self>

Wrap inner, allowing it to be used as a disk image in raw format.

pub async fn open_path<P: AsRef<Path>>(path: P, writable: bool) -> Result<Self>

Open the given path as a storage object, and wrap it in Raw.

pub fn open_image_sync(inner: S, writable: bool) -> Result<Self>

Wrap inner, allowing it to be used as a disk image in raw format.

pub fn open_path_sync<P: AsRef<Path>>(path: P, writable: bool) -> Result<Self>

Synchronous wrapper around Raw::open_path().

fn set_size(&self, size_guard: &mut MutexGuard<'_, u64>, new_size: u64)

Set the disk size.

Requires the guard of resize_lock, which must be held throughout the whole resize operation.

Trait Implementations

impl<S: Debug + Storage + 'static> Debug for Raw<S>

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

Formats the value using the given formatter.

impl<S: Storage + 'static> Display for Raw<S>

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

Formats the value using the given formatter.

impl<S: Storage + 'static> FormatDriverInstance for Raw<S>

type Storage = S

Type of storage used.

fn format(&self) -> Format

Return which format this is.

unsafe fn probe<'life0, 'async_trait>( _storage: &'life0 S, ) -> Pin<Box<dyn Future<Output = Result<bool>> + 'async_trait>>

where Self: Sized + 'async_trait, 'life0: 'async_trait,

Check whether storage has this format.

fn size(&self) -> u64

Size of the disk represented by this image.

fn zero_granularity(&self) -> Option<u64>

Granularity on which blocks can be marked as zero.

fn collect_storage_dependencies(&self) -> Vec<&S>

Recursively collect all storage objects associated with this image.

fn writable(&self) -> bool

Return whether this image may be modified.

fn get_mapping<'a, 'async_trait>( &'a self, offset: u64, max_length: u64, ) -> Pin<Box<dyn Future<Output = Result<(ShallowMapping<'a, S>, u64)>> + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Return the mapping at offset.

fn ensure_data_mapping<'a, 'async_trait>( &'a self, offset: u64, length: u64, _overwrite: bool, ) -> Pin<Box<dyn Future<Output = Result<(&'a S, u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Ensure that offset is directly mapped to some storage object, up to a length of length.

fn ensure_zero_mapping<'life0, 'async_trait>( &'life0 self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ensure that the given range is efficiently mapped as zeroes.

unsafe fn discard_to_zero_unsafe<'life0, 'async_trait>( &'life0 self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range, ensure it is read back as zeroes.

unsafe fn discard_to_any_unsafe<'life0, 'async_trait>( &'life0 self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range.

unsafe fn discard_to_backing_unsafe<'life0, 'async_trait>( &'life0 self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range, such that the backing image becomes visible.

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flush internal buffers.

fn sync<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sync data already written to the storage hardware.

unsafe fn invalidate_cache<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Drop internal buffers.

fn resize_grow<'life0, 'async_trait>( &'life0 self, new_size: u64, format_prealloc_mode: PreallocateMode, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Resize to the given size, which must be greater than the current size.

fn resize_shrink<'life0, 'async_trait>( &'life0 mut self, new_size: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Truncate to the given size, which must be smaller than the current size.

fn prepare_data_mapping<'a, 'async_trait>( &'a self, offset: u64, length: u64, overwrite: bool, ) -> Pin<Box<dyn Future<Output = Result<PreparedDataMapping<'a, Self::Storage>>> + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Prepare a raw data mapping at offset.

fn commit_data_mapping<'life0, 'life1, 'async_trait>( &'life0 self, mapping: PreparedDataMapping<'life1, Self::Storage>, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Make a mapping prepared by FormatDriverInstance::prepare_data_mapping() visible.

fn discard_to_zero<'life0, 'async_trait>( &'life0 mut self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range, ensure it is read back as zeroes.

fn discard_to_any<'life0, 'async_trait>( &'life0 mut self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range.

fn discard_to_backing<'life0, 'async_trait>( &'life0 mut self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<(u64, u64)>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Discard the given range, such that the backing image becomes visible.

fn readv_special<'life0, 'life1, 'async_trait>( &'life0 self, _bufv: IoVectorMut<'life1>, _offset: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read data from a ShallowMapping::Special area.

fn try_readv_special<'a, 'life0, 'async_trait>( &'life0 self, bufv: IoVectorMut<'a>, offset: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<(IoVectorMut<'a>, u64)>>> + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Read data from a ShallowMapping::Special area, returning the unhandled tail.