Struct devicemapper::LinearDevTargetTable

pub struct LinearDevTargetTable {
    pub table: Vec<TargetLine<LinearDevTargetParams>>,
}

A target table for a linear device. Such a table allows flakey targets as well as linear targets.

Fields

table: Vec<TargetLine<LinearDevTargetParams>>

The device’s table

Implementations

impl LinearDevTargetTable

pub fn new(
    table: Vec<TargetLine<LinearDevTargetParams>>
) -> LinearDevTargetTable

Make a new LinearDevTargetTable from a suitable vec

Examples found in repository

src/lineardev.rs (line 534)

    pub fn setup(
        dm: &DM,
        name: &DmName,
        uuid: Option<&DmUuid>,
        table: Vec<TargetLine<LinearDevTargetParams>>,
    ) -> DmResult<LinearDev> {
        let table = LinearDevTargetTable::new(table);
        let dev = if device_exists(dm, name)? {
            let dev_info = dm.device_info(&DevId::Name(name))?;
            let dev = LinearDev {
                dev_info: Box::new(dev_info),
                table,
            };
            device_match(dm, &dev, uuid)?;
            dev
        } else {
            let dev_info = device_create(dm, name, uuid, &table, DmOptions::default())?;
            LinearDev {
                dev_info: Box::new(dev_info),
                table,
            }
        };
        Ok(dev)
    }

    /// Set the segments for this linear device.
    /// This action puts the device in a state where it is ready to be resumed.
    /// Warning: It is the client's responsibility to make sure the designated
    /// segments are compatible with the device's existing segments.
    /// If they are not, this function will still succeed, but some kind of
    /// data corruption will be the inevitable result.
    pub fn set_table(
        &mut self,
        dm: &DM,
        table: Vec<TargetLine<LinearDevTargetParams>>,
    ) -> DmResult<()> {
        let table = LinearDevTargetTable::new(table);
        self.suspend(dm, DmOptions::default().set_flags(DmFlags::DM_NOFLUSH))?;
        self.table_load(dm, &table, DmOptions::default())?;
        self.table = table;
        Ok(())
    }

Trait Implementations

impl Clone for LinearDevTargetTable

fn clone(&self) -> LinearDevTargetTable

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LinearDevTargetTable

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

Formats the value using the given formatter.

impl Display for LinearDevTargetTable

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

Formats the value using the given formatter.

impl DmDevice<LinearDevTargetTable> for LinearDev

fn device(&self) -> Device

The device.

fn devnode(&self) -> PathBuf

The device’s device node.

fn equivalent_tables(
    left: &LinearDevTargetTable,
    right: &LinearDevTargetTable
) -> DmResult<bool>

Check if tables indicate an equivalent device.

fn name(&self) -> &DmName

The device’s name.

fn size(&self) -> Sectors

The number of sectors available for user data.

fn table(&self) -> &LinearDevTargetTable

What the device thinks its table is.

fn teardown(&mut self, dm: &DM) -> DmResult<()>

Erase the kernel’s memory of this device.

fn uuid(&self) -> Option<&DmUuid>

The device’s UUID, if available. Note that the UUID is not any standard UUID format.

fn read_kernel_table(dm: &DM, id: &DevId<'_>) -> DmResult<T>

Read the devicemapper table

fn resume(&mut self, dm: &DM) -> DmResult<()>

Resume I/O on the device.

fn suspend(&mut self, dm: &DM, options: DmOptions) -> DmResult<()>

Suspend I/O on the device.

fn table_load(&self, dm: &DM, table: &T, options: DmOptions) -> DmResult<()>

Load a table

impl PartialEq<LinearDevTargetTable> for LinearDevTargetTable

fn eq(&self, other: &LinearDevTargetTable) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TargetTable for LinearDevTargetTable

fn from_raw_table(
    table: &[(u64, u64, String, String)]
) -> DmResult<LinearDevTargetTable>

Constructs a table from a raw table returned by DM::table_status()

fn to_raw_table(&self) -> Vec<(u64, u64, String, String)>

Generates a table that can be loaded by DM::table_load()

impl Eq for LinearDevTargetTable

impl StructuralEq for LinearDevTargetTable

impl StructuralPartialEq for LinearDevTargetTable