vhost 0.16.0

// Copyright (C) 2021 Alibaba Cloud Computing. All rights reserved.
// SPDX-License-Identifier: Apache-2.0 or BSD-3-Clause

//! Kernel-based vhost-net backend

use std::fs::{File, OpenOptions};
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::{AsRawFd, RawFd};

use vm_memory::GuestAddressSpace;
use vmm_sys_util::ioctl::ioctl_with_ref;

use super::vhost_binding::*;
use super::{ioctl_result, Error, Result, VhostKernBackend};

use crate::net::*;

const VHOST_NET_PATH: &str = "/dev/vhost-net";

/// Handle for running VHOST_NET ioctls
pub struct Net<AS: GuestAddressSpace> {
    fd: File,
    mem: AS,
}

impl<AS: GuestAddressSpace> Net<AS> {
    /// Open a handle to a new VHOST-NET instance.
    pub fn new(mem: AS) -> Result<Self> {
        Ok(Net {
            fd: OpenOptions::new()
                .read(true)
                .write(true)
                .custom_flags(libc::O_CLOEXEC | libc::O_NONBLOCK)
                .open(VHOST_NET_PATH)
                .map_err(Error::VhostOpen)?,
            mem,
        })
    }
}

impl<AS: GuestAddressSpace> VhostNet for Net<AS> {
    fn set_backend(&self, queue_index: usize, fd: Option<&File>) -> Result<()> {
        let vring_file = vhost_vring_file {
            index: queue_index as u32,
            fd: fd.map_or(-1, |v| v.as_raw_fd()),
        };

        // SAFETY: Safe because the vhost-net fd is valid and we check the return value
        let ret = unsafe { ioctl_with_ref(self, VHOST_NET_SET_BACKEND(), &vring_file) };
        ioctl_result(ret, ())
    }
}

impl<AS: GuestAddressSpace> VhostKernBackend for Net<AS> {
    type AS = AS;

    fn mem(&self) -> &Self::AS {
        &self.mem
    }
}

impl<AS: GuestAddressSpace> AsRawFd for Net<AS> {
    fn as_raw_fd(&self) -> RawFd {
        self.fd.as_raw_fd()
    }
}

#[cfg(test)]
mod tests {
    use vm_memory::{GuestAddress, GuestMemory, GuestMemoryMmap};
    use vmm_sys_util::eventfd::EventFd;

    use super::*;
    use crate::{
        VhostBackend, VhostUserDirtyLogRegion, VhostUserMemoryRegionInfo, VringConfigData,
    };
    use serial_test::serial;

    #[test]
    #[serial]
    fn test_net_new_device() {
        let m = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10_0000)]).unwrap();
        let net = Net::new(&m).unwrap();

        assert!(net.as_raw_fd() >= 0);
        assert!(net.mem().find_region(GuestAddress(0x100)).is_some());
        assert!(net.mem().find_region(GuestAddress(0x10_0000)).is_none());
    }

    #[test]
    #[serial]
    fn test_net_is_valid() {
        let m = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10_0000)]).unwrap();
        let net = Net::new(&m).unwrap();

        let mut config = VringConfigData {
            queue_max_size: 32,
            queue_size: 32,
            flags: 0,
            desc_table_addr: 0x1000,
            used_ring_addr: 0x2000,
            avail_ring_addr: 0x3000,
            log_addr: None,
        };
        assert!(net.is_valid(&config));

        config.queue_size = 0;
        assert!(!net.is_valid(&config));
        config.queue_size = 31;
        assert!(!net.is_valid(&config));
        config.queue_size = 33;
        assert!(!net.is_valid(&config));
    }

    #[test]
    #[serial]
    fn test_net_ioctls() {
        let m = GuestMemoryMmap::<()>::from_ranges(&[(GuestAddress(0), 0x10_0000)]).unwrap();
        let net = Net::new(&m).unwrap();
        let backend = OpenOptions::new()
            .read(true)
            .write(true)
            .open("/dev/null")
            .unwrap();

        let features = net.get_features().unwrap();
        net.set_features(features).unwrap();

        net.set_owner().unwrap();

        net.set_mem_table(&[]).unwrap_err();

        let region = VhostUserMemoryRegionInfo::new(
            0x0,
            0x10_0000,
            m.get_host_address(GuestAddress(0x0)).unwrap() as u64,
            0,
            -1,
        );
        net.set_mem_table(&[region]).unwrap();

        net.set_log_base(
            0x4000,
            Some(VhostUserDirtyLogRegion {
                mmap_size: 0x1000,
                mmap_offset: 0x10,
                mmap_handle: 1,
            }),
        )
        .unwrap_err();
        net.set_log_base(0x4000, None).unwrap();

        let eventfd = EventFd::new(0).unwrap();
        net.set_log_fd(eventfd.as_raw_fd()).unwrap();

        net.set_vring_num(0, 32).unwrap();

        let config = VringConfigData {
            queue_max_size: 32,
            queue_size: 32,
            flags: 0,
            desc_table_addr: 0x1000,
            used_ring_addr: 0x2000,
            avail_ring_addr: 0x3000,
            log_addr: None,
        };
        net.set_vring_addr(0, &config).unwrap();
        net.set_vring_base(0, 1).unwrap();
        net.set_vring_call(0, &eventfd).unwrap();
        net.set_vring_kick(0, &eventfd).unwrap();
        net.set_vring_err(0, &eventfd).unwrap();
        assert_eq!(net.get_vring_base(0).unwrap(), 1);

        net.set_backend(0, Some(&backend)).unwrap_err();
        net.set_backend(0, None).unwrap();
    }
}