selftests/ftrace: Strip escape sequences for log file
[muen/linux.git] / 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 #include <stdio.h>
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <time.h>
12 #include <pthread.h>
13 #include <linux/bitmap.h>
14 #include <linux/bitops.h>
15
16 #include "test_util.h"
17 #include "kvm_util.h"
18
19 #define  DEBUG                 printf
20
21 #define  VCPU_ID                        1
22 /* The memory slot index to track dirty pages */
23 #define  TEST_MEM_SLOT_INDEX            1
24 /*
25  * GPA offset of the testing memory slot. Must be bigger than the
26  * default vm mem slot, which is DEFAULT_GUEST_PHY_PAGES.
27  */
28 #define  TEST_MEM_OFFSET                (1ULL << 30) /* 1G */
29 /* Size of the testing memory slot */
30 #define  TEST_MEM_PAGES                 (1ULL << 18) /* 1G for 4K pages */
31 /* How many pages to dirty for each guest loop */
32 #define  TEST_PAGES_PER_LOOP            1024
33 /* How many host loops to run (one KVM_GET_DIRTY_LOG for each loop) */
34 #define  TEST_HOST_LOOP_N               32UL
35 /* Interval for each host loop (ms) */
36 #define  TEST_HOST_LOOP_INTERVAL        10UL
37
38 /*
39  * Guest variables.  We use these variables to share data between host
40  * and guest.  There are two copies of the variables, one in host memory
41  * (which is unused) and one in guest memory.  When the host wants to
42  * access these variables, it needs to call addr_gva2hva() to access the
43  * guest copy.
44  */
45 uint64_t guest_random_array[TEST_PAGES_PER_LOOP];
46 uint64_t guest_iteration;
47 uint64_t guest_page_size;
48
49 /*
50  * Writes to the first byte of a random page within the testing memory
51  * region continuously.
52  */
53 void guest_code(void)
54 {
55         int i = 0;
56         uint64_t volatile *array = guest_random_array;
57         uint64_t volatile *guest_addr;
58
59         while (true) {
60                 for (i = 0; i < TEST_PAGES_PER_LOOP; i++) {
61                         /*
62                          * Write to the first 8 bytes of a random page
63                          * on the testing memory region.
64                          */
65                         guest_addr = (uint64_t *)
66                             (TEST_MEM_OFFSET +
67                              (array[i] % TEST_MEM_PAGES) * guest_page_size);
68                         *guest_addr = guest_iteration;
69                 }
70                 /* Tell the host that we need more random numbers */
71                 GUEST_SYNC(1);
72         }
73 }
74
75 /*
76  * Host variables.  These variables should only be used by the host
77  * rather than the guest.
78  */
79 bool host_quit;
80
81 /* Points to the test VM memory region on which we track dirty logs */
82 void *host_test_mem;
83
84 /* For statistics only */
85 uint64_t host_dirty_count;
86 uint64_t host_clear_count;
87 uint64_t host_track_next_count;
88
89 /*
90  * We use this bitmap to track some pages that should have its dirty
91  * bit set in the _next_ iteration.  For example, if we detected the
92  * page value changed to current iteration but at the same time the
93  * page bit is cleared in the latest bitmap, then the system must
94  * report that write in the next get dirty log call.
95  */
96 unsigned long *host_bmap_track;
97
98 void generate_random_array(uint64_t *guest_array, uint64_t size)
99 {
100         uint64_t i;
101
102         for (i = 0; i < size; i++) {
103                 guest_array[i] = random();
104         }
105 }
106
107 void *vcpu_worker(void *data)
108 {
109         int ret;
110         uint64_t loops, *guest_array, pages_count = 0;
111         struct kvm_vm *vm = data;
112         struct kvm_run *run;
113         struct guest_args args;
114
115         run = vcpu_state(vm, VCPU_ID);
116
117         /* Retrieve the guest random array pointer and cache it */
118         guest_array = addr_gva2hva(vm, (vm_vaddr_t)guest_random_array);
119
120         DEBUG("VCPU starts\n");
121
122         generate_random_array(guest_array, TEST_PAGES_PER_LOOP);
123
124         while (!READ_ONCE(host_quit)) {
125                 /* Let the guest to dirty these random pages */
126                 ret = _vcpu_run(vm, VCPU_ID);
127                 guest_args_read(vm, VCPU_ID, &args);
128                 if (run->exit_reason == KVM_EXIT_IO &&
129                     args.port == GUEST_PORT_SYNC) {
130                         pages_count += TEST_PAGES_PER_LOOP;
131                         generate_random_array(guest_array, TEST_PAGES_PER_LOOP);
132                 } else {
133                         TEST_ASSERT(false,
134                                     "Invalid guest sync status: "
135                                     "exit_reason=%s\n",
136                                     exit_reason_str(run->exit_reason));
137                 }
138         }
139
140         DEBUG("VCPU exits, dirtied %"PRIu64" pages\n", pages_count);
141
142         return NULL;
143 }
144
145 void vm_dirty_log_verify(unsigned long *bmap, uint64_t iteration)
146 {
147         uint64_t page;
148         uint64_t volatile *value_ptr;
149
150         for (page = 0; page < TEST_MEM_PAGES; page++) {
151                 value_ptr = host_test_mem + page * getpagesize();
152
153                 /* If this is a special page that we were tracking... */
154                 if (test_and_clear_bit(page, host_bmap_track)) {
155                         host_track_next_count++;
156                         TEST_ASSERT(test_bit(page, bmap),
157                                     "Page %"PRIu64" should have its dirty bit "
158                                     "set in this iteration but it is missing",
159                                     page);
160                 }
161
162                 if (test_bit(page, bmap)) {
163                         host_dirty_count++;
164                         /*
165                          * If the bit is set, the value written onto
166                          * the corresponding page should be either the
167                          * previous iteration number or the current one.
168                          */
169                         TEST_ASSERT(*value_ptr == iteration ||
170                                     *value_ptr == iteration - 1,
171                                     "Set page %"PRIu64" value %"PRIu64
172                                     " incorrect (iteration=%"PRIu64")",
173                                     page, *value_ptr, iteration);
174                 } else {
175                         host_clear_count++;
176                         /*
177                          * If cleared, the value written can be any
178                          * value smaller or equals to the iteration
179                          * number.  Note that the value can be exactly
180                          * (iteration-1) if that write can happen
181                          * like this:
182                          *
183                          * (1) increase loop count to "iteration-1"
184                          * (2) write to page P happens (with value
185                          *     "iteration-1")
186                          * (3) get dirty log for "iteration-1"; we'll
187                          *     see that page P bit is set (dirtied),
188                          *     and not set the bit in host_bmap_track
189                          * (4) increase loop count to "iteration"
190                          *     (which is current iteration)
191                          * (5) get dirty log for current iteration,
192                          *     we'll see that page P is cleared, with
193                          *     value "iteration-1".
194                          */
195                         TEST_ASSERT(*value_ptr <= iteration,
196                                     "Clear page %"PRIu64" value %"PRIu64
197                                     " incorrect (iteration=%"PRIu64")",
198                                     page, *value_ptr, iteration);
199                         if (*value_ptr == iteration) {
200                                 /*
201                                  * This page is _just_ modified; it
202                                  * should report its dirtyness in the
203                                  * next run
204                                  */
205                                 set_bit(page, host_bmap_track);
206                         }
207                 }
208         }
209 }
210
211 void help(char *name)
212 {
213         puts("");
214         printf("usage: %s [-i iterations] [-I interval] [-h]\n", name);
215         puts("");
216         printf(" -i: specify iteration counts (default: %"PRIu64")\n",
217                TEST_HOST_LOOP_N);
218         printf(" -I: specify interval in ms (default: %"PRIu64" ms)\n",
219                TEST_HOST_LOOP_INTERVAL);
220         puts("");
221         exit(0);
222 }
223
224 int main(int argc, char *argv[])
225 {
226         pthread_t vcpu_thread;
227         struct kvm_vm *vm;
228         uint64_t volatile *psize, *iteration;
229         unsigned long *bmap, iterations = TEST_HOST_LOOP_N,
230             interval = TEST_HOST_LOOP_INTERVAL;
231         int opt;
232
233         while ((opt = getopt(argc, argv, "hi:I:")) != -1) {
234                 switch (opt) {
235                 case 'i':
236                         iterations = strtol(optarg, NULL, 10);
237                         break;
238                 case 'I':
239                         interval = strtol(optarg, NULL, 10);
240                         break;
241                 case 'h':
242                 default:
243                         help(argv[0]);
244                         break;
245                 }
246         }
247
248         TEST_ASSERT(iterations > 2, "Iteration must be bigger than zero\n");
249         TEST_ASSERT(interval > 0, "Interval must be bigger than zero");
250
251         DEBUG("Test iterations: %"PRIu64", interval: %"PRIu64" (ms)\n",
252               iterations, interval);
253
254         srandom(time(0));
255
256         bmap = bitmap_alloc(TEST_MEM_PAGES);
257         host_bmap_track = bitmap_alloc(TEST_MEM_PAGES);
258
259         vm = vm_create_default(VCPU_ID, TEST_MEM_PAGES, guest_code);
260
261         /* Add an extra memory slot for testing dirty logging */
262         vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
263                                     TEST_MEM_OFFSET,
264                                     TEST_MEM_SLOT_INDEX,
265                                     TEST_MEM_PAGES,
266                                     KVM_MEM_LOG_DIRTY_PAGES);
267         /* Cache the HVA pointer of the region */
268         host_test_mem = addr_gpa2hva(vm, (vm_paddr_t)TEST_MEM_OFFSET);
269
270         /* Do 1:1 mapping for the dirty track memory slot */
271         virt_map(vm, TEST_MEM_OFFSET, TEST_MEM_OFFSET,
272                  TEST_MEM_PAGES * getpagesize(), 0);
273
274         vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
275
276         /* Tell the guest about the page size on the system */
277         psize = addr_gva2hva(vm, (vm_vaddr_t)&guest_page_size);
278         *psize = getpagesize();
279
280         /* Start the iterations */
281         iteration = addr_gva2hva(vm, (vm_vaddr_t)&guest_iteration);
282         *iteration = 1;
283
284         /* Start dirtying pages */
285         pthread_create(&vcpu_thread, NULL, vcpu_worker, vm);
286
287         while (*iteration < iterations) {
288                 /* Give the vcpu thread some time to dirty some pages */
289                 usleep(interval * 1000);
290                 kvm_vm_get_dirty_log(vm, TEST_MEM_SLOT_INDEX, bmap);
291                 vm_dirty_log_verify(bmap, *iteration);
292                 (*iteration)++;
293         }
294
295         /* Tell the vcpu thread to quit */
296         host_quit = true;
297         pthread_join(vcpu_thread, NULL);
298
299         DEBUG("Total bits checked: dirty (%"PRIu64"), clear (%"PRIu64"), "
300               "track_next (%"PRIu64")\n", host_dirty_count, host_clear_count,
301               host_track_next_count);
302
303         free(bmap);
304         free(host_bmap_track);
305         kvm_vm_free(vm);
306
307         return 0;
308 }