Struct BlockDevice 

pub struct BlockDevice {
    pub name: String,
    pub maj_min: MajMin,
    pub rm: bool,
    pub size: u64,
    pub ro: bool,
    pub device_type: DeviceType,
    pub mountpoints: Vec<Option<String>>,
    pub children: Option<Vec<BlockDevice>>,
}

Represents a single block device as reported by lsblk.

Children (partitions, RAID/LVM/crypt mappings layered on top) are stored in the children field. To walk the device tree, use BlockDevice::descendants or iterate manually via BlockDevice::children_iter.

Fields

name: String

The name of the block device (e.g. "sda", "nvme0n1").

maj_min: MajMin

The major and minor numbers of the block device.

Corresponds to the JSON field "maj:min".

rm: bool

Whether the device is removable.

size: u64

The size of the block device in bytes.

ro: bool

Whether the device is read-only.

device_type: DeviceType

The type of the block device.

Corresponds to the JSON field "type" (a reserved keyword in Rust).

mountpoints: Vec<Option<String>>

The mountpoints of the device.

Accepts both a single mountpoint (possibly null) and an array of mountpoints in the input JSON; always stored as a vector.

children: Option<Vec<BlockDevice>>

Optional nested children (partitions, RAID/LVM/crypt mappings).

Implementations

impl BlockDevice

pub fn has_children(&self) -> bool

Returns true if this device has any children.

pub fn children_iter(&self) -> impl Iterator<Item = &BlockDevice>

Returns an iterator over the direct children of this device.

Returns an empty iterator if the device has no children.

pub fn descendants(&self) -> Descendants<'_>

Returns an iterator over self and all descendants in pre-order.

The traversal is iterative, so it will not stack-overflow on pathologically deep device trees.

pub fn find_child(&self, name: &str) -> Option<&BlockDevice>

Finds a direct child device by name.

Returns None if no direct child with the given name exists. For a recursive search, use BlockDevice::find_descendant.

pub fn find_descendant(&self, name: &str) -> Option<&BlockDevice>

Recursively finds a descendant device (including self) by name.

pub fn active_mountpoints(&self) -> Vec<&str>

Returns all non-null mountpoints for this device as an allocated Vec.

For zero-allocation iteration, prefer BlockDevice::active_mountpoints_iter.

pub fn active_mountpoints_iter(&self) -> impl Iterator<Item = &str>

Returns an iterator over the non-null mountpoints for this device.

pub fn is_mounted(&self) -> bool

Returns true if this device has at least one mountpoint.

pub fn is_system(&self) -> bool

Returns true if this device or any of its descendants is mounted at / (i.e. holds the root filesystem).

Recursion depth is bounded by the depth of the device tree; for trees constructed via parse_lsblk, that is in turn bounded by serde_json’s recursion limit.

pub fn is_disk(&self) -> bool

Returns true if this device is a DeviceType::Disk.

pub fn is_partition(&self) -> bool

Returns true if this device is a DeviceType::Part.

Trait Implementations

impl Clone for BlockDevice

fn clone(&self) -> BlockDevice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockDevice

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlockDevice

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BlockDevice

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for BlockDevice

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BlockDevice

impl StructuralPartialEq for BlockDevice