This adds a mac= option to crosvm's --tap-fd option. The virtio-net
driver in the guest will read the desired MAC from virtio
configuration space.
See the documentation for VIRTIO_NET_F_MAC in the Virtio spec[1].
[1]: https://docs.oasis-open.org/virtio/virtio/v1.1/virtio-v1.1.html
---
This will be important for host-based networking in Spectrum.
devices/src/virtio/net.rs | 31 ++++++++++++++++---
src/crosvm.rs | 8 +++--
src/linux.rs | 20 +++++++-----
src/main.rs | 64 ++++++++++++++++++++++++++++++---------
4 files changed, 96 insertions(+), 27 deletions(-)
diff --git a/devices/src/virtio/net.rs b/devices/src/virtio/net.rs
index 44a39abd..fe71371f 100644
--- a/devices/src/virtio/net.rs
+++ b/devices/src/virtio/net.rs
@@ -22,7 +22,9 @@ use virtio_sys::virtio_net::{
};
use virtio_sys::{vhost, virtio_net};
-use super::{DescriptorError, Interrupt, Queue, Reader, VirtioDevice, Writer, TYPE_NET};
+use super::{
+ copy_config, DescriptorError, Interrupt, Queue, Reader, VirtioDevice, Writer, TYPE_NET,
+};
const QUEUE_SIZE: u16 = 256;
const NUM_QUEUES: usize = 3;
@@ -373,7 +375,13 @@ where
}
}
+#[derive(Default)]
+pub struct NetOptions {
+ pub guest_mac: Option,
+}
+
pub struct Net {
+ config: Vec<u8>,
workers_kill_evt: Option<EventFd>,
kill_evt: EventFd,
worker_thread: Option>,
@@ -392,6 +400,7 @@ where
ip_addr: Ipv4Addr,
netmask: Ipv4Addr,
mac_addr: MacAddress,
+ options: NetOptions,
) -> Result {
let tap: T = T::new(true).map_err(NetError::TapOpen)?;
tap.set_ip_addr(ip_addr).map_err(NetError::TapSetIp)?;
@@ -401,18 +410,18 @@ where
tap.enable().map_err(NetError::TapEnable)?;
- Net::from(tap)
+ Net::with_tap(tap, options)
}
/// Creates a new virtio network device from a tap device that has already been
/// configured.
- pub fn from(tap: T) -> Result {
+ pub fn with_tap(tap: T, options: NetOptions) -> Result {
// This would also validate a tap created by Self::new(), but that's a good thing as it
// would ensure that any changes in the creation procedure are matched in the validation.
// Plus we still need to set the offload and vnet_hdr_size values.
validate_and_configure_tap(&tap)?;
- let avail_features = 1 << virtio_net::VIRTIO_NET_F_GUEST_CSUM
+ let mut avail_features = 1 << virtio_net::VIRTIO_NET_F_GUEST_CSUM
| 1 << virtio_net::VIRTIO_NET_F_CSUM
| 1 << virtio_net::VIRTIO_NET_F_CTRL_VQ
| 1 << virtio_net::VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
@@ -422,8 +431,18 @@ where
| 1 << virtio_net::VIRTIO_NET_F_HOST_UFO
| 1 << vhost::VIRTIO_F_VERSION_1;
+ if options.guest_mac.is_some() {
+ avail_features |= 1 << virtio_net::VIRTIO_NET_F_MAC;
+ }
+
+ let config = options
+ .guest_mac
+ .map(|mac| mac.octets().to_vec())
+ .unwrap_or_default();
+
let kill_evt = EventFd::new().map_err(NetError::CreateKillEventFd)?;
Ok(Net {
+ config,
workers_kill_evt: Some(kill_evt.try_clone().map_err(NetError::CloneKillEventFd)?),
kill_evt,
worker_thread: None,
@@ -545,6 +564,10 @@ where
}
}
+ fn read_config(&self, offset: u64, data: &mut [u8]) {
+ copy_config(data, 0, self.config.as_slice(), offset);
+ }
+
fn activate(
&mut self,
mem: GuestMemory,
diff --git a/src/crosvm.rs b/src/crosvm.rs
index 81344c32..e69f2dfc 100644
--- a/src/crosvm.rs
+++ b/src/crosvm.rs
@@ -157,6 +157,10 @@ impl Default for SharedDir {
}
}
+pub struct TapFdOptions {
+ pub mac: Option,
+}
+
/// Aggregate of all configurable options for a running VM.
pub struct Config {
pub vcpu_count: Option<u32>,
@@ -177,7 +181,7 @@ pub struct Config {
pub netmask: Optionnet::Ipv4Addr,
pub mac_address: Option,
pub vhost_net: bool,
- pub tap_fd: Vec<RawFd>,
+ pub tap_fd: BTreeMap,
pub cid: Option<u64>,
pub wayland_socket_paths: BTreeMap,
pub wayland_dmabuf: bool,
@@ -224,7 +228,7 @@ impl Default for Config {
netmask: None,
mac_address: None,
vhost_net: false,
- tap_fd: Vec::new(),
+ tap_fd: BTreeMap::new(),
cid: None,
#[cfg(feature = "gpu")]
gpu_parameters: None,
diff --git a/src/linux.rs b/src/linux.rs
index 3370c1e1..f7f78ad2 100644
--- a/src/linux.rs
+++ b/src/linux.rs
@@ -60,7 +60,9 @@ use vm_control::{
VmMemoryRequest, VmMemoryResponse, VmRunMode,
};
-use crate::{Config, DiskOption, Executable, SharedDir, SharedDirKind, TouchDeviceOption};
+use crate::{
+ Config, DiskOption, Executable, SharedDir, SharedDirKind, TapFdOptions, TouchDeviceOption,
+};
use arch::{self, LinuxArch, RunnableLinuxVm, VirtioDeviceStub, VmComponents, VmImage};
#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
@@ -586,14 +588,18 @@ fn create_balloon_device(cfg: &Config, socket: BalloonControlResponseSocket) ->
})
}
-fn create_tap_net_device(cfg: &Config, tap_fd: RawFd) -> DeviceResult {
+fn create_tap_net_device(cfg: &Config, tap_fd: RawFd, options: &TapFdOptions) -> DeviceResult {
// Safe because we ensure that we get a unique handle to the fd.
let tap = unsafe {
Tap::from_raw_fd(validate_raw_fd(tap_fd).map_err(Error::ValidateRawFd)?)
.map_err(Error::CreateTapDevice)?
};
- let dev = virtio::Net::from(tap).map_err(Error::NetDeviceNew)?;
+ let net_opts = virtio::NetOptions {
+ guest_mac: options.mac,
+ };
+
+ let dev = virtio::Net::with_tap(tap, net_opts).map_err(Error::NetDeviceNew)?;
Ok(VirtioDeviceStub {
dev: Box::new(dev),
@@ -614,8 +620,8 @@ fn create_net_device(
.map_err(Error::VhostNetDeviceNew)?;
Box::new(dev) as Box<dyn VirtioDevice>
} else {
- let dev =
- virtio::Net::<Tap>::new(host_ip, netmask, mac_address).map_err(Error::NetDeviceNew)?;
+ let dev = virtio::Net::<Tap>::new(host_ip, netmask, mac_address, Default::default())
+ .map_err(Error::NetDeviceNew)?;
Box::new(dev) as Box<dyn VirtioDevice>
};
@@ -1006,8 +1012,8 @@ fn create_virtio_devices(
devs.push(create_balloon_device(cfg, balloon_device_socket)?);
// We checked above that if the IP is defined, then the netmask is, too.
- for tap_fd in &cfg.tap_fd {
- devs.push(create_tap_net_device(cfg, *tap_fd)?);
+ for (tap_fd, options) in &cfg.tap_fd {
+ devs.push(create_tap_net_device(cfg, *tap_fd, options)?);
}
if let (Some(host_ip), Some(netmask), Some(mac_address)) =
diff --git a/src/main.rs b/src/main.rs
index 3afca8e0..053af465 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -21,7 +21,8 @@ use arch::Pstore;
use audio_streams::StreamEffect;
use crosvm::{
argument::{self, print_help, set_arguments, Argument},
- linux, BindMount, Config, DiskOption, Executable, GidMap, SharedDir, TouchDeviceOption,
+ linux, BindMount, Config, DiskOption, Executable, GidMap, SharedDir, TapFdOptions,
+ TouchDeviceOption,
};
#[cfg(feature = "gpu")]
use devices::virtio::gpu::{GpuMode, GpuParameters};
@@ -1041,17 +1042,52 @@ fn set_argument(cfg: &mut Config, name: &str, value: Option<&str>) -> argument::
}
"vhost-net" => cfg.vhost_net = true,
"tap-fd" => {
- cfg.tap_fd.push(
- value
- .unwrap()
- .parse()
- .map_err(|_| argument::Error::InvalidValue {
- value: value.unwrap().to_owned(),
- expected: String::from(
- "this value for `tap-fd` must be an unsigned integer",
- ),
- })?,
- );
+ let mut components = value.unwrap().split(',');
+
+ let fd: RawFd = components
+ .next()
+ .and_then(|x| x.parse().ok())
+ .ok_or_else(|| argument::Error::InvalidValue {
+ value: value.unwrap().to_owned(),
+ expected: String::from("this value for `tap-fd` must be an unsigned integer"),
+ })?;
+
+ let mut mac = None;
+ for c in components {
+ let mut kv = c.splitn(2, '=');
+ let (kind, value) = match (kv.next(), kv.next()) {
+ (Some(kind), Some(value)) => (kind, value),
+ _ => {
+ return Err(argument::Error::InvalidValue {
+ value: c.to_owned(),
+ expected: String::from("option must be of the form `kind=value`"),
+ })
+ }
+ };
+ match kind {
+ "mac" => {
+ mac = Some(value.parse().map_err(|_| argument::Error::InvalidValue {
+ value: value.to_owned(),
+ expected: String::from(
+ "`mac` needs to be in the form \"XX:XX:XX:XX:XX:XX\"",
+ ),
+ })?)
+ }
+ _ => {
+ return Err(argument::Error::InvalidValue {
+ value: kind.to_owned(),
+ expected: String::from("unrecognized option"),
+ })
+ }
+ }
+ }
+ if cfg.tap_fd.contains_key(&fd) {
+ return Err(argument::Error::TooManyArguments(format!(
+ "TAP FD already used: '{}'",
+ name
+ )));
+ }
+ cfg.tap_fd.insert(fd, TapFdOptions { mac });
}
#[cfg(feature = "gpu")]
"gpu" => {
@@ -1295,8 +1331,8 @@ writeback=BOOL - Indicates whether the VM can use writeback caching (default: fa
Argument::value("plugin-gid-map-file", "PATH", "Path to the file listing supplemental GIDs that should be mapped in plugin jail. Can be given more than once."),
Argument::flag("vhost-net", "Use vhost for networking."),
Argument::value("tap-fd",
- "fd",
- "File descriptor for configured tap device. A different virtual network card will be added each time this argument is given."),
+ "FD[,mac=MAC]",
+ "File descriptor for configured tap device. A different virtual network card will be added each time this argument is given. MAC is the MAC address that will be set in the guest."),
#[cfg(feature = "gpu")]
Argument::flag_or_value("gpu",
"[width=INT,height=INT]",
--
2.27.0
