- Virt - mailweb.openeuler.org

StratoVirt ReadMe文档修改和设备模块中冗余的DeviceOps删除
by Xufei (VF) 28 Dec '20

28 Dec '20

1 0

[PATCH 1/5] fw_cfg: Add QEMU Firmware Configuration Device
by Ying Fang 23 Dec '20

23 Dec '20

The fw_cfg device is a hardware interface allows the guest to retrieve various data items (blobs) that can influence how the firmware configures itself, or may contain tables to be installed for the guest OS. Examples include device boot order, ACPI and SMBIOS tables, virtual machine UUID, SMP and NUMA information, kernel/initrd images for direct (Linux) kernel booting, etc. StratoVirt will reuse the fw_cfg device model as firmware loader for the our standard virtual machine. Signed-off-by: Ying Fang <fangying1(a)huawei.com> --- device_model/src/legacy/fw_cfg.rs | 781 ++++++++++++++++++++++++++++++ device_model/src/legacy/mod.rs | 11 + device_model/src/micro_vm/mod.rs | 24 + device_model/src/mmio/bus.rs | 9 + device_model/src/mmio/mod.rs | 1 + 5 files changed, 826 insertions(+) create mode 100644 device_model/src/legacy/fw_cfg.rs diff --git a/device_model/src/legacy/fw_cfg.rs b/device_model/src/legacy/fw_cfg.rs new file mode 100644 index 0000000..7422d4b --- /dev/null +++ b/device_model/src/legacy/fw_cfg.rs @@ -0,0 +1,781 @@ +// Copyright (c) 2020 Huawei Technologies Co.,Ltd. All rights reserved. +// +// StratoVirt is licensed under Mulan PSL v2. +// You can use this software according to the terms and conditions of the Mulan +// PSL v2. +// You may obtain a copy of Mulan PSL v2 at: +// http://license.coscl.org.cn/MulanPSL2 +// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY +// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO +// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +// See the Mulan PSL v2 for more details. + +use super::super::mmio::errors::{Result}; +use super::super::mmio::{DeviceResource, DeviceType, MmioDeviceOps}; +use super::super::DeviceOps; +use address_space::{AddressSpace, GuestAddress}; +use byteorder::{ByteOrder, BigEndian, LittleEndian}; +use serde::{Deserialize, Serialize}; +use kvm_ioctls::VmFd; +use std::default::Default; +use std::cmp::Ordering; +use std::sync::{Arc}; +use util::byte_code::ByteCode; + +const FW_CFG_ACPI_DEVICE_ID: &str = "QEMU0002"; +/// QEMU CFG Signature +const FW_CFG_DMA_SIGNATURE: u128 = 0x51454d5520434647; + +/// FW_CFG_VERSION bits +const FW_CFG_VERSION: u32 = 0x01; +const FW_CFG_VERSION_DMA: u32 = 0x02; +const FW_CFG_FILE_SLOTS_DFLT: u32 = 0x20; + +enum FWCfgEntryType { + FW_CFG_SIGNATURE = 0x00, + FW_CFG_ID, + FW_CFG_UUID, + FW_CFG_RAM_SIZE, + FW_CFG_NOGRAPHIC, + FW_CFG_NB_CPUS, + FW_CFG_MACHINE_ID, + FW_CFG_KERNEL_ADDR, + FW_CFG_KERNEL_SIZE, + FW_CFG_KERNEL_CMDLINE, + FW_CFG_INITRD_ADDR, + FW_CFG_INITRD_SIZE, + FW_CFG_BOOT_DEVICE, + FW_CFG_NUMA, + FW_CFG_BOOT_MENU, + FW_CFG_MAX_CPUS, + FW_CFG_KERNEL_ENTRY, + FW_CFG_KERNEL_DATA, + FW_CFG_INITRD_DATA, + FW_CFG_CMDLINE_ADDR, + FW_CFG_CMDLINE_SIZE, + FW_CFG_SETUP_ADDR, + FW_CFG_SETUP_SIZE, + FW_CFG_FILE_DIR, +} + +const FW_CFG_FILE_FIRST: u16 = 0x20; +const FW_CFG_FILE_SLOTS_MIN: u16 = 0x10; +const FW_CFG_WRITE_CHANNEL: u16 = 0x4000; +const FW_CFG_ARCH_LOCAL: u16 = 0x8000; +const FW_CFG_ENTRY_MASK: u16 = !(FW_CFG_WRITE_CHANNEL | FW_CFG_ARCH_LOCAL); + +const FW_CFG_INVALID: u16 = 0xffff; +const FW_CFG_CTL_SIZE: u32 = 0x02; +const FW_CFG_MAX_FILE_PATH: u32 = 56; +const FW_CFG_SIG_SIZE: u32 = 4; + +type FWCfgCallbackType = Box<dyn FWCfgCallback + Send + Sync>; +type FWCfgWriteCallbackType = Box<dyn FWCfgWriteCallback + Send + Sync>; + +pub struct FWCfgEntry { + data: Vec<u8>, + pub select_cb: Option<FWCfgCallbackType>, + write_cb: Option<FWCfgWriteCallbackType>, + allow_write: bool, +} + +impl FWCfgEntry { + pub fn new( + data: Vec<u8>, + select_cb: Option<FWCfgCallbackType>, + write_cb: Option<FWCfgWriteCallbackType>, + allow_write: bool, + ) -> Self { + FWCfgEntry { + data, + select_cb, + write_cb, + allow_write, + } + } +} + +pub trait FWCfgCallback { + fn select_callback(&mut self); +} + +pub trait FWCfgWriteCallback { + fn write_callback(&mut self); +} + +pub struct FWCfgFile { + size: u32, + select: u16, + reserved: u16, + name: String, +} + +impl FWCfgFile { + pub fn new(size: u32, select: u16, reserved: u16, name: String) -> Self { + FWCfgFile { + size, + select, + reserved, + name, + } + } +} + +impl PartialEq for FWCfgFile { + fn eq(&self, other: &Self) -> bool { + self.name.to_string() == other.name.to_string() + } +} + +impl Eq for FWCfgFile {} + +impl Ord for FWCfgFile { + fn cmp(&self, other: &Self) -> Ordering { + self.name.cmp(&other.name) + } +} + +impl PartialOrd for FWCfgFile { + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { + Some(self.cmp(other)) + } +} + +const FW_CFG_VMCOREINFO_FILENAME: &str = "etc/vmcoreinfo"; +const FW_CFG_VMCOREINFO_FORMAT_NONE: u8 = 0x0; +const FW_CFG_VMCOREINFO_FORMAT_ELF: u8 = 0x1; + +pub struct FWCfgVmcoreInfo { + host_format: u16, + guest_format: u16, + size: u32, + paddr: u64, +} + +/// FW_CFG_DMA_CONTROL bits +const FW_CFG_DMA_CTL_ERROR: u32 = 0x01; +const FW_CFG_DMA_CTL_READ: u32 = 0x02; +const FW_CFG_DMA_CTL_SKIP: u32 = 0x04; +const FW_CFG_DMA_CTL_SELECT: u32 = 0x08; +const FW_CFG_DMA_CTL_WRITE: u32 = 0x10; + +#[repr(C)] +#[derive(Copy, Clone, Default)] +pub struct FWCfgDmaAccess { + control: u32, + length: u32, + address: u64, +} + +impl ByteCode for FWCfgDmaAccess {} + +impl FWCfgDmaAccess { + pub fn new(control: u32, length: u32, address: u64) -> Self { + FWCfgDmaAccess { + control, + length, + address, + } + } +} + +pub fn dma_memory_set( + addr_space: &Arc<AddressSpace>, + addr: GuestAddress, + char: u8, + len: u64, +) -> Result<()> { + const FILLBUF_SIZE: usize = 512; + let fillbuf: &[u8; FILLBUF_SIZE] = &[char; FILLBUF_SIZE]; + + addr_space.write(&mut fillbuf.as_ref(), addr, len)?; + Ok(()) +} + +pub fn dma_memory_write( + addr_space: &Arc<AddressSpace>, + addr: GuestAddress, + mut buf: &[u8], + len: u64, +) -> Result<()> { + addr_space.write(&mut buf, addr, len)?; + Ok(()) +} + +pub fn dma_memory_read( + addr_space: &Arc<AddressSpace>, + addr: GuestAddress, + mut buf: &mut [u8], + len: u64, +) -> Result<()> { + addr_space.read(&mut buf, addr, len)?; + Ok(()) +} + +pub fn dma_result_write( + addr_space: &Arc<AddressSpace>, + addr: GuestAddress, + value: u32, +) -> Result<()> { + let mut dma_buf: [u8; 4] = [0; 4]; + BigEndian::write_u32(&mut dma_buf, value); + dma_memory_write( + addr_space, + addr.unchecked_add(offset_of!(FWCfgDmaAccess, control) as u64), + &dma_buf, + dma_buf.len() as u64, + )?; + Ok(()) +} + +fn extract64(value: u64, start: i32, length: i32) -> u64 { + assert!(start >= 0 && length > 0 && length < 64 - start); + + (value >> start as u64) & (!(0 as u64) >> (64 - length) as u64) +} + +fn get_key_name(key: usize) -> &'static str { + static fw_cfg_keys: [&str; 25] = [ + "signature", + "id", + "uuid", + "ram_size", + "nographic", + "nb_cpus", + "machine_id", + "kernel_addr", + "kernel_size", + "kernel_cmdline", + "initrd_size", + "boot_device", + "numa", + "boot_menu", + "max_cpus", + "kernel_entry", + "kernel_data", + "initrd_data", + "cmdline_addr", + "cmdline_size", + "cmdline_data", + "setup_addr", + "setup_size", + "setup_data", + "file_dir", + ]; + return fw_cfg_keys[key]; +} + +pub struct FWCfgCommon { + file_slots: u16, + local_entries: Vec<FWCfgEntry>, + entries: Vec<FWCfgEntry>, + files: Vec<FWCfgFile>, + cur_entry: u16, + cur_offset: u32, + + dma_enabled: bool, + dma_addr: GuestAddress, + + /// System address space. + mem_space: Arc<AddressSpace>, +} + +impl FWCfgCommon { + pub fn new(sys_mem: Arc<AddressSpace>) -> Self { + FWCfgCommon { + file_slots: FW_CFG_FILE_SLOTS_DFLT as u16, + local_entries: Vec::new(), + entries: Vec::new(), + files: Vec::new(), + cur_entry: 0, + cur_offset: 0, + dma_enabled: true, + dma_addr: GuestAddress(0), + mem_space: sys_mem, + } + } + + fn fw_cfg_max_entry(&self) -> u16 { + FW_CFG_FILE_FIRST + self.file_slots + } + + /// QEMU v2.4+ does not support write anymore + fn fw_cfg_write(&self, _value: u8) {} + + pub fn fw_cfg_get_entry(&mut self) -> Option<&mut FWCfgEntry> { + let is_local = (self.cur_entry & FW_CFG_ARCH_LOCAL as u16) > 0; + + let mut entry = None; + if self.cur_entry != FW_CFG_INVALID { + if is_local { + entry = self + .local_entries + .get_mut((self.cur_entry & FW_CFG_ENTRY_MASK) as usize) + } else { + entry = self + .entries + .get_mut((self.cur_entry & FW_CFG_ENTRY_MASK) as usize) + } + } + entry + } + + pub fn fw_cfg_select(&mut self, key: u16) -> i32 { + let mut ret = 0; + + self.cur_offset = 0; + if (key & FW_CFG_ENTRY_MASK) >= self.fw_cfg_max_entry() { + self.cur_entry = FW_CFG_INVALID; + ret = 0; + } else { + self.cur_entry = key; + ret = 1; + + // TODO Invoke callback here + let entry = self.fw_cfg_get_entry().unwrap(); + entry.select_cb.as_mut().unwrap().select_callback(); + } + + debug!("fw_cfg_select key {} ret {}", key, ret); + ret + } + + fn fw_cfg_dma_transfer(&mut self) { + let dma_addr = self.dma_addr; + let mem_space = self.mem_space.clone(); + let mut cur_offset = self.cur_offset; + let cur_entry = self.cur_entry; + + // Reset dma_addr address before next dma access + self.dma_addr = GuestAddress(0); + + let mut default = FWCfgDmaAccess::default(); + let mut dma_buf = default.as_mut_bytes(); + + // Read DMA request from guest + let size = std::mem::size_of::<FWCfgDmaAccess>() as u64; + if let Err(_) = dma_memory_read(&self.mem_space, dma_addr, dma_buf, size) { + dma_result_write(&self.mem_space, dma_addr, FW_CFG_DMA_CTL_ERROR); + } + + // Build FWCfgDmaAccess object here + let dma = FWCfgDmaAccess::from_mut_bytes(&mut dma_buf).unwrap(); + + if dma.control & FW_CFG_DMA_CTL_SELECT > 0 { + self.fw_cfg_select((dma.control >> 16) as u16); + } + + // Note a mutable borrow here + let entry = self.fw_cfg_get_entry().unwrap(); + let mut read = false; + let mut write = false; + + if dma.control & FW_CFG_DMA_CTL_READ != 0 { + read = true; + write = false; + } else if dma.control & FW_CFG_DMA_CTL_WRITE != 0 { + read = false; + write = true; + } else if dma.control & FW_CFG_DMA_CTL_SKIP != 0 { + dma.length = 0; + } + + dma.control = 0; + let mut len: u32 = 0; + + while dma.length > 0 && (dma.control & FW_CFG_DMA_CTL_ERROR) != 0 { + if cur_entry == FW_CFG_INVALID + || !entry.data.is_empty() + || cur_offset >= entry.data.len() as u32 + { + len = dma.length; + } + + if read { + if let Err(_) = dma_memory_set(&mem_space, GuestAddress(dma.address), 0, len as u64) + { + dma.control |= FW_CFG_DMA_CTL_ERROR; + } + + if write { + dma.control |= FW_CFG_DMA_CTL_ERROR; + } + } else { + if dma.length <= entry.data.len() as u32 - cur_offset { + len = dma.length; + } else { + len = entry.data.len() as u32 - cur_offset; + } + + if read { + if let Err(_) = dma_memory_write( + &mem_space, + GuestAddress(dma.address), + &entry.data[cur_offset as usize..], + len as u64, + ) { + dma.control |= FW_CFG_DMA_CTL_ERROR; + } + } + + if write { + let mut dma_read_error = false; + let data = &mut entry.data[cur_offset as usize..]; + if let Err(_) = + dma_memory_read(&mem_space, GuestAddress(dma.address), data, len as u64) + { + dma_read_error = true; + } + + if dma_read_error || !entry.allow_write || len != dma.length { + dma.control |= FW_CFG_DMA_CTL_ERROR; + } else if true { + // TODO invoke write callback + } + } + cur_offset += len; + } + + dma.length += len; + dma.address += len as u64 + } + dma_result_write(&self.mem_space, dma_addr, dma.control); + debug!("fw_cfg dma tranfer"); + } + + pub fn fw_cfg_add_entry( + &mut self, + key: u16, + select_cb: Option<FWCfgCallbackType>, + write_cb: Option<FWCfgWriteCallbackType>, + data: Vec<u8>, + allow_write: bool, + ) { + let is_local = key & FW_CFG_ARCH_LOCAL > 0; + + assert!(key < self.fw_cfg_max_entry() && data.len() < std::u32::MAX as usize); + + let mut entry; + if is_local { + entry = &mut self.local_entries[key as usize]; + } else { + entry = &mut self.entries[key as usize]; + } + + entry.data = data; + entry.select_cb = select_cb; + entry.write_cb = write_cb; + entry.allow_write = allow_write; + } + + pub fn fw_cfg_update_entry_data(&mut self, key: u16, data: Vec<u8>) { + let is_local = key & FW_CFG_ARCH_LOCAL > 0; + + assert!(key < self.fw_cfg_max_entry() && data.len() < std::u32::MAX as usize); + + let mut entry; + if is_local { + entry = &mut self.local_entries[key as usize]; + } else { + entry = &mut self.entries[key as usize]; + } + + entry.data = data; + entry.allow_write = false; + } + + pub fn fw_cfg_add_entry_data(&mut self, key: u16, data: Vec<u8>) { + debug!("fw_cfg_add_data key {} ", get_key_name(key as usize)); + + self.fw_cfg_add_entry(key, None, None, data, true); + } + + pub fn fw_cfg_entry_add_string(&mut self, key: u16, value: &str) { + self.fw_cfg_update_entry_data(key, value.as_bytes().to_vec()); + } + + pub fn fw_cfg_add_file_callback(&mut self, + filename: &str, + data: Vec<u8>, + select_cb: Option<FWCfgCallbackType>, + write_cb: Option<FWCfgWriteCallbackType>, + allow_write: bool) -> Result<()> { + let len = self.files.len(); + assert!(len < self.file_slots as usize); + let mut index = len; + loop { + if filename.to_string() < self.files[index - 1].name.to_string() { + index -= 1; + } else { + break; + } + } + + let mut i = 0; + // check duplicate file + for f in self.files.iter() { + if f.name == filename && i != index { + bail!("duplicate fw_cfg file name {}", filename); + } + i += 1; + } + + let entry = FWCfgEntry::new(data, select_cb, write_cb, allow_write); + self.local_entries.insert(index + FW_CFG_FILE_FIRST as usize, entry); + let file = FWCfgFile::new(BigEndian::read_u32((len as u32).as_bytes()), + BigEndian::read_u16(((index + FW_CFG_FILE_FIRST as usize) as u16).as_bytes()), + 0, filename.to_string()); + self.files.push(file); + self.files.sort(); + Ok(()) + } + + pub fn fw_cfg_add_file(&mut self, filename: &str, data: Vec<u8>) { + self.fw_cfg_add_file_callback(filename, data, None, None, false); + } + + pub fn fw_cfg_dma_mem_write(&mut self, addr: GuestAddress, value: u64, size: u32) { + if size == 4 { + if addr == GuestAddress(0) { + self.dma_addr = GuestAddress(value << 32); + } else if addr == GuestAddress(4) { + self.dma_addr = GuestAddress(self.dma_addr.raw_value() | size as u64); + self.fw_cfg_dma_transfer(); + } + } else if size == 8 && addr == GuestAddress(0) { + self.dma_addr = GuestAddress(value); + self.fw_cfg_dma_transfer(); + } + } + + pub fn fw_cfg_dma_mem_read(&self, addr: GuestAddress, size: u32) -> u64 { + extract64( + FW_CFG_DMA_SIGNATURE as u64, + ((8 - addr.raw_value() - size as u64) * 8) as i32, + (size * 8) as i32, + ) + } + + pub fn fw_cfg_data_read(&mut self, addr: GuestAddress, mut size: u32) -> u64 { + let mut value: u64 = 0; + let cur_entry = self.cur_entry; + let cur_offset = self.cur_offset; + + let entry = self.fw_cfg_get_entry().unwrap(); + let SIZE_U64 = std::mem::size_of::<u64>() as u32; + assert!(size > 0 && size < SIZE_U64); + if cur_entry != FW_CFG_INVALID + && !entry.data.is_empty() + && cur_offset < entry.data.len() as u32 + { + let mut offset = cur_offset; + loop { + value = (value << 8) | entry.data[offset as usize] as u64; + offset += 1; + size -= 1; + + if size < 0 || offset >= entry.data.len() as u32 { + break; + } + } + value = 8 * size as u64; + } + + debug!( + "fw_cfg_data_read 0x{:x} size {} value 0x{:x}", + addr.raw_value(), + size, + value + ); + value + } + + pub fn fw_cfg_common_realize(&mut self) { + self.local_entries = Vec::with_capacity(self.fw_cfg_max_entry() as usize); + self.entries = Vec::with_capacity(self.fw_cfg_max_entry() as usize); + + self.fw_cfg_add_entry_data( + FWCfgEntryType::FW_CFG_SIGNATURE as u16, + "QEMU".as_bytes().to_vec(), + ); + + // TODO add real uuid here + self.fw_cfg_add_entry_data( + FWCfgEntryType::FW_CFG_UUID as u16, + "49c9bedd6459b52a".as_bytes().to_vec(), + ); + + self.fw_cfg_add_entry_data( + FWCfgEntryType::FW_CFG_NOGRAPHIC as u16, + (0 as u16).as_bytes().to_vec(), + ); + + self.fw_cfg_add_entry_data( + FWCfgEntryType::FW_CFG_BOOT_MENU as u16, + (0 as u16).as_bytes().to_vec(), + ); + + let version = FW_CFG_VERSION & FW_CFG_VERSION_DMA; + self.fw_cfg_add_entry_data( + FWCfgEntryType::FW_CFG_ID as u16, + version.as_bytes().to_vec(), + ); + } +} + +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct FWCfgConfig {} + +/// Emulate FWCfg MMIO Device +pub struct FWCfgMem { + fwcfg: FWCfgCommon, + data_width: u32, +} + + +impl FWCfgMem { + pub fn new(sys_mem: Arc<AddressSpace>) -> Self { + FWCfgMem { + fwcfg: FWCfgCommon::new(sys_mem), + data_width: 8, + } + } + + pub fn fw_cfg_data_mem_write(&self, _addr: GuestAddress, value: u64, size: u32) { + let mut i = size; + loop { + i -= 1; + self.fwcfg.fw_cfg_write((value >> (8 * i) as u64) as u8); + if i == 0 { + break; + } + } + } + + pub fn fw_cfg_ctl_mem_read(&self, _addr: GuestAddress, _size: u32) -> u64 { + 0 + } + + pub fn fw_cfg_ctl_mem_write(&mut self, _addr: GuestAddress, value: u64, _size: u32) { + self.fwcfg.fw_cfg_select(value as u16); + } +} + +impl DeviceOps for FWCfgMem { + fn read(&mut self, data: &mut [u8], base: GuestAddress, offset: u64) -> bool { + let mut value = 0; + match offset { + 0..=7 => { + value = self.fwcfg.fw_cfg_data_read(base, data.len() as u32); + } + 8..=15 => { + value = self.fw_cfg_ctl_mem_read(base, data.len() as u32); + } + _ => { + self.fwcfg.fw_cfg_dma_mem_read(base, data.len() as u32); + } + } + + BigEndian::write_u64(data, value); + true + } + + fn write(&mut self, data: &[u8], base: GuestAddress, offset: u64) -> bool { + let mut value = 0; + let size = data.len() as u32; + value = BigEndian::read_u64(data); + match offset { + 0..=7 => { + self.fw_cfg_data_mem_write(base, value, size); + } + 8..=15 => { + self.fw_cfg_ctl_mem_write(base, value, size); + } + _ => { + self.fwcfg.fw_cfg_dma_mem_write(base, value, size); + } + } + true + } +} + +impl MmioDeviceOps for FWCfgMem { + /// Realize FWCfgMem device when VM started. + fn realize(&mut self, _vm_fd: &VmFd, _resource: DeviceResource) -> Result<()> { + self.fwcfg.fw_cfg_common_realize(); + Ok(()) + } + + /// Get device type. + fn get_type(&self) -> DeviceType { + DeviceType::FWCFG + } +} + +/// Emulate FWCfg IO device +pub struct FWCfgIO { + fwcfg: FWCfgCommon, +} + +impl FWCfgIO { + pub fn new(sys_mem: Arc<AddressSpace>) -> Self { + FWCfgIO { + fwcfg: FWCfgCommon { + file_slots: FW_CFG_FILE_SLOTS_DFLT as u16, + local_entries: Vec::new(), + entries: Vec::new(), + files: Vec::new(), + cur_entry: 0, + cur_offset: 0, + dma_enabled: true, + dma_addr: GuestAddress(0), + mem_space: sys_mem, + }, + } + } + + pub fn fw_cfg_comb_write(&mut self, _addr: GuestAddress, value: u64, size: u32) { + match size { + 1 => { + self.fwcfg.fw_cfg_write(value as u8); + } + 2 => { + self.fwcfg.fw_cfg_select(value as u16); + } + _ => return, + } + } +} + +impl DeviceOps for FWCfgIO { + fn read(&mut self, data: &mut [u8], base: GuestAddress, offset: u64) -> bool { + let mut value = 0; + match offset { + 1..=2 => { + value = self.fwcfg.fw_cfg_data_read(base, data.len() as u32); + } + 15..=23 => { + value = self.fwcfg.fw_cfg_dma_mem_read(base, data.len() as u32); + } + _ => error!("invalid read of set in FWCfgIO"), + } + LittleEndian::write_u64(data, value); + true + } + + fn write(&mut self, data: &[u8], base: GuestAddress, offset: u64) -> bool { + let mut value = 0; + let size = data.len() as u32; + value = LittleEndian::read_u64(data); + match offset { + 1..=2 => { + self.fw_cfg_comb_write(base, value, size); + } + 15..=23 => { + self.fwcfg.fw_cfg_dma_mem_write(base, value, size); + } + _ => {} + } + true + } +} diff --git a/device_model/src/legacy/mod.rs b/device_model/src/legacy/mod.rs index f840656..bd8970e 100644 --- a/device_model/src/legacy/mod.rs +++ b/device_model/src/legacy/mod.rs @@ -25,9 +25,20 @@ //! - `x86_64` //! - `aarch64` mod serial; + pub use self::serial::Serial; #[cfg(target_arch = "aarch64")] mod pl031; + #[cfg(target_arch = "aarch64")] pub use self::pl031::PL031; + +#[cfg(target_arch = "aarch64")] +mod fw_cfg; + +#[cfg(target_arch = "aarch64")] +pub use self::fw_cfg::FWCfgMem; +#[cfg(target_arch = "aarch64")] +pub use self::fw_cfg::FWCfgConfig; + diff --git a/device_model/src/micro_vm/mod.rs b/device_model/src/micro_vm/mod.rs index 94a3e3f..6751f8d 100644 --- a/device_model/src/micro_vm/mod.rs +++ b/device_model/src/micro_vm/mod.rs @@ -983,6 +983,26 @@ impl MainLoopManager for LightMachine { } } +/// Function that helps to generate fw-cfg node in device-tree. +/// +/// # Arguments +/// +/// * `dev_info` - Device resource info of fw-cfg device. +/// * `fdt` - Flatted device-tree blob where fw-cfg node will be filled into. +#[cfg(target_arch = "aarch64")] +fn generate_fwcfg_device_node( + dev_info: &DeviceResource, + fdt: &mut Vec<u8>, +) -> util::errors::Result<()> { + let node = format!("/fw-cfg@{:x}", dev_info.addr); + device_tree::add_sub_node(fdt, &node)?; + device_tree::set_property_string(fdt, &node, "compatible", "qemu,fw-cfg-mmio")?; + device_tree::set_property_array_u64(fdt, &node, "reg", &[dev_info.addr, dev_info.size])?; + + Ok(()) +} + + /// Function that helps to generate serial node in device-tree. /// /// # Arguments @@ -1216,6 +1236,7 @@ impl CompileFDTHelper for LightMachine { device_tree::set_property_string(fdt, node, "compatible", "arm,psci-0.2")?; device_tree::set_property_string(fdt, node, "method", "hvc")?; + for dev_info in self.bus.get_devices_info().iter().rev() { match dev_info.dev_type { DeviceType::SERIAL => { @@ -1224,6 +1245,9 @@ impl CompileFDTHelper for LightMachine { DeviceType::RTC => { generate_rtc_device_node(dev_info, fdt)?; } + DeviceType::FWCFG => { + generate_fwcfg_device_node(dev_info, fdt)?; + } _ => { generate_virtio_devices_node(dev_info, fdt)?; } diff --git a/device_model/src/mmio/bus.rs b/device_model/src/mmio/bus.rs index 79132b9..3fe8c7c 100644 --- a/device_model/src/mmio/bus.rs +++ b/device_model/src/mmio/bus.rs @@ -184,6 +184,15 @@ impl Bus { } } } + DeviceType::FWCFG => { + #[cfg(target_arch = "aarch64")] + DeviceResource { + addr: MEM_LAYOUT[LayoutEntryType::FwCfg as usize].0, + size: MEM_LAYOUT[LayoutEntryType::FwCfg as usize].1, + irq: 0, + dev_type: device_type, + } + } _ => DeviceResource { addr: MMIO_BASE + index as u64 * MMIO_LEN, size: MMIO_LEN, diff --git a/device_model/src/mmio/mod.rs b/device_model/src/mmio/mod.rs index d2f6295..4ac532f 100644 --- a/device_model/src/mmio/mod.rs +++ b/device_model/src/mmio/mod.rs @@ -65,6 +65,7 @@ pub enum DeviceType { SERIAL, #[cfg(target_arch = "aarch64")] RTC, + FWCFG, OTHER, } -- 2.23.0

1 4

会议纪要2020-12-16//RE: [Dev] virt sig meeting
by Chenzhendong (alex) 21 Dec '20

21 Dec '20

会议纪要：一、openEuler 20.03 LTS SP1： 1）5个特性均已经测试完。二、openEuler 21.03： a) Qemu+kvm：热迁移pro，提升热迁移性能和安全，已经合入qemu主干，已经回合至openeuler；vmtop支持X86 完成70%，内核patch和用户态patch都已整理完成，内核代码待linux 5.10发布后发起合入，用户态已经发起PR检视中。 b) Risc-v：支持热迁移；支持vhost的ioeventfd方案，代码已经合入riscv分支； c) StratoVirt： i. 轻量级虚拟化：支持内存弹性，代码已经合入；支持arm和X86，代码已经合入； ii. 标准虚拟化：支持PCI，基础框架开发进度100%，x86 host bridge进度50%，同时在开发设备管理面通用框架； PCI，ACPI，UEFI的对接在x86平台对接完成，arm平台等待UEFI开发完成，PCI当前问题较多。vfio 代码完成80%； iii. 性能优化：支持iothread，已经完成开发，完成代码合入； iv. 安全优化：支持sechoop启动，代码开发完成80%，正在对接kata；namespace隔离完成代码开发和自验证，待合入代码；另外在做安全、可靠性方面的测试。三、EulerRobot进展： 1、编译及UT执行均已支持；地址消毒已经对接UT版本； 2、AT已完成对接LTS及DailyBuild版本（剩下存在双主机问题待解决）；ST已经开始调试对接中。 3、性能测试与Qemu upstream社区沟通0-Day性能中，计划近期整理性能测试方案。 4、Qemu Fuzz测试能力调研构建中。 From: openEuler conference [mailto:public@openeuler.io] Sent: Tuesday, December 15, 2020 6:23 PM To: virt(a)openeuler.org; dev(a)openeuler.org Subject: [Dev] virt sig meeting 您好！ openEuler Virt SIG 邀请您参加 2020-12-16 14:30 召开的ZOOM会议会议主题：virt sig meeting 会议内容：sp1和21.03进展 euler robot进展会议链接：https://zoom.us/j/98425078731?pwd=SXptRUZiY2tnWlBpNWVDVEp4d21Odz09 更多资讯尽在：https://openeuler.org/zh/ Hello! openEuler Virt SIG invites you to attend the ZOOM conference will be held at 2020-12-16 14:30, The subject of the conference is virt sig meeting, Summary: sp1和21.03进展 euler robot进展 You can join the meeting at https://zoom.us/j/98425078731?pwd=SXptRUZiY2tnWlBpNWVDVEp4d21Odz09. More information<https://openeuler.org/zh/>

1 0

StratoVirt 修改kvm-ioctls和kvm-bindings的依赖版本
by Xufei (VF) 21 Dec '20

21 Dec '20

1 0

StratoVirt block模块用例增加
by Xufei (VF) 21 Dec '20

21 Dec '20

1 0

StratoVirt linux kernel编译配置文件修改、内存布局修改、device_model内存模块的代码和用例优化patch
by Xufei (VF) 21 Dec '20

21 Dec '20

1 0

为什么你一定要参加 openEuler Summit 的 TC、Maintainer、SIG 组工作会议
by public openEuler 16 Dec '20

16 Dec '20

嗨，各位 openEuler 社区的开发者：很高兴能够向你们汇报 openEuler Summit 的会议进度。对于各位来说，本周最重要的事情是 TC、Maintainer和SIG 组开放工作会议的议程已经上线了。 *为什么你一定要参与 TC、Maintainer、SIG组开放工作会议？* 1. 你可以清楚的了解 openEuler 社区的运作模式 2. 你可以和 TC、Maintainer、SIG 的成员共同探讨openEuler 社区的下一个版本的计划和技术路线 3. 可以跟社区里的技术大佬进行面对面交流。 4. 更好的规划自己在社区中的成长路线 *会议时间和房间号：* TC 开放工作会议 Maintainer 开放工作会议 SIG 组开放工作会议时间 12/24 13:00-14:30 12/24 15:00-17:00 12/25 13:00-15:30 房间号悦府6和悦府7 悦府6和悦府7 大宴会厅B *TC **开放工作会议议程：* 1. 讨论 openEuler 支持 App Stream 机制 2. 申请成立智能运维 SIG 3. 讨论从 Gitee issue 整体切换到bugzilla 4. 讨论2021年 TC 合作的开展方式 5. …… *Maintainer **开放工作会议议程* 1. 开场 & 颁发 Maintainer 纪念徽章 2. openEuler 社区运作分析 3. 我在 openEuler 社区担任 Maintainer 的那些事儿 4. 自由问答 5. 总结 *参与本次 SIG 组开放工作会议的 SIG 组：* 1. sig-DDE 2. sig-UKUI 3. sig-Ha 4. sig-arrch32 5. A-Tune 6. iSulad & Container 7. sig-ai-bitdata 8. sig-security-facility 9. sig-confidential-computing 10. Compiler 11. Doc 12. Infrastructure 13. security-committee 14. sig-Compatibility-Infra 15. sig-QA 16. sig-release-management 17. Kernel 18. Virt *openEuler Summit **专属伴手礼：* [image: image.png] *openEuler **卫衣* [image: image.png] *openEuler Maintainer **纪念徽章* *欢迎通过openEuler 社区开发者专属的报名渠道报名：* https://etherpad.openeuler.org/p/openEuler-Summit-2020 openEuler Summit 官网： https://openeuler.org/zh/interaction/summit-list/

1 0

Regarding contributing in Open Euler community
by Sayalee Mankar 16 Dec '20

16 Dec '20

Hello Team, Hope you are doing good. I am Sayalee from Click2Cloud Inc. We are interested to register our CEO, Mr. Prashant Mishra for technical chair in community of Open Euler. It will be really grateful if you can suggest me what will be the procedure of joining the community or can connect me with right point of contact.. Looking forward to hearing from you soon. Thanks, Sayalee

1 0

virt sig meeting
by openEuler conference 15 Dec '20

15 Dec '20

1 0

StratoVirt内存模块增加get_file_backend接口
by Xufei (VF) 14 Dec '20

14 Dec '20

1 0