net: Give the user the ability to set MTU

Add a new "mtu" parameter to the NetConfig structure and therefore to
the --net option. This allows Cloud Hypervisor's users to define the
Maximum Transmission Unit (MTU) they want to use for the network
interface that they create.

In details, there are two main aspects. On the one hand, the TAP
interface is created with the proper MTU if it is provided. And on the
other hand the guest is made aware of the MTU through the VIRTIO
configuration. That means the MTU is properly set on both the TAP on the
host and the network interface in the guest.

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>

net_util/src/lib.rs

@@ -131,17 +131,19 @@ pub fn build_net_config_space(
     config: &mut VirtioNetConfig,
     mac: MacAddr,
     num_queues: usize,
+    mtu: Option<u16>,
     avail_features: &mut u64,
 ) {
     config.mac.copy_from_slice(mac.get_bytes());
     *avail_features |= 1 << VIRTIO_NET_F_MAC;
 
-    build_net_config_space_with_mq(config, num_queues, avail_features);
+    build_net_config_space_with_mq(config, num_queues, mtu, avail_features);
 }
 
 pub fn build_net_config_space_with_mq(
     config: &mut VirtioNetConfig,
     num_queues: usize,
+    mtu: Option<u16>,
     avail_features: &mut u64,
 ) {
     let num_queue_pairs = (num_queues / 2) as u16;
@@ -151,6 +153,9 @@ pub fn build_net_config_space_with_mq(
         config.max_virtqueue_pairs = num_queue_pairs;
         *avail_features |= 1 << VIRTIO_NET_F_MQ;
     }
+    if let Some(mtu) = mtu {
+        config.mtu = mtu;
+    }
 }
 
 pub fn virtio_features_to_tap_offload(features: u64) -> c_uint {

net_util/src/open_tap.rs

@@ -30,6 +30,8 @@ pub enum Error {
     TapGetMac(TapError),
     #[error("Setting vnet header size failed: {0}")]
     TapSetVnetHdrSize(TapError),
+    #[error("Setting MTU failed: {0}")]
+    TapSetMtu(TapError),
     #[error("Enabling tap interface failed: {0}")]
     TapEnable(TapError),
 }
@@ -63,6 +65,7 @@ pub fn open_tap(
     ip_addr: Option<Ipv4Addr>,
     netmask: Option<Ipv4Addr>,
     host_mac: &mut Option<MacAddr>,
+    mtu: Option<u16>,
     num_rx_q: usize,
     flags: Option<i32>,
 ) -> Result<Vec<Tap>> {
@@ -95,6 +98,9 @@ pub fn open_tap(
             } else {
                 *host_mac = Some(tap.get_mac_addr().map_err(Error::TapGetMac)?)
             }
+            if let Some(mtu) = mtu {
+                tap.set_mtu(mtu as i32).map_err(Error::TapSetMtu)?;
+            }
             tap.enable().map_err(Error::TapEnable)?;
 
             tap.set_vnet_hdr_size(vnet_hdr_size)

net_util/src/tap.rs

@@ -297,6 +297,37 @@ impl Tap {
         Ok(())
     }
 
+    pub fn mtu(&self) -> Result<i32> {
+        let sock = create_unix_socket().map_err(Error::NetUtil)?;
+
+        let ifreq = self.get_ifreq();
+
+        // ioctl is safe. Called with a valid sock fd, and we check the return.
+        let ret = unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCGIFMTU as c_ulong, &ifreq) };
+        if ret < 0 {
+            return Err(Error::IoctlError(IoError::last_os_error()));
+        }
+
+        let mtu = unsafe { ifreq.ifr_ifru.ifru_mtu };
+
+        Ok(mtu)
+    }
+
+    pub fn set_mtu(&self, mtu: i32) -> Result<()> {
+        let sock = create_unix_socket().map_err(Error::NetUtil)?;
+
+        let mut ifreq = self.get_ifreq();
+        ifreq.ifr_ifru.ifru_mtu = mtu;
+
+        // ioctl is safe. Called with a valid sock fd, and we check the return.
+        let ret = unsafe { ioctl_with_ref(&sock, net_gen::sockios::SIOCSIFMTU as c_ulong, &ifreq) };
+        if ret < 0 {
+            return Err(Error::IoctlError(IoError::last_os_error()));
+        }
+
+        Ok(())
+    }
+
     /// Set the offload flags for the tap interface.
     pub fn set_offload(&self, flags: c_uint) -> Result<()> {
         // ioctl is safe. Called with a valid tap fd, and we check the return.