KVM: x86: Add a cap to disable NX hugepages on a VM
Subsystems (5)
v3 cover KVM: x86: Add a cap to disable NX hugepages on a VM
Given the high cost of NX hugepages in terms of TLB performance, it may be desirable to disable the mitigation on a per-VM basis. In the case of public cloud providers with many VMs on a single host, some VMs may be more trusted than others. In order to maximize performance on critical VMs, while still providing some protection to the host from iTLB Multihit, allow the mitigation to be selectively disabled.
Disabling NX hugepages on a VM is relatively straightforward, but I took this as an opportunity to add some NX hugepages test coverage and clean up selftests infrastructure a bit.
This series was tested with the new selftest and the rest of the KVM selftests on an Intel Haswell machine.
The following tests failed, but I do not believe that has anything to do with this series:
userspace_io_test
vmx_nested_tsc_scaling_test
vmx_preemption_timer_test
Changelog:v1->v2:
Dropped the complicated memslot refactor in favor of Ricardo Koller's patch with a similar effect.
Incorporated David Dunn's feedback and reviewed by tag: shortened waits to speed up test.v2->v3:
Incorporated a suggestion from David on how to build the NX huge pages test.
Fixed a build breakage identified by David.
Dropped the per-vm nx_huge_pages field in favor of simply checking the global + per-VM disable override.
Documented the new capability
Separated out the commit to test disabling NX huge pages Removed permission check when checking if the disable NX capability is supported.
Added test coverage for the permission check.
Ben Gardon (10):
KVM: selftests: Dump VM stats in binary stats test
KVM: selftests: Test reading a single stat
KVM: selftests: Add memslot parameter to elf_load
KVM: selftests: Improve error message in vm_phy_pages_alloc
KVM: selftests: Add NX huge pages test
KVM: x86/MMU: Factor out updating NX hugepages state for a VM
KVM: x86/MMU: Allow NX huge pages to be disabled on a per-vm basis
KVM: x86: Fix errant brace in KVM capability handling
KVM: x86/MMU: Require reboot permission to disable NX hugepages
selftests: KVM: Test disabling NX hugepages on a VM
Ricardo Koller (1):
KVM: selftests: Add vm_alloc_page_table_in_memslot library function
Documentation/virt/kvm/api.rst | 13 + arch/x86/include/asm/kvm_host.h | 2 + arch/x86/kvm/mmu.h | 10 +- arch/x86/kvm/mmu/mmu.c | 17 +- arch/x86/kvm/mmu/spte.c | 7 +- arch/x86/kvm/mmu/spte.h | 3 +- arch/x86/kvm/mmu/tdp_mmu.c | 3 +- arch/x86/kvm/x86.c | 17 +- include/uapi/linux/kvm.h | 1 + tools/testing/selftests/kvm/Makefile | 7 +- .../selftests/kvm/include/kvm_util_base.h | 10 + .../selftests/kvm/kvm_binary_stats_test.c | 6 + tools/testing/selftests/kvm/lib/elf.c | 13 +- tools/testing/selftests/kvm/lib/kvm_util.c | 230 +++++++++++++++++- .../kvm/lib/x86_64/nx_huge_pages_guest.S | 45 ++++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 178 ++++++++++++++ .../kvm/x86_64/nx_huge_pages_test.sh | 25 ++ 17 files changed, 561 insertions(+), 26 deletions(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S create mode 100644 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c create mode 100755 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh
Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 1/11 KVM: selftests: Add vm_alloc_page_table_in_memslot library function
From: Ricardo Koller <[email protected]>
Add a library function to allocate a page-table physical page in a particular memslot. The default behavior is to create new page-table pages in memslot 0.
--- tools/testing/selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/lib/kvm_util.c | 8 +++++++- 2 files changed, 8 insertions(+), 1 deletion(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +1 -0
@@ -311,6 +311,7 @@ vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,vm_paddr_t vm_phy_pages_alloc (struct kvm_vm *vm,size_t num,vm_paddr_t paddr_min,uint32_t memslot);vm_paddr_t vm_alloc_page_table (struct kvm_vm *vm); +vm_paddr_t vm_alloc_page_table_in_memslot (struct kvm_vm *vm,uint32_t pt_memslot);/* * Create a VM with reasonable defaults
tools/testing/selftests/kvm/lib/kvm_util.c +7 -1
@@ -2425,9 +2425,15 @@ vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,/* Arbitrary minimum physical address used for virtual translation tables. */ #define KVM_GUEST_PAGE_TABLE_MIN_PADDR 0x180000 +vm_paddr_t vm_alloc_page_table_in_memslot (struct kvm_vm *vm,uint32_t pt_memslot) +{ +return vm_phy_page_alloc (vm,KVM_GUEST_PAGE_TABLE_MIN_PADDR , + pt_memslot); +} +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_alloc_page_table_in_memslot (vm,0 ); }/*
Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 2/11 KVM: selftests: Dump VM stats in binary stats test
In reply to Ben GardonAdd kvm_util library functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend the kvm_util code and use it to make assertions in a test for NX hugepages.
--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 + tools/testing/selftests/kvm/lib/kvm_util.c | 143 ++++++++++++++++++ 3 files changed, 147 insertions(+)
tools/testing/selftests/kvm/include/kvm_util_base.h +1 -0
@@ -401,6 +401,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid); +void dump_vm_stats (struct kvm_vm *vm);uint32_t guest_get_vcpuid (void );
tools/testing/selftests/kvm/kvm_binary_stats_test.c +3 -0
@@ -174,6 +174,9 @@ static void vm_stats_test(struct kvm_vm *vm)stats_test (stats_fd);close (stats_fd);TEST_ASSERT (fcntl (stats_fd,F_GETFD ) ==-1 ,"Stats fd not freed" ); + +/* Dump VM stats */ +dump_vm_stats (vm); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)
tools/testing/selftests/kvm/lib/kvm_util.c +143 -0
146 lines not on this page · raw message
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
Quoted 192 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 + tools/testing/selftests/kvm/lib/kvm_util.c | 143 ++++++++++++++++++ 3 files changed, 147 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -401,6 +401,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid); +void dump_vm_stats (struct kvm_vm *vm);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -174,6 +174,9 @@ static void vm_stats_test(struct kvm_vm *vm)stats_test (stats_fd);close (stats_fd);TEST_ASSERT (fcntl (stats_fd,F_GETFD ) ==-1 ,"Stats fd not freed" ); + +/* Dump VM stats */ +dump_vm_stats (vm); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +143
-1@@ -2562,3 +2562,146 @@ int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid)return ioctl (vcpu->fd,KVM_GET_STATS_FD ,NULL ); } + +/* Caller is responsible for freeing the returned kvm_stats_header. */ +static struct kvm_stats_header *read_vm_stats_header (int stats_fd) +{ +struct kvm_stats_header *header; +ssize_t ret; + +/* Read kvm stats header */ + header =malloc (sizeof (*header)); +TEST_ASSERT (header,"Allocate memory for stats header" ); + + ret =read (stats_fd, header,sizeof (*header)); +TEST_ASSERT (ret ==sizeof (*header),"Read stats header" ); + +return header; +} + +static void dump_header (int stats_fd,struct kvm_stats_header *header) +{ +ssize_t ret; +char *id; + +printf ("flags: %u\n" , header->flags); +printf ("name size: %u\n" , header->name_size); +printf ("num_desc: %u\n" , header->num_desc); +printf ("id_offset: %u\n" , header->id_offset); +printf ("desc_offset: %u\n" , header->desc_offset); +printf ("data_offset: %u\n" , header->data_offset); + +/* Read kvm stats id string */ + id =malloc (header->name_size); +TEST_ASSERT (id,"Allocate memory for id string" ); + ret =pread (stats_fd, id, header->name_size, header->id_offset); +TEST_ASSERT (ret == header->name_size,"Read id string" ); + +printf ("id: %s\n" , id); + +free (id); +} + +static ssize_t stats_desc_size (struct kvm_stats_header *header) +{ +return sizeof (struct kvm_stats_desc ) + header->name_size; +} + +/* Caller is responsible for freeing the returned kvm_stats_desc. */ +static struct kvm_stats_desc *read_vm_stats_desc (int stats_fd, +struct kvm_stats_header *header) +{ +struct kvm_stats_desc *stats_desc; +size_t size_desc; +ssize_t ret; + + size_desc = header->num_desc *stats_desc_size (header); + +/* Allocate memory for stats descriptors */ + stats_desc =malloc (size_desc); +TEST_ASSERT (stats_desc,"Allocate memory for stats descriptors" ); + +/* Read kvm stats descriptors */ + ret =pread (stats_fd, stats_desc, size_desc, header->desc_offset); +TEST_ASSERT (ret == size_desc,"Read KVM stats descriptors" ); + +return stats_desc; +} + +/* Caller is responsible for freeing the memory *data. */ +static int read_stat_data (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc,uint64_t **data) +{ +u64 *stats_data; +ssize_t ret; + + stats_data =malloc (desc->size *sizeof (*stats_data)); + + ret =pread (stats_fd, stats_data, desc->size *sizeof (*stats_data), + header->data_offset + desc->offset); + +/* ret is in bytes. */ + ret = ret /sizeof (*stats_data); + +TEST_ASSERT (ret == desc->size, +"Read data of KVM stats: %s" , desc->name); + + *data = stats_data; + +return ret; +} + +static void dump_stat (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc) +{ +u64 *stats_data; +ssize_t ret; +int i; + +printf ("\tflags: %u\n" , desc->flags); +printf ("\texponent: %u\n" , desc->exponent); +printf ("\tsize: %u\n" , desc->size); +printf ("\toffset: %u\n" , desc->offset); +printf ("\tbucket_size: %u\n" , desc->bucket_size); +printf ("\tname: %s\n" , (char *)&desc->name); + + ret =read_stat_data (stats_fd, header, desc, &stats_data); + +printf ("\tdata: %lu" , *stats_data); +for (i =1 ; i < ret; i++) +printf (", %lu" , *(stats_data + i)); +printf ("\n\n" ); + +free (stats_data); +} + +void dump_vm_stats (struct kvm_vm *vm) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int i; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); +dump_header (stats_fd, header); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); +dump_stat (stats_fd, header, desc); + } + +free (stats_desc); +free (header); + +close (stats_fd); +} + --
Quoted 2 lines
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
In reply to Ben GardonQuoted 53 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 + tools/testing/selftests/kvm/lib/kvm_util.c | 143 ++++++++++++++++++ 3 files changed, 147 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -401,6 +401,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid); +void dump_vm_stats (struct kvm_vm *vm);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -174,6 +174,9 @@ static void vm_stats_test(struct kvm_vm *vm)stats_test (stats_fd);close (stats_fd);TEST_ASSERT (fcntl (stats_fd,F_GETFD ) ==-1 ,"Stats fd not freed" ); + +/* Dump VM stats */ +dump_vm_stats (vm); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +6
-0@@ -2562,3 +2562,146 @@ int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid)return ioctl (vcpu->fd,KVM_GET_STATS_FD ,NULL ); } + +/* Caller is responsible for freeing the returned kvm_stats_header. */ +static struct kvm_stats_header *read_vm_stats_header (int stats_fd) +{ +struct kvm_stats_header *header; +ssize_t ret;
tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2580
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+ +/* Read kvm stats header */ + header =malloc (sizeof (*header)); +TEST_ASSERT (header,"Allocate memory for stats header" ); + + ret =read (stats_fd, header,sizeof (*header)); +TEST_ASSERT (ret ==sizeof (*header),"Read stats header" ); + +return header; +}
It seems like this helper could be used in kvm_binary_stats_test.c to eliminate duplicate code.
Quoted 39 lines
tools/testing/selftests/kvm/lib/kvm_util.c +39
-0+ +static void dump_header (int stats_fd,struct kvm_stats_header *header) +{ +ssize_t ret; +char *id; + +printf ("flags: %u\n" , header->flags); +printf ("name size: %u\n" , header->name_size); +printf ("num_desc: %u\n" , header->num_desc); +printf ("id_offset: %u\n" , header->id_offset); +printf ("desc_offset: %u\n" , header->desc_offset); +printf ("data_offset: %u\n" , header->data_offset); + +/* Read kvm stats id string */ + id =malloc (header->name_size); +TEST_ASSERT (id,"Allocate memory for id string" ); + ret =pread (stats_fd, id, header->name_size, header->id_offset); +TEST_ASSERT (ret == header->name_size,"Read id string" ); + +printf ("id: %s\n" , id); + +free (id); +} + +static ssize_t stats_desc_size (struct kvm_stats_header *header) +{ +return sizeof (struct kvm_stats_desc ) + header->name_size; +} + +/* Caller is responsible for freeing the returned kvm_stats_desc. */ +static struct kvm_stats_desc *read_vm_stats_desc (int stats_fd, +struct kvm_stats_header *header) +{ +struct kvm_stats_desc *stats_desc; +size_t size_desc; +ssize_t ret; + + size_desc = header->num_desc *stats_desc_size (header); +
tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2629
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+/* Allocate memory for stats descriptors */ + stats_desc =malloc (size_desc); +TEST_ASSERT (stats_desc,"Allocate memory for stats descriptors" ); + +/* Read kvm stats descriptors */ + ret =pread (stats_fd, stats_desc, size_desc, header->desc_offset); +TEST_ASSERT (ret == size_desc,"Read KVM stats descriptors" ); + +return stats_desc; +}
Same with this helper.
Quoted 13 lines
tools/testing/selftests/kvm/lib/kvm_util.c +13
-0+ +/* Caller is responsible for freeing the memory *data. */ +static int read_stat_data (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc,uint64_t **data) +{ +u64 *stats_data; +ssize_t ret; + + stats_data =malloc (desc->size *sizeof (*stats_data)); + + ret =pread (stats_fd, stats_data, desc->size *sizeof (*stats_data), + header->data_offset + desc->offset); +
tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2652
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+/* ret is in bytes. */ + ret = ret /sizeof (*stats_data); + +TEST_ASSERT (ret == desc->size, +"Read data of KVM stats: %s" , desc->name); + + *data = stats_data; + +return ret; +}
Same with this helper.
Quoted 58 lines
tools/testing/selftests/kvm/lib/kvm_util.c +55
-0+ +static void dump_stat (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc) +{ +u64 *stats_data; +ssize_t ret; +int i; + +printf ("\tflags: %u\n" , desc->flags); +printf ("\texponent: %u\n" , desc->exponent); +printf ("\tsize: %u\n" , desc->size); +printf ("\toffset: %u\n" , desc->offset); +printf ("\tbucket_size: %u\n" , desc->bucket_size); +printf ("\tname: %s\n" , (char *)&desc->name); + + ret =read_stat_data (stats_fd, header, desc, &stats_data); + +printf ("\tdata: %lu" , *stats_data); +for (i =1 ; i < ret; i++) +printf (", %lu" , *(stats_data + i)); +printf ("\n\n" ); + +free (stats_data); +} + +void dump_vm_stats (struct kvm_vm *vm) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int i; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); +dump_header (stats_fd, header); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); +dump_stat (stats_fd, header, desc); + } + +free (stats_desc); +free (header); + +close (stats_fd); +} +Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
Quoted 60 lines · David Matlack
Quoted 58 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 + tools/testing/selftests/kvm/lib/kvm_util.c | 143 ++++++++++++++++++ 3 files changed, 147 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -401,6 +401,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid); +void dump_vm_stats (struct kvm_vm *vm);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -174,6 +174,9 @@ static void vm_stats_test(struct kvm_vm *vm)stats_test (stats_fd);close (stats_fd);TEST_ASSERT (fcntl (stats_fd,F_GETFD ) ==-1 ,"Stats fd not freed" ); + +/* Dump VM stats */ +dump_vm_stats (vm); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +11
-0@@ -2562,3 +2562,146 @@ int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid)return ioctl (vcpu->fd,KVM_GET_STATS_FD ,NULL ); } + +/* Caller is responsible for freeing the returned kvm_stats_header. */ +static struct kvm_stats_header *read_vm_stats_header (int stats_fd) +{ +struct kvm_stats_header *header; +ssize_t ret; + +/* Read kvm stats header */ + header =malloc (sizeof (*header)); +TEST_ASSERT (header,"Allocate memory for stats header" ); +
Quoted 8 lines
tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2580
Quoted 5 lines
tools/testing/selftests/kvm/lib/kvm_util.c +5
-0+ ret =read (stats_fd, header,sizeof (*header)); +TEST_ASSERT (ret ==sizeof (*header),"Read stats header" ); + +return header; +}It seems like this helper could be used in
kvm_binary_stats_test.cto eliminate duplicate code.
It could, but I think the duplicate code in that test has value in being verbose and well commented and having a bunch of checks to assert things the regular library function isn't interested in. I'd prefer to keep the duplication as-is.
Quoted 137 lines
Quoted 40 lines
tools/testing/selftests/kvm/lib/kvm_util.c +39
-0+ +static void dump_header (int stats_fd,struct kvm_stats_header *header) +{ +ssize_t ret; +char *id; + +printf ("flags: %u\n" , header->flags); +printf ("name size: %u\n" , header->name_size); +printf ("num_desc: %u\n" , header->num_desc); +printf ("id_offset: %u\n" , header->id_offset); +printf ("desc_offset: %u\n" , header->desc_offset); +printf ("data_offset: %u\n" , header->data_offset); + +/* Read kvm stats id string */ + id =malloc (header->name_size); +TEST_ASSERT (id,"Allocate memory for id string" ); + ret =pread (stats_fd, id, header->name_size, header->id_offset); +TEST_ASSERT (ret == header->name_size,"Read id string" ); + +printf ("id: %s\n" , id); + +free (id); +} + +static ssize_t stats_desc_size (struct kvm_stats_header *header) +{ +return sizeof (struct kvm_stats_desc ) + header->name_size; +} + +/* Caller is responsible for freeing the returned kvm_stats_desc. */ +static struct kvm_stats_desc *read_vm_stats_desc (int stats_fd, +struct kvm_stats_header *header) +{ +struct kvm_stats_desc *stats_desc; +size_t size_desc; +ssize_t ret; + + size_desc = header->num_desc *stats_desc_size (header); +tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2629
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+/* Allocate memory for stats descriptors */ + stats_desc =malloc (size_desc); +TEST_ASSERT (stats_desc,"Allocate memory for stats descriptors" ); + +/* Read kvm stats descriptors */ + ret =pread (stats_fd, stats_desc, size_desc, header->desc_offset); +TEST_ASSERT (ret == size_desc,"Read KVM stats descriptors" ); + +return stats_desc; +}Same with this helper.
Quoted 13 lines
tools/testing/selftests/kvm/lib/kvm_util.c +13
-0+ +/* Caller is responsible for freeing the memory *data. */ +static int read_stat_data (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc,uint64_t **data) +{ +u64 *stats_data; +ssize_t ret; + + stats_data =malloc (desc->size *sizeof (*stats_data)); + + ret =pread (stats_fd, stats_data, desc->size *sizeof (*stats_data), + header->data_offset + desc->offset); +tools/testing/selftests/kvm/lib/kvm_util.c int vcpu_get_stats_fd(struct kvm_vm *vm, uint32_t vcpuid) · line 2652
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+/* ret is in bytes. */ + ret = ret /sizeof (*stats_data); + +TEST_ASSERT (ret == desc->size, +"Read data of KVM stats: %s" , desc->name); + + *data = stats_data; + +return ret; +}Same with this helper.
Quoted 58 lines
tools/testing/selftests/kvm/lib/kvm_util.c +55
-1+ +static void dump_stat (int stats_fd,struct kvm_stats_header *header, +struct kvm_stats_desc *desc) +{ +u64 *stats_data; +ssize_t ret; +int i; + +printf ("\tflags: %u\n" , desc->flags); +printf ("\texponent: %u\n" , desc->exponent); +printf ("\tsize: %u\n" , desc->size); +printf ("\toffset: %u\n" , desc->offset); +printf ("\tbucket_size: %u\n" , desc->bucket_size); +printf ("\tname: %s\n" , (char *)&desc->name); + + ret =read_stat_data (stats_fd, header, desc, &stats_data); + +printf ("\tdata: %lu" , *stats_data); +for (i =1 ; i < ret; i++) +printf (", %lu" , *(stats_data + i)); +printf ("\n\n" ); + +free (stats_data); +} + +void dump_vm_stats (struct kvm_vm *vm) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int i; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); +dump_header (stats_fd, header); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); +dump_stat (stats_fd, header, desc); + } + +free (stats_desc); +free (header); + +close (stats_fd); +} + --2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerRe: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
In reply to Ben GardonQuoted 4 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.
Why? Spamming my console with info that has zero meaning to me and is useless when the test passes is not helpful. Even on failure, I don't see what the user is going to do with this information, all of the asserts are completly unrelated to the stats themselves.
Re: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
Quoted 11 lines · Sean Christopherson
Quoted 4 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.Why? Spamming my console with info that has zero meaning to me and is useless when the test passes is not helpful. Even on failure, I don't see what the user is going to do with this information, all of the asserts are completly unrelated to the stats themselves.
Debugging could be another reason, I suspect? I remember when I tried to use the interface, there is really no API that tells me "did I add this stat successfully and/or correctly?" I think having a general print so that developer/debugging folk could just 'grep mystat' to verify that would be helpful in the future.
Otherwise, they have to write code themselves to do the dirty print...
Sean Christopherson
maintainerRe: [PATCH v3 02/11] KVM: selftests: Dump VM stats in binary stats test
Quoted 13 lines · Mingwei Zhang
Quoted 11 lines · Sean Christopherson
Quoted 4 lines · Ben Gardon
Add
kvm_utillibrary functions to read KVM stats through the binary stats interface and then dump them to stdout when running the binary stats test. Subsequent commits will extend thekvm_utilcode and use it to make assertions in a test for NX hugepages.Why? Spamming my console with info that has zero meaning to me and is useless when the test passes is not helpful. Even on failure, I don't see what the user is going to do with this information, all of the asserts are completly unrelated to the stats themselves.
Quoted 7 lines
Debugging could be another reason, I suspect? I remember when I tried to use the interface, there is really no API that tells me "did I add this stat successfully and/or correctly?" I think having a general print so that developer/debugging folk could just 'grep mystat' to verify that would be helpful in the future.
Otherwise, they have to write code themselves to do the dirty print...
I've no objection to adding a --verbose option or a #define of some form, but make it opt-in, not on by default.
PATCH v3 3/11 KVM: selftests: Test reading a single stat
In reply to Ben GardonRetrieve the value of a single stat by name in the binary stats test to ensure the kvm_util library functions work.
--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 53 +++++++++++++++++++ 3 files changed, 57 insertions(+)
tools/testing/selftests/kvm/include/kvm_util_base.h +1 -0
@@ -402,6 +402,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid);void dump_vm_stats (struct kvm_vm *vm); +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name);uint32_t guest_get_vcpuid (void );
tools/testing/selftests/kvm/kvm_binary_stats_test.c +3 -0
@@ -177,6 +177,9 @@ static void vm_stats_test(struct kvm_vm *vm)/* Dump VM stats */ dump_vm_stats (vm); + +/* Read a single stat. */ +printf ("remote_tlb_flush: %lu\n" ,vm_get_single_stat (vm,"remote_tlb_flush" )); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)
tools/testing/selftests/kvm/lib/kvm_util.c +53 -0
56 lines not on this page · raw message
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 03/11] KVM: selftests: Test reading a single stat
Quoted 100 lines · Ben Gardon
Retrieve the value of a single stat by name in the binary stats test to ensure the
kvm_utillibrary functions work.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 53 +++++++++++++++++++ 3 files changed, 57 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -402,6 +402,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid);void dump_vm_stats (struct kvm_vm *vm); +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -177,6 +177,9 @@ static void vm_stats_test(struct kvm_vm *vm)/* Dump VM stats */ dump_vm_stats (vm); + +/* Read a single stat. */ +printf ("remote_tlb_flush: %lu\n" ,vm_get_single_stat (vm,"remote_tlb_flush" )); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +53
-1@@ -2705,3 +2705,56 @@ void dump_vm_stats(struct kvm_vm *vm)close (stats_fd); } +static int vm_get_stat_data (struct kvm_vm *vm,const char *stat_name, +uint64_t **data) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int ret = -EINVAL ; +int i; + + *data =NULL ; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); + +if (strcmp (desc->name, stat_name)) +continue ; + + ret =read_stat_data (stats_fd, header, desc, data); + } + +free (stats_desc); +free (header); + +close (stats_fd); + +return ret; +} + +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name) +{ +uint64_t *data; +uint64_t value; +int ret; + + ret =vm_get_stat_data (vm, stat_name, &data); +TEST_ASSERT (ret ==1 ,"Stat %s expected to have 1 element, but has %d" , + stat_name, ret); + value = *data; +free (data); +return value; +} + --
Quoted 2 lines
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 03/11] KVM: selftests: Test reading a single stat
In reply to Ben GardonQuoted 85 lines · Ben Gardon
Retrieve the value of a single stat by name in the binary stats test to ensure the
kvm_utillibrary functions work.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 53 +++++++++++++++++++ 3 files changed, 57 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -402,6 +402,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid);void dump_vm_stats (struct kvm_vm *vm); +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -177,6 +177,9 @@ static void vm_stats_test(struct kvm_vm *vm)/* Dump VM stats */ dump_vm_stats (vm); + +/* Read a single stat. */ +printf ("remote_tlb_flush: %lu\n" ,vm_get_single_stat (vm,"remote_tlb_flush" )); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +40
-0@@ -2705,3 +2705,56 @@ void dump_vm_stats(struct kvm_vm *vm)close (stats_fd); } +static int vm_get_stat_data (struct kvm_vm *vm,const char *stat_name, +uint64_t **data) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int ret = -EINVAL ; +int i; + + *data =NULL ; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); + +if (strcmp (desc->name, stat_name)) +continue ; + + ret =read_stat_data (stats_fd, header, desc, data); + } + +free (stats_desc); +free (header); + +close (stats_fd); + +return ret; +} + +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name)
tools/testing/selftests/kvm/lib/kvm_util.c void dump_vm_stats(struct kvm_vm *vm) · line 2757
Quoted 10 lines
tools/testing/selftests/kvm/lib/kvm_util.c +10
-0+{ +uint64_t *data; +uint64_t value; +int ret; + + ret =vm_get_stat_data (vm, stat_name, &data); +TEST_ASSERT (ret ==1 ,"Stat %s expected to have 1 element, but has %d" , + stat_name, ret); + value = *data; +free (data);
Allocating temporary storage for the data is unnecessary. Just read the stat directly into &value. You'll need to change read_stat_data() to accept another parameter that defines the number of elements the caller wants to read. Otherwise botched stats could trigger a buffer overflow.
Quoted 6 lines
tools/testing/selftests/kvm/lib/kvm_util.c +3
-0+return value; +} +Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 03/11] KVM: selftests: Test reading a single stat
Quoted 94 lines · David Matlack
Quoted 92 lines · Ben Gardon
Retrieve the value of a single stat by name in the binary stats test to ensure the
kvm_utillibrary functions work.CC Jing Zhang <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 1 + .../selftests/kvm/kvm_binary_stats_test.c | 3 ++ tools/testing/selftests/kvm/lib/kvm_util.c | 53 +++++++++++++++++++ 3 files changed, 57 insertions(+)tools/testing/selftests/kvm/include/kvm_util_base.h +1
-0@@ -402,6 +402,7 @@ void assert_on_unhandled_exception(struct kvm_vm *vm, uint32_t vcpuid);int vm_get_stats_fd (struct kvm_vm *vm);int vcpu_get_stats_fd (struct kvm_vm *vm,uint32_t vcpuid);void dump_vm_stats (struct kvm_vm *vm); +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name);uint32_t guest_get_vcpuid (void );tools/testing/selftests/kvm/kvm_binary_stats_test.c +3
-0@@ -177,6 +177,9 @@ static void vm_stats_test(struct kvm_vm *vm)/* Dump VM stats */ dump_vm_stats (vm); + +/* Read a single stat. */ +printf ("remote_tlb_flush: %lu\n" ,vm_get_single_stat (vm,"remote_tlb_flush" )); }static void vcpu_stats_test (struct kvm_vm *vm,int vcpu_id)tools/testing/selftests/kvm/lib/kvm_util.c +47
-0@@ -2705,3 +2705,56 @@ void dump_vm_stats(struct kvm_vm *vm)close (stats_fd); } +static int vm_get_stat_data (struct kvm_vm *vm,const char *stat_name, +uint64_t **data) +{ +struct kvm_stats_desc *stats_desc; +struct kvm_stats_header *header; +struct kvm_stats_desc *desc; +size_t size_desc; +int stats_fd; +int ret = -EINVAL ; +int i; + + *data =NULL ; + + stats_fd =vm_get_stats_fd (vm); + + header =read_vm_stats_header (stats_fd); + + stats_desc =read_vm_stats_desc (stats_fd, header); + + size_desc =stats_desc_size (header); + +/* Read kvm stats data one by one */ +for (i =0 ; i < header->num_desc; ++i) { + desc = (void *)stats_desc + (i * size_desc); + +if (strcmp (desc->name, stat_name)) +continue ; + + ret =read_stat_data (stats_fd, header, desc, data); + } + +free (stats_desc); +free (header); + +close (stats_fd); + +return ret; +} + +uint64_t vm_get_single_stat (struct kvm_vm *vm,const char *stat_name) +{ +uint64_t *data; +uint64_t value; +int ret; + + ret =vm_get_stat_data (vm, stat_name, &data); + TEST_ASSERT(ret == 1, "Stat %s expected to have 1 element, but has %d",
Quoted 8 lines
tools/testing/selftests/kvm/lib/kvm_util.c void dump_vm_stats(struct kvm_vm *vm) · line 2757
Quoted 3 lines
tools/testing/selftests/kvm/lib/kvm_util.c +3
-0+ stat_name, ret); + value = *data; +free (data);Allocating temporary storage for the data is unnecessary. Just read the stat directly into &value. You'll need to change
read_stat_data()to accept another parameter that defines the number of elements the caller wants to read. Otherwise botched stats could trigger a buffer overflow.
Will do.
Quoted 7 lines
Quoted 7 lines
tools/testing/selftests/kvm/lib/kvm_util.c +3
-1+return value; +} + --2.35.1.1021.g381101b075-goog
PATCH v3 4/11 KVM: selftests: Add memslot parameter to elf_load
In reply to Ben GardonCurrently elf_load loads code into memslot 0. Add a parameter to allow loading code into any memslot. This will be useful for backing code pages with huge pages in future commits.
No functional change intended.
--- .../testing/selftests/kvm/include/kvm_util_base.h | 5 +++++ tools/testing/selftests/kvm/lib/elf.c | 13 +++++++++++-- tools/testing/selftests/kvm/lib/kvm_util.c | 14 ++++++++++---- 3 files changed, 26 insertions(+), 6 deletions(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +5 -0
@@ -122,7 +122,10 @@ uint32_t kvm_vm_reset_dirty_ring(struct kvm_vm *vm);int kvm_memcmp_hva_gva (void *hva,struct kvm_vm *vm,const vm_vaddr_t gva,size_t len); +void kvm_vm_elf_load_memslot (struct kvm_vm *vm,const char *filename, +uint32_t memslot);void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename); +int kvm_memfd_alloc (size_t size,bool hugepages);void vm_dump (FILE *stream,struct kvm_vm *vm,uint8_t indent);
@@ -169,6 +172,8 @@ void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags);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);void vm_vcpu_add (struct kvm_vm *vm,uint32_t vcpuid); +vm_vaddr_t vm_vaddr_alloc_memslot (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,uint32_t memslot);vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min);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);
tools/testing/selftests/kvm/lib/elf.c +11 -2
@@ -97,6 +97,7 @@ static void elfhdr_get(const char *filename, Elf64_Ehdr *hdrp)* * Input Args: * filename - Path to ELF file +* memslot - the memslot into which the elf should be loaded * * Output Args: None *
@@ -111,7 +112,8 @@ static void elfhdr_get(const char *filename, Elf64_Ehdr *hdrp)* by the image and it needs to have sufficient available physical pages, to * back the virtual pages used to load the image. */ -void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename) +void kvm_vm_elf_load_memslot (struct kvm_vm *vm,const char *filename, +uint32_t memslot) {off_t offset, offset_rv;Elf64_Ehdr hdr;
@@ -162,7 +164,9 @@ 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_memslot (vm, seg_size, + seg_vstart, + memslot);TEST_ASSERT (vaddr == seg_vstart,"Unable to allocate " "virtual memory for segment at requested min addr,\n" " segment idx: %u\n"
@@ -191,3 +195,8 @@ void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename) } } } + +void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename) +{ +kvm_vm_elf_load_memslot (vm, filename,0 ); +}
tools/testing/selftests/kvm/lib/kvm_util.c +10 -4
@@ -1336,8 +1336,7 @@ static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz,* vm - Virtual Machine * sz - Size in bytes * vaddr_min - Minimum starting virtual address -* data_memslot - Memory region slot for data pages -* pgd_memslot - Memory region slot for new virtual translation tables +* memslot - Memory region slot for data pages * * Output Args: None *
@@ -1350,13 +1349,15 @@ static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz,* a unique set of pages, with the minimum real allocation being at least * a page. */ -vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +vm_vaddr_t vm_vaddr_alloc_memslot (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,uint32_t memslot) {uint64_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, + memslot);/* * Find an unused range of virtual page addresses of at least
@@ -1377,6 +1378,11 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min)return vaddr_start; } +vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +{ +return vm_vaddr_alloc_memslot (vm, sz, vaddr_min,0 ); +} +/* * VM Virtual Address Allocate Pages *
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 04/11] KVM: selftests: Add memslot parameter to elf_load
Quoted 50 lines · Ben Gardon
Currently
elf_loadloads code into memslot 0. Add a parameter to allow loading code into any memslot. This will be useful for backing code pages with huge pages in future commits.No functional change intended.
Signed-off-by Ben Gardon <[email protected]>--- .../testing/selftests/kvm/include/kvm_util_base.h | 5 +++++ tools/testing/selftests/kvm/lib/elf.c | 13 +++++++++++-- tools/testing/selftests/kvm/lib/kvm_util.c | 14 ++++++++++---- 3 files changed, 26 insertions(+), 6 deletions(-)tools/testing/selftests/kvm/include/kvm_util_base.h +5
-0@@ -122,7 +122,10 @@ uint32_t kvm_vm_reset_dirty_ring(struct kvm_vm *vm);int kvm_memcmp_hva_gva (void *hva,struct kvm_vm *vm,const vm_vaddr_t gva,size_t len); +void kvm_vm_elf_load_memslot (struct kvm_vm *vm,const char *filename, +uint32_t memslot);void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename); +int kvm_memfd_alloc (size_t size,bool hugepages);void vm_dump (FILE *stream,struct kvm_vm *vm,uint8_t indent);@@ -169,6 +172,8 @@ void vm_mem_region_set_flags(struct kvm_vm *vm, uint32_t slot, uint32_t flags);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);void vm_vcpu_add (struct kvm_vm *vm,uint32_t vcpuid); +vm_vaddr_t vm_vaddr_alloc_memslot (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,uint32_t memslot);vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min);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);tools/testing/selftests/kvm/lib/elf.c +1
-0@@ -97,6 +97,7 @@ static void elfhdr_get(const char *filename, Elf64_Ehdr *hdrp)* * Input Args: * filename - Path to ELF file +* memslot - the memslot into which the elf should be loaded * * Output Args: None *
tools/testing/selftests/kvm/lib/elf.c static void elfhdr_get(const char *filename, Elf64_Ehdr *hdrp) · line 116
Quoted 6 lines
tools/testing/selftests/kvm/lib/elf.c +2
-1@@ -111,7 +112,8 @@ static void elfhdr_get(const char *filename, Elf64_Ehdr *hdrp)* by the image and it needs to have sufficient available physical pages, to * back the virtual pages used to load the image. */ -void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename) +void kvm_vm_elf_load_memslot (struct kvm_vm *vm,const char *filename, +uint32_t memslot)
Feedback I've gotten in the past for kernel code and selftests is to just use double-underscores (i.e. __kvm_vm_elf_load()) for situations like this, rather than trying to encode the extra parameters in the function name.
Quoted 38 lines
tools/testing/selftests/kvm/lib/elf.c +8
-1{off_t offset, offset_rv;Elf64_Ehdr hdr;@@ -162,7 +164,9 @@ 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_memslot (vm, seg_size, + seg_vstart, + memslot);TEST_ASSERT (vaddr == seg_vstart,"Unable to allocate " "virtual memory for segment at requested min addr,\n" " segment idx: %u\n"@@ -191,3 +195,8 @@ void kvm_vm_elf_load(struct kvm_vm *vm, const char *filename) } } } + +void kvm_vm_elf_load (struct kvm_vm *vm,const char *filename) +{ +kvm_vm_elf_load_memslot (vm, filename,0 ); +}tools/testing/selftests/kvm/lib/kvm_util.c +1
-2@@ -1336,8 +1336,7 @@ static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz,* vm - Virtual Machine * sz - Size in bytes * vaddr_min - Minimum starting virtual address -* data_memslot - Memory region slot for data pages -* pgd_memslot - Memory region slot for new virtual translation tables +* memslot - Memory region slot for data pages * * Output Args: None *
tools/testing/selftests/kvm/lib/kvm_util.c static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, · line 1353
Quoted 6 lines
tools/testing/selftests/kvm/lib/kvm_util.c +2
-1@@ -1350,13 +1349,15 @@ static vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz,* a unique set of pages, with the minimum real allocation being at least * a page. */ -vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +vm_vaddr_t vm_vaddr_alloc_memslot (struct kvm_vm *vm,size_t sz, +vm_vaddr_t vaddr_min,uint32_t memslot)
Same feedback here; use __vm_vaddr_alloc().
Quoted 26 lines
tools/testing/selftests/kvm/lib/kvm_util.c +7
-1{uint64_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, + memslot);/* * Find an unused range of virtual page addresses of at least @@ -1377,6 +1378,11 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min)return vaddr_start; } +vm_vaddr_t vm_vaddr_alloc (struct kvm_vm *vm,size_t sz,vm_vaddr_t vaddr_min) +{ +return vm_vaddr_alloc_memslot (vm, sz, vaddr_min,0 ); +} +/* * VM Virtual Address Allocate Pages * Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 5/11 KVM: selftests: Improve error message in vm_phy_pages_alloc
In reply to Ben GardonMake an error message in vm_phy_pages_alloc more specific, and log the number of pages requested in the allocation.
--- tools/testing/selftests/kvm/lib/kvm_util.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
tools/testing/selftests/kvm/lib/kvm_util.c +3 -2
@@ -2408,9 +2408,10 @@ vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, }while (pg && pg != base + num);if (pg ==0 ) { -fprintf (stderr,"No guest physical page available, " +fprintf (stderr, +"Unable to find %ld contiguous guest physical pages. " "paddr_min: 0x%lx page_size: 0x%x memslot: %u\n" , - paddr_min, vm->page_size, memslot); + num, paddr_min, vm->page_size, memslot);fputs ("---- vm dump ----\n" , stderr);vm_dump (stderr, vm,2 );abort ();
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 05/11] KVM: selftests: Improve error message in vm_phy_pages_alloc
Quoted 1 line · Ben Gardon
Make an error message in
vm_phy_pages_allocmore specific, and log the
vm_phy_pages_alloc()
Quoted 27 lines
number of pages requested in the allocation.
Signed-off-by Ben Gardon <[email protected]>--- tools/testing/selftests/kvm/lib/kvm_util.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)tools/testing/selftests/kvm/lib/kvm_util.c +3
-2@@ -2408,9 +2408,10 @@ vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num, }while (pg && pg != base + num);if (pg ==0 ) { -fprintf (stderr,"No guest physical page available, " +fprintf (stderr, +"Unable to find %ld contiguous guest physical pages. " "paddr_min: 0x%lx page_size: 0x%x memslot: %u\n" , - paddr_min, vm->page_size, memslot); + num, paddr_min, vm->page_size, memslot);fputs ("---- vm dump ----\n" , stderr);vm_dump (stderr, vm,2 );abort ();Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 6/11 KVM: selftests: Add NX huge pages test
In reply to Ben GardonThere's currently no test coverage of NX hugepages in KVM selftests, so add a basic test to ensure that the feature works as intended.
--- tools/testing/selftests/kvm/Makefile | 7 +- .../kvm/lib/x86_64/nx_huge_pages_guest.S | 45 ++++++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 133 ++++++++++++++++++ .../kvm/x86_64/nx_huge_pages_test.sh | 25 ++++ 4 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S create mode 100644 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c create mode 100755 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh
tools/testing/selftests/kvm/Makefile +6 -1
@@ -38,7 +38,7 @@ ifeq ($(ARCH),riscv) endif LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/rbtree.c lib/sparsebit.c lib/test_util.c lib/guest_modes.c lib/perf_test_util.c -LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S +LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S lib/x86_64/nx_huge_pages_guest.S LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c lib/aarch64/handlers.S lib/aarch64/spinlock.c lib/aarch64/gic.c lib/aarch64/gic_v3.c lib/aarch64/vgic.c LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318_test_handler.c LIBKVM_riscv = lib/riscv/processor.c lib/riscv/ucall.c
@@ -57,6 +57,8 @@ TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test +TEST_GEN_PROGS_EXTENDED_x86_64 += x86_64/nx_huge_pages_test +TEST_PROGS_x86_64 += x86_64/nx_huge_pages_test.sh TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id
@@ -141,7 +143,9 @@ TEST_GEN_PROGS_riscv += kvm_page_table_test TEST_GEN_PROGS_riscv += set_memory_region_test TEST_GEN_PROGS_riscv += kvm_binary_stats_test +TEST_PROGS += $(TEST_PROGS_$(UNAME_M)) TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M)) +TEST_GEN_PROGS_EXTENDED += $(TEST_GEN_PROGS_EXTENDED_$(UNAME_M)) LIBKVM += $(LIBKVM_$(UNAME_M)) INSTALL_HDR_PATH = $(top_srcdir)/usr
@@ -192,6 +196,7 @@ $(OUTPUT)/libkvm.a: $(LIBKVM_OBJS) x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS)))) all: $(STATIC_LIBS) $(TEST_GEN_PROGS): $(STATIC_LIBS) +$(TEST_GEN_PROGS_EXTENDED): $(STATIC_LIBS) cscope: include_paths = $(LINUX_TOOL_INCLUDE) $(LINUX_HDR_PATH) include lib .. cscope:
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +45 -0
45 lines not on this page · raw message
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +133 -0
133 lines not on this page · raw message
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh new file +25 -0
@@ -0,0 +1,25 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0-only */ + +# tools/testing/selftests/kvm/nx_huge_page_test.sh +# Copyright (C) 2022, Google LLC. + +NX_HUGE_PAGES=$(cat /sys/module/kvm/parameters/nx_huge_pages) +NX_HUGE_PAGES_RECOVERY_RATIO=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio) +NX_HUGE_PAGES_RECOVERY_PERIOD=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms) +HUGE_PAGES=$(cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages) + +echo 1 > /sys/module/kvm/parameters/nx_huge_pages +echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +./nx_huge_pages_test +RET=$? + +echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages +echo $NX_HUGE_PAGES_RECOVERY_RATIO > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo $NX_HUGE_PAGES_RECOVERY_PERIOD > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo $HUGE_PAGES > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +exit $RET
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 06/11] KVM: selftests: Add NX huge pages test
Quoted 30 lines · Ben Gardon
There's currently no test coverage of NX hugepages in KVM selftests, so add a basic test to ensure that the feature works as intended.
Reviewed-by David Dunn <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- tools/testing/selftests/kvm/Makefile | 7 +- .../kvm/lib/x86_64/nx_huge_pages_guest.S | 45 ++++++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 133 ++++++++++++++++++ .../kvm/x86_64/nx_huge_pages_test.sh | 25 ++++ 4 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S create mode 100644 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c create mode 100755 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.shtools/testing/selftests/kvm/Makefile +1
-1@@ -38,7 +38,7 @@ ifeq ($(ARCH),riscv) endif LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/rbtree.c lib/sparsebit.c lib/test_util.c lib/guest_modes.c lib/perf_test_util.c -LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S +LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S lib/x86_64/nx_huge_pages_guest.S LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c lib/aarch64/handlers.S lib/aarch64/spinlock.c lib/aarch64/gic.c lib/aarch64/gic_v3.c lib/aarch64/vgic.c LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318_test_handler.c LIBKVM_riscv = lib/riscv/processor.c lib/riscv/ucall.c
tools/testing/selftests/kvm/Makefile TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test · line 61
Quoted 5 lines
tools/testing/selftests/kvm/Makefile +2
-0@@ -57,6 +57,8 @@ TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test +TEST_GEN_PROGS_EXTENDED_x86_64 += x86_64/nx_huge_pages_test +TEST_PROGS_x86_64 += x86_64/nx_huge_pages_test.sh
Suggest brearking TEST_PROGS and TEST_GEN_PROGS_EXTENDED out into their own separate blocks with newlines in between. They capture different types of files so I think it makes sense to separate them in the Makefile. I expect both lists will grow over time so the awkwardness of having them off on their lonesome is temporary :).
It'd also be nice to have some comments above each explaining when they should be used. A short blurb is fine since the selftest documentation is the authority.
Quoted 54 lines
tools/testing/selftests/kvm/Makefile +3
-0TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id@@ -141,7 +143,9 @@ TEST_GEN_PROGS_riscv += kvm_page_table_test TEST_GEN_PROGS_riscv += set_memory_region_test TEST_GEN_PROGS_riscv += kvm_binary_stats_test +TEST_PROGS += $(TEST_PROGS_$(UNAME_M)) TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M)) +TEST_GEN_PROGS_EXTENDED += $(TEST_GEN_PROGS_EXTENDED_$(UNAME_M)) LIBKVM += $(LIBKVM_$(UNAME_M)) INSTALL_HDR_PATH = $(top_srcdir)/usr@@ -192,6 +196,7 @@ $(OUTPUT)/libkvm.a: $(LIBKVM_OBJS) x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS)))) all: $(STATIC_LIBS) $(TEST_GEN_PROGS): $(STATIC_LIBS) +$(TEST_GEN_PROGS_EXTENDED): $(STATIC_LIBS) cscope: include_paths = $(LINUX_TOOL_INCLUDE) $(LINUX_HDR_PATH) include lib .. cscope:tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +27
-0@@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * tools/testing/selftests/kvm/nx_huge_page_guest.S + * + * Copyright (C) 2022, Google LLC. + */ + +.include "kvm_util.h" + +#define HPAGE_SIZE (2*1024*1024) +#define PORT_SUCCESS 0x70 + +.global guest_code0 +.global guest_code1 + +.align HPAGE_SIZE +exit_vm: + mov $0x1,%edi + mov $0x2,%esi + mov a_string,%edx + mov $0x1,%ecx + xor %eax,%eax + jmp ucall + + +guest_code0: + mov data1, %eax
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S line 37
Quoted 10 lines
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +10
-0+ mov data2, %eax + jmp exit_vm + +.align HPAGE_SIZE +guest_code1: + mov data1, %eax + mov data2, %eax + jmp exit_vm +data1: +.quad 0
What do you think about my idea in [1] of using ret instructions and function pointers to trigger execution on an arbitrary page? That would avoid the need for this assembly file and we could probably share the code between our tests.
Feel free to take the idea and incorporate it directly if you agree, and I'll rebase on top, since you're series is further along than mine.
Quoted 109 lines
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +8
-0+ +.align HPAGE_SIZE +data2: +.quad 0 +a_string: +.string "why does the ucall function take a string argument?" + +tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +95
-0@@ -0,0 +1,133 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* tools/testing/selftests/kvm/nx_huge_page_test.c +* +* Usage: to be run via nx_huge_page_test.sh, which does the necessary +* environment setup and teardown +* +* Copyright (C) 2022, Google LLC. +*/ + +#define _GNU_SOURCE + +#include <fcntl.h> +#include <stdint.h> +#include <time.h> + +#include <test_util.h> +#include "kvm_util.h" + +#define HPAGE_SLOT 10 +#define HPAGE_PADDR_START (10*1024*1024) +#define HPAGE_SLOT_NPAGES (100*1024*1024/4096) + +/* Defined in nx_huge_page_guest.S */ +void guest_code0 (void ); +void guest_code1 (void ); + +static void run_guest_code (struct kvm_vm *vm,void (*guest_code)(void )) +{ +struct kvm_regs regs; + +vcpu_regs_get (vm,0 , ®s); + regs.rip = (uint64_t )guest_code; +vcpu_regs_set (vm,0 , ®s); +vcpu_run (vm,0 ); +} + +static void check_2m_page_count (struct kvm_vm *vm,int expected_pages_2m) +{ +int actual_pages_2m; + + actual_pages_2m =vm_get_single_stat (vm,"pages_2m" ); + +TEST_ASSERT (actual_pages_2m == expected_pages_2m, +"Unexpected 2m page count. Expected %d, got %d" , + expected_pages_2m, actual_pages_2m); +} + +static void check_split_count (struct kvm_vm *vm,int expected_splits) +{ +int actual_splits; + + actual_splits =vm_get_single_stat (vm,"nx_lpage_splits" ); + +TEST_ASSERT (actual_splits == expected_splits, +"Unexpected nx lpage split count. Expected %d, got %d" , + expected_splits, actual_splits); +} + +int main (int argc,char **argv) +{ +struct kvm_vm *vm; +struct timespec ts; + + vm =vm_create (VM_MODE_DEFAULT ,DEFAULT_GUEST_PHY_PAGES ,O_RDWR ); + +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS_HUGETLB , +HPAGE_PADDR_START ,HPAGE_SLOT , +HPAGE_SLOT_NPAGES ,0 ); + +kvm_vm_elf_load_memslot (vm, program_invocation_name,HPAGE_SLOT ); + +vm_vcpu_add_default (vm,0 , guest_code0); + +check_2m_page_count (vm,0 ); +check_split_count (vm,0 ); + +/* +* Running guest_code0 will access data1 and data2. +* This should result in part of the huge page containing guest_code0, +* and part of the hugepage containing the ucall function being mapped +* at 4K. The huge pages containing data1 and data2 will be mapped +* at 2M. +*/ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,2 ); +check_split_count (vm,2 ); + +/* +* guest_code1 is in the same huge page as data1, so it will cause +* that huge page to be remapped at 4k. +*/ +run_guest_code (vm, guest_code1); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 );
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c line 105
Quoted 10 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +10
-0+ +/* Run guest_code0 again to check that is has no effect. */ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 ); + +/* +* Give recovery thread time to run. The wrapper script sets +* recovery_period_ms to 100, so wait 1.5x that. +*/
So we give it an extra 50ms? That should probably be enough but I'm paranoid so I'd probably bump it up to 500 ms.
Quoted 62 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +28
-0+ ts.tv_sec =0 ; + ts.tv_nsec =150000000 ; +nanosleep (&ts,NULL ); + +/* +* Now that the reclaimer has run, all the split pages should be gone. +*/ +check_2m_page_count (vm,1 ); +check_split_count (vm,0 ); + +/* +* The split 2M pages should have been reclaimed, so run guest_code0 +* again to check that pages are mapped at 2M again. +*/ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,2 ); +check_split_count (vm,2 ); + +/* Pages are once again split from running guest_code1. */ +run_guest_code (vm, guest_code1); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 ); + +kvm_vm_free (vm); + +return 0 ; +} +tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh new file +25
-0@@ -0,0 +1,25 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0-only */ + +# tools/testing/selftests/kvm/nx_huge_page_test.sh +# Copyright (C) 2022, Google LLC. + +NX_HUGE_PAGES=$(cat /sys/module/kvm/parameters/nx_huge_pages) +NX_HUGE_PAGES_RECOVERY_RATIO=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio) +NX_HUGE_PAGES_RECOVERY_PERIOD=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms) +HUGE_PAGES=$(cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages) + +echo 1 > /sys/module/kvm/parameters/nx_huge_pages +echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +./nx_huge_pages_test +RET=$? + +echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages +echo $NX_HUGE_PAGES_RECOVERY_RATIO > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo $NX_HUGE_PAGES_RECOVERY_PERIOD > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo $HUGE_PAGES > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +exit $RETSignature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 06/11] KVM: selftests: Add NX huge pages test
Quoted 44 lines · David Matlack
Quoted 30 lines · Ben Gardon
There's currently no test coverage of NX hugepages in KVM selftests, so add a basic test to ensure that the feature works as intended.
Reviewed-by David Dunn <[email protected]>Signed-off-by Ben Gardon <[email protected]>--- tools/testing/selftests/kvm/Makefile | 7 +- .../kvm/lib/x86_64/nx_huge_pages_guest.S | 45 ++++++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 133 ++++++++++++++++++ .../kvm/x86_64/nx_huge_pages_test.sh | 25 ++++ 4 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S create mode 100644 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c create mode 100755 tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.shtools/testing/selftests/kvm/Makefile +1
-1@@ -38,7 +38,7 @@ ifeq ($(ARCH),riscv) endif LIBKVM = lib/assert.c lib/elf.c lib/io.c lib/kvm_util.c lib/rbtree.c lib/sparsebit.c lib/test_util.c lib/guest_modes.c lib/perf_test_util.c -LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S +LIBKVM_x86_64 = lib/x86_64/apic.c lib/x86_64/processor.c lib/x86_64/vmx.c lib/x86_64/svm.c lib/x86_64/ucall.c lib/x86_64/handlers.S lib/x86_64/nx_huge_pages_guest.S LIBKVM_aarch64 = lib/aarch64/processor.c lib/aarch64/ucall.c lib/aarch64/handlers.S lib/aarch64/spinlock.c lib/aarch64/gic.c lib/aarch64/gic_v3.c lib/aarch64/vgic.c LIBKVM_s390x = lib/s390x/processor.c lib/s390x/ucall.c lib/s390x/diag318_test_handler.c LIBKVM_riscv = lib/riscv/processor.c lib/riscv/ucall.ctools/testing/selftests/kvm/Makefile TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test · line 61
Quoted 5 lines
tools/testing/selftests/kvm/Makefile +2
-0@@ -57,6 +57,8 @@ TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test +TEST_GEN_PROGS_EXTENDED_x86_64 += x86_64/nx_huge_pages_test +TEST_PROGS_x86_64 += x86_64/nx_huge_pages_test.shSuggest brearking
TEST_PROGSandTEST_GEN_PROGS_EXTENDEDout into their own separate blocks with newlines in between. They capture different types of files so I think it makes sense to separate them in theMakefile. I expect both lists will grow over time so the awkwardness of having them off on their lonesome is temporary :).
Quoted 3 lines
It'd also be nice to have some comments above each explaining when they should be used. A short blurb is fine since the selftest documentation is the authority.
Will do.
Quoted 71 lines
Quoted 55 lines
tools/testing/selftests/kvm/Makefile +3
-0TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id@@ -141,7 +143,9 @@ TEST_GEN_PROGS_riscv += kvm_page_table_test TEST_GEN_PROGS_riscv += set_memory_region_test TEST_GEN_PROGS_riscv += kvm_binary_stats_test +TEST_PROGS += $(TEST_PROGS_$(UNAME_M)) TEST_GEN_PROGS += $(TEST_GEN_PROGS_$(UNAME_M)) +TEST_GEN_PROGS_EXTENDED += $(TEST_GEN_PROGS_EXTENDED_$(UNAME_M)) LIBKVM += $(LIBKVM_$(UNAME_M)) INSTALL_HDR_PATH = $(top_srcdir)/usr@@ -192,6 +196,7 @@ $(OUTPUT)/libkvm.a: $(LIBKVM_OBJS) x := $(shell mkdir -p $(sort $(dir $(TEST_GEN_PROGS)))) all: $(STATIC_LIBS) $(TEST_GEN_PROGS): $(STATIC_LIBS) +$(TEST_GEN_PROGS_EXTENDED): $(STATIC_LIBS) cscope: include_paths = $(LINUX_TOOL_INCLUDE) $(LINUX_HDR_PATH) include lib .. cscope:tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +27
-0@@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * tools/testing/selftests/kvm/nx_huge_page_guest.S + * + * Copyright (C) 2022, Google LLC. + */ + +.include "kvm_util.h" + +#define HPAGE_SIZE (2*1024*1024) +#define PORT_SUCCESS 0x70 + +.global guest_code0 +.global guest_code1 + +.align HPAGE_SIZE +exit_vm: + mov $0x1,%edi + mov $0x2,%esi + mov a_string,%edx + mov $0x1,%ecx + xor %eax,%eax + jmp ucall + + +guest_code0: + mov data1, %eaxtools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S line 37
Quoted 10 lines
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +10
-0+ mov data2, %eax + jmp exit_vm + +.align HPAGE_SIZE +guest_code1: + mov data1, %eax + mov data2, %eax + jmp exit_vm +data1: +.quad 0What do you think about my idea in [1] of using ret instructions and function pointers to trigger execution on an arbitrary page? That would avoid the need for this assembly file and we could probably share the code between our tests.
Quoted 5 lines
Feel free to take the idea and incorporate it directly if you agree, and I'll rebase on top, since you're series is further along than mine.
Sigh, it means I have to rewrite a lot of the test, but it is the better way to write this test.
Quoted 114 lines
Quoted 114 lines
tools/testing/selftests/kvm/lib/x86_64/nx_huge_pages_guest.S new file +8
-0+ +.align HPAGE_SIZE +data2: +.quad 0 +a_string: +.string "why does the ucall function take a string argument?" + +tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +100
-0@@ -0,0 +1,133 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* tools/testing/selftests/kvm/nx_huge_page_test.c +* +* Usage: to be run via nx_huge_page_test.sh, which does the necessary +* environment setup and teardown +* +* Copyright (C) 2022, Google LLC. +*/ + +#define _GNU_SOURCE + +#include <fcntl.h> +#include <stdint.h> +#include <time.h> + +#include <test_util.h> +#include "kvm_util.h" + +#define HPAGE_SLOT 10 +#define HPAGE_PADDR_START (10*1024*1024) +#define HPAGE_SLOT_NPAGES (100*1024*1024/4096) + +/* Defined in nx_huge_page_guest.S */ +void guest_code0 (void ); +void guest_code1 (void ); + +static void run_guest_code (struct kvm_vm *vm,void (*guest_code)(void )) +{ +struct kvm_regs regs; + +vcpu_regs_get (vm,0 , ®s); + regs.rip = (uint64_t )guest_code; +vcpu_regs_set (vm,0 , ®s); +vcpu_run (vm,0 ); +} + +static void check_2m_page_count (struct kvm_vm *vm,int expected_pages_2m) +{ +int actual_pages_2m; + + actual_pages_2m =vm_get_single_stat (vm,"pages_2m" ); + +TEST_ASSERT (actual_pages_2m == expected_pages_2m, +"Unexpected 2m page count. Expected %d, got %d" , + expected_pages_2m, actual_pages_2m); +} + +static void check_split_count (struct kvm_vm *vm,int expected_splits) +{ +int actual_splits; + + actual_splits =vm_get_single_stat (vm,"nx_lpage_splits" ); + +TEST_ASSERT (actual_splits == expected_splits, +"Unexpected nx lpage split count. Expected %d, got %d" , + expected_splits, actual_splits); +} + +int main (int argc,char **argv) +{ +struct kvm_vm *vm; +struct timespec ts; + + vm =vm_create (VM_MODE_DEFAULT ,DEFAULT_GUEST_PHY_PAGES ,O_RDWR ); + +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS_HUGETLB , +HPAGE_PADDR_START ,HPAGE_SLOT , +HPAGE_SLOT_NPAGES ,0 ); + +kvm_vm_elf_load_memslot (vm, program_invocation_name,HPAGE_SLOT ); + +vm_vcpu_add_default (vm,0 , guest_code0); + +check_2m_page_count (vm,0 ); +check_split_count (vm,0 ); + +/* +* Running guest_code0 will access data1 and data2. +* This should result in part of the huge page containing guest_code0, +* and part of the hugepage containing the ucall function being mapped +* at 4K. The huge pages containing data1 and data2 will be mapped +* at 2M. +*/ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,2 ); +check_split_count (vm,2 ); + +/* +* guest_code1 is in the same huge page as data1, so it will cause +* that huge page to be remapped at 4k. +*/ +run_guest_code (vm, guest_code1); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 ); + +/* Run guest_code0 again to check that is has no effect. */ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 );
Quoted 8 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c line 105
Quoted 5 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +5
-0+ +/* +* Give recovery thread time to run. The wrapper script sets +* recovery_period_ms to 100, so wait 1.5x that. +*/ So we give it an extra 50ms? That should probably be enough but I'm paranoid so I'd probably bump it up to 500 ms.
Will do.
Quoted 63 lines
Quoted 63 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c new file +28
-0+ ts.tv_sec =0 ; + ts.tv_nsec =150000000 ; +nanosleep (&ts,NULL ); + +/* +* Now that the reclaimer has run, all the split pages should be gone. +*/ +check_2m_page_count (vm,1 ); +check_split_count (vm,0 ); + +/* +* The split 2M pages should have been reclaimed, so run guest_code0 +* again to check that pages are mapped at 2M again. +*/ +run_guest_code (vm, guest_code0); +check_2m_page_count (vm,2 ); +check_split_count (vm,2 ); + +/* Pages are once again split from running guest_code1. */ +run_guest_code (vm, guest_code1); +check_2m_page_count (vm,1 ); +check_split_count (vm,3 ); + +kvm_vm_free (vm); + +return 0 ; +} +tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh new file +25
-1@@ -0,0 +1,25 @@ +#!/bin/bash +# SPDX-License-Identifier: GPL-2.0-only */ + +# tools/testing/selftests/kvm/nx_huge_page_test.sh +# Copyright (C) 2022, Google LLC. + +NX_HUGE_PAGES=$(cat /sys/module/kvm/parameters/nx_huge_pages) +NX_HUGE_PAGES_RECOVERY_RATIO=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio) +NX_HUGE_PAGES_RECOVERY_PERIOD=$(cat /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms) +HUGE_PAGES=$(cat /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages) + +echo 1 > /sys/module/kvm/parameters/nx_huge_pages +echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +./nx_huge_pages_test +RET=$? + +echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages +echo $NX_HUGE_PAGES_RECOVERY_RATIO > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio +echo $NX_HUGE_PAGES_RECOVERY_PERIOD > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms +echo $HUGE_PAGES > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages + +exit $RET --2.35.1.1021.g381101b075-goog
PATCH v3 7/11 KVM: x86/MMU: Factor out updating NX hugepages state for a VM
In reply to Ben GardonFactor out the code to update the NX hugepages state for an individual VM. This will be expanded in future commits to allow per-VM control of Nx hugepages.
No functional change intended.
--- arch/x86/kvm/mmu/mmu.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
arch/x86/kvm/mmu/mmu.c +11 -6
@@ -6202,6 +6202,15 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages = itlb_multihit_kvm_mitigation = val; } +static void kvm_update_nx_huge_pages (struct kvm *kvm) +{ +mutex_lock (&kvm->slots_lock); +kvm_mmu_zap_all_fast (kvm); +mutex_unlock (&kvm->slots_lock); + +wake_up_process (kvm->arch.nx_lpage_recovery_thread); +} +static int set_nx_huge_pages (const char *val,const struct kernel_param *kp) {bool old_val = nx_huge_pages;
@@ -6224,13 +6233,9 @@ static int set_nx_huge_pages(const char *val, const struct kernel_param *kp)mutex_lock (&kvm_lock); -list_for_each_entry (kvm, &vm_list, vm_list) { -mutex_lock (&kvm->slots_lock); -kvm_mmu_zap_all_fast (kvm); -mutex_unlock (&kvm->slots_lock); +list_for_each_entry (kvm, &vm_list, vm_list) +kvm_update_nx_huge_pages (kvm); -wake_up_process (kvm->arch.nx_lpage_recovery_thread); - }mutex_unlock (&kvm_lock); }
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 07/11] KVM: x86/MMU: Factor out updating NX hugepages state for a VM
Quoted 7 lines · Ben Gardon
Factor out the code to update the NX hugepages state for an individual VM. This will be expanded in future commits to allow per-VM control of Nx hugepages.
No functional change intended.
Signed-off-by Ben Gardon <[email protected]>
Quoted 43 lines
--- arch/x86/kvm/mmu/mmu.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)arch/x86/kvm/mmu/mmu.c +11
-6@@ -6202,6 +6202,15 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages = itlb_multihit_kvm_mitigation = val; } +static void kvm_update_nx_huge_pages (struct kvm *kvm) +{ +mutex_lock (&kvm->slots_lock); +kvm_mmu_zap_all_fast (kvm); +mutex_unlock (&kvm->slots_lock); + +wake_up_process (kvm->arch.nx_lpage_recovery_thread); +} +static int set_nx_huge_pages (const char *val,const struct kernel_param *kp) {bool old_val = nx_huge_pages;@@ -6224,13 +6233,9 @@ static int set_nx_huge_pages(const char *val, const struct kernel_param *kp)mutex_lock (&kvm_lock); -list_for_each_entry (kvm, &vm_list, vm_list) { -mutex_lock (&kvm->slots_lock); -kvm_mmu_zap_all_fast (kvm); -mutex_unlock (&kvm->slots_lock); +list_for_each_entry (kvm, &vm_list, vm_list) +kvm_update_nx_huge_pages (kvm); -wake_up_process (kvm->arch.nx_lpage_recovery_thread); - }mutex_unlock (&kvm_lock); }Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 8/11 KVM: x86/MMU: Allow NX huge pages to be disabled on a per-vm basis
In reply to Ben GardonIn some cases, the NX hugepage mitigation for iTLB multihit is not needed for all guests on a host. Allow disabling the mitigation on a per-VM basis to avoid the performance hit of NX hugepages on trusted workloads.
--- Documentation/virt/kvm/api.rst | 11 +++++++++++ arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/mmu.h | 10 ++++++---- arch/x86/kvm/mmu/mmu.c | 2 +- arch/x86/kvm/mmu/spte.c | 7 ++++--- arch/x86/kvm/mmu/spte.h | 3 ++- arch/x86/kvm/mmu/tdp_mmu.c | 3 ++- arch/x86/kvm/x86.c | 6 ++++++ include/uapi/linux/kvm.h | 1 + 9 files changed, 35 insertions(+), 10 deletions(-)
Documentation/virt/kvm/api.rst +11 -0
@@ -7844,6 +7844,17 @@ At this time, KVM_PMU_CAP_DISABLE is the only capability. Setting this capability will disable PMU virtualization for that VM. Usermode should adjust CPUID leaf 0xA to reflect that the PMU is disabled. +8.36 KVM_CAP_VM_DISABLE_NX_HUGE_PAGES +--------------------------- + +:Capability KVM_CAP_PMU_CAPABILITY +:Architectures: x86 +:Type: vm + +This capability disables the NX huge pages mitigation for iTLB MULTIHIT. + +The capability has no effect if the nx_huge_pages module parameter is not set. + 9. Known KVM API problems =========================
arch/x86/include/asm/kvm_host.h +2 -0
@@ -1246,6 +1246,8 @@ struct kvm_arch {hpa_t hv_root_tdp;spinlock_t hv_root_tdp_lock;#endif + +bool disable_nx_huge_pages; };struct kvm_vm_stat {
arch/x86/kvm/mmu.h +6 -4
@@ -173,10 +173,12 @@ struct kvm_page_fault {int kvm_tdp_page_fault (struct kvm_vcpu *vcpu,struct kvm_page_fault *fault);extern int nx_huge_pages; -static inline bool is_nx_huge_page_enabled (void ) +static inline bool is_nx_huge_page_enabled (struct kvm *kvm) { -return READ_ONCE (nx_huge_pages); +return READ_ONCE (nx_huge_pages) && + !kvm->arch.disable_nx_huge_pages; } +void kvm_update_nx_huge_pages (struct kvm *kvm);static inline int kvm_mmu_do_page_fault (struct kvm_vcpu *vcpu,gpa_t cr2_or_gpa,u32 err,bool prefetch)
@@ -191,8 +193,8 @@ static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, .user = err & PFERR_USER_MASK, .prefetch = prefetch, .is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault), - .nx_huge_page_workaround_enabled = is_nx_huge_page_enabled(), - + .nx_huge_page_workaround_enabled = + is_nx_huge_page_enabled(vcpu->kvm), .max_level = KVM_MAX_HUGEPAGE_LEVEL, .req_level = PG_LEVEL_4K, .goal_level = PG_LEVEL_4K,
arch/x86/kvm/mmu/mmu.c +1 -1
@@ -6202,7 +6202,7 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages = itlb_multihit_kvm_mitigation = val; } -static void kvm_update_nx_huge_pages (struct kvm *kvm) +void kvm_update_nx_huge_pages (struct kvm *kvm) {mutex_lock (&kvm->slots_lock);kvm_mmu_zap_all_fast (kvm);
arch/x86/kvm/mmu/spte.c +4 -3
@@ -116,7 +116,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, spte |=spte_shadow_accessed_mask (spte);if (level >PG_LEVEL_4K && (pte_access &ACC_EXEC_MASK ) && -is_nx_huge_page_enabled ()) { +is_nx_huge_page_enabled (vcpu->kvm)) { pte_access &= ~ACC_EXEC_MASK ; }
@@ -215,7 +215,8 @@ static u64 make_spte_executable(u64 spte)* This is used during huge page splitting to build the SPTEs that make up the * new page table. */ -u64 make_huge_page_split_spte (u64 huge_spte,int huge_level,int index) +u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,int huge_level, +int index) {u64 child_spte;int child_level;
@@ -243,7 +244,7 @@ u64 make_huge_page_split_spte(u64 huge_spte, int huge_level, int index)* When splitting to a 4K page, mark the page executable as the * NX hugepage mitigation no longer applies. */ -if (is_nx_huge_page_enabled ()) +if (is_nx_huge_page_enabled (kvm)) child_spte =make_spte_executable (child_spte); }
arch/x86/kvm/mmu/spte.h +2 -1
@@ -415,7 +415,8 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, bool host_writable, u64 *new_spte); -u64 make_huge_page_split_spte (u64 huge_spte,int huge_level,int index); +u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,int huge_level, +int index);u64 make_nonleaf_spte (u64 *child_pt,bool ad_disabled);u64 make_mmio_spte (struct kvm_vcpu *vcpu,u64 gfn,unsigned int access);u64 mark_spte_for_access_track (u64 spte);
arch/x86/kvm/mmu/tdp_mmu.c +2 -1
@@ -1469,7 +1469,8 @@ static int tdp_mmu_split_huge_page(struct kvm *kvm, struct tdp_iter *iter,* not been linked in yet and thus is not reachable from any other CPU. */ for (i =0 ; i <PT64_ENT_PER_PAGE ; i++) - sp->spt[i] =make_huge_page_split_spte (huge_spte, level, i); + sp->spt[i] =make_huge_page_split_spte (kvm, huge_spte, + level, i);/* * Replace the huge spte with a pointer to the populated lower level
arch/x86/kvm/x86.c +6 -0
@@ -4268,6 +4268,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_SYS_ATTRIBUTES :case KVM_CAP_VAPIC :case KVM_CAP_ENABLE_CAP : +case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES : r =1 ;break ;case KVM_CAP_EXIT_HYPERCALL :
@@ -6061,6 +6062,11 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, }mutex_unlock (&kvm->lock);break ; +case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES : + kvm->arch.disable_nx_huge_pages = true; +kvm_update_nx_huge_pages (kvm); + r =0 ; +break ;default : r = -EINVAL ;break ;
include/uapi/linux/kvm.h +1 -0
@@ -1145,6 +1145,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_PMU_CAPABILITY 212#define KVM_CAP_DISABLE_QUIRKS2 213#define KVM_CAP_VM_TSC_CONTROL 214 +#define KVM_CAP_VM_DISABLE_NX_HUGE_PAGES 215#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 08/11] KVM: x86/MMU: Allow NX huge pages to be disabled on a per-vm basis
Quoted 6 lines · Ben Gardon
In some cases, the NX hugepage mitigation for iTLB multihit is not needed for all guests on a host. Allow disabling the mitigation on a per-VM basis to avoid the performance hit of NX hugepages on trusted workloads.
Signed-off-by Ben Gardon <[email protected]>
Quoted 189 lines
--- Documentation/virt/kvm/api.rst | 11 +++++++++++ arch/x86/include/asm/kvm_host.h | 2 ++ arch/x86/kvm/mmu.h | 10 ++++++---- arch/x86/kvm/mmu/mmu.c | 2 +- arch/x86/kvm/mmu/spte.c | 7 ++++--- arch/x86/kvm/mmu/spte.h | 3 ++- arch/x86/kvm/mmu/tdp_mmu.c | 3 ++- arch/x86/kvm/x86.c | 6 ++++++ include/uapi/linux/kvm.h | 1 + 9 files changed, 35 insertions(+), 10 deletions(-)Documentation/virt/kvm/api.rst +11
-0@@ -7844,6 +7844,17 @@ At this time, KVM_PMU_CAP_DISABLE is the only capability. Setting this capability will disable PMU virtualization for that VM. Usermode should adjust CPUID leaf 0xA to reflect that the PMU is disabled. +8.36 KVM_CAP_VM_DISABLE_NX_HUGE_PAGES +--------------------------- + +:Capability KVM_CAP_PMU_CAPABILITY +:Architectures: x86 +:Type: vm + +This capability disables the NX huge pages mitigation for iTLB MULTIHIT. + +The capability has no effect if the nx_huge_pages module parameter is not set. + 9. Known KVM API problems =========================arch/x86/include/asm/kvm_host.h +2
-0@@ -1246,6 +1246,8 @@ struct kvm_arch {hpa_t hv_root_tdp;spinlock_t hv_root_tdp_lock;#endif + +bool disable_nx_huge_pages; };struct kvm_vm_stat {arch/x86/kvm/mmu.h +6
-4@@ -173,10 +173,12 @@ struct kvm_page_fault {int kvm_tdp_page_fault (struct kvm_vcpu *vcpu,struct kvm_page_fault *fault);extern int nx_huge_pages; -static inline bool is_nx_huge_page_enabled (void ) +static inline bool is_nx_huge_page_enabled (struct kvm *kvm) { -return READ_ONCE (nx_huge_pages); +return READ_ONCE (nx_huge_pages) && + !kvm->arch.disable_nx_huge_pages; } +void kvm_update_nx_huge_pages (struct kvm *kvm);static inline int kvm_mmu_do_page_fault (struct kvm_vcpu *vcpu,gpa_t cr2_or_gpa,u32 err,bool prefetch)@@ -191,8 +193,8 @@ static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, .user = err & PFERR_USER_MASK, .prefetch = prefetch, .is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault), - .nx_huge_page_workaround_enabled = is_nx_huge_page_enabled(), - + .nx_huge_page_workaround_enabled = + is_nx_huge_page_enabled(vcpu->kvm), .max_level = KVM_MAX_HUGEPAGE_LEVEL, .req_level = PG_LEVEL_4K, .goal_level = PG_LEVEL_4K,arch/x86/kvm/mmu/mmu.c +1
-1@@ -6202,7 +6202,7 @@ static void __set_nx_huge_pages(bool val) nx_huge_pages = itlb_multihit_kvm_mitigation = val; } -static void kvm_update_nx_huge_pages (struct kvm *kvm) +void kvm_update_nx_huge_pages (struct kvm *kvm) {mutex_lock (&kvm->slots_lock);kvm_mmu_zap_all_fast (kvm);arch/x86/kvm/mmu/spte.c +4
-3@@ -116,7 +116,7 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, spte |=spte_shadow_accessed_mask (spte);if (level >PG_LEVEL_4K && (pte_access &ACC_EXEC_MASK ) && -is_nx_huge_page_enabled ()) { +is_nx_huge_page_enabled (vcpu->kvm)) { pte_access &= ~ACC_EXEC_MASK ; }@@ -215,7 +215,8 @@ static u64 make_spte_executable(u64 spte)* This is used during huge page splitting to build the SPTEs that make up the * new page table. */ -u64 make_huge_page_split_spte (u64 huge_spte,int huge_level,int index) +u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,int huge_level, +int index) {u64 child_spte;int child_level;@@ -243,7 +244,7 @@ u64 make_huge_page_split_spte(u64 huge_spte, int huge_level, int index)* When splitting to a 4K page, mark the page executable as the * NX hugepage mitigation no longer applies. */ -if (is_nx_huge_page_enabled ()) +if (is_nx_huge_page_enabled (kvm)) child_spte =make_spte_executable (child_spte); }arch/x86/kvm/mmu/spte.h +2
-1@@ -415,7 +415,8 @@ bool make_spte(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp, unsigned int pte_access, gfn_t gfn, kvm_pfn_t pfn, u64 old_spte, bool prefetch, bool can_unsync, bool host_writable, u64 *new_spte); -u64 make_huge_page_split_spte (u64 huge_spte,int huge_level,int index); +u64 make_huge_page_split_spte (struct kvm *kvm,u64 huge_spte,int huge_level, +int index);u64 make_nonleaf_spte (u64 *child_pt,bool ad_disabled);u64 make_mmio_spte (struct kvm_vcpu *vcpu,u64 gfn,unsigned int access);u64 mark_spte_for_access_track (u64 spte);arch/x86/kvm/mmu/tdp_mmu.c +2
-1@@ -1469,7 +1469,8 @@ static int tdp_mmu_split_huge_page(struct kvm *kvm, struct tdp_iter *iter,* not been linked in yet and thus is not reachable from any other CPU. */ for (i =0 ; i <PT64_ENT_PER_PAGE ; i++) - sp->spt[i] =make_huge_page_split_spte (huge_spte, level, i); + sp->spt[i] =make_huge_page_split_spte (kvm, huge_spte, + level, i);/* * Replace the huge spte with a pointer to the populated lower level arch/x86/kvm/x86.c +6
-0@@ -4268,6 +4268,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_SYS_ATTRIBUTES :case KVM_CAP_VAPIC :case KVM_CAP_ENABLE_CAP : +case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES : r =1 ;break ;case KVM_CAP_EXIT_HYPERCALL :@@ -6061,6 +6062,11 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, }mutex_unlock (&kvm->lock);break ; +case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES : + kvm->arch.disable_nx_huge_pages = true; +kvm_update_nx_huge_pages (kvm); + r =0 ; +break ;default : r = -EINVAL ;break ;include/uapi/linux/kvm.h +1
-0@@ -1145,6 +1145,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_PMU_CAPABILITY 212#define KVM_CAP_DISABLE_QUIRKS2 213#define KVM_CAP_VM_TSC_CONTROL 214 +#define KVM_CAP_VM_DISABLE_NX_HUGE_PAGES 215#ifdef KVM_CAP_IRQ_ROUTING Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 9/11 KVM: x86: Fix errant brace in KVM capability handling
In reply to Ben GardonThe braces around the KVM_CAP_XSAVE2 block also surround the KVM_CAP_PMU_CAPABILITY block, likely the result of a merge issue. Simply move the curly brace back to where it belongs.
--- arch/x86/kvm/x86.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/x86.c +1 -1
@@ -4365,10 +4365,10 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)if (r <sizeof (struct kvm_xsave )) r =sizeof (struct kvm_xsave );break ; + }case KVM_CAP_PMU_CAPABILITY : r = enable_pmu ?KVM_CAP_PMU_VALID_MASK :0 ;break ; - }case KVM_CAP_DISABLE_QUIRKS2 : r =KVM_X86_VALID_QUIRKS ;break ;
Signature · 1 line
2.35.1.1021.g381101b075-goog
PATCH v3 10/11 KVM: x86/MMU: Require reboot permission to disable NX hugepages
In reply to Ben GardonEnsure that the userspace actor attempting to disable NX hugepages has permission to reboot the system. Since disabling NX hugepages would allow a guest to crash the system, it is similar to reboot permissions.
This approach is the simplest permission gating, but passing a file descriptor opened for write for the module parameter would also work well and be more precise.
The latter approach was suggested by Sean Christopherson.
--- Documentation/virt/kvm/api.rst | 2 ++ arch/x86/kvm/x86.c | 9 +++++++++ 2 files changed, 11 insertions(+)
Documentation/virt/kvm/api.rst +2 -0
@@ -7850,6 +7850,8 @@ should adjust CPUID leaf 0xA to reflect that the PMU is disabled. :Capability KVM_CAP_PMU_CAPABILITY :Architectures: x86 :Type: vm +:Returns 0 on success, -EPERM if the userspace process does not + have CAP_SYS_BOOT This capability disables the NX huge pages mitigation for iTLB MULTIHIT.
arch/x86/kvm/x86.c +9 -0
@@ -6063,6 +6063,15 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm,mutex_unlock (&kvm->lock);break ;case KVM_CAP_VM_DISABLE_NX_HUGE_PAGES : +/* +* Since the risk of disabling NX hugepages is a guest crashing +* the system, ensure the userspace process has permission to +* reboot the system. +*/ +if (!capable (CAP_SYS_BOOT )) { + r = -EPERM ; +break ; + } kvm->arch.disable_nx_huge_pages = true;kvm_update_nx_huge_pages (kvm); r =0 ;
Signature · 1 line
2.35.1.1021.g381101b075-goog
Sean Christopherson
maintainerRe: [PATCH v3 10/11] KVM: x86/MMU: Require reboot permission to disable NX hugepages
Quoted 3 lines · Ben Gardon
Ensure that the userspace actor attempting to disable NX hugepages has permission to reboot the system. Since disabling NX hugepages would allow a guest to crash the system, it is similar to reboot permissions.
This patch needs to be squashed with the patch that introduces the capability, otherwise you're introdcuing a bug and then fixing it in the same series.
Re: [PATCH v3 10/11] KVM: x86/MMU: Require reboot permission to disable NX hugepages
Quoted 8 lines · Sean Christopherson
Quoted 3 lines · Ben Gardon
Ensure that the userspace actor attempting to disable NX hugepages has permission to reboot the system. Since disabling NX hugepages would allow a guest to crash the system, it is similar to reboot permissions.
This patch needs to be squashed with the patch that introduces the capability, otherwise you're introdcuing a bug and then fixing it in the same series.
I'm happy to do that. I figured that leaving it as a separate patch would provide an easy way to separate the discussion on how to implement the new cap versus how to restrict it.
I don't know if I'd consider not having this patch a bug, especially since it can make testing kind of a pain, but I see your point.
PATCH v3 11/11 selftests: KVM: Test disabling NX hugepages on a VM
In reply to Ben GardonAdd an argument to the NX huge pages test to test disabling the feature on a VM using the new capability.
--- .../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 7 ++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 67 ++++++++++++++++--- .../kvm/x86_64/nx_huge_pages_test.sh | 2 +- 4 files changed, 66 insertions(+), 12 deletions(-)
tools/testing/selftests/kvm/include/kvm_util_base.h +2 -0
@@ -411,4 +411,6 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name);uint32_t guest_get_vcpuid (void ); +void vm_disable_nx_huge_pages (struct kvm_vm *vm); +#endif /* SELFTEST_KVM_UTIL_BASE_H */
tools/testing/selftests/kvm/lib/kvm_util.c +7 -0
@@ -2765,3 +2765,10 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name)return value; } +void vm_disable_nx_huge_pages (struct kvm_vm *vm) +{ +struct kvm_enable_cap cap = {0 }; + + cap.cap =KVM_CAP_VM_DISABLE_NX_HUGE_PAGES ; +vm_enable_cap (vm, &cap); +}
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +56 -11
116 lines not on this page · raw message
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh +1 -1
@@ -14,7 +14,7 @@ echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages -./nx_huge_pages_test +./nx_huge_pages_test "${@}" RET=$? echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages
Signature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 11/11] selftests: KVM: Test disabling NX hugepages on a VM
Quoted 51 lines · Ben Gardon
Add an argument to the NX huge pages test to test disabling the feature on a VM using the new capability.
Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 7 ++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 67 ++++++++++++++++--- .../kvm/x86_64/nx_huge_pages_test.sh | 2 +- 4 files changed, 66 insertions(+), 12 deletions(-)tools/testing/selftests/kvm/include/kvm_util_base.h +2
-0@@ -411,4 +411,6 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name);uint32_t guest_get_vcpuid (void ); +void vm_disable_nx_huge_pages (struct kvm_vm *vm); +#endif /* SELFTEST_KVM_UTIL_BASE_H */ tools/testing/selftests/kvm/lib/kvm_util.c +7
-0@@ -2765,3 +2765,10 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name)return value; } +void vm_disable_nx_huge_pages (struct kvm_vm *vm) +{ +struct kvm_enable_cap cap = {0 }; + + cap.cap =KVM_CAP_VM_DISABLE_NX_HUGE_PAGES ; +vm_enable_cap (vm, &cap); +}tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +2
-0@@ -13,6 +13,8 @@#include <fcntl.h> #include <stdint.h> #include <time.h> +#include <linux/reboot.h> +#include <sys/syscall.h> #include <test_util.h> #include "kvm_util.h"
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 67
Quoted 9 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +6
-0@@ -57,13 +59,56 @@ static void check_split_count(struct kvm_vm *vm, int expected_splits) expected_splits, actual_splits); } +static void help (void ) +{ +puts ("" ); +printf ("usage: nx_huge_pages_test.sh [-x]\n" ); +puts ("" ); +printf (" -x: Allow executable huge pages on the VM.\n" );
Making it a flag means we won't exercise it by default. Is there are reason to avoid exercising KVM_CAP_VM_DISABLE_NX_HUGE_PAGES by default?
Assuming no, I would recommend factoring out the test to a helper function that takes a parameter that tells it if nx_huge_pages is enabled or disabled. Then run this helper function multiple times. E.g. once with nx_huge_pages enabled, once with nx_huge_pages disabled via KVM_CAP_VM_DISABLE_NX_HUGE_PAGES. This would also then let you test that disabling via module param also works.
By the way, that brings up another issue. What if NX HugePages is not enabled on this host? e.g. we're running on AMD, or we're running on a non-affected Intel host, or we're running on a machine where nx huge pages has been disabled by the admin? The test should probably return KSFT_SKIP in those cases.
Quoted 30 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +23
-0+puts ("" ); +exit (0 ); +} +int main (int argc,char **argv) {struct kvm_vm *vm;struct timespec ts; +bool disable_nx = false; +int opt; +int r; + +while ((opt =getopt (argc, argv,"x" )) !=-1 ) { +switch (opt) { +case 'x' : + disable_nx = true; +break ; +case 'h' : +default : +help (); +break ; + } + } vm =vm_create (VM_MODE_DEFAULT ,DEFAULT_GUEST_PHY_PAGES ,O_RDWR ); +if (disable_nx) { +/* +* Check if this process has the reboot permissions needed to +* disable NX huge pages on a VM.
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 107
Quoted 10 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +10
-0+* +* The reboot call below will never have any effect because +* the magic values are not set correctly, however the +* permission check is done before the magic value check. +*/ + r =syscall (SYS_reboot,0 ,0 ,0 ,NULL ); +if (r == -EPERM ) +return KSFT_SKIP ; +TEST_ASSERT (r == -EINVAL , +"Reboot syscall should fail with -EINVAL" );
Just check if KVM_CAP_VM_DISABLE_NX_HUGE_PAGES returns -EPERM?
Quoted 78 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +15
-11+ +vm_disable_nx_huge_pages (vm); + } +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS_HUGETLB ,HPAGE_PADDR_START ,HPAGE_SLOT ,HPAGE_SLOT_NPAGES ,0 );@@ -83,21 +128,21 @@ int main(int argc, char **argv)* at 2M. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* * guest_code1 is in the same huge page as data1, so it will cause * that huge page to be remapped at 4k. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* Run guest_code0 again to check that is has no effect. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* * Give recovery thread time to run. The wrapper script sets @@ -110,7 +155,7 @@ int main(int argc, char **argv)/* * Now that the reclaimer has run, all the split pages should be gone. */ -check_2m_page_count (vm,1 ); +check_2m_page_count (vm, disable_nx ?4 :1 );check_split_count (vm,0 );/* @@ -118,13 +163,13 @@ int main(int argc, char **argv)* again to check that pages are mapped at 2M again. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* Pages are once again split from running guest_code1. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );kvm_vm_free (vm);tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh +1
-1@@ -14,7 +14,7 @@ echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages -./nx_huge_pages_test +./nx_huge_pages_test "${@}" RET=$? echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pagesSignature · 1 line
2.35.1.1021.g381101b075-goog
Re: [PATCH v3 11/11] selftests: KVM: Test disabling NX hugepages on a VM
Quoted 73 lines · David Matlack
Quoted 51 lines · Ben Gardon
Add an argument to the NX huge pages test to test disabling the feature on a VM using the new capability.
Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 7 ++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 67 ++++++++++++++++--- .../kvm/x86_64/nx_huge_pages_test.sh | 2 +- 4 files changed, 66 insertions(+), 12 deletions(-)tools/testing/selftests/kvm/include/kvm_util_base.h +2
-0@@ -411,4 +411,6 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name);uint32_t guest_get_vcpuid (void ); +void vm_disable_nx_huge_pages (struct kvm_vm *vm); +#endif /* SELFTEST_KVM_UTIL_BASE_H */ tools/testing/selftests/kvm/lib/kvm_util.c +7
-0@@ -2765,3 +2765,10 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name)return value; } +void vm_disable_nx_huge_pages (struct kvm_vm *vm) +{ +struct kvm_enable_cap cap = {0 }; + + cap.cap =KVM_CAP_VM_DISABLE_NX_HUGE_PAGES ; +vm_enable_cap (vm, &cap); +}tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +2
-0@@ -13,6 +13,8 @@#include <fcntl.h> #include <stdint.h> #include <time.h> +#include <linux/reboot.h> +#include <sys/syscall.h> #include <test_util.h> #include "kvm_util.h" tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 67
Quoted 9 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +6
-0@@ -57,13 +59,56 @@ static void check_split_count(struct kvm_vm *vm, int expected_splits) expected_splits, actual_splits); } +static void help (void ) +{ +puts ("" ); +printf ("usage: nx_huge_pages_test.sh [-x]\n" ); +puts ("" ); +printf (" -x: Allow executable huge pages on the VM.\n" );Making it a flag means we won't exercise it by default. Is there are reason to avoid exercising
KVM_CAP_VM_DISABLE_NX_HUGE_PAGESby default?Assuming no, I would recommend factoring out the test to a helper function that takes a parameter that tells it if
nx_huge_pagesis enabled or disabled. Then run this helper function multiple times. E.g. once withnx_huge_pagesenabled, once withnx_huge_pagesdisabled viaKVM_CAP_VM_DISABLE_NX_HUGE_PAGES. This would also then let you test that disabling via module param also works.
Quoted 5 lines
By the way, that brings up another issue. What if NX HugePages is not enabled on this host? e.g. we're running on AMD, or we're running on a non-affected Intel host, or we're running on a machine where nx huge pages has been disabled by the admin? The test should probably return
KSFT_SKIPin those cases.
That's all a good idea. Will do.
Quoted 122 lines
Quoted 31 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +23
-0+puts ("" ); +exit (0 ); +} +int main (int argc,char **argv) {struct kvm_vm *vm;struct timespec ts; +bool disable_nx = false; +int opt; +int r; + +while ((opt =getopt (argc, argv,"x" )) !=-1 ) { +switch (opt) { +case 'x' : + disable_nx = true; +break ; +case 'h' : +default : +help (); +break ; + } + } vm =vm_create (VM_MODE_DEFAULT ,DEFAULT_GUEST_PHY_PAGES ,O_RDWR ); +if (disable_nx) { +/* +* Check if this process has the reboot permissions needed to +* disable NX huge pages on a VM. tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 107
Quoted 10 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +10
-0+* +* The reboot call below will never have any effect because +* the magic values are not set correctly, however the +* permission check is done before the magic value check. +*/ + r =syscall (SYS_reboot,0 ,0 ,0 ,NULL ); +if (r == -EPERM ) +return KSFT_SKIP ; +TEST_ASSERT (r == -EINVAL , +"Reboot syscall should fail with -EINVAL" );Just check if
KVM_CAP_VM_DISABLE_NX_HUGE_PAGESreturns-EPERM?Quoted 78 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +15
-11+ +vm_disable_nx_huge_pages (vm); + } +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS_HUGETLB ,HPAGE_PADDR_START ,HPAGE_SLOT ,HPAGE_SLOT_NPAGES ,0 );@@ -83,21 +128,21 @@ int main(int argc, char **argv)* at 2M. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* * guest_code1 is in the same huge page as data1, so it will cause * that huge page to be remapped at 4k. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* Run guest_code0 again to check that is has no effect. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* * Give recovery thread time to run. The wrapper script sets @@ -110,7 +155,7 @@ int main(int argc, char **argv)/* * Now that the reclaimer has run, all the split pages should be gone. */ -check_2m_page_count (vm,1 ); +check_2m_page_count (vm, disable_nx ?4 :1 );check_split_count (vm,0 );/* @@ -118,13 +163,13 @@ int main(int argc, char **argv)* again to check that pages are mapped at 2M again. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* Pages are once again split from running guest_code1. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );kvm_vm_free (vm);tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh +1
-2@@ -14,7 +14,7 @@ echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages -./nx_huge_pages_test +./nx_huge_pages_test "${@}" RET=$? echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages --2.35.1.1021.g381101b075-goog
Re: [PATCH v3 11/11] selftests: KVM: Test disabling NX hugepages on a VM
Quoted 75 lines · Ben Gardon
Quoted 73 lines · David Matlack
Quoted 51 lines · Ben Gardon
Add an argument to the NX huge pages test to test disabling the feature on a VM using the new capability.
Signed-off-by Ben Gardon <[email protected]>--- .../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 7 ++ .../selftests/kvm/x86_64/nx_huge_pages_test.c | 67 ++++++++++++++++--- .../kvm/x86_64/nx_huge_pages_test.sh | 2 +- 4 files changed, 66 insertions(+), 12 deletions(-)tools/testing/selftests/kvm/include/kvm_util_base.h +2
-0@@ -411,4 +411,6 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name);uint32_t guest_get_vcpuid (void ); +void vm_disable_nx_huge_pages (struct kvm_vm *vm); +#endif /* SELFTEST_KVM_UTIL_BASE_H */ tools/testing/selftests/kvm/lib/kvm_util.c +7
-0@@ -2765,3 +2765,10 @@ uint64_t vm_get_single_stat(struct kvm_vm *vm, const char *stat_name)return value; } +void vm_disable_nx_huge_pages (struct kvm_vm *vm) +{ +struct kvm_enable_cap cap = {0 }; + + cap.cap =KVM_CAP_VM_DISABLE_NX_HUGE_PAGES ; +vm_enable_cap (vm, &cap); +}tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +2
-0@@ -13,6 +13,8 @@#include <fcntl.h> #include <stdint.h> #include <time.h> +#include <linux/reboot.h> +#include <sys/syscall.h> #include <test_util.h> #include "kvm_util.h" tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 67
Quoted 9 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +6
-0@@ -57,13 +59,56 @@ static void check_split_count(struct kvm_vm *vm, int expected_splits) expected_splits, actual_splits); } +static void help (void ) +{ +puts ("" ); +printf ("usage: nx_huge_pages_test.sh [-x]\n" ); +puts ("" ); +printf (" -x: Allow executable huge pages on the VM.\n" );Making it a flag means we won't exercise it by default. Is there are reason to avoid exercising
KVM_CAP_VM_DISABLE_NX_HUGE_PAGESby default?Assuming no, I would recommend factoring out the test to a helper function that takes a parameter that tells it if
nx_huge_pagesis enabled or disabled. Then run this helper function multiple times. E.g. once withnx_huge_pagesenabled, once withnx_huge_pagesdisabled viaKVM_CAP_VM_DISABLE_NX_HUGE_PAGES. This would also then let you test that disabling via module param also works.
Quoted 5 lines
Quoted 5 lines
By the way, that brings up another issue. What if NX HugePages is not enabled on this host? e.g. we're running on AMD, or we're running on a non-affected Intel host, or we're running on a machine where nx huge pages has been disabled by the admin? The test should probably return
KSFT_SKIPin those cases.
The wrapper script just always turns nx_huge_pages on, which I think is a better solution, but perhaps it should check for permission errors when doing that.
Quoted 46 lines
That's all a good idea. Will do.
Quoted 43 lines
Quoted 31 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +23
-0+puts ("" ); +exit (0 ); +} +int main (int argc,char **argv) {struct kvm_vm *vm;struct timespec ts; +bool disable_nx = false; +int opt; +int r; + +while ((opt =getopt (argc, argv,"x" )) !=-1 ) { +switch (opt) { +case 'x' : + disable_nx = true; +break ; +case 'h' : +default : +help (); +break ; + } + } vm =vm_create (VM_MODE_DEFAULT ,DEFAULT_GUEST_PHY_PAGES ,O_RDWR ); +if (disable_nx) { +/* +* Check if this process has the reboot permissions needed to +* disable NX huge pages on a VM. tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c static void check_split_count(struct kvm_vm *vm, int expected_splits) · line 107
Quoted 10 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +10
-0+* +* The reboot call below will never have any effect because +* the magic values are not set correctly, however the +* permission check is done before the magic value check. +*/ + r =syscall (SYS_reboot,0 ,0 ,0 ,NULL ); +if (r == -EPERM ) +return KSFT_SKIP ; +TEST_ASSERT (r == -EINVAL , +"Reboot syscall should fail with -EINVAL" );Just check if
KVM_CAP_VM_DISABLE_NX_HUGE_PAGESreturns-EPERM?
We could do that but then we wouldn't be checking that the permission checks work as expected.
Quoted 79 lines
Quoted 79 lines
Quoted 79 lines
tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.c +15
-11+ +vm_disable_nx_huge_pages (vm); + } +vm_userspace_mem_region_add (vm,VM_MEM_SRC_ANONYMOUS_HUGETLB ,HPAGE_PADDR_START ,HPAGE_SLOT ,HPAGE_SLOT_NPAGES ,0 );@@ -83,21 +128,21 @@ int main(int argc, char **argv)* at 2M. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* * guest_code1 is in the same huge page as data1, so it will cause * that huge page to be remapped at 4k. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* Run guest_code0 again to check that is has no effect. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );/* * Give recovery thread time to run. The wrapper script sets @@ -110,7 +155,7 @@ int main(int argc, char **argv)/* * Now that the reclaimer has run, all the split pages should be gone. */ -check_2m_page_count (vm,1 ); +check_2m_page_count (vm, disable_nx ?4 :1 );check_split_count (vm,0 );/* @@ -118,13 +163,13 @@ int main(int argc, char **argv)* again to check that pages are mapped at 2M again. */ run_guest_code (vm, guest_code0); -check_2m_page_count (vm,2 ); -check_split_count (vm,2 ); +check_2m_page_count (vm, disable_nx ?4 :2 ); +check_split_count (vm, disable_nx ?0 :2 );/* Pages are once again split from running guest_code1. */ run_guest_code (vm, guest_code1); -check_2m_page_count (vm,1 ); -check_split_count (vm,3 ); +check_2m_page_count (vm, disable_nx ?4 :1 ); +check_split_count (vm, disable_nx ?0 :3 );kvm_vm_free (vm);tools/testing/selftests/kvm/x86_64/nx_huge_pages_test.sh +1
-2@@ -14,7 +14,7 @@ echo 1 > /sys/module/kvm/parameters/nx_huge_pages_recovery_ratio echo 100 > /sys/module/kvm/parameters/nx_huge_pages_recovery_period_ms echo 200 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages -./nx_huge_pages_test +./nx_huge_pages_test "${@}" RET=$? echo $NX_HUGE_PAGES > /sys/module/kvm/parameters/nx_huge_pages --2.35.1.1021.g381101b075-goog