KVM: selftests: Add aarch64/page_fault_test
v7 cover KVM: selftests: Add aarch64/page_fault_test
This series adds a new aarch64 selftest for testing stage 2 fault handling for various combinations of guest accesses (e.g., write, S1PTW), backing sources (e.g., anon), and types of faults (e.g., read on hugetlbfs with a hole, write on a readonly memslot). Each test tries a different combination and then checks that the access results in the right behavior (e.g., uffd faults with the right address and write/read flag). Some interesting combinations are:
- loading an instruction leads to a stage 1 page-table-walk that misses on stage 2 because the backing memslot for the page table it not in host memory (a hole was punched right there) and the fault is handled using userfaultfd. The expected behavior is that this leads to a userfaultfd fault marked as a write. See commit c4ad98e4b72c ("KVM: arm64: Assume write fault on S1PTW permission fault on instruction fetch") for why that's a write.
- a cas (compare-and-swap) on a readonly memslot leads to a failed vcpu run.
- write-faulting on a memslot that's marked for userfaultfd handling and dirty logging should result in a uffd fault and having the respective bit set in the dirty log.
The first 8 commits of this series add library support. The first one adds a new userfaultfd library. Commits 2-5 add some misc library changes that will be used by the new test, like a library function to get the GPA of a PTE. Commits 6-8 breaks the implicit assumption that code and page tables live in memslot memslots should allocators use. This is then used by the new test to place the page tables in a specific memslot. The last 5 commits add the new selftest, one type of test at a time. It first adds core tests, then uffd, then dirty logging, then readonly memslots tests, and finally combinations of the previous ones (like uffd and dirty logging at the same time).
v6 -> v7: https://lore.kernel.org/kvmarm/Yyi03sX5hx36M%[email protected]/
- removed struct kvm_vm_mem_params. Changed page_fault_test.c accordingly. [Sean]
- applied Oliver's patch to fix page_fault_test compilation warnings. [Oliver]
- added R-b's from Oliver and Andrew. Didn't Andrew's R-b on 6/13 as the commit changed afterwards.
v5 -> v6: https://lore.kernel.org/kvmarm/[email protected]/
- added "enum memslot_type" and all the related cleanups due to it [Andrew]
- default kvm_vm_mem_default with size=0 [Andrew,Sean]
- __vm_vaddr_alloc() taking "enum memslot_type" and all the related cleanups due to this change [Andrew]
v4 -> v5: https://lore.kernel.org/kvmarm/[email protected]/
- biggest change: followed suggestion from Sean and Andrew regarding a new arg for vm_create() to specify the guest memory layout. That's taken care of with these two new commits:
KVM: selftests: Use the right memslot for code, page-tables, and data allocations
KVM: selftests: Change ____vm_create() to take struct kvm_vm_mem_params
plus the respective changes in the page_fault_test itself (mostly code reduction).
- dropped some commits that are not needed after the above change:
KVM: selftests: aarch64: Export _virt_pg_map with a pt_memslot arg
KVM: selftests: Add vm_alloc_page_table_in_memslot library function
KVM: selftests: Add vm_mem_region_get_src_fd library function
- addressed Oliver comments in commit "KVM: selftests: aarch64: Add aarch64/page_fault_test"
- collect r-b's from Andrew
Ricardo Koller (13):
KVM: selftests: Add a userfaultfd library
KVM: selftests: aarch64: Add virt_get_pte_hva() library function
KVM: selftests: Add missing close and munmap in
__vm_mem_region_delete()
KVM: selftests: aarch64: Construct DEFAULT_MAIR_EL1 using sysreg.h
macros
tools: Copy bitfield.h from the kernel sources
KVM: selftests: Stash backing_src_type in struct userspace_mem_region
KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
KVM: selftests: Use the right memslot for code, page-tables, and data
allocations
KVM: selftests: aarch64: Add aarch64/page_fault_test
KVM: selftests: aarch64: Add userfaultfd tests into page_fault_test
KVM: selftests: aarch64: Add dirty logging tests into page_fault_test
KVM: selftests: aarch64: Add readonly memslot tests into
page_fault_test
KVM: selftests: aarch64: Add mix of tests into page_fault_test
tools/include/linux/bitfield.h | 176 +++ tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 2 + .../selftests/kvm/aarch64/page_fault_test.c | 1116 +++++++++++++++++ .../selftests/kvm/demand_paging_test.c | 228 +--- .../selftests/kvm/include/aarch64/processor.h | 35 +- .../selftests/kvm/include/kvm_util_base.h | 29 +- .../selftests/kvm/include/userfaultfd_util.h | 45 + .../selftests/kvm/lib/aarch64/processor.c | 26 +- tools/testing/selftests/kvm/lib/elf.c | 3 +- tools/testing/selftests/kvm/lib/kvm_util.c | 82 +- .../selftests/kvm/lib/riscv/processor.c | 7 +- .../selftests/kvm/lib/s390x/processor.c | 7 +- .../selftests/kvm/lib/userfaultfd_util.c | 186 +++ .../selftests/kvm/lib/x86_64/processor.c | 13 +- 15 files changed, 1698 insertions(+), 258 deletions(-) create mode 100644 tools/include/linux/bitfield.h create mode 100644 tools/testing/selftests/kvm/aarch64/page_fault_test.c create mode 100644 tools/testing/selftests/kvm/include/userfaultfd_util.h create mode 100644 tools/testing/selftests/kvm/lib/userfaultfd_util.c
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 1/13 KVM: selftests: Add a userfaultfd library
Move the generic userfaultfd code out of demand_paging_test.c into a common library, userfaultfd_util. This library consists of a setup and a stop function. The setup function starts a thread for handling page faults using the handler callback function. This setup returns a uffd_desc object which is then used in the stop function (to wait and destroy the threads).
--- tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/demand_paging_test.c | 228 +++--------------- .../selftests/kvm/include/userfaultfd_util.h | 45 ++++ .../selftests/kvm/lib/userfaultfd_util.c | 186 ++++++++++++++ 4 files changed, 262 insertions(+), 198 deletions(-) create mode 100644 tools/testing/selftests/kvm/include/userfaultfd_util.h create mode 100644 tools/testing/selftests/kvm/lib/userfaultfd_util.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -47,6 +47,7 @@ LIBKVM += lib/perf_test_util.c LIBKVM += lib/rbtree.c LIBKVM += lib/sparsebit.c LIBKVM += lib/test_util.c +LIBKVM += lib/userfaultfd_util.c LIBKVM_x86_64 += lib/x86_64/apic.c LIBKVM_x86_64 += lib/x86_64/handlers.S
tools/testing/selftests/kvm/demand_paging_test.c +30 -198
296 lines not on this page · raw message
tools/testing/selftests/kvm/include/userfaultfd_util.h new file +45 -0
45 lines not on this page · raw message
tools/testing/selftests/kvm/lib/userfaultfd_util.c new file +186 -0
186 lines not on this page · raw message
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 2/13 KVM: selftests: aarch64: Add virt_get_pte_hva() library function
In reply to Ricardo KollerAdd a library function to get the PTE (a host virtual address) of a given GVA. This will be used in a future commit by a test to clear and check the access flag of a particular page.
--- .../selftests/kvm/include/aarch64/processor.h | 2 ++ tools/testing/selftests/kvm/lib/aarch64/processor.c | 13 ++++++++++--- 2 files changed, 12 insertions(+), 3 deletions(-)
tools/testing/selftests/kvm/include/aarch64/processor.h +2 -0
@@ -109,6 +109,8 @@ void vm_install_exception_handler(struct kvm_vm *vm,void vm_install_sync_handler (struct kvm_vm *vm,int vector,int ec,handler_fn handler); +uint64_t *virt_get_pte_hva (struct kvm_vm *vm,vm_vaddr_t gva); +static inline void cpu_relax (void ) { asmvolatile ("yield" :::"memory" );
tools/testing/selftests/kvm/lib/aarch64/processor.c +10 -3
@@ -138,7 +138,7 @@ void virt_arch_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr)_virt_pg_map (vm, vaddr, paddr, attr_idx); } -vm_paddr_t addr_arch_gva2gpa (struct kvm_vm *vm,vm_vaddr_t gva) +uint64_t *virt_get_pte_hva (struct kvm_vm *vm,vm_vaddr_t gva) {uint64_t *ptep;
@@ -169,11 +169,18 @@ vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)TEST_FAIL ("Page table levels must be 2, 3, or 4" ); } -return pte_addr (vm, *ptep) + (gva & (vm->page_size -1 )); +return ptep; unmapped_gva:TEST_FAIL ("No mapping for vm virtual address, gva: 0x%lx" , gva); -exit (1 ); +exit (EXIT_FAILURE ); +} + +vm_paddr_t addr_arch_gva2gpa (struct kvm_vm *vm,vm_vaddr_t gva) +{ +uint64_t *ptep =virt_get_pte_hva (vm, gva); + +return pte_addr (vm, *ptep) + (gva & (vm->page_size -1 )); }static void pte_dump (FILE *stream,struct kvm_vm *vm,uint8_t indent,uint64_t page,int level)
Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
PATCH v7 3/13 KVM: selftests: Add missing close and munmap in __vm_mem_region_delete()
In reply to Ricardo KollerDeleting a memslot (when freeing a VM) is not closing the backing fd, nor it's unmapping the alias mapping. Fix by adding the missing close and munmap.
--- tools/testing/selftests/kvm/lib/kvm_util.c | 6 ++++++ 1 file changed, 6 insertions(+)
tools/testing/selftests/kvm/lib/kvm_util.c +6 -0
@@ -544,6 +544,12 @@ static void __vm_mem_region_delete(struct kvm_vm *vm,sparsebit_free (®ion->unused_phy_pages); ret =munmap (region->mmap_start, region->mmap_size);TEST_ASSERT (!ret,__KVM_SYSCALL_ERROR ("munmap()" , ret)); +if (region->fd >=0 ) { +/* There's an extra map when using shared memory. */ + ret =munmap (region->mmap_alias, region->mmap_size); +TEST_ASSERT (!ret,__KVM_SYSCALL_ERROR ("munmap()" , ret)); +close (region->fd); + }free (region); }
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 4/13 KVM: selftests: aarch64: Construct DEFAULT_MAIR_EL1 using sysreg.h macros
In reply to Ricardo KollerDefine macros for memory type indexes and construct DEFAULT_MAIR_EL1 with macros from asm/sysreg.h. The index macros can then be used when constructing PTEs (instead of using raw numbers).
--- .../selftests/kvm/include/aarch64/processor.h | 25 ++++++++++++++----- .../selftests/kvm/lib/aarch64/processor.c | 2 +- 2 files changed, 20 insertions(+), 7 deletions(-)
tools/testing/selftests/kvm/include/aarch64/processor.h +19 -6
@@ -38,12 +38,25 @@* NORMAL 4 1111:1111 * NORMAL_WT 5 1011:1011 */ -#define DEFAULT_MAIR_EL1 ((0x00ul << (0 * 8)) | \ - (0x04ul << (1 * 8)) | \ - (0x0cul << (2 * 8)) | \ - (0x44ul << (3 * 8)) | \ - (0xfful << (4 * 8)) | \ - (0xbbul << (5 * 8))) + +/* Linux doesn't use these memory types, so let's define them. */ +#define MAIR_ATTR_DEVICE_GRE UL(0x0c) +#define MAIR_ATTR_NORMAL_WT UL(0xbb) + +#define MT_DEVICE_nGnRnE 0 +#define MT_DEVICE_nGnRE 1 +#define MT_DEVICE_GRE 2 +#define MT_NORMAL_NC 3 +#define MT_NORMAL 4 +#define MT_NORMAL_WT 5 + +#define DEFAULT_MAIR_EL1 \ + (MAIR_ATTRIDX(MAIR_ATTR_DEVICE_nGnRnE, MT_DEVICE_nGnRnE) | \ + MAIR_ATTRIDX(MAIR_ATTR_DEVICE_nGnRE, MT_DEVICE_nGnRE) | \ + MAIR_ATTRIDX(MAIR_ATTR_DEVICE_GRE, MT_DEVICE_GRE) | \ + MAIR_ATTRIDX(MAIR_ATTR_NORMAL_NC, MT_NORMAL_NC) | \ + MAIR_ATTRIDX(MAIR_ATTR_NORMAL, MT_NORMAL) | \ + MAIR_ATTRIDX(MAIR_ATTR_NORMAL_WT, MT_NORMAL_WT))#define MPIDR_HWID_BITMASK (0xff00fffffful)
tools/testing/selftests/kvm/lib/aarch64/processor.c +1 -1
@@ -133,7 +133,7 @@ static void _virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,void virt_arch_pg_map (struct kvm_vm *vm,uint64_t vaddr,uint64_t paddr) { -uint64_t attr_idx =4 ;/* NORMAL (See DEFAULT_MAIR_EL1) */ +uint64_t attr_idx =MT_NORMAL ;_virt_pg_map (vm, vaddr, paddr, attr_idx); }
Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
PATCH v7 5/13 tools: Copy bitfield.h from the kernel sources
In reply to Ricardo KollerCopy bitfield.h from include/linux/bitfield.h. A subsequent change will make use of some FIELD_{GET,PREP} macros defined in this header.
The header was copied as-is, no changes needed.
--- tools/include/linux/bitfield.h | 176 +++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 tools/include/linux/bitfield.h
tools/include/linux/bitfield.h new file +176 -0
@@ -0,0 +1,176 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2014 Felix Fietkau <[email protected]> +* Copyright (C) 2004 - 2009 Ivo van Doorn <[email protected]> +*/ + +#ifndef _LINUX_BITFIELD_H +#define _LINUX_BITFIELD_H + +#include <linux/build_bug.h> +#include <asm/byteorder.h> + +/* +* Bitfield access macros +* +* FIELD_{GET,PREP} macros take as first parameter shifted mask +* from which they extract the base mask and shift amount. +* Mask must be a compilation time constant. +* +* Example: +* +* #define REG_FIELD_A GENMASK(6, 0) +* #define REG_FIELD_B BIT(7) +* #define REG_FIELD_C GENMASK(15, 8) +* #define REG_FIELD_D GENMASK(31, 16) +* +* Get: +* a = FIELD_GET(REG_FIELD_A, reg); +* b = FIELD_GET(REG_FIELD_B, reg); +* +* Set: +* reg = FIELD_PREP(REG_FIELD_A, 1) | +* FIELD_PREP(REG_FIELD_B, 0) | +* FIELD_PREP(REG_FIELD_C, c) | +* FIELD_PREP(REG_FIELD_D, 0x40); +* +* Modify: +* reg &= ~REG_FIELD_C; +* reg |= FIELD_PREP(REG_FIELD_C, c); +*/ + +#define __bf_shf (x) (__builtin_ffsll(x) - 1) + +#define __scalar_type_to_unsigned_cases (type) \ + unsigned type: (unsigned type)0, \ + signed type: (unsigned type)0 + +#define __unsigned_scalar_typeof (x) typeof( \ + _Generic((x), \ + char: (unsigned char)0, \ + __scalar_type_to_unsigned_cases(char), \ + __scalar_type_to_unsigned_cases(short), \ + __scalar_type_to_unsigned_cases(int), \ + __scalar_type_to_unsigned_cases(long), \ + __scalar_type_to_unsigned_cases(long long), \ + default: (x))) + +#define __bf_cast_unsigned (type, x) ((__unsigned_scalar_typeof(type))(x)) + +#define __BF_FIELD_CHECK (_mask, _reg, _val, _pfx) \ + ({ \ + BUILD_BUG_ON_MSG(!__builtin_constant_p(_mask), \ + _pfx "mask is not constant"); \ + BUILD_BUG_ON_MSG((_mask) == 0, _pfx "mask is zero"); \ + BUILD_BUG_ON_MSG(__builtin_constant_p(_val) ? \ + ~((_mask) >> __bf_shf(_mask)) & (_val) : 0, \ + _pfx "value too large for the field"); \ + BUILD_BUG_ON_MSG(__bf_cast_unsigned(_mask, _mask) > \ + __bf_cast_unsigned(_reg, ~0ull), \ + _pfx "type of reg too small for mask"); \ + __BUILD_BUG_ON_NOT_POWER_OF_2((_mask) + \ + (1ULL << __bf_shf(_mask))); \ + }) + +/** +* FIELD_MAX() - produce the maximum value representable by a field +* @_mask: shifted mask defining the field's length and position +* +* FIELD_MAX() returns the maximum value that can be held in the field +* specified by @_mask. +*/ +#define FIELD_MAX (_mask) \ + ({ \ + __BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_MAX: "); \ + (typeof(_mask))((_mask) >> __bf_shf(_mask)); \ + }) + +/** +* FIELD_FIT() - check if value fits in the field +* @_mask: shifted mask defining the field's length and position +* @_val: value to test against the field +* +* Return: true if @_val can fit inside @_mask, false if @_val is too big. +*/ +#define FIELD_FIT (_mask, _val) \ + ({ \ + __BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_FIT: "); \ + !((((typeof(_mask))_val) << __bf_shf(_mask)) & ~(_mask)); \ + }) + +/** +* FIELD_PREP() - prepare a bitfield element +* @_mask: shifted mask defining the field's length and position +* @_val: value to put in the field +* +* FIELD_PREP() masks and shifts up the value. The result should +* be combined with other fields of the bitfield using logical OR. +*/ +#define FIELD_PREP (_mask, _val) \ + ({ \ + __BF_FIELD_CHECK(_mask, 0ULL, _val, "FIELD_PREP: "); \ + ((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask); \ + }) + +/** +* FIELD_GET() - extract a bitfield element +* @_mask: shifted mask defining the field's length and position +* @_reg: value of entire bitfield +* +* FIELD_GET() extracts the field specified by @_mask from the +* bitfield passed in as @_reg by masking and shifting it down. +*/ +#define FIELD_GET (_mask, _reg) \ + ({ \ + __BF_FIELD_CHECK(_mask, _reg, 0U, "FIELD_GET: "); \ + (typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask)); \ + }) + +extern void __compiletime_error("value doesn't fit into mask") +__field_overflow(void); +extern void __compiletime_error("bad bitfield mask") +__bad_mask(void); +static __always_inline u64 field_multiplier(u64 field) +{ +if ((field | (field -1 )) & ((field | (field -1 )) +1 )) +__bad_mask (); +return field & -field; +} +static __always_inline u64 field_mask(u64 field) +{ +return field /field_multiplier (field); +} +#define field_max (field) ((typeof(field))field_mask(field)) +#define ____MAKE_OP (type,base,to,from) \ +static __always_inline __##type type##_encode_bits(base v, base field) \ +{ \ + if (__builtin_constant_p(v) && (v & ~field_mask(field))) \ + __field_overflow(); \ + return to((v & field_mask(field)) * field_multiplier(field)); \ +} \ +static __always_inline __##type type##_replace_bits(__##type old, \ + base val, base field) \ +{ \ + return (old & ~to(field)) | type##_encode_bits(val, field); \ +} \ +static __always_inline void type##p_replace_bits(__##type *p, \ + base val, base field) \ +{ \ + *p = (*p & ~to(field)) | type##_encode_bits(val, field); \ +} \ +static __always_inline base type##_get_bits(__##type v, base field) \ +{ \ + return (from(v) & field)/field_multiplier(field); \ +} +#define __MAKE_OP (size) \ + ____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu) \ + ____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu) \ + ____MAKE_OP(u##size,u##size,,) +____MAKE_OP(u8,u8,,) +__MAKE_OP(16) +__MAKE_OP(32) +__MAKE_OP(64) +#undef __MAKE_OP +#undef ____MAKE_OP + +#endif
Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
PATCH v7 6/13 KVM: selftests: Stash backing_src_type in struct userspace_mem_region
In reply to Ricardo KollerAdd the backing_src_type into struct userspace_mem_region. This struct already stores a lot of info about memory regions, except the backing source type. This info will be used by a future commit in order to determine the method for punching a hole.
--- tools/testing/selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/lib/kvm_util.c | 1 + 2 files changed, 2 insertions(+)
tools/testing/selftests/kvm/include/kvm_util_base.h +1 -0
@@ -34,6 +34,7 @@ struct userspace_mem_region {struct sparsebit *unused_phy_pages;int fd;off_t offset; +enum vm_mem_backing_src_type backing_src_type;void *host_mem;void *host_alias;void *mmap_start;
tools/testing/selftests/kvm/lib/kvm_util.c +1 -0
@@ -887,6 +887,7 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm, vm_mem_backing_src_alias(src_type)->name); } + region->backing_src_type = src_type; region->unused_phy_pages =sparsebit_alloc ();sparsebit_set_num (region->unused_phy_pages, guest_paddr >> vm->page_shift, npages);
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 7/13 KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
In reply to Ricardo KollerThe vm_create() helpers are hardcoded to place most page types (code, page-tables, stacks, etc) in the same memslot #0, and always backed with anonymous 4K. There are a couple of issues with that. First, tests willing to differ a bit, like placing page-tables in a different backing source type must replicate much of what's already done by the vm_create() functions. Second, the hardcoded assumption of memslot #0 holding most things is spreaded everywhere; this makes it very hard to change.
Fix the above issues by having selftests specify how they want memory to be laid out. Start by changing ____vm_create() to not create memslot #0; a future commit will add test that specifies all memslots used by the VM. Then, add the vm->memslots[] array to specify the right memslot for different memory allocators, e.g.,: lib/elf should use the vm->[MEM_REGION_CODE] memslot. This will be used as a way to specify the page-tables memslots (to be backed by huge pages for example).
There is no functional change intended. The current commit lays out memory exactly as before. The next commit will change the allocators to get the region they should be using, e.g.,: like the page table allocators using the pt memslot.
--- .../selftests/kvm/include/kvm_util_base.h | 25 +++++++++++++++++-- tools/testing/selftests/kvm/lib/kvm_util.c | 18 +++++++------ 2 files changed, 33 insertions(+), 10 deletions(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +23 -2
@@ -65,6 +65,13 @@ struct userspace_mem_regions {DECLARE_HASHTABLE (slot_hash,9 ); }; +enum kvm_mem_region_type { +MEM_REGION_CODE , +MEM_REGION_PT , +MEM_REGION_DATA , +NR_MEM_REGIONS , +}; +struct kvm_vm {int mode;unsigned long type;
@@ -93,6 +100,13 @@ struct kvm_vm {int stats_fd;struct kvm_stats_header stats_header;struct kvm_stats_desc *stats_desc; + +/* +* KVM region slots. These are the default memslots used by page +* allocators, e.g., lib/elf uses the memslots[MEM_REGION_CODE] +* memslot. +*/ +uint32_t memslots[NR_MEM_REGIONS ]; };
@@ -105,6 +119,13 @@ struct kvm_vm {struct userspace_mem_region *memslot2region (struct kvm_vm *vm,uint32_t memslot); +inline struct userspace_mem_region * +vm_get_mem_region (struct kvm_vm *vm,enum kvm_mem_region_type mrt) +{ +assert (mrt <NR_MEM_REGIONS ); +return memslot2region (vm, vm->memslots[mrt]); +} +/* Minimum allocated guest virtual and physical addresses */ #define KVM_UTIL_MIN_VADDR 0x2000#define KVM_GUEST_PAGE_TABLE_MIN_PADDR 0x180000
@@ -643,13 +664,13 @@ vm_paddr_t vm_alloc_page_table(struct kvm_vm *vm);* __vm_create() does NOT create vCPUs, @nr_runnable_vcpus is used purely to * calculate the amount of memory needed for per-vCPU data, e.g. stacks. */ -struct kvm_vm *____vm_create (enum vm_guest_mode mode,uint64_t nr_pages); +struct kvm_vm *____vm_create (enum vm_guest_mode mode);struct kvm_vm *__vm_create (enum vm_guest_mode mode,uint32_t nr_runnable_vcpus,uint64_t nr_extra_pages);static inline struct kvm_vm *vm_create_barebones (void ) { -return ____vm_create (VM_MODE_DEFAULT ,0 ); +return ____vm_create (VM_MODE_DEFAULT ); }static inline struct kvm_vm *vm_create (uint32_t nr_runnable_vcpus)
tools/testing/selftests/kvm/lib/kvm_util.c +10 -8
@@ -143,13 +143,10 @@ const struct vm_guest_mode_params vm_guest_mode_params[] = {_Static_assert (sizeof (vm_guest_mode_params)/sizeof (struct vm_guest_mode_params ) ==NUM_VM_MODES ,"Missing new mode params?" ); -struct kvm_vm *____vm_create (enum vm_guest_mode mode,uint64_t nr_pages) +struct kvm_vm *____vm_create (enum vm_guest_mode mode) {struct kvm_vm *vm; -pr_debug ("%s: mode='%s' pages='%ld'\n" , __func__, -vm_guest_mode_string (mode), nr_pages); - vm =calloc (1 ,sizeof (*vm));TEST_ASSERT (vm !=NULL ,"Insufficient Memory" );
@@ -245,9 +242,6 @@ struct kvm_vm *____vm_create(enum vm_guest_mode mode, uint64_t nr_pages)/* Allocate and setup memory for guest. */ vm->vpages_mapped =sparsebit_alloc (); -if (nr_pages !=0 ) -vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS , -0 ,0 , nr_pages,0 );return vm; }
@@ -293,8 +287,16 @@ struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus,uint64_t nr_pages =vm_nr_pages_required (mode, nr_runnable_vcpus, nr_extra_pages);struct kvm_vm *vm; +int i; + +pr_debug ("%s: mode='%s' pages='%ld'\n" , __func__, +vm_guest_mode_string (mode), nr_pages); + + vm =____vm_create (mode); +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,0 , nr_pages,0 ); - vm =____vm_create (mode, nr_pages); +for (i =0 ; i <NR_MEM_REGIONS ; i++) + vm->memslots[i] =0 ;kvm_vm_elf_load (vm, program_invocation_name);
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Re: [PATCH v7 07/13] KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
Quoted 21 lines · Ricardo Koller
The
vm_create()helpers are hardcoded to place most page types (code, page-tables, stacks, etc) in the same memslot #0, and always backed with anonymous 4K. There are a couple of issues with that. First, tests willing to differ a bit, like placing page-tables in a different backing source type must replicate much of what's already done by thevm_create()functions. Second, the hardcoded assumption of memslot #0 holding most things is spreaded everywhere; this makes it very hard to change.Fix the above issues by having selftests specify how they want memory to be laid out. Start by changing
____vm_create()to not create memslot #0; a future commit will add test that specifies all memslots used by the VM. Then, add the vm->memslots[] array to specify the right memslot for different memory allocators, e.g.,: lib/elf should use the vm->[MEM_REGION_CODE] memslot. This will be used as a way to specify the page-tables memslots (to be backed by huge pages for example).There is no functional change intended. The current commit lays out memory exactly as before. The next commit will change the allocators to get the region they should be using, e.g.,: like the page table allocators using the pt memslot.
Quoted 8 lines
Cc Sean Christopherson <[email protected]>Cc Andrew Jones <[email protected]>Signed-off-by Ricardo Koller <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 25 +++++++++++++++++-- tools/testing/selftests/kvm/lib/kvm_util.c | 18 +++++++------ 2 files changed, 33 insertions(+), 10 deletions(-)
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Sean Christopherson
reviewerRe: [PATCH v7 07/13] KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
In reply to Ricardo KollerQuoted 3 lines · Ricardo Koller
The
vm_create()helpers are hardcoded to place most page types (code, page-tables, stacks, etc) in the same memslot #0, and always backed with anonymous 4K. There are a couple of issues with that. First, tests willing to
Preferred kernel style is to wrap changelogs at ~75 chars, e.g. so that git show stays under 80 chars.
And in general, please incorporate checkpatch into your workflow, e.g. there's also a spelling mistake below.
WARNING: Possible unwrapped commit description (prefer a maximum 75 chars per line) #9:
anonymous 4K. There are a couple of issues with that. First, tests willing to
WARNING: 'spreaded' may be misspelled - perhaps 'spread'? #12:
the hardcoded assumption of memslot #0 holding most things is spreaded
^^^^^^^^
total: 0 errors, 2 warnings, 94 lines checked
Quoted 4 lines
differ a bit, like placing page-tables in a different backing source type must replicate much of what's already done by the
vm_create()functions. Second, the hardcoded assumption of memslot #0 holding most things is spreaded everywhere; this makes it very hard to change.
...
tools/testing/selftests/kvm/include/kvm_util_base.h struct kvm_vm { · line 122
Quoted 5 lines
tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -105,6 +119,13 @@ struct kvm_vm {struct userspace_mem_region *memslot2region (struct kvm_vm *vm,uint32_t memslot); +inline struct userspace_mem_region *
Should be static inline.
Review struct kvm_vm { · line 123
Quoted 1 line
(quoted diff) +1
-0+vm_get_mem_region
Please don't insert newlines before the function name, it makes searching painful. Ignore existing patterns in KVM selfetsts, they're wrong. ;-) Linus has a nice explanation/rant on this[*].
The resulting declaration will run long, but at least for me, I'll take that any day over putting the function name on a new line.
[*] https://lore.kernel.org/all/CAHk-=wjoLAYG446ZNHfg=GhjSY6nFmuB_wA8fYd5iLBNXjo9Bw@mail.gmail.com
Review struct kvm_vm { · line 124
Quoted 1 line
(quoted diff) +0
-0(struct kvm_vm *vm, enum kvm_mem_region_type mrt)
One last nit, what about "region" or "type" instead of "mrt"? The acronym made me briefly pause to figure out what "mrt" meant, which is silly because the name really doesn't have much meaning.
Quoted 4 lines
tools/testing/selftests/kvm/include/kvm_util_base.h +4
-0+{ +assert (mrt <NR_MEM_REGIONS ); +return memslot2region (vm, vm->memslots[mrt]); +}
...
tools/testing/selftests/kvm/lib/kvm_util.c struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus, · line 296
Quoted 11 lines
tools/testing/selftests/kvm/lib/kvm_util.c +7
-0@@ -293,8 +287,16 @@ struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus,uint64_t nr_pages =vm_nr_pages_required (mode, nr_runnable_vcpus, nr_extra_pages);struct kvm_vm *vm; +int i; + +pr_debug ("%s: mode='%s' pages='%ld'\n" , __func__, +vm_guest_mode_string (mode), nr_pages); + + vm =____vm_create (mode); +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,0 , nr_pages,0 );
The spacing is weird here. Adding the region and stuffing vm->memslots are what should be bundled together, not creating the VM and adding the common region. I.e.
pr_debug("%s: mode='%s' pages='%ld'\n", __func__,
vm_guest_mode_string(mode), nr_pages);
vm = ____vm_create(mode);
vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 0, 0, nr_pages, 0);
for (i = 0; i < NR_MEM_REGIONS; i++)
vm->memslots[i] = 0;Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1- vm =____vm_create (mode, nr_pages); +for (i =0 ; i <NR_MEM_REGIONS ; i++) + vm->memslots[i] =0 ;kvm_vm_elf_load (vm, program_invocation_name);Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
Re: [PATCH v7 07/13] KVM: selftests: Add vm->memslots[] and enum kvm_mem_region_type
Quoted 91 lines · Sean Christopherson
Quoted 3 lines · Ricardo Koller
The
vm_create()helpers are hardcoded to place most page types (code, page-tables, stacks, etc) in the same memslot #0, and always backed with anonymous 4K. There are a couple of issues with that. First, tests willing toPreferred kernel style is to wrap changelogs at ~75 chars, e.g. so that
git showstays under 80 chars.And in general, please incorporate checkpatch into your workflow, e.g. there's also a spelling mistake below.
WARNING: Possible unwrapped commit description (prefer a maximum 75 chars per line) #9:
anonymous 4K. There are a couple of issues with that. First, tests willing toWARNING: 'spreaded' may be misspelled - perhaps 'spread'? #12:
the hardcoded assumption of memslot #0 holding most things is spreaded^^^^^^^^total: 0 errors, 2 warnings, 94 lines checked
Quoted 4 lines
differ a bit, like placing page-tables in a different backing source type must replicate much of what's already done by the
vm_create()functions. Second, the hardcoded assumption of memslot #0 holding most things is spreaded everywhere; this makes it very hard to change....
tools/testing/selftests/kvm/include/kvm_util_base.h struct kvm_vm { · line 122
Quoted 5 lines
tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -105,6 +119,13 @@ struct kvm_vm {struct userspace_mem_region *memslot2region (struct kvm_vm *vm,uint32_t memslot); +inline struct userspace_mem_region *Should be static inline.
Review struct kvm_vm { · line 123
Quoted 1 line
(quoted diff) +1
-0+vm_get_mem_regionPlease don't insert newlines before the function name, it makes searching painful. Ignore existing patterns in KVM selfetsts, they're wrong. ;-) Linus has a nice explanation/rant on this[*].
The resulting declaration will run long, but at least for me, I'll take that any day over putting the function name on a new line.
[*] https://lore.kernel.org/all/CAHk-=wjoLAYG446ZNHfg=GhjSY6nFmuB_wA8fYd5iLBNXjo9Bw@mail.gmail.com
Review struct kvm_vm { · line 124
Quoted 1 line
(quoted diff) +0
-0(struct kvm_vm *vm, enum kvm_mem_region_type mrt)One last nit, what about "region" or "type" instead of "mrt"? The acronym made me briefly pause to figure out what "mrt" meant, which is silly because the name really doesn't have much meaning.
Quoted 4 lines
tools/testing/selftests/kvm/include/kvm_util_base.h +4
-0+{ +assert (mrt <NR_MEM_REGIONS ); +return memslot2region (vm, vm->memslots[mrt]); +}...
tools/testing/selftests/kvm/lib/kvm_util.c struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus, · line 296
Quoted 11 lines
tools/testing/selftests/kvm/lib/kvm_util.c +7
-0@@ -293,8 +287,16 @@ struct kvm_vm *__vm_create(enum vm_guest_mode mode, uint32_t nr_runnable_vcpus,uint64_t nr_pages =vm_nr_pages_required (mode, nr_runnable_vcpus, nr_extra_pages);struct kvm_vm *vm; +int i; + +pr_debug ("%s: mode='%s' pages='%ld'\n" , __func__, +vm_guest_mode_string (mode), nr_pages); + + vm =____vm_create (mode); +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,0 , nr_pages,0 );The spacing is weird here. Adding the region and stuffing
vm->memslotsare what should be bundled together, not creating the VM and adding the common region. I.e.pr_debug("%s: mode='%s' pages='%ld'\n", __func__, vm_guest_mode_string(mode), nr_pages); vm = ____vm_create(mode); vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, 0, 0, nr_pages, 0); for (i = 0; i < NR_MEM_REGIONS; i++) vm->memslots[i] = 0;Quoted 5 lines
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1- vm =____vm_create (mode, nr_pages); +for (i =0 ; i <NR_MEM_REGIONS ; i++) + vm->memslots[i] =0 ;
Quoted 5 lines
Quoted 5 lines
tools/testing/selftests/kvm/lib/kvm_util.c +0
-0kvm_vm_elf_load (vm, program_invocation_name);Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
Ack on all the above. Will send a v8 later today.
Thanks!
Ricardo
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 8/13 KVM: selftests: Use the right memslot for code, page-tables, and data allocations
In reply to Ricardo KollerThe previous commit added support for callers of ____vm_create() to specify what memslots to use for code, page-tables, and data allocations. Change them accordingly:
- stacks, code, and exception tables use the code memslot
- page tables and the pgd use the pt memslot
- data (anything allocated with vm_vaddr_alloc()) uses the data memslot
No functional change intended. All allocators keep using memslot #0.
--- .../selftests/kvm/include/kvm_util_base.h | 3 + .../selftests/kvm/lib/aarch64/processor.c | 11 ++-- tools/testing/selftests/kvm/lib/elf.c | 3 +- tools/testing/selftests/kvm/lib/kvm_util.c | 57 ++++++++++++------- .../selftests/kvm/lib/riscv/processor.c | 7 ++- .../selftests/kvm/lib/s390x/processor.c | 7 ++- .../selftests/kvm/lib/x86_64/processor.c | 13 +++-- 7 files changed, 61 insertions(+), 40 deletions(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +3 -0
@@ -402,7 +402,10 @@ void vm_mem_region_move(struct kvm_vm *vm, uint32_t slot, uint64_t new_gpa);void vm_mem_region_delete (struct kvm_vm *vm,uint32_t slot);struct kvm_vcpu *__vm_vcpu_add (struct kvm_vm *vm,uint32_t vcpu_id);vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min); +vm_vaddr_t __vm_vaddr_alloc (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,enum kvm_mem_region_type mr);vm_vaddr_t vm_vaddr_alloc_pages (struct kvm_vm *vm,int nr_pages); +vm_vaddr_t __vm_vaddr_alloc_page (struct kvm_vm *vm,enum kvm_mem_region_type mr);vm_vaddr_t vm_vaddr_alloc_page (struct kvm_vm *vm); void virt_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
tools/testing/selftests/kvm/lib/aarch64/processor.c +6 -5
@@ -79,7 +79,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)if (!vm->pgd_created) {vm_paddr_t paddr =vm_phy_pages_alloc (vm,page_align (vm,ptrs_per_pgd (vm) *8 ) / vm->page_size, -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]); vm->pgd = paddr; vm->pgd_created = true; }
@@ -328,8 +328,9 @@ struct kvm_vcpu *aarch64_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,size_t stack_size = vm->page_size ==4096 ?DEFAULT_STACK_PGS * vm->page_size : vm->page_size; -uint64_t stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_ARM64_GUEST_STACK_VADDR_MIN ); +uint64_t stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_ARM64_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );struct kvm_vcpu *vcpu =__vm_vcpu_add (vm, vcpu_id);aarch64_vcpu_setup (vcpu, init);
@@ -435,8 +436,8 @@ void route_exception(struct ex_regs *regs, int vector)void vm_init_descriptor_tables (struct kvm_vm *vm) { - vm->handlers =vm_vaddr_alloc (vm,sizeof (struct handlers ), - vm->page_size); + vm->handlers =__vm_vaddr_alloc (vm,sizeof (struct handlers ), + vm->page_size,MEM_REGION_CODE ); *(vm_vaddr_t *)addr_gva2hva (vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers; }
tools/testing/selftests/kvm/lib/elf.c +2 -1
@@ -161,7 +161,8 @@ void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename) seg_vend |= vm->page_size -1 ;size_t seg_size = seg_vend - seg_vstart +1 ; -vm_vaddr_t vaddr =vm_vaddr_alloc (vm, seg_size, seg_vstart); +vm_vaddr_t vaddr =__vm_vaddr_alloc (vm, seg_size, seg_vstart, +MEM_REGION_CODE );TEST_ASSERT (vaddr == seg_vstart,"Unable to allocate " "virtual memory for segment at requested min addr,\n" " segment idx: %u\n"
tools/testing/selftests/kvm/lib/kvm_util.c +35 -22
86 lines not on this page · raw message
tools/testing/selftests/kvm/lib/riscv/processor.c +4 -3
@@ -58,7 +58,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)if (!vm->pgd_created) {vm_paddr_t paddr =vm_phy_pages_alloc (vm,page_align (vm,ptrs_per_pte (vm) *8 ) / vm->page_size, -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]); vm->pgd = paddr; vm->pgd_created = true; }
@@ -282,8 +282,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,size_t stack_size = vm->page_size ==4096 ?DEFAULT_STACK_PGS * vm->page_size : vm->page_size; -unsigned long stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_RISCV_GUEST_STACK_VADDR_MIN ); +unsigned long stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_RISCV_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );unsigned long current_gp =0 ;struct kvm_mp_state mps;struct kvm_vcpu *vcpu;
tools/testing/selftests/kvm/lib/s390x/processor.c +4 -3
@@ -21,7 +21,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)return ; paddr =vm_phy_pages_alloc (vm,PAGES_PER_REGION , -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]);memset (addr_gpa2hva (vm, paddr),0xff ,PAGES_PER_REGION * vm->page_size); vm->pgd = paddr;
@@ -167,8 +167,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,TEST_ASSERT (vm->page_size ==4096 ,"Unsupported page size: 0x%x" , vm->page_size); - stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE ); vcpu =__vm_vcpu_add (vm, vcpu_id);
tools/testing/selftests/kvm/lib/x86_64/processor.c +7 -6
@@ -525,7 +525,7 @@ vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)static void kvm_setup_gdt (struct kvm_vm *vm,struct kvm_dtable *dt) {if (!vm->gdt) - vm->gdt =vm_vaddr_alloc_page (vm); + vm->gdt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE ); dt->base = vm->gdt; dt->limit =getpagesize ();
@@ -535,7 +535,7 @@ static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, int selector) {if (!vm->tss) - vm->tss =vm_vaddr_alloc_page (vm); + vm->tss =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );memset (segp,0 ,sizeof (*segp)); segp->base = vm->tss;
@@ -620,8 +620,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,vm_vaddr_t stack_vaddr;struct kvm_vcpu *vcpu; - stack_vaddr =vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE ); vcpu =__vm_vcpu_add (vm, vcpu_id);vcpu_init_cpuid (vcpu,kvm_get_supported_cpuid ());
@@ -1118,8 +1119,8 @@ void vm_init_descriptor_tables(struct kvm_vm *vm)extern void *idt_handlers;int i; - vm->idt =vm_vaddr_alloc_page (vm); - vm->handlers =vm_vaddr_alloc_page (vm); + vm->idt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE ); + vm->handlers =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );/* Handlers have the same address in both address spaces.*/ for (i =0 ; i <NUM_INTERRUPTS ; i++) set_idt_entry(vm, i, (unsigned long)(&idt_handlers)[i], 0,
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Re: [PATCH v7 08/13] KVM: selftests: Use the right memslot for code, page-tables, and data allocations
Quoted 14 lines · Ricardo Koller
The previous commit added support for callers of
____vm_create()to specify what memslots to use for code, page-tables, and data allocations. Change them accordingly:- stacks, code, and exception tables use the code memslot
- page tables and the pgd use the pt memslot
- data (anything allocated withvm_vaddr_alloc()) uses the data memslotNo functional change intended. All allocators keep using memslot #0.
Reviewed-by Oliver Upton <[email protected]>Cc Sean Christopherson <[email protected]>Cc Andrew Jones <[email protected]>Signed-off-by Ricardo Koller <[email protected]>
Quoted 10 lines
--- .../selftests/kvm/include/kvm_util_base.h | 3 + .../selftests/kvm/lib/aarch64/processor.c | 11 ++-- tools/testing/selftests/kvm/lib/elf.c | 3 +- tools/testing/selftests/kvm/lib/kvm_util.c | 57 ++++++++++++------- .../selftests/kvm/lib/riscv/processor.c | 7 ++- .../selftests/kvm/lib/s390x/processor.c | 7 ++- .../selftests/kvm/lib/x86_64/processor.c | 13 +++-- 7 files changed, 61 insertions(+), 40 deletions(-)
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Sean Christopherson
reviewerRe: [PATCH v7 08/13] KVM: selftests: Use the right memslot for code, page-tables, and data allocations
In reply to Ricardo KollerQuoted 1 line · Ricardo Koller
The previous commit added support for callers of
____vm_create()to specify
Changelog is stale, ____vm_create() no longer takes the struct.
Side topic, it's usually a good idea to use "strong" terminology when referencing past/future changes, e.g. if patches get shuffled around for whatever reason, then "previous commit" may become stale/misleading.
It's fairly easy to convey the same info ("something happened recently" or "something is going to happen soon") without being so explicit, e.g.
Wire up common code to use the appropriate code, page table, and data memmslots that were recently added instead of hardcoding '0' for the memslot.
or
Now that kvm_vm allows specifying different memslots for code, page tables, and data, use the appropriate memslot when making allocations in common/libraty code.
Quoted 4 lines
what memslots to use for code, page-tables, and data allocations. Change them accordingly:
- stacks, code, and exception tables use the code memslot
Huh? Stacks and exceptions are very much data, not code.
Quoted 4 lines
- page tables and the pgd use the pt memslot
- data (anything allocated withvm_vaddr_alloc()) uses the data memslotNo functional change intended. All allocators keep using memslot #0.
...
tools/testing/selftests/kvm/lib/kvm_util.c static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, · line 1188
Quoted 3 lines
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1-vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +vm_vaddr_t __vm_vaddr_alloc (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,enum kvm_mem_region_type mrt)
Similar to other feedback, I'd prefer "type" over "mrt".
tools/testing/selftests/kvm/lib/kvm_util.c static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, · line 1195
Quoted 8 lines
{
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) !=0 );virt_pgd_alloc (vm);vm_paddr_t paddr =vm_phy_pages_alloc (vm, pages, -KVM_UTIL_MIN_PFN * vm->page_size,0 ); +KVM_UTIL_MIN_PFN * vm->page_size, + vm->memslots[mrt]);
Please align parameters.
Quoted 6 lines
tools/testing/selftests/kvm/lib/kvm_util.c +0
-0/* * Find an unused range of virtual page addresses of at least @@ -1230,6 +1213,30 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min)return vaddr_start; }
...
tools/testing/selftests/kvm/lib/kvm_util.c vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min) · line 1237
Quoted 3 lines
tools/testing/selftests/kvm/lib/kvm_util.c +3
-0+vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +{ +return __vm_vaddr_alloc (vm, sz, vaddr_min,MEM_REGION_DATA );
I like the vm_alloc_page_table() wrapper, what about adding vm_alloc_code() and vm_alloc_data() too? Feel free to ignore if it's not much of a benefit.
Quoted 32 lines
tools/testing/selftests/kvm/lib/kvm_util.c +9
-1+} +/* * VM Virtual Address Allocate Pages * @@ -1249,6 +1256,11 @@ vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages)return vm_vaddr_alloc (vm, nr_pages *getpagesize (),KVM_UTIL_MIN_VADDR ); } +vm_vaddr_t __vm_vaddr_alloc_page (struct kvm_vm *vm,enum kvm_mem_region_type mrt) +{ +return __vm_vaddr_alloc (vm,getpagesize (),KVM_UTIL_MIN_VADDR , mrt); +} +/* * VM Virtual Address Allocate Page * @@ -1814,7 +1826,8 @@ vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,vm_paddr_t vm_alloc_page_table (struct kvm_vm *vm) { -return vm_phy_page_alloc (vm,KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +return vm_phy_page_alloc (vm,KVM_GUEST_PAGE_TABLE_MIN_PADDR , + vm->memslots[MEM_REGION_PT ]); }/* tools/testing/selftests/kvm/lib/riscv/processor.c +0
-0
tools/testing/selftests/kvm/lib/riscv/processor.c void virt_arch_pgd_alloc(struct kvm_vm *vm) · line 61
Quoted 5 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +1
-1@@ -58,7 +58,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)if (!vm->pgd_created) {vm_paddr_t paddr =vm_phy_pages_alloc (vm,page_align (vm,ptrs_per_pte (vm) *8 ) / vm->page_size, -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]);
Ah, more copy-paste from aarch64. Not your code (though the s390x change below is new badness), but align params please. Similar to newlines before function names, running over the 80 char soft limit is preferrable to weird alignment. And for the soft limit, it's often easy to stay under the soft limit by refactoring, e.g. in a separate prep patch for RISC-V and aarch64, do:
size_t nr_pages = page_align(vm, ptrs_per_pgd(vm) * 8) / vm->page_size; if (vm->pgd_created) return; vm->pgd = vm_phy_pages_alloc(vm, nr_pages, KVM_GUEST_PAGE_TABLE_MIN_PADDR, vm->memslots[MEM_REGION_PT]); vm->pgd_created = true;
tools/testing/selftests/kvm/lib/riscv/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 287
Quoted 12 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +3
-2vm->pgd = paddr; vm->pgd_created = true; }@@ -282,8 +282,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,size_t stack_size = vm->page_size ==4096 ?DEFAULT_STACK_PGS * vm->page_size : vm->page_size; -unsigned long stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_RISCV_GUEST_STACK_VADDR_MIN ); +unsigned long stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_RISCV_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );
Stack is data, not code.
tools/testing/selftests/kvm/lib/s390x/processor.c void virt_arch_pgd_alloc(struct kvm_vm *vm) · line 24
Quoted 13 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +0
-0unsigned long current_gp =0 ;struct kvm_mp_state mps;struct kvm_vcpu *vcpu;tools/testing/selftests/kvm/lib/s390x/processor.c +1
-1@@ -21,7 +21,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)return ; paddr =vm_phy_pages_alloc (vm,PAGES_PER_REGION , -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]);
Please align.
paddr = vm_phy_pages_alloc(vm, PAGES_PER_REGION, KVM_GUEST_PAGE_TABLE_MIN_PADDR, vm->memslots[MEM_REGION_PT]);
tools/testing/selftests/kvm/lib/s390x/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 172
Quoted 12 lines
tools/testing/selftests/kvm/lib/s390x/processor.c +3
-2memset (addr_gpa2hva (vm, paddr),0xff ,PAGES_PER_REGION * vm->page_size); vm->pgd = paddr;@@ -167,8 +167,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,TEST_ASSERT (vm->page_size ==4096 ,"Unsupported page size: 0x%x" , vm->page_size); - stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );
Same bug here.
tools/testing/selftests/kvm/lib/x86_64/processor.c vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva) · line 528
Quoted 13 lines
tools/testing/selftests/kvm/lib/s390x/processor.c +0
-0vcpu =__vm_vcpu_add (vm, vcpu_id);tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-1@@ -525,7 +525,7 @@ vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)static void kvm_setup_gdt (struct kvm_vm *vm,struct kvm_dtable *dt) {if (!vm->gdt) - vm->gdt =vm_vaddr_alloc_page (vm); + vm->gdt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );
GDT is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, · line 538
Quoted 8 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-1dt->base = vm->gdt; dt->limit =getpagesize ();@@ -535,7 +535,7 @@ static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, int selector) {if (!vm->tss) - vm->tss =vm_vaddr_alloc_page (vm); + vm->tss =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );
TSS is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 625
Quoted 12 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +3
-2memset (segp,0 ,sizeof (*segp)); segp->base = vm->tss;@@ -620,8 +620,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,vm_vaddr_t stack_vaddr;struct kvm_vcpu *vcpu; - stack_vaddr =vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );
Stack is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c void vm_init_descriptor_tables(struct kvm_vm *vm) · line 1122
Quoted 9 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-2vcpu =__vm_vcpu_add (vm, vcpu_id);vcpu_init_cpuid (vcpu,kvm_get_supported_cpuid ());@@ -1118,8 +1119,8 @@ void vm_init_descriptor_tables(struct kvm_vm *vm)extern void *idt_handlers;int i; - vm->idt =vm_vaddr_alloc_page (vm); - vm->handlers =vm_vaddr_alloc_page (vm); + vm->idt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );
IDT is data, not code.
Quoted 7 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-0+ vm->handlers =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );/* Handlers have the same address in both address spaces.*/ for (i =0 ; i <NUM_INTERRUPTS ; i++) set_idt_entry(vm, i, (unsigned long)(&idt_handlers)[i], 0,Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
Re: [PATCH v7 08/13] KVM: selftests: Use the right memslot for code, page-tables, and data allocations
Quoted 22 lines · Sean Christopherson
Quoted 1 line · Ricardo Koller
The previous commit added support for callers of
____vm_create()to specifyChangelog is stale,
____vm_create()no longer takes the struct.Side topic, it's usually a good idea to use "strong" terminology when referencing past/future changes, e.g. if patches get shuffled around for whatever reason, then "previous commit" may become stale/misleading.
It's fairly easy to convey the same info ("something happened recently" or "something is going to happen soon") without being so explicit, e.g.
Wire up common code to use the appropriate code, page table, and data memmslots that were recently added instead of hardcoding '0' for the memslot.
or
Now that
kvm_vmallows specifying different memslots for code, page tables, and data, use the appropriate memslot when making allocations in common/libraty code.
Quoted 7 lines
Quoted 4 lines
what memslots to use for code, page-tables, and data allocations. Change them accordingly:
- stacks, code, and exception tables use the code memslot
Huh? Stacks and exceptions are very much data, not code.
I would *really* like to have the data region only store test data. It makes things easier for the test implementation, like owning the whole region. At the same I wanted to have a single region for all the "core pages" like code, descriptors, exception tables, stacks, etc. Not sure what to call it though. So, what about one of these 2 options:
Option A: 3 regions, where we call the "code" region something else, like "core".
Option B: 4 regions: code, page-tables, core-data (stacks, exception tables, etc), test-data.
Quoted 206 lines
Quoted 4 lines
- page tables and the pgd use the pt memslot
- data (anything allocated withvm_vaddr_alloc()) uses the data memslotNo functional change intended. All allocators keep using memslot #0.
...
tools/testing/selftests/kvm/lib/kvm_util.c static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, · line 1188
Quoted 3 lines
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1-vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +vm_vaddr_t __vm_vaddr_alloc (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,enum kvm_mem_region_type mrt)Similar to other feedback, I'd prefer "type" over "mrt".
tools/testing/selftests/kvm/lib/kvm_util.c static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, · line 1195
Quoted 8 lines
{
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) !=0 );virt_pgd_alloc (vm);vm_paddr_t paddr =vm_phy_pages_alloc (vm, pages, -KVM_UTIL_MIN_PFN * vm->page_size,0 ); +KVM_UTIL_MIN_PFN * vm->page_size, + vm->memslots[mrt]);Please align parameters.
Quoted 6 lines
tools/testing/selftests/kvm/lib/kvm_util.c +0
-0/* * Find an unused range of virtual page addresses of at least @@ -1230,6 +1213,30 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min)return vaddr_start; }...
tools/testing/selftests/kvm/lib/kvm_util.c vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min) · line 1237
Quoted 3 lines
tools/testing/selftests/kvm/lib/kvm_util.c +3
-0+vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +{ +return __vm_vaddr_alloc (vm, sz, vaddr_min,MEM_REGION_DATA );I like the
vm_alloc_page_table()wrapper, what about addingvm_alloc_code()andvm_alloc_data()too? Feel free to ignore if it's not much of a benefit.Quoted 32 lines
tools/testing/selftests/kvm/lib/kvm_util.c +9
-1+} +/* * VM Virtual Address Allocate Pages * @@ -1249,6 +1256,11 @@ vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages)return vm_vaddr_alloc (vm, nr_pages *getpagesize (),KVM_UTIL_MIN_VADDR ); } +vm_vaddr_t __vm_vaddr_alloc_page (struct kvm_vm *vm,enum kvm_mem_region_type mrt) +{ +return __vm_vaddr_alloc (vm,getpagesize (),KVM_UTIL_MIN_VADDR , mrt); +} +/* * VM Virtual Address Allocate Page * @@ -1814,7 +1826,8 @@ vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,vm_paddr_t vm_alloc_page_table (struct kvm_vm *vm) { -return vm_phy_page_alloc (vm,KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +return vm_phy_page_alloc (vm,KVM_GUEST_PAGE_TABLE_MIN_PADDR , + vm->memslots[MEM_REGION_PT ]); }/* tools/testing/selftests/kvm/lib/riscv/processor.c +0
-0tools/testing/selftests/kvm/lib/riscv/processor.c void virt_arch_pgd_alloc(struct kvm_vm *vm) · line 61
Quoted 5 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +1
-1@@ -58,7 +58,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)if (!vm->pgd_created) {vm_paddr_t paddr =vm_phy_pages_alloc (vm,page_align (vm,ptrs_per_pte (vm) *8 ) / vm->page_size, -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]);Ah, more copy-paste from aarch64. Not your code (though the s390x change below is new badness), but align params please. Similar to newlines before function names, running over the 80 char soft limit is preferrable to weird alignment. And for the soft limit, it's often easy to stay under the soft limit by refactoring, e.g. in a separate prep patch for RISC-V and aarch64, do:
size_t nr_pages = page_align(vm, ptrs_per_pgd(vm) * 8) / vm->page_size; if (vm->pgd_created) return; vm->pgd = vm_phy_pages_alloc(vm, nr_pages, KVM_GUEST_PAGE_TABLE_MIN_PADDR, vm->memslots[MEM_REGION_PT]); vm->pgd_created = true;tools/testing/selftests/kvm/lib/riscv/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 287
Quoted 12 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +3
-2vm->pgd = paddr; vm->pgd_created = true; }@@ -282,8 +282,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,size_t stack_size = vm->page_size ==4096 ?DEFAULT_STACK_PGS * vm->page_size : vm->page_size; -unsigned long stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_RISCV_GUEST_STACK_VADDR_MIN ); +unsigned long stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_RISCV_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );Stack is data, not code.
tools/testing/selftests/kvm/lib/s390x/processor.c void virt_arch_pgd_alloc(struct kvm_vm *vm) · line 24
Quoted 13 lines
tools/testing/selftests/kvm/lib/riscv/processor.c +0
-0unsigned long current_gp =0 ;struct kvm_mp_state mps;struct kvm_vcpu *vcpu;tools/testing/selftests/kvm/lib/s390x/processor.c +1
-1@@ -21,7 +21,7 @@ void virt_arch_pgd_alloc(struct kvm_vm *vm)return ; paddr =vm_phy_pages_alloc (vm,PAGES_PER_REGION , -KVM_GUEST_PAGE_TABLE_MIN_PADDR ,0 ); +KVM_GUEST_PAGE_TABLE_MIN_PADDR , vm->memslots[MEM_REGION_PT ]);Please align.
paddr = vm_phy_pages_alloc(vm, PAGES_PER_REGION, KVM_GUEST_PAGE_TABLE_MIN_PADDR, vm->memslots[MEM_REGION_PT]);tools/testing/selftests/kvm/lib/s390x/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 172
Quoted 12 lines
tools/testing/selftests/kvm/lib/s390x/processor.c +3
-2memset (addr_gpa2hva (vm, paddr),0xff ,PAGES_PER_REGION * vm->page_size); vm->pgd = paddr;@@ -167,8 +167,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,TEST_ASSERT (vm->page_size ==4096 ,"Unsupported page size: 0x%x" , vm->page_size); - stack_vaddr =vm_vaddr_alloc (vm, stack_size, -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm, stack_size, +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );Same bug here.
tools/testing/selftests/kvm/lib/x86_64/processor.c vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva) · line 528
Quoted 13 lines
tools/testing/selftests/kvm/lib/s390x/processor.c +0
-0vcpu =__vm_vcpu_add (vm, vcpu_id);tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-1@@ -525,7 +525,7 @@ vm_paddr_t addr_arch_gva2gpa(struct kvm_vm *vm, vm_vaddr_t gva)static void kvm_setup_gdt (struct kvm_vm *vm,struct kvm_dtable *dt) {if (!vm->gdt) - vm->gdt =vm_vaddr_alloc_page (vm); + vm->gdt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );GDT is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, · line 538
Quoted 8 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-1dt->base = vm->gdt; dt->limit =getpagesize ();@@ -535,7 +535,7 @@ static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, int selector) {if (!vm->tss) - vm->tss =vm_vaddr_alloc_page (vm); + vm->tss =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );TSS is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, · line 625
Quoted 12 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +3
-2memset (segp,0 ,sizeof (*segp)); segp->base = vm->tss;@@ -620,8 +620,9 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id,vm_vaddr_t stack_vaddr;struct kvm_vcpu *vcpu; - stack_vaddr =vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), -DEFAULT_GUEST_STACK_VADDR_MIN ); + stack_vaddr =__vm_vaddr_alloc (vm,DEFAULT_STACK_PGS *getpagesize (), +DEFAULT_GUEST_STACK_VADDR_MIN , +MEM_REGION_CODE );Stack is data, not code.
tools/testing/selftests/kvm/lib/x86_64/processor.c void vm_init_descriptor_tables(struct kvm_vm *vm) · line 1122
Quoted 9 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-2vcpu =__vm_vcpu_add (vm, vcpu_id);vcpu_init_cpuid (vcpu,kvm_get_supported_cpuid ());@@ -1118,8 +1119,8 @@ void vm_init_descriptor_tables(struct kvm_vm *vm)extern void *idt_handlers;int i; - vm->idt =vm_vaddr_alloc_page (vm); - vm->handlers =vm_vaddr_alloc_page (vm); + vm->idt =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );IDT is data, not code.
Quoted 7 lines
tools/testing/selftests/kvm/lib/x86_64/processor.c +1
-0+ vm->handlers =__vm_vaddr_alloc_page (vm,MEM_REGION_CODE );/* Handlers have the same address in both address spaces.*/ for (i =0 ; i <NUM_INTERRUPTS ; i++) set_idt_entry(vm, i, (unsigned long)(&idt_handlers)[i], 0,Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
Sean Christopherson
reviewerRe: [PATCH v7 08/13] KVM: selftests: Use the right memslot for code, page-tables, and data allocations
Quoted 26 lines · Ricardo Koller
Quoted 25 lines · Sean Christopherson
Quoted 1 line · Ricardo Koller
The previous commit added support for callers of
____vm_create()to specifyChangelog is stale,
____vm_create()no longer takes the struct.Side topic, it's usually a good idea to use "strong" terminology when referencing past/future changes, e.g. if patches get shuffled around for whatever reason, then "previous commit" may become stale/misleading.
It's fairly easy to convey the same info ("something happened recently" or "something is going to happen soon") without being so explicit, e.g.
Wire up common code to use the appropriate code, page table, and data memmslots that were recently added instead of hardcoding '0' for the memslot.
or
Now that
kvm_vmallows specifying different memslots for code, page tables, and data, use the appropriate memslot when making allocations in common/libraty code.Quoted 3 lines
what memslots to use for code, page-tables, and data allocations. Change them accordingly:
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
- stacks, code, and exception tables use the code memslot
Huh? Stacks and exceptions are very much data, not code.
I would *really* like to have the data region only store test data. It makes things easier for the test implementation, like owning the whole region.
That's fine, but allocating stack as "code" is super confusing.
Quoted 3 lines
At the same I wanted to have a single region for all the "core pages" like code, descriptors, exception tables, stacks, etc. Not sure what to call it though.
Why? Code is very different than all those other things. E.g. the main reason KVM doesn't provide "not-executable" or "execute-only" memslots is because there's never been a compelling use case, not because it's difficult to implement. If KVM were to ever add such functionality, then we'd want/need selftests to have a dedicated code memslot.
Quoted 6 lines
So, what about one of these 2 options:
Option A: 3 regions, where we call the "code" region something else, like "core".
Option B: 4 regions: code, page-tables, core-data (stacks, exception tables, etc), test-data.
I like (B), though I'd just call 'em "DATA" and "TEST_DATA". IIUC, TEST_DATA is the one you want to be special, i.e. it's ok if something that's not "core" allocates in DATA, but it's not ok if "core" allocates in TEST_DATA. That yields an easy to understand "never use TEST_DATA" rule for library/common/core functionality, with the code vs. page tables vs. data decision (hopefully) being fairly obvious.
Defining CORE_DATA will force developers to make judgement calls and probably lead to bikeshedding over whether something is considered "core" code.
Re: [PATCH v7 08/13] KVM: selftests: Use the right memslot for code, page-tables, and data allocations
Quoted 55 lines · Sean Christopherson
Quoted 26 lines · Ricardo Koller
Quoted 25 lines · Sean Christopherson
Quoted 1 line · Ricardo Koller
The previous commit added support for callers of
____vm_create()to specifyChangelog is stale,
____vm_create()no longer takes the struct.Side topic, it's usually a good idea to use "strong" terminology when referencing past/future changes, e.g. if patches get shuffled around for whatever reason, then "previous commit" may become stale/misleading.
It's fairly easy to convey the same info ("something happened recently" or "something is going to happen soon") without being so explicit, e.g.
Wire up common code to use the appropriate code, page table, and data memmslots that were recently added instead of hardcoding '0' for the memslot.
or
Now that
kvm_vmallows specifying different memslots for code, page tables, and data, use the appropriate memslot when making allocations in common/libraty code.Quoted 3 lines
what memslots to use for code, page-tables, and data allocations. Change them accordingly:
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
- stacks, code, and exception tables use the code memslot
Huh? Stacks and exceptions are very much data, not code.
I would *really* like to have the data region only store test data. It makes things easier for the test implementation, like owning the whole region.
That's fine, but allocating stack as "code" is super confusing.
Quoted 3 lines
At the same I wanted to have a single region for all the "core pages" like code, descriptors, exception tables, stacks, etc. Not sure what to call it though.
Why? Code is very different than all those other things. E.g. the main reason KVM doesn't provide "not-executable" or "execute-only" memslots is because there's never been a compelling use case, not because it's difficult to implement. If KVM were to ever add such functionality, then we'd want/need selftests to have a dedicated code memslot.
Quoted 6 lines
So, what about one of these 2 options:
Option A: 3 regions, where we call the "code" region something else, like "core".
Option B: 4 regions: code, page-tables, core-data (stacks, exception tables, etc), test-data.
Quoted 8 lines
I like (B), though I'd just call 'em "DATA" and "
TEST_DATA". IIUC,TEST_DATAis the one you want to be special, i.e. it's ok if something that's not "core" allocates in DATA, but it's not ok if "core" allocates inTEST_DATA. That yields an easy to understand "never useTEST_DATA" rule for library/common/core functionality, with the code vs. page tables vs. data decision (hopefully) being fairly obvious.Defining
CORE_DATAwill force developers to make judgement calls and probably lead to bikeshedding over whether something is considered "core" code.
Sounds good, Option B then (with code, pt, data, test-data).
Thanks,
Ricardo
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 9/13 KVM: selftests: aarch64: Add aarch64/page_fault_test
In reply to Ricardo KollerAdd a new test for stage 2 faults when using different combinations of guest accesses (e.g., write, S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on hugetlbfs with a hole). The next commits will add different handling methods and more faults (e.g., uffd and dirty logging). This first commit starts by adding two sanity checks for all types of accesses: AF setting by the hw, and accessing memslots with holes.
--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/aarch64/page_fault_test.c | 601 ++++++++++++++++++ .../selftests/kvm/include/aarch64/processor.h | 8 + 4 files changed, 611 insertions(+) create mode 100644 tools/testing/selftests/kvm/aarch64/page_fault_test.c
tools/testing/selftests/kvm/.gitignore +1 -0
@@ -3,6 +3,7 @@ /aarch64/debug-exceptions /aarch64/get-reg-list /aarch64/hypercalls +/aarch64/page_fault_test /aarch64/psci_test /aarch64/vcpu_width_config /aarch64/vgic_init
tools/testing/selftests/kvm/Makefile +1 -0
@@ -149,6 +149,7 @@ TEST_GEN_PROGS_aarch64 += aarch64/arch_timer TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list TEST_GEN_PROGS_aarch64 += aarch64/hypercalls +TEST_GEN_PROGS_aarch64 += aarch64/page_fault_test TEST_GEN_PROGS_aarch64 += aarch64/psci_test TEST_GEN_PROGS_aarch64 += aarch64/vcpu_width_config TEST_GEN_PROGS_aarch64 += aarch64/vgic_init
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +601 -0
601 lines not on this page · raw message
tools/testing/selftests/kvm/include/aarch64/processor.h +8 -0
@@ -105,11 +105,19 @@ enum {#define ESR_EC_MASK (ESR_EC_NUM - 1)#define ESR_EC_SVC64 0x15 +#define ESR_EC_IABT 0x21 +#define ESR_EC_DABT 0x25#define ESR_EC_HW_BP_CURRENT 0x31#define ESR_EC_SSTEP_CURRENT 0x33#define ESR_EC_WP_CURRENT 0x35#define ESR_EC_BRK_INS 0x3c +/* Access flag */ +#define PTE_AF (1ULL << 10) + +/* Access flag update enable/disable */ +#define TCR_EL1_HA (1ULL << 39) +void aarch64_get_supported_page_sizes (uint32_t ipa,bool *ps4k,bool *ps16k,bool *ps64k);
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Re: [PATCH v7 09/13] KVM: selftests: aarch64: Add aarch64/page_fault_test
Quoted 404 lines · Ricardo Koller
Add a new test for stage 2 faults when using different combinations of guest accesses (e.g., write, S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on hugetlbfs with a hole). The next commits will add different handling methods and more faults (e.g., uffd and dirty logging). This first commit starts by adding two sanity checks for all types of accesses: AF setting by the hw, and accessing memslots with holes.
Signed-off-by Ricardo Koller <[email protected]>--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/aarch64/page_fault_test.c | 601 ++++++++++++++++++ .../selftests/kvm/include/aarch64/processor.h | 8 + 4 files changed, 611 insertions(+) create mode 100644 tools/testing/selftests/kvm/aarch64/page_fault_test.ctools/testing/selftests/kvm/.gitignore +1
-0@@ -3,6 +3,7 @@ /aarch64/debug-exceptions /aarch64/get-reg-list /aarch64/hypercalls +/aarch64/page_fault_test /aarch64/psci_test /aarch64/vcpu_width_config /aarch64/vgic_inittools/testing/selftests/kvm/Makefile +1
-0@@ -149,6 +149,7 @@ TEST_GEN_PROGS_aarch64 += aarch64/arch_timer TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list TEST_GEN_PROGS_aarch64 += aarch64/hypercalls +TEST_GEN_PROGS_aarch64 += aarch64/page_fault_test TEST_GEN_PROGS_aarch64 += aarch64/psci_test TEST_GEN_PROGS_aarch64 += aarch64/vcpu_width_config TEST_GEN_PROGS_aarch64 += aarch64/vgic_inittools/testing/selftests/kvm/aarch64/page_fault_test.c new file +357
-0@@ -0,0 +1,601 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* page_fault_test.c - Test stage 2 faults. +* +* This test tries different combinations of guest accesses (e.g., write, +* S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on +* hugetlbfs with a hole). It checks that the expected handling method is +* called (e.g., uffd faults with the right address and write/read flag). +*/ + +#define _GNU_SOURCE +#include <linux/bitmap.h> +#include <fcntl.h> +#include <test_util.h> +#include <kvm_util.h> +#include <processor.h> +#include <asm/sysreg.h> +#include <linux/bitfield.h> +#include "guest_modes.h" +#include "userfaultfd_util.h" + +/* Guest virtual addresses that point to the test page and its PTE. */ +#define TEST_GVA 0xc0000000 +#define TEST_EXEC_GVA (TEST_GVA + 0x8) +#define TEST_PTE_GVA 0xb0000000 +#define TEST_DATA 0x0123456789ABCDEF + +static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA ; + +#define CMD_NONE (0) +#define CMD_SKIP_TEST (1ULL << 1) +#define CMD_HOLE_PT (1ULL << 2) +#define CMD_HOLE_DATA (1ULL << 3) + +#define PREPARE_FN_NR 10 +#define CHECK_FN_NR 10 + +struct test_desc { +const char *name; +uint64_t mem_mark_cmd; +/* Skip the test if any prepare function returns false */ +bool (*guest_prepare[PREPARE_FN_NR ])(void ); +void (*guest_test)(void ); +void (*guest_test_check[CHECK_FN_NR ])(void ); +void (*dabt_handler)(struct ex_regs *regs); +void (*iabt_handler)(struct ex_regs *regs); +uint32_t pt_memslot_flags; +uint32_t data_memslot_flags; +bool skip; +}; + +struct test_params { +enum vm_mem_backing_src_type src_type; +struct test_desc *test_desc; +}; + +static inline void flush_tlb_page (uint64_t vaddr) +{ +uint64_t page = vaddr >>12 ; + +dsb (ishst); + asmvolatile ("tlbi vaae1is, %0" ::"r" (page)); +dsb (ish); +isb (); +} + +static void guest_write64 (void ) +{ +uint64_t val; + +WRITE_ONCE (*guest_test_memory,TEST_DATA ); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,TEST_DATA ); +} + +/* Check the system for atomic instructions. */ +static bool guest_check_lse (void ) +{ +uint64_t isar0 =read_sysreg (id_aa64isar0_el1); +uint64_t atomic; + + atomic =FIELD_GET (ARM64_FEATURE_MASK (ID_AA64ISAR0_ATOMICS ), isar0); +return atomic >=2 ; +} + +static bool guest_check_dc_zva (void ) +{ +uint64_t dczid =read_sysreg (dczid_el0); +uint64_t dzp =FIELD_GET (ARM64_FEATURE_MASK (DCZID_DZP ), dczid); + +return dzp ==0 ; +} + +/* Compare and swap instruction. */ +static void guest_cas (void ) +{ +uint64_t val; + +GUEST_ASSERT (guest_check_lse ()); + asmvolatile (".arch_extension lse\n" +"casal %0, %1, [%2]\n" + ::"r" (0 ),"r" (TEST_DATA ),"r" (guest_test_memory)); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,TEST_DATA ); +} + +static void guest_read64 (void ) +{ +uint64_t val; + + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,0 ); +} + +/* Address translation instruction */ +static void guest_at (void ) +{ +uint64_t par; + + asmvolatile ("at s1e1r, %0" ::"r" (guest_test_memory)); + par =read_sysreg (par_el1); +isb (); + +/* Bit 1 indicates whether the AT was successful */ +GUEST_ASSERT_EQ (par &1 ,0 ); +} + +/* +* The size of the block written by "dc zva" is guaranteed to be between (2 << +* 0) and (2 << 9), which is safe in our case as we need the write to happen +* for at least a word, and not more than a page. +*/ +static void guest_dc_zva (void ) +{ +uint16_t val; + + asmvolatile ("dc zva, %0" ::"r" (guest_test_memory)); +dsb (ish); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,0 ); +} + +/* +* Pre-indexing loads and stores don't have a valid syndrome (ESR_EL2.ISV==0). +* And that's special because KVM must take special care with those: they +* should still count as accesses for dirty logging or user-faulting, but +* should be handled differently on mmio. +*/ +static void guest_ld_preidx (void ) +{ +uint64_t val; +uint64_t addr =TEST_GVA -8 ; + +/* +* This ends up accessing "TEST_GVA + 8 - 8", where "TEST_GVA - 8" is +* in a gap between memslots not backing by anything. +*/ + asmvolatile ("ldr %0, [%1, #8]!" + :"=r" (val),"+r" (addr)); +GUEST_ASSERT_EQ (val,0 ); +GUEST_ASSERT_EQ (addr,TEST_GVA ); +} + +static void guest_st_preidx (void ) +{ +uint64_t val =TEST_DATA ; +uint64_t addr =TEST_GVA -8 ; + + asmvolatile ("str %0, [%1, #8]!" + :"+r" (val),"+r" (addr)); + +GUEST_ASSERT_EQ (addr,TEST_GVA ); + val =READ_ONCE (*guest_test_memory); +} + +static bool guest_set_ha (void ) +{ +uint64_t mmfr1 =read_sysreg (id_aa64mmfr1_el1); +uint64_t hadbs, tcr; + +/* Skip if HA is not supported. */ + hadbs =FIELD_GET (ARM64_FEATURE_MASK (ID_AA64MMFR1_HADBS ), mmfr1); +if (hadbs ==0 ) +return false; + + tcr =read_sysreg (tcr_el1) |TCR_EL1_HA ; +write_sysreg (tcr, tcr_el1); +isb (); + +return true; +} + +static bool guest_clear_pte_af (void ) +{ + *((uint64_t *)TEST_PTE_GVA ) &= ~PTE_AF ; +flush_tlb_page (TEST_GVA ); + +return true; +} + +static void guest_check_pte_af (void ) +{ +dsb (ish); +GUEST_ASSERT_EQ (*((uint64_t *)TEST_PTE_GVA ) &PTE_AF ,PTE_AF ); +} + +static void guest_exec (void ) +{ +int (*code)(void ) = (int (*)(void ))TEST_EXEC_GVA ; +int ret; + + ret =code (); +GUEST_ASSERT_EQ (ret,0x77 ); +} + +static bool guest_prepare (struct test_desc *test) +{ +bool (*prepare_fn)(void ); +int i; + +for (i =0 ; i <PREPARE_FN_NR ; i++) { + prepare_fn = test->guest_prepare[i]; +if (prepare_fn && !prepare_fn ()) +return false; + } + +return true; +} + +static void guest_test_check (struct test_desc *test) +{ +void (*check_fn)(void ); +int i; + +for (i =0 ; i <CHECK_FN_NR ; i++) { + check_fn = test->guest_test_check[i]; +if (check_fn) +check_fn (); + } +} + +static void guest_code (struct test_desc *test) +{ +if (!guest_prepare (test)) +GUEST_SYNC (CMD_SKIP_TEST ); + +GUEST_SYNC (test->mem_mark_cmd); + +if (test->guest_test) + test->guest_test (); + +guest_test_check (test); +GUEST_DONE (); +} + +static void no_dabt_handler (struct ex_regs *regs) +{ +GUEST_ASSERT_1 (false,read_sysreg (far_el1)); +} + +static void no_iabt_handler (struct ex_regs *regs) +{ +GUEST_ASSERT_1 (false, regs->pc); +} + +/* Returns true to continue the test, and false if it should be skipped. */ +static bool punch_hole_in_memslot (struct kvm_vm *vm, +struct userspace_mem_region *region) +{ +void *hva = (void *)region->region.userspace_addr; +uint64_t paging_size = region->region.memory_size; +int ret, fd = region->fd; + +if (fd !=-1 ) { + ret =fallocate (fd,FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , +0 , paging_size); +TEST_ASSERT (ret ==0 ,"fallocate failed, errno: %d\n" , errno); + }else { +if (is_backing_src_hugetlb (region->backing_src_type)) +return false; + + ret =madvise (hva, paging_size,MADV_DONTNEED ); +TEST_ASSERT (ret ==0 ,"madvise failed, errno: %d\n" , errno); + } + +return true; +} + +/* Returns true to continue the test, and false if it should be skipped. */ +static bool handle_cmd (struct kvm_vm *vm,int cmd) +{ +struct userspace_mem_region *data_region, *pt_region; +bool continue_test = true; + + data_region =vm_get_mem_region (vm,MEM_REGION_DATA ); + pt_region =vm_get_mem_region (vm,MEM_REGION_PT ); + +if (cmd ==CMD_SKIP_TEST ) + continue_test = false; + +if (cmd &CMD_HOLE_PT ) + continue_test =punch_hole_in_memslot (vm, pt_region); +if (cmd &CMD_HOLE_DATA ) + continue_test =punch_hole_in_memslot (vm, data_region); + +return continue_test; +} + +typedef uint32_t aarch64_insn_t ; +extern aarch64_insn_t __exec_test[2 ]; + +void noinline __return_0x77(void) +{ + asmvolatile ("__exec_test: mov x0, #0x77\n" +"ret\n" ); +} + +/* +* Note that this function runs on the host before the test VM starts: there's +* no need to sync the D$ and I$ caches. +*/ +static void load_exec_code_for_test (struct kvm_vm *vm) +{ +uint64_t *code; +struct userspace_mem_region *region; +void *hva; + + region =vm_get_mem_region (vm,MEM_REGION_DATA ); + hva = (void *)region->region.userspace_addr; + +assert (TEST_EXEC_GVA >TEST_GVA ); + code = hva +TEST_EXEC_GVA -TEST_GVA ; +memcpy (code, __exec_test,sizeof (__exec_test)); +} + +static void setup_abort_handlers (struct kvm_vm *vm,struct kvm_vcpu *vcpu, +struct test_desc *test) +{ +vm_init_descriptor_tables (vm); +vcpu_init_descriptor_tables (vcpu); + +vm_install_sync_handler (vm,VECTOR_SYNC_CURRENT , +ESR_EC_DABT , no_dabt_handler); +vm_install_sync_handler (vm,VECTOR_SYNC_CURRENT , +ESR_EC_IABT , no_iabt_handler); +} + +static void setup_gva_maps (struct kvm_vm *vm) +{ +struct userspace_mem_region *region; +uint64_t pte_gpa; + + region =vm_get_mem_region (vm,MEM_REGION_DATA ); +/* Map TEST_GVA first. This will install a new PTE. */ +virt_pg_map (vm,TEST_GVA , region->region.guest_phys_addr); +/* Then map TEST_PTE_GVA to the above PTE. */ + pte_gpa =addr_hva2gpa (vm,virt_get_pte_hva (vm,TEST_GVA ));
tools/testing/selftests/kvm/aarch64/page_fault_test.c line 367
Quoted 10 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +10
-0+virt_pg_map (vm,TEST_PTE_GVA , pte_gpa); +} + +unsigned long get_max_gfn (enum vm_guest_mode mode) +{ +unsigned int pa_bits = vm_guest_mode_params[mode].pa_bits; +unsigned int page_shift = vm_guest_mode_params[mode].page_shift; + +return ((1ULL << pa_bits) >> page_shift) -1 ; +}
The above function should be deleted.
Quoted 205 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +205
-0+ +enum pf_test_memslots { +CODE_MEMSLOT , +PAGE_TABLE_MEMSLOT , +DATA_MEMSLOT , +}; + +/* Create a code memslot at pfn=0, and data and PT ones at max_gfn. */ +static void setup_memslots (struct kvm_vm *vm,struct test_params *p) +{ +uint64_t backing_src_pagesz =get_backing_src_pagesz (p->src_type); +uint64_t guest_page_size = vm->page_size; +uint64_t max_gfn =vm_compute_max_gfn (vm); +/* Enough for 2M of code when using 4K guest pages. */ +uint64_t code_npages =512 ; +uint64_t pt_size, data_size, data_gpa; + +/* +* This test requires 1 pgd, 2 pud, 4 pmd, and 6 pte pages when using +* VM_MODE_P48V48_4K. Note that the .text takes ~1.6MBs. That's 13 +* pages. VM_MODE_P48V48_4K is the mode with most PT pages; let's use +* twice that just in case. +*/ + pt_size =26 * guest_page_size; + +/* memslot sizes and gpa's must be aligned to the backing page size */ + pt_size =align_up (pt_size, backing_src_pagesz); + data_size =align_up (guest_page_size, backing_src_pagesz); + data_gpa = (max_gfn * guest_page_size) - data_size; + data_gpa =align_down (data_gpa, backing_src_pagesz); + +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,CODE_MEMSLOT , + code_npages,0 ); + vm->memslots[MEM_REGION_CODE ] =CODE_MEMSLOT ; + +vm_userspace_mem_region_add (vm, p->src_type, data_gpa - pt_size, +PAGE_TABLE_MEMSLOT , pt_size / guest_page_size, + p->test_desc->pt_memslot_flags); + vm->memslots[MEM_REGION_PT ] =PAGE_TABLE_MEMSLOT ; + +vm_userspace_mem_region_add (vm, p->src_type, data_gpa,DATA_MEMSLOT , + data_size / guest_page_size, + p->test_desc->data_memslot_flags); + vm->memslots[MEM_REGION_DATA ] =DATA_MEMSLOT ; +} + +static void print_test_banner (enum vm_guest_mode mode,struct test_params *p) +{ +struct test_desc *test = p->test_desc; + +pr_debug ("Test: %s\n" , test->name); +pr_debug ("Testing guest mode: %s\n" ,vm_guest_mode_string (mode)); +pr_debug ("Testing memory backing src type: %s\n" , +vm_mem_backing_src_alias (p->src_type)->name); +} + +/* +* This function either succeeds, skips the test (after setting test->skip), or +* fails with a TEST_FAIL that aborts all tests. +*/ +static void vcpu_run_loop (struct kvm_vm *vm,struct kvm_vcpu *vcpu, +struct test_desc *test) +{ +struct ucall uc; + +for (;;) { +vcpu_run (vcpu); + +switch (get_ucall (vcpu, &uc)) { +case UCALL_SYNC : +if (!handle_cmd (vm, uc.args[1 ])) { + test->skip = true; + goto done; + } +break ; +case UCALL_ABORT : +REPORT_GUEST_ASSERT_2 (uc,"values: %#lx, %#lx" ); +break ; +case UCALL_DONE : + goto done; +default : +TEST_FAIL ("Unknown ucall %lu" , uc.cmd); + } + } + +done: +pr_debug (test->skip ?"Skipped.\n" :"Done.\n" ); +return ; +} + +static void run_test (enum vm_guest_mode mode,void *arg) +{ +struct test_params *p = (struct test_params *)arg; +struct test_desc *test = p->test_desc; +struct kvm_vm *vm; +struct kvm_vcpu *vcpu; + +print_test_banner (mode, p); + + vm =____vm_create (mode); +setup_memslots (vm, p); +kvm_vm_elf_load (vm, program_invocation_name); + vcpu =vm_vcpu_add (vm,0 , guest_code); + +setup_gva_maps (vm); + +ucall_init (vm,NULL ); + +load_exec_code_for_test (vm); +setup_abort_handlers (vm, vcpu, test); +vcpu_args_set (vcpu,1 , test); + +vcpu_run_loop (vm, vcpu, test); + +ucall_uninit (vm); +kvm_vm_free (vm); +} + +static void help (char *name) +{ +puts ("" ); +printf ("usage: %s [-h] [-s mem-type]\n" , name); +puts ("" ); +guest_modes_help (); +backing_src_help ("-s" ); +puts ("" ); +} + +#define SNAME (s) #s +#define SCAT2 (a, b) SNAME(a ## _ ## b) +#define SCAT3 (a, b, c) SCAT2(a, SCAT2(b, c)) + +#define _CHECK (_test) _CHECK_##_test +#define _PREPARE (_test) _PREPARE_##_test +#define _PREPARE_guest_read64 NULL +#define _PREPARE_guest_ld_preidx NULL +#define _PREPARE_guest_write64 NULL +#define _PREPARE_guest_st_preidx NULL +#define _PREPARE_guest_exec NULL +#define _PREPARE_guest_at NULL +#define _PREPARE_guest_dc_zva guest_check_dc_zva +#define _PREPARE_guest_cas guest_check_lse + +/* With or without access flag checks */ +#define _PREPARE_with_af guest_set_ha, guest_clear_pte_af +#define _PREPARE_no_af NULL +#define _CHECK_with_af guest_check_pte_af +#define _CHECK_no_af NULL + +/* Performs an access and checks that no faults were triggered. */ +#define TEST_ACCESS (_access, _with_af, _mark_cmd) \ +{ \ + .name = SCAT3(_access, _with_af, #_mark_cmd), \ + .guest_prepare = { _PREPARE(_with_af), \ + _PREPARE(_access) }, \ + .mem_mark_cmd = _mark_cmd, \ + .guest_test = _access, \ + .guest_test_check = { _CHECK(_with_af) }, \ +} + +static struct test_desc tests[] = { + +/* Check that HW is setting the Access Flag (AF) (sanity checks). */ +TEST_ACCESS (guest_read64, with_af,CMD_NONE ), +TEST_ACCESS (guest_ld_preidx, with_af,CMD_NONE ), +TEST_ACCESS (guest_cas, with_af,CMD_NONE ), +TEST_ACCESS (guest_write64, with_af,CMD_NONE ), +TEST_ACCESS (guest_st_preidx, with_af,CMD_NONE ), +TEST_ACCESS (guest_dc_zva, with_af,CMD_NONE ), +TEST_ACCESS (guest_exec, with_af,CMD_NONE ), + +/* +* Accessing a hole in the data memslot (punched with fallocate or +* madvise) shouldn't fault (more sanity checks). +*/ +TEST_ACCESS (guest_read64, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_cas, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_ld_preidx, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_write64, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_st_preidx, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_at, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_dc_zva, no_af,CMD_HOLE_DATA ), + + {0 } +}; + +static void for_each_test_and_guest_mode ( +void (*func)(enum vm_guest_mode m,void *a), +enum vm_mem_backing_src_type src_type) +{ +struct test_desc *t; + +for (t = &tests[0 ]; t->name; t++) { +if (t->skip) +continue ; + +struct test_params p = { + .src_type = src_type, + .test_desc = t, + }; + +for_each_guest_mode (run_test, &p); + } +} +
tools/testing/selftests/kvm/aarch64/page_fault_test.c line 582
Quoted 10 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +10
-0+int main (int argc,char *argv[]) +{ +enum vm_mem_backing_src_type src_type; +int opt; + +setbuf (stdout,NULL ); + + src_type =DEFAULT_VM_MEM_SRC ; + +guest_modes_append_default ();
This guest mode append call is redundant with the one already done in the constructor function, so it isn't necessary for aarch64-only tests.
Quoted 46 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +19
-0+ +while ((opt =getopt (argc, argv,"hm:s:" )) !=-1 ) { +switch (opt) { +case 'm' : +guest_modes_cmdline (optarg); +break ; +case 's' : + src_type =parse_backing_src_type (optarg); +break ; +case 'h' : +default : +help (argv[0 ]); +exit (0 ); + } + } + +for_each_test_and_guest_mode (run_test, src_type); +return 0 ; +}tools/testing/selftests/kvm/include/aarch64/processor.h +8
-0@@ -105,11 +105,19 @@ enum {#define ESR_EC_MASK (ESR_EC_NUM - 1)#define ESR_EC_SVC64 0x15 +#define ESR_EC_IABT 0x21 +#define ESR_EC_DABT 0x25#define ESR_EC_HW_BP_CURRENT 0x31#define ESR_EC_SSTEP_CURRENT 0x33#define ESR_EC_WP_CURRENT 0x35#define ESR_EC_BRK_INS 0x3c +/* Access flag */ +#define PTE_AF (1ULL << 10) + +/* Access flag update enable/disable */ +#define TCR_EL1_HA (1ULL << 39) +void aarch64_get_supported_page_sizes (uint32_t ipa,bool *ps4k,bool *ps16k,bool *ps64k);Signature · 1 line
2.37.3.968.ga6b4b080e4-goog
Thanks,
drew
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Re: [PATCH v7 09/13] KVM: selftests: aarch64: Add aarch64/page_fault_test
Quoted 409 lines · Andrew Jones
Quoted 408 lines · Ricardo Koller
Add a new test for stage 2 faults when using different combinations of guest accesses (e.g., write, S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on hugetlbfs with a hole). The next commits will add different handling methods and more faults (e.g., uffd and dirty logging). This first commit starts by adding two sanity checks for all types of accesses: AF setting by the hw, and accessing memslots with holes.
Signed-off-by Ricardo Koller <[email protected]>--- tools/testing/selftests/kvm/.gitignore | 1 + tools/testing/selftests/kvm/Makefile | 1 + .../selftests/kvm/aarch64/page_fault_test.c | 601 ++++++++++++++++++ .../selftests/kvm/include/aarch64/processor.h | 8 + 4 files changed, 611 insertions(+) create mode 100644 tools/testing/selftests/kvm/aarch64/page_fault_test.ctools/testing/selftests/kvm/.gitignore +1
-0@@ -3,6 +3,7 @@ /aarch64/debug-exceptions /aarch64/get-reg-list /aarch64/hypercalls +/aarch64/page_fault_test /aarch64/psci_test /aarch64/vcpu_width_config /aarch64/vgic_inittools/testing/selftests/kvm/Makefile +1
-0@@ -149,6 +149,7 @@ TEST_GEN_PROGS_aarch64 += aarch64/arch_timer TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list TEST_GEN_PROGS_aarch64 += aarch64/hypercalls +TEST_GEN_PROGS_aarch64 += aarch64/page_fault_test TEST_GEN_PROGS_aarch64 += aarch64/psci_test TEST_GEN_PROGS_aarch64 += aarch64/vcpu_width_config TEST_GEN_PROGS_aarch64 += aarch64/vgic_inittools/testing/selftests/kvm/aarch64/page_fault_test.c new file +361
-0@@ -0,0 +1,601 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* page_fault_test.c - Test stage 2 faults. +* +* This test tries different combinations of guest accesses (e.g., write, +* S1PTW), backing source type (e.g., anon) and types of faults (e.g., read on +* hugetlbfs with a hole). It checks that the expected handling method is +* called (e.g., uffd faults with the right address and write/read flag). +*/ + +#define _GNU_SOURCE +#include <linux/bitmap.h> +#include <fcntl.h> +#include <test_util.h> +#include <kvm_util.h> +#include <processor.h> +#include <asm/sysreg.h> +#include <linux/bitfield.h> +#include "guest_modes.h" +#include "userfaultfd_util.h" + +/* Guest virtual addresses that point to the test page and its PTE. */ +#define TEST_GVA 0xc0000000 +#define TEST_EXEC_GVA (TEST_GVA + 0x8) +#define TEST_PTE_GVA 0xb0000000 +#define TEST_DATA 0x0123456789ABCDEF + +static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA ; + +#define CMD_NONE (0) +#define CMD_SKIP_TEST (1ULL << 1) +#define CMD_HOLE_PT (1ULL << 2) +#define CMD_HOLE_DATA (1ULL << 3) + +#define PREPARE_FN_NR 10 +#define CHECK_FN_NR 10 + +struct test_desc { +const char *name; +uint64_t mem_mark_cmd; +/* Skip the test if any prepare function returns false */ +bool (*guest_prepare[PREPARE_FN_NR ])(void ); +void (*guest_test)(void ); +void (*guest_test_check[CHECK_FN_NR ])(void ); +void (*dabt_handler)(struct ex_regs *regs); +void (*iabt_handler)(struct ex_regs *regs); +uint32_t pt_memslot_flags; +uint32_t data_memslot_flags; +bool skip; +}; + +struct test_params { +enum vm_mem_backing_src_type src_type; +struct test_desc *test_desc; +}; + +static inline void flush_tlb_page (uint64_t vaddr) +{ +uint64_t page = vaddr >>12 ; + +dsb (ishst); + asmvolatile ("tlbi vaae1is, %0" ::"r" (page)); +dsb (ish); +isb (); +} + +static void guest_write64 (void ) +{ +uint64_t val; + +WRITE_ONCE (*guest_test_memory,TEST_DATA ); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,TEST_DATA ); +} + +/* Check the system for atomic instructions. */ +static bool guest_check_lse (void ) +{ +uint64_t isar0 =read_sysreg (id_aa64isar0_el1); +uint64_t atomic; + + atomic =FIELD_GET (ARM64_FEATURE_MASK (ID_AA64ISAR0_ATOMICS ), isar0); +return atomic >=2 ; +} + +static bool guest_check_dc_zva (void ) +{ +uint64_t dczid =read_sysreg (dczid_el0); +uint64_t dzp =FIELD_GET (ARM64_FEATURE_MASK (DCZID_DZP ), dczid); + +return dzp ==0 ; +} + +/* Compare and swap instruction. */ +static void guest_cas (void ) +{ +uint64_t val; + +GUEST_ASSERT (guest_check_lse ()); + asmvolatile (".arch_extension lse\n" +"casal %0, %1, [%2]\n" + ::"r" (0 ),"r" (TEST_DATA ),"r" (guest_test_memory)); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,TEST_DATA ); +} + +static void guest_read64 (void ) +{ +uint64_t val; + + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,0 ); +} + +/* Address translation instruction */ +static void guest_at (void ) +{ +uint64_t par; + + asmvolatile ("at s1e1r, %0" ::"r" (guest_test_memory)); + par =read_sysreg (par_el1); +isb (); + +/* Bit 1 indicates whether the AT was successful */ +GUEST_ASSERT_EQ (par &1 ,0 ); +} + +/* +* The size of the block written by "dc zva" is guaranteed to be between (2 << +* 0) and (2 << 9), which is safe in our case as we need the write to happen +* for at least a word, and not more than a page. +*/ +static void guest_dc_zva (void ) +{ +uint16_t val; + + asmvolatile ("dc zva, %0" ::"r" (guest_test_memory)); +dsb (ish); + val =READ_ONCE (*guest_test_memory); +GUEST_ASSERT_EQ (val,0 ); +} + +/* +* Pre-indexing loads and stores don't have a valid syndrome (ESR_EL2.ISV==0). +* And that's special because KVM must take special care with those: they +* should still count as accesses for dirty logging or user-faulting, but +* should be handled differently on mmio. +*/ +static void guest_ld_preidx (void ) +{ +uint64_t val; +uint64_t addr =TEST_GVA -8 ; + +/* +* This ends up accessing "TEST_GVA + 8 - 8", where "TEST_GVA - 8" is +* in a gap between memslots not backing by anything. +*/ + asmvolatile ("ldr %0, [%1, #8]!" + :"=r" (val),"+r" (addr)); +GUEST_ASSERT_EQ (val,0 ); +GUEST_ASSERT_EQ (addr,TEST_GVA ); +} + +static void guest_st_preidx (void ) +{ +uint64_t val =TEST_DATA ; +uint64_t addr =TEST_GVA -8 ; + + asmvolatile ("str %0, [%1, #8]!" + :"+r" (val),"+r" (addr)); + +GUEST_ASSERT_EQ (addr,TEST_GVA ); + val =READ_ONCE (*guest_test_memory); +} + +static bool guest_set_ha (void ) +{ +uint64_t mmfr1 =read_sysreg (id_aa64mmfr1_el1); +uint64_t hadbs, tcr; + +/* Skip if HA is not supported. */ + hadbs =FIELD_GET (ARM64_FEATURE_MASK (ID_AA64MMFR1_HADBS ), mmfr1); +if (hadbs ==0 ) +return false; + + tcr =read_sysreg (tcr_el1) |TCR_EL1_HA ; +write_sysreg (tcr, tcr_el1); +isb (); + +return true; +} + +static bool guest_clear_pte_af (void ) +{ + *((uint64_t *)TEST_PTE_GVA ) &= ~PTE_AF ; +flush_tlb_page (TEST_GVA ); + +return true; +} + +static void guest_check_pte_af (void ) +{ +dsb (ish); +GUEST_ASSERT_EQ (*((uint64_t *)TEST_PTE_GVA ) &PTE_AF ,PTE_AF ); +} + +static void guest_exec (void ) +{ +int (*code)(void ) = (int (*)(void ))TEST_EXEC_GVA ; +int ret; + + ret =code (); +GUEST_ASSERT_EQ (ret,0x77 ); +} + +static bool guest_prepare (struct test_desc *test) +{ +bool (*prepare_fn)(void ); +int i; + +for (i =0 ; i <PREPARE_FN_NR ; i++) { + prepare_fn = test->guest_prepare[i]; +if (prepare_fn && !prepare_fn ()) +return false; + } + +return true; +} + +static void guest_test_check (struct test_desc *test) +{ +void (*check_fn)(void ); +int i; + +for (i =0 ; i <CHECK_FN_NR ; i++) { + check_fn = test->guest_test_check[i]; +if (check_fn) +check_fn (); + } +} + +static void guest_code (struct test_desc *test) +{ +if (!guest_prepare (test)) +GUEST_SYNC (CMD_SKIP_TEST ); + +GUEST_SYNC (test->mem_mark_cmd); + +if (test->guest_test) + test->guest_test (); + +guest_test_check (test); +GUEST_DONE (); +} + +static void no_dabt_handler (struct ex_regs *regs) +{ +GUEST_ASSERT_1 (false,read_sysreg (far_el1)); +} + +static void no_iabt_handler (struct ex_regs *regs) +{ +GUEST_ASSERT_1 (false, regs->pc); +} + +/* Returns true to continue the test, and false if it should be skipped. */ +static bool punch_hole_in_memslot (struct kvm_vm *vm, +struct userspace_mem_region *region) +{ +void *hva = (void *)region->region.userspace_addr; +uint64_t paging_size = region->region.memory_size; +int ret, fd = region->fd; + +if (fd !=-1 ) { + ret =fallocate (fd,FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , +0 , paging_size); +TEST_ASSERT (ret ==0 ,"fallocate failed, errno: %d\n" , errno); + }else { +if (is_backing_src_hugetlb (region->backing_src_type)) +return false; + + ret =madvise (hva, paging_size,MADV_DONTNEED ); +TEST_ASSERT (ret ==0 ,"madvise failed, errno: %d\n" , errno); + } + +return true; +} + +/* Returns true to continue the test, and false if it should be skipped. */ +static bool handle_cmd (struct kvm_vm *vm,int cmd) +{ +struct userspace_mem_region *data_region, *pt_region; +bool continue_test = true; + + data_region =vm_get_mem_region (vm,MEM_REGION_DATA ); + pt_region =vm_get_mem_region (vm,MEM_REGION_PT ); + +if (cmd ==CMD_SKIP_TEST ) + continue_test = false; + +if (cmd &CMD_HOLE_PT ) + continue_test =punch_hole_in_memslot (vm, pt_region); +if (cmd &CMD_HOLE_DATA ) + continue_test =punch_hole_in_memslot (vm, data_region); + +return continue_test; +} + +typedef uint32_t aarch64_insn_t ; +extern aarch64_insn_t __exec_test[2 ]; + +void noinline __return_0x77(void) +{ + asmvolatile ("__exec_test: mov x0, #0x77\n" +"ret\n" ); +} + +/* +* Note that this function runs on the host before the test VM starts: there's +* no need to sync the D$ and I$ caches. +*/ +static void load_exec_code_for_test (struct kvm_vm *vm) +{ +uint64_t *code; +struct userspace_mem_region *region; +void *hva; + + region =vm_get_mem_region (vm,MEM_REGION_DATA ); + hva = (void *)region->region.userspace_addr; + +assert (TEST_EXEC_GVA >TEST_GVA ); + code = hva +TEST_EXEC_GVA -TEST_GVA ; +memcpy (code, __exec_test,sizeof (__exec_test)); +} + +static void setup_abort_handlers (struct kvm_vm *vm,struct kvm_vcpu *vcpu, +struct test_desc *test) +{ +vm_init_descriptor_tables (vm); +vcpu_init_descriptor_tables (vcpu); + +vm_install_sync_handler (vm,VECTOR_SYNC_CURRENT , +ESR_EC_DABT , no_dabt_handler); +vm_install_sync_handler (vm,VECTOR_SYNC_CURRENT , +ESR_EC_IABT , no_iabt_handler); +} + +static void setup_gva_maps (struct kvm_vm *vm) +{ +struct userspace_mem_region *region; +uint64_t pte_gpa; + + region =vm_get_mem_region (vm,MEM_REGION_DATA ); +/* Map TEST_GVA first. This will install a new PTE. */ +virt_pg_map (vm,TEST_GVA , region->region.guest_phys_addr); +/* Then map TEST_PTE_GVA to the above PTE. */ + pte_gpa =addr_hva2gpa (vm,virt_get_pte_hva (vm,TEST_GVA )); +virt_pg_map (vm,TEST_PTE_GVA , pte_gpa); +} + +unsigned long get_max_gfn (enum vm_guest_mode mode)
Quoted 9 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c line 367
Quoted 6 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +6
-0+{ +unsigned int pa_bits = vm_guest_mode_params[mode].pa_bits; +unsigned int page_shift = vm_guest_mode_params[mode].page_shift; + +return ((1ULL << pa_bits) >> page_shift) -1 ; +}The above function should be deleted.
Ack. Removing in v8.
Quoted 210 lines
Quoted 210 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +210
-0+ +enum pf_test_memslots { +CODE_MEMSLOT , +PAGE_TABLE_MEMSLOT , +DATA_MEMSLOT , +}; + +/* Create a code memslot at pfn=0, and data and PT ones at max_gfn. */ +static void setup_memslots (struct kvm_vm *vm,struct test_params *p) +{ +uint64_t backing_src_pagesz =get_backing_src_pagesz (p->src_type); +uint64_t guest_page_size = vm->page_size; +uint64_t max_gfn =vm_compute_max_gfn (vm); +/* Enough for 2M of code when using 4K guest pages. */ +uint64_t code_npages =512 ; +uint64_t pt_size, data_size, data_gpa; + +/* +* This test requires 1 pgd, 2 pud, 4 pmd, and 6 pte pages when using +* VM_MODE_P48V48_4K. Note that the .text takes ~1.6MBs. That's 13 +* pages. VM_MODE_P48V48_4K is the mode with most PT pages; let's use +* twice that just in case. +*/ + pt_size =26 * guest_page_size; + +/* memslot sizes and gpa's must be aligned to the backing page size */ + pt_size =align_up (pt_size, backing_src_pagesz); + data_size =align_up (guest_page_size, backing_src_pagesz); + data_gpa = (max_gfn * guest_page_size) - data_size; + data_gpa =align_down (data_gpa, backing_src_pagesz); + +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS ,0 ,CODE_MEMSLOT , + code_npages,0 ); + vm->memslots[MEM_REGION_CODE ] =CODE_MEMSLOT ; + +vm_userspace_mem_region_add (vm, p->src_type, data_gpa - pt_size, +PAGE_TABLE_MEMSLOT , pt_size / guest_page_size, + p->test_desc->pt_memslot_flags); + vm->memslots[MEM_REGION_PT ] =PAGE_TABLE_MEMSLOT ; + +vm_userspace_mem_region_add (vm, p->src_type, data_gpa,DATA_MEMSLOT , + data_size / guest_page_size, + p->test_desc->data_memslot_flags); + vm->memslots[MEM_REGION_DATA ] =DATA_MEMSLOT ; +} + +static void print_test_banner (enum vm_guest_mode mode,struct test_params *p) +{ +struct test_desc *test = p->test_desc; + +pr_debug ("Test: %s\n" , test->name); +pr_debug ("Testing guest mode: %s\n" ,vm_guest_mode_string (mode)); +pr_debug ("Testing memory backing src type: %s\n" , +vm_mem_backing_src_alias (p->src_type)->name); +} + +/* +* This function either succeeds, skips the test (after setting test->skip), or +* fails with a TEST_FAIL that aborts all tests. +*/ +static void vcpu_run_loop (struct kvm_vm *vm,struct kvm_vcpu *vcpu, +struct test_desc *test) +{ +struct ucall uc; + +for (;;) { +vcpu_run (vcpu); + +switch (get_ucall (vcpu, &uc)) { +case UCALL_SYNC : +if (!handle_cmd (vm, uc.args[1 ])) { + test->skip = true; + goto done; + } +break ; +case UCALL_ABORT : +REPORT_GUEST_ASSERT_2 (uc,"values: %#lx, %#lx" ); +break ; +case UCALL_DONE : + goto done; +default : +TEST_FAIL ("Unknown ucall %lu" , uc.cmd); + } + } + +done: +pr_debug (test->skip ?"Skipped.\n" :"Done.\n" ); +return ; +} + +static void run_test (enum vm_guest_mode mode,void *arg) +{ +struct test_params *p = (struct test_params *)arg; +struct test_desc *test = p->test_desc; +struct kvm_vm *vm; +struct kvm_vcpu *vcpu; + +print_test_banner (mode, p); + + vm =____vm_create (mode); +setup_memslots (vm, p); +kvm_vm_elf_load (vm, program_invocation_name); + vcpu =vm_vcpu_add (vm,0 , guest_code); + +setup_gva_maps (vm); + +ucall_init (vm,NULL ); + +load_exec_code_for_test (vm); +setup_abort_handlers (vm, vcpu, test); +vcpu_args_set (vcpu,1 , test); + +vcpu_run_loop (vm, vcpu, test); + +ucall_uninit (vm); +kvm_vm_free (vm); +} + +static void help (char *name) +{ +puts ("" ); +printf ("usage: %s [-h] [-s mem-type]\n" , name); +puts ("" ); +guest_modes_help (); +backing_src_help ("-s" ); +puts ("" ); +} + +#define SNAME (s) #s +#define SCAT2 (a, b) SNAME(a ## _ ## b) +#define SCAT3 (a, b, c) SCAT2(a, SCAT2(b, c)) + +#define _CHECK (_test) _CHECK_##_test +#define _PREPARE (_test) _PREPARE_##_test +#define _PREPARE_guest_read64 NULL +#define _PREPARE_guest_ld_preidx NULL +#define _PREPARE_guest_write64 NULL +#define _PREPARE_guest_st_preidx NULL +#define _PREPARE_guest_exec NULL +#define _PREPARE_guest_at NULL +#define _PREPARE_guest_dc_zva guest_check_dc_zva +#define _PREPARE_guest_cas guest_check_lse + +/* With or without access flag checks */ +#define _PREPARE_with_af guest_set_ha, guest_clear_pte_af +#define _PREPARE_no_af NULL +#define _CHECK_with_af guest_check_pte_af +#define _CHECK_no_af NULL + +/* Performs an access and checks that no faults were triggered. */ +#define TEST_ACCESS (_access, _with_af, _mark_cmd) \ +{ \ + .name = SCAT3(_access, _with_af, #_mark_cmd), \ + .guest_prepare = { _PREPARE(_with_af), \ + _PREPARE(_access) }, \ + .mem_mark_cmd = _mark_cmd, \ + .guest_test = _access, \ + .guest_test_check = { _CHECK(_with_af) }, \ +} + +static struct test_desc tests[] = { + +/* Check that HW is setting the Access Flag (AF) (sanity checks). */ +TEST_ACCESS (guest_read64, with_af,CMD_NONE ), +TEST_ACCESS (guest_ld_preidx, with_af,CMD_NONE ), +TEST_ACCESS (guest_cas, with_af,CMD_NONE ), +TEST_ACCESS (guest_write64, with_af,CMD_NONE ), +TEST_ACCESS (guest_st_preidx, with_af,CMD_NONE ), +TEST_ACCESS (guest_dc_zva, with_af,CMD_NONE ), +TEST_ACCESS (guest_exec, with_af,CMD_NONE ), + +/* +* Accessing a hole in the data memslot (punched with fallocate or +* madvise) shouldn't fault (more sanity checks). +*/ +TEST_ACCESS (guest_read64, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_cas, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_ld_preidx, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_write64, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_st_preidx, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_at, no_af,CMD_HOLE_DATA ), +TEST_ACCESS (guest_dc_zva, no_af,CMD_HOLE_DATA ), + + {0 } +}; + +static void for_each_test_and_guest_mode ( +void (*func)(enum vm_guest_mode m,void *a), +enum vm_mem_backing_src_type src_type) +{ +struct test_desc *t; + +for (t = &tests[0 ]; t->name; t++) { +if (t->skip) +continue ; + +struct test_params p = { + .src_type = src_type, + .test_desc = t, + }; + +for_each_guest_mode (run_test, &p); + } +} + +int main (int argc,char *argv[]) +{ +enum vm_mem_backing_src_type src_type; +int opt; +
Quoted 9 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c line 582
Quoted 5 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +5
-0+setbuf (stdout,NULL ); + + src_type =DEFAULT_VM_MEM_SRC ; + +guest_modes_append_default ();This guest mode append call is redundant with the one already done in the constructor function, so it isn't necessary for aarch64-only tests.
Good point, will remove it in v8.
Quoted 43 lines
Quoted 43 lines
tools/testing/selftests/kvm/aarch64/page_fault_test.c new file +19
-0+ +while ((opt =getopt (argc, argv,"hm:s:" )) !=-1 ) { +switch (opt) { +case 'm' : +guest_modes_cmdline (optarg); +break ; +case 's' : + src_type =parse_backing_src_type (optarg); +break ; +case 'h' : +default : +help (argv[0 ]); +exit (0 ); + } + } + +for_each_test_and_guest_mode (run_test, src_type); +return 0 ; +}tools/testing/selftests/kvm/include/aarch64/processor.h +8
-0@@ -105,11 +105,19 @@ enum {#define ESR_EC_MASK (ESR_EC_NUM - 1)#define ESR_EC_SVC64 0x15 +#define ESR_EC_IABT 0x21 +#define ESR_EC_DABT 0x25#define ESR_EC_HW_BP_CURRENT 0x31#define ESR_EC_SSTEP_CURRENT 0x33#define ESR_EC_WP_CURRENT 0x35#define ESR_EC_BRK_INS 0x3c +/* Access flag */ +#define PTE_AF (1ULL << 10) + +/* Access flag update enable/disable */ +#define TCR_EL1_HA (1ULL << 39) +void aarch64_get_supported_page_sizes (uint32_t ipa,bool *ps4k,bool *ps16k,bool *ps64k);
Quoted 6 lines
Quoted 3 lines
Signature · 1 line
2.37.3.968.ga6b4b080e4-googThanks,
drew
Thanks,
Ricardo
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 10/13 KVM: selftests: aarch64: Add userfaultfd tests into page_fault_test
In reply to Ricardo KollerAdd some userfaultfd tests into page_fault_test. Punch holes into the data and/or page-table memslots, perform some accesses, and check that the faults are taken (or not taken) when expected.
--- .../selftests/kvm/aarch64/page_fault_test.c | 190 +++++++++++++++++- 1 file changed, 188 insertions(+), 2 deletions(-)
tools/testing/selftests/kvm/aarch64/page_fault_test.c +188 -2
@@ -35,6 +35,12 @@ static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA;#define PREPARE_FN_NR 10#define CHECK_FN_NR 10 +static struct event_cnt { +int uffd_faults; +/* uffd_faults is incremented from multiple threads. */ +pthread_mutex_t uffd_faults_mutex; +} events; +struct test_desc {const char *name;uint64_t mem_mark_cmd;
@@ -42,11 +48,14 @@ struct test_desc {bool (*guest_prepare[PREPARE_FN_NR ])(void );void (*guest_test)(void );void (*guest_test_check[CHECK_FN_NR ])(void ); +uffd_handler_t uffd_pt_handler; +uffd_handler_t uffd_data_handler;void (*dabt_handler)(struct ex_regs *regs);void (*iabt_handler)(struct ex_regs *regs);uint32_t pt_memslot_flags;uint32_t data_memslot_flags;bool skip; +struct event_cnt expected_events; };struct test_params {
@@ -263,7 +272,110 @@ static void no_iabt_handler(struct ex_regs *regs)GUEST_ASSERT_1 (false, regs->pc); } +static struct uffd_args { +char *copy; +void *hva; +uint64_t paging_size; +} pt_args, data_args; +/* Returns true to continue the test, and false if it should be skipped. */ +static int uffd_generic_handler (int uffd_mode,int uffd, +struct uffd_msg *msg,struct uffd_args *args, +bool expect_write) +{ +uint64_t addr = msg->arg.pagefault.address; +uint64_t flags = msg->arg.pagefault.flags; +struct uffdio_copy copy; +int ret; + +TEST_ASSERT (uffd_mode ==UFFDIO_REGISTER_MODE_MISSING , +"The only expected UFFD mode is MISSING" ); +ASSERT_EQ (!!(flags &UFFD_PAGEFAULT_FLAG_WRITE ), expect_write); +ASSERT_EQ (addr, (uint64_t )args->hva); + +pr_debug ("uffd fault: addr=%p write=%d\n" , + (void *)addr, !!(flags &UFFD_PAGEFAULT_FLAG_WRITE )); + + copy.src = (uint64_t )args->copy; + copy.dst = addr; + copy.len = args->paging_size; + copy.mode =0 ; + + ret =ioctl (uffd,UFFDIO_COPY , ©); +if (ret ==-1 ) { +pr_info ("Failed UFFDIO_COPY in 0x%lx with errno: %d\n" , + addr, errno); +return ret; + } + +pthread_mutex_lock (&events.uffd_faults_mutex); + events.uffd_faults +=1 ; +pthread_mutex_unlock (&events.uffd_faults_mutex); +return 0 ; +} + +static int uffd_pt_write_handler (int mode,int uffd,struct uffd_msg *msg) +{ +return uffd_generic_handler (mode, uffd, msg, &pt_args, true); +} + +static int uffd_data_write_handler (int mode,int uffd,struct uffd_msg *msg) +{ +return uffd_generic_handler (mode, uffd, msg, &data_args, true); +} + +static int uffd_data_read_handler (int mode,int uffd,struct uffd_msg *msg) +{ +return uffd_generic_handler (mode, uffd, msg, &data_args, false); +} + +static void setup_uffd_args (struct userspace_mem_region *region, +struct uffd_args *args) +{ + args->hva = (void *)region->region.userspace_addr; + args->paging_size = region->region.memory_size; + + args->copy =malloc (args->paging_size); +TEST_ASSERT (args->copy,"Failed to allocate data copy." ); +memcpy (args->copy, args->hva, args->paging_size); +} + +static void setup_uffd (struct kvm_vm *vm,struct test_params *p, +struct uffd_desc **pt_uffd,struct uffd_desc **data_uffd) +{ +struct test_desc *test = p->test_desc; + +setup_uffd_args (vm_get_mem_region (vm,MEM_REGION_PT ), &pt_args); +setup_uffd_args (vm_get_mem_region (vm,MEM_REGION_DATA ), &data_args); + + *pt_uffd =NULL ; +if (test->uffd_pt_handler) + *pt_uffd =uffd_setup_demand_paging ( +UFFDIO_REGISTER_MODE_MISSING ,0 , + pt_args.hva, pt_args.paging_size, + test->uffd_pt_handler); + + *data_uffd =NULL ; +if (test->uffd_data_handler) + *data_uffd =uffd_setup_demand_paging ( +UFFDIO_REGISTER_MODE_MISSING ,0 , + data_args.hva, data_args.paging_size, + test->uffd_data_handler); +} + +static void free_uffd (struct test_desc *test,struct uffd_desc *pt_uffd, +struct uffd_desc *data_uffd) +{ +if (test->uffd_pt_handler) +uffd_stop_demand_paging (pt_uffd); +if (test->uffd_data_handler) +uffd_stop_demand_paging (data_uffd); + +free (pt_args.copy); +free (data_args.copy); +} + +/* Returns false if the test should be skipped. */ static bool punch_hole_in_memslot (struct kvm_vm *vm,struct userspace_mem_region *region) {
@@ -411,6 +523,11 @@ static void setup_memslots(struct kvm_vm *vm, struct test_params *p) vm->memslots[MEM_REGION_DATA ] =DATA_MEMSLOT ; } +static void check_event_counts (struct test_desc *test) +{ +ASSERT_EQ (test->expected_events.uffd_faults, events.uffd_faults); +} +static void print_test_banner (enum vm_guest_mode mode,struct test_params *p) {struct test_desc *test = p->test_desc;
@@ -421,12 +538,17 @@ static void print_test_banner(enum vm_guest_mode mode, struct test_params *p) vm_mem_backing_src_alias(p->src_type)->name); } +static void reset_event_counts (void ) +{ +memset (&events,0 ,sizeof (events)); +} +/* * This function either succeeds, skips the test (after setting test->skip), or * fails with a TEST_FAIL that aborts all tests. */ static void vcpu_run_loop (struct kvm_vm *vm,struct kvm_vcpu *vcpu, -struct test_desc *test) +struct test_desc *test) {struct ucall uc;
@@ -461,6 +583,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)struct test_desc *test = p->test_desc;struct kvm_vm *vm;struct kvm_vcpu *vcpu; +struct uffd_desc *pt_uffd, *data_uffd;print_test_banner (mode, p);
@@ -473,7 +596,16 @@ static void run_test(enum vm_guest_mode mode, void *arg)ucall_init (vm,NULL ); +reset_event_counts (); + +/* +* Set some code in the data memslot for the guest to execute (only +* applicable to the EXEC tests). This has to be done before +* setup_uffd() as that function copies the memslot data for the uffd +* handler. +*/ load_exec_code_for_test (vm); +setup_uffd (vm, p, &pt_uffd, &data_uffd);setup_abort_handlers (vm, vcpu, test);vcpu_args_set (vcpu,1 , test);
@@ -481,6 +613,14 @@ static void run_test(enum vm_guest_mode mode, void *arg)ucall_uninit (vm);kvm_vm_free (vm); +free_uffd (test, pt_uffd, data_uffd); + +/* +* Make sure we check the events after the uffd threads have exited, +* which means they updated their respective event counters. +*/ +if (!test->skip) +check_event_counts (test); }static void help (char *name)
@@ -496,6 +636,7 @@ static void help(char *name)#define SNAME (s) #s#define SCAT2 (a, b) SNAME(a ## _ ## b)#define SCAT3 (a, b, c) SCAT2(a, SCAT2(b, c)) +#define SCAT4 (a, b, c, d) SCAT2(a, SCAT3(b, c, d))#define _CHECK (_test) _CHECK_##_test#define _PREPARE (_test) _PREPARE_##_test
@@ -514,7 +655,7 @@ static void help(char *name)#define _CHECK_with_af guest_check_pte_af#define _CHECK_no_af NULL -/* Performs an access and checks that no faults were triggered. */ +/* Performs an access and checks that no faults (no events) were triggered. */ #define TEST_ACCESS (_access, _with_af, _mark_cmd) \ { \ .name = SCAT3(_access, _with_af, #_mark_cmd), \
@@ -523,6 +664,21 @@ static void help(char *name) .mem_mark_cmd = _mark_cmd, \ .guest_test = _access, \ .guest_test_check = { _CHECK(_with_af) }, \ + .expected_events = { 0 }, \ +} + +#define TEST_UFFD (_access, _with_af, _mark_cmd, \ + _uffd_data_handler, _uffd_pt_handler, _uffd_faults) \ +{ \ + .name = SCAT4(uffd, _access, _with_af, #_mark_cmd), \ + .guest_prepare = { _PREPARE(_with_af), \ + _PREPARE(_access) }, \ + .guest_test = _access, \ + .mem_mark_cmd = _mark_cmd, \ + .guest_test_check = { _CHECK(_with_af) }, \ + .uffd_data_handler = _uffd_data_handler, \ + .uffd_pt_handler = _uffd_pt_handler, \ + .expected_events = { .uffd_faults = _uffd_faults, }, \ } static struct test_desc tests[] = {
@@ -548,6 +704,36 @@ static struct test_desc tests[] = {TEST_ACCESS (guest_at, no_af,CMD_HOLE_DATA ),TEST_ACCESS (guest_dc_zva, no_af,CMD_HOLE_DATA ), +/* +* Punch holes in the test and PT memslots and mark them for +* userfaultfd handling. This should result in 2 faults: the test +* access and its respective S1 page table walk (S1PTW). +*/ +TEST_UFFD (guest_read64, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,2 ), +/* no_af should also lead to a PT write. */ +TEST_UFFD (guest_read64, no_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,2 ), +/* Note how that cas invokes the read handler. */ +TEST_UFFD (guest_cas, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,2 ), +/* +* Can't test guest_at with_af as it's IMPDEF whether the AF is set. +* The S1PTW fault should still be marked as a write. +*/ +TEST_UFFD (guest_at, no_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,1 ), +TEST_UFFD (guest_ld_preidx, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,2 ), +TEST_UFFD (guest_write64, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_write_handler, uffd_pt_write_handler,2 ), +TEST_UFFD (guest_dc_zva, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_write_handler, uffd_pt_write_handler,2 ), +TEST_UFFD (guest_st_preidx, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_write_handler, uffd_pt_write_handler,2 ), +TEST_UFFD (guest_exec, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , + uffd_data_read_handler, uffd_pt_write_handler,2 ), + { 0 } };
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 11/13 KVM: selftests: aarch64: Add dirty logging tests into page_fault_test
In reply to Ricardo KollerAdd some dirty logging tests into page_fault_test. Mark the data and/or page-table memslots for dirty logging, perform some accesses, and check that the dirty log bits are set or clean when expected.
--- .../selftests/kvm/aarch64/page_fault_test.c | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+)
tools/testing/selftests/kvm/aarch64/page_fault_test.c +75 -0
@@ -31,6 +31,11 @@ static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA;#define CMD_SKIP_TEST (1ULL << 1)#define CMD_HOLE_PT (1ULL << 2)#define CMD_HOLE_DATA (1ULL << 3) +#define CMD_CHECK_WRITE_IN_DIRTY_LOG (1ULL << 4) +#define CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG (1ULL << 5) +#define CMD_CHECK_NO_WRITE_IN_DIRTY_LOG (1ULL << 6) +#define CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG (1ULL << 7) +#define CMD_SET_PTE_AF (1ULL << 8)#define PREPARE_FN_NR 10#define CHECK_FN_NR 10
@@ -213,6 +218,21 @@ static void guest_check_pte_af(void)GUEST_ASSERT_EQ (*((uint64_t *)TEST_PTE_GVA ) &PTE_AF ,PTE_AF ); } +static void guest_check_write_in_dirty_log (void ) +{ +GUEST_SYNC (CMD_CHECK_WRITE_IN_DIRTY_LOG ); +} + +static void guest_check_no_write_in_dirty_log (void ) +{ +GUEST_SYNC (CMD_CHECK_NO_WRITE_IN_DIRTY_LOG ); +} + +static void guest_check_s1ptw_wr_in_dirty_log (void ) +{ +GUEST_SYNC (CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG ); +} +static void guest_exec (void ) {int (*code)(void ) = (int (*)(void ))TEST_EXEC_GVA ;
@@ -398,6 +418,21 @@ static bool punch_hole_in_memslot(struct kvm_vm *vm,return true; } +static bool check_write_in_dirty_log (struct kvm_vm *vm, +struct userspace_mem_region *region,uint64_t host_pg_nr) +{ +unsigned long *bmap; +bool first_page_dirty; +uint64_t size = region->region.memory_size; + +/* getpage_size() is not always equal to vm->page_size */ + bmap =bitmap_zalloc (size /getpagesize ()); +kvm_vm_get_dirty_log (vm, region->region.slot, bmap); + first_page_dirty =test_bit (host_pg_nr, bmap); +free (bmap); +return first_page_dirty; +} +/* Returns true to continue the test, and false if it should be skipped. */ static bool handle_cmd (struct kvm_vm *vm,int cmd) {
@@ -414,6 +449,18 @@ static bool handle_cmd(struct kvm_vm *vm, int cmd) continue_test =punch_hole_in_memslot (vm, pt_region);if (cmd &CMD_HOLE_DATA ) continue_test =punch_hole_in_memslot (vm, data_region); +if (cmd &CMD_CHECK_WRITE_IN_DIRTY_LOG ) +TEST_ASSERT (check_write_in_dirty_log (vm, data_region,0 ), +"Missing write in dirty log" ); +if (cmd &CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG ) +TEST_ASSERT (check_write_in_dirty_log (vm, pt_region,0 ), +"Missing s1ptw write in dirty log" ); +if (cmd &CMD_CHECK_NO_WRITE_IN_DIRTY_LOG ) +TEST_ASSERT (!check_write_in_dirty_log (vm, data_region,0 ), +"Unexpected write in dirty log" ); +if (cmd &CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG ) +TEST_ASSERT (!check_write_in_dirty_log (vm, pt_region,0 ), +"Unexpected s1ptw write in dirty log" );return continue_test; }
@@ -681,6 +728,19 @@ static void help(char *name) .expected_events = { .uffd_faults = _uffd_faults, }, \ } +#define TEST_DIRTY_LOG (_access, _with_af, _test_check) \ +{ \ + .name = SCAT3(dirty_log, _access, _with_af), \ + .data_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .guest_prepare = { _PREPARE(_with_af), \ + _PREPARE(_access) }, \ + .guest_test = _access, \ + .guest_test_check = { _CHECK(_with_af), _test_check, \ + guest_check_s1ptw_wr_in_dirty_log}, \ + .expected_events = { 0 }, \ +} +static struct test_desc tests[] = {/* Check that HW is setting the Access Flag (AF) (sanity checks). */
@@ -734,6 +794,21 @@ static struct test_desc tests[] = {TEST_UFFD (guest_exec, with_af,CMD_HOLE_DATA |CMD_HOLE_PT , uffd_data_read_handler, uffd_pt_write_handler,2 ), +/* +* Try accesses when the data and PT memslots are both tracked for +* dirty logging. +*/ +TEST_DIRTY_LOG (guest_read64, with_af, guest_check_no_write_in_dirty_log), +/* no_af should also lead to a PT write. */ +TEST_DIRTY_LOG (guest_read64, no_af, guest_check_no_write_in_dirty_log), +TEST_DIRTY_LOG (guest_ld_preidx, with_af, guest_check_no_write_in_dirty_log), +TEST_DIRTY_LOG (guest_at, no_af, guest_check_no_write_in_dirty_log), +TEST_DIRTY_LOG (guest_exec, with_af, guest_check_no_write_in_dirty_log), +TEST_DIRTY_LOG (guest_write64, with_af, guest_check_write_in_dirty_log), +TEST_DIRTY_LOG (guest_cas, with_af, guest_check_write_in_dirty_log), +TEST_DIRTY_LOG (guest_dc_zva, with_af, guest_check_write_in_dirty_log), +TEST_DIRTY_LOG (guest_st_preidx, with_af, guest_check_write_in_dirty_log), + { 0 } };
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 12/13 KVM: selftests: aarch64: Add readonly memslot tests into page_fault_test
In reply to Ricardo KollerAdd some readonly memslot tests into page_fault_test. Mark the data and/or page-table memslots as readonly, perform some accesses, and check that the right fault is triggered when expected (e.g., a store with no write-back should lead to an mmio exit).
--- .../selftests/kvm/aarch64/page_fault_test.c | 101 +++++++++++++++++- 1 file changed, 100 insertions(+), 1 deletion(-)
tools/testing/selftests/kvm/aarch64/page_fault_test.c +100 -1
@@ -41,6 +41,8 @@ static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA;#define CHECK_FN_NR 10 static struct event_cnt { + int mmio_exits; + int fail_vcpu_runs; int uffd_faults; /* uffd_faults is incremented from multiple threads. */ pthread_mutex_t uffd_faults_mutex;
@@ -57,6 +59,8 @@ struct test_desc {uffd_handler_t uffd_data_handler;void (*dabt_handler)(struct ex_regs *regs);void (*iabt_handler)(struct ex_regs *regs); +void (*mmio_handler)(struct kvm_vm *vm,struct kvm_run *run); +void (*fail_vcpu_run_handler)(int ret);uint32_t pt_memslot_flags;uint32_t data_memslot_flags;bool skip;
@@ -418,6 +422,31 @@ static bool punch_hole_in_memslot(struct kvm_vm *vm,return true; } +static void mmio_on_test_gpa_handler (struct kvm_vm *vm,struct kvm_run *run) +{ +struct userspace_mem_region *region; +void *hva; + + region =vm_get_mem_region (vm,MEM_REGION_DATA ); + hva = (void *)region->region.userspace_addr; + +ASSERT_EQ (run->mmio.phys_addr, region->region.guest_phys_addr); + +memcpy (hva, run->mmio.data, run->mmio.len); + events.mmio_exits +=1 ; +} + +static void mmio_no_handler (struct kvm_vm *vm,struct kvm_run *run) +{ +uint64_t data; + +memcpy (&data, run->mmio.data,sizeof (data)); +pr_debug ("addr=%lld len=%d w=%d data=%lx\n" , + run->mmio.phys_addr, run->mmio.len, + run->mmio.is_write, data); +TEST_FAIL ("There was no MMIO exit expected." ); +} +static bool check_write_in_dirty_log (struct kvm_vm *vm,struct userspace_mem_region *region,uint64_t host_pg_nr) {
@@ -465,6 +494,18 @@ static bool handle_cmd(struct kvm_vm *vm, int cmd)return continue_test; } +void fail_vcpu_run_no_handler (int ret) +{ +TEST_FAIL ("Unexpected vcpu run failure\n" ); +} + +void fail_vcpu_run_mmio_no_syndrome_handler (int ret) +{ +TEST_ASSERT (errno ==ENOSYS , +"The mmio handler should have returned not implemented." ); + events.fail_vcpu_runs +=1 ; +} +typedef uint32_t aarch64_insn_t ;extern aarch64_insn_t __exec_test[2 ];
@@ -570,9 +611,20 @@ static void setup_memslots(struct kvm_vm *vm, struct test_params *p) vm->memslots[MEM_REGION_DATA ] =DATA_MEMSLOT ; } +static void setup_default_handlers (struct test_desc *test) +{ +if (!test->mmio_handler) + test->mmio_handler = mmio_no_handler; + +if (!test->fail_vcpu_run_handler) + test->fail_vcpu_run_handler = fail_vcpu_run_no_handler; +} +static void check_event_counts (struct test_desc *test) {ASSERT_EQ (test->expected_events.uffd_faults, events.uffd_faults); +ASSERT_EQ (test->expected_events.mmio_exits, events.mmio_exits); +ASSERT_EQ (test->expected_events.fail_vcpu_runs, events.fail_vcpu_runs); }static void print_test_banner (enum vm_guest_mode mode,struct test_params *p)
@@ -597,10 +649,18 @@ static void reset_event_counts(void)static void vcpu_run_loop (struct kvm_vm *vm,struct kvm_vcpu *vcpu,struct test_desc *test) { +struct kvm_run *run;struct ucall uc; +int ret; + + run = vcpu->run;for (;;) { -vcpu_run (vcpu); + ret =_vcpu_run (vcpu); +if (ret) { + test->fail_vcpu_run_handler (ret); + goto done; + }switch (get_ucall (vcpu, &uc)) {case UCALL_SYNC :
@@ -614,6 +674,10 @@ static void vcpu_run_loop(struct kvm_vm *vm, struct kvm_vcpu *vcpu,break ;case UCALL_DONE : goto done; +case UCALL_NONE : +if (run->exit_reason ==KVM_EXIT_MMIO ) + test->mmio_handler (vm, run); +break ;default :TEST_FAIL ("Unknown ucall %lu" , uc.cmd); }
@@ -654,6 +718,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)load_exec_code_for_test (vm);setup_uffd (vm, p, &pt_uffd, &data_uffd);setup_abort_handlers (vm, vcpu, test); +setup_default_handlers (test);vcpu_args_set (vcpu,1 , test);vcpu_run_loop (vm, vcpu, test);
@@ -741,6 +806,25 @@ static void help(char *name) .expected_events = { 0 }, \ } +#define TEST_RO_MEMSLOT (_access, _mmio_handler, _mmio_exits) \ +{ \ + .name = SCAT3(ro_memslot, _access, _with_af), \ + .data_memslot_flags = KVM_MEM_READONLY, \ + .guest_prepare = { _PREPARE(_access) }, \ + .guest_test = _access, \ + .mmio_handler = _mmio_handler, \ + .expected_events = { .mmio_exits = _mmio_exits }, \ +} + +#define TEST_RO_MEMSLOT_NO_SYNDROME (_access) \ +{ \ + .name = SCAT2(ro_memslot_no_syndrome, _access), \ + .data_memslot_flags = KVM_MEM_READONLY, \ + .guest_test = _access, \ + .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ + .expected_events = { .fail_vcpu_runs = 1 }, \ +} +static struct test_desc tests[] = {/* Check that HW is setting the Access Flag (AF) (sanity checks). */
@@ -809,6 +893,21 @@ static struct test_desc tests[] = {TEST_DIRTY_LOG (guest_dc_zva, with_af, guest_check_write_in_dirty_log),TEST_DIRTY_LOG (guest_st_preidx, with_af, guest_check_write_in_dirty_log), +/* +* Try accesses when the data memslot is marked read-only (with +* KVM_MEM_READONLY). Writes with a syndrome result in an MMIO exit, +* writes with no syndrome (e.g., CAS) result in a failed vcpu run, and +* reads/execs with and without syndroms do not fault. +*/ +TEST_RO_MEMSLOT (guest_read64,0 ,0 ), +TEST_RO_MEMSLOT (guest_ld_preidx,0 ,0 ), +TEST_RO_MEMSLOT (guest_at,0 ,0 ), +TEST_RO_MEMSLOT (guest_exec,0 ,0 ), +TEST_RO_MEMSLOT (guest_write64, mmio_on_test_gpa_handler,1 ), +TEST_RO_MEMSLOT_NO_SYNDROME (guest_dc_zva), +TEST_RO_MEMSLOT_NO_SYNDROME (guest_cas), +TEST_RO_MEMSLOT_NO_SYNDROME (guest_st_preidx), + { 0 } };
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v7 13/13 KVM: selftests: aarch64: Add mix of tests into page_fault_test
In reply to Ricardo KollerAdd some mix of tests into page_fault_test: memslots with all the pairwise combinations of read-only, userfaultfd, and dirty-logging. For example, writing into a read-only memslot which has a hole handled with userfaultfd.
--- .../selftests/kvm/aarch64/page_fault_test.c | 155 ++++++++++++++++++ 1 file changed, 155 insertions(+)
tools/testing/selftests/kvm/aarch64/page_fault_test.c +155 -0
@@ -399,6 +399,12 @@ static void free_uffd(struct test_desc *test, struct uffd_desc *pt_uffd,free (data_args.copy); } +static int uffd_no_handler (int mode,int uffd,struct uffd_msg *msg) +{ +TEST_FAIL ("There was no UFFD fault expected." ); +return -1 ; +} +/* Returns false if the test should be skipped. */ static bool punch_hole_in_memslot (struct kvm_vm *vm,struct userspace_mem_region *region)
@@ -806,6 +812,22 @@ static void help(char *name) .expected_events = { 0 }, \ } +#define TEST_UFFD_AND_DIRTY_LOG (_access, _with_af, _uffd_data_handler, \ + _uffd_faults, _test_check) \ +{ \ + .name = SCAT3(uffd_and_dirty_log, _access, _with_af), \ + .data_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .guest_prepare = { _PREPARE(_with_af), \ + _PREPARE(_access) }, \ + .guest_test = _access, \ + .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ + .guest_test_check = { _CHECK(_with_af), _test_check }, \ + .uffd_data_handler = _uffd_data_handler, \ + .uffd_pt_handler = uffd_pt_write_handler, \ + .expected_events = { .uffd_faults = _uffd_faults, }, \ +} +#define TEST_RO_MEMSLOT (_access, _mmio_handler, _mmio_exits) \ { \ .name = SCAT3(ro_memslot, _access, _with_af), \
@@ -825,6 +847,59 @@ static void help(char *name) .expected_events = { .fail_vcpu_runs = 1 }, \ } +#define TEST_RO_MEMSLOT_AND_DIRTY_LOG (_access, _mmio_handler, _mmio_exits, \ + _test_check) \ +{ \ + .name = SCAT3(ro_memslot, _access, _with_af), \ + .data_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ + .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .guest_prepare = { _PREPARE(_access) }, \ + .guest_test = _access, \ + .guest_test_check = { _test_check }, \ + .mmio_handler = _mmio_handler, \ + .expected_events = { .mmio_exits = _mmio_exits}, \ +} + +#define TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG (_access, _test_check) \ +{ \ + .name = SCAT2(ro_memslot_no_syn_and_dlog, _access), \ + .data_memslot_flags = KVM_MEM_READONLY | KVM_MEM_LOG_DIRTY_PAGES, \ + .pt_memslot_flags = KVM_MEM_LOG_DIRTY_PAGES, \ + .guest_test = _access, \ + .guest_test_check = { _test_check }, \ + .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ + .expected_events = { .fail_vcpu_runs = 1 }, \ +} + +#define TEST_RO_MEMSLOT_AND_UFFD (_access, _mmio_handler, _mmio_exits, \ + _uffd_data_handler, _uffd_faults) \ +{ \ + .name = SCAT2(ro_memslot_uffd, _access), \ + .data_memslot_flags = KVM_MEM_READONLY, \ + .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ + .guest_prepare = { _PREPARE(_access) }, \ + .guest_test = _access, \ + .uffd_data_handler = _uffd_data_handler, \ + .uffd_pt_handler = uffd_pt_write_handler, \ + .mmio_handler = _mmio_handler, \ + .expected_events = { .mmio_exits = _mmio_exits, \ + .uffd_faults = _uffd_faults }, \ +} + +#define TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD (_access, _uffd_data_handler, \ + _uffd_faults) \ +{ \ + .name = SCAT2(ro_memslot_no_syndrome, _access), \ + .data_memslot_flags = KVM_MEM_READONLY, \ + .mem_mark_cmd = CMD_HOLE_DATA | CMD_HOLE_PT, \ + .guest_test = _access, \ + .uffd_data_handler = _uffd_data_handler, \ + .uffd_pt_handler = uffd_pt_write_handler, \ + .fail_vcpu_run_handler = fail_vcpu_run_mmio_no_syndrome_handler, \ + .expected_events = { .fail_vcpu_runs = 1, \ + .uffd_faults = _uffd_faults }, \ +} +static struct test_desc tests[] = {/* Check that HW is setting the Access Flag (AF) (sanity checks). */
@@ -893,6 +968,35 @@ static struct test_desc tests[] = {TEST_DIRTY_LOG (guest_dc_zva, with_af, guest_check_write_in_dirty_log),TEST_DIRTY_LOG (guest_st_preidx, with_af, guest_check_write_in_dirty_log), +/* +* Access when the data and PT memslots are both marked for dirty +* logging and UFFD at the same time. The expected result is that +* writes should mark the dirty log and trigger a userfaultfd write +* fault. Reads/execs should result in a read userfaultfd fault, and +* nothing in the dirty log. Any S1PTW should result in a write in the +* dirty log and a userfaultfd write. +*/ +TEST_UFFD_AND_DIRTY_LOG (guest_read64, with_af, uffd_data_read_handler,2 , + guest_check_no_write_in_dirty_log), +/* no_af should also lead to a PT write. */ +TEST_UFFD_AND_DIRTY_LOG (guest_read64, no_af, uffd_data_read_handler,2 , + guest_check_no_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_ld_preidx, with_af, uffd_data_read_handler, +2 , guest_check_no_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_at, with_af,0 ,1 , + guest_check_no_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_exec, with_af, uffd_data_read_handler,2 , + guest_check_no_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_write64, with_af, uffd_data_write_handler, +2 , guest_check_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_cas, with_af, uffd_data_read_handler,2 , + guest_check_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_dc_zva, with_af, uffd_data_write_handler, +2 , guest_check_write_in_dirty_log), +TEST_UFFD_AND_DIRTY_LOG (guest_st_preidx, with_af, + uffd_data_write_handler,2 , + guest_check_write_in_dirty_log), +/* * Try accesses when the data memslot is marked read-only (with * KVM_MEM_READONLY). Writes with a syndrome result in an MMIO exit,
@@ -908,6 +1012,57 @@ static struct test_desc tests[] = {TEST_RO_MEMSLOT_NO_SYNDROME (guest_cas),TEST_RO_MEMSLOT_NO_SYNDROME (guest_st_preidx), +/* +* Access when both the data memslot is both read-only and marked for +* dirty logging at the same time. The expected result is that for +* writes there should be no write in the dirty log. The readonly +* handling is the same as if the memslot was not marked for dirty +* logging: writes with a syndrome result in an MMIO exit, and writes +* with no syndrome result in a failed vcpu run. +*/ +TEST_RO_MEMSLOT_AND_DIRTY_LOG (guest_read64,0 ,0 , + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_AND_DIRTY_LOG (guest_ld_preidx,0 ,0 , + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_AND_DIRTY_LOG (guest_at,0 ,0 , + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_AND_DIRTY_LOG (guest_exec,0 ,0 , + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_AND_DIRTY_LOG (guest_write64, mmio_on_test_gpa_handler, +1 , guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG (guest_dc_zva, + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG (guest_cas, + guest_check_no_write_in_dirty_log), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_DIRTY_LOG (guest_st_preidx, + guest_check_no_write_in_dirty_log), + +/* +* Access when the data memslot is both read-only and punched with +* holes tracked with userfaultfd. The expected result is the union of +* both userfaultfd and read-only behaviors. For example, write +* accesses result in a userfaultfd write fault and an MMIO exit. +* Writes with no syndrome result in a failed vcpu run and no +* userfaultfd write fault. Reads result in userfaultfd getting +* triggered. +*/ +TEST_RO_MEMSLOT_AND_UFFD (guest_read64,0 ,0 , + uffd_data_read_handler,2 ), +TEST_RO_MEMSLOT_AND_UFFD (guest_ld_preidx,0 ,0 , + uffd_data_read_handler,2 ), +TEST_RO_MEMSLOT_AND_UFFD (guest_at,0 ,0 , + uffd_no_handler,1 ), +TEST_RO_MEMSLOT_AND_UFFD (guest_exec,0 ,0 , + uffd_data_read_handler,2 ), +TEST_RO_MEMSLOT_AND_UFFD (guest_write64, mmio_on_test_gpa_handler,1 , + uffd_data_write_handler,2 ), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD (guest_cas, + uffd_data_read_handler,2 ), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD (guest_dc_zva, + uffd_no_handler,1 ), +TEST_RO_MEMSLOT_NO_SYNDROME_AND_UFFD (guest_st_preidx, + uffd_no_handler,1 ), + { 0 } };
Signature · 6 lines
2.37.3.968.ga6b4b080e4-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm