refactor(queue): remove mem from pop method

`mem` parameter was not used for anything.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

src/vmm/benches/block_request.rs

@@ -24,7 +24,7 @@ pub fn block_request_benchmark(c: &mut Criterion) {
     chain.set_header(request_header);
 
     let mut queue = virt_queue.create_queue();
-    let desc = queue.pop(&mem).unwrap();
+    let desc = queue.pop().unwrap();
 
     c.bench_function("request_parse", |b| {
         b.iter(|| {

src/vmm/benches/queue.rs

@@ -61,7 +61,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
 
     set_dtable_one_chain(&rxq, 1);
     queue.next_avail = Wrapping(0);
-    let desc = queue.pop(&mem).unwrap();
+    let desc = queue.pop().unwrap();
     c.bench_function("next_descriptor_1", |b| {
         b.iter(|| {
             let mut head = Some(desc.clone());
@@ -73,7 +73,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
 
     set_dtable_one_chain(&rxq, 2);
     queue.next_avail = Wrapping(0);
-    let desc = queue.pop(&mem).unwrap();
+    let desc = queue.pop().unwrap();
     c.bench_function("next_descriptor_2", |b| {
         b.iter(|| {
             let mut head = Some(desc.clone());
@@ -85,7 +85,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
 
     set_dtable_one_chain(&rxq, 4);
     queue.next_avail = Wrapping(0);
-    let desc = queue.pop(&mem).unwrap();
+    let desc = queue.pop().unwrap();
     c.bench_function("next_descriptor_4", |b| {
         b.iter(|| {
             let mut head = Some(desc.clone());
@@ -97,7 +97,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
 
     set_dtable_one_chain(&rxq, 16);
     queue.next_avail = Wrapping(0);
-    let desc = queue.pop(&mem).unwrap();
+    let desc = queue.pop().unwrap();
     c.bench_function("next_descriptor_16", |b| {
         b.iter(|| {
             let mut head = Some(desc.clone());
@@ -113,7 +113,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
     c.bench_function("queue_pop_1", |b| {
         b.iter(|| {
             queue.next_avail = Wrapping(0);
-            while let Some(desc) = queue.pop(&mem) {
+            while let Some(desc) = queue.pop() {
                 std::hint::black_box(desc);
             }
         })
@@ -123,7 +123,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
     c.bench_function("queue_pop_4", |b| {
         b.iter(|| {
             queue.next_avail = Wrapping(0);
-            while let Some(desc) = queue.pop(&mem) {
+            while let Some(desc) = queue.pop() {
                 std::hint::black_box(desc);
             }
         })
@@ -133,7 +133,7 @@ pub fn queue_benchmark(c: &mut Criterion) {
     c.bench_function("queue_pop_16", |b| {
         b.iter(|| {
             queue.next_avail = Wrapping(0);
-            while let Some(desc) = queue.pop(&mem) {
+            while let Some(desc) = queue.pop() {
                 std::hint::black_box(desc);
             }
         })

src/vmm/src/devices/virtio/balloon/device.rs

@@ -297,7 +297,7 @@ impl Balloon {
             // Internal loop processes descriptors and acummulates the pfns in `pfn_buffer`.
             // Breaks out when there is not enough space in `pfn_buffer` to completely process
             // the next descriptor.
-            while let Some(head) = queue.pop(mem) {
+            while let Some(head) = queue.pop() {
                 let len = head.len as usize;
                 let max_len = MAX_PAGES_IN_DESC * SIZE_OF_U32;
                 valid_descs_found = true;
@@ -370,14 +370,12 @@ impl Balloon {
     }
 
     pub(crate) fn process_deflate_queue(&mut self) -> Result<(), BalloonError> {
-        // This is safe since we checked in the event handler that the device is activated.
-        let mem = self.device_state.mem().unwrap();
         METRICS.deflate_count.inc();
 
         let queue = &mut self.queues[DEFLATE_INDEX];
         let mut needs_interrupt = false;
 
-        while let Some(head) = queue.pop(mem) {
+        while let Some(head) = queue.pop() {
             queue.add_used(head.index, 0).map_err(BalloonError::Queue)?;
             needs_interrupt = true;
         }
@@ -394,7 +392,7 @@ impl Balloon {
         let mem = self.device_state.mem().unwrap();
         METRICS.stats_updates_count.inc();
 
-        while let Some(head) = self.queues[STATS_INDEX].pop(mem) {
+        while let Some(head) = self.queues[STATS_INDEX].pop() {
             if let Some(prev_stats_desc) = self.stats_desc_index {
                 // We shouldn't ever have an extra buffer if the driver follows
                 // the protocol, but return it if we find one.

src/vmm/src/devices/virtio/block/virtio/request.rs

@@ -473,16 +473,15 @@ mod tests {
             let memory = self.driver_queue.memory();
 
             assert!(matches!(
-                Request::parse(&q.pop(memory).unwrap(), memory, NUM_DISK_SECTORS),
+                Request::parse(&q.pop().unwrap(), memory, NUM_DISK_SECTORS),
                 Err(_e)
             ));
         }
 
         fn check_parse(&self, check_data: bool) {
             let mut q = self.driver_queue.create_queue();
             let memory = self.driver_queue.memory();
-            let request =
-                Request::parse(&q.pop(memory).unwrap(), memory, NUM_DISK_SECTORS).unwrap();
+            let request = Request::parse(&q.pop().unwrap(), memory, NUM_DISK_SECTORS).unwrap();
             let expected_header = self.header();
 
             assert_eq!(
@@ -949,7 +948,7 @@ mod tests {
     fn parse_random_requests() {
         let cfg = ProptestConfig::with_cases(1000);
         proptest!(cfg, |(mut request in random_request_parse())| {
-            let result = Request::parse(&request.2.pop(&request.1).unwrap(), &request.1, NUM_DISK_SECTORS);
+            let result = Request::parse(&request.2.pop().unwrap(), &request.1, NUM_DISK_SECTORS);
             match result {
                 Ok(r) => prop_assert!(r == request.0.unwrap()),
                 Err(err) => {

src/vmm/src/devices/virtio/iovec.rs

@@ -490,22 +490,22 @@ mod tests {
     fn test_access_mode() {
         let mem = default_mem();
         let (mut q, _) = read_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
         // SAFETY: This descriptor chain is only loaded into one buffer
         unsafe { IoVecBuffer::from_descriptor_chain(&mem, head).unwrap() };
 
         let (mut q, _) = write_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
         // SAFETY: This descriptor chain is only loaded into one buffer
         unsafe { IoVecBuffer::from_descriptor_chain(&mem, head).unwrap_err() };
 
         let (mut q, _) = read_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
         // SAFETY: This descriptor chain is only loaded into one buffer
         unsafe { IoVecBufferMut::from_descriptor_chain(&mem, head).unwrap_err() };
 
         let (mut q, _) = write_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
         // SAFETY: This descriptor chain is only loaded into one buffer
         unsafe { IoVecBufferMut::from_descriptor_chain(&mem, head).unwrap() };
     }
@@ -514,7 +514,7 @@ mod tests {
     fn test_iovec_length() {
         let mem = default_mem();
         let (mut q, _) = read_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
 
         // SAFETY: This descriptor chain is only loaded once in this test
         let iovec = unsafe { IoVecBuffer::from_descriptor_chain(&mem, head).unwrap() };
@@ -525,7 +525,7 @@ mod tests {
     fn test_iovec_mut_length() {
         let mem = default_mem();
         let (mut q, _) = write_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
 
         // SAFETY: This descriptor chain is only loaded once in this test
         let iovec = unsafe { IoVecBufferMut::from_descriptor_chain(&mem, head).unwrap() };
@@ -536,7 +536,7 @@ mod tests {
     fn test_iovec_read_at() {
         let mem = default_mem();
         let (mut q, _) = read_only_chain(&mem);
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
 
         // SAFETY: This descriptor chain is only loaded once in this test
         let iovec = unsafe { IoVecBuffer::from_descriptor_chain(&mem, head).unwrap() };
@@ -591,7 +591,7 @@ mod tests {
         let (mut q, vq) = write_only_chain(&mem);
 
         // This is a descriptor chain with 4 elements 64 bytes long each.
-        let head = q.pop(&mem).unwrap();
+        let head = q.pop().unwrap();
 
         // SAFETY: This descriptor chain is only loaded into one buffer
         let mut iovec = unsafe { IoVecBufferMut::from_descriptor_chain(&mem, head).unwrap() };

src/vmm/src/devices/virtio/queue.rs

@@ -500,9 +500,7 @@ impl Queue {
     }
 
     /// Pop the first available descriptor chain from the avail ring.
-    pub fn pop<M: GuestMemory>(&mut self, mem: &M) -> Option<DescriptorChain> {
-        debug_assert!(self.is_valid(mem));
-
+    pub fn pop(&mut self) -> Option<DescriptorChain> {
         let len = self.len();
         // The number of descriptor chain heads to process should always
         // be smaller or equal to the queue size, as the driver should
@@ -531,10 +529,10 @@ impl Queue {
     /// If no descriptor is available, enable notifications.
     pub fn pop_or_enable_notification<M: GuestMemory>(
         &mut self,
-        mem: &M,
+        _mem: &M,
     ) -> Option<DescriptorChain> {
         if !self.uses_notif_suppression {
-            return self.pop(mem);
+            return self.pop();
         }
 
         if self.try_enable_notification() {
@@ -1087,7 +1085,7 @@ mod verification {
     #[kani::unwind(0)]
     #[kani::solver(cadical)]
     fn verify_pop() {
-        let ProofContext(mut queue, mem) = ProofContext::bounded_queue();
+        let ProofContext(mut queue, _) = ProofContext::bounded_queue();
 
         // This is an assertion in pop which we use to abort firecracker in a ddos scenario
         // This condition being false means that the guest is asking us to process every element
@@ -1099,7 +1097,7 @@ mod verification {
 
         let next_avail = queue.next_avail;
 
-        if let Some(_) = queue.pop(&mem) {
+        if let Some(_) = queue.pop() {
             // Can't get anything out of an empty queue, assert queue_len != 0
             assert_ne!(queue_len, 0);
             assert_eq!(queue.next_avail, next_avail + Wrapping(1));
@@ -1110,13 +1108,13 @@ mod verification {
     #[kani::unwind(0)]
     #[kani::solver(cadical)]
     fn verify_undo_pop() {
-        let ProofContext(mut queue, mem) = ProofContext::bounded_queue();
+        let ProofContext(mut queue, _) = ProofContext::bounded_queue();
 
         // See verify_pop for explanation
         kani::assume(queue.len() <= queue.actual_size());
 
         let queue_clone = queue.clone();
-        if let Some(_) = queue.pop(&mem) {
+        if let Some(_) = queue.pop() {
             queue.undo_pop();
             assert_eq!(queue, queue_clone);
 
@@ -1322,7 +1320,7 @@ mod tests {
         assert_eq!(q.len(), 2);
 
         // The first chain should hold exactly two descriptors.
-        let d = q.pop(m).unwrap().next_descriptor().unwrap();
+        let d = q.pop().unwrap().next_descriptor().unwrap();
         assert!(!d.has_next());
         assert!(d.next_descriptor().is_none());
 
@@ -1331,7 +1329,7 @@ mod tests {
 
         // The next chain holds three descriptors.
         let d = q
-            .pop(m)
+            .pop()
             .unwrap()
             .next_descriptor()
             .unwrap()
@@ -1342,15 +1340,15 @@ mod tests {
 
         // We've popped both chains, so the queue should be empty.
         assert!(q.is_empty());
-        assert!(q.pop(m).is_none());
+        assert!(q.pop().is_none());
 
         // Undoing the last pop should let us walk the last chain again.
         q.undo_pop();
         assert_eq!(q.len(), 1);
 
         // Walk the last chain again (three descriptors).
         let d = q
-            .pop(m)
+            .pop()
             .unwrap()
             .next_descriptor()
             .unwrap()
@@ -1418,7 +1416,7 @@ mod tests {
         assert_eq!(q.len(), 2);
 
         // We process the first descriptor.
-        let d = q.pop(m).unwrap().next_descriptor();
+        let d = q.pop().unwrap().next_descriptor();
         assert!(matches!(d, Some(x) if !x.has_next()));
         // We confuse the device and set the available index as being 6.
         vq.avail.idx.set(6);
@@ -1429,7 +1427,7 @@ mod tests {
         // However, since the apparent length set by the driver is more than the queue size,
         // we would be running the risk of going through some descriptors more than once.
         // As such, we expect to panic.
-        q.pop(m);
+        q.pop();
     }
 
     #[test]
@@ -1592,7 +1590,7 @@ mod tests {
         assert_eq!(q.avail_event(m), 0);
 
         // Consume the descriptor. avail_event should be modified
-        assert!(q.pop(m).is_some());
+        assert!(q.pop().is_some());
         assert!(q.try_enable_notification());
         assert_eq!(q.avail_event(m), 1);
     }

src/vmm/src/devices/virtio/rng/device.rs

@@ -128,7 +128,7 @@ impl Entropy {
         let mem = self.device_state.mem().unwrap();
 
         let mut used_any = false;
-        while let Some(desc) = self.queues[RNG_QUEUE].pop(mem) {
+        while let Some(desc) = self.queues[RNG_QUEUE].pop() {
             let index = desc.index;
             METRICS.entropy_event_count.inc();
 
@@ -434,15 +434,15 @@ mod tests {
         let mut entropy_dev = th.device();
 
         // This should succeed, we just added two descriptors
-        let desc = entropy_dev.queues_mut()[RNG_QUEUE].pop(&mem).unwrap();
+        let desc = entropy_dev.queues_mut()[RNG_QUEUE].pop().unwrap();
         assert!(matches!(
             // SAFETY: This descriptor chain is only loaded into one buffer
             unsafe { IoVecBufferMut::from_descriptor_chain(&mem, desc) },
             Err(crate::devices::virtio::iovec::IoVecError::ReadOnlyDescriptor)
         ));
 
         // This should succeed, we should have one more descriptor
-        let desc = entropy_dev.queues_mut()[RNG_QUEUE].pop(&mem).unwrap();
+        let desc = entropy_dev.queues_mut()[RNG_QUEUE].pop().unwrap();
         // SAFETY: This descriptor chain is only loaded into one buffer
         let mut iovec = unsafe { IoVecBufferMut::from_descriptor_chain(&mem, desc).unwrap() };
         entropy_dev.handle_one(&mut iovec).unwrap();

src/vmm/src/devices/virtio/vsock/csm/connection.rs

@@ -863,16 +863,12 @@ mod tests {
             let stream = TestStream::new();
             let mut rx_pkt = VsockPacket::from_rx_virtq_head(
                 &vsock_test_ctx.mem,
-                handler_ctx.device.queues[RXQ_INDEX]
-                    .pop(&vsock_test_ctx.mem)
-                    .unwrap(),
+                handler_ctx.device.queues[RXQ_INDEX].pop().unwrap(),
             )
             .unwrap();
             let tx_pkt = VsockPacket::from_tx_virtq_head(
                 &vsock_test_ctx.mem,
-                handler_ctx.device.queues[TXQ_INDEX]
-                    .pop(&vsock_test_ctx.mem)
-                    .unwrap(),
+                handler_ctx.device.queues[TXQ_INDEX].pop().unwrap(),
             )
             .unwrap();
             let conn = match conn_state {

src/vmm/src/devices/virtio/vsock/device.rs

@@ -145,7 +145,7 @@ where
 
         let mut have_used = false;
 
-        while let Some(head) = self.queues[RXQ_INDEX].pop(mem) {
+        while let Some(head) = self.queues[RXQ_INDEX].pop() {
             let index = head.index;
             let used_len = match VsockPacket::from_rx_virtq_head(mem, head) {
                 Ok(mut pkt) => {
@@ -198,7 +198,7 @@ where
 
         let mut have_used = false;
 
-        while let Some(head) = self.queues[TXQ_INDEX].pop(mem) {
+        while let Some(head) = self.queues[TXQ_INDEX].pop() {
             let index = head.index;
             let pkt = match VsockPacket::from_tx_virtq_head(mem, head) {
                 Ok(pkt) => pkt,
@@ -237,7 +237,7 @@ where
         // This is safe since we checked in the caller function that the device is activated.
         let mem = self.device_state.mem().unwrap();
 
-        let head = self.queues[EVQ_INDEX].pop(mem).ok_or_else(|| {
+        let head = self.queues[EVQ_INDEX].pop().ok_or_else(|| {
             METRICS.ev_queue_event_fails.inc();
             DeviceError::VsockError(VsockError::EmptyQueue)
         })?;