virtio_blk: negotiate virtio feature for RO disk

In order to mark a virtio block device as read only,
we need to negotiate the VIRTIO_BLK_F_RO feature
as per virtio 1.0 spec.

Signed-off-by: Diana Popa <[email protected]>

Author: dianpopa

devices/src/virtio/block.rs

@@ -18,6 +18,7 @@ use super::{DescriptorChain, Queue, VirtioDevice, INTERRUPT_STATUS_USED_RING, TY
 use sys_util::Result as SysResult;
 use sys_util::{EventFd, GuestAddress, GuestMemory, GuestMemoryError};
 use virtio_sys::virtio_blk::*;
+use virtio_sys::virtio_config::*;
 
 const SECTOR_SHIFT: u8 = 9;
 const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
@@ -313,6 +314,8 @@ impl EpollConfig {
 pub struct Block {
     kill_evt: Option<EventFd>,
     disk_image: Option<File>,
+    avail_features: u64,
+    acked_features: u64,
     config_space: Vec<u8>,
     epoll_config: EpollConfig,
 }
@@ -333,7 +336,11 @@ impl Block {
     /// Create a new virtio block device that operates on the given file.
     ///
     /// The given file must be seekable and sizable.
-    pub fn new(mut disk_image: File, epoll_config: EpollConfig) -> SysResult<Block> {
+    pub fn new(
+        mut disk_image: File,
+        is_disk_read_only: bool,
+        epoll_config: EpollConfig,
+    ) -> SysResult<Block> {
         let disk_size = disk_image.seek(SeekFrom::End(0))? as u64;
         if disk_size % SECTOR_SIZE != 0 {
             warn!(
@@ -342,9 +349,18 @@ impl Block {
                 disk_size, SECTOR_SIZE
             );
         }
+
+        let mut avail_features = 1 << VIRTIO_F_VERSION_1;
+
+        if is_disk_read_only {
+            avail_features |= 1 << VIRTIO_BLK_F_RO;
+        };
+
         Ok(Block {
             kill_evt: None,
             disk_image: Some(disk_image),
+            avail_features,
+            acked_features: 0u64,
             config_space: build_config_space(disk_size),
             epoll_config,
         })
@@ -369,6 +385,46 @@ impl VirtioDevice for Block {
         QUEUE_SIZES
     }
 
+    fn features(&self, page: u32) -> u32 {
+        match page {
+            // Get the lower 32-bits of the features bitfield.
+            0 => self.avail_features as u32,
+            // Get the upper 32-bits of the features bitfield.
+            1 => (self.avail_features >> 32) as u32,
+            _ => {
+                warn!(
+                    "block: virtio-block got request for features page: {}",
+                    page
+                );
+                0u32
+            }
+        }
+    }
+
+    fn ack_features(&mut self, page: u32, value: u32) {
+        let mut v = match page {
+            0 => value as u64,
+            1 => (value as u64) << 32,
+            _ => {
+                warn!(
+                    "block: virtio-block device cannot ack unknown feature page: {}",
+                    page
+                );
+                0u64
+            }
+        };
+
+        // Check if the guest is ACK'ing a feature that we didn't claim to have.
+        let unrequested_features = v & !self.avail_features;
+        if unrequested_features != 0 {
+            warn!("block: virtio-block got unknown feature ack: {:x}", v);
+
+            // Don't count these features as acked.
+            v &= !unrequested_features;
+        }
+        self.acked_features |= v;
+    }
+
     fn read_config(&self, offset: u64, mut data: &mut [u8]) {
         let config_len = self.config_space.len() as u64;
         if offset >= config_len {
@@ -504,7 +560,7 @@ mod tests {
             f.set_len(0x1000).unwrap();
 
             DummyBlock {
-                block: Block::new(f, epoll_config).unwrap(),
+                block: Block::new(f, false, epoll_config).unwrap(),
                 epoll_raw_fd,
                 _receiver,
             }

vmm/src/lib.rs

@@ -417,16 +417,19 @@ impl Vmm {
 
             let epoll_context = &mut self.epoll_context;
             for drive_config in self.block_device_configs.config_list.iter() {
-                // adding root blk device from file (currently always opened as read + write)
+                // adding root blk device from file
                 let root_image = OpenOptions::new()
                     .read(true)
                     .write(!drive_config.is_read_only)
                     .open(&drive_config.path_on_host)
                     .map_err(Error::RootDiskImage)?;
                 let epoll_config = epoll_context.allocate_virtio_block_tokens();
 
-                let block_box = Box::new(devices::virtio::Block::new(root_image, epoll_config)
-                    .map_err(Error::RootBlockDeviceNew)?);
+                let block_box = Box::new(devices::virtio::Block::new(
+                    root_image,
+                    drive_config.is_read_only,
+                    epoll_config,
+                ).map_err(Error::RootBlockDeviceNew)?);
                 device_manager
                     .register_mmio(block_box, &mut kernel_config.cmdline)
                     .map_err(Error::RegisterBlock)?;