tests

Author: ahrens

lib/propolis/src/hw/nvme/bits.rs

@@ -180,7 +180,7 @@ impl CompletionQueueEntry {
 /// A Dataset Management Range Definition as represented in memory.
 ///
 /// See NVMe 1.0e Section 6.6 Figure 114: Dataset Management – Range Definition
-#[derive(Debug, Default, Copy, Clone, FromBytes)]
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, FromBytes)]
 #[repr(C, packed(1))]
 pub struct DatasetManagementRangeDefinition {
     /// The context attributes specified for each range provides information about how the range
@@ -1230,5 +1230,6 @@ mod test {
         assert_eq!(size_of::<IdentifyController>(), 4096);
         assert_eq!(size_of::<LbaFormat>(), 4);
         assert_eq!(size_of::<IdentifyNamespace>(), 4096);
+        assert_eq!(size_of::<DatasetManagementRangeDefinition>(), 16);
     }
 }

lib/propolis/src/hw/nvme/cmds.rs

@@ -1206,6 +1206,8 @@ impl From<block::Result> for Completion {
 mod test {
     use crate::accessors::MemAccessor;
     use crate::common::*;
+    use crate::hw::nvme::bits::DatasetManagementRangeDefinition;
+    use crate::hw::nvme::cmds::DatasetManagementCmd;
     use crate::vmm::mem::PhysMap;
 
     use super::PrpIter;
@@ -1410,4 +1412,127 @@ mod test {
         }
         assert_eq!(iter.next(), None);
     }
+
+    static RANGES: [DatasetManagementRangeDefinition; 3] = [
+        DatasetManagementRangeDefinition {
+            context_attributes: 0,
+            starting_lba: 0x1000,
+            number_logical_blocks: 0x10,
+        },
+        DatasetManagementRangeDefinition {
+            context_attributes: 0,
+            starting_lba: 0x2000,
+            number_logical_blocks: 0x20,
+        },
+        DatasetManagementRangeDefinition {
+            context_attributes: 0,
+            starting_lba: 0x3000,
+            number_logical_blocks: 0x30,
+        },
+    ];
+
+    #[test]
+    fn test_dsmgmt_ranges() {
+        let (_pmap, acc_mem) = setup();
+        let memctx = acc_mem.access().unwrap();
+
+        let listaddr = 0x80000u64;
+        memctx.write_many(GuestAddr(listaddr), &RANGES);
+
+        let cmd = DatasetManagementCmd {
+            prp1: listaddr,
+            prp2: 0,
+            nr: RANGES.len() as u16,
+            ad: true,
+            _idw: false,
+            _idr: false,
+        };
+
+        let mut iter = cmd.ranges(&memctx);
+        for expected in &RANGES {
+            assert_eq!(
+                iter.next(),
+                Some(Ok(*expected)),
+                "bad range definition"
+            );
+        }
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_dsmgmt_ranges_dual() {
+        let (_pmap, acc_mem) = setup();
+        let memctx = acc_mem.access().unwrap();
+
+        let listaddr1 = 0x80FF0u64;
+        let listaddr2 = 0x90000u64;
+        memctx.write_many(GuestAddr(listaddr1), &RANGES[0..1]);
+        memctx.write_many(GuestAddr(listaddr2), &RANGES[1..]);
+
+        let cmd = DatasetManagementCmd {
+            prp1: listaddr1,
+            prp2: listaddr2,
+            nr: RANGES.len() as u16,
+            ad: true,
+            _idw: false,
+            _idr: false,
+        };
+
+        let mut iter = cmd.ranges(&memctx);
+        for expected in &RANGES {
+            assert_eq!(
+                iter.next(),
+                Some(Ok(*expected)),
+                "bad range definition"
+            );
+        }
+        assert_eq!(iter.next(), None);
+    }
+
+    #[test]
+    fn test_dsmgmt_ranges_bad_dual() {
+        let (_pmap, acc_mem) = setup();
+        let memctx = acc_mem.access().unwrap();
+
+        let listaddr1 = 0x80FF8u64;
+        let listaddr2 = 0x90000u64;
+        memctx.write_many(GuestAddr(listaddr1), &RANGES[0..1]);
+        memctx.write_many(GuestAddr(listaddr2), &RANGES[1..]);
+
+        let cmd = DatasetManagementCmd {
+            prp1: listaddr1,
+            prp2: listaddr2,
+            nr: RANGES.len() as u16,
+            ad: true,
+            _idw: false,
+            _idr: false,
+        };
+
+        let mut iter = cmd.ranges(&memctx);
+        match iter.next() {
+            Some(Err(_)) => {}
+            other => panic!("expected alignment error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_dsmgmt_ranges_bad_address() {
+        let (_pmap, acc_mem) = setup();
+        let memctx = acc_mem.access().unwrap();
+
+        let cmd = DatasetManagementCmd {
+            prp1: VM_SIZE as u64, // out of bounds
+            prp2: 0,
+            nr: 1,
+            ad: true,
+            _idw: false,
+            _idr: false,
+        };
+
+        let mut iter = cmd.ranges(&memctx);
+        match iter.next() {
+            Some(Err(_)) => {}
+            other => panic!("expected alignment error, got {other:?}"),
+        }
+    }
 }