alioth/src/virtio/queue/queue.rs - a0deb75

queue.rs100.00%

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
pub mod packed;
pub mod split;
 
use std::collections::HashMap;
use std::fmt::Debug;
use std::io::{ErrorKind, IoSlice, IoSliceMut, Read, Write};
use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU64, Ordering, fence};
 
use crate::bitflags;
use crate::mem::mapped::Ram;
use crate::virtio::{IrqSender, Result, error};
 
pub const QUEUE_SIZE_MAX: u16 = 256;
 
bitflags! {
    pub struct DescFlag(u16) {
        NEXT = 1 << 0;
        WRITE = 1 << 1;
        INDIRECT = 1 << 2;
        AVAIL = 1 << 7;
        USED = 1 << 15;
    }
}
 
#[derive(Debug, Default)]
pub struct QueueReg {
    pub size: AtomicU16,
    pub desc: AtomicU64,
    pub driver: AtomicU64,
    pub device: AtomicU64,
    pub enabled: AtomicBool,
}
 
#[derive(Debug)]
pub struct DescChain<'m> {
    id: u16,
    delta: u16,
    pub readable: Vec<IoSlice<'m>>,
    pub writable: Vec<IoSliceMut<'m>>,
}
 
impl DescChain<'_> {
    pub fn id(&self) -> u16 {6x
        self.id6x
    }6x
}
 
pub trait VirtQueue<'m> {
    type Index: Clone + Copy;
    const INIT_INDEX: Self::Index;
    fn desc_avail(&self, index: Self::Index) -> bool;
    fn get_avail(&self, index: Self::Index, ram: &'m Ram) -> Result<Option<DescChain<'m>>>;
    fn set_used(&self, index: Self::Index, id: u16, len: u32);
    fn enable_notification(&self, enabled: bool);
    fn interrupt_enabled(&self, index: Self::Index, delta: u16) -> bool;
    fn index_add(&self, index: Self::Index, delta: u16) -> Self::Index;
}
 
#[derive(Debug)]
pub enum Status {
    Done { len: u32 },
    Deferred,
    Break,
}
 
pub struct Queue<'r, 'm, Q>
where
    Q: VirtQueue<'m>,
{
    q: Q,
    avail: Q::Index,
    used: Q::Index,
    reg: &'r QueueReg,
    ram: &'m Ram,
    deferred: HashMap<u16, DescChain<'m>>,
}
 
impl<'r, 'm, Q> Queue<'r, 'm, Q>
where
    Q: VirtQueue<'m>,
{
    pub fn new(q: Q, reg: &'r QueueReg, ram: &'m Ram) -> Self {21x
        Self {21x
            q,21x
            avail: Q::INIT_INDEX,21x
            used: Q::INIT_INDEX,21x
            reg,21x
            ram,21x
            deferred: HashMap::new(),21x
        }21x
    }21x
 
    pub fn reg(&self) -> &QueueReg {3x
        self.reg3x
    }3x
 
    fn push_used(&mut self, chain: DescChain, len: u32) {57x
        self.q.set_used(self.used, chain.id, len);57x
        self.used = self.q.index_add(self.used, chain.delta);57x
    }57x
 
    pub fn handle_deferred(9x
        &mut self,9x
        id: u16,9x
        q_index: u16,9x
        irq_sender: &impl IrqSender,9x
        mut op: impl FnMut(&mut DescChain) -> Result<u32>,9x
    ) -> Result<()> {9x
        let Some(mut chain) = self.deferred.remove(&id) else {9x
            return error::InvalidDescriptor { id }.fail();3x
        };
        let len = op(&mut chain)?;6x
        let delta = chain.delta;6x
        self.push_used(chain, len);6x
        if self.q.interrupt_enabled(self.used, delta) {6x
            irq_sender.queue_irq(q_index);6x
        }6x
        Ok(())6x
    }9x
 
    pub fn handle_desc(93x
        &mut self,93x
        q_index: u16,93x
        irq_sender: &impl IrqSender,93x
        mut op: impl FnMut(&mut DescChain) -> Result<Status>,93x
    ) -> Result<()> {93x
        let mut send_irq = false;93x
        let mut ret = Ok(());93x
        'out: loop {
            if !self.q.desc_avail(self.avail) {147x
                break;75x
            }72x
            self.q.enable_notification(false);72x
            while let Some(mut chain) = self.q.get_avail(self.avail, self.ram)? {129x
                let delta = chain.delta;75x
                match op(&mut chain) {75x
                    Err(e) => {6x
                        ret = Err(e);6x
                        self.q.enable_notification(true);6x
                        break 'out;6x
                    }
                    Ok(Status::Break) => break 'out,12x
                    Ok(Status::Done { len }) => {51x
                        self.push_used(chain, len);51x
                        send_irq = send_irq || self.q.interrupt_enabled(self.used, delta);51x
                    }
                    Ok(Status::Deferred) => {6x
                        self.deferred.insert(chain.id, chain);6x
                    }6x
                }
                self.avail = self.q.index_add(self.avail, delta);57x
            }
            self.q.enable_notification(true);54x
            fence(Ordering::SeqCst);54x
        }
        if send_irq {93x
            fence(Ordering::SeqCst);51x
            irq_sender.queue_irq(q_index);51x
        }51x
        ret93x
    }93x
}
 
pub fn copy_from_reader(mut reader: impl Read) -> impl FnMut(&mut DescChain) -> Result<Status> {36x
    move |chain| {27x
        let ret = reader.read_vectored(&mut chain.writable);27x
        match ret {6x
            Ok(0) => {
                let size: usize = chain.writable.iter().map(|s| s.len()).sum();6x
                if size == 0 {6x
                    Ok(Status::Done { len: 0 })3x
                } else {
                    Ok(Status::Break)3x
                }
            }
            Ok(len) => Ok(Status::Done { len: len as u32 }),15x
            Err(e) if e.kind() == ErrorKind::WouldBlock => Ok(Status::Break),6x
            Err(e) => Err(e.into()),3x
        }
    }27x
}36x
 
pub fn copy_to_writer(mut writer: impl Write) -> impl FnMut(&mut DescChain) -> Result<Status> {27x
    move |chain| {21x
        let ret = writer.write_vectored(&chain.readable);21x
        match ret {6x
            Ok(0) => {
                let size: usize = chain.readable.iter().map(|s| s.len()).sum();6x
                if size == 0 {6x
                    Ok(Status::Done { len: 0 })3x
                } else {
                    Ok(Status::Break)3x
                }
            }
            Ok(_) => Ok(Status::Done { len: 0 }),9x
            Err(e) if e.kind() == ErrorKind::WouldBlock => Ok(Status::Break),6x
            Err(e) => Err(e.into()),3x
        }
    }21x
}27x
 
#[cfg(test)]
#[path = "queue_test.rs"]
pub(in crate::virtio) mod tests;
 