[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, &local_err, true);
    g_assert(!local_err);

    /* Secondary */
    bdrv_img_create(s_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, &local_err, true);
    g_assert(!local_err);
    bdrv_img_create(s_active_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, &local_err, true);
    g_assert(!local_err);
    bdrv_img_create(s_hidden_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
                    BDRV_O_RDWR, &local_err, true);
    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"
                              , 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", 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.backing.driver=qcow2,"
                              "file.backing.file.filename=%s,"
                              "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,
	147	BDRV_O_RDWR, &local_err, true);
	148	g_assert(!local_err);
	149
	150	/* Secondary */
	151	bdrv_img_create(s_local_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
	152	BDRV_O_RDWR, &local_err, true);
	153	g_assert(!local_err);
	154	bdrv_img_create(s_active_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
	155	BDRV_O_RDWR, &local_err, true);
	156	g_assert(!local_err);
	157	bdrv_img_create(s_hidden_disk, "qcow2", NULL, NULL, NULL, IMG_SIZE,
	158	BDRV_O_RDWR, &local_err, true);
	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,"
	182	"file.driver=qcow2,file.file.filename=%s"
	183	, p_local_disk);
	184	opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
	185	g_free(cmdline);
186
187	qdict = qemu_opts_to_qdict(opts, NULL);
188	qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
189	qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
190
191	blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
192	g_assert(blk);
193	g_assert(!local_err);
194
195	monitor_add_blk(blk, P_ID, &local_err);
196	g_assert(!local_err);
197
198	qemu_opts_del(opts);
199
200	return blk;
201	}
202
203	static void teardown_primary(void)
204	{
205	BlockBackend *blk;
206
207	/* remove P_ID */
208	blk = blk_by_name(P_ID);
209	assert(blk);
210
211	monitor_remove_blk(blk);
212	blk_unref(blk);
213	}
214
215	static void test_primary_read(void)
216	{
217	BlockBackend *blk;
218
219	blk = start_primary();
220
221	/* read from 0 to IMG_SIZE */
222	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
223
224	teardown_primary();
225	}
226
227	static void test_primary_write(void)
228	{
229	BlockBackend *blk;
230
231	blk = start_primary();
232
233	/* write from 0 to IMG_SIZE */
234	test_blk_write(blk, 0, 0, IMG_SIZE, true);
235
236	teardown_primary();
237	}
238
239	static void test_primary_start(void)
240	{
241	BlockBackend *blk = NULL;
242	Error *local_err = NULL;
243
244	blk = start_primary();
245
246	replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
247	g_assert(!local_err);
248
249	/* read from 0 to IMG_SIZE */
250	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
251
252	/* write 0x22 from 0 to IMG_SIZE */
253	test_blk_write(blk, 0x22, 0, IMG_SIZE, false);
254
255	teardown_primary();
256	}
257
258	static void test_primary_stop(void)
259	{
260	Error *local_err = NULL;
261	bool failover = true;
262
263	start_primary();
264
265	replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
266	g_assert(!local_err);
267
268	replication_stop_all(failover, &local_err);
269	g_assert(!local_err);
270
271	teardown_primary();
272	}
273
274	static void test_primary_do_checkpoint(void)
275	{
276	Error *local_err = NULL;
277
278	start_primary();
279
280	replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
281	g_assert(!local_err);
282
283	replication_do_checkpoint_all(&local_err);
284	g_assert(!local_err);
285
286	teardown_primary();
287	}
288
289	static void test_primary_get_error_all(void)
290	{
291	Error *local_err = NULL;
292
293	start_primary();
294
295	replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
296	g_assert(!local_err);
297
298	replication_get_error_all(&local_err);
299	g_assert(!local_err);
300
301	teardown_primary();
302	}
303
304	static BlockBackend *start_secondary(void)
305	{
306	QemuOpts *opts;
307	QDict *qdict;
308	BlockBackend *blk;
309	char *cmdline;
310	Error *local_err = NULL;
311
312	/* add s_local_disk and forge S_LOCAL_DISK_ID */
313	cmdline = g_strdup_printf("file.filename=%s,driver=qcow2", s_local_disk);
314	opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
315	g_free(cmdline);
316
317	qdict = qemu_opts_to_qdict(opts, NULL);
318	qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
319	qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
320
321	blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
322	assert(blk);
323	monitor_add_blk(blk, S_LOCAL_DISK_ID, &local_err);
324	g_assert(!local_err);
325
326	/* format s_local_disk with pattern "0x11" */
327	test_blk_write(blk, 0x11, 0, IMG_SIZE, false);
328
329	qemu_opts_del(opts);
330
331	/* add S_(ACTIVE/HIDDEN)_DISK and forge S_ID */
332	cmdline = g_strdup_printf("driver=replication,mode=secondary,top-id=%s,"
333	"file.driver=qcow2,file.file.filename=%s,"
334	"file.backing.driver=qcow2,"
335	"file.backing.file.filename=%s,"
336	"file.backing.backing=%s"
337	, S_ID, s_active_disk, s_hidden_disk
338	, S_LOCAL_DISK_ID);
339	opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
340	g_free(cmdline);
341
342	qdict = qemu_opts_to_qdict(opts, NULL);
343	qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
344	qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
345
346	blk = blk_new_open(NULL, NULL, qdict, BDRV_O_RDWR, &local_err);
347	assert(blk);
348	monitor_add_blk(blk, S_ID, &local_err);
349	g_assert(!local_err);
350
351	qemu_opts_del(opts);
352
353	return blk;
354	}
355
356	static void teardown_secondary(void)
357	{
358	/* only need to destroy two BBs */
359	BlockBackend *blk;
360
361	/* remove S_LOCAL_DISK_ID */
362	blk = blk_by_name(S_LOCAL_DISK_ID);
363	assert(blk);
364
365	monitor_remove_blk(blk);
366	blk_unref(blk);
367
368	/* remove S_ID */
369	blk = blk_by_name(S_ID);
370	assert(blk);
371
372	monitor_remove_blk(blk);
373	blk_unref(blk);
374	}
375
376	static void test_secondary_read(void)
377	{
378	BlockBackend *blk;
379
380	blk = start_secondary();
381
382	/* read from 0 to IMG_SIZE */
383	test_blk_read(blk, 0, 0, IMG_SIZE, 0, IMG_SIZE, true);
384
385	teardown_secondary();
386	}
387
388	static void test_secondary_write(void)
389	{
390	BlockBackend *blk;
391
392	blk = start_secondary();
393
394	/* write from 0 to IMG_SIZE */
395	test_blk_write(blk, 0, 0, IMG_SIZE, true);
396
397	teardown_secondary();
398	}
399
400	static void test_secondary_start(void)
401	{
402	BlockBackend top_blk, local_blk;
403	Error *local_err = NULL;
404	bool failover = true;
405
406	top_blk = start_secondary();
407	replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
408	g_assert(!local_err);
409
410	/* read from s_local_disk (0, IMG_SIZE) */
411	test_blk_read(top_blk, 0x11, 0, IMG_SIZE, 0, IMG_SIZE, false);
412
413	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
414	local_blk = blk_by_name(S_LOCAL_DISK_ID);
415	test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
416
417	/* replication will backup s_local_disk to s_hidden_disk */
418	test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
419	IMG_SIZE / 2, 0, IMG_SIZE, false);
420
421	/* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
422	test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
423
424	/* read from s_active_disk (0, IMG_SIZE/2) */
425	test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
426	0, IMG_SIZE / 2, false);
427
428	/* unblock top_bs */
429	replication_stop_all(failover, &local_err);
430	g_assert(!local_err);
431
432	teardown_secondary();
433	}
434
435
436	static void test_secondary_stop(void)
437	{
438	BlockBackend top_blk, local_blk;
439	Error *local_err = NULL;
440	bool failover = true;
441
442	top_blk = start_secondary();
443	replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
444	g_assert(!local_err);
445
446	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
447	local_blk = blk_by_name(S_LOCAL_DISK_ID);
448	test_blk_write(local_blk, 0x22, IMG_SIZE / 2, IMG_SIZE / 2, false);
449
450	/* replication will backup s_local_disk to s_hidden_disk */
451	test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
452	IMG_SIZE / 2, 0, IMG_SIZE, false);
453
454	/* write 0x33 to s_active_disk (0, IMG_SIZE / 2) */
455	test_blk_write(top_blk, 0x33, 0, IMG_SIZE / 2, false);
456
457	/* do active commit */
458	replication_stop_all(failover, &local_err);
459	g_assert(!local_err);
460
461	/* read from s_local_disk (0, IMG_SIZE / 2) */
462	test_blk_read(top_blk, 0x33, 0, IMG_SIZE / 2,
463	0, IMG_SIZE / 2, false);
464
465
466	/* read from s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
467	test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
468	IMG_SIZE / 2, 0, IMG_SIZE, false);
469
470	teardown_secondary();
471	}
472
473	static void test_secondary_do_checkpoint(void)
474	{
475	BlockBackend top_blk, local_blk;
476	Error *local_err = NULL;
477	bool failover = true;
478
479	top_blk = start_secondary();
480	replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
481	g_assert(!local_err);
482
483	/* write 0x22 to s_local_disk (IMG_SIZE / 2, IMG_SIZE) */
484	local_blk = blk_by_name(S_LOCAL_DISK_ID);
485	test_blk_write(local_blk, 0x22, IMG_SIZE / 2,
486	IMG_SIZE / 2, false);
487
488	/* replication will backup s_local_disk to s_hidden_disk */
489	test_blk_read(top_blk, 0x11, IMG_SIZE / 2,
490	IMG_SIZE / 2, 0, IMG_SIZE, false);
491
492	replication_do_checkpoint_all(&local_err);
493	g_assert(!local_err);
494
495	/* after checkpoint, read pattern 0x22 from s_local_disk */
496	test_blk_read(top_blk, 0x22, IMG_SIZE / 2,
497	IMG_SIZE / 2, 0, IMG_SIZE, false);
498
499	/* unblock top_bs */
500	replication_stop_all(failover, &local_err);
501	g_assert(!local_err);
502
503	teardown_secondary();
504	}
505
506	static void test_secondary_get_error_all(void)
507	{
508	Error *local_err = NULL;
509	bool failover = true;
510
511	start_secondary();
512	replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
513	g_assert(!local_err);
514
515	replication_get_error_all(&local_err);
516	g_assert(!local_err);
517
518	/* unblock top_bs */
519	replication_stop_all(failover, &local_err);
520	g_assert(!local_err);
521
522	teardown_secondary();
523	}
524
525	static void sigabrt_handler(int signo)
526	{
527	cleanup_imgs();
528	}
529
530	static void setup_sigabrt_handler(void)
531	{
532	struct sigaction sigact;
533
534	sigact = (struct sigaction) {
535	.sa_handler = sigabrt_handler,
536	.sa_flags = SA_RESETHAND,
537	};
538	sigemptyset(&sigact.sa_mask);
539	sigaction(SIGABRT, &sigact, NULL);
540	}
541
542	int main(int argc, char **argv)
543	{
544	int ret;
545	qemu_init_main_loop(&error_fatal);
546	bdrv_init();
547
548	g_test_init(&argc, &argv, NULL);
549	setup_sigabrt_handler();
550
551	prepare_imgs();
552
553	/* Primary */
554	g_test_add_func("/replication/primary/read", test_primary_read);
555	g_test_add_func("/replication/primary/write", test_primary_write);
556	g_test_add_func("/replication/primary/start", test_primary_start);
557	g_test_add_func("/replication/primary/stop", test_primary_stop);
558	g_test_add_func("/replication/primary/do_checkpoint",
559	test_primary_do_checkpoint);
560	g_test_add_func("/replication/primary/get_error_all",
561	test_primary_get_error_all);
562
563	/* Secondary */
564	g_test_add_func("/replication/secondary/read", test_secondary_read);
565	g_test_add_func("/replication/secondary/write", test_secondary_write);
566	g_test_add_func("/replication/secondary/start", test_secondary_start);
567	g_test_add_func("/replication/secondary/stop", test_secondary_stop);
568	g_test_add_func("/replication/secondary/do_checkpoint",
569	test_secondary_do_checkpoint);
570	g_test_add_func("/replication/secondary/get_error_all",
571	test_secondary_get_error_all);
572
573	ret = g_test_run();
574
575	cleanup_imgs();
576
577	return ret;
578	}