Struct libparted::Geometry

pub struct Geometry<'a> { /* fields omitted */ }

Implementations

impl<'a> Geometry<'a>

pub fn from_raw(geometry: *mut PedGeometry) -> Geometry<'a>

pub fn exact(&self) -> Option<Constraint<'_>>

Return a constraint that only the given region will satisfy.

pub fn check(
    &self,
    offset: i64,
    granularity: i64,
    count: i64,
    timer: &Timer<'_>
) -> Result<(), u64>

Checks for physical disk errors.

Checks a region for physical defects on geom. The region checked starts at offset sectors inside the region represented by geom, and is count sectors long. granularity specifies how sectors should be grouped together.

The first bad sector to be returned will always be in the form:

    offset + n * granularity

Returns the first bad sector if a bad sector was found.

pub fn dev(&self) -> Device<'_>

pub fn dev_mut(&mut self) -> Device<'_>

pub fn duplicate<'b>(&self) -> Result<Geometry<'b>>

Duplicate a Geometry object.

pub fn end(&self) -> i64

pub fn init(
    &mut self,
    device: &Device<'_>,
    start: i64,
    length: i64
) -> Result<()>

Initializes a pre-allocated Geometry.

pub fn intersect(&self, other: &Geometry<'_>) -> Option<Geometry<'a>>

Return a Geometry object that refers to the intersection between itself and another Geometry.

pub fn length(&self) -> i64

pub fn map(&self, src: &Geometry<'_>, sector: i64) -> Option<u64>

Takes a sector inside the region described by src and returns that sector’s address inside of our own Geometry marked as self. This means that the following code examples are equivalent:

geometry.read(buf, geometry.map(src, sector), 1);

geometry.read(buf, sector, 1);

Clearly, this will only work if self and src overlap.

pub fn new(device: &Device<'_>, start: i64, length: i64) -> Result<Geometry<'a>>

Create a new Geometry object on disk, starting at start with a size of length sectors.

pub fn read(&self, buffer: &mut Vec<u8>, offset: i64, count: i64) -> Result<()>

Reads data from the region within our Geometry. offset is the location from within the region, not from the start of the disk. count sectors are read into buffer. An exception is thrown when attempting to read sectors outside of the partition.

Note:

The supplied vector will be reallocated to the correct size automatically.

Throws:

Throws PED_EXCEPTION_ERROR when attempting to read sectors outside of partition.

pub fn set(&mut self, start: i64, length: i64) -> Result<()>

Assign a new start and length, where end will also be set implicitly from those values.

pub fn set_end(&mut self, end: i64) -> Result<()>

Assign a new end to self without changing self->start field.

self->length will be updated accordingly.

pub fn set_start(&mut self, start: i64) -> Result<()>

Assign a new start to self witout changing self->end.

self->length will be updated accordingly.

pub fn start(&self) -> i64

pub fn sync(&mut self) -> Result<()>

Flushes the cache on self.

This function flushses all write-behind caches that might be holding writes made by Geometry::write() to self. It is slow because it guarantees cache coherency among all relevant caches.

pub fn sync_fast(&mut self) -> Result<()>

Flushes the cache on self.

This function flushses all write-behind caches that might be holding writes made by Geometry::write() to self. It does not ensure cache coherency with other caches that cache data in the region described by self.

If you need cache coherency, use Geometry::sync() instead.

pub fn test_equal(&self, other: &Geometry<'_>) -> bool

Tests if the other Geometry refers to the same physical region as self.

pub fn test_inside(&self, other: &Geometry<'_>) -> bool

Tests if the other Geometry is inside self.

pub fn test_sector_inside(&self, sector: i64) -> bool

Tests if sector is inside the geometry.

pub fn write_to_sectors(
    &mut self,
    buffer: &[u8],
    offset: i64,
    count: i64
) -> Result<()>

Writes data into the region represented by self. The offset is the location from within the region, not from the start of the disk. count sectors are to be written.

pub fn open_fs(&self) -> Option<FileSystem<'_>>

Opens the file system stored in the given Geometry.

Examples

let mut fs = FileSystem::open(&mut geometry);

let mut fs = geometry.open_fs();

Throws

• PED_EXCEPTION_ERROR if the file system could not be detected.
• PED_EXCEPTION_ERROR if the file system is bigger than its volume.
• PED_EXCEPTION_NO_FEATURE if opening of a file system stored on geom is not implemented.

pub fn probe_fs(&self) -> Result<FileSystemType<'_>>

Attempt to detect a file system in the given Geometry.

This function tries to be clever at dealing with ambiguous situations, such as when one file system was not completely erased before a new file system was created on on top of it.

pub fn probe_specific_fs<'b>(
    &'b self,
    fs_type: &'b FileSystemType<'_>
) -> Option<Geometry<'b>>

Attempt to find a file system and return the region it occupies.

Trait Implementations

impl<'a> Drop for Geometry<'a>

fn drop(&mut self)

Executes the destructor for this type.