2 * Block replication tests
4 * Copyright (c) 2016 FUJITSU LIMITED
5 * Author: Changlong Xie <xiecl.fnst@cn.fujitsu.com>
7 * This work is licensed under the terms of the GNU GPL, version 2 or
8 * later. See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
13 #include "qapi/error.h"
14 #include "qapi/qmp/qdict.h"
15 #include "qemu/option.h"
16 #include "qemu/main-loop.h"
17 #include "block/replication.h"
18 #include "block/block_int.h"
19 #include "block/qdict.h"
20 #include "sysemu/block-backend.h"
22 #define IMG_SIZE (64 * 1024 * 1024)
25 #define P_ID "primary-id"
26 static char *p_local_disk
;
29 #define S_ID "secondary-id"
30 #define S_LOCAL_DISK_ID "secondary-local-disk-id"
31 static char *s_local_disk
;
32 static char *s_active_disk
;
33 static char *s_hidden_disk
;
35 /* FIXME: steal from blockdev.c */
36 QemuOptsList qemu_drive_opts
= {
38 .head
= QTAILQ_HEAD_INITIALIZER(qemu_drive_opts
.head
),
44 #define NOT_DONE 0x7fffffff
46 static void blk_rw_done(void *opaque
, int ret
)
51 static void test_blk_read(BlockBackend
*blk
, long pattern
,
52 int64_t pattern_offset
, int64_t pattern_count
,
53 int64_t offset
, int64_t count
,
56 void *pattern_buf
= NULL
;
59 int async_ret
= NOT_DONE
;
62 cmp_buf
= g_malloc(pattern_count
);
63 memset(cmp_buf
, pattern
, pattern_count
);
66 pattern_buf
= g_malloc(count
);
68 memset(pattern_buf
, pattern
, count
);
70 memset(pattern_buf
, 0x00, count
);
73 qemu_iovec_init(&qiov
, 1);
74 qemu_iovec_add(&qiov
, pattern_buf
, count
);
76 blk_aio_preadv(blk
, offset
, &qiov
, 0, blk_rw_done
, &async_ret
);
77 while (async_ret
== NOT_DONE
) {
78 main_loop_wait(false);
82 g_assert(async_ret
!= 0);
84 g_assert(async_ret
== 0);
86 g_assert(memcmp(pattern_buf
+ pattern_offset
,
87 cmp_buf
, pattern_count
) <= 0);
93 qemu_iovec_destroy(&qiov
);
96 static void test_blk_write(BlockBackend
*blk
, long pattern
, int64_t offset
,
97 int64_t count
, bool expect_failed
)
99 void *pattern_buf
= NULL
;
101 int async_ret
= NOT_DONE
;
103 pattern_buf
= g_malloc(count
);
105 memset(pattern_buf
, pattern
, count
);
107 memset(pattern_buf
, 0x00, count
);
110 qemu_iovec_init(&qiov
, 1);
111 qemu_iovec_add(&qiov
, pattern_buf
, count
);
113 blk_aio_pwritev(blk
, offset
, &qiov
, 0, blk_rw_done
, &async_ret
);
114 while (async_ret
== NOT_DONE
) {
115 main_loop_wait(false);
119 g_assert(async_ret
!= 0);
121 g_assert(async_ret
== 0);
125 qemu_iovec_destroy(&qiov
);
129 * Create a uniquely-named empty temporary file.
131 static void make_temp(char *template)
135 fd
= mkstemp(template);
140 static void prepare_imgs(void)
142 make_temp(p_local_disk
);
143 make_temp(s_local_disk
);
144 make_temp(s_active_disk
);
145 make_temp(s_hidden_disk
);
148 bdrv_img_create(p_local_disk
, "qcow2", NULL
, NULL
, NULL
, IMG_SIZE
,
149 BDRV_O_RDWR
, true, &error_abort
);
152 bdrv_img_create(s_local_disk
, "qcow2", NULL
, NULL
, NULL
, IMG_SIZE
,
153 BDRV_O_RDWR
, true, &error_abort
);
154 bdrv_img_create(s_active_disk
, "qcow2", NULL
, NULL
, NULL
, IMG_SIZE
,
155 BDRV_O_RDWR
, true, &error_abort
);
156 bdrv_img_create(s_hidden_disk
, "qcow2", NULL
, NULL
, NULL
, IMG_SIZE
,
157 BDRV_O_RDWR
, true, &error_abort
);
160 static void cleanup_imgs(void)
163 unlink(p_local_disk
);
166 unlink(s_local_disk
);
167 unlink(s_active_disk
);
168 unlink(s_hidden_disk
);
171 static BlockBackend
*start_primary(void)
178 cmdline
= g_strdup_printf("driver=replication,mode=primary,node-name=xxx,"
179 "file.driver=qcow2,file.file.filename=%s,"
180 "file.file.locking=off"
182 opts
= qemu_opts_parse_noisily(&qemu_drive_opts
, cmdline
, false);
185 qdict
= qemu_opts_to_qdict(opts
, NULL
);
186 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_DIRECT
, "off");
187 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
189 blk
= blk_new_open(NULL
, NULL
, qdict
, BDRV_O_RDWR
, &error_abort
);
192 monitor_add_blk(blk
, P_ID
, &error_abort
);
199 static void teardown_primary(void)
204 blk
= blk_by_name(P_ID
);
207 monitor_remove_blk(blk
);
211 static void test_primary_read(void)
215 blk
= start_primary();
217 /* read from 0 to IMG_SIZE */
218 test_blk_read(blk
, 0, 0, IMG_SIZE
, 0, IMG_SIZE
, true);
223 static void test_primary_write(void)
227 blk
= start_primary();
229 /* write from 0 to IMG_SIZE */
230 test_blk_write(blk
, 0, 0, IMG_SIZE
, true);
235 static void test_primary_start(void)
237 BlockBackend
*blk
= NULL
;
239 blk
= start_primary();
241 replication_start_all(REPLICATION_MODE_PRIMARY
, &error_abort
);
243 /* read from 0 to IMG_SIZE */
244 test_blk_read(blk
, 0, 0, IMG_SIZE
, 0, IMG_SIZE
, true);
246 /* write 0x22 from 0 to IMG_SIZE */
247 test_blk_write(blk
, 0x22, 0, IMG_SIZE
, false);
252 static void test_primary_stop(void)
254 bool failover
= true;
258 replication_start_all(REPLICATION_MODE_PRIMARY
, &error_abort
);
260 replication_stop_all(failover
, &error_abort
);
265 static void test_primary_do_checkpoint(void)
269 replication_start_all(REPLICATION_MODE_PRIMARY
, &error_abort
);
271 replication_do_checkpoint_all(&error_abort
);
276 static void test_primary_get_error_all(void)
280 replication_start_all(REPLICATION_MODE_PRIMARY
, &error_abort
);
282 replication_get_error_all(&error_abort
);
287 static BlockBackend
*start_secondary(void)
294 /* add s_local_disk and forge S_LOCAL_DISK_ID */
295 cmdline
= g_strdup_printf("file.filename=%s,driver=qcow2,"
298 opts
= qemu_opts_parse_noisily(&qemu_drive_opts
, cmdline
, false);
301 qdict
= qemu_opts_to_qdict(opts
, NULL
);
302 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_DIRECT
, "off");
303 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
305 blk
= blk_new_open(NULL
, NULL
, qdict
, BDRV_O_RDWR
, &error_abort
);
307 monitor_add_blk(blk
, S_LOCAL_DISK_ID
, &error_abort
);
309 /* format s_local_disk with pattern "0x11" */
310 test_blk_write(blk
, 0x11, 0, IMG_SIZE
, false);
314 /* add S_(ACTIVE/HIDDEN)_DISK and forge S_ID */
315 cmdline
= g_strdup_printf("driver=replication,mode=secondary,top-id=%s,"
316 "file.driver=qcow2,file.file.filename=%s,"
317 "file.file.locking=off,"
318 "file.backing.driver=qcow2,"
319 "file.backing.file.filename=%s,"
320 "file.backing.file.locking=off,"
321 "file.backing.backing=%s"
322 , S_ID
, s_active_disk
, s_hidden_disk
324 opts
= qemu_opts_parse_noisily(&qemu_drive_opts
, cmdline
, false);
327 qdict
= qemu_opts_to_qdict(opts
, NULL
);
328 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_DIRECT
, "off");
329 qdict_set_default_str(qdict
, BDRV_OPT_CACHE_NO_FLUSH
, "off");
331 blk
= blk_new_open(NULL
, NULL
, qdict
, BDRV_O_RDWR
, &error_abort
);
333 monitor_add_blk(blk
, S_ID
, &error_abort
);
340 static void teardown_secondary(void)
342 /* only need to destroy two BBs */
345 /* remove S_LOCAL_DISK_ID */
346 blk
= blk_by_name(S_LOCAL_DISK_ID
);
349 monitor_remove_blk(blk
);
353 blk
= blk_by_name(S_ID
);
356 monitor_remove_blk(blk
);
360 static void test_secondary_read(void)
364 blk
= start_secondary();
366 /* read from 0 to IMG_SIZE */
367 test_blk_read(blk
, 0, 0, IMG_SIZE
, 0, IMG_SIZE
, true);
369 teardown_secondary();
372 static void test_secondary_write(void)
376 blk
= start_secondary();
378 /* write from 0 to IMG_SIZE */
379 test_blk_write(blk
, 0, 0, IMG_SIZE
, true);
381 teardown_secondary();
385 static void test_secondary_start(void)
387 BlockBackend
*top_blk
, *local_blk
;
388 bool failover
= true;
390 top_blk
= start_secondary();
391 replication_start_all(REPLICATION_MODE_SECONDARY
, &error_abort
);
393 /* read from s_local_disk (0, IMG_SIZE) */
394 test_blk_read(top_blk
, 0x11, 0, IMG_SIZE
, 0, IMG_SIZE
, false);
396 /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
397 local_blk
= blk_by_name(S_LOCAL_DISK_ID
);
398 test_blk_write(local_blk
, 0x22, IMG_SIZE
/ 2, IMG_SIZE
/ 2, false);
400 /* replication will backup s_local_disk to s_hidden_disk */
401 test_blk_read(top_blk
, 0x11, IMG_SIZE
/ 2,
402 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
404 /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
405 test_blk_write(top_blk
, 0x33, 0, IMG_SIZE
/ 2, false);
407 /* read from s_active_disk (0, IMG_SIZE/2) */
408 test_blk_read(top_blk
, 0x33, 0, IMG_SIZE
/ 2,
409 0, IMG_SIZE
/ 2, false);
412 replication_stop_all(failover
, &error_abort
);
414 teardown_secondary();
418 static void test_secondary_stop(void)
420 BlockBackend
*top_blk
, *local_blk
;
421 bool failover
= true;
423 top_blk
= start_secondary();
424 replication_start_all(REPLICATION_MODE_SECONDARY
, &error_abort
);
426 /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
427 local_blk
= blk_by_name(S_LOCAL_DISK_ID
);
428 test_blk_write(local_blk
, 0x22, IMG_SIZE
/ 2, IMG_SIZE
/ 2, false);
430 /* replication will backup s_local_disk to s_hidden_disk */
431 test_blk_read(top_blk
, 0x11, IMG_SIZE
/ 2,
432 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
434 /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
435 test_blk_write(top_blk
, 0x33, 0, IMG_SIZE
/ 2, false);
437 /* do active commit */
438 replication_stop_all(failover
, &error_abort
);
440 /* read from s_local_disk (0, IMG_SIZE / 2) */
441 test_blk_read(top_blk
, 0x33, 0, IMG_SIZE
/ 2,
442 0, IMG_SIZE
/ 2, false);
445 /* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
446 test_blk_read(top_blk
, 0x22, IMG_SIZE
/ 2,
447 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
449 teardown_secondary();
452 static void test_secondary_continuous_replication(void)
454 BlockBackend
*top_blk
, *local_blk
;
456 top_blk
= start_secondary();
457 replication_start_all(REPLICATION_MODE_SECONDARY
, &error_abort
);
459 /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
460 local_blk
= blk_by_name(S_LOCAL_DISK_ID
);
461 test_blk_write(local_blk
, 0x22, IMG_SIZE
/ 2, IMG_SIZE
/ 2, false);
463 /* replication will backup s_local_disk to s_hidden_disk */
464 test_blk_read(top_blk
, 0x11, IMG_SIZE
/ 2,
465 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
467 /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
468 test_blk_write(top_blk
, 0x33, 0, IMG_SIZE
/ 2, false);
470 /* do failover (active commit) */
471 replication_stop_all(true, &error_abort
);
473 /* it should ignore all requests from now on */
475 /* start after failover */
476 replication_start_all(REPLICATION_MODE_PRIMARY
, &error_abort
);
479 replication_do_checkpoint_all(&error_abort
);
482 replication_stop_all(true, &error_abort
);
484 /* read from s_local_disk (0, IMG_SIZE / 2) */
485 test_blk_read(top_blk
, 0x33, 0, IMG_SIZE
/ 2,
486 0, IMG_SIZE
/ 2, false);
489 /* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
490 test_blk_read(top_blk
, 0x22, IMG_SIZE
/ 2,
491 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
493 teardown_secondary();
496 static void test_secondary_do_checkpoint(void)
498 BlockBackend
*top_blk
, *local_blk
;
499 bool failover
= true;
501 top_blk
= start_secondary();
502 replication_start_all(REPLICATION_MODE_SECONDARY
, &error_abort
);
504 /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
505 local_blk
= blk_by_name(S_LOCAL_DISK_ID
);
506 test_blk_write(local_blk
, 0x22, IMG_SIZE
/ 2,
507 IMG_SIZE
/ 2, false);
509 /* replication will backup s_local_disk to s_hidden_disk */
510 test_blk_read(top_blk
, 0x11, IMG_SIZE
/ 2,
511 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
513 replication_do_checkpoint_all(&error_abort
);
515 /* after checkpoint, read pattern 0x22 from s_local_disk */
516 test_blk_read(top_blk
, 0x22, IMG_SIZE
/ 2,
517 IMG_SIZE
/ 2, 0, IMG_SIZE
, false);
520 replication_stop_all(failover
, &error_abort
);
522 teardown_secondary();
525 static void test_secondary_get_error_all(void)
527 bool failover
= true;
530 replication_start_all(REPLICATION_MODE_SECONDARY
, &error_abort
);
532 replication_get_error_all(&error_abort
);
535 replication_stop_all(failover
, &error_abort
);
537 teardown_secondary();
541 static void sigabrt_handler(int signo
)
546 static void setup_sigabrt_handler(void)
549 signal(SIGABRT
, sigabrt_handler
);
551 struct sigaction sigact
;
553 sigact
= (struct sigaction
) {
554 .sa_handler
= sigabrt_handler
,
555 .sa_flags
= SA_RESETHAND
,
557 sigemptyset(&sigact
.sa_mask
);
558 sigaction(SIGABRT
, &sigact
, NULL
);
562 int main(int argc
, char **argv
)
565 const char *tmpdir
= g_get_tmp_dir();
566 p_local_disk
= g_strdup_printf("%s/p_local_disk.XXXXXX", tmpdir
);
567 s_local_disk
= g_strdup_printf("%s/s_local_disk.XXXXXX", tmpdir
);
568 s_active_disk
= g_strdup_printf("%s/s_active_disk.XXXXXX", tmpdir
);
569 s_hidden_disk
= g_strdup_printf("%s/s_hidden_disk.XXXXXX", tmpdir
);
570 qemu_init_main_loop(&error_fatal
);
573 g_test_init(&argc
, &argv
, NULL
);
574 setup_sigabrt_handler();
579 g_test_add_func("/replication/primary/read", test_primary_read
);
580 g_test_add_func("/replication/primary/write", test_primary_write
);
581 g_test_add_func("/replication/primary/start", test_primary_start
);
582 g_test_add_func("/replication/primary/stop", test_primary_stop
);
583 g_test_add_func("/replication/primary/do_checkpoint",
584 test_primary_do_checkpoint
);
585 g_test_add_func("/replication/primary/get_error_all",
586 test_primary_get_error_all
);
589 g_test_add_func("/replication/secondary/read", test_secondary_read
);
590 g_test_add_func("/replication/secondary/write", test_secondary_write
);
592 g_test_add_func("/replication/secondary/start", test_secondary_start
);
593 g_test_add_func("/replication/secondary/stop", test_secondary_stop
);
594 g_test_add_func("/replication/secondary/continuous_replication",
595 test_secondary_continuous_replication
);
596 g_test_add_func("/replication/secondary/do_checkpoint",
597 test_secondary_do_checkpoint
);
598 g_test_add_func("/replication/secondary/get_error_all",
599 test_secondary_get_error_all
);
606 g_free(p_local_disk
);
607 g_free(s_local_disk
);
608 g_free(s_active_disk
);
609 g_free(s_hidden_disk
);