1c33e05d9SDavid Matlack // SPDX-License-Identifier: GPL-2.0 2c33e05d9SDavid Matlack /* 3c33e05d9SDavid Matlack * access_tracking_perf_test 4c33e05d9SDavid Matlack * 5c33e05d9SDavid Matlack * Copyright (C) 2021, Google, Inc. 6c33e05d9SDavid Matlack * 7c33e05d9SDavid Matlack * This test measures the performance effects of KVM's access tracking. 8c33e05d9SDavid Matlack * Access tracking is driven by the MMU notifiers test_young, clear_young, and 9c33e05d9SDavid Matlack * clear_flush_young. These notifiers do not have a direct userspace API, 10c33e05d9SDavid Matlack * however the clear_young notifier can be triggered by marking a pages as idle 11c33e05d9SDavid Matlack * in /sys/kernel/mm/page_idle/bitmap. This test leverages that mechanism to 12c33e05d9SDavid Matlack * enable access tracking on guest memory. 13c33e05d9SDavid Matlack * 14c33e05d9SDavid Matlack * To measure performance this test runs a VM with a configurable number of 15c33e05d9SDavid Matlack * vCPUs that each touch every page in disjoint regions of memory. Performance 16c33e05d9SDavid Matlack * is measured in the time it takes all vCPUs to finish touching their 17c33e05d9SDavid Matlack * predefined region. 18c33e05d9SDavid Matlack * 19c33e05d9SDavid Matlack * Note that a deterministic correctness test of access tracking is not possible 20c33e05d9SDavid Matlack * by using page_idle as it exists today. This is for a few reasons: 21c33e05d9SDavid Matlack * 22c33e05d9SDavid Matlack * 1. page_idle only issues clear_young notifiers, which lack a TLB flush. This 23c33e05d9SDavid Matlack * means subsequent guest accesses are not guaranteed to see page table 24c33e05d9SDavid Matlack * updates made by KVM until some time in the future. 25c33e05d9SDavid Matlack * 26c33e05d9SDavid Matlack * 2. page_idle only operates on LRU pages. Newly allocated pages are not 27c33e05d9SDavid Matlack * immediately allocated to LRU lists. Instead they are held in a "pagevec", 28c33e05d9SDavid Matlack * which is drained to LRU lists some time in the future. There is no 29c33e05d9SDavid Matlack * userspace API to force this drain to occur. 30c33e05d9SDavid Matlack * 31c33e05d9SDavid Matlack * These limitations are worked around in this test by using a large enough 32c33e05d9SDavid Matlack * region of memory for each vCPU such that the number of translations cached in 33c33e05d9SDavid Matlack * the TLB and the number of pages held in pagevecs are a small fraction of the 34c33e05d9SDavid Matlack * overall workload. And if either of those conditions are not true this test 35c33e05d9SDavid Matlack * will fail rather than silently passing. 36c33e05d9SDavid Matlack */ 37c33e05d9SDavid Matlack #include <inttypes.h> 38c33e05d9SDavid Matlack #include <limits.h> 39c33e05d9SDavid Matlack #include <pthread.h> 40c33e05d9SDavid Matlack #include <sys/mman.h> 41c33e05d9SDavid Matlack #include <sys/types.h> 42c33e05d9SDavid Matlack #include <sys/stat.h> 43c33e05d9SDavid Matlack 44c33e05d9SDavid Matlack #include "kvm_util.h" 45c33e05d9SDavid Matlack #include "test_util.h" 46c33e05d9SDavid Matlack #include "perf_test_util.h" 47c33e05d9SDavid Matlack #include "guest_modes.h" 48c33e05d9SDavid Matlack 49c33e05d9SDavid Matlack /* Global variable used to synchronize all of the vCPU threads. */ 50*36c5ad73SDavid Matlack static int iteration; 51c33e05d9SDavid Matlack 52c33e05d9SDavid Matlack /* Defines what vCPU threads should do during a given iteration. */ 53c33e05d9SDavid Matlack static enum { 54c33e05d9SDavid Matlack /* Run the vCPU to access all its memory. */ 55c33e05d9SDavid Matlack ITERATION_ACCESS_MEMORY, 56c33e05d9SDavid Matlack /* Mark the vCPU's memory idle in page_idle. */ 57c33e05d9SDavid Matlack ITERATION_MARK_IDLE, 58c33e05d9SDavid Matlack } iteration_work; 59c33e05d9SDavid Matlack 60c33e05d9SDavid Matlack /* Set to true when vCPU threads should exit. */ 61c33e05d9SDavid Matlack static bool done; 62c33e05d9SDavid Matlack 63c33e05d9SDavid Matlack /* The iteration that was last completed by each vCPU. */ 64c33e05d9SDavid Matlack static int vcpu_last_completed_iteration[KVM_MAX_VCPUS]; 65c33e05d9SDavid Matlack 66c33e05d9SDavid Matlack /* Whether to overlap the regions of memory vCPUs access. */ 67c33e05d9SDavid Matlack static bool overlap_memory_access; 68c33e05d9SDavid Matlack 69c33e05d9SDavid Matlack struct test_params { 70c33e05d9SDavid Matlack /* The backing source for the region of memory. */ 71c33e05d9SDavid Matlack enum vm_mem_backing_src_type backing_src; 72c33e05d9SDavid Matlack 73c33e05d9SDavid Matlack /* The amount of memory to allocate for each vCPU. */ 74c33e05d9SDavid Matlack uint64_t vcpu_memory_bytes; 75c33e05d9SDavid Matlack 76c33e05d9SDavid Matlack /* The number of vCPUs to create in the VM. */ 77c33e05d9SDavid Matlack int vcpus; 78c33e05d9SDavid Matlack }; 79c33e05d9SDavid Matlack 80c33e05d9SDavid Matlack static uint64_t pread_uint64(int fd, const char *filename, uint64_t index) 81c33e05d9SDavid Matlack { 82c33e05d9SDavid Matlack uint64_t value; 83c33e05d9SDavid Matlack off_t offset = index * sizeof(value); 84c33e05d9SDavid Matlack 85c33e05d9SDavid Matlack TEST_ASSERT(pread(fd, &value, sizeof(value), offset) == sizeof(value), 86c33e05d9SDavid Matlack "pread from %s offset 0x%" PRIx64 " failed!", 87c33e05d9SDavid Matlack filename, offset); 88c33e05d9SDavid Matlack 89c33e05d9SDavid Matlack return value; 90c33e05d9SDavid Matlack 91c33e05d9SDavid Matlack } 92c33e05d9SDavid Matlack 93c33e05d9SDavid Matlack #define PAGEMAP_PRESENT (1ULL << 63) 94c33e05d9SDavid Matlack #define PAGEMAP_PFN_MASK ((1ULL << 55) - 1) 95c33e05d9SDavid Matlack 96c33e05d9SDavid Matlack static uint64_t lookup_pfn(int pagemap_fd, struct kvm_vm *vm, uint64_t gva) 97c33e05d9SDavid Matlack { 98c33e05d9SDavid Matlack uint64_t hva = (uint64_t) addr_gva2hva(vm, gva); 99c33e05d9SDavid Matlack uint64_t entry; 100c33e05d9SDavid Matlack uint64_t pfn; 101c33e05d9SDavid Matlack 102c33e05d9SDavid Matlack entry = pread_uint64(pagemap_fd, "pagemap", hva / getpagesize()); 103c33e05d9SDavid Matlack if (!(entry & PAGEMAP_PRESENT)) 104c33e05d9SDavid Matlack return 0; 105c33e05d9SDavid Matlack 106c33e05d9SDavid Matlack pfn = entry & PAGEMAP_PFN_MASK; 107c33e05d9SDavid Matlack if (!pfn) { 108c33e05d9SDavid Matlack print_skip("Looking up PFNs requires CAP_SYS_ADMIN"); 109c33e05d9SDavid Matlack exit(KSFT_SKIP); 110c33e05d9SDavid Matlack } 111c33e05d9SDavid Matlack 112c33e05d9SDavid Matlack return pfn; 113c33e05d9SDavid Matlack } 114c33e05d9SDavid Matlack 115c33e05d9SDavid Matlack static bool is_page_idle(int page_idle_fd, uint64_t pfn) 116c33e05d9SDavid Matlack { 117c33e05d9SDavid Matlack uint64_t bits = pread_uint64(page_idle_fd, "page_idle", pfn / 64); 118c33e05d9SDavid Matlack 119c33e05d9SDavid Matlack return !!((bits >> (pfn % 64)) & 1); 120c33e05d9SDavid Matlack } 121c33e05d9SDavid Matlack 122c33e05d9SDavid Matlack static void mark_page_idle(int page_idle_fd, uint64_t pfn) 123c33e05d9SDavid Matlack { 124c33e05d9SDavid Matlack uint64_t bits = 1ULL << (pfn % 64); 125c33e05d9SDavid Matlack 126c33e05d9SDavid Matlack TEST_ASSERT(pwrite(page_idle_fd, &bits, 8, 8 * (pfn / 64)) == 8, 127c33e05d9SDavid Matlack "Set page_idle bits for PFN 0x%" PRIx64, pfn); 128c33e05d9SDavid Matlack } 129c33e05d9SDavid Matlack 130c33e05d9SDavid Matlack static void mark_vcpu_memory_idle(struct kvm_vm *vm, int vcpu_id) 131c33e05d9SDavid Matlack { 132c33e05d9SDavid Matlack uint64_t base_gva = perf_test_args.vcpu_args[vcpu_id].gva; 133c33e05d9SDavid Matlack uint64_t pages = perf_test_args.vcpu_args[vcpu_id].pages; 134c33e05d9SDavid Matlack uint64_t page; 135c33e05d9SDavid Matlack uint64_t still_idle = 0; 136c33e05d9SDavid Matlack uint64_t no_pfn = 0; 137c33e05d9SDavid Matlack int page_idle_fd; 138c33e05d9SDavid Matlack int pagemap_fd; 139c33e05d9SDavid Matlack 140c33e05d9SDavid Matlack /* If vCPUs are using an overlapping region, let vCPU 0 mark it idle. */ 141c33e05d9SDavid Matlack if (overlap_memory_access && vcpu_id) 142c33e05d9SDavid Matlack return; 143c33e05d9SDavid Matlack 144c33e05d9SDavid Matlack page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR); 145c33e05d9SDavid Matlack TEST_ASSERT(page_idle_fd > 0, "Failed to open page_idle."); 146c33e05d9SDavid Matlack 147c33e05d9SDavid Matlack pagemap_fd = open("/proc/self/pagemap", O_RDONLY); 148c33e05d9SDavid Matlack TEST_ASSERT(pagemap_fd > 0, "Failed to open pagemap."); 149c33e05d9SDavid Matlack 150c33e05d9SDavid Matlack for (page = 0; page < pages; page++) { 151c33e05d9SDavid Matlack uint64_t gva = base_gva + page * perf_test_args.guest_page_size; 152c33e05d9SDavid Matlack uint64_t pfn = lookup_pfn(pagemap_fd, vm, gva); 153c33e05d9SDavid Matlack 154c33e05d9SDavid Matlack if (!pfn) { 155c33e05d9SDavid Matlack no_pfn++; 156c33e05d9SDavid Matlack continue; 157c33e05d9SDavid Matlack } 158c33e05d9SDavid Matlack 159c33e05d9SDavid Matlack if (is_page_idle(page_idle_fd, pfn)) { 160c33e05d9SDavid Matlack still_idle++; 161c33e05d9SDavid Matlack continue; 162c33e05d9SDavid Matlack } 163c33e05d9SDavid Matlack 164c33e05d9SDavid Matlack mark_page_idle(page_idle_fd, pfn); 165c33e05d9SDavid Matlack } 166c33e05d9SDavid Matlack 167c33e05d9SDavid Matlack /* 168c33e05d9SDavid Matlack * Assumption: Less than 1% of pages are going to be swapped out from 169c33e05d9SDavid Matlack * under us during this test. 170c33e05d9SDavid Matlack */ 171c33e05d9SDavid Matlack TEST_ASSERT(no_pfn < pages / 100, 172c33e05d9SDavid Matlack "vCPU %d: No PFN for %" PRIu64 " out of %" PRIu64 " pages.", 173c33e05d9SDavid Matlack vcpu_id, no_pfn, pages); 174c33e05d9SDavid Matlack 175c33e05d9SDavid Matlack /* 176c33e05d9SDavid Matlack * Test that at least 90% of memory has been marked idle (the rest might 177c33e05d9SDavid Matlack * not be marked idle because the pages have not yet made it to an LRU 178c33e05d9SDavid Matlack * list or the translations are still cached in the TLB). 90% is 179c33e05d9SDavid Matlack * arbitrary; high enough that we ensure most memory access went through 180c33e05d9SDavid Matlack * access tracking but low enough as to not make the test too brittle 181c33e05d9SDavid Matlack * over time and across architectures. 182c33e05d9SDavid Matlack */ 183c33e05d9SDavid Matlack TEST_ASSERT(still_idle < pages / 10, 184c33e05d9SDavid Matlack "vCPU%d: Too many pages still idle (%"PRIu64 " out of %" 185c33e05d9SDavid Matlack PRIu64 ").\n", 186c33e05d9SDavid Matlack vcpu_id, still_idle, pages); 187c33e05d9SDavid Matlack 188c33e05d9SDavid Matlack close(page_idle_fd); 189c33e05d9SDavid Matlack close(pagemap_fd); 190c33e05d9SDavid Matlack } 191c33e05d9SDavid Matlack 192c33e05d9SDavid Matlack static void assert_ucall(struct kvm_vm *vm, uint32_t vcpu_id, 193c33e05d9SDavid Matlack uint64_t expected_ucall) 194c33e05d9SDavid Matlack { 195c33e05d9SDavid Matlack struct ucall uc; 196c33e05d9SDavid Matlack uint64_t actual_ucall = get_ucall(vm, vcpu_id, &uc); 197c33e05d9SDavid Matlack 198c33e05d9SDavid Matlack TEST_ASSERT(expected_ucall == actual_ucall, 199c33e05d9SDavid Matlack "Guest exited unexpectedly (expected ucall %" PRIu64 200c33e05d9SDavid Matlack ", got %" PRIu64 ")", 201c33e05d9SDavid Matlack expected_ucall, actual_ucall); 202c33e05d9SDavid Matlack } 203c33e05d9SDavid Matlack 204c33e05d9SDavid Matlack static bool spin_wait_for_next_iteration(int *current_iteration) 205c33e05d9SDavid Matlack { 206c33e05d9SDavid Matlack int last_iteration = *current_iteration; 207c33e05d9SDavid Matlack 208c33e05d9SDavid Matlack do { 209c33e05d9SDavid Matlack if (READ_ONCE(done)) 210c33e05d9SDavid Matlack return false; 211c33e05d9SDavid Matlack 212c33e05d9SDavid Matlack *current_iteration = READ_ONCE(iteration); 213c33e05d9SDavid Matlack } while (last_iteration == *current_iteration); 214c33e05d9SDavid Matlack 215c33e05d9SDavid Matlack return true; 216c33e05d9SDavid Matlack } 217c33e05d9SDavid Matlack 218c33e05d9SDavid Matlack static void *vcpu_thread_main(void *arg) 219c33e05d9SDavid Matlack { 220c33e05d9SDavid Matlack struct perf_test_vcpu_args *vcpu_args = arg; 221c33e05d9SDavid Matlack struct kvm_vm *vm = perf_test_args.vm; 222c33e05d9SDavid Matlack int vcpu_id = vcpu_args->vcpu_id; 223*36c5ad73SDavid Matlack int current_iteration = 0; 224c33e05d9SDavid Matlack 225c33e05d9SDavid Matlack while (spin_wait_for_next_iteration(¤t_iteration)) { 226c33e05d9SDavid Matlack switch (READ_ONCE(iteration_work)) { 227c33e05d9SDavid Matlack case ITERATION_ACCESS_MEMORY: 228c33e05d9SDavid Matlack vcpu_run(vm, vcpu_id); 229c33e05d9SDavid Matlack assert_ucall(vm, vcpu_id, UCALL_SYNC); 230c33e05d9SDavid Matlack break; 231c33e05d9SDavid Matlack case ITERATION_MARK_IDLE: 232c33e05d9SDavid Matlack mark_vcpu_memory_idle(vm, vcpu_id); 233c33e05d9SDavid Matlack break; 234c33e05d9SDavid Matlack }; 235c33e05d9SDavid Matlack 236c33e05d9SDavid Matlack vcpu_last_completed_iteration[vcpu_id] = current_iteration; 237c33e05d9SDavid Matlack } 238c33e05d9SDavid Matlack 239c33e05d9SDavid Matlack return NULL; 240c33e05d9SDavid Matlack } 241c33e05d9SDavid Matlack 242c33e05d9SDavid Matlack static void spin_wait_for_vcpu(int vcpu_id, int target_iteration) 243c33e05d9SDavid Matlack { 244c33e05d9SDavid Matlack while (READ_ONCE(vcpu_last_completed_iteration[vcpu_id]) != 245c33e05d9SDavid Matlack target_iteration) { 246c33e05d9SDavid Matlack continue; 247c33e05d9SDavid Matlack } 248c33e05d9SDavid Matlack } 249c33e05d9SDavid Matlack 250c33e05d9SDavid Matlack /* The type of memory accesses to perform in the VM. */ 251c33e05d9SDavid Matlack enum access_type { 252c33e05d9SDavid Matlack ACCESS_READ, 253c33e05d9SDavid Matlack ACCESS_WRITE, 254c33e05d9SDavid Matlack }; 255c33e05d9SDavid Matlack 256c33e05d9SDavid Matlack static void run_iteration(struct kvm_vm *vm, int vcpus, const char *description) 257c33e05d9SDavid Matlack { 258c33e05d9SDavid Matlack struct timespec ts_start; 259c33e05d9SDavid Matlack struct timespec ts_elapsed; 260c33e05d9SDavid Matlack int next_iteration; 261c33e05d9SDavid Matlack int vcpu_id; 262c33e05d9SDavid Matlack 263c33e05d9SDavid Matlack /* Kick off the vCPUs by incrementing iteration. */ 264c33e05d9SDavid Matlack next_iteration = ++iteration; 265c33e05d9SDavid Matlack 266c33e05d9SDavid Matlack clock_gettime(CLOCK_MONOTONIC, &ts_start); 267c33e05d9SDavid Matlack 268c33e05d9SDavid Matlack /* Wait for all vCPUs to finish the iteration. */ 269c33e05d9SDavid Matlack for (vcpu_id = 0; vcpu_id < vcpus; vcpu_id++) 270c33e05d9SDavid Matlack spin_wait_for_vcpu(vcpu_id, next_iteration); 271c33e05d9SDavid Matlack 272c33e05d9SDavid Matlack ts_elapsed = timespec_elapsed(ts_start); 273c33e05d9SDavid Matlack pr_info("%-30s: %ld.%09lds\n", 274c33e05d9SDavid Matlack description, ts_elapsed.tv_sec, ts_elapsed.tv_nsec); 275c33e05d9SDavid Matlack } 276c33e05d9SDavid Matlack 277c33e05d9SDavid Matlack static void access_memory(struct kvm_vm *vm, int vcpus, enum access_type access, 278c33e05d9SDavid Matlack const char *description) 279c33e05d9SDavid Matlack { 28013bbc703SSean Christopherson perf_test_set_wr_fract(vm, (access == ACCESS_READ) ? INT_MAX : 1); 281c33e05d9SDavid Matlack iteration_work = ITERATION_ACCESS_MEMORY; 282c33e05d9SDavid Matlack run_iteration(vm, vcpus, description); 283c33e05d9SDavid Matlack } 284c33e05d9SDavid Matlack 285c33e05d9SDavid Matlack static void mark_memory_idle(struct kvm_vm *vm, int vcpus) 286c33e05d9SDavid Matlack { 287c33e05d9SDavid Matlack /* 288c33e05d9SDavid Matlack * Even though this parallelizes the work across vCPUs, this is still a 289c33e05d9SDavid Matlack * very slow operation because page_idle forces the test to mark one pfn 290c33e05d9SDavid Matlack * at a time and the clear_young notifier serializes on the KVM MMU 291c33e05d9SDavid Matlack * lock. 292c33e05d9SDavid Matlack */ 293c33e05d9SDavid Matlack pr_debug("Marking VM memory idle (slow)...\n"); 294c33e05d9SDavid Matlack iteration_work = ITERATION_MARK_IDLE; 295c33e05d9SDavid Matlack run_iteration(vm, vcpus, "Mark memory idle"); 296c33e05d9SDavid Matlack } 297c33e05d9SDavid Matlack 298c33e05d9SDavid Matlack static pthread_t *create_vcpu_threads(int vcpus) 299c33e05d9SDavid Matlack { 300c33e05d9SDavid Matlack pthread_t *vcpu_threads; 301c33e05d9SDavid Matlack int i; 302c33e05d9SDavid Matlack 303c33e05d9SDavid Matlack vcpu_threads = malloc(vcpus * sizeof(vcpu_threads[0])); 304c33e05d9SDavid Matlack TEST_ASSERT(vcpu_threads, "Failed to allocate vcpu_threads."); 305c33e05d9SDavid Matlack 306*36c5ad73SDavid Matlack for (i = 0; i < vcpus; i++) 307c33e05d9SDavid Matlack pthread_create(&vcpu_threads[i], NULL, vcpu_thread_main, 308c33e05d9SDavid Matlack &perf_test_args.vcpu_args[i]); 309c33e05d9SDavid Matlack 310c33e05d9SDavid Matlack return vcpu_threads; 311c33e05d9SDavid Matlack } 312c33e05d9SDavid Matlack 313c33e05d9SDavid Matlack static void terminate_vcpu_threads(pthread_t *vcpu_threads, int vcpus) 314c33e05d9SDavid Matlack { 315c33e05d9SDavid Matlack int i; 316c33e05d9SDavid Matlack 317c33e05d9SDavid Matlack /* Set done to signal the vCPU threads to exit */ 318c33e05d9SDavid Matlack done = true; 319c33e05d9SDavid Matlack 320c33e05d9SDavid Matlack for (i = 0; i < vcpus; i++) 321c33e05d9SDavid Matlack pthread_join(vcpu_threads[i], NULL); 322c33e05d9SDavid Matlack } 323c33e05d9SDavid Matlack 324c33e05d9SDavid Matlack static void run_test(enum vm_guest_mode mode, void *arg) 325c33e05d9SDavid Matlack { 326c33e05d9SDavid Matlack struct test_params *params = arg; 327c33e05d9SDavid Matlack struct kvm_vm *vm; 328c33e05d9SDavid Matlack pthread_t *vcpu_threads; 329c33e05d9SDavid Matlack int vcpus = params->vcpus; 330c33e05d9SDavid Matlack 331609e6202SDavid Matlack vm = perf_test_create_vm(mode, vcpus, params->vcpu_memory_bytes, 1, 332cf1d5930SSean Christopherson params->backing_src, !overlap_memory_access); 333c33e05d9SDavid Matlack 334c33e05d9SDavid Matlack vcpu_threads = create_vcpu_threads(vcpus); 335c33e05d9SDavid Matlack 336c33e05d9SDavid Matlack pr_info("\n"); 337c33e05d9SDavid Matlack access_memory(vm, vcpus, ACCESS_WRITE, "Populating memory"); 338c33e05d9SDavid Matlack 339c33e05d9SDavid Matlack /* As a control, read and write to the populated memory first. */ 340c33e05d9SDavid Matlack access_memory(vm, vcpus, ACCESS_WRITE, "Writing to populated memory"); 341c33e05d9SDavid Matlack access_memory(vm, vcpus, ACCESS_READ, "Reading from populated memory"); 342c33e05d9SDavid Matlack 343c33e05d9SDavid Matlack /* Repeat on memory that has been marked as idle. */ 344c33e05d9SDavid Matlack mark_memory_idle(vm, vcpus); 345c33e05d9SDavid Matlack access_memory(vm, vcpus, ACCESS_WRITE, "Writing to idle memory"); 346c33e05d9SDavid Matlack mark_memory_idle(vm, vcpus); 347c33e05d9SDavid Matlack access_memory(vm, vcpus, ACCESS_READ, "Reading from idle memory"); 348c33e05d9SDavid Matlack 349c33e05d9SDavid Matlack terminate_vcpu_threads(vcpu_threads, vcpus); 350c33e05d9SDavid Matlack free(vcpu_threads); 351c33e05d9SDavid Matlack perf_test_destroy_vm(vm); 352c33e05d9SDavid Matlack } 353c33e05d9SDavid Matlack 354c33e05d9SDavid Matlack static void help(char *name) 355c33e05d9SDavid Matlack { 356c33e05d9SDavid Matlack puts(""); 357c33e05d9SDavid Matlack printf("usage: %s [-h] [-m mode] [-b vcpu_bytes] [-v vcpus] [-o] [-s mem_type]\n", 358c33e05d9SDavid Matlack name); 359c33e05d9SDavid Matlack puts(""); 360c33e05d9SDavid Matlack printf(" -h: Display this help message."); 361c33e05d9SDavid Matlack guest_modes_help(); 362c33e05d9SDavid Matlack printf(" -b: specify the size of the memory region which should be\n" 363c33e05d9SDavid Matlack " dirtied by each vCPU. e.g. 10M or 3G.\n" 364c33e05d9SDavid Matlack " (default: 1G)\n"); 365c33e05d9SDavid Matlack printf(" -v: specify the number of vCPUs to run.\n"); 366c33e05d9SDavid Matlack printf(" -o: Overlap guest memory accesses instead of partitioning\n" 367c33e05d9SDavid Matlack " them into a separate region of memory for each vCPU.\n"); 3689f2fc555SDavid Matlack backing_src_help("-s"); 369c33e05d9SDavid Matlack puts(""); 370c33e05d9SDavid Matlack exit(0); 371c33e05d9SDavid Matlack } 372c33e05d9SDavid Matlack 373c33e05d9SDavid Matlack int main(int argc, char *argv[]) 374c33e05d9SDavid Matlack { 375c33e05d9SDavid Matlack struct test_params params = { 3769f2fc555SDavid Matlack .backing_src = DEFAULT_VM_MEM_SRC, 377c33e05d9SDavid Matlack .vcpu_memory_bytes = DEFAULT_PER_VCPU_MEM_SIZE, 378c33e05d9SDavid Matlack .vcpus = 1, 379c33e05d9SDavid Matlack }; 380c33e05d9SDavid Matlack int page_idle_fd; 381c33e05d9SDavid Matlack int opt; 382c33e05d9SDavid Matlack 383c33e05d9SDavid Matlack guest_modes_append_default(); 384c33e05d9SDavid Matlack 385c33e05d9SDavid Matlack while ((opt = getopt(argc, argv, "hm:b:v:os:")) != -1) { 386c33e05d9SDavid Matlack switch (opt) { 387c33e05d9SDavid Matlack case 'm': 388c33e05d9SDavid Matlack guest_modes_cmdline(optarg); 389c33e05d9SDavid Matlack break; 390c33e05d9SDavid Matlack case 'b': 391c33e05d9SDavid Matlack params.vcpu_memory_bytes = parse_size(optarg); 392c33e05d9SDavid Matlack break; 393c33e05d9SDavid Matlack case 'v': 394c33e05d9SDavid Matlack params.vcpus = atoi(optarg); 395c33e05d9SDavid Matlack break; 396c33e05d9SDavid Matlack case 'o': 397c33e05d9SDavid Matlack overlap_memory_access = true; 398c33e05d9SDavid Matlack break; 399c33e05d9SDavid Matlack case 's': 400c33e05d9SDavid Matlack params.backing_src = parse_backing_src_type(optarg); 401c33e05d9SDavid Matlack break; 402c33e05d9SDavid Matlack case 'h': 403c33e05d9SDavid Matlack default: 404c33e05d9SDavid Matlack help(argv[0]); 405c33e05d9SDavid Matlack break; 406c33e05d9SDavid Matlack } 407c33e05d9SDavid Matlack } 408c33e05d9SDavid Matlack 409c33e05d9SDavid Matlack page_idle_fd = open("/sys/kernel/mm/page_idle/bitmap", O_RDWR); 410c33e05d9SDavid Matlack if (page_idle_fd < 0) { 411c33e05d9SDavid Matlack print_skip("CONFIG_IDLE_PAGE_TRACKING is not enabled"); 412c33e05d9SDavid Matlack exit(KSFT_SKIP); 413c33e05d9SDavid Matlack } 414c33e05d9SDavid Matlack close(page_idle_fd); 415c33e05d9SDavid Matlack 416c33e05d9SDavid Matlack for_each_guest_mode(run_test, ¶ms); 417c33e05d9SDavid Matlack 418c33e05d9SDavid Matlack return 0; 419c33e05d9SDavid Matlack } 420