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