Method process_queue

virtio-devices/src/pmem.rs:170–211

(&mut self)

impl PmemEpollHandler {
    fn process_queue(&mut self) -> result::Result<bool, Error> {
        let mut used_descs = false;
        while let Some(mut desc_chain) = self.queue.pop_descriptor_chain(self.mem.memory()) {
            let len = match Request::parse(&mut desc_chain, self.access_platform.as_deref()) {
                Ok(ref req) => {
                    let status_code = match req.type_ {
                        RequestType::Flush => match self.disk.sync_all() {
                            Ok(()) => VIRTIO_PMEM_RESP_TYPE_OK,
                            Err(e) => {
                                error!("Failed flushing disk image: {e}");
                                VIRTIO_PMEM_RESP_TYPE_EIO
                            }
                        },
                        RequestType::Unknown(t) => {
                            warn!("Unknown request type: {t}");
                            VIRTIO_PMEM_RESP_TYPE_EIO
                        }
                    };

                    let resp = VirtioPmemResp { ret: status_code };
                    match desc_chain.memory().write_obj(resp, req.status_addr) {
                        Ok(_) => size_of::<VirtioPmemResp>() as u32,
                        Err(e) => {
                            error!("bad guest memory address: {e}");
                            0
                        }
                    }
                }
                Err(e) => {
                    error!("Failed to parse available descriptor chain: {e:?}");
                    0
                }
            };

            self.queue
                .add_used(desc_chain.memory(), desc_chain.head_index(), len)
                .map_err(Error::QueueAddUsed)?;
            used_descs = true;
        }

        Ok(used_descs)
    }

    fn signal_used_queue(&self) -> result::Result<(), DeviceError> {
        self.interrupt_cb