Struct RefTable 

pub(super) struct RefTable {
    cluster: Option<HostCluster>,
    data: Box<[RefTableEntry]>,
    cluster_bits: u32,
    modified: AtomicBool,
}

Refcount table.

Fields

cluster: Option<HostCluster>

First cluster in the image file.

data: Box<[RefTableEntry]>

Table data.

cluster_bits: u32

log2 of the cluster size.

modified: AtomicBool

Whether this table has been modified since it was last written.

Implementations

impl RefTable

pub fn clone_and_grow( &self, header: &Header, at_least_index: usize, ) -> Result<Self>

Create a clone that covers at least at_least_index.

Also ensure that beyond at_least_index, there are enough entries to self-describe the new refcount table (so that it can actually be allocated).

pub fn in_bounds(&self, index: usize) -> bool

Check whether index is in bounds.

pub fn enter_refblock( &mut self, index: usize, rb: &RefBlock, new_allocation: Option<PendingClusters>, ) -> Result<()>

Enter the given refcount block into this refcount table.

If the refblock’s cluster has been newly allocated, new_allocation must be its pending clusters guard, which is disarmed once the refblock is entered.

Trait Implementations

impl Debug for RefTable

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

Formats the value using the given formatter.

impl Table for RefTable

const MAX_ENTRIES: usize = <L1Table as Table>::MAX_ENTRIES

Maximum number of refcount table entries.

Not in QEMU, but makes sense to limit to the same as the L1 table. Note that refcount blocks usually cover more clusters than an L2 table, so this generally allows larger image files than would be necessary for the maximum guest disk size determined by the maximum number of L1 entries.

const NAME: &'static str = "Refcount table"

User-readable struct name.

type InternalEntry = RefTableEntry

Internal type for each table entry.

type Entry = RefTableEntry

Externally visible type for each table entry.

fn from_data(data: Box<[RefTableEntry]>, header: &Header) -> Self

Create a new table with the given contents

fn entries(&self) -> usize

Number of entries.

fn get_ref(&self, index: usize) -> Option<&RefTableEntry>

Get the given entry (as reference).

fn get(&self, index: usize) -> RefTableEntry

Get the given entry (copied).

fn get_cluster(&self) -> Option<HostCluster>

Get this table’s (first) cluster in the image file.

fn get_offset(&self) -> Option<HostOffset>

Get this table’s offset in the image file.

fn set_cluster(&mut self, cluster: HostCluster)

Set this table’s (first) cluster in the image file (for writing).

fn unset_cluster(&mut self)

Remove the table’s association with any cluster in the image file.

fn is_modified(&self) -> bool

Check whether this table has been modified since it was last written.

fn clear_modified(&self)

Clear the modified flag.

fn set_modified(&self)

Set the modified flag.

fn cluster_bits(&self) -> u32

Return log2 of the cluster size.

fn byte_size(&self) -> usize

Table size in bytes.

fn cluster_count(&self) -> ClusterCount

Number of clusters used by this table.

async fn load<S: Storage>( image: &S, header: &Header, cluster: HostCluster, entries: usize, ) -> Result<Self>

Load a table from the image file.

async fn write<S: Storage>(&self, image: &S) -> Result<()>

Write a table to the image file.

async fn write_entry<S: Storage>(&self, image: &S, index: usize) -> Result<()>

Write at least the given single (modified) entry to the image file.