Struct RaidArray 

pub struct RaidArray {
    pub name: String,
    pub uuid: [u8; 16],
    pub level: RaidLevel,
    pub chunk_size: u64,
    pub disks: Vec<RaidDisk>,
    pub spares: Vec<RaidDisk>,
    pub state: ArrayState,
    pub superblock: Superblock,
    pub rebuild_progress: u8,
}

A RAID array composed of multiple disks.

Fields

name: String

Array name.

uuid: [u8; 16]

Array UUID.

level: RaidLevel

RAID level.

chunk_size: u64

Chunk size in blocks.

disks: Vec<RaidDisk>

Member disks.

spares: Vec<RaidDisk>

Hot spare disks.

state: ArrayState

Array state.

superblock: Superblock

Superblock.

rebuild_progress: u8

Rebuild progress (0-100).

Implementations

impl RaidArray

pub fn new( name: &str, level: RaidLevel, disks: Vec<RaidDisk>, ) -> Result<Self, RaidError>

Create a new RAID array.

pub fn stripe_map(&self, logical_block: u64) -> Result<StripeMap, RaidError>

Map a logical block to a physical stripe location (RAID0).

pub fn raid5_map(&self, logical_block: u64) -> Result<StripeMap, RaidError>

Map a logical block for RAID5 (left-symmetric parity rotation).

pub fn read_stripe(&self, logical_block: u64) -> Result<StripeMap, RaidError>

Read a stripe (dispatch by RAID level).

pub fn write_stripe( &self, logical_block: u64, ) -> Result<Vec<StripeMap>, RaidError>

Write a stripe (dispatch by RAID level, returns all disks to write).

pub fn compute_parity(blocks: &[&[u8]]) -> Vec<u8>

Compute XOR parity across data blocks.

pub fn rebuild(&mut self, failed_disk_idx: usize) -> Result<(), RaidError>

Rebuild a failed disk from parity and remaining data.

pub fn check_health(&mut self) -> ArrayState

Check array health and update state.

pub fn replace_disk(&mut self, failed_disk_idx: usize) -> Result<(), RaidError>

Replace a failed disk with a spare.

pub fn add_spare(&mut self, disk: RaidDisk)

Add a hot spare disk.

pub fn active_disk_count(&self) -> usize

Get the number of active disks.

pub fn failed_disk_count(&self) -> usize

Get the number of failed disks.

pub fn capacity_blocks(&self) -> u64

Get usable capacity in blocks.

Trait Implementations

impl Debug for RaidArray

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

Formats the value using the given formatter.

impl PartialEq for RaidArray

fn eq(&self, other: &RaidArray) -> 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 StructuralPartialEq for RaidArray