nvme::namespace_list: handle unused entries

According to NVM Express® Base Specification, Revision 2.0c 4.4.2
(Namespace List), unused entries in the namespace list are zero filled.

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/block/nvme/command.rs

@@ -187,6 +187,7 @@ pub struct IdentifyController {
     pub sqes: u8,
     pub cqes: u8,
     pub maxcmd: u16,
+    /// This field indicates the maximum value of a valid NSID for the NVM subsystem.
     pub nn: u32,
     pub oncs: u16,
     pub fuses: u16,

src/aero_kernel/src/drivers/block/nvme/dma.rs

@@ -112,6 +112,12 @@ impl<T: ?Sized> core::ops::DerefMut for Dma<T> {
     }
 }
 
+impl<T: ?Sized + core::fmt::Debug> core::fmt::Debug for Dma<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("Dma").field(&self.0).finish()
+    }
+}
+
 impl<T: ?Sized> Dma<T> {
     pub fn addr(&self) -> PhysAddr {
         unsafe {

src/aero_kernel/src/drivers/block/nvme/mod.rs

@@ -363,9 +363,8 @@ impl<'a> Controller<'a> {
         io_cq_cmd.prp1 = io_queue.completion_addr().as_u64();
         io_cq_cmd.cqid = io_queue.id();
         io_cq_cmd.q_size = (io_queue.len() - 1) as u16;
-        io_cq_cmd.irq_vector = vector as u16;
-        io_cq_cmd.cq_flags =
-            (CommandFlags::CQ_IRQ_ENABLED | CommandFlags::QUEUE_PHYS_CONTIG).bits();
+        io_cq_cmd.irq_vector = 0;
+        io_cq_cmd.cq_flags = CommandFlags::QUEUE_PHYS_CONTIG.bits();
 
         admin.submit_command(io_cq_cmd);
 
@@ -376,8 +375,7 @@ impl<'a> Controller<'a> {
         io_sq_cmd.cqid = io_queue.id();
         io_sq_cmd.sqid = io_queue.id();
         io_sq_cmd.q_size = (io_queue.len() - 1) as u16;
-        io_sq_cmd.sq_flags =
-            (CommandFlags::CQ_IRQ_ENABLED | CommandFlags::QUEUE_PHYS_CONTIG).bits();
+        io_sq_cmd.sq_flags = CommandFlags::QUEUE_PHYS_CONTIG.bits();
 
         admin.submit_command(io_sq_cmd);
 
@@ -396,7 +394,8 @@ impl<'a> Controller<'a> {
             io_queue: Mutex::new(io_queue),
         });
 
-        let namespace_ids = || {
+        // Discover and initialize the namespaces.
+        let nsids = {
             let nsid_list = Dma::<u32>::new_uninit_slice(this.identity.nn as usize);
             let mut nsid_command = IdentifyCommand::default();
 
@@ -410,48 +409,50 @@ impl<'a> Controller<'a> {
             unsafe { nsid_list.assume_init() }
         };
 
-        // Discover and initialize the namespaces.
-        let nsids = namespace_ids();
-        let namespaces = nsids
-            .iter()
-            .map(|nsid| {
-                let identity = Dma::<IdentifyNamespace>::new();
-                let mut identify_command = IdentifyCommand::default();
-
-                identify_command.opcode = AdminOpcode::Identify as u8;
-                identify_command.cns = IdentifyCns::Namespace as u8;
-                identify_command.nsid = *nsid;
-                identify_command.data_ptr.prp1 = identity.addr().as_u64();
-
-                this.admin.lock().submit_command(identify_command);
-
-                let blocks = identity.nsze as usize;
-                let block_size = 1 << identity.lbaf[(identity.flbas & 0b11111) as usize].ds;
-
-                // The maximum transfer size is in units of 2^(min page size)
-                let lba_shift = identity.lbaf[(identity.flbas & 0xf) as usize].ds;
-                let max_lbas = 1 << (max_transfer_shift - lba_shift as usize);
-                let max_prps = (max_lbas * (1 << lba_shift)) / Size4KiB::SIZE as usize;
-
-                Namespace {
-                    controller: this.clone(),
-                    nsid: *nsid,
-                    blocks,
-                    block_size,
-                    size: blocks * block_size,
-                    max_prps,
-                    prps: Mutex::new(Dma::new_uninit_slice(max_prps)),
-                }
-            })
-            .collect::<Vec<_>>();
+        let mut namespaces = alloc::vec![];
+
+        for &nsid in nsids.iter() {
+            // Unused entries are zero-filled.
+            if nsid == 0 {
+                continue;
+            }
+
+            let identity = Dma::<IdentifyNamespace>::new();
+            let mut identify_command = IdentifyCommand::default();
+
+            identify_command.opcode = AdminOpcode::Identify as u8;
+            identify_command.cns = IdentifyCns::Namespace as u8;
+            identify_command.nsid = nsid;
+            identify_command.data_ptr.prp1 = identity.addr().as_u64();
+
+            this.admin.lock().submit_command(identify_command);
+
+            let blocks = identity.nsze as usize;
+            let block_size = 1 << identity.lbaf[(identity.flbas & 0b11111) as usize].ds;
+
+            // The maximum transfer size is in units of 2^(min page size)
+            let lba_shift = identity.lbaf[(identity.flbas & 0xf) as usize].ds;
+            let max_lbas = 1 << (max_transfer_shift - lba_shift as usize);
+            let max_prps = (max_lbas * (1 << lba_shift)) / Size4KiB::SIZE as usize;
+
+            let namespace = Namespace {
+                controller: this.clone(),
+                nsid,
+                blocks,
+                block_size,
+                size: blocks * block_size,
+                max_prps,
+                prps: Mutex::new(Dma::new_uninit_slice(max_prps)),
+            };
 
-        for namespace in namespaces.iter() {
             log::trace!(
                 "nvme: identified namespace (blocks={}, block_size={}, size={})",
                 namespace.blocks,
                 namespace.block_size,
                 namespace.size
             );
+
+            namespaces.push(namespace);
         }
 
         *this.namespaces.lock() = namespaces;

src/aero_kernel/src/drivers/block/nvme/queue.rs

@@ -109,25 +109,41 @@ pub(super) struct QueuePair<'a> {
     id: u16,
     size: usize,
 
+    cid: u16,
+
     submission: Queue<'a, Submisson>,
     completion: Queue<'a, Completion>,
 }
 
 impl<'a> QueuePair<'a> {
     pub fn new(registers: &Registers, size: usize) -> Result<Self, Error> {
-        let queue_id = QUEUE_PAIR_ID.fetch_add(2, Ordering::SeqCst);
+        let queue_id = QUEUE_PAIR_ID.fetch_add(1, Ordering::SeqCst);
 
         Ok(Self {
             size,
             id: queue_id,
 
+            cid: 0,
+
             submission: Queue::new(registers, size, queue_id)?,
             completion: Queue::new(registers, size, queue_id)?,
         })
     }
 
     pub fn submit_command<T: Into<Command>>(&mut self, command: T) {
-        self.submission.submit_command(command.into());
+        let mut command = command.into();
+
+        unsafe {
+            // SAFETY: Command Layout:
+            //              - opcode: u8
+            //              - flags: u8
+            //              - command_id: u16 (offset=2 bytes))
+            *(&mut command as *mut Command as *mut u16).offset(1) = self.cid;
+        }
+
+        self.cid += 1;
+
+        self.submission.submit_command(command);
         self.completion.next_cmd_result().unwrap();
     }