Block device live resize

Added support for resizing of block devices (as in: detecting the new
size and updating the block device) after the VM has booted.

See also: https://sim.amazon.com/issues/P12874968

Fixes #211

Signed-off-by: Alexandra Ghecenco <[email protected]>

Author: Alexandra Ghecenco

api_server/src/request/sync/drive.rs

@@ -36,6 +36,8 @@ pub enum DriveError {
     RootBlockDeviceAlreadyAdded,
     InvalidBlockDevicePath,
     BlockDevicePathAlreadyExists,
+    BlockDeviceUpdateFailed,
+    BlockDeviceUpdateNotAllowed,
     NotImplemented,
 }
 
@@ -55,9 +57,17 @@ impl GenerateResponse for DriveError {
                 StatusCode::BadRequest,
                 json_fault_message("The block device path was already added to a different drive!"),
             ),
+            BlockDeviceUpdateFailed => json_response(
+                StatusCode::InternalServerError,
+                json_fault_message("The update operation failed!"),
+            ),
+            BlockDeviceUpdateNotAllowed => json_response(
+                StatusCode::Forbidden,
+                json_fault_message("The update operation is not allowed!"),
+            ),
             NotImplemented => json_response(
                 StatusCode::InternalServerError,
-                json_fault_message("The update operation is not implemented!"),
+                json_fault_message("The operation is not implemented!"),
             ),
         }
     }
@@ -133,6 +143,18 @@ mod tests {
                 .status(),
             StatusCode::BadRequest
         );
+        assert_eq!(
+            DriveError::BlockDeviceUpdateFailed
+                .generate_response()
+                .status(),
+            StatusCode::InternalServerError
+        );
+        assert_eq!(
+            DriveError::BlockDeviceUpdateNotAllowed
+                .generate_response()
+                .status(),
+            StatusCode::Forbidden
+        );
         assert_eq!(
             DriveError::NotImplemented.generate_response().status(),
             StatusCode::InternalServerError

devices/src/bus.rs

@@ -19,6 +19,8 @@ pub trait BusDevice: Send {
     fn read(&mut self, offset: u64, data: &mut [u8]) {}
     /// Writes at `offset` into this device
     fn write(&mut self, offset: u64, data: &[u8]) {}
+    /// Triggers the `irq_mask` interrupt on this device
+    fn interrupt(&self, irq_mask: u32) {}
 }
 
 #[derive(Debug)]
@@ -79,7 +81,7 @@ impl Bus {
         None
     }
 
-    fn get_device(&self, addr: u64) -> Option<(u64, &Mutex<BusDevice>)> {
+    pub fn get_device(&self, addr: u64) -> Option<(u64, &Mutex<BusDevice>)> {
         if let Some((BusRange(start, len), dev)) = self.first_before(addr) {
             let offset = addr - start;
             if offset < len {

devices/src/virtio/block.rs

@@ -14,14 +14,14 @@ use std::sync::mpsc;
 use {DeviceEventT, EpollHandler};
 use super::{ActivateError, ActivateResult};
 use epoll;
-use super::{DescriptorChain, Queue, VirtioDevice, INTERRUPT_STATUS_USED_RING, TYPE_BLOCK};
+use super::{DescriptorChain, Queue, VirtioDevice, TYPE_BLOCK, VIRTIO_MMIO_INT_VRING};
 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;
+pub const SECTOR_SIZE: u64 = 0x01 << SECTOR_SHIFT;
 const QUEUE_SIZE: u16 = 256;
 const NUM_QUEUES: usize = 1;
 const QUEUE_SIZES: &'static [u16] = &[QUEUE_SIZE];
@@ -256,7 +256,7 @@ impl BlockEpollHandler {
 
     fn signal_used_queue(&self) {
         self.interrupt_status
-            .fetch_or(INTERRUPT_STATUS_USED_RING as usize, Ordering::SeqCst);
+            .fetch_or(VIRTIO_MMIO_INT_VRING as usize, Ordering::SeqCst);
         self.interrupt_evt.write(1).unwrap();
     }
 
@@ -320,7 +320,7 @@ pub struct Block {
     epoll_config: EpollConfig,
 }
 
-fn build_config_space(disk_size: u64) -> Vec<u8> {
+pub fn build_config_space(disk_size: u64) -> Vec<u8> {
     // We only support disk size, which uses the first two words of the configuration space.
     // If the image is not a multiple of the sector size, the tail bits are not exposed.
     // The config space is little endian.
@@ -437,6 +437,17 @@ impl VirtioDevice for Block {
         }
     }
 
+    fn write_config(&mut self, offset: u64, data: &[u8]) {
+        let data_len = data.len() as u64;
+        let config_len = self.config_space.len() as u64;
+        if offset + data_len > config_len {
+            warn!("block: failed to write config space");
+            return;
+        }
+        let (_, right) = self.config_space.split_at_mut(offset as usize);
+        right.copy_from_slice(&data[..]);
+    }
+
     fn activate(
         &mut self,
         mem: GuestMemory,
@@ -773,6 +784,18 @@ mod tests {
         let result = b.activate(m.clone(), ievt, stat, queues, queue_evts);
 
         assert!(result.is_ok());
+
+        // test write config
+        let new_config: [u8; 8] = [0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        b.write_config(0, &new_config);
+        let mut new_config_read = [0u8; 8];
+        b.read_config(0, &mut new_config_read);
+        assert_eq!(new_config, new_config_read);
+        // invalid write
+        b.write_config(5, &new_config);
+        new_config_read = [0u8; 8];
+        b.read_config(0, &mut new_config_read);
+        assert_eq!(new_config, new_config_read);
     }
 
     fn invoke_handler(h: &mut BlockEpollHandler, e: DeviceEventT) {

devices/src/virtio/mmio.rs

@@ -268,12 +268,12 @@ impl BusDevice for MmioDevice {
         }
 
         if !self.device_activated && self.is_driver_ready() && self.are_queues_valid() {
-            if let Some(interrupt_evt) = self.interrupt_evt.take() {
+            if let Some(ref interrupt_evt) = self.interrupt_evt {
                 if let Some(mem) = self.mem.take() {
                     self.device
                         .activate(
                             mem,
-                            interrupt_evt,
+                            interrupt_evt.try_clone().unwrap(),
                             self.interrupt_status.clone(),
                             self.queues.clone(),
                             self.queue_evts.split_off(0),
@@ -284,6 +284,15 @@ impl BusDevice for MmioDevice {
             }
         }
     }
+
+    fn interrupt(&self, irq_mask: u32) {
+        self.interrupt_status
+            .fetch_or(irq_mask as usize, Ordering::SeqCst);
+        // interrupt_evt() is safe to unwrap because the inner interrupt_evt is initialized in the
+        // constructor.
+        // write() is safe to unwrap because the inner syscall is tailored to be safe as well.
+        self.interrupt_evt().unwrap().write(1).unwrap();
+    }
 }
 
 #[cfg(test)]

devices/src/virtio/mod.rs

@@ -23,11 +23,14 @@ const DEVICE_DRIVER_OK: u32 = 0x04;
 const DEVICE_FEATURES_OK: u32 = 0x08;
 const DEVICE_FAILED: u32 = 0x80;
 
-// Types taken from linux/virtio_ids.h
+/// Types taken from linux/virtio_ids.h.
 const TYPE_NET: u32 = 1;
 const TYPE_BLOCK: u32 = 2;
 
-const INTERRUPT_STATUS_USED_RING: u32 = 0x1;
+/// Interrupt flags (re: interrupt status & acknowledge registers).
+/// See linux/virtio_mmio.h.
+pub const VIRTIO_MMIO_INT_VRING: u32 = 0x01;
+pub const VIRTIO_MMIO_INT_CONFIG: u32 = 0x02;
 
 /// Offset from the base MMIO address of a virtio device used by the guest to notify the device of
 /// queue events.

devices/src/virtio/net.rs

@@ -20,7 +20,7 @@ use super::{ActivateError, ActivateResult};
 use epoll;
 use net_util::{MacAddr, Tap, TapError, MAC_ADDR_LEN};
 use net_sys;
-use super::{Queue, VirtioDevice, INTERRUPT_STATUS_USED_RING, TYPE_NET};
+use super::{Queue, VirtioDevice, TYPE_NET, VIRTIO_MMIO_INT_VRING};
 use sys_util::{Error as SysError, EventFd, GuestMemory};
 use virtio_sys::virtio_net::*;
 use virtio_sys::virtio_config::*;
@@ -85,7 +85,7 @@ struct NetEpollHandler {
 impl NetEpollHandler {
     fn signal_used_queue(&self) {
         self.interrupt_status
-            .fetch_or(INTERRUPT_STATUS_USED_RING as usize, Ordering::SeqCst);
+            .fetch_or(VIRTIO_MMIO_INT_VRING as usize, Ordering::SeqCst);
         self.interrupt_evt.write(1).unwrap();
     }
 

sys_util/src/tempdir.rs

@@ -21,7 +21,7 @@ pub struct TempDir {
 }
 
 impl TempDir {
-    /// Creates a new tempory directory.
+    /// Creates a new temporary directory.
     /// The directory will be removed when the object goes out of scope.
     ///
     /// # Examples

vmm/src/device_config/drive.rs

@@ -83,7 +83,7 @@ impl BlockDeviceConfigs {
         }
 
         // check whether the Device Config belongs to a root device
-        // we need to satify the condition by which a VMM can only have on root device
+        // we need to satisfy the condition by which a VMM can only have on root device
         if block_device_config.is_root_device {
             if self.has_root_block {
                 return Err(DriveError::RootBlockDeviceAlreadyAdded);

vmm/src/device_manager/mmio.rs

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+use std::collections::HashMap;
 use std::fmt;
 use std::sync::{Arc, Mutex};
 
@@ -25,6 +26,8 @@ pub enum Error {
     Cmdline(kernel_cmdline::Error),
     /// No more IRQs are available.
     IrqsExhausted,
+    /// Failed to update the mmio device.
+    UpdateFailed,
 }
 
 impl fmt::Display for Error {
@@ -37,6 +40,7 @@ impl fmt::Display for Error {
                 write!(f, "unable to add device to kernel command line: {}", e)
             }
             &Error::IrqsExhausted => write!(f, "no more IRQs are available"),
+            &Error::UpdateFailed => write!(f, "failed to update the mmio device"),
         }
     }
 }
@@ -54,13 +58,18 @@ const IRQ_BASE: u32 = 5;
 /// Currently hardcoded to 4K
 const MMIO_LEN: u64 = 0x1000;
 
+/// This represents the offset at which the device should call BusDevice::write in order to write
+/// to its configuration space.
+const MMIO_CFG_SPACE_OFF: u64 = 0x100;
+
 /// Manages the complexities of adding a device.
 pub struct MMIODeviceManager {
     pub bus: devices::Bus,
     pub vm_requests: Vec<VmRequest>,
     guest_mem: GuestMemory,
     mmio_base: u64,
     irq: u32,
+    id_to_addr_map: HashMap<String, u64>,
 }
 
 impl MMIODeviceManager {
@@ -72,6 +81,7 @@ impl MMIODeviceManager {
             mmio_base: mmio_base,
             irq: IRQ_BASE,
             bus: devices::Bus::new(),
+            id_to_addr_map: HashMap::new(),
         }
     }
 
@@ -80,7 +90,8 @@ impl MMIODeviceManager {
         &mut self,
         device: Box<devices::virtio::VirtioDevice>,
         cmdline: &mut kernel_cmdline::Cmdline,
-    ) -> Result<()> {
+        id: Option<String>,
+    ) -> Result<u64> {
         if self.irq > MAX_IRQ {
             return Err(Error::IrqsExhausted);
         }
@@ -111,17 +122,43 @@ impl MMIODeviceManager {
         // as per doc, [virtio_mmio.]device=<size>@<baseaddr>:<irq> needs to be appended
         // to kernel commandline for virtio mmio devices to get recognized
         // the size parameter has to be transformed to KiB, so dividing hexadecimal value in
-        // bytes to 1024; further, the '{}' formatting rust construct will automatically transform it to decimal
+        // bytes to 1024; further, the '{}' formatting rust construct will automatically
+        // transform it to decimal
         cmdline
             .insert(
                 "virtio_mmio.device",
                 &format!("{}K@0x{:08x}:{}", MMIO_LEN / 1024, self.mmio_base, self.irq),
             )
             .map_err(Error::Cmdline)?;
+        let ret = self.mmio_base;
         self.mmio_base += MMIO_LEN;
         self.irq += 1;
 
-        Ok(())
+        if let Some(device_id) = id {
+            self.id_to_addr_map.insert(device_id.clone(), ret);
+        }
+
+        Ok(ret)
+    }
+
+    /// Update a drive by rebuilding its config space and rewriting it on the bus.
+    pub fn update_drive(&self, addr: u64, new_size: u64) -> Result<()> {
+        if let Some((_, device)) = self.bus.get_device(addr) {
+            let data = devices::virtio::build_config_space(new_size);
+            let mut busdev = device.lock().unwrap();
+
+            busdev.write(MMIO_CFG_SPACE_OFF, &data[..]);
+            busdev.interrupt(devices::virtio::VIRTIO_MMIO_INT_CONFIG);
+
+            Ok(())
+        } else {
+            Err(Error::UpdateFailed)
+        }
+    }
+
+    /// Gets the address of the specified device on the bus.
+    pub fn get_address(&self, id: &String) -> Option<&u64> {
+        return self.id_to_addr_map.get(id.as_str());
     }
 }
 
@@ -176,7 +213,7 @@ mod tests {
 
         assert!(
             device_manager
-                .register_device(dummy_box, &mut cmdline)
+                .register_device(dummy_box, &mut cmdline, None)
                 .is_ok()
         );
     }
@@ -193,14 +230,14 @@ mod tests {
         let dummy_box = Box::new(DummyDevice { dummy: 0 });
         for _i in IRQ_BASE..(MAX_IRQ + 1) {
             device_manager
-                .register_device(dummy_box.clone(), &mut cmdline)
+                .register_device(dummy_box.clone(), &mut cmdline, None)
                 .unwrap();
         }
         assert_eq!(
             format!(
                 "{}",
                 device_manager
-                    .register_device(dummy_box.clone(), &mut cmdline)
+                    .register_device(dummy_box.clone(), &mut cmdline, None)
                     .unwrap_err()
             ),
             "no more IRQs are available".to_string()
@@ -251,5 +288,43 @@ mod tests {
         assert_eq!(format!("{}", e), "failed to clone ioeventfd: Error(0)");
         let e = Error::CloneIrqFd(sys_util::Error::new(0));
         assert_eq!(format!("{}", e), "failed to clone irqfd: Error(0)");
+        let e = Error::UpdateFailed;
+        assert_eq!(format!("{}", e), "failed to update the mmio device");
+    }
+
+    #[test]
+    fn test_update_drive() {
+        let start_addr1 = GuestAddress(0x0);
+        let start_addr2 = GuestAddress(0x1000);
+        let guest_mem =
+            GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
+        let mut device_manager = MMIODeviceManager::new(guest_mem, 0xd0000000);
+        let mut cmdline = kernel_cmdline::Cmdline::new(4096);
+        let dummy_box = Box::new(DummyDevice { dummy: 0 });
+
+        if let Ok(addr) =
+            device_manager.register_device(dummy_box, &mut cmdline, Some(String::from("foo")))
+        {
+            assert!(device_manager.update_drive(addr, 1048576).is_ok());
+        }
+        assert!(device_manager.update_drive(0xbeef, 1048576).is_err());
+    }
+
+    #[test]
+    fn test_get_address() {
+        let start_addr1 = GuestAddress(0x0);
+        let start_addr2 = GuestAddress(0x1000);
+        let guest_mem =
+            GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
+        let mut device_manager = MMIODeviceManager::new(guest_mem, 0xd0000000);
+        let mut cmdline = kernel_cmdline::Cmdline::new(4096);
+        let dummy_box = Box::new(DummyDevice { dummy: 0 });
+
+        let id = String::from("foo");
+        if let Ok(addr) = device_manager.register_device(dummy_box, &mut cmdline, Some(id.clone()))
+        {
+            assert_eq!(Some(&addr), device_manager.get_address(&id));
+        }
+        assert_eq!(None, device_manager.get_address(&String::from("bar")));
     }
 }