Cleanup warnings

Author: johnramsden

nvme/src/info.rs

@@ -231,7 +231,9 @@ pub fn get_zone_capacity(fd: RawFd, nsid: u32) -> Result<LogicalBlock, NVMeError
 
 /// Returns the zone capacity for the given NVMe device and namespace.
 pub fn get_zone_state(fd: RawFd, nsid: u32, zone: Zone) -> Result<ZoneState, NVMeError> {
-    Ok(report_zones_all(fd, nsid)?.1[zone as usize].zone_state.clone())
+    Ok(report_zones_all(fd, nsid)?.1[zone as usize]
+        .zone_state
+        .clone())
 }
 
 /// Returns a report of all zones for the given NVMe device and namespace.

oxcache/src/bin/spclient.rs

@@ -53,16 +53,16 @@ struct Cli {
 
 #[derive(Debug, Clone)]
 struct TraceEntry {
-    device: String,
+    _device: String,
     lba: u64,
     size: u64,
-    rw: String,
-    timestamp: String,
+    _rw: String,
+    _timestamp: String,
 }
 
 #[derive(Debug, Clone)]
 struct QuantizedRequest {
-    original_lba: u64,
+    _original_lba: u64,
     chunk_key: String,
     offset: u64,
     size: u64,
@@ -118,11 +118,11 @@ fn parse_trace(path: &str) -> Result<Vec<TraceEntry>, Box<dyn std::error::Error>
                     continue;
                 }
                 entries.push(TraceEntry {
-                    device: fields[0].to_string(),
+                    _device: fields[0].to_string(),
                     lba,
                     size,
-                    rw: fields[3].to_string(),
-                    timestamp: fields[4].to_string(),
+                    _rw: fields[3].to_string(),
+                    _timestamp: fields[4].to_string(),
                 });
             }
             _ => {
@@ -185,7 +185,7 @@ fn quantize_request(entry: &TraceEntry, chunk_size: u64) -> Vec<QuantizedRequest
         let chunk_key = format!("chunk_{}", chunk_num);
 
         results.push(QuantizedRequest {
-            original_lba: aligned_lba,
+            _original_lba: aligned_lba,
             chunk_key,
             offset: offset_in_chunk,
             size: request_size,
@@ -571,11 +571,11 @@ mod tests {
     #[test]
     fn test_quantize_single_chunk() {
         let entry = TraceEntry {
-            device: "dev0".to_string(),
+            _device: "dev0".to_string(),
             lba: 0,
             size: 4096,
-            rw: "R".to_string(),
-            timestamp: "0".to_string(),
+            _rw: "R".to_string(),
+            _timestamp: "0".to_string(),
         };
 
         let result = quantize_request(&entry, 65536);
@@ -588,11 +588,11 @@ mod tests {
     #[test]
     fn test_quantize_spanning_chunks() {
         let entry = TraceEntry {
-            device: "dev0".to_string(),
+            _device: "dev0".to_string(),
             lba: 4096,
             size: 20480,
-            rw: "R".to_string(),
-            timestamp: "0".to_string(),
+            _rw: "R".to_string(),
+            _timestamp: "0".to_string(),
         };
 
         let result = quantize_request(&entry, 8192);
@@ -617,11 +617,11 @@ mod tests {
     #[test]
     fn test_quantize_unaligned() {
         let entry = TraceEntry {
-            device: "dev0".to_string(),
+            _device: "dev0".to_string(),
             lba: 100,
             size: 100,
-            rw: "R".to_string(),
-            timestamp: "0".to_string(),
+            _rw: "R".to_string(),
+            _timestamp: "0".to_string(),
         };
 
         let result = quantize_request(&entry, 8192);
@@ -635,11 +635,11 @@ mod tests {
     #[test]
     fn test_quantize_chunk_boundary() {
         let entry = TraceEntry {
-            device: "dev0".to_string(),
+            _device: "dev0".to_string(),
             lba: 8192,
             size: 16384,
-            rw: "R".to_string(),
-            timestamp: "0".to_string(),
+            _rw: "R".to_string(),
+            _timestamp: "0".to_string(),
         };
 
         let result = quantize_request(&entry, 8192);

oxcache/src/server.rs

@@ -518,7 +518,10 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
                                 let start = Arc::clone(&start);
                                 let request_offset = request_offset;
                                 let request_size = request_size;
+
+                                #[cfg(debug_assertions)]
                                 let request_uuid = request_uuid.clone();
+
                                 move |data_source| async move {
                                     match data_source {
                                         DataSource::Ram(buffer_data) => {
@@ -580,7 +583,7 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
 
                                             tracing::debug!("REQ[{}] Waiting for read response", request_id);
                                             let recv_err = rx.recv_async().await;
-                                            let (header, data) = match recv_err {
+                                            let (_header, data) = match recv_err {
                                                 Ok(wr) => {
                                                     tracing::debug!("REQ[{}] Received read response from reader pool", request_id);
                                                     match wr.data {
@@ -599,7 +602,7 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
 
                                             // Validate read response
                                             #[cfg(debug_assertions)]
-                                            validate_read_response(&header, &request_uuid, 0, chunk_size);
+                                            validate_read_response(&_header, &request_uuid, 0, chunk_size);
 
                                             let chunked_resp = data;
 
@@ -642,7 +645,10 @@ async fn handle_connection<T: RemoteBackend + Send + Sync + 'static>(
                                 let start = Arc::clone(&start);
                                 let request_offset = request_offset;
                                 let request_size = request_size;
+
+                                #[cfg(debug_assertions)]
                                 let request_uuid = request_uuid.clone();
+
                                 move |buffer_ref, notify_ref| async move {
                                     tracing::debug!("REQ[{}] CACHE MISS - entering remote fetch path", request_id);
                                     let resp = match remote.get(request_uuid.as_str(), 0, chunk_size).await {

oxcache/src/zone_state/zone_list.rs

@@ -1,5 +1,8 @@
+#[cfg(debug_assertions)]
 use nvme::info::report_zones_all;
-use nvme::types::{Chunk, ZoneState};
+#[cfg(debug_assertions)]
+use nvme::types::ZoneState;
+use nvme::types::Chunk;
 
 use crate::cache::bucket::ChunkLocation;
 use crate::device;
@@ -599,6 +602,7 @@ impl ZoneList {
     }
 
     /// Makes sure that the zone list is consistent with itself.
+    #[cfg(debug_assertions)]
     fn check_invariants(&self) {
         // free_zones & open are unique and dont share elems
         {