External/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2024-10-01 11:05:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

vmm: add configuration for network offloading features

Browse Source 
Add new configuration for offloading features, including
Checksum/TSO/UFO, and set these offloading features as
enabled by default.

Fixes: #4792.

Signed-off-by: Yong He <alexyonghe@tencent.com>
This commit is contained in:
Yong He 2022-12-20 20:04:08 +08:00 committed by Rob Bradford
parent 06e583c9ab
commit 3494080e2f
6 changed files with 130 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
fuzz/fuzz_targets/net.rs
View File

@ -76,6 +76,9 @@ fuzz_target!(|bytes| {
None, None,
EventFd::new(EFD_NONBLOCK).unwrap(), EventFd::new(EFD_NONBLOCK).unwrap(),
None, None,
true,
true,
true,
) )
.unwrap(); .unwrap();

51
virtio-devices/src/net.rs
View File

@ -446,6 +446,9 @@ impl Net {
rate_limiter_config: Option<RateLimiterConfig>, rate_limiter_config: Option<RateLimiterConfig>,
exit_evt: EventFd, exit_evt: EventFd,
state: Option<NetState>, state: Option<NetState>,
offload_tso: bool,
offload_ufo: bool,
offload_csum: bool,
) -> Result<Self> { ) -> Result<Self> {
assert!(!taps.is_empty()); assert!(!taps.is_empty());
@ -462,25 +465,33 @@ impl Net {
true, true,
) )
} else { } else {
let mut avail_features = 1 << VIRTIO_NET_F_CSUM let mut avail_features =
| 1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS 1 << VIRTIO_NET_F_MTU | 1 << VIRTIO_RING_F_EVENT_IDX | 1 << VIRTIO_F_VERSION_1;
| 1 << VIRTIO_NET_F_GUEST_CSUM
| 1 << VIRTIO_NET_F_GUEST_ECN
| 1 << VIRTIO_NET_F_GUEST_TSO4
| 1 << VIRTIO_NET_F_GUEST_TSO6
| 1 << VIRTIO_NET_F_GUEST_UFO
| 1 << VIRTIO_NET_F_HOST_ECN
| 1 << VIRTIO_NET_F_HOST_TSO4
| 1 << VIRTIO_NET_F_HOST_TSO6
| 1 << VIRTIO_NET_F_HOST_UFO
| 1 << VIRTIO_NET_F_MTU
| 1 << VIRTIO_RING_F_EVENT_IDX
| 1 << VIRTIO_F_VERSION_1;
if iommu { if iommu {
avail_features |= 1u64 << VIRTIO_F_IOMMU_PLATFORM; avail_features |= 1u64 << VIRTIO_F_IOMMU_PLATFORM;
} }
// Configure TSO/UFO features when hardware checksum offload is enabled.
if offload_csum {
avail_features |= 1 << VIRTIO_NET_F_CSUM
| 1 << VIRTIO_NET_F_GUEST_CSUM
| 1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS;
if offload_tso {
avail_features |= 1 << VIRTIO_NET_F_HOST_ECN
| 1 << VIRTIO_NET_F_HOST_TSO4
| 1 << VIRTIO_NET_F_HOST_TSO6
| 1 << VIRTIO_NET_F_GUEST_ECN
| 1 << VIRTIO_NET_F_GUEST_TSO4
| 1 << VIRTIO_NET_F_GUEST_TSO6;
}
if offload_ufo {
avail_features |= 1 << VIRTIO_NET_F_HOST_UFO | 1 << VIRTIO_NET_F_GUEST_UFO;
}
}
avail_features |= 1 << VIRTIO_NET_F_CTRL_VQ; avail_features |= 1 << VIRTIO_NET_F_CTRL_VQ;
let queue_num = num_queues + 1; let queue_num = num_queues + 1;
@ -551,6 +562,9 @@ impl Net {
rate_limiter_config: Option<RateLimiterConfig>, rate_limiter_config: Option<RateLimiterConfig>,
exit_evt: EventFd, exit_evt: EventFd,
state: Option<NetState>, state: Option<NetState>,
offload_tso: bool,
offload_ufo: bool,
offload_csum: bool,
) -> Result<Self> { ) -> Result<Self> {
let taps = open_tap( let taps = open_tap(
if_name, if_name,
@ -574,6 +588,9 @@ impl Net {
rate_limiter_config, rate_limiter_config,
exit_evt, exit_evt,
state, state,
offload_tso,
offload_ufo,
offload_csum,
) )
} }
@ -589,6 +606,9 @@ impl Net {
rate_limiter_config: Option<RateLimiterConfig>, rate_limiter_config: Option<RateLimiterConfig>,
exit_evt: EventFd, exit_evt: EventFd,
state: Option<NetState>, state: Option<NetState>,
offload_tso: bool,
offload_ufo: bool,
offload_csum: bool,
) -> Result<Self> { ) -> Result<Self> {
let mut taps: Vec<Tap> = Vec::new(); let mut taps: Vec<Tap> = Vec::new();
let num_queue_pairs = fds.len(); let num_queue_pairs = fds.len();
@ -621,6 +641,9 @@ impl Net {
rate_limiter_config, rate_limiter_config,
exit_evt, exit_evt,
state, state,
offload_tso,
offload_ufo,
offload_csum,
) )
} }

33
virtio-devices/src/vhost_user/net.rs
View File

@ -78,6 +78,9 @@ impl Net {
exit_evt: EventFd, exit_evt: EventFd,
iommu: bool, iommu: bool,
state: Option<State>, state: Option<State>,
offload_tso: bool,
offload_ufo: bool,
offload_csum: bool,
) -> Result<Net> { ) -> Result<Net> {
let mut num_queues = vu_cfg.num_queues; let mut num_queues = vu_cfg.num_queues;
@ -120,17 +123,7 @@ impl Net {
) )
} else { } else {
// Filling device and vring features VMM supports. // Filling device and vring features VMM supports.
let mut avail_features = 1 << VIRTIO_NET_F_CSUM let mut avail_features = 1 << VIRTIO_NET_F_MRG_RXBUF
| 1 << VIRTIO_NET_F_GUEST_CSUM
| 1 << VIRTIO_NET_F_GUEST_TSO4
| 1 << VIRTIO_NET_F_GUEST_TSO6
| 1 << VIRTIO_NET_F_GUEST_ECN
| 1 << VIRTIO_NET_F_GUEST_UFO
| 1 << VIRTIO_NET_F_HOST_TSO4
| 1 << VIRTIO_NET_F_HOST_TSO6
| 1 << VIRTIO_NET_F_HOST_ECN
| 1 << VIRTIO_NET_F_HOST_UFO
| 1 << VIRTIO_NET_F_MRG_RXBUF
| 1 << VIRTIO_NET_F_CTRL_VQ | 1 << VIRTIO_NET_F_CTRL_VQ
| 1 << VIRTIO_F_RING_EVENT_IDX | 1 << VIRTIO_F_RING_EVENT_IDX
| 1 << VIRTIO_F_VERSION_1 | 1 << VIRTIO_F_VERSION_1
@ -140,6 +133,24 @@ impl Net {
avail_features |= 1u64 << VIRTIO_NET_F_MTU; avail_features |= 1u64 << VIRTIO_NET_F_MTU;
} }
// Configure TSO/UFO features when hardware checksum offload is enabled.
if offload_csum {
avail_features |= 1 << VIRTIO_NET_F_CSUM | 1 << VIRTIO_NET_F_GUEST_CSUM;
if offload_tso {
avail_features |= 1 << VIRTIO_NET_F_HOST_ECN
| 1 << VIRTIO_NET_F_HOST_TSO4
| 1 << VIRTIO_NET_F_HOST_TSO6
| 1 << VIRTIO_NET_F_GUEST_ECN
| 1 << VIRTIO_NET_F_GUEST_TSO4
| 1 << VIRTIO_NET_F_GUEST_TSO6;
}
if offload_ufo {
avail_features |= 1 << VIRTIO_NET_F_HOST_UFO | 1 << VIRTIO_NET_F_GUEST_UFO;
}
}
let mut config = VirtioNetConfig::default(); let mut config = VirtioNetConfig::default();
build_net_config_space(&mut config, mac_addr, num_queues, mtu, &mut avail_features); build_net_config_space(&mut config, mac_addr, num_queues, mtu, &mut avail_features);

44
vmm/src/config.rs
View File

@ -134,6 +134,8 @@ pub enum ValidationError {
VnetQueueFdMismatch, VnetQueueFdMismatch,
/// Using reserved fd /// Using reserved fd
VnetReservedFd, VnetReservedFd,
/// Hardware checksum offload is disabled.
NoHardwareChecksumOffload,
/// Hugepages not turned on /// Hugepages not turned on
HugePageSizeWithoutHugePages, HugePageSizeWithoutHugePages,
/// Huge page size is not power of 2 /// Huge page size is not power of 2
@ -205,6 +207,10 @@ impl fmt::Display for ValidationError {
"Number of queues to virtio_net does not match the number of input FDs" "Number of queues to virtio_net does not match the number of input FDs"
), ),
VnetReservedFd => write!(f, "Reserved fd number (<= 2)"), VnetReservedFd => write!(f, "Reserved fd number (<= 2)"),
NoHardwareChecksumOffload => write!(
f,
"\"offload_tso\" and \"offload_ufo\" depend on \"offload_tso\""
),
HugePageSizeWithoutHugePages => { HugePageSizeWithoutHugePages => {
write!(f, "Huge page size specified but huge pages not enabled") write!(f, "Huge page size specified but huge pages not enabled")
} }
@ -1006,7 +1012,8 @@ impl NetConfig {
num_queues=<number_of_queues>,queue_size=<size_of_each_queue>,id=<device_id>,\ num_queues=<number_of_queues>,queue_size=<size_of_each_queue>,id=<device_id>,\
vhost_user=<vhost_user_enable>,socket=<vhost_user_socket_path>,vhost_mode=client|server,\ vhost_user=<vhost_user_enable>,socket=<vhost_user_socket_path>,vhost_mode=client|server,\
bw_size=<bytes>,bw_one_time_burst=<bytes>,bw_refill_time=<ms>,\ bw_size=<bytes>,bw_one_time_burst=<bytes>,bw_refill_time=<ms>,\
ops_size=<io_ops>,ops_one_time_burst=<io_ops>,ops_refill_time=<ms>,pci_segment=<segment_id>\""; ops_size=<io_ops>,ops_one_time_burst=<io_ops>,ops_refill_time=<ms>,pci_segment=<segment_id>\
offload_tso=on|off,offload_ufo=on|off,offload_csum=on|off\"";
pub fn parse(net: &str) -> Result<Self> { pub fn parse(net: &str) -> Result<Self> {
let mut parser = OptionParser::new(); let mut parser = OptionParser::new();
@ -1017,6 +1024,9 @@ impl NetConfig {
.add("mask") .add("mask")
.add("mac") .add("mac")
.add("host_mac") .add("host_mac")
.add("offload_tso")
.add("offload_ufo")
.add("offload_csum")
.add("mtu") .add("mtu")
.add("iommu") .add("iommu")
.add("queue_size") .add("queue_size")
@ -1049,6 +1059,21 @@ impl NetConfig {
.map_err(Error::ParseNetwork)? .map_err(Error::ParseNetwork)?
.unwrap_or_else(default_netconfig_mac); .unwrap_or_else(default_netconfig_mac);
let host_mac = parser.convert("host_mac").map_err(Error::ParseNetwork)?; let host_mac = parser.convert("host_mac").map_err(Error::ParseNetwork)?;
let offload_tso = parser
.convert::<Toggle>("offload_tso")
.map_err(Error::ParseNetwork)?
.unwrap_or(Toggle(true))
.0;
let offload_ufo = parser
.convert::<Toggle>("offload_ufo")
.map_err(Error::ParseNetwork)?
.unwrap_or(Toggle(true))
.0;
let offload_csum = parser
.convert::<Toggle>("offload_csum")
.map_err(Error::ParseNetwork)?
.unwrap_or(Toggle(true))
.0;
let mtu = parser.convert("mtu").map_err(Error::ParseNetwork)?; let mtu = parser.convert("mtu").map_err(Error::ParseNetwork)?;
let iommu = parser let iommu = parser
.convert::<Toggle>("iommu") .convert::<Toggle>("iommu")
@ -1150,6 +1175,9 @@ impl NetConfig {
fds, fds,
rate_limiter_config, rate_limiter_config,
pci_segment, pci_segment,
offload_tso,
offload_ufo,
offload_csum,
}; };
Ok(config) Ok(config)
} }
@ -1197,6 +1225,10 @@ impl NetConfig {
} }
} }
if !self.offload_csum && (self.offload_tso || self.offload_ufo) {
return Err(ValidationError::NoHardwareChecksumOffload);
}
Ok(()) Ok(())
} }
} }
@ -2932,6 +2964,16 @@ mod tests {
Err(ValidationError::VnetReservedFd) Err(ValidationError::VnetReservedFd)
); );
let mut invalid_config = valid_config.clone();
invalid_config.net = Some(vec![NetConfig {
offload_csum: false,
..Default::default()
}]);
assert_eq!(
invalid_config.validate(),
Err(ValidationError::NoHardwareChecksumOffload)
);
let mut invalid_config = valid_config.clone(); let mut invalid_config = valid_config.clone();
invalid_config.fs = Some(vec![FsConfig { invalid_config.fs = Some(vec![FsConfig {
..Default::default() ..Default::default()

12
vmm/src/device_manager.rs
View File

@ -2334,6 +2334,9 @@ impl DeviceManager {
.map(|s| s.to_versioned_state()) .map(|s| s.to_versioned_state())
.transpose() .transpose()
.map_err(DeviceManagerError::RestoreGetState)?, .map_err(DeviceManagerError::RestoreGetState)?,
net_cfg.offload_tso,
net_cfg.offload_ufo,
net_cfg.offload_csum,
) { ) {
Ok(vun_device) => vun_device, Ok(vun_device) => vun_device,
Err(e) => { Err(e) => {
@ -2371,6 +2374,9 @@ impl DeviceManager {
.try_clone() .try_clone()
.map_err(DeviceManagerError::EventFd)?, .map_err(DeviceManagerError::EventFd)?,
state, state,
net_cfg.offload_tso,
net_cfg.offload_ufo,
net_cfg.offload_csum,
) )
.map_err(DeviceManagerError::CreateVirtioNet)?, .map_err(DeviceManagerError::CreateVirtioNet)?,
)) ))
@ -2389,6 +2395,9 @@ impl DeviceManager {
.try_clone() .try_clone()
.map_err(DeviceManagerError::EventFd)?, .map_err(DeviceManagerError::EventFd)?,
state, state,
net_cfg.offload_tso,
net_cfg.offload_ufo,
net_cfg.offload_csum,
) )
.map_err(DeviceManagerError::CreateVirtioNet)?, .map_err(DeviceManagerError::CreateVirtioNet)?,
)) ))
@ -2411,6 +2420,9 @@ impl DeviceManager {
.try_clone() .try_clone()
.map_err(DeviceManagerError::EventFd)?, .map_err(DeviceManagerError::EventFd)?,
state, state,
net_cfg.offload_tso,
net_cfg.offload_ufo,
net_cfg.offload_csum,
) )
.map_err(DeviceManagerError::CreateVirtioNet)?, .map_err(DeviceManagerError::CreateVirtioNet)?,
)) ))

13
vmm/src/vm_config.rs
View File

@ -291,6 +291,16 @@ pub struct NetConfig {
pub rate_limiter_config: Option<RateLimiterConfig>, pub rate_limiter_config: Option<RateLimiterConfig>,
#[serde(default)] #[serde(default)]
pub pci_segment: u16, pub pci_segment: u16,
#[serde(default = "default_netconfig_true")]
pub offload_tso: bool,
#[serde(default = "default_netconfig_true")]
pub offload_ufo: bool,
#[serde(default = "default_netconfig_true")]
pub offload_csum: bool,
}
pub fn default_netconfig_true() -> bool {
true
} }
pub fn default_netconfig_tap() -> Option<String> { pub fn default_netconfig_tap() -> Option<String> {
@ -340,6 +350,9 @@ impl Default for NetConfig {
fds: None, fds: None,
rate_limiter_config: None, rate_limiter_config: None,
pci_segment: 0, pci_segment: 0,
offload_tso: true,
offload_ufo: true,
offload_csum: true,
} }
} }
} }