KVM: selftests: memslot_perf_test: Report optimal memory slots

The memory area in each slot should be aligned to host page size.
Otherwise, the test will fail. For example, the following command
fails with the following messages with 64KB-page-size-host and
4KB-pae-size-guest. It's not user friendly to abort the test.
Lets do something to report the optimal memory slots, instead of
failing the test.

  # ./memslot_perf_test -v -s 1000
  Number of memory slots: 999
  Testing map performance with 1 runs, 5 seconds each
  Adding slots 1..999, each slot with 8 pages + 216 extra pages last
  ==== Test Assertion Failure ====
    lib/kvm_util.c:824: vm_adjust_num_guest_pages(vm->mode, npages) == npages
    pid=19872 tid=19872 errno=0 - Success
       1  0x00000000004065b3: vm_userspace_mem_region_add at kvm_util.c:822
       2  0x0000000000401d6b: prepare_vm at memslot_perf_test.c:273
       3  (inlined by) test_execute at memslot_perf_test.c:756
       4  (inlined by) test_loop at memslot_perf_test.c:994
       5  (inlined by) main at memslot_perf_test.c:1073
       6  0x0000ffff7ebb4383: ?? ??:0
       7  0x00000000004021ff: _start at :?
    Number of guest pages is not compatible with the host. Try npages=16

Report the optimal memory slots instead of failing the test when
the memory area in each slot isn't aligned to host page size. With
this applied, the optimal memory slots is reported.

  # ./memslot_perf_test -v -s 1000
  Number of memory slots: 999
  Testing map performance with 1 runs, 5 seconds each
  Memslot count too high for this test, decrease the cap (max is 514)

Signed-off-by: Gavin Shan <gshan@redhat.com>
Reviewed-by: Maciej S. Szmigiero <maciej.szmigiero@oracle.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20221020071209.559062-7-gshan@redhat.com

diff --git a/tools/testing/selftests/kvm/memslot_perf_test.c b/tools/testing/selftests/kvm/memslot_perf_test.c
index daebc264de5adc9fcfcb9f4210cdfffd15235af7..2ad40f7c9c08e4ec2b05196e03174e749d48e788 100644 (file)
--- a/tools/testing/selftests/kvm/memslot_perf_test.c
+++ b/tools/testing/selftests/kvm/memslot_perf_test.c
@@ -239,16 +239,52 @@ static struct vm_data *alloc_vm(void)
        return data;
 }
 
+static bool check_slot_pages(uint32_t host_page_size, uint32_t guest_page_size,
+                            uint64_t pages_per_slot, uint64_t rempages)
+{
+       if (!pages_per_slot)
+               return false;
+
+       if ((pages_per_slot * guest_page_size) % host_page_size)
+               return false;
+
+       if ((rempages * guest_page_size) % host_page_size)
+               return false;
+
+       return true;
+}
+
+
+static uint64_t get_max_slots(struct vm_data *data, uint32_t host_page_size)
+{
+       uint32_t guest_page_size = data->vm->page_size;
+       uint64_t mempages, pages_per_slot, rempages;
+       uint64_t slots;
+
+       mempages = data->npages;
+       slots = data->nslots;
+       while (--slots > 1) {
+               pages_per_slot = mempages / slots;
+               rempages = mempages % pages_per_slot;
+               if (check_slot_pages(host_page_size, guest_page_size,
+                                    pages_per_slot, rempages))
+                       return slots + 1;       /* slot 0 is reserved */
+       }
+
+       return 0;
+}
+
 static bool prepare_vm(struct vm_data *data, int nslots, uint64_t *maxslots,
                       void *guest_code, uint64_t mem_size,
                       struct timespec *slot_runtime)
 {
        uint64_t mempages, rempages;
        uint64_t guest_addr;
-       uint32_t slot, guest_page_size;
+       uint32_t slot, host_page_size, guest_page_size;
        struct timespec tstart;
        struct sync_area *sync;
 
+       host_page_size = getpagesize();
        guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;
        mempages = mem_size / guest_page_size;
 
@@ -260,12 +296,13 @@ static bool prepare_vm(struct vm_data *data, int nslots, uint64_t *maxslots,
        TEST_ASSERT(data->npages > 1, "Can't test without any memory");
        data->nslots = nslots;
        data->pages_per_slot = data->npages / data->nslots;
-       if (!data->pages_per_slot) {
-               *maxslots = data->npages + 1;
+       rempages = data->npages % data->nslots;
+       if (!check_slot_pages(host_page_size, guest_page_size,
+                             data->pages_per_slot, rempages)) {
+               *maxslots = get_max_slots(data, host_page_size);
                return false;
        }
 
-       rempages = data->npages % data->nslots;
        data->hva_slots = malloc(sizeof(*data->hva_slots) * data->nslots);
        TEST_ASSERT(data->hva_slots, "malloc() fail");