github/kata-containers
1
0
Fork 1
mirror of https://github.com/kata-containers/kata-containers.git synced 2025-04-30 12:44:39 +00:00
Code Issues Projects Releases Wiki Activity

libs/types: modify implementation details

Browse Source 
1. fix nit problems
2. use generic type when parsing different type

Signed-off-by: Zhongtao Hu <zhongtaohu.tim@linux.alibaba.com>
This commit is contained in:
Zhongtao Hu 2022-02-15 14:54:33 +08:00 committed by Fupan Li
parent 05ad026fc0
commit b9b6d70aae
6 changed files with 234 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

336
src/libs/kata-types/src/annotations/mod.rs
View File

@ -7,6 +7,7 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::fs::File; use std::fs::File;
use std::io::{self, BufReader, Result}; use std::io::{self, BufReader, Result};
use std::result::{self};
use std::u32; use std::u32;
use serde::Deserialize; use serde::Deserialize;
@ -330,74 +331,24 @@ impl Annotation {
&mut self.annotations &mut self.annotations
} }
/// Get the value of annotation with `key`
pub fn get_value<T>(
&self,
key: &str,
) -> result::Result<Option<T>, <T as std::str::FromStr>::Err>
where
T: std::str::FromStr,
{
if let Some(value) = self.get(key) {
return value.parse::<T>().map(Some);
}
Ok(None)
}
/// Get the value of annotation with `key` as string. /// Get the value of annotation with `key` as string.
pub fn get(&self, key: &str) -> Option<String> { pub fn get(&self, key: &str) -> Option<String> {
self.annotations.get(key).map(|v| String::from(v.trim())) self.annotations.get(key).map(|v| String::from(v.trim()))
} }
/// Get the value of annotation with `key` as bool.
pub fn get_bool(&self, key: &str) -> Result<Option<bool>> {
if let Some(value) = self.get(key) {
return value
.parse::<bool>()
.map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("Invalid input {} for bool", key),
)
})
.map(Some);
}
Ok(None)
}
/// Get the value of annotation with `key` as u32.
pub fn get_u32(&self, key: &str) -> Result<Option<u32>> {
if let Some(value) = self.get(key) {
return value
.parse::<u32>()
.map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("Invalid input {} for u32", key),
)
})
.map(Some);
}
Ok(None)
}
/// Get the value of annotation with `key` as i32.
pub fn get_i32(&self, key: &str) -> Result<Option<i32>> {
if let Some(value) = self.get(key) {
return value
.parse::<i32>()
.map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("Invalid input {} for i32", key),
)
})
.map(Some);
}
Ok(None)
}
/// Get the value of annotation with `key` as u64.
pub fn get_u64(&self, key: &str) -> Result<Option<u64>> {
if let Some(value) = self.get(key) {
return value
.parse::<u64>()
.map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
format!("Invalid input {} for u64", key),
)
})
.map(Some);
}
Ok(None)
}
} }
// Miscellaneous annotations. // Miscellaneous annotations.
@ -419,7 +370,7 @@ impl Annotation {
/// Get the annotation to specify the Resources.Memory.Swappiness. /// Get the annotation to specify the Resources.Memory.Swappiness.
pub fn get_container_resource_swappiness(&self) -> Result<Option<u32>> { pub fn get_container_resource_swappiness(&self) -> Result<Option<u32>> {
match self.get_u32(KATA_ANNO_CONTAINER_RES_SWAPPINESS) { match self.get_value::<u32>(KATA_ANNO_CONTAINER_RES_SWAPPINESS) {
Ok(r) => { Ok(r) => {
if r.unwrap_or_default() > 100 { if r.unwrap_or_default() > 100 {
return Err(io::Error::new( return Err(io::Error::new(
@ -430,7 +381,10 @@ impl Annotation {
Ok(r) Ok(r)
} }
} }
Err(e) => Err(e), Err(_e) => Err(io::Error::new(
io::ErrorKind::InvalidData,
"parse u32 error".to_string(),
)),
} }
} }
@ -461,6 +415,11 @@ impl Annotation {
format!("agent {} not found", agent_name), format!("agent {} not found", agent_name),
)); ));
} }
let bool_err = io::Error::new(io::ErrorKind::InvalidData, "parse bool error".to_string());
let u32_err = io::Error::new(io::ErrorKind::InvalidData, "parse u32 error".to_string());
let u64_err = io::Error::new(io::ErrorKind::InvalidData, "parse u64 error".to_string());
let i32_err = io::Error::new(io::ErrorKind::InvalidData, "parse i32 error".to_string());
let mut hv = config.hypervisor.get_mut(hypervisor_name).unwrap(); let mut hv = config.hypervisor.get_mut(hypervisor_name).unwrap();
let mut ag = config.agent.get_mut(agent_name).unwrap(); let mut ag = config.agent.get_mut(agent_name).unwrap();
for (key, value) in &self.annotations { for (key, value) in &self.annotations {
@ -481,74 +440,87 @@ impl Annotation {
hv.validate_jailer_path(value)?; hv.validate_jailer_path(value)?;
hv.jailer_path = value.to_string(); hv.jailer_path = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_ENABLE_IO_THREADS => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_ENABLE_IO_THREADS => match self.get_value::<bool>(key)
{
Ok(r) => { Ok(r) => {
hv.enable_iothreads = r.unwrap_or_default(); hv.enable_iothreads = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
// Hypervisor Block Device related annotations // Hypervisor Block Device related annotations
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_DRIVER => { KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_DRIVER => {
hv.blockdev_info.block_device_driver = value.to_string(); hv.blockdev_info.block_device_driver = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_DISABLE_BLOCK_DEV_USE => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_DISABLE_BLOCK_DEV_USE => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.disable_block_device_use = r.unwrap_or_default(); hv.blockdev_info.disable_block_device_use = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_SET => match self.get_bool(key) { }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_SET => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.block_device_cache_set = r.unwrap_or_default(); hv.blockdev_info.block_device_cache_set = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_DIRECT => match self.get_bool(key) { }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_DIRECT => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.block_device_cache_direct = r.unwrap_or_default(); hv.blockdev_info.block_device_cache_direct = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_NOFLUSH => match self.get_bool(key) { }
KATA_ANNO_CFG_HYPERVISOR_BLOCK_DEV_CACHE_NOFLUSH => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.block_device_cache_noflush = r.unwrap_or_default(); hv.blockdev_info.block_device_cache_noflush = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_DISABLE_IMAGE_NVDIMM => match self.get_bool(key) { }
KATA_ANNO_CFG_HYPERVISOR_DISABLE_IMAGE_NVDIMM => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.disable_image_nvdimm = r.unwrap_or_default(); hv.blockdev_info.disable_image_nvdimm = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_MEMORY_OFFSET => match self.get_u64(key) { }
KATA_ANNO_CFG_HYPERVISOR_MEMORY_OFFSET => match self.get_value::<u64>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.memory_offset = r.unwrap_or_default(); hv.blockdev_info.memory_offset = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u64_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_ENABLE_VHOSTUSER_STORE => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_ENABLE_VHOSTUSER_STORE => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.blockdev_info.enable_vhost_user_store = r.unwrap_or_default(); hv.blockdev_info.enable_vhost_user_store = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
}
}
} }
},
KATA_ANNO_CFG_HYPERVISOR_VHOSTUSER_STORE_PATH => { KATA_ANNO_CFG_HYPERVISOR_VHOSTUSER_STORE_PATH => {
hv.blockdev_info.validate_vhost_user_store_path(value)?; hv.blockdev_info.validate_vhost_user_store_path(value)?;
hv.blockdev_info.vhost_user_store_path = value.to_string(); hv.blockdev_info.vhost_user_store_path = value.to_string();
@ -577,7 +549,7 @@ impl Annotation {
KATA_ANNO_CFG_HYPERVISOR_CPU_FEATURES => { KATA_ANNO_CFG_HYPERVISOR_CPU_FEATURES => {
hv.cpu_info.cpu_features = value.to_string(); hv.cpu_info.cpu_features = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_DEFAULT_VCPUS => match self.get_i32(key) { KATA_ANNO_CFG_HYPERVISOR_DEFAULT_VCPUS => match self.get_value::<i32>(key) {
Ok(num_cpus) => { Ok(num_cpus) => {
let num_cpus = num_cpus.unwrap_or_default(); let num_cpus = num_cpus.unwrap_or_default();
if num_cpus if num_cpus
@ -599,49 +571,53 @@ impl Annotation {
hv.cpu_info.default_vcpus = num_cpus; hv.cpu_info.default_vcpus = num_cpus;
} }
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(i32_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_DEFAULT_MAX_VCPUS => match self.get_u32(key) { KATA_ANNO_CFG_HYPERVISOR_DEFAULT_MAX_VCPUS => {
match self.get_value::<u32>(key) {
Ok(r) => { Ok(r) => {
hv.cpu_info.default_maxvcpus = r.unwrap_or_default(); hv.cpu_info.default_maxvcpus = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
}
}
} }
},
// Hypervisor Device related annotations // Hypervisor Device related annotations
KATA_ANNO_CFG_HYPERVISOR_HOTPLUG_VFIO_ON_ROOT_BUS => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_HOTPLUG_VFIO_ON_ROOT_BUS => {
match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.device_info.hotplug_vfio_on_root_bus = r.unwrap_or_default(); hv.device_info.hotplug_vfio_on_root_bus = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_PCIE_ROOT_PORT => match self.get_u32(key) { }
KATA_ANNO_CFG_HYPERVISOR_PCIE_ROOT_PORT => match self.get_value::<u32>(key) {
Ok(r) => { Ok(r) => {
hv.device_info.pcie_root_port = r.unwrap_or_default(); hv.device_info.pcie_root_port = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_IOMMU => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_IOMMU => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.device_info.enable_iommu = r.unwrap_or_default(); hv.device_info.enable_iommu = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_IOMMU_PLATFORM => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_IOMMU_PLATFORM => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.device_info.enable_iommu_platform = r.unwrap_or_default(); hv.device_info.enable_iommu_platform = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
// Hypervisor Machine related annotations // Hypervisor Machine related annotations
@ -656,7 +632,7 @@ impl Annotation {
hv.machine_info.entropy_source = value.to_string(); hv.machine_info.entropy_source = value.to_string();
} }
// Hypervisor Memory related annotations // Hypervisor Memory related annotations
KATA_ANNO_CFG_HYPERVISOR_DEFAULT_MEMORY => match self.get_u32(key) { KATA_ANNO_CFG_HYPERVISOR_DEFAULT_MEMORY => match self.get_value::<u32>(key) {
Ok(r) => { Ok(r) => {
let mem = r.unwrap_or_default(); let mem = r.unwrap_or_default();
if mem if mem
@ -678,100 +654,106 @@ impl Annotation {
hv.memory_info.default_memory = mem; hv.memory_info.default_memory = mem;
} }
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_MEMORY_SLOTS => match self.get_u32(key) { KATA_ANNO_CFG_HYPERVISOR_MEMORY_SLOTS => match self.get_value::<u32>(key) {
Ok(v) => { Ok(v) => {
hv.memory_info.memory_slots = v.unwrap_or_default(); hv.memory_info.memory_slots = v.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_MEMORY_PREALLOC => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_MEMORY_PREALLOC => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.memory_info.enable_mem_prealloc = r.unwrap_or_default(); hv.memory_info.enable_mem_prealloc = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_HUGE_PAGES => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_HUGE_PAGES => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.memory_info.enable_hugepages = r.unwrap_or_default(); hv.memory_info.enable_hugepages = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_FILE_BACKED_MEM_ROOT_DIR => { KATA_ANNO_CFG_HYPERVISOR_FILE_BACKED_MEM_ROOT_DIR => {
hv.memory_info.validate_memory_backend_path(value)?; hv.memory_info.validate_memory_backend_path(value)?;
hv.memory_info.file_mem_backend = value.to_string(); hv.memory_info.file_mem_backend = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_VIRTIO_MEM => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_VIRTIO_MEM => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.memory_info.enable_virtio_mem = r.unwrap_or_default(); hv.memory_info.enable_virtio_mem = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_ENABLE_SWAP => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_ENABLE_SWAP => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.memory_info.enable_swap = r.unwrap_or_default(); hv.memory_info.enable_swap = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_ENABLE_GUEST_SWAP => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_ENABLE_GUEST_SWAP => match self.get_value::<bool>(key)
{
Ok(r) => { Ok(r) => {
hv.memory_info.enable_guest_swap = r.unwrap_or_default(); hv.memory_info.enable_guest_swap = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
// Hypervisor Network related annotations // Hypervisor Network related annotations
KATA_ANNO_CFG_HYPERVISOR_DISABLE_VHOST_NET => match self.get_bool(key) { KATA_ANNO_CFG_HYPERVISOR_DISABLE_VHOST_NET => match self.get_value::<bool>(key)
{
Ok(r) => { Ok(r) => {
hv.network_info.disable_vhost_net = r.unwrap_or_default(); hv.network_info.disable_vhost_net = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_HYPERVISOR_RX_RATE_LIMITER_MAX_RATE => match self.get_u64(key) { KATA_ANNO_CFG_HYPERVISOR_RX_RATE_LIMITER_MAX_RATE => {
match self.get_value::<u64>(key) {
Ok(r) => { Ok(r) => {
hv.network_info.rx_rate_limiter_max_rate = r.unwrap_or_default(); hv.network_info.rx_rate_limiter_max_rate = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u64_err);
} }
}, }
KATA_ANNO_CFG_HYPERVISOR_TX_RATE_LIMITER_MAX_RATE => match self.get_u64(key) { }
KATA_ANNO_CFG_HYPERVISOR_TX_RATE_LIMITER_MAX_RATE => {
match self.get_value::<u64>(key) {
Ok(r) => { Ok(r) => {
hv.network_info.tx_rate_limiter_max_rate = r.unwrap_or_default(); hv.network_info.tx_rate_limiter_max_rate = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u64_err);
}
}
} }
},
// Hypervisor Security related annotations // Hypervisor Security related annotations
KATA_ANNO_CFG_HYPERVISOR_GUEST_HOOK_PATH => { KATA_ANNO_CFG_HYPERVISOR_GUEST_HOOK_PATH => {
hv.security_info.validate_path(value)?; hv.security_info.validate_path(value)?;
hv.security_info.guest_hook_path = value.to_string(); hv.security_info.guest_hook_path = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_ENABLE_ROOTLESS_HYPERVISOR => { KATA_ANNO_CFG_HYPERVISOR_ENABLE_ROOTLESS_HYPERVISOR => {
match self.get_bool(key) { match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
hv.security_info.rootless = r.unwrap_or_default(); hv.security_info.rootless = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
} }
} }
@ -788,14 +770,16 @@ impl Annotation {
KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_CACHE => { KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_CACHE => {
hv.shared_fs.virtio_fs_cache = value.to_string(); hv.shared_fs.virtio_fs_cache = value.to_string();
} }
KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_CACHE_SIZE => match self.get_u32(key) { KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_CACHE_SIZE => {
match self.get_value::<u32>(key) {
Ok(r) => { Ok(r) => {
hv.shared_fs.virtio_fs_cache_size = r.unwrap_or_default(); hv.shared_fs.virtio_fs_cache_size = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
}
}
} }
},
KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_EXTRA_ARGS => { KATA_ANNO_CFG_HYPERVISOR_VIRTIO_FS_EXTRA_ARGS => {
let args: Vec<String> = let args: Vec<String> =
value.to_string().split(',').map(str::to_string).collect(); value.to_string().split(',').map(str::to_string).collect();
@ -803,12 +787,12 @@ impl Annotation {
hv.shared_fs.virtio_fs_extra_args.push(arg.to_string()); hv.shared_fs.virtio_fs_extra_args.push(arg.to_string());
} }
} }
KATA_ANNO_CFG_HYPERVISOR_MSIZE_9P => match self.get_u32(key) { KATA_ANNO_CFG_HYPERVISOR_MSIZE_9P => match self.get_value::<u32>(key) {
Ok(v) => { Ok(v) => {
hv.shared_fs.msize_9p = v.unwrap_or_default(); hv.shared_fs.msize_9p = v.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
} }
}, },
@ -829,37 +813,37 @@ impl Annotation {
ag.kernel_modules.push(modules.to_string()); ag.kernel_modules.push(modules.to_string());
} }
} }
KATA_ANNO_CFG_AGENT_TRACE => match self.get_bool(key) { KATA_ANNO_CFG_AGENT_TRACE => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
ag.enable_tracing = r.unwrap_or_default(); ag.enable_tracing = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_AGENT_CONTAINER_PIPE_SIZE => match self.get_u32(key) { KATA_ANNO_CFG_AGENT_CONTAINER_PIPE_SIZE => match self.get_value::<u32>(key) {
Ok(v) => { Ok(v) => {
ag.container_pipe_size = v.unwrap_or_default(); ag.container_pipe_size = v.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(u32_err);
} }
}, },
//update runtume config //update runtume config
KATA_ANNO_CFG_DISABLE_GUEST_SECCOMP => match self.get_bool(key) { KATA_ANNO_CFG_DISABLE_GUEST_SECCOMP => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
config.runtime.disable_guest_seccomp = r.unwrap_or_default(); config.runtime.disable_guest_seccomp = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_ENABLE_PPROF => match self.get_bool(key) { KATA_ANNO_CFG_ENABLE_PPROF => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
config.runtime.enable_pprof = r.unwrap_or_default(); config.runtime.enable_pprof = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_EXPERIMENTAL => { KATA_ANNO_CFG_EXPERIMENTAL => {
@ -872,20 +856,20 @@ impl Annotation {
KATA_ANNO_CFG_INTER_NETWORK_MODEL => { KATA_ANNO_CFG_INTER_NETWORK_MODEL => {
config.runtime.internetworking_model = value.to_string(); config.runtime.internetworking_model = value.to_string();
} }
KATA_ANNO_CFG_SANDBOX_CGROUP_ONLY => match self.get_bool(key) { KATA_ANNO_CFG_SANDBOX_CGROUP_ONLY => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
config.runtime.sandbox_cgroup_only = r.unwrap_or_default(); config.runtime.sandbox_cgroup_only = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_DISABLE_NEW_NETNS => match self.get_bool(key) { KATA_ANNO_CFG_DISABLE_NEW_NETNS => match self.get_value::<bool>(key) {
Ok(r) => { Ok(r) => {
config.runtime.disable_new_netns = r.unwrap_or_default(); config.runtime.disable_new_netns = r.unwrap_or_default();
} }
Err(e) => { Err(_e) => {
return Err(e); return Err(bool_err);
} }
}, },
KATA_ANNO_CFG_VFIO_MODE => { KATA_ANNO_CFG_VFIO_MODE => {

2
src/libs/kata-types/src/annotations/thirdparty.rs
View File

@ -9,4 +9,4 @@
/// Annotation to enable SGX. /// Annotation to enable SGX.
/// ///
/// Hardware-based isolation and memory encryption. /// Hardware-based isolation and memory encryption.
pub const SGXEPC: &str = "sgx.intel.com/epc"; pub const SGX_EPC: &str = "sgx.intel.com/epc";

16
src/libs/kata-types/src/config/default.rs
View File

@ -15,7 +15,7 @@ lazy_static! {
"/usr/share/defaults/kata-containers/configuration.toml", "/usr/share/defaults/kata-containers/configuration.toml",
]; ];
} }
pub const DEFAULT_AGENT_NAME: &str = "kata"; pub const DEFAULT_AGENT_NAME: &str = "kata-agent";
pub const DEFAULT_INTERNETWORKING_MODEL: &str = "tcfilter"; pub const DEFAULT_INTERNETWORKING_MODEL: &str = "tcfilter";
@ -35,13 +35,13 @@ pub const DEFAULT_GUEST_HOOK_PATH: &str = "/opt";
pub const DEFAULT_GUEST_VCPUS: u32 = 1; pub const DEFAULT_GUEST_VCPUS: u32 = 1;
// Default configuration for Dragonball // Default configuration for Dragonball
pub const DEFAULT_DB_GUEST_KERNEL_IMAGE: &str = "vmlinuz"; pub const DEFAULT_DRAGONBALL_GUEST_KERNEL_IMAGE: &str = "vmlinuz";
pub const DEFAULT_DB_GUEST_KERNEL_PARAMS: &str = ""; pub const DEFAULT_DRAGONBALL_GUEST_KERNEL_PARAMS: &str = "";
pub const DEFAULT_DB_ENTROPY_SOURCE: &str = "/dev/urandom"; pub const DEFAULT_DRAGONBALL_ENTROPY_SOURCE: &str = "/dev/urandom";
pub const DEFAULT_DB_MEMORY_SIZE: u32 = 128; pub const DEFAULT_DRAGONBALL_MEMORY_SIZE: u32 = 128;
pub const DEFAULT_DB_MEMORY_SLOTS: u32 = 128; pub const DEFAULT_DRAGONBALL_MEMORY_SLOTS: u32 = 128;
pub const MAX_DB_VCPUS: u32 = 256; pub const MAX_DRAGONBALL_VCPUS: u32 = 256;
pub const MIN_DB_MEMORY_SIZE: u32 = 64; pub const MIN_DRAGONBALL_MEMORY_SIZE: u32 = 64;
// Default configuration for qemu // Default configuration for qemu
pub const DEFAULT_QEMU_BINARY_PATH: &str = "qemu"; pub const DEFAULT_QEMU_BINARY_PATH: &str = "qemu";
pub const DEFAULT_QEMU_CONTROL_PATH: &str = ""; pub const DEFAULT_QEMU_CONTROL_PATH: &str = "";

28
src/libs/kata-types/src/config/hypervisor/dragonball.rs
View File

@ -9,8 +9,8 @@ use std::sync::Arc;
use std::u32; use std::u32;
use super::{default, register_hypervisor_plugin}; use super::{default, register_hypervisor_plugin};
use crate::config::default::MAX_DB_VCPUS; use crate::config::default::MAX_DRAGONBALL_VCPUS;
use crate::config::default::MIN_DB_MEMORY_SIZE; use crate::config::default::MIN_DRAGONBALL_MEMORY_SIZE;
use crate::config::hypervisor::{ use crate::config::hypervisor::{
VIRTIO_BLK, VIRTIO_BLK_MMIO, VIRTIO_FS, VIRTIO_FS_INLINE, VIRTIO_PMEM, VIRTIO_BLK, VIRTIO_BLK_MMIO, VIRTIO_FS, VIRTIO_FS_INLINE, VIRTIO_PMEM,
}; };
@ -39,10 +39,10 @@ impl DragonballConfig {
impl ConfigPlugin for DragonballConfig { impl ConfigPlugin for DragonballConfig {
fn get_max_cpus(&self) -> u32 { fn get_max_cpus(&self) -> u32 {
MAX_DB_VCPUS MAX_DRAGONBALL_VCPUS
} }
fn get_min_memory(&self) -> u32 { fn get_min_memory(&self) -> u32 {
MIN_DB_MEMORY_SIZE MIN_DRAGONBALL_MEMORY_SIZE
} }
fn name(&self) -> &str { fn name(&self) -> &str {
HYPERVISOR_NAME_DRAGONBALL HYPERVISOR_NAME_DRAGONBALL
@ -54,25 +54,27 @@ impl ConfigPlugin for DragonballConfig {
resolve_path!(db.jailer_path, "Dragonball jailer path {} is invalid: {}")?; resolve_path!(db.jailer_path, "Dragonball jailer path {} is invalid: {}")?;
if db.boot_info.kernel.is_empty() { if db.boot_info.kernel.is_empty() {
db.boot_info.kernel = default::DEFAULT_DB_GUEST_KERNEL_IMAGE.to_string(); db.boot_info.kernel = default::DEFAULT_DRAGONBALL_GUEST_KERNEL_IMAGE.to_string();
} }
if db.boot_info.kernel_params.is_empty() { if db.boot_info.kernel_params.is_empty() {
db.boot_info.kernel_params = default::DEFAULT_DB_GUEST_KERNEL_PARAMS.to_string(); db.boot_info.kernel_params =
default::DEFAULT_DRAGONBALL_GUEST_KERNEL_PARAMS.to_string();
} }
if db.cpu_info.default_maxvcpus > default::MAX_DB_VCPUS { if db.cpu_info.default_maxvcpus > default::MAX_DRAGONBALL_VCPUS {
db.cpu_info.default_maxvcpus = default::MAX_DB_VCPUS; db.cpu_info.default_maxvcpus = default::MAX_DRAGONBALL_VCPUS;
} }
if db.machine_info.entropy_source.is_empty() { if db.machine_info.entropy_source.is_empty() {
db.machine_info.entropy_source = default::DEFAULT_DB_ENTROPY_SOURCE.to_string(); db.machine_info.entropy_source =
default::DEFAULT_DRAGONBALL_ENTROPY_SOURCE.to_string();
} }
if db.memory_info.default_memory == 0 { if db.memory_info.default_memory == 0 {
db.memory_info.default_memory = default::DEFAULT_DB_MEMORY_SIZE; db.memory_info.default_memory = default::DEFAULT_DRAGONBALL_MEMORY_SIZE;
} }
if db.memory_info.memory_slots == 0 { if db.memory_info.memory_slots == 0 {
db.memory_info.memory_slots = default::DEFAULT_DB_MEMORY_SLOTS; db.memory_info.memory_slots = default::DEFAULT_DRAGONBALL_MEMORY_SLOTS;
} }
} }
Ok(()) Ok(())
@ -131,8 +133,8 @@ impl ConfigPlugin for DragonballConfig {
} }
if (db.cpu_info.default_vcpus > 0 if (db.cpu_info.default_vcpus > 0
&& db.cpu_info.default_vcpus as u32 > default::MAX_DB_VCPUS) && db.cpu_info.default_vcpus as u32 > default::MAX_DRAGONBALL_VCPUS)
|| db.cpu_info.default_maxvcpus > default::MAX_DB_VCPUS || db.cpu_info.default_maxvcpus > default::MAX_DRAGONBALL_VCPUS
{ {
return Err(eother!( return Err(eother!(
"Dragonball hypervisor can not support {} vCPUs", "Dragonball hypervisor can not support {} vCPUs",

1
src/libs/kata-types/src/config/runtime_vendor.rs
View File

@ -6,7 +6,6 @@
//! A sample for vendor to customize the runtime implementation. //! A sample for vendor to customize the runtime implementation.
use super::*; use super::*;
use crate::{eother, sl};
use slog::Level; use slog::Level;
/// Vendor customization runtime configuration. /// Vendor customization runtime configuration.
#[derive(Debug, Default, Deserialize, Serialize)] #[derive(Debug, Default, Deserialize, Serialize)]

34
src/libs/kata-types/tests/test_config.rs
View File

@ -30,7 +30,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
std::process::Command::new("mkdir") std::process::Command::new("mkdir")
@ -167,7 +167,7 @@ mod tests {
anno_hash.insert(KATA_ANNO_CFG_EXPERIMENTAL.to_string(), "c,d,e".to_string()); anno_hash.insert(KATA_ANNO_CFG_EXPERIMENTAL.to_string(), "c,d,e".to_string());
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -281,7 +281,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -290,7 +290,7 @@ mod tests {
"fvfvfvfvf".to_string(), "fvfvfvfvf".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -304,7 +304,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -313,7 +313,7 @@ mod tests {
"false".to_string(), "false".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -327,7 +327,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -374,7 +374,7 @@ mod tests {
#[test] #[test]
fn test_fail_to_change_memory_slots_because_of_less_than_zero() { fn test_fail_to_change_memory_slots_because_of_less_than_zero() {
let content = include_str!("texture/configuration-anno-0.toml"); let content = include_str!("texture/configuration-anno-0.toml");
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
@ -386,7 +386,7 @@ mod tests {
"-1".to_string(), "-1".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -400,7 +400,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -409,7 +409,7 @@ mod tests {
"10".to_string(), "10".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -423,7 +423,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -432,7 +432,7 @@ mod tests {
"400".to_string(), "400".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -446,7 +446,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -455,7 +455,7 @@ mod tests {
"false1".to_string(), "false1".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")
@ -469,7 +469,7 @@ mod tests {
let qemu = QemuConfig::new(); let qemu = QemuConfig::new();
qemu.register(); qemu.register();
let config = TomlConfig::load(&content).unwrap(); let config = TomlConfig::load(content).unwrap();
KataConfig::set_active_config(Some(config), "qemu", "agent0"); KataConfig::set_active_config(Some(config), "qemu", "agent0");
let mut anno_hash = HashMap::new(); let mut anno_hash = HashMap::new();
@ -478,7 +478,7 @@ mod tests {
"ddc".to_string(), "ddc".to_string(),
); );
let anno = Annotation::new(anno_hash); let anno = Annotation::new(anno_hash);
let mut config = TomlConfig::load(&content).unwrap(); let mut config = TomlConfig::load(content).unwrap();
assert!(anno assert!(anno
.update_config_by_annotation(&mut config, "qemu", "agent0") .update_config_by_annotation(&mut config, "qemu", "agent0")