nvme: mi: dev: Implement Admin / Namespace Mangement / Delete

Signed-off-by: Andrew Jeffery <andrew@codeconstruct.com.au>

Author: amboar

src/lib.rs

@@ -7,6 +7,7 @@
 use deku::{DekuContainerWrite, DekuError};
 use flagset::FlagSet;
 use hmac::Mac;
+use log::debug;
 use mctp::AsyncRespChannel;
 use nvme::{
     AdminGetLogPageLidRequestType, LidSupportedAndEffectsFlags, LogPageAttributes,
@@ -365,6 +366,7 @@ pub enum NamespaceIdentifierType {
 
 #[derive(Debug)]
 pub struct Namespace {
+    id: NamespaceId,
     size: u64,
     capacity: u64,
     used: u64,
@@ -385,20 +387,26 @@ impl Namespace {
         uuid::Builder::from_random_bytes(digest).into_uuid()
     }
 
-    pub fn new(id: Uuid, capacity: u64) -> Self {
+    pub fn new(nsid: NamespaceId, uuid: Uuid, capacity: u64) -> Self {
         Self {
+            id: nsid,
             size: capacity,
             capacity,
             used: 0,
             block_order: 9,
             nids: [
-                NamespaceIdentifierType::Nuuid(id),
+                NamespaceIdentifierType::Nuuid(uuid),
                 NamespaceIdentifierType::Csi(nvme::CommandSetIdentifier::Nvm),
             ],
         }
     }
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub enum SubsystemError {
+    NamespaceIdentifierUnavailable,
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct SubsystemInfo {
     pub pci_vid: u16,
@@ -480,6 +488,7 @@ pub struct Subsystem {
     caps: nvme::mi::SubsystemCapabilities,
     ports: heapless::Vec<Port, MAX_PORTS>,
     ctlrs: heapless::Vec<Controller, MAX_CONTROLLERS>,
+    nsids: u32,
     nss: heapless::Vec<Namespace, MAX_NAMESPACES>,
     health: SubsystemHealth,
     mi: MiCapability,
@@ -495,6 +504,7 @@ impl Subsystem {
             caps: nvme::mi::SubsystemCapabilities::new(),
             ports: heapless::Vec::new(),
             ctlrs: heapless::Vec::new(),
+            nsids: 0,
             nss: heapless::Vec::new(),
             health: SubsystemHealth::new(),
             mi: MiCapability::new(),
@@ -523,16 +533,33 @@ impl Subsystem {
             .expect("Invalid ControllerId provided")
     }
 
-    pub fn add_namespace(&mut self, capacity: u64) -> Result<NamespaceId, u8> {
-        debug_assert!(self.nss.len() <= u32::MAX.try_into().unwrap());
-        let nsid = NamespaceId((self.nss.len() + 1).try_into().unwrap());
+    pub fn add_namespace(&mut self, capacity: u64) -> Result<NamespaceId, SubsystemError> {
+        let Some(allocated) = self.nsids.checked_add(1) else {
+            debug!("Implement allocation tracking with reuse");
+            return Err(SubsystemError::NamespaceIdentifierUnavailable);
+        };
+        self.nsids = allocated;
+        let nsid = NamespaceId(self.nsids);
         let ns = Namespace::new(
+            nsid,
             Namespace::generate_uuid(&self.info.instance, nsid),
             capacity,
         );
         match self.nss.push(ns) {
             Ok(_) => Ok(nsid),
-            Err(_) => Err(0x16), // Namespace Identifier Unavailable
+            Err(_) => Err(SubsystemError::NamespaceIdentifierUnavailable),
         }
     }
+
+    pub fn remove_namespace(&mut self, nsid: NamespaceId) -> Result<(), SubsystemError> {
+        if nsid.0 == u32::MAX {
+            self.nss.clear();
+            return Ok(());
+        }
+        let Some(e) = self.nss.iter().enumerate().find(|args| args.1.id == nsid) else {
+            return Err(SubsystemError::NamespaceIdentifierUnavailable);
+        };
+        let _ = self.nss.swap_remove(e.0);
+        Ok(())
+    }
 }

src/nvme.rs

@@ -61,7 +61,7 @@ impl From<AdminIoCqeStatus> for u32 {
         debug_assert_eq!((sct & !7), 0);
         let sc: u32 = match value.status {
             AdminIoCqeStatusType::GenericCommandStatus(s) => s.id(),
-            AdminIoCqeStatusType::CommandSpecificStatus => todo!(),
+            AdminIoCqeStatusType::CommandSpecificStatus(s) => s.id(),
             AdminIoCqeStatusType::MediaAndDataIntegrityErrors => todo!(),
             AdminIoCqeStatusType::PathRelatedStatus => todo!(),
             AdminIoCqeStatusType::VendorSpecific => todo!(),
@@ -90,8 +90,7 @@ unsafe impl Discriminant<u8> for CommandRetryDelay {}
 #[repr(u8)]
 enum AdminIoCqeStatusType {
     GenericCommandStatus(AdminIoCqeGenericCommandStatus) = 0x00,
-    #[expect(dead_code)]
-    CommandSpecificStatus = 0x01,
+    CommandSpecificStatus(AdminIoCqeCommandSpecificStatus) = 0x01,
     #[expect(dead_code)]
     MediaAndDataIntegrityErrors = 0x02,
     #[expect(dead_code)]
@@ -110,6 +109,14 @@ enum AdminIoCqeGenericCommandStatus {
 }
 unsafe impl Discriminant<u8> for AdminIoCqeGenericCommandStatus {}
 
+// Base v2.1, 4.2.3.2, Figure 103
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(u8)]
+enum AdminIoCqeCommandSpecificStatus {
+    NamespaceIdentifierUnavailable = 0x16,
+}
+unsafe impl Discriminant<u8> for AdminIoCqeCommandSpecificStatus {}
+
 // Base v2.1, 5.1.12, Figure 202
 // MI v2.0, 6.3, Figure 141
 #[derive(Debug, DekuRead, DekuWrite, Eq, PartialEq)]

src/nvme/mi/dev.rs

@@ -9,16 +9,17 @@ use log::debug;
 use mctp::{AsyncRespChannel, MsgIC};
 
 use crate::{
-    CommandEffect, CommandEffectError, Discriminant, MAX_CONTROLLERS, MAX_NAMESPACES,
+    CommandEffect, CommandEffectError, Discriminant, MAX_CONTROLLERS, MAX_NAMESPACES, NamespaceId,
+    SubsystemError,
     nvme::{
         AdminGetLogPageLidRequestType, AdminGetLogPageSupportedLogPagesResponse,
         AdminIdentifyActiveNamespaceIdListResponse, AdminIdentifyAllocatedNamespaceIdListResponse,
         AdminIdentifyCnsRequestType, AdminIdentifyControllerResponse,
         AdminIdentifyNamespaceIdentificationDescriptorListResponse,
-        AdminIdentifyNvmIdentifyNamespaceResponse, AdminIoCqeGenericCommandStatus,
-        AdminIoCqeStatus, AdminIoCqeStatusType, ControllerListResponse,
-        LidSupportedAndEffectsDataStructure, LidSupportedAndEffectsFlags, LogPageAttributes,
-        NamespaceIdentifierType, SmartHealthInformationLogPageResponse,
+        AdminIdentifyNvmIdentifyNamespaceResponse, AdminIoCqeCommandSpecificStatus,
+        AdminIoCqeGenericCommandStatus, AdminIoCqeStatus, AdminIoCqeStatusType,
+        ControllerListResponse, LidSupportedAndEffectsDataStructure, LidSupportedAndEffectsFlags,
+        LogPageAttributes, NamespaceIdentifierType, SmartHealthInformationLogPageResponse,
         mi::{
             AdminCommandRequestHeader, AdminCommandResponseHeader, AdminNamespaceManagementRequest,
             CompositeControllerStatusDataStructureResponse, CompositeControllerStatusFlagSet,
@@ -1519,7 +1520,41 @@ impl RequestHandler for AdminNamespaceManagementRequest {
 
                 Ok(())
             }
-            crate::nvme::mi::AdminNamespaceManagementSelect::Delete => todo!(),
+            crate::nvme::mi::AdminNamespaceManagementSelect::Delete => {
+                let res = subsys.remove_namespace(NamespaceId(self.nsid));
+                let status = match &res {
+                    Ok(_) => AdminIoCqeStatusType::GenericCommandStatus(
+                        AdminIoCqeGenericCommandStatus::SuccessfulCompletion,
+                    ),
+                    Err(err) => {
+                        assert_eq!(err, &SubsystemError::NamespaceIdentifierUnavailable);
+                        AdminIoCqeStatusType::CommandSpecificStatus(
+                            AdminIoCqeCommandSpecificStatus::NamespaceIdentifierUnavailable,
+                        )
+                    }
+                };
+                let mh = MessageHeader::respond(MessageType::NvmeAdminCommand).encode()?;
+
+                let acrh = AdminCommandResponseHeader {
+                    status: ResponseStatus::Success,
+                    cqedw0: self.nsid, // TODO: Base v2.1, 5.1.21 unclear, test against hardware
+                    cqedw1: 0,
+                    cqedw3: AdminIoCqeStatus {
+                        cid: 0,
+                        p: true,
+                        status,
+                        crd: crate::nvme::CommandRetryDelay::None,
+                        m: false,
+                        dnr: res.is_err(),
+                    }
+                    .into(),
+                }
+                .encode()?;
+
+                send_response(resp, &[&mh.0, &acrh.0]).await;
+
+                Ok(())
+            }
         }
     }
 }