[qemu.git] / tests / test-replication.c

/*
 * Block replication tests
 *
 * Copyright (c) 2016 FUJITSU LIMITED
 * Author: Changlong Xie <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * later.  See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"

#include "qapi/error.h"
#include "replication.h"
#include "block/block_int.h"
#include "sysemu/block-backend.h"

#define IMG_SIZE (64 * 1024 * 1024)

/* primary */
#define P_ID "primary-id"
static char p_local_disk[] = "/tmp/p_local_disk.XXXXXX";

/* secondary */
#define S_ID "secondary-id"
#define S_LOCAL_DISK_ID "secondary-local-disk-id"
static char s_local_disk[] = "/tmp/s_local_disk.XXXXXX";
static char s_active_disk[] = "/tmp/s_active_disk.XXXXXX";
static char s_hidden_disk[] = "/tmp/s_hidden_disk.XXXXXX";

/* FIXME: steal from blockdev.c */
QemuOptsList qemu_drive_opts = {
    .name = "drive",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
    .desc = {
        { /* end of list */ }
    },
};

#define NOT_DONE 0x7fffffff

static void blk_rw_done(void *opaque, int ret)
{
    *(int *)opaque = ret;
}

static void test_blk_read(BlockBackend *blk, long pattern,
                          int64_t pattern_offset, int64_t pattern_count,
                          int64_t offset, int64_t count,
                          bool expect_failed)
{
    void *pattern_buf = NULL;
    QEMUIOVector qiov;
    void *cmp_buf = NULL;
    int async_ret = NOT_DONE;

    if (pattern) {
        cmp_buf = g_malloc(pattern_count);
        memset(cmp_buf, pattern, pattern_count);
    }

    pattern_buf = g_malloc(count);
    if (pattern) {
        memset(pattern_buf, pattern, count);
    } else {
        memset(pattern_buf, 0x00, count);
    }

    qemu_iovec_init(&qiov, 1);
    qemu_iovec_add(&qiov, pattern_buf, count);

    blk_aio_preadv(blk, offset, &qiov, 0, blk_rw_done, &async_ret);
    while (async_ret == NOT_DONE) {
        main_loop_wait(false);
    }

    if (expect_failed) {
        g_assert(async_ret != 0);
    } else {
        g_assert(async_ret == 0);
        if (pattern) {
            g_assert(memcmp(pattern_buf + pattern_offset,
                            cmp_buf, pattern_count) <= 0);
        }
    }

    g_free(pattern_buf);
    g_free(cmp_buf);
    qemu_iovec_destroy(&qiov);
}

static void test_blk_write(BlockBackend *blk, long pattern, int64_t offset,
                           int64_t count, bool expect_failed)
{
    void *pattern_buf = NULL;
    QEMUIOVector qiov;
    int async_ret = NOT_DONE;

    pattern_buf = g_malloc(count);
    if (pattern) {
        memset(pattern_buf, pattern, count);
    } else {
        memset(pattern_buf, 0x00, count);
    }

    qemu_iovec_init(&qiov, 1);
    qemu_iovec_add(&qiov, pattern_buf, count);

    blk_aio_pwritev(blk, offset, &qiov, 0, blk_rw_done, &async_ret);
    while (async_ret == NOT_DONE) {
        main_loop_wait(false);
    }

    if (expect_failed) {
        g_assert(async_ret != 0);
    } else {
        g_assert(async_ret == 0);
    }

    g_free(pattern_buf);
    qemu_iovec_destroy(&qiov);
}

/*
 * Create a uniquely-named empty temporary file.
 */
static void make_temp(char *template)
{
    int fd;

    fd = mkstemp(template);
    g_assert(fd >= 0);
    close(fd);
}

static void prepare_imgs(void)
{
    Error *local_err = NULL;

    make_temp(p_local_disk);
    make_temp(s_local_disk);
    make_temp(s_active_disk);
    make_temp(s_hidden_disk);

    /* Primary */
    bdrv_img_create(p_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, true, &local_err);
    g_assert(!local_err);

    /* Secondary */
    bdrv_img_create(s_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, true, &local_err);
    g_assert(!local_err);
    bdrv_img_create(s_active_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, true, &local_err);
    g_assert(!local_err);
    bdrv_img_create(s_hidden_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, true, &local_err);
    g_assert(!local_err);
}

static void cleanup_imgs(void)
{
    /* Primary */
    unlink(p_local_disk);

    /* Secondary */
    unlink(s_local_disk);
    unlink(s_active_disk);
    unlink(s_hidden_disk);
}

static BlockBackend *start_primary(void)
{
    BlockBackend *blk;
    QemuOpts *opts;
    QDict *qdict;
    Error *local_err = NULL;
    char *cmdline;

    cmdline = g_strdup_printf("driver=replication,mode=primary,node-name=xxx,"
                              "file.driver=qcow2,file.file.filename=%s,"
                              "file.file.locking=off"
                              , p_local_disk);
    opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
    g_free(cmdline);

    qdict = qemu_opts_to_qdict(opts, NULL);
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");

    blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
    g_assert(blk);
    g_assert(!local_err);

    monitor_add_blk(blk, P_ID, &local_err);
    g_assert(!local_err);

    qemu_opts_del(opts);

    return blk;
}

static void teardown_primary(void)
{
    BlockBackend *blk;

    /* remove P_ID */
    blk = blk_by_name(P_ID);
    assert(blk);

    monitor_remove_blk(blk);
    blk_unref(blk);
}

static void test_primary_read(void)
{
    BlockBackend *blk;

    blk = start_primary();

    /* read from 0 to IMG_SIZE */
    test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);

    teardown_primary();
}

static void test_primary_write(void)
{
    BlockBackend *blk;

    blk = start_primary();

    /* write from 0 to IMG_SIZE */
    test_blk_write(blk, 0, 0, IMG_SIZE, true);

    teardown_primary();
}

static void test_primary_start(void)
{
    BlockBackend *blk = NULL;
    Error *local_err = NULL;

    blk = start_primary();

    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
    g_assert(!local_err);

    /* read from 0 to IMG_SIZE */
    test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);

    /* write 0x22 from 0 to IMG_SIZE */
    test_blk_write(blk, 0x22, 0, IMG_SIZE, false);

    teardown_primary();
}

static void test_primary_stop(void)
{
    Error *local_err = NULL;
    bool failover = true;

    start_primary();

    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
    g_assert(!local_err);

    replication_stop_all(failover, &local_err);
    g_assert(!local_err);

    teardown_primary();
}

static void test_primary_do_checkpoint(void)
{
    Error *local_err = NULL;

    start_primary();

    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
    g_assert(!local_err);

    replication_do_checkpoint_all(&local_err);
    g_assert(!local_err);

    teardown_primary();
}

static void test_primary_get_error_all(void)
{
    Error *local_err = NULL;

    start_primary();

    replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
    g_assert(!local_err);

    replication_get_error_all(&local_err);
    g_assert(!local_err);

    teardown_primary();
}

static BlockBackend *start_secondary(void)
{
    QemuOpts *opts;
    QDict *qdict;
    BlockBackend *blk;
    char *cmdline;
    Error *local_err = NULL;

    /* add s_local_disk and forge S_LOCAL_DISK_ID */
    cmdline = g_strdup_printf("file.filename=%s,driver=qcow2,"
                              "file.locking=off",
                              s_local_disk);
    opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
    g_free(cmdline);

    qdict = qemu_opts_to_qdict(opts, NULL);
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");

    blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
    assert(blk);
    monitor_add_blk(blk, S_LOCAL_DISK_ID, &local_err);
    g_assert(!local_err);

    /* format s_local_disk with pattern "0x11" */
    test_blk_write(blk, 0x11, 0, IMG_SIZE, false);

    qemu_opts_del(opts);

    /* add S_(ACTIVE/HIDDEN)_DISK and forge S_ID */
    cmdline = g_strdup_printf("driver=replication,mode=secondary,top-id=%s,"
                              "file.driver=qcow2,file.file.filename=%s,"
                              "file.file.locking=off,"
                              "file.backing.driver=qcow2,"
                              "file.backing.file.filename=%s,"
                              "file.backing.file.locking=off,"
                              "file.backing.backing=%s"
                              , S_ID, s_active_disk, s_hidden_disk
                              , S_LOCAL_DISK_ID);
    opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
    g_free(cmdline);

    qdict = qemu_opts_to_qdict(opts, NULL);
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
    qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");

    blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
    assert(blk);
    monitor_add_blk(blk, S_ID, &local_err);
    g_assert(!local_err);

    qemu_opts_del(opts);

    return blk;
}

static void teardown_secondary(void)
{
    /* only need to destroy two BBs */
    BlockBackend *blk;

    /* remove S_LOCAL_DISK_ID */
    blk = blk_by_name(S_LOCAL_DISK_ID);
    assert(blk);

    monitor_remove_blk(blk);
    blk_unref(blk);

    /* remove S_ID */
    blk = blk_by_name(S_ID);
    assert(blk);

    monitor_remove_blk(blk);
    blk_unref(blk);
}

static void test_secondary_read(void)
{
    BlockBackend *blk;

    blk = start_secondary();

    /* read from 0 to IMG_SIZE */
    test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);

    teardown_secondary();
}

static void test_secondary_write(void)
{
    BlockBackend *blk;

    blk = start_secondary();

    /* write from 0 to IMG_SIZE */
    test_blk_write(blk, 0, 0, IMG_SIZE, true);

    teardown_secondary();
}

static void test_secondary_start(void)
{
    BlockBackend *top_blk, *local_blk;
    Error *local_err = NULL;
    bool failover = true;

    top_blk = start_secondary();
    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
    g_assert(!local_err);

    /* read from s_local_disk (0, IMG_SIZE) */
    test_blk_read(top_blk, 0x11, 0, IMG_SIZE, 0, IMG_SIZE, false);

    /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
    local_blk = blk_by_name(S_LOCAL_DISK_ID);
    test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);

    /* replication will backup s_local_disk to s_hidden_disk */
    test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
                  IMG_SIZE / 2, 0, IMG_SIZE, false);

    /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
    test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);

    /* read from s_active_disk (0, IMG_SIZE/2) */
    test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
                  0, IMG_SIZE / 2, false);

    /* unblock top_bs */
    replication_stop_all(failover, &local_err);
    g_assert(!local_err);

    teardown_secondary();
}


static void test_secondary_stop(void)
{
    BlockBackend *top_blk, *local_blk;
    Error *local_err = NULL;
    bool failover = true;

    top_blk = start_secondary();
    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
    g_assert(!local_err);

    /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
    local_blk = blk_by_name(S_LOCAL_DISK_ID);
    test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);

    /* replication will backup s_local_disk to s_hidden_disk */
    test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
                  IMG_SIZE / 2, 0, IMG_SIZE, false);

    /* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
    test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);

    /* do active commit */
    replication_stop_all(failover, &local_err);
    g_assert(!local_err);

    /* read from s_local_disk (0, IMG_SIZE / 2) */
    test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
                  0, IMG_SIZE / 2, false);


    /* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
    test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
                  IMG_SIZE / 2, 0, IMG_SIZE, false);

    teardown_secondary();
}

static void test_secondary_do_checkpoint(void)
{
    BlockBackend *top_blk, *local_blk;
    Error *local_err = NULL;
    bool failover = true;

    top_blk = start_secondary();
    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
    g_assert(!local_err);

    /* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
    local_blk = blk_by_name(S_LOCAL_DISK_ID);
    test_blk_write(local_blk, 0x22, IMG_SIZE / 2,
                   IMG_SIZE / 2, false);

    /* replication will backup s_local_disk to s_hidden_disk */
    test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
                  IMG_SIZE / 2, 0, IMG_SIZE, false);

    replication_do_checkpoint_all(&local_err);
    g_assert(!local_err);

    /* after checkpoint, read pattern 0x22 from s_local_disk */
    test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
                  IMG_SIZE / 2, 0, IMG_SIZE, false);

    /* unblock top_bs */
    replication_stop_all(failover, &local_err);
    g_assert(!local_err);

    teardown_secondary();
}

static void test_secondary_get_error_all(void)
{
    Error *local_err = NULL;
    bool failover = true;

    start_secondary();
    replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
    g_assert(!local_err);

    replication_get_error_all(&local_err);
    g_assert(!local_err);

    /* unblock top_bs */
    replication_stop_all(failover, &local_err);
    g_assert(!local_err);

    teardown_secondary();
}

static void sigabrt_handler(int signo)
{
    cleanup_imgs();
}

static void setup_sigabrt_handler(void)
{
    struct sigaction sigact;

    sigact = (struct sigaction) {
        .sa_handler = sigabrt_handler,
        .sa_flags = SA_RESETHAND,
    };
    sigemptyset(&sigact.sa_mask);
    sigaction(SIGABRT, &sigact, NULL);
}

int main(int argc, char **argv)
{
    int ret;
    qemu_init_main_loop(&error_fatal);
    bdrv_init();

    g_test_init(&argc, &argv, NULL);
    setup_sigabrt_handler();

    prepare_imgs();

    /* Primary */
    g_test_add_func("/replication/primary/read",    test_primary_read);
    g_test_add_func("/replication/primary/write",   test_primary_write);
    g_test_add_func("/replication/primary/start",   test_primary_start);
    g_test_add_func("/replication/primary/stop",    test_primary_stop);
    g_test_add_func("/replication/primary/do_checkpoint",
                    test_primary_do_checkpoint);
    g_test_add_func("/replication/primary/get_error_all",
                    test_primary_get_error_all);

    /* Secondary */
    g_test_add_func("/replication/secondary/read",  test_secondary_read);
    g_test_add_func("/replication/secondary/write", test_secondary_write);
    g_test_add_func("/replication/secondary/start", test_secondary_start);
    g_test_add_func("/replication/secondary/stop",  test_secondary_stop);
    g_test_add_func("/replication/secondary/do_checkpoint",
                    test_secondary_do_checkpoint);
    g_test_add_func("/replication/secondary/get_error_all",
                    test_secondary_get_error_all);

    ret = g_test_run();

    cleanup_imgs();

    return ret;
}
Commit	Line	Data
b3110466 CX	1	/*
	2	* Block replication tests
	3	*
	4	* Copyright (c) 2016 FUJITSU LIMITED
	5	* Author: Changlong Xie <[email protected]>
	6	*
	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.
	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	/* primary */
	21	#define P_ID "primary-id"
	22	static char p_local_disk[] = "/tmp/p_local_disk.XXXXXX";
	23
	24	/* secondary */
	25	#define S_ID "secondary-id"
	26	#define S_LOCAL_DISK_ID "secondary-local-disk-id"
	27	static char s_local_disk[] = "/tmp/s_local_disk.XXXXXX";
	28	static char s_active_disk[] = "/tmp/s_active_disk.XXXXXX";
	29	static char s_hidden_disk[] = "/tmp/s_hidden_disk.XXXXXX";
	30
	31	/* FIXME: steal from blockdev.c */
	32	QemuOptsList qemu_drive_opts = {
	33	.name = "drive",
	34	.head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head),
	35	.desc = {
	36	{ /* end of list */ }
	37	},
	38	};
	39
	40	#define NOT_DONE 0x7fffffff
	41
	42	static void blk_rw_done(void *opaque, int ret)
	43	{
	44	(int )opaque = ret;
	45	}
	46
	47	static 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);
baf905e5 MAL	88	g_free(cmp_buf);
baf905e5 MAL	89	qemu_iovec_destroy(&qiov);
b3110466 CX	90	}
	91
	92	static 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);
baf905e5	121	qemu_iovec_destroy(&qiov);
b3110466 CX	122	}
	123
	124	/*
	125	* Create a uniquely-named empty temporary file.
	126	*/
	127	static void make_temp(char *template)
	128	{
	129	int fd;
	130
	131	fd = mkstemp(template);
	132	g_assert(fd >= 0);
	133	close(fd);
	134	}
	135
	136	static 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	/* Primary */
	146	bdrv_img_create(p_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
9217283d	147	BDRV_O_RDWR, true, &local_err);
b3110466 CX	148	g_assert(!local_err);
	149
	150	/* Secondary */
	151	bdrv_img_create(s_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
9217283d	152	BDRV_O_RDWR, true, &local_err);
b3110466 CX	153	g_assert(!local_err);
b3110466 CX	154	bdrv_img_create(s_active_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
9217283d	155	BDRV_O_RDWR, true, &local_err);
b3110466 CX	156	g_assert(!local_err);
b3110466 CX	157	bdrv_img_create(s_hidden_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
9217283d	158	BDRV_O_RDWR, true, &local_err);
b3110466 CX	159	g_assert(!local_err);
	160	}
	161
	162	static void cleanup_imgs(void)
	163	{
	164	/* Primary */
	165	unlink(p_local_disk);
	166
	167	/* Secondary */
	168	unlink(s_local_disk);
	169	unlink(s_active_disk);
	170	unlink(s_hidden_disk);
	171	}
	172
	173	static 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,"
9c77fec2 FZ	182	"file.driver=qcow2,file.file.filename=%s,"
9c77fec2 FZ	183	"file.file.locking=off"
b3110466 CX	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
	204	static void teardown_primary(void)
	205	{
	206	BlockBackend *blk;
	207
	208	/* remove P_ID */
	209	blk = blk_by_name(P_ID);
	210	assert(blk);
	211
	212	monitor_remove_blk(blk);
	213	blk_unref(blk);
	214	}
	215
	216	static void test_primary_read(void)
	217	{
	218	BlockBackend *blk;
	219
	220	blk = start_primary();
	221
	222	/* read from 0 to IMG_SIZE */
	223	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
	224
	225	teardown_primary();
	226	}
	227
	228	static void test_primary_write(void)
	229	{
	230	BlockBackend *blk;
	231
	232	blk = start_primary();
	233
	234	/* write from 0 to IMG_SIZE */
	235	test_blk_write(blk, 0, 0, IMG_SIZE, true);
	236
	237	teardown_primary();
	238	}
	239
	240	static 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	/* read from 0 to IMG_SIZE */
251	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
252
253	/* write 0x22 from 0 to IMG_SIZE */
254	test_blk_write(blk, 0x22, 0, IMG_SIZE, false);
255
256	teardown_primary();
257	}
258
259	static 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
275	static 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
290	static 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
305	static BlockBackend *start_secondary(void)
306	{
307	QemuOpts *opts;
308	QDict *qdict;
309	BlockBackend *blk;
310	char *cmdline;
311	Error *local_err = NULL;
312
313	/* add s_local_disk and forge S_LOCAL_DISK_ID */
9c77fec2 FZ	314	cmdline = g_strdup_printf("file.filename=%s,driver=qcow2,"
	315	"file.locking=off",
	316	s_local_disk);
b3110466 CX	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	/* format s_local_disk with pattern "0x11" */
	330	test_blk_write(blk, 0x11, 0, IMG_SIZE, false);
	331
	332	qemu_opts_del(opts);
	333
	334	/* add S_(ACTIVE/HIDDEN)_DISK and forge S_ID */
	335	cmdline = g_strdup_printf("driver=replication,mode=secondary,top-id=%s,"
	336	"file.driver=qcow2,file.file.filename=%s,"
9c77fec2	337	"file.file.locking=off,"
b3110466 CX	338	"file.backing.driver=qcow2,"
b3110466 CX	339	"file.backing.file.filename=%s,"
9c77fec2	340	"file.backing.file.locking=off,"
b3110466 CX	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
	361	static void teardown_secondary(void)
	362	{
	363	/* only need to destroy two BBs */
	364	BlockBackend *blk;
	365
	366	/* remove S_LOCAL_DISK_ID */
	367	blk = blk_by_name(S_LOCAL_DISK_ID);
	368	assert(blk);
	369
	370	monitor_remove_blk(blk);
	371	blk_unref(blk);
	372
	373	/* remove S_ID */
	374	blk = blk_by_name(S_ID);
	375	assert(blk);
	376
	377	monitor_remove_blk(blk);
	378	blk_unref(blk);
	379	}
	380
	381	static void test_secondary_read(void)
	382	{
	383	BlockBackend *blk;
	384
	385	blk = start_secondary();
	386
	387	/* read from 0 to IMG_SIZE */
	388	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
	389
	390	teardown_secondary();
	391	}
	392
	393	static void test_secondary_write(void)
	394	{
	395	BlockBackend *blk;
	396
	397	blk = start_secondary();
	398
	399	/* write from 0 to IMG_SIZE */
	400	test_blk_write(blk, 0, 0, IMG_SIZE, true);
	401
	402	teardown_secondary();
	403	}
	404
405	static 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	/* read from s_local_disk (0, IMG_SIZE) */
416	test_blk_read(top_blk, 0x11, 0, IMG_SIZE, 0, IMG_SIZE, false);
417
418	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
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	/* replication will backup s_local_disk to s_hidden_disk */
423	test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
424	IMG_SIZE / 2, 0, IMG_SIZE, false);
425
426	/* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
427	test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
428
429	/* read from s_active_disk (0, IMG_SIZE/2) */
430	test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
431	0, IMG_SIZE / 2, false);
432
433	/* unblock top_bs */
434	replication_stop_all(failover, &local_err);
435	g_assert(!local_err);
436
437	teardown_secondary();
438	}
439
440
441	static 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	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
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	/* replication will backup s_local_disk to s_hidden_disk */
456	test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
457	IMG_SIZE / 2, 0, IMG_SIZE, false);
458
459	/* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
460	test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
461
462	/* do active commit */
463	replication_stop_all(failover, &local_err);
464	g_assert(!local_err);
465
466	/* read from s_local_disk (0, IMG_SIZE / 2) */
467	test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
468	0, IMG_SIZE / 2, false);
469
470
471	/* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
472	test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
473	IMG_SIZE / 2, 0, IMG_SIZE, false);
474
475	teardown_secondary();
476	}
477
478	static 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	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
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	/* replication will backup s_local_disk to s_hidden_disk */
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	/* after checkpoint, read pattern 0x22 from s_local_disk */
501	test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
502	IMG_SIZE / 2, 0, IMG_SIZE, false);
503
504	/* unblock top_bs */
505	replication_stop_all(failover, &local_err);
506	g_assert(!local_err);
507
508	teardown_secondary();
509	}
510
511	static 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	/* unblock top_bs */
524	replication_stop_all(failover, &local_err);
525	g_assert(!local_err);
526
527	teardown_secondary();
528	}
529
530	static void sigabrt_handler(int signo)
531	{
532	cleanup_imgs();
533	}
534
535	static 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
547	int 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	/* Primary */
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	/* Secondary */
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	}