Pausing work to create a PR

Author: gurasinghMS

vm/devices/storage/disk_nvme/nvme_driver/src/tests.rs

@@ -12,7 +12,7 @@ use mesh::CellUpdater;
 use nvme::NvmeControllerCaps;
 use nvme_resources::fault::AdminQueueFaultConfig;
 use nvme_resources::fault::FaultConfiguration;
-use nvme_resources::fault::QueueFaultBehavior;
+use nvme_resources::fault::FaultBehaviour;
 use nvme_spec::AdminOpcode;
 use nvme_spec::Cap;
 use nvme_spec::Command;
@@ -48,7 +48,7 @@ async fn test_nvme_command_fault(driver: DefaultDriver) {
             fault_active: CellUpdater::new(true).cell(),
             admin_fault: AdminQueueFaultConfig::new().with_submission_queue_fault(
                 AdminOpcode::CREATE_IO_COMPLETION_QUEUE.0,
-                QueueFaultBehavior::Update(output_cmd),
+                FaultBehaviour::Update(output_cmd),
             ),
         },
     )

vm/devices/storage/nvme_resources/src/fault.rs

@@ -10,7 +10,7 @@ use std::time::Duration;
 
 /// Supported fault behaviour for NVMe queues
 #[derive(Debug, Clone, Copy, MeshPayload)]
-pub enum QueueFaultBehavior<T> {
+pub enum FaultBehaviour<T> {
     /// Update the queue entry with the returned data
     Update(T),
     /// Drop the queue entry
@@ -21,11 +21,18 @@ pub enum QueueFaultBehavior<T> {
     Delay(Duration),
 }
 
+#[derive(MeshPayload)]
+/// A buildable fault configuration for the controller management interface (cc.en(), csts.rdy(), ... )
+pub struct ControllerManagementFaultConfig {
+    /// Fault to apply to cc.en() bit during enablement
+    pub controller_management_fault_enable: FaultBehaviour<bool>,
+}
+
 #[derive(MeshPayload, Clone)]
 /// A buildable fault configuration
 pub struct AdminQueueFaultConfig {
     /// A map of NVME opcodes to the fault behavior for each. (This would ideally be a `HashMap`, but `mesh` doesn't support that type. Given that this is not performance sensitive, the lookup is okay)
-    pub admin_submission_queue_faults: Vec<(u8, QueueFaultBehavior<Command>)>,
+    pub admin_submission_queue_faults: Vec<(u8, FaultBehaviour<Command>)>,
 }
 
 #[derive(MeshPayload, Clone)]
@@ -35,6 +42,26 @@ pub struct FaultConfiguration {
     pub fault_active: Cell<bool>,
     /// Fault to apply to the admin queues
     pub admin_fault: AdminQueueFaultConfig,
+    /// Fault to apply to management layer of the controller
+    pub controller_management_fault: ControllerManagementFaultConfig,
+}
+
+impl ControllerManagementFaultConfig {
+    /// Create a new no-op fault configuration
+    pub fn new() -> Self {
+        Self {
+            controller_management_fault_enable: FaultBehaviour::Default,
+        }
+    }
+
+    /// Create a new fault configuration
+    pub fn with_controller_management_enable_fault(
+        mut self,
+        behaviour: FaultBehaviour<bool>,
+    ) -> Self {
+        self.controller_management_fault_enable = behaviour;
+        self
+    }
 }
 
 impl AdminQueueFaultConfig {
@@ -49,7 +76,7 @@ impl AdminQueueFaultConfig {
     pub fn with_submission_queue_fault(
         mut self,
         opcode: u8,
-        behaviour: QueueFaultBehavior<Command>,
+        behaviour: FaultBehaviour<Command>,
     ) -> Self {
         if self
             .admin_submission_queue_faults

vm/devices/storage/nvme_test/src/pci.rs

@@ -59,6 +59,8 @@ pub struct NvmeFaultController {
     qe_sizes: Arc<Mutex<IoQueueEntrySizes>>,
     #[inspect(flatten, mut)]
     workers: NvmeWorkers,
+    #[inspect(skip)]
+    fault_configuration: FaultConfiguration,
 }
 
 #[derive(Inspect)]
@@ -341,6 +343,9 @@ impl NvmeFaultController {
 
         if cc.en() != self.registers.cc.en() {
             if cc.en() {
+                // If any, perform the fault at the beginning of the enable sequence.
+                if 
+
                 // Some drivers will write zeros to IOSQES and IOCQES, assuming that the defaults will work.
                 if cc.iocqes() == 0 {
                     cc.set_iocqes(IOCQES);
@@ -384,6 +389,8 @@ impl NvmeFaultController {
             }
         }
 
+
+
         self.registers.cc = cc;
         *self.qe_sizes.lock() = IoQueueEntrySizes {
             sqe_bits: cc.iosqes(),

vm/devices/storage/nvme_test/src/tests/controller_tests.rs

@@ -17,8 +17,9 @@ use guestmem::GuestMemory;
 use guid::Guid;
 use mesh::CellUpdater;
 use nvme_resources::fault::AdminQueueFaultConfig;
+use nvme_resources::fault::ControllerManagementFaultConfig;
+use nvme_resources::fault::FaultBehaviour;
 use nvme_resources::fault::FaultConfiguration;
-use nvme_resources::fault::QueueFaultBehavior;
 use nvme_spec::Command;
 use nvme_spec::Completion;
 use pal_async::DefaultDriver;
@@ -208,6 +209,7 @@ async fn test_basic_registers(driver: DefaultDriver) {
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let mut nvmec = instantiate_controller(driver, &gm, None, fault_configuration);
     let mut dword = 0u32;
@@ -236,6 +238,7 @@ async fn test_invalid_configuration(driver: DefaultDriver) {
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let mut nvmec = instantiate_controller(driver, &gm, None, fault_configuration);
     let mut dword = 0u32;
@@ -254,6 +257,7 @@ async fn test_enable_controller(driver: DefaultDriver) {
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let mut nvmec = instantiate_controller(driver, &gm, None, fault_configuration);
 
@@ -285,6 +289,7 @@ async fn test_multi_page_admin_queues(driver: DefaultDriver) {
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let mut nvmec = instantiate_controller(driver, &gm, None, fault_configuration);
 
@@ -359,6 +364,7 @@ async fn test_send_identify_no_fault(driver: DefaultDriver) {
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let cqe = send_identify(driver, fault_configuration).await;
 
@@ -374,8 +380,9 @@ async fn test_send_identify_with_sq_fault(driver: DefaultDriver) {
         fault_active: CellUpdater::new(true).cell(),
         admin_fault: AdminQueueFaultConfig::new().with_submission_queue_fault(
             nvme_spec::AdminOpcode::IDENTIFY.0,
-            QueueFaultBehavior::Update(faulty_identify),
+            FaultBehaviour::Update(faulty_identify),
         ),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     };
     let cqe = send_identify(driver, fault_configuration).await;
 

vm/devices/storage/nvme_test/src/tests/shadow_doorbell_tests.rs

@@ -14,6 +14,7 @@ use crate::tests::test_helpers::write_command_to_queue;
 use guestmem::GuestMemory;
 use mesh::CellUpdater;
 use nvme_resources::fault::AdminQueueFaultConfig;
+use nvme_resources::fault::ControllerManagementFaultConfig;
 use nvme_resources::fault::FaultConfiguration;
 use pal_async::DefaultDriver;
 use pal_async::async_test;
@@ -42,6 +43,7 @@ async fn setup_shadow_doorbells(
     let fault_configuration = FaultConfiguration {
         fault_active: CellUpdater::new(false).cell(),
         admin_fault: AdminQueueFaultConfig::new(),
+        controller_management_fault: ControllerManagementFaultConfig::new(),
     }; // Build a controller with 64 entries in the admin queue (just so that the ASQ fits in one page).
     let mut nvmec = instantiate_and_build_admin_queue(
         cq_buf,

vm/devices/storage/nvme_test/src/workers/admin.rs

@@ -32,7 +32,7 @@ use guestmem::GuestMemory;
 use guid::Guid;
 use inspect::Inspect;
 use nvme_resources::fault::FaultConfiguration;
-use nvme_resources::fault::QueueFaultBehavior;
+use nvme_resources::fault::FaultBehaviour;
 use pal_async::task::Spawn;
 use pal_async::task::Task;
 use pal_async::timer::PolledTimer;
@@ -478,28 +478,28 @@ impl AdminHandler {
                         .iter()
                         .find(|(op, _)| *op == opcode.0)
                         .map(|(_, behavior)| *behavior)
-                        .unwrap_or_else(|| QueueFaultBehavior::Default);
+                        .unwrap_or_else(|| FaultBehaviour::Default);
 
                     match fault {
-                        QueueFaultBehavior::Update(command_updated) => {
+                        FaultBehaviour::Update(command_updated) => {
                             tracing::warn!(
                                 "configured fault: admin command updated in sq. original: {:?},\n new: {:?}",
                                 &command,
                                 &command_updated
                             );
                             command = command_updated;
                         }
-                        QueueFaultBehavior::Drop => {
+                        FaultBehaviour::Drop => {
                             tracing::warn!(
                                 "configured fault: admin command dropped from sq {:?}",
                                 &command
                             );
                             return Ok(());
                         }
-                        QueueFaultBehavior::Delay(duration) => {
+                        FaultBehaviour::Delay(duration) => {
                             self.timer.sleep(duration).await;
                         }
-                        QueueFaultBehavior::Default => {}
+                        FaultBehaviour::Default => {}
                     }
                 }
 

vmm_tests/vmm_tests/tests/tests/multiarch/openhcl_servicing.rs

@@ -16,7 +16,7 @@ use nvme_resources::NamespaceDefinition;
 use nvme_resources::NvmeFaultControllerHandle;
 use nvme_resources::fault::AdminQueueFaultConfig;
 use nvme_resources::fault::FaultConfiguration;
-use nvme_resources::fault::QueueFaultBehavior;
+use nvme_resources::fault::FaultBehaviour;
 use petri::OpenHclServicingFlags;
 use petri::PetriVmBuilder;
 use petri::PetriVmmBackend;
@@ -256,7 +256,7 @@ async fn keepalive_with_nvme_fault(
         fault_active: fault_start_updater.cell(),
         admin_fault: AdminQueueFaultConfig::new().with_submission_queue_fault(
             nvme_spec::AdminOpcode::CREATE_IO_COMPLETION_QUEUE.0,
-            QueueFaultBehavior::Drop,
+            FaultBehaviour::Drop,
         ),
     };