Skip to content
GitLab
Select Git revision
  • main default
Find file BlameHistoryPermalink
blk.rs 9.80 KiB
1 
use super::*;
2 
use crate::header::VirtIOHeader;
3 
use crate::queue::VirtQueue;
4 
use _core::sync::atomic::{fence, Ordering};
5 
use bitflags::*;
6 
use core::hint::spin_loop;
7 
use log::*;
8 
use volatile::Volatile;
9
10 
/// The virtio block device is a simple virtual block device (ie. disk).
11 
///
12 
/// Read and write requests (and other exotic requests) are placed in the queue,
13 
/// and serviced (probably out of order) by the device except where noted.
14 
pub struct VirtIOBlk<'a, H: Hal> {
15 
    header: &'static mut VirtIOHeader,
16 
    queue: VirtQueue<'a, H>,
17 
    capacity: usize,
18 
}
19
20 
impl<H: Hal> VirtIOBlk<'_, H> {
21 
    /// Create a new VirtIO-Blk driver.
22 
    pub fn new(header: &'static mut VirtIOHeader) -> Result<Self> {
23 
        header.begin_init(|features| {
24 
            let features = BlkFeature::from_bits_truncate(features);
25 
            info!("device features: {:?}", features);
26 
            // negotiate these flags only
27 
            let supported_features = BlkFeature::empty();
28 
            (features & supported_features).bits()
29 
        });
30
31 
        // read configuration space
32 
        let config = unsafe { &mut *(header.config_space() as *mut BlkConfig) };
33 
        info!("config: {:?}", config);
34 
        info!(
35 
            "found a block device of size {}KB",
36 
            config.capacity.read() / 2
37 
        );
38
39 
        let queue = VirtQueue::new(header, 0, 16)?;
40 
        header.finish_init();
41
42 
        Ok(VirtIOBlk {
43 
            header,
44 
            queue,
45 
            capacity: config.capacity.read() as usize,
46 
        })
47 
    }
48
49 
    /// Acknowledge interrupt.
50 
    pub fn ack_interrupt(&mut self) -> bool {
51 
        self.header.ack_interrupt()
52 
    }
53
54 
    /// Read a block.
55 
    pub fn read_block(&mut self, block_id: usize, buf: &mut [u8]) -> Result {
56 
        assert_eq!(buf.len(), BLK_SIZE);
57 
        let req = BlkReq {
58 
            type_: ReqType::In,
59 
            reserved: 0,
60 
            sector: block_id as u64,
61 
        };
62 
        let mut resp = BlkResp::default();
63 
        self.queue.add(&[req.as_buf()], &[buf, resp.as_buf_mut()])?;
64 
        self.header.notify(0);
65 
        while !self.queue.can_pop() {
66 
            spin_loop();
67 
        }
68 
        self.queue.pop_used()?;
69 
        fence(Ordering::SeqCst);
70 
        match resp.status {
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
RespStatus::Ok => Ok(()), _ => Err(Error::IoError), } } /// Read a block in a non-blocking way which means that it returns immediately. /// /// # Arguments /// /// * `block_id` - The identifier of the block to read. /// * `buf` - The buffer in the memory which the block is read into. /// * `resp` - A mutable reference to a variable provided by the caller /// which contains the status of the requests. The caller can safely /// read the variable only after the request is ready. /// /// # Usage /// /// It will submit request to the virtio block device and return a token identifying /// the position of the first Descriptor in the chain. If there are not enough /// Descriptors to allocate, then it returns [Error::BufferTooSmall]. /// /// After the request is ready, `resp` will be updated and the caller can get the /// status of the request(e.g. succeed or failed) through it. However, the caller /// **must not** spin on `resp` to wait for it to change. A safe way is to read it /// after the same token as this method returns is fetched through [VirtIOBlk::pop_used()], /// which means that the request has been ready. /// /// # Safety /// /// `buf` is still borrowed by the underlying virtio block device even if this /// method returns. Thus, it is the caller's responsibility to guarantee that /// `buf` is not accessed before the request is completed in order to avoid /// data races. pub unsafe fn read_block_nb( &mut self, block_id: usize, buf: &mut [u8], resp: &mut BlkResp, ) -> Result<u16> { assert_eq!(buf.len(), BLK_SIZE); let req = BlkReq { type_: ReqType::In, reserved: 0, sector: block_id as u64, }; let token = self.queue.add(&[req.as_buf()], &[buf, resp.as_buf_mut()])?; self.header.notify(0); Ok(token) } /// Write a block. pub fn write_block(&mut self, block_id: usize, buf: &[u8]) -> Result { assert_eq!(buf.len(), BLK_SIZE); let req = BlkReq { type_: ReqType::Out, reserved: 0, sector: block_id as u64, }; let mut resp = BlkResp::default(); self.queue.add(&[req.as_buf(), buf], &[resp.as_buf_mut()])?; self.header.notify(0); while !self.queue.can_pop() { spin_loop(); } self.queue.pop_used()?; match resp.status { RespStatus::Ok => Ok(()), _ => Err(Error::IoError), } }
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
//// Write a block in a non-blocking way which means that it returns immediately. /// /// # Arguments /// /// * `block_id` - The identifier of the block to write. /// * `buf` - The buffer in the memory containing the data to write to the block. /// * `resp` - A mutable reference to a variable provided by the caller /// which contains the status of the requests. The caller can safely /// read the variable only after the request is ready. /// /// # Usage /// /// See also [VirtIOBlk::read_block_nb()]. /// /// # Safety /// /// See also [VirtIOBlk::read_block_nb()]. pub unsafe fn write_block_nb( &mut self, block_id: usize, buf: &[u8], resp: &mut BlkResp, ) -> Result<u16> { assert_eq!(buf.len(), BLK_SIZE); let req = BlkReq { type_: ReqType::Out, reserved: 0, sector: block_id as u64, }; let token = self.queue.add(&[req.as_buf(), buf], &[resp.as_buf_mut()])?; self.header.notify(0); Ok(token) } /// During an interrupt, it fetches a token of a completed request from the used /// ring and return it. If all completed requests have already been fetched, return /// Err(Error::NotReady). pub fn pop_used(&mut self) -> Result<u16> { self.queue.pop_used().map(|p| p.0) } /// Return size of its VirtQueue. /// It can be used to tell the caller how many channels he should monitor on. pub fn virt_queue_size(&self) -> u16 { self.queue.size() } } #[repr(C)] #[derive(Debug)] struct BlkConfig { /// Number of 512 Bytes sectors capacity: Volatile<u64>, size_max: Volatile<u32>, seg_max: Volatile<u32>, cylinders: Volatile<u16>, heads: Volatile<u8>, sectors: Volatile<u8>, blk_size: Volatile<u32>, physical_block_exp: Volatile<u8>, alignment_offset: Volatile<u8>, min_io_size: Volatile<u16>, opt_io_size: Volatile<u32>, // ... ignored } #[repr(C)] #[derive(Debug)] struct BlkReq {