KVM: selftests: aarch64: Add dirty logging tests into page_fault_test

Add some dirty logging tests into page_fault_test. Mark the data and/or
page-table memory regions for dirty logging, perform some accesses, and
check that the dirty log bits are set or clean when expected.

Signed-off-by: Ricardo Koller <ricarkol@google.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20221017195834.2295901-13-ricarkol@google.com

diff --git a/tools/testing/selftests/kvm/aarch64/page_fault_test.c b/tools/testing/selftests/kvm/aarch64/page_fault_test.c
index 8ecc2ac8c476cb7423e031f584bca02b3d1649ec..a36001143aff5160c8e61f62a1415536a0d09bd0 100644 (file)
--- a/tools/testing/selftests/kvm/aarch64/page_fault_test.c
+++ b/tools/testing/selftests/kvm/aarch64/page_fault_test.c
@@ -31,6 +31,11 @@ static uint64_t *guest_test_memory = (uint64_t *)TEST_GVA;
 #define CMD_SKIP_TEST                          (1ULL << 1)
 #define CMD_HOLE_PT                            (1ULL << 2)
 #define CMD_HOLE_DATA                          (1ULL << 3)
+#define CMD_CHECK_WRITE_IN_DIRTY_LOG           (1ULL << 4)
+#define CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG                (1ULL << 5)
+#define CMD_CHECK_NO_WRITE_IN_DIRTY_LOG                (1ULL << 6)
+#define CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG     (1ULL << 7)
+#define CMD_SET_PTE_AF                         (1ULL << 8)
 
 #define PREPARE_FN_NR                          10
 #define CHECK_FN_NR                            10
@@ -213,6 +218,21 @@ static void guest_check_pte_af(void)
        GUEST_ASSERT_EQ(*((uint64_t *)TEST_PTE_GVA) & PTE_AF, PTE_AF);
 }
 
+static void guest_check_write_in_dirty_log(void)
+{
+       GUEST_SYNC(CMD_CHECK_WRITE_IN_DIRTY_LOG);
+}
+
+static void guest_check_no_write_in_dirty_log(void)
+{
+       GUEST_SYNC(CMD_CHECK_NO_WRITE_IN_DIRTY_LOG);
+}
+
+static void guest_check_s1ptw_wr_in_dirty_log(void)
+{
+       GUEST_SYNC(CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG);
+}
+
 static void guest_exec(void)
 {
        int (*code)(void) = (int (*)(void))TEST_EXEC_GVA;
@@ -395,6 +415,22 @@ static bool punch_hole_in_backing_store(struct kvm_vm *vm,
        return true;
 }
 
+static bool check_write_in_dirty_log(struct kvm_vm *vm,
+                                    struct userspace_mem_region *region,
+                                    uint64_t host_pg_nr)
+{
+       unsigned long *bmap;
+       bool first_page_dirty;
+       uint64_t size = region->region.memory_size;
+
+       /* getpage_size() is not always equal to vm->page_size */
+       bmap = bitmap_zalloc(size / getpagesize());
+       kvm_vm_get_dirty_log(vm, region->region.slot, bmap);
+       first_page_dirty = test_bit(host_pg_nr, bmap);
+       free(bmap);
+       return first_page_dirty;
+}
+
 /* Returns true to continue the test, and false if it should be skipped. */
 static bool handle_cmd(struct kvm_vm *vm, int cmd)
 {
@@ -411,6 +447,18 @@ static bool handle_cmd(struct kvm_vm *vm, int cmd)
                continue_test = punch_hole_in_backing_store(vm, pt_region);
        if (cmd & CMD_HOLE_DATA)
                continue_test = punch_hole_in_backing_store(vm, data_region);
+       if (cmd & CMD_CHECK_WRITE_IN_DIRTY_LOG)
+               TEST_ASSERT(check_write_in_dirty_log(vm, data_region, 0),
+                           "Missing write in dirty log");
+       if (cmd & CMD_CHECK_S1PTW_WR_IN_DIRTY_LOG)
+               TEST_ASSERT(check_write_in_dirty_log(vm, pt_region, 0),
+                           "Missing s1ptw write in dirty log");
+       if (cmd & CMD_CHECK_NO_WRITE_IN_DIRTY_LOG)
+               TEST_ASSERT(!check_write_in_dirty_log(vm, data_region, 0),
+                           "Unexpected write in dirty log");
+       if (cmd & CMD_CHECK_NO_S1PTW_WR_IN_DIRTY_LOG)
+               TEST_ASSERT(!check_write_in_dirty_log(vm, pt_region, 0),
+                           "Unexpected s1ptw write in dirty log");
 
        return continue_test;
 }
@@ -673,6 +721,19 @@ static void help(char *name)
        .expected_events        = { .uffd_faults = _uffd_faults, },             \
 }
 
+#define TEST_DIRTY_LOG(_access, _with_af, _test_check)                         \
+{                                                                              \
+       .name                   = SCAT3(dirty_log, _access, _with_af),          \
+       .data_memslot_flags     = KVM_MEM_LOG_DIRTY_PAGES,                      \
+       .pt_memslot_flags       = KVM_MEM_LOG_DIRTY_PAGES,                      \
+       .guest_prepare          = { _PREPARE(_with_af),                         \
+                                   _PREPARE(_access) },                        \
+       .guest_test             = _access,                                      \
+       .guest_test_check       = { _CHECK(_with_af), _test_check,              \
+                                   guest_check_s1ptw_wr_in_dirty_log},         \
+       .expected_events        = { 0 },                                        \
+}
+
 static struct test_desc tests[] = {
 
        /* Check that HW is setting the Access Flag (AF) (sanity checks). */
@@ -732,6 +793,21 @@ static struct test_desc tests[] = {
        TEST_UFFD(guest_exec, with_af, CMD_HOLE_DATA | CMD_HOLE_PT,
                  uffd_data_read_handler, uffd_pt_write_handler, 2),
 
+       /*
+        * Try accesses when the data and PT memory regions are both
+        * tracked for dirty logging.
+        */
+       TEST_DIRTY_LOG(guest_read64, with_af, guest_check_no_write_in_dirty_log),
+       /* no_af should also lead to a PT write. */
+       TEST_DIRTY_LOG(guest_read64, no_af, guest_check_no_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_ld_preidx, with_af, guest_check_no_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_at, no_af, guest_check_no_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_exec, with_af, guest_check_no_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_write64, with_af, guest_check_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_cas, with_af, guest_check_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_dc_zva, with_af, guest_check_write_in_dirty_log),
+       TEST_DIRTY_LOG(guest_st_preidx, with_af, guest_check_write_in_dirty_log),
+
        { 0 }
 };