Add CFI flash emulation
v4 cover Add CFI flash emulation
Hi,
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.
In addition to a branch with this series[1], I also put a git branch with all the changes compared to v3[2] as separate patches on the server, please have a look if you want to verify against a previous review.
===============
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, and looks like a generic standard, this series adds a CFI flash emulation to kvmtool.
Patch 2/5 is the actual emulation code, patch 1/5 is a bug-fix for registering MMIO devices, which is needed for this device. Patches 3-5 add support for mapping the flash memory into guest, should it be in read-array mode. For this to work, patch 3/5 is cherry-picked from Alex' PCIe reassignable BAR series, to support removing a memslot mapping. Patch 4/5 adds support for read-only mappings, while patch 5/5 adds or removes the mapping based on the current state.
I am happy to squash 5/5 into 2/5, if we agree that patch 3/5 should be merged either separately or the PCIe series is actually merged before this one.
This is one missing piece towards a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP. This series alone already enables UEFI boot, but only with virtio-mmio.
Cheers,
Andre
[1] http://www.linux-arm.org/git?p=kvmtool.git;a=log;h=refs/heads/cfi-flash/v4
[2] http://www.linux-arm.org/git?p=kvmtool.git;a=log;h=refs/heads/cfi-flash/v3git://linux-arm.org/kvmtool.git (branches cfi-flash/v3 and cfi-flash/v4)
Changelog v3 .. v4:
- Rename file to cfi-flash.c (dash instead of underscore).
- Unify macro names for states, modes and commands.
- Enforce one or two chips only.
- Comment on pow2_size() function.
- Use more consistent identifier spellings.
- Assign symbols to status register values.
- Drop RCR register emulation.
- Use numerical offsets instead of names for query offsets to match spec.
- Cleanup error path and reword info message in create_flash_device_file().
- Add fix to allow non-virtio MMIO device emulations.
- Support tearing down and adding read-only memslots.
- Add read-only memslot mapping when in read mode.
Changelog v2 .. v3:
- Breaking MMIO handling into three separate functions.
- Assing the flash base address in the memory map, but stay at 32 MB for now. The MMIO area has been moved up to 48 MB, to never overlap with the flash.
- Impose a limit of 16 MB for the flash size, mostly to fit into the (for now) fixed memory map.
- Trim flash size down to nearest power-of-2, to match hardware.
- Announce forced flash size trimming.
- Rework the CFI query table slightly, to add the addresses as array indicies.
- Fix error handling when creating the flash device.
- Fix pow2_size implementation for 0 and 1 as input values.
- Fix write buffer size handling.
- Improve some comments.
Changelog v1 .. v2:
- Add locking for MMIO handling.
- Fold flash read into handler.
- Move pow2_size() into generic header.
- Spell out flash base address.
PATCH v4 1/5 virtio-mmio: Assign IRQ line directly before registering device
At the moment the IRQ line for a virtio-mmio device is assigned in the generic device__register() routine in devices.c, by calling back into virtio-mmio.c. This does not only sound slightly convoluted, but also breaks when we try to register an MMIO device that is not a virtio-mmio device. In this case container_of will return a bogus pointer (as it assumes a struct virtio_mmio), and the IRQ allocation routine will corrupt some data in the device_header (for instance the first byte of the "data" pointer).
Simply assign the IRQ directly in virtio_mmio_init(), before calling device__register(). This avoids the problem and looks actually much more straightforward.
--- devices.c | 4 ---- include/kvm/virtio-mmio.h | 1 - virtio/mmio.c | 10 ++-------- 3 files changed, 2 insertions(+), 13 deletions(-)
devices.c +0 -4
@@ -1,7 +1,6 @@#include "kvm/devices.h" #include "kvm/kvm.h" #include "kvm/pci.h" -#include "kvm/virtio-mmio.h" #include <linux/err.h> #include <linux/rbtree.h>
@@ -33,9 +32,6 @@ int device__register(struct device_header *dev)case DEVICE_BUS_PCI :pci__assign_irq (dev);break ; -case DEVICE_BUS_MMIO : -virtio_mmio_assign_irq (dev); -break ;default :break ; }
include/kvm/virtio-mmio.h +0 -1
@@ -57,5 +57,4 @@ int virtio_mmio_exit(struct kvm *kvm, struct virtio_device *vdev);int virtio_mmio_reset (struct kvm *kvm,struct virtio_device *vdev);int virtio_mmio_init (struct kvm *kvm,void *dev,struct virtio_device *vdev,int device_id,int subsys_id,int class); -void virtio_mmio_assign_irq (struct device_header *dev_hdr);#endif
virtio/mmio.c +2 -8
@@ -280,14 +280,6 @@ static void generate_virtio_mmio_fdt_node(void *fdt, }#endif -void virtio_mmio_assign_irq (struct device_header *dev_hdr) -{ -struct virtio_mmio *vmmio =container_of (dev_hdr, - struct virtio_mmio, - dev_hdr); - vmmio->irq =irq__alloc_line (); -} -int virtio_mmio_init (struct kvm *kvm,void *dev,struct virtio_device *vdev,int device_id,int subsys_id,int class) {
@@ -316,6 +308,8 @@ int virtio_mmio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev, .data = generate_virtio_mmio_fdt_node, }; + vmmio->irq =irq__alloc_line (); + r =device__register (&vmmio->dev_hdr);if (r <0 ) {kvm__deregister_mmio (kvm, vmmio->addr);
Signature · 1 line
2.17.1
Re: [PATCH kvmtool v4 1/5] virtio-mmio: Assign IRQ line directly before registering device
Quoted 33 lines · Andre Przywara
At the moment the IRQ line for a virtio-mmio device is assigned in the generic
device__register()routine indevices.c, by calling back intovirtio-mmio.c. This does not only sound slightly convoluted, but also breaks when we try to register an MMIO device that is not a virtio-mmio device. In this casecontainer_ofwill return a bogus pointer (as it assumes a structvirtio_mmio), and the IRQ allocation routine will corrupt some data in thedevice_header(for instance the first byte of the "data" pointer).Simply assign the IRQ directly in
virtio_mmio_init(), before callingdevice__register(). This avoids the problem and looks actually much more straightforward.Signed-off-by Andre Przywara <[email protected]>--- devices.c | 4 ---- include/kvm/virtio-mmio.h | 1 - virtio/mmio.c | 10 ++-------- 3 files changed, 2 insertions(+), 13 deletions(-)devices.c +0
-1@@ -1,7 +1,6 @@#include "kvm/devices.h" #include "kvm/kvm.h" #include "kvm/pci.h" -#include "kvm/virtio-mmio.h" #include <linux/err.h> #include <linux/rbtree.h>
devices.c int device__register(struct device_header *dev) · line 38
Quoted 6 lines
devices.c +0
-3@@ -33,9 +32,6 @@ int device__register(struct device_header *dev)case DEVICE_BUS_PCI :pci__assign_irq (dev);break ; -case DEVICE_BUS_MMIO : -virtio_mmio_assign_irq (dev); -break ;
Hmm, but then it's a bit ugly to handle these differently to PCI. How difficult is it to add a new bus type instead? e.g. stick the virtio mmio devices on DEVICE_BUS_VIRTIO_MMIO and then add the non-virtio MMIO devices to DEVICE_BUS_MMIO?
Will
Re: [PATCH kvmtool v4 1/5] virtio-mmio: Assign IRQ line directly before registering device
On 24/04/2020 09:41, Will Deacon wrote:
Hi Will,
thanks for having a look!
Quoted 31 lines · Andre Przywara
Quoted 30 lines
At the moment the IRQ line for a virtio-mmio device is assigned in the generic
device__register()routine indevices.c, by calling back intovirtio-mmio.c. This does not only sound slightly convoluted, but also breaks when we try to register an MMIO device that is not a virtio-mmio device. In this casecontainer_ofwill return a bogus pointer (as it assumes a structvirtio_mmio), and the IRQ allocation routine will corrupt some data in thedevice_header(for instance the first byte of the "data" pointer).Simply assign the IRQ directly in
virtio_mmio_init(), before callingdevice__register(). This avoids the problem and looks actually much more straightforward.Signed-off-by Andre Przywara <[email protected]>--- devices.c | 4 ---- include/kvm/virtio-mmio.h | 1 - virtio/mmio.c | 10 ++-------- 3 files changed, 2 insertions(+), 13 deletions(-)devices.c +0
-1@@ -1,7 +1,6 @@#include "kvm/devices.h" #include "kvm/kvm.h" #include "kvm/pci.h" -#include "kvm/virtio-mmio.h"
Quoted 14 lines
devices.c int device__register(struct device_header *dev) · line 38
Quoted 9 lines
devices.c +0
-3#include <linux/err.h> #include <linux/rbtree.h> @@ -33,9 +32,6 @@ int device__register(struct device_header *dev)case DEVICE_BUS_PCI :pci__assign_irq (dev);break ; -case DEVICE_BUS_MMIO : -virtio_mmio_assign_irq (dev); -break ;Hmm, but then it's a bit ugly to handle these differently to PCI. How difficult is it to add a new bus type instead? e.g. stick the virtio mmio devices on
DEVICE_BUS_VIRTIO_MMIOand then add the non-virtio MMIO devices toDEVICE_BUS_MMIO?
I have another patch to also do the IRQ allocation for PCI devices in their callers. This avoids the allocation on an IRQ for vesa, for instance, but otherwise doesn't solve a real problem, so I didn't post it yet.
By looking at devices.c, I feel like this should only be handling the administrative part of managing the device_header structs in the rbtree. Dealing with bus specific things looks out of scope for this file, IMHO.
If you agree, I will send the patch shortly.
Cheers,
Andre
Re: [PATCH kvmtool v4 1/5] virtio-mmio: Assign IRQ line directly before registering device
Quoted 35 lines · André Przywara
Quoted 11 lines · Will Deacon
Quoted 10 lines · Andre Przywara
devices.c +0
-1@@ -1,7 +1,6 @@#include "kvm/devices.h" #include "kvm/kvm.h" #include "kvm/pci.h" -#include "kvm/virtio-mmio.h" Quoted 14 lines
devices.c int device__register(struct device_header *dev) · line 38
Quoted 9 lines
devices.c +0
-3#include <linux/err.h> #include <linux/rbtree.h> @@ -33,9 +32,6 @@ int device__register(struct device_header *dev)case DEVICE_BUS_PCI :pci__assign_irq (dev);break ; -case DEVICE_BUS_MMIO : -virtio_mmio_assign_irq (dev); -break ;Hmm, but then it's a bit ugly to handle these differently to PCI. How difficult is it to add a new bus type instead? e.g. stick the virtio mmio devices on
DEVICE_BUS_VIRTIO_MMIOand then add the non-virtio MMIO devices toDEVICE_BUS_MMIO?I have another patch to also do the IRQ allocation for PCI devices in their callers. This avoids the allocation on an IRQ for vesa, for instance, but otherwise doesn't solve a real problem, so I didn't post it yet.
By looking atdevices.c, I feel like this should only be handling the administrative part of managing thedevice_headerstructs in the rbtree. Dealing with bus specific things looks out of scope for this file, IMHO.
Quoted 1 line
If you agree, I will send the patch shortly.
Yes please.
Will
PATCH v4 2/5 Add emulation for CFI compatible flash memory
In reply to Andre PrzywaraFrom: Raphael Gault <[email protected]>
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, we add a CFI flash emulation to kvmtool.
This is backed by a file, specified via the --flash or -F command line option. Any flash writes done by the guest will immediately be reflected into this file (kvmtool mmap's the file).
The flash will be limited to the nearest power-of-2 size, so only the first 2 MB of a 3 MB file will be used.
This implements a CFI flash using the "Intel/Sharp extended command set", as specified in:
- JEDEC JESD68.01
- JEDEC JEP137B
- Intel Application Note 646
Some gaps in those specs have been filled by looking at real devices and other implementations (QEMU, Linux kernel driver).
At the moment this relies on DT to advertise the base address of the flash memory (mapped into the MMIO address space) and is only enabled for ARM/ARM64. The emulation itself is architecture agnostic, though.
This is one missing piece toward a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP.
--- Makefile | 6 + arm/include/arm-common/kvm-arch.h | 8 +- builtin-run.c | 2 + hw/cfi_flash.c | 592 ++++++++++++++++++++++++++++++ include/kvm/kvm-config.h | 1 + include/kvm/util.h | 23 ++ 6 files changed, 630 insertions(+), 2 deletions(-) create mode 100644 hw/cfi_flash.c
Makefile +6 -0
@@ -170,6 +170,7 @@ ifeq ($(ARCH), arm) CFLAGS += -march=armv7-a ARCH_WANT_LIBFDT := y + ARCH_HAS_FLASH_MEM := y endif # ARM64
@@ -182,6 +183,7 @@ ifeq ($(ARCH), arm64) ARCH_INCLUDE += -Iarm/aarch64/include ARCH_WANT_LIBFDT := y + ARCH_HAS_FLASH_MEM := y endif ifeq ($(ARCH),mips)
@@ -261,6 +263,10 @@ ifeq (y,$(ARCH_HAS_FRAMEBUFFER)) endif endif +ifeq (y,$(ARCH_HAS_FLASH_MEM)) + OBJS += hw/cfi_flash.o +endif + ifeq ($(call try-build,$(SOURCE_ZLIB),$(CFLAGS),$(LDFLAGS) -lz),y) CFLAGS_DYNOPT += -DCONFIG_HAS_ZLIB LIBS_DYNOPT += -lz
arm/include/arm-common/kvm-arch.h +6 -2
@@ -8,7 +8,8 @@#include "arm-common/gic.h" #define ARM_IOPORT_AREA _AC(0x0000000000000000, UL) -#define ARM_MMIO_AREA _AC(0x0000000000010000, UL) +#define ARM_FLASH_AREA _AC(0x0000000002000000, UL) +#define ARM_MMIO_AREA _AC(0x0000000003000000, UL)#define ARM_AXI_AREA _AC(0x0000000040000000, UL)#define ARM_MEMORY_AREA _AC(0x0000000080000000, UL)
@@ -21,7 +22,10 @@#define ARM_GIC_DIST_SIZE 0x10000#define ARM_GIC_CPUI_SIZE 0x20000 -#define ARM_IOPORT_SIZE (ARM_MMIO_AREA - ARM_IOPORT_AREA) +#define KVM_FLASH_MMIO_BASE ARM_FLASH_AREA +#define KVM_FLASH_MAX_SIZE (ARM_MMIO_AREA - ARM_FLASH_AREA) + +#define ARM_IOPORT_SIZE (1U << 16)#define ARM_VIRTIO_MMIO_SIZE (ARM_AXI_AREA - (ARM_MMIO_AREA + ARM_GIC_SIZE))#define ARM_PCI_CFG_SIZE (1ULL << 24)#define ARM_PCI_MMIO_SIZE (ARM_MEMORY_AREA - \
builtin-run.c +2 -0
@@ -133,6 +133,8 @@ void kvm_run_set_wrapper_sandbox(void) "Kernel command line arguments"), \OPT_STRING ('f' ,"firmware" , &(cfg)->firmware_filename,"firmware" ,\"Firmware image to boot in virtual machine" ), \ +OPT_STRING ('F' ,"flash" , &(cfg)->flash_filename,"flash" ,\ +"Flash image to present to virtual machine" ), \ \OPT_GROUP ("Networking options:" ), \ OPT_CALLBACK_DEFAULT('n', "network", NULL, "network params", \
hw/cfi_flash.c new file +592 -0
592 lines not on this page · raw message
include/kvm/kvm-config.h +1 -0
@@ -35,6 +35,7 @@ struct kvm_config {const char *vmlinux_filename;const char *initrd_filename;const char *firmware_filename; +const char *flash_filename;const char *console;const char *dev;const char *network;
include/kvm/util.h +23 -0
@@ -106,6 +106,29 @@ static inline unsigned long roundup_pow_of_two(unsigned long x)#define is_power_of_two (x) ((x) > 0 ? ((x) & ((x) - 1)) == 0 : 0) +/** +* pow2_size: return the number of bits needed to store values +* @x: number of distinct values to store (or number of bytes) +* +* Determines the number of bits needed to store @x different values. +* Could be used to determine the number of address bits needed to +* store @x bytes. +* +* Example: +* pow2_size(255) => 8 +* pow2_size(256) => 8 +* pow2_size(257) => 9 +* +* Return: number of bits +*/ +static inline int pow2_size (unsigned long x) +{ +if (x <=1 ) +return x; + +return sizeof (x) *8 -__builtin_clzl (x -1 ); +} +struct kvm ;void *mmap_hugetlbfs (struct kvm *kvm,const char *htlbfs_path,u64 size);void *mmap_anon_or_hugetlbfs (struct kvm *kvm,const char *hugetlbfs_path,u64 size);
Signature · 1 line
2.17.1
PATCH v4 3/5 vfio: Destroy memslot when unmapping the associated VAs
In reply to Andre PrzywaraFrom: Alexandru Elisei <[email protected]>
When we want to map a device region into the guest address space, first we perform an mmap on the device fd. The resulting VMA is a mapping between host userspace addresses and physical addresses associated with the device. Next, we create a memslot, which populates the stage 2 table with the mappings between guest physical addresses and the device physical adresses.
However, when we want to unmap the device from the guest address space, we only call munmap, which destroys the VMA and the stage 2 mappings, but doesn't destroy the memslot and kvmtool's internal mem_bank structure associated with the memslot.
This has been perfectly fine so far, because we only unmap a device region when we exit kvmtool. This is will change when we add support for reassignable BARs, and we will have to unmap vfio regions as the guest kernel writes new addresses in the BARs. This can lead to two possible problems:
- We refuse to create a valid BAR mapping because of a stale mem_bank structure which belonged to a previously unmapped region.
- It is possible that the mmap in vfio_map_region returns the same address that was used to create a memslot, but was unmapped by vfio_unmap_region. Guest accesses to the device memory will fault because the stage 2 mappings are missing, and this can lead to performance degradation.
Let's do the right thing and destroy the memslot and the mem_bank struct associated with it when we unmap a vfio region. Set host_addr to NULL after the munmap call so we won't try to unmap an address which is currently used by the process for something else if vfio_unmap_region gets called twice.
--- include/kvm/kvm.h | 4 ++ kvm.c | 101 ++++++++++++++++++++++++++++++++++++++++------ vfio/core.c | 6 +++ 3 files changed, 99 insertions(+), 12 deletions(-)
include/kvm/kvm.h +4 -0
@@ -1,6 +1,7 @@#ifndef KVM__KVM_H #define KVM__KVM_H +#include "kvm/mutex.h" #include "kvm/kvm-arch.h" #include "kvm/kvm-config.h" #include "kvm/util-init.h"
@@ -56,6 +57,7 @@ struct kvm_mem_bank {void *host_addr;u64 size;enum kvm_mem_type type; +u32 slot; };struct kvm {
@@ -72,6 +74,7 @@ struct kvm {u64 ram_size;void *ram_start;u64 ram_pagesize; +struct mutex mem_banks_lock;struct list_head mem_banks;bool nmi_disabled;
@@ -106,6 +109,7 @@ void kvm__irq_line(struct kvm *kvm, int irq, int level);void kvm__irq_trigger (struct kvm *kvm,int irq);bool kvm__emulate_io (struct kvm_cpu *vcpu,u16 port,void *data,int direction,int size,u32 count);bool kvm__emulate_mmio (struct kvm_cpu *vcpu,u64 phys_addr,u8 *data,u32 len,u8 is_write); +int kvm__destroy_mem (struct kvm *kvm,u64 guest_phys,u64 size,void *userspace_addr);int kvm__register_mem (struct kvm *kvm,u64 guest_phys,u64 size,void *userspace_addr,enum kvm_mem_type type); static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
kvm.c +89 -12
153 lines not on this page · raw message
vfio/core.c +6 -0
@@ -256,8 +256,14 @@ int vfio_map_region(struct kvm *kvm, struct vfio_device *vdev,void vfio_unmap_region (struct kvm *kvm,struct vfio_region *region) { +u64 map_size; +if (region->host_addr) { + map_size =ALIGN (region->info.size,PAGE_SIZE ); +kvm__destroy_mem (kvm, region->guest_phys_addr, map_size, + region->host_addr);munmap (region->host_addr, region->info.size); + region->host_addr =NULL ; }else if (region->is_ioport) {ioport__unregister (kvm, region->port_base); }else {
Signature · 1 line
2.17.1
PATCH v4 4/5 memslot: Add support for READONLY mappings
In reply to Andre PrzywaraA KVM memslot has a flags field, which allows to mark a region as read-only.
Add another memory type bit to allow kvmtool-internal users to map a write-protected region. Write access would trap and can be handled by the MMIO emulation, which should register on the same guest address region.
--- include/kvm/kvm.h | 12 ++++++++---- kvm.c | 5 +++++ 2 files changed, 13 insertions(+), 4 deletions(-)
include/kvm/kvm.h +8 -4
@@ -40,10 +40,12 @@ enum kvm_mem_type {KVM_MEM_TYPE_RAM =1 <<0 ,KVM_MEM_TYPE_DEVICE =1 <<1 ,KVM_MEM_TYPE_RESERVED =1 <<2 , +KVM_MEM_TYPE_READONLY =1 <<3 ,KVM_MEM_TYPE_ALL =KVM_MEM_TYPE_RAM |KVM_MEM_TYPE_DEVICE |KVM_MEM_TYPE_RESERVED + |KVM_MEM_TYPE_READONLY }; struct kvm_ext {
@@ -158,17 +160,19 @@ u64 host_to_guest_flat(struct kvm *kvm, void *ptr);bool kvm__arch_load_kernel_image (struct kvm *kvm,int fd_kernel,int fd_initrd,const char *kernel_cmdline); +#define add_read_only (type, str) \ + (((type) & KVM_MEM_TYPE_READONLY) ? str " (read-only)" : str)static inline const char *kvm_mem_type_to_string (enum kvm_mem_type type) { -switch (type) { +switch (type & ~KVM_MEM_TYPE_READONLY ) {case KVM_MEM_TYPE_ALL :return "(all)" ;case KVM_MEM_TYPE_RAM : -return "RAM" ; +return add_read_only (type,"RAM" );case KVM_MEM_TYPE_DEVICE : -return "device" ; +return add_read_only (type,"device" );case KVM_MEM_TYPE_RESERVED : -return "reserved" ; +return add_read_only (type,"reserved" ); }return "???" ;
kvm.c +5 -0
@@ -242,6 +242,7 @@ int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size,struct kvm_mem_bank *bank;struct list_head *prev_entry;u32 slot; +u32 flags =0 ;int ret;mutex_lock (&kvm->mem_banks_lock);
@@ -313,9 +314,13 @@ int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, bank->type = type; bank->slot = slot; +if (type &KVM_MEM_TYPE_READONLY ) + flags |=KVM_MEM_READONLY ; +if (type !=KVM_MEM_TYPE_RESERVED ) { mem = (struct kvm_userspace_memory_region ) { .slot = slot, + .flags = flags, .guest_phys_addr = guest_phys, .memory_size = size, .userspace_addr = (unsigned long )userspace_addr,
Signature · 1 line
2.17.1
Re: [PATCH kvmtool v4 4/5] memslot: Add support for READONLY mappings
Quoted 31 lines · Andre Przywara
A KVM memslot has a flags field, which allows to mark a region as read-only.
Add another memory type bit to allow kvmtool-internal users to map a write-protected region. Write access would trap and can be handled by the MMIO emulation, which should register on the same guest address region.Signed-off-by Andre Przywara <[email protected]>--- include/kvm/kvm.h | 12 ++++++++---- kvm.c | 5 +++++ 2 files changed, 13 insertions(+), 4 deletions(-)include/kvm/kvm.h +2
-0@@ -40,10 +40,12 @@ enum kvm_mem_type {KVM_MEM_TYPE_RAM =1 <<0 ,KVM_MEM_TYPE_DEVICE =1 <<1 ,KVM_MEM_TYPE_RESERVED =1 <<2 , +KVM_MEM_TYPE_READONLY =1 <<3 ,KVM_MEM_TYPE_ALL =KVM_MEM_TYPE_RAM |KVM_MEM_TYPE_DEVICE |KVM_MEM_TYPE_RESERVED + |KVM_MEM_TYPE_READONLY }; struct kvm_ext {
include/kvm/kvm.h u64 host_to_guest_flat(struct kvm *kvm, void *ptr); · line 163
Quoted 4 lines
include/kvm/kvm.h +1
-0@@ -158,17 +160,19 @@ u64 host_to_guest_flat(struct kvm *kvm, void *ptr);bool kvm__arch_load_kernel_image (struct kvm *kvm,int fd_kernel,int fd_initrd,const char *kernel_cmdline); +#define add_read_only (type, str) \
nit: this is a bit broad to throw in a header file. How about __kvm_mem_add_read_only() instead?
Will
PATCH v4 5/5 cfi-flash: Add support for mapping flash into guest
In reply to Andre PrzywaraAt the moment we trap *every* access to the flash memory, even when we are in array read mode (which just directly copies from the storage array to the guest).
To improve performance, allow cacheable mappings and to avoid fatal traps on unsupported instructions (on ARM), export a read-only memslot to the guest when the flash is in read-array mode. A guest does not need to trap on read accesses then.
A write command (which always traps) will revoke this mapping if the read mode changes.
This reduces the number of read traps from more than 800,000 to a few hundreds when booting into the UEFI shell.
--- hw/cfi_flash.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
hw/cfi_flash.c +47 -0
@@ -8,6 +8,7 @@#include "kvm/kvm.h" #include "kvm/kvm-arch.h" +#include "kvm/kvm-cpu.h" #include "kvm/devices.h" #include "kvm/fdt.h" #include "kvm/mutex.h"
@@ -139,6 +140,7 @@ struct cfi_flash_device {enum cfi_flash_state state;enum cfi_read_mode read_mode;u8 sr; +bool is_mapped; };static int nr_erase_blocks (struct cfi_flash_device *sfdev)
@@ -437,6 +439,43 @@ static void cfi_flash_write(struct cfi_flash_device *sfdev, u16 command, } } +/* +* If we are in ARRAY_READ mode, we can map the flash array directly +* into the guest, just as read-only. This greatly improves read +* performance, and avoids problems with exits due to accesses from +* load instructions without syndrome information (on ARM). +* Also it could allow code to be executed XIP in there. +*/ +static int map_flash_memory (struct kvm *kvm,struct cfi_flash_device *sfdev) +{ +int ret; + + ret =kvm__register_mem (kvm, sfdev->base_addr, sfdev->size, + sfdev->flash_memory, +KVM_MEM_TYPE_RAM |KVM_MEM_TYPE_READONLY ); +if (!ret) + sfdev->is_mapped = true; + +return ret; +} + +/* +* Any write access changing the read mode would need to bring us back to +* "trap everything", as the CFI query read need proper handholding. +*/ +static int unmap_flash_memory (struct kvm *kvm,struct cfi_flash_device *sfdev) +{ +int ret; + + ret =kvm__destroy_mem (kvm, sfdev->base_addr, sfdev->size, + sfdev->flash_memory); + +if (!ret) + sfdev->is_mapped = false; + +return ret; +} +static void cfi_flash_mmio (struct kvm_cpu *vcpu,u64 addr,u8 *data,u32 len,u8 is_write,void *context)
@@ -467,6 +506,12 @@ static void cfi_flash_mmio(struct kvm_cpu *vcpu,cfi_flash_write (sfdev, value &0xffff , faddr, data, len); +/* Adjust our mapping status accordingly. */ +if (!sfdev->is_mapped && sfdev->read_mode ==READ_ARRAY ) +map_flash_memory (vcpu->kvm, sfdev); +else if (sfdev->is_mapped && sfdev->read_mode !=READ_ARRAY ) +unmap_flash_memory (vcpu->kvm, sfdev); +mutex_unlock (&sfdev->mutex); }
@@ -543,6 +588,8 @@ static struct cfi_flash_device *create_flash_device_file(struct kvm *kvm, sfdev->read_mode =READ_ARRAY ; sfdev->sr =CFI_STATUS_READY ; +map_flash_memory (kvm, sfdev); + value =roundup (nr_erase_blocks (sfdev),BITS_PER_LONG ) /8 ; sfdev->lock_bm =malloc (value);memset (sfdev->lock_bm,0 , value);
Signature · 1 line
2.17.1
Quoted 31 lines · Andre Przywara
Hi,
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.In addition to a branch with this series[1], I also put a git branch with all the changes compared to v3[2] as separate patches on the server, please have a look if you want to verify against a previous review.
===============
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, and looks like a generic standard, this series adds a CFI flash emulation to kvmtool.Patch 2/5 is the actual emulation code, patch 1/5 is a bug-fix for registering MMIO devices, which is needed for this device. Patches 3-5 add support for mapping the flash memory into guest, should it be in read-array mode. For this to work, patch 3/5 is cherry-picked from Alex' PCIe reassignable BAR series, to support removing a memslot mapping. Patch 4/5 adds support for read-only mappings, while patch 5/5 adds or removes the mapping based on the current state.
I am happy to squash 5/5 into 2/5, if we agree that patch 3/5 should be merged either separately or the PCIe series is actually merged before this one.
Quoted 4 lines
This is one missing piece towards a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP. This series alone already enables UEFI boot, but only with virtio-mmio.
Excellent! Thanks for taking the time to implement the r/o memslot for the flash, it really makes the UEFI firmware much more usable.
I will test this as soon as I get a chance, probably tomorrow.
Quoted 40 lines
[1] http://www.linux-arm.org/git?p=kvmtool.git;a=log;h=refs/heads/cfi-flash/v4
[2] http://www.linux-arm.org/git?p=kvmtool.git;a=log;h=refs/heads/cfi-flash/v3git://linux-arm.org/kvmtool.git(branches cfi-flash/v3 and cfi-flash/v4)Changelog v3 .. v4:
- Rename file tocfi-flash.c(dash instead of underscore).
- Unify macro names for states, modes and commands.
- Enforce one or two chips only.
- Comment onpow2_size()function.
- Use more consistent identifier spellings.
- Assign symbols to status register values.
- Drop RCR register emulation.
- Use numerical offsets instead of names for query offsets to match spec.
- Cleanup error path and reword info message increate_flash_device_file().
- Add fix to allow non-virtio MMIO device emulations.
- Support tearing down and adding read-only memslots.
- Add read-only memslot mapping when in read mode.Changelog v2 .. v3:
- Breaking MMIO handling into three separate functions.
- Assing the flash base address in the memory map, but stay at 32 MB for now. The MMIO area has been moved up to 48 MB, to never overlap with the flash.
- Impose a limit of 16 MB for the flash size, mostly to fit into the (for now) fixed memory map.
- Trim flash size down to nearest power-of-2, to match hardware.
- Announce forced flash size trimming.
- Rework the CFI query table slightly, to add the addresses as array indicies.
- Fix error handling when creating the flash device.
- Fixpow2_sizeimplementation for 0 and 1 as input values.
- Fix write buffer size handling.
- Improve some comments.Changelog v1 .. v2:
- Add locking for MMIO handling.
- Fold flash read into handler.
- Movepow2_size()into generic header.
- Spell out flash base address.
Ard Biesheuvel
Tested-byQuoted 38 lines · Ard Biesheuvel
Quoted 31 lines · Andre Przywara
Hi,
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.In addition to a branch with this series[1], I also put a git branch with all the changes compared to v3[2] as separate patches on the server, please have a look if you want to verify against a previous review.
===============
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, and looks like a generic standard, this series adds a CFI flash emulation to kvmtool.Patch 2/5 is the actual emulation code, patch 1/5 is a bug-fix for registering MMIO devices, which is needed for this device. Patches 3-5 add support for mapping the flash memory into guest, should it be in read-array mode. For this to work, patch 3/5 is cherry-picked from Alex' PCIe reassignable BAR series, to support removing a memslot mapping. Patch 4/5 adds support for read-only mappings, while patch 5/5 adds or removes the mapping based on the current state.
I am happy to squash 5/5 into 2/5, if we agree that patch 3/5 should be merged either separately or the PCIe series is actually merged before this one.Quoted 4 lines
This is one missing piece towards a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP. This series alone already enables UEFI boot, but only with virtio-mmio.
Quoted 5 lines
Excellent! Thanks for taking the time to implement the r/o memslot for the flash, it really makes the UEFI firmware much more usable.
I will test this as soon as I get a chance, probably tomorrow.
I tested this on a SynQuacer box as a host, using EFI firmware [0] built from patches provided by Sami.
I booted the Debian buster installer, completed the installation, and could boot into the system. The only glitch was the fact that the reboot didn't work, but I suppose we are not preserving the memory the contains the firmware image, so there is nothing to reboot into. But just restarting kvmtool with the flash image containing the EFI variables got me straight into GRUB and the installed OS.
Thanks again for getting this sorted.
[0] https://people.linaro.org/~ard.biesheuvel/KVMTOOL_EFI.fd
On 23/04/2020 21:43, Ard Biesheuvel wrote:
Hi Ard,
Quoted 45 lines · Ard Biesheuvel
Quoted 38 lines · Andre Przywara
Quoted 31 lines
Hi,
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.In addition to a branch with this series[1], I also put a git branch with all the changes compared to v3[2] as separate patches on the server, please have a look if you want to verify against a previous review.
===============
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, and looks like a generic standard, this series adds a CFI flash emulation to kvmtool.Patch 2/5 is the actual emulation code, patch 1/5 is a bug-fix for registering MMIO devices, which is needed for this device. Patches 3-5 add support for mapping the flash memory into guest, should it be in read-array mode. For this to work, patch 3/5 is cherry-picked from Alex' PCIe reassignable BAR series, to support removing a memslot mapping. Patch 4/5 adds support for read-only mappings, while patch 5/5 adds or removes the mapping based on the current state.
I am happy to squash 5/5 into 2/5, if we agree that patch 3/5 should be merged either separately or the PCIe series is actually merged before this one.Quoted 4 lines
This is one missing piece towards a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP. This series alone already enables UEFI boot, but only with virtio-mmio.
Quoted 5 lines
Excellent! Thanks for taking the time to implement the r/o memslot for the flash, it really makes the UEFI firmware much more usable.
I will test this as soon as I get a chance, probably tomorrow.
Quoted 7 lines
I tested this on a SynQuacer box as a host, using EFI firmware [0] built from patches provided by Sami.
I booted the Debian buster installer, completed the installation, and could boot into the system. The only glitch was the fact that the reboot didn't work, but I suppose we are not preserving the memory the contains the firmware image, so there is nothing to reboot into.
It's even worth, kvmtool does actually not support reset at all:
https://git.kernel.org/pub/scm/linux/kernel/git/will/kvmtool.git/tree/kvm-cpu.c#n220
And yeah, the UEFI firmware is loaded at the beginning of RAM, so most of it is long gone by then.
kvmtool could reload the image and reset the VCPUs, but every device emulation would need to be reset, for which there is no code yet.
Quoted 3 lines
But
just restarting kvmtool with the flash image containing the EFI variables got me straight into GRUB and the installed OS.
So, yeah, this is the way to do it ;-)
Quoted 1 line
Tested-by Ard Biesheuvel <[email protected]>
Many thanks for that!
Quoted 1 line
Thanks again for getting this sorted.
It was actually easier than I thought (see the last patch).
Just curious: the images Sami gave me this morning did not show any issues anymore (no no-syndrome fault, no alignment issues), even without the mapping [1]. And even though I saw the 800k read traps, I didn't notice any real performance difference (on a Juno). The PXE timeout was definitely much more noticeable.
So did you see any performance impact with this series?
Quoted 1 line
[0] https://people.linaro.org/~ard.biesheuvel/KVMTOOL_EFI.fd
Ah, nice, will this stay there for a while? I can't provide binaries, but wanted others to be able to easily test this.
Cheers,
Andre.
[1]
http://www.linux-arm.org/git?p=kvmtool.git;a=commitdiff;h=2f2cf67f9514894d88e9ca799bb9dacd1f7557d4
Quoted 58 lines · André Przywara
On 23/04/2020 21:43, Ard Biesheuvel wrote:
Hi Ard,
Quoted 45 lines · Ard Biesheuvel
Quoted 38 lines · Andre Przywara
Quoted 31 lines
Hi,
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.In addition to a branch with this series[1], I also put a git branch with all the changes compared to v3[2] as separate patches on the server, please have a look if you want to verify against a previous review.
===============
The EDK II UEFI firmware implementation requires some storage for the EFI variables, which is typically some flash storage.
Since this is already supported on the EDK II side, and looks like a generic standard, this series adds a CFI flash emulation to kvmtool.Patch 2/5 is the actual emulation code, patch 1/5 is a bug-fix for registering MMIO devices, which is needed for this device. Patches 3-5 add support for mapping the flash memory into guest, should it be in read-array mode. For this to work, patch 3/5 is cherry-picked from Alex' PCIe reassignable BAR series, to support removing a memslot mapping. Patch 4/5 adds support for read-only mappings, while patch 5/5 adds or removes the mapping based on the current state.
I am happy to squash 5/5 into 2/5, if we agree that patch 3/5 should be merged either separately or the PCIe series is actually merged before this one.Quoted 4 lines
This is one missing piece towards a working UEFI boot with kvmtool on ARM guests, the other is to provide writable PCI BARs, which is WIP. This series alone already enables UEFI boot, but only with virtio-mmio.
Quoted 5 lines
Excellent! Thanks for taking the time to implement the r/o memslot for the flash, it really makes the UEFI firmware much more usable.
I will test this as soon as I get a chance, probably tomorrow.
Quoted 7 lines
I tested this on a SynQuacer box as a host, using EFI firmware [0] built from patches provided by Sami.
I booted the Debian buster installer, completed the installation, and could boot into the system. The only glitch was the fact that the reboot didn't work, but I suppose we are not preserving the memory the contains the firmware image, so there is nothing to reboot into.
Quoted 8 lines
It's even worth, kvmtool does actually not support reset at all:
https://git.kernel.org/pub/scm/linux/kernel/git/will/kvmtool.git/tree/kvm-cpu.c#n220And yeah, the UEFI firmware is loaded at the beginning of RAM, so most of it is long gone by then.
kvmtool could reload the image and reset the VCPUs, but every device emulation would need to be reset, for which there is no code yet.
Fair enough. For my use case, it doesn't really matter anyway.
Quoted 14 lines
Quoted 3 lines
But
just restarting kvmtool with the flash image containing the EFI variables got me straight into GRUB and the installed OS.So, yeah, this is the way to do it ;-)
Quoted 1 line
Tested-by Ard Biesheuvel <[email protected]>Many thanks for that!
Quoted 1 line
Thanks again for getting this sorted.
It was actually easier than I thought (see the last patch).
Quoted 8 lines
Just curious: the images Sami gave me this morning did not show any issues anymore (no no-syndrome fault, no alignment issues), even without the mapping [1]. And even though I saw the 800k read traps, I didn't notice any real performance difference (on a Juno). The PXE timeout was definitely much more noticeable.
So did you see any performance impact with this series?
You normally don't PXE boot. There is an issue with the iSCSI driver as well, which causes a boot delay for some reason, so I disabled that in my build.
I definitely *feels* faster :-) But in any case, exposing the array mode as a r/o memslot is definitely the right way to deal with this. Even if Sami did find a workaround that masks the error, it is no guarantee that all accesses go through that library.
Quoted 5 lines
Quoted 1 line
[0] https://people.linaro.org/~ard.biesheuvel/KVMTOOL_EFI.fd
Ah, nice, will this stay there for a while? I can't provide binaries, but wanted others to be able to easily test this.
Sure, I will leave it up until Linaro decides to take down my account.
On 24/04/2020 07:45, Ard Biesheuvel wrote:
Hi,
(adding Leif for EDK-2 discussion)
Quoted 3 lines · André Przywara
Quoted 2 lines · Ard Biesheuvel
[ ... kvmtool series to add CFI flash emulation allowing EDK-2 to store variables. Starting with this version (v4) the flash memory region is presented as a read-only memslot to KVM, to allow direct guest accesses as opposed to trap-and-emulate even read accesses to the array.]
Quoted 11 lines
Quoted 10 lines
Just curious: the images Sami gave me this morning did not show any issues anymore (no no-syndrome fault, no alignment issues), even without the mapping [1]. And even though I saw the 800k read traps, I didn't notice any real performance difference (on a Juno). The PXE timeout was definitely much more noticeable.
So did you see any performance impact with this series?
Quoted 8 lines
You normally don't PXE boot. There is an issue with the iSCSI driver as well, which causes a boot delay for some reason, so I disabled that in my build.
I definitely *feels* faster :-) But in any case, exposing the array mode as a r/o memslot is definitely the right way to deal with this. Even if Sami did find a workaround that masks the error, it is no guarantee that all accesses go through that library.
So I was wondering about this, maybe you can confirm or debunk this:
- Any memory given to the compiler (through a pointer) is assumed to be "normal" memory: the compiler can re-arrange accesses, split them up or collate them. Also unaligned accesses should be allowed - although I guess most compilers would avoid them.
- This normally forbids to give a pointer to memory mapped as "device memory" to the compiler, since this would violate all of the assumptions above.
- If the device mapped as "device memory" is actually memory (SRAM, ROM/flash, framebuffer), then most of the assumptions are met, except the alignment requirement, which is bound to the mapping type, not the actual device (ARMv8 ARM: Unaligned accesses to device memory always trap, regardless of SCTLR.A)
- To accommodate the latter, GCC knows the option -malign-strict, to avoid unaligned accesses. TF-A and U-Boot use this option, to run without the MMU enabled.
Now if EDK-2 lets the compiler deal with the flash memory region directly, I think this would still be prone to alignment faults. In fact an earlier build I got from Sami faulted on exactly that, when I ran it, even with the r/o memslot mapping in place.
So should EDK-2 add -malign-strict to be safe?
or
Should EDK-2 add an additional or alternate mapping using a non-device memory type (with all the mismatched attributes consequences)?
or
Should EDK-2 only touch the flash region using MMIO accessors, and forbid the compiler direct access to that region?
So does EDK-2 get away with this because the compiler typically avoids unaligned accesses?
Cheers,
Andre
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
[0] https://people.linaro.org/~ard.biesheuvel/KVMTOOL_EFI.fd
Ah, nice, will this stay there for a while? I can't provide binaries, but wanted others to be able to easily test this.
Sure, I will leave it up until Linaro decides to take down my account.
Quoted 53 lines · André Przywara
On 24/04/2020 07:45, Ard Biesheuvel wrote:
Hi,
(adding Leif for EDK-2 discussion)
Quoted 3 lines · André Przywara
Quoted 2 lines · Ard Biesheuvel
[ ... kvmtool series to add CFI flash emulation allowing EDK-2 to store variables. Starting with this version (v4) the flash memory region is presented as a read-only memslot to KVM, to allow direct guest accesses as opposed to trap-and-emulate even read accesses to the array.]
Quoted 11 lines
Quoted 10 lines
Just curious: the images Sami gave me this morning did not show any issues anymore (no no-syndrome fault, no alignment issues), even without the mapping [1]. And even though I saw the 800k read traps, I didn't notice any real performance difference (on a Juno). The PXE timeout was definitely much more noticeable.
So did you see any performance impact with this series?
Quoted 8 lines
You normally don't PXE boot. There is an issue with the iSCSI driver as well, which causes a boot delay for some reason, so I disabled that in my build.
I definitely *feels* faster :-) But in any case, exposing the array mode as a r/o memslot is definitely the right way to deal with this. Even if Sami did find a workaround that masks the error, it is no guarantee that all accesses go through that library.
So I was wondering about this, maybe you can confirm or debunk this:
- Any memory given to the compiler (through a pointer) is assumed to be "normal" memory: the compiler can re-arrange accesses, split them up or collate them. Also unaligned accesses should be allowed - although I guess most compilers would avoid them.
- This normally forbids to give a pointer to memory mapped as "device memory" to the compiler, since this would violate all of the assumptions above.
- If the device mapped as "device memory" is actually memory (SRAM, ROM/flash, framebuffer), then most of the assumptions are met, except the alignment requirement, which is bound to the mapping type, not the actual device (ARMv8 ARM: Unaligned accesses to device memory always trap, regardless of SCTLR.A)
- To accommodate the latter, GCC knows the option -malign-strict, to avoid unaligned accesses. TF-A and U-Boot use this option, to run without the MMU enabled.
Quoted 6 lines
Now if EDK-2 lets the compiler deal with the flash memory region directly, I think this would still be prone to alignment faults. In fact an earlier build I got from Sami faulted on exactly that, when I ran it, even with the r/o memslot mapping in place.
So should EDK-2 add -malign-strict to be safe?
It already uses this in various places where it matters.
Quoted 3 lines
or
Should EDK-2 add an additional or alternate mapping using a non-device memory type (with all the mismatched attributes consequences)?
The memory mapped NOR flash in UEFI is really a special case, since we need the OS to map it for us at runtime, and we cannot tell it to switch between normal-NC and device attributes depending on which mode the firmware is using it in.
Note that this is not any different on bare metal.
Quoted 4 lines
or
Should EDK-2 only touch the flash region using MMIO accessors, and forbid the compiler direct access to that region?
It should only touch those regions using abstractions it defines itself, and which can be backed in different ways. This is already the case in EDK2: it has its own CopyMem, ZeroMem, etc string library, and bans the use the standard C ones. On top of that, it bans struct assignment, initializers for automatic variables and are things that result in such calls to be emitted implicitly.
So in practice, this issue is under control, unless you use a version of those abstractions that willingly uses unaligned accesses (we have optimized versions based on the cortex-strings library). So my suspicion is that this may have caused the crash: on bare metal, we have to switch to the non-optimized string library for the variable driver for this reason.
The real solution is to fix EDK2, and make the variable stack work with NOR flash that is non-memory mapped. This is something that has come up before, and the other day, Sami and I were just discussing logging this as a wishlist item for the firmware team.
Quoted 3 lines
So does EDK-2 get away with this because the compiler typically avoids unaligned accesses?
There are certainly some places in the current code base where it is the compiler that is emitting reads from the NOR flash region, but there aren't that many. Moving the variable data itself in and out will typically use the abstractions, since it is moving anonymous chunks of data. However, there are places where, e.g., fields in the FS metadata are being read by the code, and there it just casts an address pointing into the NOR flash region to the appropriate struct type, and dereferences the fields.
Quoted 6 lines · Andre Przywara
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.
Cheers, this mostly looks good to me. I've left a couple of minor comments, and I'll give Alexandru a chance to have another look, but hopefully we can merge it soon.
Will
Quoted 11 lines · Will Deacon
Quoted 6 lines · Andre Przywara
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.Cheers, this mostly looks good to me. I've left a couple of minor comments, and I'll give Alexandru a chance to have another look, but hopefully we can merge it soon.
Ok, I pushed this out along with the follow-up patch.
Thanks!
Will
Quoted 10 lines · Will Deacon
Quoted 8 lines · Will Deacon
Quoted 6 lines · Andre Przywara
an update for the CFI flash emulation, addressing Alex' comments and adding direct mapping support.
The actual code changes to the flash emulation are minimal, mostly this is about renaming and cleanups.
This versions now adds some patches. 1/5 is a required fix, the last three patches add mapping support as an extension. See below.
Quoted 6 lines
Quoted 3 lines
Cheers, this mostly looks good to me. I've left a couple of minor comments, and I'll give Alexandru a chance to have another look, but hopefully we can merge it soon.
Ok, I pushed this out along with the follow-up patch.
Cheers for that, this is useful stuff.
For the record, I did a quick benchmark on RPi4 booting Debian in a VM, and I get the following delays (with GRUB and EFI timeouts both set to 0)
17:04:58.487065
17:04:58.563700 UEFI firmware (version built at 22:13:20 on Apr 23 2020) 17:04:58.853653 Welcome to GRUB!
17:04:58.924606 Booting `Debian GNU/Linux'
17:04:58.927835 Loading Linux 5.5.0-2-arm64 ...
17:04:59.063490 Loading initial ramdisk ...
17:05:01.303560 /dev/vda2: recovering journal
17:05:01.408861 /dev/vda2: clean, 37882/500960 files, 457154/2001920 blocks 17:05:09.646023 Debian GNU/Linux bullseye/sid rpi4vm64 ttyS0
So it takes less than 400 ms from starting kvmtool to entering GRUB when the boot path is set normally. Any other delays you are observing may be due to the fact that no boot path has been configured yet, which is why it attempts PXE boot or other things.
Also, note that you can pass the --rng option to kvmtool to get the EFI_RNG_PROTOCOL to be exposed to the EFI stub, for KASLR and for seeding the kernel's RNG.