[DRAFT] nvme_driver: fix overflow computing queue size and don't wait for bad devices forever

vm/devices/storage/disk_nvme/nvme_driver/Cargo.toml

@@ -6,6 +6,10 @@ name = "nvme_driver"
 edition = "2021"
 rust-version.workspace = true
 
+[features]
+# Reduced timeouts for faster fuzzing
+fuzz_timeout = []
+
 [dependencies]
 inspect = { workspace = true, features = ["defer"] }
 inspect_counters.workspace = true

vm/devices/storage/disk_nvme/nvme_driver/fuzz/Cargo.toml

@@ -16,7 +16,7 @@ guestmem.workspace = true
 guid.workspace = true
 inspect.workspace = true
 nvme.workspace = true
-nvme_driver.workspace = true
+nvme_driver = { workspace = true, features = ["fuzz_timeout"] }
 nvme_spec.workspace = true
 pal_async.workspace = true
 parking_lot.workspace = true

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

@@ -399,8 +399,8 @@ impl<T: DeviceBacking> NvmeDriver<T> {
         let max_io_queues = allocated_io_queue_count.min(requested_io_queue_count);
 
         let qsize = {
-            let io_cqsize = QueuePair::MAX_CQ_ENTRIES.min(worker.registers.cap.mqes_z() + 1);
-            let io_sqsize = QueuePair::MAX_SQ_ENTRIES.min(worker.registers.cap.mqes_z() + 1);
+            let io_cqsize = QueuePair::MAX_CQ_ENTRIES.min(worker.registers.cap.mqes_z().saturating_add(1));
+            let io_sqsize = QueuePair::MAX_SQ_ENTRIES.min(worker.registers.cap.mqes_z().saturating_add(1));
 
             // Some hardware (such as ASAP) require that the sq and cq have the same size.
             io_cqsize.min(io_sqsize)

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

@@ -8,6 +8,8 @@ use inspect::Inspect;
 use pal_async::driver::Driver;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering::Relaxed;
+use std::time::Duration;
+use std::time::Instant;
 use tracing::instrument;
 use user_driver::backoff::Backoff;
 use user_driver::DeviceBacking;
@@ -108,6 +110,14 @@ impl<T: DeviceRegisterIo + Inspect> Bar0<T> {
         let cc = self.cc().with_en(false);
         self.set_cc(cc);
         let mut backoff = Backoff::new(driver);
+        let timeout_duration = self.cap().to() as u64 * 500;
+        #[cfg(feature="fuzz_timeout")]
+        {
+            timeout_duration = 10; 
+        }
+        let start = Instant::now();
+        let timeout = Duration::from_millis(timeout_duration);
+
         loop {
             let csts = self.csts();
             if !csts.rdy() {
@@ -116,6 +126,9 @@ impl<T: DeviceRegisterIo + Inspect> Bar0<T> {
             if u32::from(csts) == !0 {
                 break false;
             }
+            if start.elapsed() >= timeout {
+                break false;
+            }
             backoff.back_off().await;
         }
     }