Struct DsmRange 

pub struct DsmRange { /* private fields */ }

One DSM range entry. NVMe spec: each entry covers up to 4 GiB of LBAs.

Fields are private — construct via DsmRange::new (which takes a 1-based block count, matching the rest of this module’s I/O API) and refine with DsmRange::with_context. This makes it impossible to confuse the public 1-based count with the spec’s 0-based wire encoding (which execute applies internally).

Implementations

impl DsmRange

pub fn new(slba: u64, nlb: u32) -> Self

Construct a range starting at slba covering nlb logical blocks.

nlb is 1-based (1 = a single LBA), consistent with the rest of this module; it is decremented to the spec’s 0-based encoding when the command is submitted. nlb of 0 is treated as 1.

Examples found in repository

examples/io_smoke.rs (line 73)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = Root::scan()?;
    let mut exercised = 0;

    for host in root.hosts() {
        for subsys in host.subsystems() {
            for ctrl in subsys.controllers() {
                let model = ctrl.model().unwrap_or("?").trim();
                if model != QEMU_MODEL {
                    println!(
                        "skipping {}: model {model:?} != {QEMU_MODEL:?} (refusing on real hardware)",
                        ctrl.name()?
                    );
                    continue;
                }

                for ns in ctrl.namespaces() {
                    let lba_size = ns.lba_size();
                    println!(
                        "exercising {} (NSID {}, {} B LBAs)",
                        ns.name()?,
                        ns.nsid(),
                        lba_size
                    );

                    // ---- Write one LBA with a recognizable pattern -----
                    let mut pattern = vec![0u8; lba_size as usize];
                    for (i, b) in pattern.iter_mut().enumerate() {
                        *b = (i & 0xFF) as u8;
                    }
                    ns.write(0, 1, &pattern).fua().execute()?;
                    println!("  write ok");

                    // ---- Read it back ---------------------------------
                    let got = ns.read_to_vec(0, 1)?;
                    assert_eq!(got, pattern, "read did not return the bytes we wrote");
                    println!("  read ok (round-trip matches)");

                    // ---- Compare (should succeed) ---------------------
                    ns.compare(0, 1, &pattern).execute()?;
                    println!("  compare ok");

                    // ---- Verify (controller-side integrity check) -----
                    ns.verify(0, 1).execute()?;
                    println!("  verify ok");

                    // ---- Write zeroes over the LBA --------------------
                    ns.write_zeroes(0, 1).execute()?;
                    let zeroed = ns.read_to_vec(0, 1)?;
                    assert!(zeroed.iter().all(|&b| b == 0), "expected all-zero LBA");
                    println!("  write_zeroes ok");

                    // ---- DSM deallocate (TRIM) ------------------------
                    ns.dsm(DsmAttr::DEALLOCATE)
                        .ranges(&[DsmRange::new(0, 1)])
                        .execute()?;
                    println!("  dsm(deallocate) ok");

                    // ---- Flush ----------------------------------------
                    ns.flush()?;
                    println!("  flush ok");

                    exercised += 1;
                }
            }
        }
    }

    if exercised == 0 {
        println!("(no QEMU virtual NVMe controllers found)");
    } else {
        println!("\nall I/O commands exercised on {exercised} namespace(s)");
    }
    Ok(())
}

pub fn with_context(self, context: u32) -> Self

Attach DSM context-attribute bits (frequency / latency / access-pattern hints — see the NVMe spec figure on DSM context attributes).

Trait Implementations

impl Clone for DsmRange

fn clone(&self) -> DsmRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DsmRange

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

Formats the value using the given formatter.

impl Copy for DsmRange