| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Tue, 18 Oct 2022 08:46:11 +0800
From: Gavin Shan <gshan@...hat.com>
To: "Maciej S. Szmigiero" <mail@...iej.szmigiero.name>
Cc: kvmarm@...ts.cs.columbia.edu, kvm@...r.kernel.org,
linux-kernel@...r.kernel.org, ajones@...tanamicro.com,
pbonzini@...hat.com, maz@...nel.org, shuah@...nel.org,
oliver.upton@...ux.dev, seanjc@...gle.com, peterx@...hat.com,
ricarkol@...gle.com, zhenyzha@...hat.com, shan.gavin@...il.com,
kvmarm@...ts.linux.dev
Subject: Re: [PATCH 4/6] KVM: selftests: memslot_perf_test: Support variable
guest page size
On 10/18/22 5:31 AM, Maciej S. Szmigiero wrote:
> On 14.10.2022 09:19, Gavin Shan wrote:
>> The test case is obviously broken on aarch64 because non-4KB guest
>> page size is supported. The guest page size on aarch64 could be 4KB,
>> 16KB or 64KB.
>>
>> This supports variable guest page size, mostly for aarch64.
>>
>> - The host determines the guest page size when virtual machine is
>> created. The value is also passed to guest through the synchronization
>> area.
>>
>> - The number of guest pages are unknown until the virtual machine
>> is to be created. So all the related macros are dropped. Instead,
>> their values are dynamically calculated based on the guest page
>> size.
>>
>> - The static checks on memory sizes and pages becomes dependent
>> on guest page size, which is unknown until the virtual machine
>> is about to be created. So all the static checks are converted
>> to dynamic checks, done in check_memory_sizes().
>>
>> - As the address passed to madvise() should be aligned to host page,
>> the size of page chunk is automatically selected, other than one
>> page.
>>
>> - All other changes included in this patch are almost mechanical
>> replacing '4096' with 'guest_page_size'.
>>
>> Signed-off-by: Gavin Shan <gshan@...hat.com>
>> ---
>> .../testing/selftests/kvm/memslot_perf_test.c | 191 +++++++++++-------
>> 1 file changed, 115 insertions(+), 76 deletions(-)
>>
>> diff --git a/tools/testing/selftests/kvm/memslot_perf_test.c b/tools/testing/selftests/kvm/memslot_perf_test.c
>> index d5aa9148f96f..d587bd952ff9 100644
>> --- a/tools/testing/selftests/kvm/memslot_perf_test.c
>> +++ b/tools/testing/selftests/kvm/memslot_perf_test.c
>> @@ -26,14 +26,11 @@
>> #include <processor.h>
>> #define MEM_SIZE ((512U << 20) + 4096)
>> -#define MEM_SIZE_PAGES (MEM_SIZE / 4096)
>> #define MEM_GPA 0x10000000UL
>> #define MEM_AUX_GPA MEM_GPA
>> #define MEM_SYNC_GPA MEM_AUX_GPA
>> #define MEM_TEST_GPA (MEM_AUX_GPA + 4096)
>> #define MEM_TEST_SIZE (MEM_SIZE - 4096)
>> -static_assert(MEM_SIZE % 4096 == 0, "invalid mem size");
>> -static_assert(MEM_TEST_SIZE % 4096 == 0, "invalid mem test size");
>> /*
>> * 32 MiB is max size that gets well over 100 iterations on 509 slots.
>> @@ -42,29 +39,16 @@ static_assert(MEM_TEST_SIZE % 4096 == 0, "invalid mem test size");
>> * limited resolution).
>> */
>> #define MEM_SIZE_MAP ((32U << 20) + 4096)
>> -#define MEM_SIZE_MAP_PAGES (MEM_SIZE_MAP / 4096)
>> #define MEM_TEST_MAP_SIZE (MEM_SIZE_MAP - 4096)
>> -#define MEM_TEST_MAP_SIZE_PAGES (MEM_TEST_MAP_SIZE / 4096)
>> -static_assert(MEM_SIZE_MAP % 4096 == 0, "invalid map test region size");
>> -static_assert(MEM_TEST_MAP_SIZE % 4096 == 0, "invalid map test region size");
>> -static_assert(MEM_TEST_MAP_SIZE_PAGES % 2 == 0, "invalid map test region size");
>> -static_assert(MEM_TEST_MAP_SIZE_PAGES > 2, "invalid map test region size");
>> /*
>> * 128 MiB is min size that fills 32k slots with at least one page in each
>> * while at the same time gets 100+ iterations in such test
>> + *
>> + * 2 MiB chunk size like a typical huge page
>> */
>> #define MEM_TEST_UNMAP_SIZE (128U << 20)
>> -#define MEM_TEST_UNMAP_SIZE_PAGES (MEM_TEST_UNMAP_SIZE / 4096)
>> -/* 2 MiB chunk size like a typical huge page */
>> -#define MEM_TEST_UNMAP_CHUNK_PAGES (2U << (20 - 12))
>> -static_assert(MEM_TEST_UNMAP_SIZE <= MEM_TEST_SIZE,
>> - "invalid unmap test region size");
>> -static_assert(MEM_TEST_UNMAP_SIZE % 4096 == 0,
>> - "invalid unmap test region size");
>> -static_assert(MEM_TEST_UNMAP_SIZE_PAGES %
>> - (2 * MEM_TEST_UNMAP_CHUNK_PAGES) == 0,
>> - "invalid unmap test region size");
>> +#define MEM_TEST_UNMAP_CHUNK_SIZE (2U << 20)
>> /*
>> * For the move active test the middle of the test area is placed on
>> @@ -77,8 +61,7 @@ static_assert(MEM_TEST_UNMAP_SIZE_PAGES %
>> * for the total size of 25 pages.
>> * Hence, the maximum size here is 50 pages.
>> */
>> -#define MEM_TEST_MOVE_SIZE_PAGES (50)
>> -#define MEM_TEST_MOVE_SIZE (MEM_TEST_MOVE_SIZE_PAGES * 4096)
>> +#define MEM_TEST_MOVE_SIZE 0x32000
>
> The above number seems less readable than an explicit value of 50 pages.
>
> In addition to that, it's 50 pages only with 4k page size, so at least
> the comment above needs to be updated to reflect this fact.
>
Yeah, I will change the comments like below in next revision.
/*
* When running this test with 32k memslots, actually 32763 excluding
* the reserved memory slot 0, the memory for each slot is 0x4000 bytes.
* The last slot contains 0x19000 bytes memory. Hence, the maximum size
* here is 0x32000 bytes.
*/
>> #define MEM_TEST_MOVE_GPA_DEST (MEM_GPA + MEM_SIZE)
>> static_assert(MEM_TEST_MOVE_SIZE <= MEM_TEST_SIZE,
>> "invalid move test region size");
> (...)
>> @@ -242,33 +229,34 @@ static struct vm_data *alloc_vm(void)
>> }
>> static bool prepare_vm(struct vm_data *data, int nslots, uint64_t *maxslots,
>> - void *guest_code, uint64_t mempages,
>> + void *guest_code, uint64_t mem_size,
>> struct timespec *slot_runtime)
>> {
>> - uint64_t rempages;
>> + uint64_t mempages, rempages;
>> uint64_t guest_addr;
>> - uint32_t slot;
>> + uint32_t slot, guest_page_size;
>> struct timespec tstart;
>> struct sync_area *sync;
>> - TEST_ASSERT(mempages > 1,
>> - "Can't test without any memory");
>> + guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;
>> + mempages = mem_size / guest_page_size;
>> +
>> + data->vm = __vm_create_with_one_vcpu(&data->vcpu, mempages, guest_code);
>> + ucall_init(data->vm, NULL);
>>
>
> TEST_ASSERT(data->vm->page_size == guest_page_size, "Invalid VM page size")
> here would catch the case if someone accidentally modifies
> __vm_create_with_one_vcpu() to use other page size than specified for
> VM_MODE_DEFAULT.
>
Sure, it's not harmful at least.
>> data->npages = mempages;
>> + TEST_ASSERT(data->npages > 1, "Can't test without any memory");
>> data->nslots = nslots;
>> - data->pages_per_slot = mempages / data->nslots;
>> + data->pages_per_slot = data->npages / data->nslots;
>> if (!data->pages_per_slot) {
>> - *maxslots = mempages + 1;
>> + *maxslots = data->npages + 1;
>> return false;
>> }
>> - rempages = mempages % data->nslots;
>> + rempages = data->npages % data->nslots;
>> data->hva_slots = malloc(sizeof(*data->hva_slots) * data->nslots);
>> TEST_ASSERT(data->hva_slots, "malloc() fail");
>> - data->vm = __vm_create_with_one_vcpu(&data->vcpu, mempages, guest_code);
>> - ucall_init(data->vm, NULL);
>> -
>> pr_info_v("Adding slots 1..%i, each slot with %"PRIu64" pages + %"PRIu64" extra pages last\n",
>> data->nslots, data->pages_per_slot, rempages);
> (...)
>> @@ -856,6 +863,35 @@ static void help(char *name, struct test_args *targs)
>> pr_info("%d: %s\n", ctr, tests[ctr].name);
>> }
>> +static bool check_memory_sizes(void)
>> +{
>> + uint32_t guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;
>> +
>> + if (MEM_SIZE % guest_page_size ||
>> + MEM_TEST_SIZE % guest_page_size) {
>> + pr_info("invalid MEM_SIZE or MEM_TEST_SIZE\n");
>> + return false;
>> + }
>> +
>> + if (MEM_SIZE_MAP % guest_page_size ||
>> + MEM_TEST_MAP_SIZE % guest_page_size ||
>> + (MEM_TEST_MAP_SIZE / guest_page_size) <= 2 ||
>> + (MEM_TEST_MAP_SIZE / guest_page_size) % 2) {
>> + pr_info("invalid MEM_SIZE_MAP or MEM_TEST_MAP_SIZE\n");
>> + return false;
>> + }
>> +
>> + if (MEM_TEST_UNMAP_SIZE > MEM_TEST_SIZE ||
>> + MEM_TEST_UNMAP_SIZE % guest_page_size ||
>> + (MEM_TEST_UNMAP_SIZE / guest_page_size) %
>> + (MEM_TEST_UNMAP_CHUNK_SIZE / guest_page_size)) {
>
> This should be (MEM_TEST_UNMAP_SIZE / guest_page_size) % (2 * MEM_TEST_UNMAP_CHUNK_SIZE / guest_page_size))
> to match the old static_assert().
>
Nice catch! I will fix it up in next revision :)
Thanks,
Gavin
Powered by blists - more mailing lists