nvme: Convert Sanitize structures to deku bits, FlagSet

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

Author: amboar

src/lib.rs

@@ -638,7 +638,8 @@ pub struct Subsystem {
     nsids: u32,
     nss: heapless::Vec<Namespace, MAX_NAMESPACES>,
     health: SubsystemHealth,
-    sanicap: nvme::SanitizeCapabilities,
+    sanicap: FlagSet<nvme::SanitizeCapabilityFlags>,
+    nodmmas: nvme::NoDeallocateModifiesMediaAfterSanitize,
     ssi: nvme::SanitizeStateInformation,
     sstat: nvme::SanitizeStatus,
     sconf: Option<nvme::AdminSanitizeConfiguration>,
@@ -665,7 +666,11 @@ impl Subsystem {
             sstat: Default::default(),
             sconf: None,
             ssi: Default::default(),
-            sanicap: Default::default(),
+            sanicap: nvme::SanitizeCapabilityFlags::Ces
+                | nvme::SanitizeCapabilityFlags::Bes
+                | nvme::SanitizeCapabilityFlags::Ows
+                | nvme::SanitizeCapabilityFlags::Ndi,
+            nodmmas: Default::default(),
         }
     }
 

src/nvme.rs

@@ -378,7 +378,7 @@ pub struct SanitizeStateInformation {
 struct SanitizeStatusLogPageResponse {
     sprog: u16,
     sstat: SanitizeStatus,
-    scdw10: u32,
+    scdw10: AdminSanitizeConfiguration,
     eto: u32,
     etbe: u32,
     etce: u32,
@@ -555,7 +555,14 @@ flags! {
 }
 
 // Base v2.1, 5.1.13.2.1, Figure 312, SANICAP, NODMMAS
-#[derive(Clone, Copy, Debug, Default)]
+#[derive(Clone, Copy, Debug, Default, DekuRead, DekuWrite)]
+#[deku(
+    bits = "bits.0",
+    bit_order = "order",
+    ctx = "endian: Endian, bits: BitSize, order: Order",
+    endian = "endian",
+    id_type = "u8"
+)]
 #[repr(u8)]
 pub enum NoDeallocateModifiesMediaAfterSanitize {
     Undefined = 0b00,
@@ -564,41 +571,26 @@ pub enum NoDeallocateModifiesMediaAfterSanitize {
     Modified = 0b10,
     Reserved = 0b11,
 }
-unsafe impl Discriminant<u8> for NoDeallocateModifiesMediaAfterSanitize {}
 
 // Base v2.1, 5.1.13.2.1, Figure 312, SANICAP
-#[derive(Clone, Copy, Debug)]
-pub struct SanitizeCapabilities {
-    ces: bool,
-    bes: bool,
-    ows: bool,
-    vers: bool,
-    ndi: bool,
-    nodmmas: NoDeallocateModifiesMediaAfterSanitize,
-}
-
-impl From<SanitizeCapabilities> for u32 {
-    fn from(value: SanitizeCapabilities) -> Self {
-        (((value.nodmmas.id() & 0b11) as u32) << 30)
-            | ((value.ndi as u32) << 29)
-            | ((value.vers as u32) << 3)
-            | ((value.ows as u32) << 2)
-            | ((value.bes as u32) << 1)
-            | (value.ces as u32)
+flags! {
+    pub enum SanitizeCapabilityFlags: u32 {
+        Ces = 1 << 0,
+        Bes = 1 << 1,
+        Ows = 1 << 2,
+        Vers = 1 << 3,
+        Ndi = 1 << 29,
     }
 }
 
-impl Default for SanitizeCapabilities {
-    fn default() -> Self {
-        Self {
-            ces: true,
-            bes: true,
-            ows: true,
-            vers: false,
-            ndi: true,
-            nodmmas: NoDeallocateModifiesMediaAfterSanitize::Unmodified,
-        }
-    }
+// Base v2.1, 5.1.13.2.1, Figure 312, SANICAP
+#[derive(Clone, Copy, Debug, DekuRead, DekuWrite)]
+#[deku(bit_order = "lsb", ctx = "endian: Endian", endian = "endian")]
+pub struct SanitizeCapabilities {
+    #[deku(bits = 30)]
+    caps: WireFlagSet<SanitizeCapabilityFlags>,
+    #[deku(bits = 2)]
+    nodmmas: NoDeallocateModifiesMediaAfterSanitize,
 }
 
 // Base v2.1, 5.1.13.2.1, Figure 312, FNA
@@ -651,7 +643,7 @@ struct AdminIdentifyControllerResponse {
     fwug: u8,
     kas: u16,
     #[deku(seek_from_current = "6")]
-    sanicap: u32,
+    sanicap: SanitizeCapabilities,
     #[deku(seek_from_current = "54")]
     cqt: u16,
     #[deku(seek_from_current = "124")]
@@ -800,17 +792,23 @@ struct NvmNamespaceManagementCreate {
 }
 
 // Base v2.1, 5.1.22, Figure 372, SANACT
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default, DekuRead, DekuWrite, Eq, PartialEq)]
+#[deku(
+    bits = "bits.0",
+    ctx = "endian: Endian, bits: BitSize",
+    endian = "endian",
+    id_type = "u8"
+)]
 #[repr(u8)]
 enum SanitizeAction {
+    #[default]
     Reserved = 0x00,
     ExitFailureMode = 0x01,
     StartBlockErase = 0x02,
     StartOverwrite = 0x03,
     StartCryptoErase = 0x04,
     ExitMediaVerificationState = 0x05,
 }
-unsafe impl Discriminant<u8> for SanitizeAction {}
 
 impl TryFrom<u32> for SanitizeAction {
     type Error = ();
@@ -829,40 +827,21 @@ impl TryFrom<u32> for SanitizeAction {
 }
 
 // Base v2.1, 5.1.22, Figure 372
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default, DekuRead, DekuWrite, Eq, PartialEq)]
+#[deku(ctx = "endian: Endian", endian = "endian")]
 pub struct AdminSanitizeConfiguration {
-    sanact: SanitizeAction,
-    ause: bool,
+    #[deku(bits = "4")]
     owpass: u8,
-    oipbp: bool,
-    ndas: bool,
+    #[deku(bits = "1")]
+    ause: bool,
+    #[deku(bits = "3")]
+    sanact: SanitizeAction,
+    #[deku(bits = "1", pad_bits_before = "5")]
     emvs: bool,
-}
-
-impl TryFrom<u32> for AdminSanitizeConfiguration {
-    type Error = ();
-
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        Ok(Self {
-            sanact: TryInto::try_into(value & 0x7)?,
-            ause: ((value >> 3) & 1) == 1,
-            owpass: ((value >> 4) & 0xf) as u8,
-            oipbp: ((value >> 8) & 1) == 1,
-            ndas: ((value >> 9) & 1) == 1,
-            emvs: ((value >> 10) & 1) == 1,
-        })
-    }
-}
-
-impl From<AdminSanitizeConfiguration> for u32 {
-    fn from(value: AdminSanitizeConfiguration) -> Self {
-        ((value.emvs as u32) << 10)
-            | ((value.ndas as u32) << 9)
-            | ((value.oipbp as u32) << 8)
-            | (((value.owpass & 0xf) as u32) << 4)
-            | ((value.ause as u32) << 3)
-            | value.sanact.id() as u32
-    }
+    #[deku(bits = "1")]
+    ndas: bool,
+    #[deku(bits = "1", pad_bytes_after = "2")]
+    oipbp: bool,
 }
 
 // Base v2.1, 5.1.25, Figure 385

src/nvme/mi.rs

@@ -10,7 +10,7 @@ use log::debug;
 
 use crate::nvme::{
     AdminFormatNvmConfiguration, AdminNamespaceAttachmentSelect, AdminNamespaceManagementSelect,
-    ControllerListRequest,
+    AdminSanitizeConfiguration, ControllerListRequest,
 };
 use crate::wire::{WireFlagSet, WireVec};
 use crate::{CommandEffectError, Discriminant, Encode, MAX_CONTROLLERS};
@@ -997,7 +997,7 @@ struct AdminSanitizeRequest {
     dofst: u32,
     dlen: u32,
     #[deku(seek_from_current = "8")]
-    config: u32,
+    config: AdminSanitizeConfiguration,
     #[deku(pad_bytes_after = "16")]
     ovrpat: u32,
 }

src/nvme/mi/dev.rs

@@ -11,7 +11,7 @@ use mctp::{AsyncRespChannel, MsgIC};
 use crate::nvme::mi::{NvmSubsystemStatusFlags, PortCapabilityFlags};
 use crate::nvme::{
     ControllerAttributeFlags, ControllerMultipathIoNamespaceSharingCapabilityFlags,
-    ManagementEndpointCapabilityFlags, NvmSubsystemReportFlags,
+    ManagementEndpointCapabilityFlags, NvmSubsystemReportFlags, SanitizeCapabilityFlags,
 };
 use crate::{
     CommandEffect, CommandEffectError, Controller, ControllerError, ControllerType, Discriminant,
@@ -22,11 +22,10 @@ use crate::{
         AdminIdentifyCnsRequestType, AdminIdentifyControllerResponse,
         AdminIdentifyNamespaceIdentificationDescriptorListResponse,
         AdminIdentifyNvmIdentifyNamespaceResponse, AdminIoCqeGenericCommandStatus,
-        AdminIoCqeStatusType, AdminSanitizeConfiguration, ControllerListResponse,
-        LidSupportedAndEffectsDataStructure, LidSupportedAndEffectsFlags, LogPageAttributes,
-        NamespaceIdentifierType, SanitizeAction, SanitizeOperationStatus, SanitizeState,
-        SanitizeStateInformation, SanitizeStatus, SanitizeStatusLogPageResponse,
-        SmartHealthInformationLogPageResponse,
+        AdminIoCqeStatusType, ControllerListResponse, LidSupportedAndEffectsDataStructure,
+        LidSupportedAndEffectsFlags, LogPageAttributes, NamespaceIdentifierType, SanitizeAction,
+        SanitizeOperationStatus, SanitizeState, SanitizeStateInformation, SanitizeStatus,
+        SanitizeStatusLogPageResponse, SmartHealthInformationLogPageResponse,
         mi::{
             AdminCommandRequestHeader, AdminCommandResponseHeader, AdminFormatNvmRequest,
             AdminNamespaceAttachmentRequest, AdminNamespaceManagementRequest, AdminSanitizeRequest,
@@ -1277,13 +1276,7 @@ impl RequestHandler for AdminGetLogPageRequest {
                 let sslpr = SanitizeStatusLogPageResponse {
                     sprog: u16::MAX,
                     sstat: subsys.sstat,
-                    scdw10: {
-                        if let Some(sconf) = subsys.sconf {
-                            sconf.into()
-                        } else {
-                            0
-                        }
-                    },
+                    scdw10: subsys.sconf.unwrap_or_default(),
                     eto: u32::MAX,
                     etbe: u32::MAX,
                     etce: u32::MAX,
@@ -1464,7 +1457,10 @@ impl RequestHandler for AdminIdentifyRequest {
                         msdbd: 0,
                         ofcs: 0,
                         apsta: 0,
-                        sanicap: subsys.sanicap.into(),
+                        sanicap: crate::nvme::SanitizeCapabilities {
+                            caps: subsys.sanicap.into(),
+                            nodmmas: subsys.nodmmas,
+                        },
                     }
                     .encode()
                     .map_err(AdminIoCqeGenericCommandStatus::from)
@@ -1918,18 +1914,7 @@ impl RequestHandler for AdminSanitizeRequest {
             return Err(ResponseStatus::InvalidCommandSize);
         }
 
-        let Ok(config) = TryInto::<AdminSanitizeConfiguration>::try_into(self.config) else {
-            debug!("Invalid sanitize configuration: {}", self.config);
-            return admin_send_status(
-                resp,
-                AdminIoCqeStatusType::GenericCommandStatus(
-                    AdminIoCqeGenericCommandStatus::InvalidFieldInCommand,
-                ),
-            )
-            .await;
-        };
-
-        if subsys.sanicap.ndi && config.ndas {
+        if subsys.sanicap.contains(SanitizeCapabilityFlags::Ndi) && self.config.ndas {
             debug!("Request for No-Deallocate After Sanitize when No-Deallocate is inhibited");
             return admin_send_status(
                 resp,
@@ -1941,7 +1926,7 @@ impl RequestHandler for AdminSanitizeRequest {
         }
 
         // TODO: Implement action latency, progress state machine, error states
-        match config.sanact {
+        match self.config.sanact {
             SanitizeAction::Reserved => Err(ResponseStatus::InvalidParameter),
             SanitizeAction::ExitFailureMode | SanitizeAction::ExitMediaVerificationState => {
                 if subsys.ssi.sans != SanitizeState::Idle {
@@ -1960,7 +1945,7 @@ impl RequestHandler for AdminSanitizeRequest {
                     mvcncled: false,
                     gde: true,
                 };
-                subsys.sconf = Some(self.config.try_into()?);
+                subsys.sconf = Some(self.config);
 
                 admin_send_response_body(resp, &[]).await
             }
@@ -1970,12 +1955,12 @@ impl RequestHandler for AdminSanitizeRequest {
                     fails: 0,
                 };
                 subsys.sstat = SanitizeStatus {
-                    opc: config.owpass,
+                    opc: self.config.owpass,
                     sos: SanitizeOperationStatus::Sanitized,
                     mvcncled: false,
                     gde: true,
                 };
-                subsys.sconf = Some(self.config.try_into()?);
+                subsys.sconf = Some(self.config);
 
                 admin_send_response_body(resp, &[]).await
             }