Struct MkfsConfig 

pub struct MkfsConfig {
    pub fs_type: FsType,
    pub block_size: u32,
    pub label: Option<String>,
    pub uuid: Option<[u8; 16]>,
    pub journal: bool,
    pub inode_size: u32,
}

Configuration for creating an ext4 filesystem.

Fields

fs_type: FsType

Filesystem type (ext2, ext3, or ext4)

block_size: u32

Block size in bytes (1024, 2048, or 4096)

label: Option<String>

Volume label (max 16 characters)

uuid: Option<[u8; 16]>

UUID for the filesystem

journal: bool

Enable journaling (only for ext3/ext4)

inode_size: u32

Inode size (128 or 256)

Implementations

impl MkfsConfig

pub fn new() -> Self

Create a new configuration with default values.

Examples found in repository

examples/mkfs_file.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "test_disk.img";
    let size: u64 = 10 * 1024 * 1024; // 10 MB

    println!("Creating disk image: {} ({} bytes)", path, size);

    // Create and size the file
    {
        let mut file = File::create(path)?;
        file.seek(SeekFrom::Start(size - 1))?;
        file.write_all(&[0])?;
        file.sync_all()?;
    }

    // Open for read/write
    let file = OpenOptions::new().read(true).write(true).open(path)?;

    // Create block device wrapper (512-byte sectors)
    let device = IoBlockDevice::new(file, 512, size);

    // Configure and create filesystem
    let config = MkfsConfig::new()
        .fs_type(FsType::Ext4)
        .block_size(4096)
        .label("test_volume");

    println!("Formatting as ext4...");
    mkfs(device, config)?;

    println!("Done! You can verify with: file {} or dumpe2fs {}", path, path);

    Ok(())
}

pub fn fs_type(self, fs_type: FsType) -> Self

Set the filesystem type.

Examples found in repository

examples/mkfs_file.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "test_disk.img";
    let size: u64 = 10 * 1024 * 1024; // 10 MB

    println!("Creating disk image: {} ({} bytes)", path, size);

    // Create and size the file
    {
        let mut file = File::create(path)?;
        file.seek(SeekFrom::Start(size - 1))?;
        file.write_all(&[0])?;
        file.sync_all()?;
    }

    // Open for read/write
    let file = OpenOptions::new().read(true).write(true).open(path)?;

    // Create block device wrapper (512-byte sectors)
    let device = IoBlockDevice::new(file, 512, size);

    // Configure and create filesystem
    let config = MkfsConfig::new()
        .fs_type(FsType::Ext4)
        .block_size(4096)
        .label("test_volume");

    println!("Formatting as ext4...");
    mkfs(device, config)?;

    println!("Done! You can verify with: file {} or dumpe2fs {}", path, path);

    Ok(())
}

pub fn block_size(self, size: u32) -> Self

Set the block size.

Examples found in repository

examples/mkfs_file.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "test_disk.img";
    let size: u64 = 10 * 1024 * 1024; // 10 MB

    println!("Creating disk image: {} ({} bytes)", path, size);

    // Create and size the file
    {
        let mut file = File::create(path)?;
        file.seek(SeekFrom::Start(size - 1))?;
        file.write_all(&[0])?;
        file.sync_all()?;
    }

    // Open for read/write
    let file = OpenOptions::new().read(true).write(true).open(path)?;

    // Create block device wrapper (512-byte sectors)
    let device = IoBlockDevice::new(file, 512, size);

    // Configure and create filesystem
    let config = MkfsConfig::new()
        .fs_type(FsType::Ext4)
        .block_size(4096)
        .label("test_volume");

    println!("Formatting as ext4...");
    mkfs(device, config)?;

    println!("Done! You can verify with: file {} or dumpe2fs {}", path, path);

    Ok(())
}

pub fn label(self, label: impl Into<String>) -> Self

Set the volume label.

Examples found in repository

examples/mkfs_file.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = "test_disk.img";
    let size: u64 = 10 * 1024 * 1024; // 10 MB

    println!("Creating disk image: {} ({} bytes)", path, size);

    // Create and size the file
    {
        let mut file = File::create(path)?;
        file.seek(SeekFrom::Start(size - 1))?;
        file.write_all(&[0])?;
        file.sync_all()?;
    }

    // Open for read/write
    let file = OpenOptions::new().read(true).write(true).open(path)?;

    // Create block device wrapper (512-byte sectors)
    let device = IoBlockDevice::new(file, 512, size);

    // Configure and create filesystem
    let config = MkfsConfig::new()
        .fs_type(FsType::Ext4)
        .block_size(4096)
        .label("test_volume");

    println!("Formatting as ext4...");
    mkfs(device, config)?;

    println!("Done! You can verify with: file {} or dumpe2fs {}", path, path);

    Ok(())
}

pub fn uuid(self, uuid: [u8; 16]) -> Self

Set the UUID.

pub fn journal(self, enable: bool) -> Self

Enable or disable journaling.

pub fn inode_size(self, size: u32) -> Self

Set the inode size.

Trait Implementations

impl Clone for MkfsConfig

fn clone(&self) -> MkfsConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MkfsConfig

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

Formats the value using the given formatter.

impl Default for MkfsConfig

fn default() -> Self

Returns the “default value” for a type.