cirrus: fix off-by-one in cirrus_bitblt_rop_bkwd_transp_*_16
[qemu.git] / tests / postcopy-test.c
1 /*
2 * QTest testcase for postcopy
3 *
4 * Copyright (c) 2016 Red Hat, Inc. and/or its affiliates
5 * based on the vhost-user-test.c that is:
6 * Copyright (c) 2014 Virtual Open Systems Sarl.
7 *
8 * This work is licensed under the terms of the GNU GPL, version 2 or later.
9 * See the COPYING file in the top-level directory.
10 *
11 */
12
13 #include "qemu/osdep.h"
14
15 #include "libqtest.h"
16 #include "qemu/option.h"
17 #include "qemu/range.h"
18 #include "qemu/sockets.h"
19 #include "sysemu/char.h"
20 #include "sysemu/sysemu.h"
21 #include "hw/nvram/chrp_nvram.h"
22
23 #define MIN_NVRAM_SIZE 8192 /* from spapr_nvram.c */
24
25 const unsigned start_address = 1024 * 1024;
26 const unsigned end_address = 100 * 1024 * 1024;
27 bool got_stop;
28
29 #if defined(__linux__)
30 #include <sys/syscall.h>
31 #include <sys/vfs.h>
32 #endif
33
34 #if defined(__linux__) && defined(__NR_userfaultfd) && defined(CONFIG_EVENTFD)
35 #include <sys/eventfd.h>
36 #include <sys/ioctl.h>
37 #include <linux/userfaultfd.h>
38
39 static bool ufd_version_check(void)
40 {
41 struct uffdio_api api_struct;
42 uint64_t ioctl_mask;
43
44 int ufd = ufd = syscall(__NR_userfaultfd, O_CLOEXEC);
45
46 if (ufd == -1) {
47 g_test_message("Skipping test: userfaultfd not available");
48 return false;
49 }
50
51 api_struct.api = UFFD_API;
52 api_struct.features = 0;
53 if (ioctl(ufd, UFFDIO_API, &api_struct)) {
54 g_test_message("Skipping test: UFFDIO_API failed");
55 return false;
56 }
57
58 ioctl_mask = (__u64)1 << _UFFDIO_REGISTER |
59 (__u64)1 << _UFFDIO_UNREGISTER;
60 if ((api_struct.ioctls & ioctl_mask) != ioctl_mask) {
61 g_test_message("Skipping test: Missing userfault feature");
62 return false;
63 }
64
65 return true;
66 }
67
68 #else
69 static bool ufd_version_check(void)
70 {
71 g_test_message("Skipping test: Userfault not available (builtdtime)");
72 return false;
73 }
74
75 #endif
76
77 static const char *tmpfs;
78
79 /* A simple PC boot sector that modifies memory (1-100MB) quickly
80 * outputing a 'B' every so often if it's still running.
81 */
82 unsigned char bootsect[] = {
83 0xfa, 0x0f, 0x01, 0x16, 0x74, 0x7c, 0x66, 0xb8, 0x01, 0x00, 0x00, 0x00,
84 0x0f, 0x22, 0xc0, 0x66, 0xea, 0x20, 0x7c, 0x00, 0x00, 0x08, 0x00, 0x00,
85 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x92, 0x0c, 0x02,
86 0xe6, 0x92, 0xb8, 0x10, 0x00, 0x00, 0x00, 0x8e, 0xd8, 0x66, 0xb8, 0x41,
87 0x00, 0x66, 0xba, 0xf8, 0x03, 0xee, 0xb3, 0x00, 0xb8, 0x00, 0x00, 0x10,
88 0x00, 0xfe, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x40,
89 0x06, 0x7c, 0xf2, 0xfe, 0xc3, 0x75, 0xe9, 0x66, 0xb8, 0x42, 0x00, 0x66,
90 0xba, 0xf8, 0x03, 0xee, 0xeb, 0xde, 0x66, 0x90, 0x00, 0x00, 0x00, 0x00,
91 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x9a, 0xcf, 0x00,
92 0xff, 0xff, 0x00, 0x00, 0x00, 0x92, 0xcf, 0x00, 0x27, 0x00, 0x5c, 0x7c,
93 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
94 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
95 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
96 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
97 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
98 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
99 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
103 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
104 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
108 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
109 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
110 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
114 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
116 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
117 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
118 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
120 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
123 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0xaa
126 };
127
128 static void init_bootfile_x86(const char *bootpath)
129 {
130 FILE *bootfile = fopen(bootpath, "wb");
131
132 g_assert_cmpint(fwrite(bootsect, 512, 1, bootfile), ==, 1);
133 fclose(bootfile);
134 }
135
136 static void init_bootfile_ppc(const char *bootpath)
137 {
138 FILE *bootfile;
139 char buf[MIN_NVRAM_SIZE];
140 ChrpNvramPartHdr *header = (ChrpNvramPartHdr *)buf;
141
142 memset(buf, 0, MIN_NVRAM_SIZE);
143
144 /* Create a "common" partition in nvram to store boot-command property */
145
146 header->signature = CHRP_NVPART_SYSTEM;
147 memcpy(header->name, "common", 6);
148 chrp_nvram_finish_partition(header, MIN_NVRAM_SIZE);
149
150 /* FW_MAX_SIZE is 4MB, but slof.bin is only 900KB,
151 * so let's modify memory between 1MB and 100MB
152 * to do like PC bootsector
153 */
154
155 sprintf(buf + 16,
156 "boot-command=hex .\" _\" begin %x %x do i c@ 1 + i c! 1000 +loop "
157 ".\" B\" 0 until", end_address, start_address);
158
159 /* Write partition to the NVRAM file */
160
161 bootfile = fopen(bootpath, "wb");
162 g_assert_cmpint(fwrite(buf, MIN_NVRAM_SIZE, 1, bootfile), ==, 1);
163 fclose(bootfile);
164 }
165
166 /*
167 * Wait for some output in the serial output file,
168 * we get an 'A' followed by an endless string of 'B's
169 * but on the destination we won't have the A.
170 */
171 static void wait_for_serial(const char *side)
172 {
173 char *serialpath = g_strdup_printf("%s/%s", tmpfs, side);
174 FILE *serialfile = fopen(serialpath, "r");
175 const char *arch = qtest_get_arch();
176 int started = (strcmp(side, "src_serial") == 0 &&
177 strcmp(arch, "ppc64") == 0) ? 0 : 1;
178
179 g_free(serialpath);
180 do {
181 int readvalue = fgetc(serialfile);
182
183 if (!started) {
184 /* SLOF prints its banner before starting test,
185 * to ignore it, mark the start of the test with '_',
186 * ignore all characters until this marker
187 */
188 switch (readvalue) {
189 case '_':
190 started = 1;
191 break;
192 case EOF:
193 fseek(serialfile, 0, SEEK_SET);
194 usleep(1000);
195 break;
196 }
197 continue;
198 }
199 switch (readvalue) {
200 case 'A':
201 /* Fine */
202 break;
203
204 case 'B':
205 /* It's alive! */
206 fclose(serialfile);
207 return;
208
209 case EOF:
210 started = (strcmp(side, "src_serial") == 0 &&
211 strcmp(arch, "ppc64") == 0) ? 0 : 1;
212 fseek(serialfile, 0, SEEK_SET);
213 usleep(1000);
214 break;
215
216 default:
217 fprintf(stderr, "Unexpected %d on %s serial\n", readvalue, side);
218 g_assert_not_reached();
219 }
220 } while (true);
221 }
222
223 /*
224 * Events can get in the way of responses we are actually waiting for.
225 */
226 static QDict *return_or_event(QDict *response)
227 {
228 const char *event_string;
229 if (!qdict_haskey(response, "event")) {
230 return response;
231 }
232
233 /* OK, it was an event */
234 event_string = qdict_get_str(response, "event");
235 if (!strcmp(event_string, "STOP")) {
236 got_stop = true;
237 }
238 QDECREF(response);
239 return return_or_event(qtest_qmp_receive(global_qtest));
240 }
241
242
243 /*
244 * It's tricky to use qemu's migration event capability with qtest,
245 * events suddenly appearing confuse the qmp()/hmp() responses.
246 * so wait for a couple of passes to have happened before
247 * going postcopy.
248 */
249
250 static uint64_t get_migration_pass(void)
251 {
252 QDict *rsp, *rsp_return, *rsp_ram;
253 uint64_t result;
254
255 rsp = return_or_event(qmp("{ 'execute': 'query-migrate' }"));
256 rsp_return = qdict_get_qdict(rsp, "return");
257 if (!qdict_haskey(rsp_return, "ram")) {
258 /* Still in setup */
259 result = 0;
260 } else {
261 rsp_ram = qdict_get_qdict(rsp_return, "ram");
262 result = qdict_get_try_int(rsp_ram, "dirty-sync-count", 0);
263 }
264 QDECREF(rsp);
265 return result;
266 }
267
268 static void wait_for_migration_complete(void)
269 {
270 QDict *rsp, *rsp_return;
271 bool completed;
272
273 do {
274 const char *status;
275
276 rsp = return_or_event(qmp("{ 'execute': 'query-migrate' }"));
277 rsp_return = qdict_get_qdict(rsp, "return");
278 status = qdict_get_str(rsp_return, "status");
279 completed = strcmp(status, "completed") == 0;
280 g_assert_cmpstr(status, !=, "failed");
281 QDECREF(rsp);
282 usleep(1000 * 100);
283 } while (!completed);
284 }
285
286 static void wait_for_migration_pass(void)
287 {
288 uint64_t initial_pass = get_migration_pass();
289 uint64_t pass;
290
291 /* Wait for the 1st sync */
292 do {
293 initial_pass = get_migration_pass();
294 if (got_stop || initial_pass) {
295 break;
296 }
297 usleep(1000 * 100);
298 } while (true);
299
300 do {
301 usleep(1000 * 100);
302 pass = get_migration_pass();
303 } while (pass == initial_pass && !got_stop);
304 }
305
306 static void check_guests_ram(void)
307 {
308 /* Our ASM test will have been incrementing one byte from each page from
309 * 1MB to <100MB in order.
310 * This gives us a constraint that any page's byte should be equal or less
311 * than the previous pages byte (mod 256); and they should all be equal
312 * except for one transition at the point where we meet the incrementer.
313 * (We're running this with the guest stopped).
314 */
315 unsigned address;
316 uint8_t first_byte;
317 uint8_t last_byte;
318 bool hit_edge = false;
319 bool bad = false;
320
321 qtest_memread(global_qtest, start_address, &first_byte, 1);
322 last_byte = first_byte;
323
324 for (address = start_address + 4096; address < end_address; address += 4096)
325 {
326 uint8_t b;
327 qtest_memread(global_qtest, address, &b, 1);
328 if (b != last_byte) {
329 if (((b + 1) % 256) == last_byte && !hit_edge) {
330 /* This is OK, the guest stopped at the point of
331 * incrementing the previous page but didn't get
332 * to us yet.
333 */
334 hit_edge = true;
335 } else {
336 fprintf(stderr, "Memory content inconsistency at %x"
337 " first_byte = %x last_byte = %x current = %x"
338 " hit_edge = %x\n",
339 address, first_byte, last_byte, b, hit_edge);
340 bad = true;
341 }
342 }
343 last_byte = b;
344 }
345 g_assert_false(bad);
346 }
347
348 static void cleanup(const char *filename)
349 {
350 char *path = g_strdup_printf("%s/%s", tmpfs, filename);
351
352 unlink(path);
353 g_free(path);
354 }
355
356 static void test_migrate(void)
357 {
358 char *uri = g_strdup_printf("unix:%s/migsocket", tmpfs);
359 QTestState *global = global_qtest, *from, *to;
360 unsigned char dest_byte_a, dest_byte_b, dest_byte_c, dest_byte_d;
361 gchar *cmd, *cmd_src, *cmd_dst;
362 QDict *rsp;
363
364 char *bootpath = g_strdup_printf("%s/bootsect", tmpfs);
365 const char *arch = qtest_get_arch();
366
367 got_stop = false;
368
369 if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
370 init_bootfile_x86(bootpath);
371 cmd_src = g_strdup_printf("-machine accel=kvm:tcg -m 150M"
372 " -name pcsource,debug-threads=on"
373 " -serial file:%s/src_serial"
374 " -drive file=%s,format=raw",
375 tmpfs, bootpath);
376 cmd_dst = g_strdup_printf("-machine accel=kvm:tcg -m 150M"
377 " -name pcdest,debug-threads=on"
378 " -serial file:%s/dest_serial"
379 " -drive file=%s,format=raw"
380 " -incoming %s",
381 tmpfs, bootpath, uri);
382 } else if (strcmp(arch, "ppc64") == 0) {
383 const char *accel;
384
385 /* On ppc64, the test only works with kvm-hv, but not with kvm-pr */
386 accel = access("/sys/module/kvm_hv", F_OK) ? "tcg" : "kvm:tcg";
387 init_bootfile_ppc(bootpath);
388 cmd_src = g_strdup_printf("-machine accel=%s -m 256M"
389 " -name pcsource,debug-threads=on"
390 " -serial file:%s/src_serial"
391 " -drive file=%s,if=pflash,format=raw",
392 accel, tmpfs, bootpath);
393 cmd_dst = g_strdup_printf("-machine accel=%s -m 256M"
394 " -name pcdest,debug-threads=on"
395 " -serial file:%s/dest_serial"
396 " -incoming %s",
397 accel, tmpfs, uri);
398 } else {
399 g_assert_not_reached();
400 }
401
402 g_free(bootpath);
403
404 from = qtest_start(cmd_src);
405 g_free(cmd_src);
406
407 to = qtest_init(cmd_dst);
408 g_free(cmd_dst);
409
410 global_qtest = from;
411 rsp = qmp("{ 'execute': 'migrate-set-capabilities',"
412 "'arguments': { "
413 "'capabilities': [ {"
414 "'capability': 'postcopy-ram',"
415 "'state': true } ] } }");
416 g_assert(qdict_haskey(rsp, "return"));
417 QDECREF(rsp);
418
419 global_qtest = to;
420 rsp = qmp("{ 'execute': 'migrate-set-capabilities',"
421 "'arguments': { "
422 "'capabilities': [ {"
423 "'capability': 'postcopy-ram',"
424 "'state': true } ] } }");
425 g_assert(qdict_haskey(rsp, "return"));
426 QDECREF(rsp);
427
428 /* We want to pick a speed slow enough that the test completes
429 * quickly, but that it doesn't complete precopy even on a slow
430 * machine, so also set the downtime.
431 */
432 global_qtest = from;
433 rsp = qmp("{ 'execute': 'migrate_set_speed',"
434 "'arguments': { 'value': 100000000 } }");
435 g_assert(qdict_haskey(rsp, "return"));
436 QDECREF(rsp);
437
438 /* 1ms downtime - it should never finish precopy */
439 rsp = qmp("{ 'execute': 'migrate_set_downtime',"
440 "'arguments': { 'value': 0.001 } }");
441 g_assert(qdict_haskey(rsp, "return"));
442 QDECREF(rsp);
443
444
445 /* Wait for the first serial output from the source */
446 wait_for_serial("src_serial");
447
448 cmd = g_strdup_printf("{ 'execute': 'migrate',"
449 "'arguments': { 'uri': '%s' } }",
450 uri);
451 rsp = qmp(cmd);
452 g_free(cmd);
453 g_assert(qdict_haskey(rsp, "return"));
454 QDECREF(rsp);
455
456 wait_for_migration_pass();
457
458 rsp = return_or_event(qmp("{ 'execute': 'migrate-start-postcopy' }"));
459 g_assert(qdict_haskey(rsp, "return"));
460 QDECREF(rsp);
461
462 if (!got_stop) {
463 qmp_eventwait("STOP");
464 }
465
466 global_qtest = to;
467 qmp_eventwait("RESUME");
468
469 wait_for_serial("dest_serial");
470 global_qtest = from;
471 wait_for_migration_complete();
472
473 qtest_quit(from);
474
475 global_qtest = to;
476
477 qtest_memread(to, start_address, &dest_byte_a, 1);
478
479 /* Destination still running, wait for a byte to change */
480 do {
481 qtest_memread(to, start_address, &dest_byte_b, 1);
482 usleep(10 * 1000);
483 } while (dest_byte_a == dest_byte_b);
484
485 qmp_discard_response("{ 'execute' : 'stop'}");
486 /* With it stopped, check nothing changes */
487 qtest_memread(to, start_address, &dest_byte_c, 1);
488 sleep(1);
489 qtest_memread(to, start_address, &dest_byte_d, 1);
490 g_assert_cmpint(dest_byte_c, ==, dest_byte_d);
491
492 check_guests_ram();
493
494 qtest_quit(to);
495 g_free(uri);
496
497 global_qtest = global;
498
499 cleanup("bootsect");
500 cleanup("migsocket");
501 cleanup("src_serial");
502 cleanup("dest_serial");
503 }
504
505 int main(int argc, char **argv)
506 {
507 char template[] = "/tmp/postcopy-test-XXXXXX";
508 int ret;
509
510 g_test_init(&argc, &argv, NULL);
511
512 if (!ufd_version_check()) {
513 return 0;
514 }
515
516 tmpfs = mkdtemp(template);
517 if (!tmpfs) {
518 g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
519 }
520 g_assert(tmpfs);
521
522 module_call_init(MODULE_INIT_QOM);
523
524 qtest_add_func("/postcopy", test_migrate);
525
526 ret = g_test_run();
527
528 g_assert_cmpint(ret, ==, 0);
529
530 ret = rmdir(tmpfs);
531 if (ret != 0) {
532 g_test_message("unable to rmdir: path (%s): %s\n",
533 tmpfs, strerror(errno));
534 }
535
536 return ret;
537 }