1
2
3
4
5
6
7
8
9
10
11#include "qemu/osdep.h"
12
13#include "qapi/error.h"
14#include "replication.h"
15#include "block/block_int.h"
16#include "sysemu/block-backend.h"
17
18#define IMG_SIZE (64 * 1024 * 1024)
19
20
21#define P_ID "primary-id"
22static char p_local_disk[] = "/tmp/p_local_disk.XXXXXX";
23
24
25#define S_ID "secondary-id"
26#define S_LOCAL_DISK_ID "secondary-local-disk-id"
27static char s_local_disk[] = "/tmp/s_local_disk.XXXXXX";
28static char s_active_disk[] = "/tmp/s_active_disk.XXXXXX";
29static char s_hidden_disk[] = "/tmp/s_hidden_disk.XXXXXX";
30
31
32QemuOptsList qemu_drive_opts = {
33 .name = "drive",
34 .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
35 .desc = {
36 { }
37 },
38};
39
40#define NOT_DONE 0x7fffffff
41
42static void blk_rw_done(void *opaque, int ret)
43{
44 *(int *)opaque = ret;
45}
46
47static void test_blk_read(BlockBackend *blk, long pattern,
48 int64_t pattern_offset, int64_t pattern_count,
49 int64_t offset, int64_t count,
50 bool expect_failed)
51{
52 void *pattern_buf = NULL;
53 QEMUIOVector qiov;
54 void *cmp_buf = NULL;
55 int async_ret = NOT_DONE;
56
57 if (pattern) {
58 cmp_buf = g_malloc(pattern_count);
59 memset(cmp_buf, pattern, pattern_count);
60 }
61
62 pattern_buf = g_malloc(count);
63 if (pattern) {
64 memset(pattern_buf, pattern, count);
65 } else {
66 memset(pattern_buf, 0x00, count);
67 }
68
69 qemu_iovec_init(&qiov, 1);
70 qemu_iovec_add(&qiov, pattern_buf, count);
71
72 blk_aio_preadv(blk, offset, &qiov, 0, blk_rw_done, &async_ret);
73 while (async_ret == NOT_DONE) {
74 main_loop_wait(false);
75 }
76
77 if (expect_failed) {
78 g_assert(async_ret != 0);
79 } else {
80 g_assert(async_ret == 0);
81 if (pattern) {
82 g_assert(memcmp(pattern_buf + pattern_offset,
83 cmp_buf, pattern_count) <= 0);
84 }
85 }
86
87 g_free(pattern_buf);
88 g_free(cmp_buf);
89 qemu_iovec_destroy(&qiov);
90}
91
92static void test_blk_write(BlockBackend *blk, long pattern, int64_t offset,
93 int64_t count, bool expect_failed)
94{
95 void *pattern_buf = NULL;
96 QEMUIOVector qiov;
97 int async_ret = NOT_DONE;
98
99 pattern_buf = g_malloc(count);
100 if (pattern) {
101 memset(pattern_buf, pattern, count);
102 } else {
103 memset(pattern_buf, 0x00, count);
104 }
105
106 qemu_iovec_init(&qiov, 1);
107 qemu_iovec_add(&qiov, pattern_buf, count);
108
109 blk_aio_pwritev(blk, offset, &qiov, 0, blk_rw_done, &async_ret);
110 while (async_ret == NOT_DONE) {
111 main_loop_wait(false);
112 }
113
114 if (expect_failed) {
115 g_assert(async_ret != 0);
116 } else {
117 g_assert(async_ret == 0);
118 }
119
120 g_free(pattern_buf);
121 qemu_iovec_destroy(&qiov);
122}
123
124
125
126
127static void make_temp(char *template)
128{
129 int fd;
130
131 fd = mkstemp(template);
132 g_assert(fd >= 0);
133 close(fd);
134}
135
136static void prepare_imgs(void)
137{
138 Error *local_err = NULL;
139
140 make_temp(p_local_disk);
141 make_temp(s_local_disk);
142 make_temp(s_active_disk);
143 make_temp(s_hidden_disk);
144
145
146 bdrv_img_create(p_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
147 BDRV_O_RDWR, true, &local_err);
148 g_assert(!local_err);
149
150
151 bdrv_img_create(s_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
152 BDRV_O_RDWR, true, &local_err);
153 g_assert(!local_err);
154 bdrv_img_create(s_active_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
155 BDRV_O_RDWR, true, &local_err);
156 g_assert(!local_err);
157 bdrv_img_create(s_hidden_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
158 BDRV_O_RDWR, true, &local_err);
159 g_assert(!local_err);
160}
161
162static void cleanup_imgs(void)
163{
164
165 unlink(p_local_disk);
166
167
168 unlink(s_local_disk);
169 unlink(s_active_disk);
170 unlink(s_hidden_disk);
171}
172
173static BlockBackend *start_primary(void)
174{
175 BlockBackend *blk;
176 QemuOpts *opts;
177 QDict *qdict;
178 Error *local_err = NULL;
179 char *cmdline;
180
181 cmdline = g_strdup_printf("driver=replication,mode=primary,node-name=xxx,"
182 "file.driver=qcow2,file.file.filename=%s,"
183 "file.file.locking=off"
184 , p_local_disk);
185 opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
186 g_free(cmdline);
187
188 qdict = qemu_opts_to_qdict(opts, NULL);
189 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
190 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
191
192 blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
193 g_assert(blk);
194 g_assert(!local_err);
195
196 monitor_add_blk(blk, P_ID, &local_err);
197 g_assert(!local_err);
198
199 qemu_opts_del(opts);
200
201 return blk;
202}
203
204static void teardown_primary(void)
205{
206 BlockBackend *blk;
207
208
209 blk = blk_by_name(P_ID);
210 assert(blk);
211
212 monitor_remove_blk(blk);
213 blk_unref(blk);
214}
215
216static void test_primary_read(void)
217{
218 BlockBackend *blk;
219
220 blk = start_primary();
221
222
223 test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
224
225 teardown_primary();
226}
227
228static void test_primary_write(void)
229{
230 BlockBackend *blk;
231
232 blk = start_primary();
233
234
235 test_blk_write(blk, 0, 0, IMG_SIZE, true);
236
237 teardown_primary();
238}
239
240static void test_primary_start(void)
241{
242 BlockBackend *blk = NULL;
243 Error *local_err = NULL;
244
245 blk = start_primary();
246
247 replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
248 g_assert(!local_err);
249
250
251 test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
252
253
254 test_blk_write(blk, 0x22, 0, IMG_SIZE, false);
255
256 teardown_primary();
257}
258
259static void test_primary_stop(void)
260{
261 Error *local_err = NULL;
262 bool failover = true;
263
264 start_primary();
265
266 replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
267 g_assert(!local_err);
268
269 replication_stop_all(failover, &local_err);
270 g_assert(!local_err);
271
272 teardown_primary();
273}
274
275static void test_primary_do_checkpoint(void)
276{
277 Error *local_err = NULL;
278
279 start_primary();
280
281 replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
282 g_assert(!local_err);
283
284 replication_do_checkpoint_all(&local_err);
285 g_assert(!local_err);
286
287 teardown_primary();
288}
289
290static void test_primary_get_error_all(void)
291{
292 Error *local_err = NULL;
293
294 start_primary();
295
296 replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
297 g_assert(!local_err);
298
299 replication_get_error_all(&local_err);
300 g_assert(!local_err);
301
302 teardown_primary();
303}
304
305static BlockBackend *start_secondary(void)
306{
307 QemuOpts *opts;
308 QDict *qdict;
309 BlockBackend *blk;
310 char *cmdline;
311 Error *local_err = NULL;
312
313
314 cmdline = g_strdup_printf("file.filename=%s,driver=qcow2,"
315 "file.locking=off",
316 s_local_disk);
317 opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
318 g_free(cmdline);
319
320 qdict = qemu_opts_to_qdict(opts, NULL);
321 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
322 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
323
324 blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
325 assert(blk);
326 monitor_add_blk(blk, S_LOCAL_DISK_ID, &local_err);
327 g_assert(!local_err);
328
329
330 test_blk_write(blk, 0x11, 0, IMG_SIZE, false);
331
332 qemu_opts_del(opts);
333
334
335 cmdline = g_strdup_printf("driver=replication,mode=secondary,top-id=%s,"
336 "file.driver=qcow2,file.file.filename=%s,"
337 "file.file.locking=off,"
338 "file.backing.driver=qcow2,"
339 "file.backing.file.filename=%s,"
340 "file.backing.file.locking=off,"
341 "file.backing.backing=%s"
342 , S_ID, s_active_disk, s_hidden_disk
343 , S_LOCAL_DISK_ID);
344 opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
345 g_free(cmdline);
346
347 qdict = qemu_opts_to_qdict(opts, NULL);
348 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
349 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
350
351 blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
352 assert(blk);
353 monitor_add_blk(blk, S_ID, &local_err);
354 g_assert(!local_err);
355
356 qemu_opts_del(opts);
357
358 return blk;
359}
360
361static void teardown_secondary(void)
362{
363
364 BlockBackend *blk;
365
366
367 blk = blk_by_name(S_LOCAL_DISK_ID);
368 assert(blk);
369
370 monitor_remove_blk(blk);
371 blk_unref(blk);
372
373
374 blk = blk_by_name(S_ID);
375 assert(blk);
376
377 monitor_remove_blk(blk);
378 blk_unref(blk);
379}
380
381static void test_secondary_read(void)
382{
383 BlockBackend *blk;
384
385 blk = start_secondary();
386
387
388 test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
389
390 teardown_secondary();
391}
392
393static void test_secondary_write(void)
394{
395 BlockBackend *blk;
396
397 blk = start_secondary();
398
399
400 test_blk_write(blk, 0, 0, IMG_SIZE, true);
401
402 teardown_secondary();
403}
404
405static void test_secondary_start(void)
406{
407 BlockBackend *top_blk, *local_blk;
408 Error *local_err = NULL;
409 bool failover = true;
410
411 top_blk = start_secondary();
412 replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
413 g_assert(!local_err);
414
415
416 test_blk_read(top_blk, 0x11, 0, IMG_SIZE, 0, IMG_SIZE, false);
417
418
419 local_blk = blk_by_name(S_LOCAL_DISK_ID);
420 test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
421
422
423 test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
424 IMG_SIZE / 2, 0, IMG_SIZE, false);
425
426
427 test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
428
429
430 test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
431 0, IMG_SIZE / 2, false);
432
433
434 replication_stop_all(failover, &local_err);
435 g_assert(!local_err);
436
437 teardown_secondary();
438}
439
440
441static void test_secondary_stop(void)
442{
443 BlockBackend *top_blk, *local_blk;
444 Error *local_err = NULL;
445 bool failover = true;
446
447 top_blk = start_secondary();
448 replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
449 g_assert(!local_err);
450
451
452 local_blk = blk_by_name(S_LOCAL_DISK_ID);
453 test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
454
455
456 test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
457 IMG_SIZE / 2, 0, IMG_SIZE, false);
458
459
460 test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
461
462
463 replication_stop_all(failover, &local_err);
464 g_assert(!local_err);
465
466
467 test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
468 0, IMG_SIZE / 2, false);
469
470
471
472 test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
473 IMG_SIZE / 2, 0, IMG_SIZE, false);
474
475 teardown_secondary();
476}
477
478static void test_secondary_do_checkpoint(void)
479{
480 BlockBackend *top_blk, *local_blk;
481 Error *local_err = NULL;
482 bool failover = true;
483
484 top_blk = start_secondary();
485 replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
486 g_assert(!local_err);
487
488
489 local_blk = blk_by_name(S_LOCAL_DISK_ID);
490 test_blk_write(local_blk, 0x22, IMG_SIZE / 2,
491 IMG_SIZE / 2, false);
492
493
494 test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
495 IMG_SIZE / 2, 0, IMG_SIZE, false);
496
497 replication_do_checkpoint_all(&local_err);
498 g_assert(!local_err);
499
500
501 test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
502 IMG_SIZE / 2, 0, IMG_SIZE, false);
503
504
505 replication_stop_all(failover, &local_err);
506 g_assert(!local_err);
507
508 teardown_secondary();
509}
510
511static void test_secondary_get_error_all(void)
512{
513 Error *local_err = NULL;
514 bool failover = true;
515
516 start_secondary();
517 replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
518 g_assert(!local_err);
519
520 replication_get_error_all(&local_err);
521 g_assert(!local_err);
522
523
524 replication_stop_all(failover, &local_err);
525 g_assert(!local_err);
526
527 teardown_secondary();
528}
529
530static void sigabrt_handler(int signo)
531{
532 cleanup_imgs();
533}
534
535static void setup_sigabrt_handler(void)
536{
537 struct sigaction sigact;
538
539 sigact = (struct sigaction) {
540 .sa_handler = sigabrt_handler,
541 .sa_flags = SA_RESETHAND,
542 };
543 sigemptyset(&sigact.sa_mask);
544 sigaction(SIGABRT, &sigact, NULL);
545}
546
547int main(int argc, char **argv)
548{
549 int ret;
550 qemu_init_main_loop(&error_fatal);
551 bdrv_init();
552
553 g_test_init(&argc, &argv, NULL);
554 setup_sigabrt_handler();
555
556 prepare_imgs();
557
558
559 g_test_add_func("/replication/primary/read", test_primary_read);
560 g_test_add_func("/replication/primary/write", test_primary_write);
561 g_test_add_func("/replication/primary/start", test_primary_start);
562 g_test_add_func("/replication/primary/stop", test_primary_stop);
563 g_test_add_func("/replication/primary/do_checkpoint",
564 test_primary_do_checkpoint);
565 g_test_add_func("/replication/primary/get_error_all",
566 test_primary_get_error_all);
567
568
569 g_test_add_func("/replication/secondary/read", test_secondary_read);
570 g_test_add_func("/replication/secondary/write", test_secondary_write);
571 g_test_add_func("/replication/secondary/start", test_secondary_start);
572 g_test_add_func("/replication/secondary/stop", test_secondary_stop);
573 g_test_add_func("/replication/secondary/do_checkpoint",
574 test_secondary_do_checkpoint);
575 g_test_add_func("/replication/secondary/get_error_all",
576 test_secondary_get_error_all);
577
578 ret = g_test_run();
579
580 cleanup_imgs();
581
582 return ret;
583}
584
