Struct disk::QcowFile

pub struct QcowFile {
    inner: Mutex<QcowFileInner>,
    virtual_size: u64,
}

Represents a qcow2 file. This is a sparse file format maintained by the qemu project. Full documentation of the format can be found in the qemu repository.

Example

    let mut q = QcowFile::from(file, DiskFileParams {
        path,
        is_read_only: false,
        is_sparse_file: false,
        is_overlapped: false,
        is_direct: false,
        lock: true,
        depth: 0,
    }).expect("Can't open qcow file");
    let mut buf = [0u8; 12];
    let mut vslice = VolatileSlice::new(&mut buf);
    q.read_at_volatile(vslice, 10)?;

Fields

inner: Mutex<QcowFileInner>

virtual_size: u64

Implementations

impl QcowFile

pub fn from(file: File, params: DiskFileParams) -> Result<QcowFile, Error>

Creates a QcowFile from file. File must be a valid qcow2 image.

pub fn new( file: File, params: DiskFileParams, virtual_size: u64 ) -> Result<QcowFile, Error>

Creates a new QcowFile at the given path.

pub fn new_from_backing( file: File, params: DiskFileParams, backing_file_name: &str ) -> Result<QcowFile, Error>

Creates a new QcowFile at the given path.

fn new_from_header( file: File, params: DiskFileParams, header: QcowHeader ) -> Result<QcowFile, Error>

pub fn set_backing_file(&mut self, backing: Option<Box<dyn DiskFile>>)

Trait Implementations

impl AsRawDescriptors for QcowFile

fn as_raw_descriptors(&self) -> Vec<RawDescriptor>

Returns the underlying raw descriptors.

impl Debug for QcowFile

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

Formats the value using the given formatter.

impl DiskFile for QcowFile

fn try_clone(&self) -> Result<Box<dyn DiskFile>>

Creates a new DiskFile instance that shares the same underlying disk file image. IO operations to a DiskFile should affect all DiskFile instances with the same underlying disk file image.

impl DiskFlush for QcowFile

fn flush(&self) -> Result<()>

Flush intermediary buffers and/or dirty state to file. fsync not required.

impl DiskGetLen for QcowFile

fn get_len(&self) -> Result<u64>

Get the current length of the disk in bytes.

impl Drop for QcowFile

fn drop(&mut self)

Executes the destructor for this type.

impl FileAllocate for QcowFile

fn allocate(&self, offset: u64, len: u64) -> Result<()>

Allocate storage for the region of the file starting at offset and extending len bytes.

impl FileReadWriteAtVolatile for QcowFile

fn read_at_volatile( &self, slice: VolatileSlice<'_>, offset: u64 ) -> Result<usize>

Reads bytes from this file at offset into the given slice, returning the number of bytes read on success. On Windows file pointer will update with the read, but on Linux the file pointer will not change.

fn write_at_volatile( &self, slice: VolatileSlice<'_>, offset: u64 ) -> Result<usize>

Writes bytes to this file at offset from the given slice, returning the number of bytes written on success. On Windows file pointer will update with the write, but on Linux the file pointer will not change.

fn read_vectored_at_volatile( &self, bufs: &[VolatileSlice<'_>], offset: u64 ) -> Result<usize, Error>

Like read_at_volatile, except it reads to a slice of buffers. Data is copied to fill each buffer in order, with the final buffer written to possibly being only partially filled. This method must behave as a single call to read_at_volatile with the buffers concatenated would. The default implementation calls read_at_volatile with either the first nonempty buffer provided, or returns Ok(0) if none exists. On Windows file pointer will update with the read, but on Linux the file pointer will not change.

fn read_exact_at_volatile( &self, slice: VolatileSlice<'_>, offset: u64 ) -> Result<(), Error>

Reads bytes from this file at offset into the given slice until all bytes in the slice are read, or an error is returned. On Windows file pointer will update with the read, but on Linux the file pointer will not change.

fn write_vectored_at_volatile( &self, bufs: &[VolatileSlice<'_>], offset: u64 ) -> Result<usize, Error>

Like write_at_volatile, except that it writes from a slice of buffers. Data is copied from each buffer in order, with the final buffer read from possibly being only partially consumed. This method must behave as a call to write_at_volatile with the buffers concatenated would. The default implementation calls write_at_volatile with either the first nonempty buffer provided, or returns Ok(0) if none exists. On Windows file pointer will update with the write, but on Linux the file pointer will not change.

fn write_all_at_volatile( &self, slice: VolatileSlice<'_>, offset: u64 ) -> Result<(), Error>

Writes bytes to this file at offset from the given slice until all bytes in the slice are written, or an error is returned. On Windows file pointer will update with the write, but on Linux the file pointer will not change.

impl FileSetLen for QcowFile

fn set_len(&self, _len: u64) -> Result<()>

impl FileSync for QcowFile

fn fsync(&self) -> Result<()>

fn fdatasync(&self) -> Result<()>

impl PunchHole for QcowFile

fn punch_hole(&self, offset: u64, length: u64) -> Result<()>

Replace a range of bytes with a hole.

impl Read for QcowFile

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl Seek for QcowFile

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

🔬This is a nightly-only experimental API. (seek_seek_relative)

Seeks relative to the current position.

impl ToAsyncDisk for QcowFile

fn to_async_disk(self: Box<Self>, ex: &Executor) -> Result<Box<dyn AsyncDisk>>

Convert a boxed self in to a box-wrapped implementaiton of AsyncDisk. Used to convert a standard disk image to an async disk image. This conversion and the inverse are needed so that the Send DiskImage can be given to the block thread where it is converted to a non-Send AsyncDisk. The AsyncDisk can then be converted back and returned to the main device thread if the block device is destroyed or reset.

impl Write for QcowFile

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl WriteZeroesAt for QcowFile

fn write_zeroes_at(&self, offset: u64, length: usize) -> Result<usize>

Write up to length bytes of zeroes starting at offset, returning how many bytes were written.

fn write_zeroes_all_at(&self, offset: u64, length: usize) -> Result<(), Error>

Write zeroes starting at offset until length bytes have been written.