tools/testing/selftests/kvm/dirty_log_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * KVM dirty page logging test
   4  *
   5  * Copyright (C) 2018, Red Hat, Inc.
   6  */
   7
   8 #define _GNU_SOURCE /* for program_invocation_name */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include <pthread.h>
  15 #include <linux/bitmap.h>
  16 #include <linux/bitops.h>
  17
  18 #include "test_util.h"
  19 #include "kvm_util.h"
  20 #include "processor.h"
  21
  22 #define VCPU_ID                         1
  23
  24 /* The memory slot index to track dirty pages */
  25 #define TEST_MEM_SLOT_INDEX             1
  26
  27 /* Default guest test virtual memory offset */
  28 #define DEFAULT_GUEST_TEST_MEM          0xc0000000
  29
  30 /* How many pages to dirty for each guest loop */
  31 #define TEST_PAGES_PER_LOOP             1024
  32
  33 /* How many host loops to run (one KVM_GET_DIRTY_LOG for each loop) */
  34 #define TEST_HOST_LOOP_N                32UL
  35
  36 /* Interval for each host loop (ms) */
  37 #define TEST_HOST_LOOP_INTERVAL         10UL
  38
  39 /* Dirty bitmaps are always little endian, so we need to swap on big endian */
  40 #if defined(__s390x__)
  41 # define BITOP_LE_SWIZZLE       ((BITS_PER_LONG-1) & ~0x7)
  42 # define test_bit_le(nr, addr) \
  43         test_bit((nr) ^ BITOP_LE_SWIZZLE, addr)
  44 # define set_bit_le(nr, addr) \
  45         set_bit((nr) ^ BITOP_LE_SWIZZLE, addr)
  46 # define clear_bit_le(nr, addr) \
  47         clear_bit((nr) ^ BITOP_LE_SWIZZLE, addr)
  48 # define test_and_set_bit_le(nr, addr) \
  49         test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, addr)
  50 # define test_and_clear_bit_le(nr, addr) \
  51         test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, addr)
  52 #else
  53 # define test_bit_le            test_bit
  54 # define set_bit_le             set_bit
  55 # define clear_bit_le           clear_bit
  56 # define test_and_set_bit_le    test_and_set_bit
  57 # define test_and_clear_bit_le  test_and_clear_bit
  58 #endif
  59
  60 /*
  61  * Guest/Host shared variables. Ensure addr_gva2hva() and/or
  62  * sync_global_to/from_guest() are used when accessing from
  63  * the host. READ/WRITE_ONCE() should also be used with anything
  64  * that may change.
  65  */
  66 static uint64_t host_page_size;
  67 static uint64_t guest_page_size;
  68 static uint64_t guest_num_pages;
  69 static uint64_t random_array[TEST_PAGES_PER_LOOP];
  70 static uint64_t iteration;
  71
  72 /*
  73  * Guest physical memory offset of the testing memory slot.
  74  * This will be set to the topmost valid physical address minus
  75  * the test memory size.
  76  */
  77 static uint64_t guest_test_phys_mem;
  78
  79 /*
  80  * Guest virtual memory offset of the testing memory slot.
  81  * Must not conflict with identity mapped test code.
  82  */
  83 static uint64_t guest_test_virt_mem = DEFAULT_GUEST_TEST_MEM;
  84
  85 /*
  86  * Continuously write to the first 8 bytes of a random pages within
  87  * the testing memory region.
  88  */
  89 static void guest_code(void)
  90 {
  91         uint64_t addr;
  92         int i;
  93
  94         /*
  95          * On s390x, all pages of a 1M segment are initially marked as dirty
  96          * when a page of the segment is written to for the very first time.
  97          * To compensate this specialty in this test, we need to touch all
  98          * pages during the first iteration.
  99          */
 100         for (i = 0; i < guest_num_pages; i++) {
 101                 addr = guest_test_virt_mem + i * guest_page_size;
 102                 *(uint64_t *)addr = READ_ONCE(iteration);
 103         }
 104
 105         while (true) {
 106                 for (i = 0; i < TEST_PAGES_PER_LOOP; i++) {
 107                         addr = guest_test_virt_mem;
 108                         addr += (READ_ONCE(random_array[i]) % guest_num_pages)
 109                                 * guest_page_size;
 110                         addr &= ~(host_page_size - 1);
 111                         *(uint64_t *)addr = READ_ONCE(iteration);
 112                 }
 113
 114                 /* Tell the host that we need more random numbers */
 115                 GUEST_SYNC(1);
 116         }
 117 }
 118
 119 /* Host variables */
 120 static bool host_quit;
 121
 122 /* Points to the test VM memory region on which we track dirty logs */
 123 static void *host_test_mem;
 124 static uint64_t host_num_pages;
 125
 126 /* For statistics only */
 127 static uint64_t host_dirty_count;
 128 static uint64_t host_clear_count;
 129 static uint64_t host_track_next_count;
 130
 131 enum log_mode_t {
 132         /* Only use KVM_GET_DIRTY_LOG for logging */
 133         LOG_MODE_DIRTY_LOG = 0,
 134
 135         /* Use both KVM_[GET|CLEAR]_DIRTY_LOG for logging */
 136         LOG_MODE_CLEAR_LOG = 1,
 137
 138         LOG_MODE_NUM,
 139
 140         /* Run all supported modes */
 141         LOG_MODE_ALL = LOG_MODE_NUM,
 142 };
 143
 144 /* Mode of logging to test.  Default is to run all supported modes */
 145 static enum log_mode_t host_log_mode_option = LOG_MODE_ALL;
 146 /* Logging mode for current run */
 147 static enum log_mode_t host_log_mode;
 148
 149 static bool clear_log_supported(void)
 150 {
 151         return kvm_check_cap(KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
 152 }
 153
 154 static void clear_log_create_vm_done(struct kvm_vm *vm)
 155 {
 156         struct kvm_enable_cap cap = {};
 157         u64 manual_caps;
 158
 159         manual_caps = kvm_check_cap(KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
 160         TEST_ASSERT(manual_caps, "MANUAL_CAPS is zero!");
 161         manual_caps &= (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE |
 162                         KVM_DIRTY_LOG_INITIALLY_SET);
 163         cap.cap = KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2;
 164         cap.args[0] = manual_caps;
 165         vm_enable_cap(vm, &cap);
 166 }
 167
 168 static void dirty_log_collect_dirty_pages(struct kvm_vm *vm, int slot,
 169                                           void *bitmap, uint32_t num_pages)
 170 {
 171         kvm_vm_get_dirty_log(vm, slot, bitmap);
 172 }
 173
 174 static void clear_log_collect_dirty_pages(struct kvm_vm *vm, int slot,
 175                                           void *bitmap, uint32_t num_pages)
 176 {
 177         kvm_vm_get_dirty_log(vm, slot, bitmap);
 178         kvm_vm_clear_dirty_log(vm, slot, bitmap, 0, num_pages);
 179 }
 180
 181 struct log_mode {
 182         const char *name;
 183         /* Return true if this mode is supported, otherwise false */
 184         bool (*supported)(void);
 185         /* Hook when the vm creation is done (before vcpu creation) */
 186         void (*create_vm_done)(struct kvm_vm *vm);
 187         /* Hook to collect the dirty pages into the bitmap provided */
 188         void (*collect_dirty_pages) (struct kvm_vm *vm, int slot,
 189                                      void *bitmap, uint32_t num_pages);
 190 } log_modes[LOG_MODE_NUM] = {
 191         {
 192                 .name = "dirty-log",
 193                 .collect_dirty_pages = dirty_log_collect_dirty_pages,
 194         },
 195         {
 196                 .name = "clear-log",
 197                 .supported = clear_log_supported,
 198                 .create_vm_done = clear_log_create_vm_done,
 199                 .collect_dirty_pages = clear_log_collect_dirty_pages,
 200         },
 201 };
 202
 203 /*
 204  * We use this bitmap to track some pages that should have its dirty
 205  * bit set in the _next_ iteration.  For example, if we detected the
 206  * page value changed to current iteration but at the same time the
 207  * page bit is cleared in the latest bitmap, then the system must
 208  * report that write in the next get dirty log call.
 209  */
 210 static unsigned long *host_bmap_track;
 211
 212 static void log_modes_dump(void)
 213 {
 214         int i;
 215
 216         printf("all");
 217         for (i = 0; i < LOG_MODE_NUM; i++)
 218                 printf(", %s", log_modes[i].name);
 219         printf("\n");
 220 }
 221
 222 static bool log_mode_supported(void)
 223 {
 224         struct log_mode *mode = &log_modes[host_log_mode];
 225
 226         if (mode->supported)
 227                 return mode->supported();
 228
 229         return true;
 230 }
 231
 232 static void log_mode_create_vm_done(struct kvm_vm *vm)
 233 {
 234         struct log_mode *mode = &log_modes[host_log_mode];
 235
 236         if (mode->create_vm_done)
 237                 mode->create_vm_done(vm);
 238 }
 239
 240 static void log_mode_collect_dirty_pages(struct kvm_vm *vm, int slot,
 241                                          void *bitmap, uint32_t num_pages)
 242 {
 243         struct log_mode *mode = &log_modes[host_log_mode];
 244
 245         TEST_ASSERT(mode->collect_dirty_pages != NULL,
 246                     "collect_dirty_pages() is required for any log mode!");
 247         mode->collect_dirty_pages(vm, slot, bitmap, num_pages);
 248 }
 249
 250 static void generate_random_array(uint64_t *guest_array, uint64_t size)
 251 {
 252         uint64_t i;
 253
 254         for (i = 0; i < size; i++)
 255                 guest_array[i] = random();
 256 }
 257
 258 static void *vcpu_worker(void *data)
 259 {
 260         int ret;
 261         struct kvm_vm *vm = data;
 262         uint64_t *guest_array;
 263         uint64_t pages_count = 0;
 264         struct kvm_run *run;
 265
 266         run = vcpu_state(vm, VCPU_ID);
 267
 268         guest_array = addr_gva2hva(vm, (vm_vaddr_t)random_array);
 269         generate_random_array(guest_array, TEST_PAGES_PER_LOOP);
 270
 271         while (!READ_ONCE(host_quit)) {
 272                 /* Let the guest dirty the random pages */
 273                 ret = _vcpu_run(vm, VCPU_ID);
 274                 TEST_ASSERT(ret == 0, "vcpu_run failed: %d\n", ret);
 275                 if (get_ucall(vm, VCPU_ID, NULL) == UCALL_SYNC) {
 276                         pages_count += TEST_PAGES_PER_LOOP;
 277                         generate_random_array(guest_array, TEST_PAGES_PER_LOOP);
 278                 } else {
 279                         TEST_FAIL("Invalid guest sync status: "
 280                                   "exit_reason=%s\n",
 281                                   exit_reason_str(run->exit_reason));
 282                 }
 283         }
 284
 285         pr_info("Dirtied %"PRIu64" pages\n", pages_count);
 286
 287         return NULL;
 288 }
 289
 290 static void vm_dirty_log_verify(enum vm_guest_mode mode, unsigned long *bmap)
 291 {
 292         uint64_t step = vm_num_host_pages(mode, 1);
 293         uint64_t page;
 294         uint64_t *value_ptr;
 295
 296         for (page = 0; page < host_num_pages; page += step) {
 297                 value_ptr = host_test_mem + page * host_page_size;
 298
 299                 /* If this is a special page that we were tracking... */
 300                 if (test_and_clear_bit_le(page, host_bmap_track)) {
 301                         host_track_next_count++;
 302                         TEST_ASSERT(test_bit_le(page, bmap),
 303                                     "Page %"PRIu64" should have its dirty bit "
 304                                     "set in this iteration but it is missing",
 305                                     page);
 306                 }
 307
 308                 if (test_and_clear_bit_le(page, bmap)) {
 309                         host_dirty_count++;
 310                         /*
 311                          * If the bit is set, the value written onto
 312                          * the corresponding page should be either the
 313                          * previous iteration number or the current one.
 314                          */
 315                         TEST_ASSERT(*value_ptr == iteration ||
 316                                     *value_ptr == iteration - 1,
 317                                     "Set page %"PRIu64" value %"PRIu64
 318                                     " incorrect (iteration=%"PRIu64")",
 319                                     page, *value_ptr, iteration);
 320                 } else {
 321                         host_clear_count++;
 322                         /*
 323                          * If cleared, the value written can be any
 324                          * value smaller or equals to the iteration
 325                          * number.  Note that the value can be exactly
 326                          * (iteration-1) if that write can happen
 327                          * like this:
 328                          *
 329                          * (1) increase loop count to "iteration-1"
 330                          * (2) write to page P happens (with value
 331                          *     "iteration-1")
 332                          * (3) get dirty log for "iteration-1"; we'll
 333                          *     see that page P bit is set (dirtied),
 334                          *     and not set the bit in host_bmap_track
 335                          * (4) increase loop count to "iteration"
 336                          *     (which is current iteration)
 337                          * (5) get dirty log for current iteration,
 338                          *     we'll see that page P is cleared, with
 339                          *     value "iteration-1".
 340                          */
 341                         TEST_ASSERT(*value_ptr <= iteration,
 342                                     "Clear page %"PRIu64" value %"PRIu64
 343                                     " incorrect (iteration=%"PRIu64")",
 344                                     page, *value_ptr, iteration);
 345                         if (*value_ptr == iteration) {
 346                                 /*
 347                                  * This page is _just_ modified; it
 348                                  * should report its dirtyness in the
 349                                  * next run
 350                                  */
 351                                 set_bit_le(page, host_bmap_track);
 352                         }
 353                 }
 354         }
 355 }
 356
 357 static struct kvm_vm *create_vm(enum vm_guest_mode mode, uint32_t vcpuid,
 358                                 uint64_t extra_mem_pages, void *guest_code)
 359 {
 360         struct kvm_vm *vm;
 361         uint64_t extra_pg_pages = extra_mem_pages / 512 * 2;
 362
 363         pr_info("Testing guest mode: %s\n", vm_guest_mode_string(mode));
 364
 365         vm = vm_create(mode, DEFAULT_GUEST_PHY_PAGES + extra_pg_pages, O_RDWR);
 366         kvm_vm_elf_load(vm, program_invocation_name, 0, 0);
 367 #ifdef __x86_64__
 368         vm_create_irqchip(vm);
 369 #endif
 370         log_mode_create_vm_done(vm);
 371         vm_vcpu_add_default(vm, vcpuid, guest_code);
 372         return vm;
 373 }
 374
 375 #define DIRTY_MEM_BITS 30 /* 1G */
 376 #define PAGE_SHIFT_4K  12
 377
 378 static void run_test(enum vm_guest_mode mode, unsigned long iterations,
 379                      unsigned long interval, uint64_t phys_offset)
 380 {
 381         pthread_t vcpu_thread;
 382         struct kvm_vm *vm;
 383         unsigned long *bmap;
 384
 385         if (!log_mode_supported()) {
 386                 print_skip("Log mode '%s' not supported",
 387                            log_modes[host_log_mode].name);
 388                 return;
 389         }
 390
 391         /*
 392          * We reserve page table for 2 times of extra dirty mem which
 393          * will definitely cover the original (1G+) test range.  Here
 394          * we do the calculation with 4K page size which is the
 395          * smallest so the page number will be enough for all archs
 396          * (e.g., 64K page size guest will need even less memory for
 397          * page tables).
 398          */
 399         vm = create_vm(mode, VCPU_ID,
 400                        2ul << (DIRTY_MEM_BITS - PAGE_SHIFT_4K),
 401                        guest_code);
 402
 403         guest_page_size = vm_get_page_size(vm);
 404         /*
 405          * A little more than 1G of guest page sized pages.  Cover the
 406          * case where the size is not aligned to 64 pages.
 407          */
 408         guest_num_pages = (1ul << (DIRTY_MEM_BITS -
 409                                    vm_get_page_shift(vm))) + 3;
 410         guest_num_pages = vm_adjust_num_guest_pages(mode, guest_num_pages);
 411
 412         host_page_size = getpagesize();
 413         host_num_pages = vm_num_host_pages(mode, guest_num_pages);
 414
 415         if (!phys_offset) {
 416                 guest_test_phys_mem = (vm_get_max_gfn(vm) -
 417                                        guest_num_pages) * guest_page_size;
 418                 guest_test_phys_mem &= ~(host_page_size - 1);
 419         } else {
 420                 guest_test_phys_mem = phys_offset;
 421         }
 422
 423 #ifdef __s390x__
 424         /* Align to 1M (segment size) */
 425         guest_test_phys_mem &= ~((1 << 20) - 1);
 426 #endif
 427
 428         pr_info("guest physical test memory offset: 0x%lx\n", guest_test_phys_mem);
 429
 430         bmap = bitmap_alloc(host_num_pages);
 431         host_bmap_track = bitmap_alloc(host_num_pages);
 432
 433         /* Add an extra memory slot for testing dirty logging */
 434         vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
 435                                     guest_test_phys_mem,
 436                                     TEST_MEM_SLOT_INDEX,
 437                                     guest_num_pages,
 438                                     KVM_MEM_LOG_DIRTY_PAGES);
 439
 440         /* Do mapping for the dirty track memory slot */
 441         virt_map(vm, guest_test_virt_mem, guest_test_phys_mem, guest_num_pages, 0);
 442
 443         /* Cache the HVA pointer of the region */
 444         host_test_mem = addr_gpa2hva(vm, (vm_paddr_t)guest_test_phys_mem);
 445
 446 #ifdef __x86_64__
 447         vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
 448 #endif
 449         ucall_init(vm, NULL);
 450
 451         /* Export the shared variables to the guest */
 452         sync_global_to_guest(vm, host_page_size);
 453         sync_global_to_guest(vm, guest_page_size);
 454         sync_global_to_guest(vm, guest_test_virt_mem);
 455         sync_global_to_guest(vm, guest_num_pages);
 456
 457         /* Start the iterations */
 458         iteration = 1;
 459         sync_global_to_guest(vm, iteration);
 460         host_quit = false;
 461         host_dirty_count = 0;
 462         host_clear_count = 0;
 463         host_track_next_count = 0;
 464
 465         pthread_create(&vcpu_thread, NULL, vcpu_worker, vm);
 466
 467         while (iteration < iterations) {
 468                 /* Give the vcpu thread some time to dirty some pages */
 469                 usleep(interval * 1000);
 470                 log_mode_collect_dirty_pages(vm, TEST_MEM_SLOT_INDEX,
 471                                              bmap, host_num_pages);
 472                 vm_dirty_log_verify(mode, bmap);
 473                 iteration++;
 474                 sync_global_to_guest(vm, iteration);
 475         }
 476
 477         /* Tell the vcpu thread to quit */
 478         host_quit = true;
 479         pthread_join(vcpu_thread, NULL);
 480
 481         pr_info("Total bits checked: dirty (%"PRIu64"), clear (%"PRIu64"), "
 482                 "track_next (%"PRIu64")\n", host_dirty_count, host_clear_count,
 483                 host_track_next_count);
 484
 485         free(bmap);
 486         free(host_bmap_track);
 487         ucall_uninit(vm);
 488         kvm_vm_free(vm);
 489 }
 490
 491 struct guest_mode {
 492         bool supported;
 493         bool enabled;
 494 };
 495 static struct guest_mode guest_modes[NUM_VM_MODES];
 496
 497 #define guest_mode_init(mode, supported, enabled) ({ \
 498         guest_modes[mode] = (struct guest_mode){ supported, enabled }; \
 499 })
 500
 501 static void help(char *name)
 502 {
 503         int i;
 504
 505         puts("");
 506         printf("usage: %s [-h] [-i iterations] [-I interval] "
 507                "[-p offset] [-m mode]\n", name);
 508         puts("");
 509         printf(" -i: specify iteration counts (default: %"PRIu64")\n",
 510                TEST_HOST_LOOP_N);
 511         printf(" -I: specify interval in ms (default: %"PRIu64" ms)\n",
 512                TEST_HOST_LOOP_INTERVAL);
 513         printf(" -p: specify guest physical test memory offset\n"
 514                "     Warning: a low offset can conflict with the loaded test code.\n");
 515         printf(" -M: specify the host logging mode "
 516                "(default: run all log modes).  Supported modes: \n\t");
 517         log_modes_dump();
 518         printf(" -m: specify the guest mode ID to test "
 519                "(default: test all supported modes)\n"
 520                "     This option may be used multiple times.\n"
 521                "     Guest mode IDs:\n");
 522         for (i = 0; i < NUM_VM_MODES; ++i) {
 523                 printf("         %d:    %s%s\n", i, vm_guest_mode_string(i),
 524                        guest_modes[i].supported ? " (supported)" : "");
 525         }
 526         puts("");
 527         exit(0);
 528 }
 529
 530 int main(int argc, char *argv[])
 531 {
 532         unsigned long iterations = TEST_HOST_LOOP_N;
 533         unsigned long interval = TEST_HOST_LOOP_INTERVAL;
 534         bool mode_selected = false;
 535         uint64_t phys_offset = 0;
 536         unsigned int mode;
 537         int opt, i, j;
 538
 539 #ifdef __x86_64__
 540         guest_mode_init(VM_MODE_PXXV48_4K, true, true);
 541 #endif
 542 #ifdef __aarch64__
 543         guest_mode_init(VM_MODE_P40V48_4K, true, true);
 544         guest_mode_init(VM_MODE_P40V48_64K, true, true);
 545
 546         {
 547                 unsigned int limit = kvm_check_cap(KVM_CAP_ARM_VM_IPA_SIZE);
 548
 549                 if (limit >= 52)
 550                         guest_mode_init(VM_MODE_P52V48_64K, true, true);
 551                 if (limit >= 48) {
 552                         guest_mode_init(VM_MODE_P48V48_4K, true, true);
 553                         guest_mode_init(VM_MODE_P48V48_64K, true, true);
 554                 }
 555         }
 556 #endif
 557 #ifdef __s390x__
 558         guest_mode_init(VM_MODE_P40V48_4K, true, true);
 559 #endif
 560
 561         while ((opt = getopt(argc, argv, "hi:I:p:m:M:")) != -1) {
 562                 switch (opt) {
 563                 case 'i':
 564                         iterations = strtol(optarg, NULL, 10);
 565                         break;
 566                 case 'I':
 567                         interval = strtol(optarg, NULL, 10);
 568                         break;
 569                 case 'p':
 570                         phys_offset = strtoull(optarg, NULL, 0);
 571                         break;
 572                 case 'm':
 573                         if (!mode_selected) {
 574                                 for (i = 0; i < NUM_VM_MODES; ++i)
 575                                         guest_modes[i].enabled = false;
 576                                 mode_selected = true;
 577                         }
 578                         mode = strtoul(optarg, NULL, 10);
 579                         TEST_ASSERT(mode < NUM_VM_MODES,
 580                                     "Guest mode ID %d too big", mode);
 581                         guest_modes[mode].enabled = true;
 582                         break;
 583                 case 'M':
 584                         if (!strcmp(optarg, "all")) {
 585                                 host_log_mode_option = LOG_MODE_ALL;
 586                                 break;
 587                         }
 588                         for (i = 0; i < LOG_MODE_NUM; i++) {
 589                                 if (!strcmp(optarg, log_modes[i].name)) {
 590                                         pr_info("Setting log mode to: '%s'\n",
 591                                                 optarg);
 592                                         host_log_mode_option = i;
 593                                         break;
 594                                 }
 595                         }
 596                         if (i == LOG_MODE_NUM) {
 597                                 printf("Log mode '%s' invalid. Please choose "
 598                                        "from: ", optarg);
 599                                 log_modes_dump();
 600                                 exit(1);
 601                         }
 602                         break;
 603                 case 'h':
 604                 default:
 605                         help(argv[0]);
 606                         break;
 607                 }
 608         }
 609
 610         TEST_ASSERT(iterations > 2, "Iterations must be greater than two");
 611         TEST_ASSERT(interval > 0, "Interval must be greater than zero");
 612
 613         pr_info("Test iterations: %"PRIu64", interval: %"PRIu64" (ms)\n",
 614                 iterations, interval);
 615
 616         srandom(time(0));
 617
 618         for (i = 0; i < NUM_VM_MODES; ++i) {
 619                 if (!guest_modes[i].enabled)
 620                         continue;
 621                 TEST_ASSERT(guest_modes[i].supported,
 622                             "Guest mode ID %d (%s) not supported.",
 623                             i, vm_guest_mode_string(i));
 624                 if (host_log_mode_option == LOG_MODE_ALL) {
 625                         /* Run each log mode */
 626                         for (j = 0; j < LOG_MODE_NUM; j++) {
 627                                 pr_info("Testing Log Mode '%s'\n",
 628                                         log_modes[j].name);
 629                                 host_log_mode = j;
 630                                 run_test(i, iterations, interval, phys_offset);
 631                         }
 632                 } else {
 633                         host_log_mode = host_log_mode_option;
 634                         run_test(i, iterations, interval, phys_offset);
 635                 }
 636         }
 637
 638         return 0;
 639 }