[qemu.git] / block / blklogwrites.c

/*
 * Write logging blk driver based on blkverify and blkdebug.
 *
 * Copyright (c) 2017 Tuomas Tynkkynen <[email protected]>
 * Copyright (c) 2018 Aapo Vienamo <[email protected]>
 * Copyright (c) 2018 Ari Sundholm <[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 "qemu/sockets.h" /* for EINPROGRESS on Windows */
#include "block/block_int.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qstring.h"
#include "qemu/cutils.h"
#include "qemu/option.h"

/* Disk format stuff - taken from Linux drivers/md/dm-log-writes.c */

#define LOG_FLUSH_FLAG   (1 << 0)
#define LOG_FUA_FLAG     (1 << 1)
#define LOG_DISCARD_FLAG (1 << 2)
#define LOG_MARK_FLAG    (1 << 3)
#define LOG_FLAG_MASK    (LOG_FLUSH_FLAG \
                         | LOG_FUA_FLAG \
                         | LOG_DISCARD_FLAG \
                         | LOG_MARK_FLAG)

#define WRITE_LOG_VERSION 1ULL
#define WRITE_LOG_MAGIC 0x6a736677736872ULL

/* All fields are little-endian. */
struct log_write_super {
    uint64_t magic;
    uint64_t version;
    uint64_t nr_entries;
    uint32_t sectorsize;
} QEMU_PACKED;

struct log_write_entry {
    uint64_t sector;
    uint64_t nr_sectors;
    uint64_t flags;
    uint64_t data_len;
} QEMU_PACKED;

/* End of disk format structures. */

typedef struct {
    BdrvChild *log_file;
    uint32_t sectorsize;
    uint32_t sectorbits;
    uint64_t cur_log_sector;
    uint64_t nr_entries;
    uint64_t update_interval;
} BDRVBlkLogWritesState;

static QemuOptsList runtime_opts = {
    .name = "blklogwrites",
    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
    .desc = {
        {
            .name = "log-append",
            .type = QEMU_OPT_BOOL,
            .help = "Append to an existing log",
        },
        {
            .name = "log-sector-size",
            .type = QEMU_OPT_SIZE,
            .help = "Log sector size",
        },
        {
            .name = "log-super-update-interval",
            .type = QEMU_OPT_NUMBER,
            .help = "Log superblock update interval (# of write requests)",
        },
        { /* end of list */ }
    },
};

static inline uint32_t blk_log_writes_log2(uint32_t value)
{
    assert(value > 0);
    return 31 - clz32(value);
}

static inline bool blk_log_writes_sector_size_valid(uint32_t sector_size)
{
    return is_power_of_2(sector_size) &&
        sector_size >= sizeof(struct log_write_super) &&
        sector_size >= sizeof(struct log_write_entry) &&
        sector_size < (1ull << 24);
}

static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
                                                   uint32_t sector_size,
                                                   uint64_t nr_entries,
                                                   Error **errp)
{
    uint64_t cur_sector = 1;
    uint64_t cur_idx = 0;
    uint32_t sector_bits = blk_log_writes_log2(sector_size);
    struct log_write_entry cur_entry;

    while (cur_idx < nr_entries) {
        int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
                                  sizeof(cur_entry));
        if (read_ret < 0) {
            error_setg_errno(errp, -read_ret,
                             "Failed to read log entry %"PRIu64, cur_idx);
            return (uint64_t)-1ull;
        }

        if (cur_entry.flags & ~cpu_to_le64(LOG_FLAG_MASK)) {
            error_setg(errp, "Invalid flags 0x%"PRIx64" in log entry %"PRIu64,
                       le64_to_cpu(cur_entry.flags), cur_idx);
            return (uint64_t)-1ull;
        }

        /* Account for the sector of the entry itself */
        ++cur_sector;

        /*
         * Account for the data of the write.
         * For discards, this data is not present.
         */
        if (!(cur_entry.flags & cpu_to_le64(LOG_DISCARD_FLAG))) {
            cur_sector += le64_to_cpu(cur_entry.nr_sectors);
        }

        ++cur_idx;
    }

    return cur_sector;
}

static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
                               Error **errp)
{
    BDRVBlkLogWritesState *s = bs->opaque;
    QemuOpts *opts;
    Error *local_err = NULL;
    int ret;
    uint64_t log_sector_size;
    bool log_append;

    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
    qemu_opts_absorb_qdict(opts, options, &local_err);
    if (local_err) {
        ret = -EINVAL;
        error_propagate(errp, local_err);
        goto fail;
    }

    /* Open the file */
    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
                               &local_err);
    if (local_err) {
        ret = -EINVAL;
        error_propagate(errp, local_err);
        goto fail;
    }

    /* Open the log file */
    s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
                                  &local_err);
    if (local_err) {
        ret = -EINVAL;
        error_propagate(errp, local_err);
        goto fail;
    }

    log_append = qemu_opt_get_bool(opts, "log-append", false);

    if (log_append) {
        struct log_write_super log_sb = { 0, 0, 0, 0 };

        if (qemu_opt_find(opts, "log-sector-size")) {
            ret = -EINVAL;
            error_setg(errp, "log-append and log-sector-size are mutually "
                       "exclusive");
            goto fail_log;
        }

        /* Read log superblock or fake one for an empty log */
        if (!bdrv_getlength(s->log_file->bs)) {
            log_sb.magic      = cpu_to_le64(WRITE_LOG_MAGIC);
            log_sb.version    = cpu_to_le64(WRITE_LOG_VERSION);
            log_sb.nr_entries = cpu_to_le64(0);
            log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
        } else {
            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb));
            if (ret < 0) {
                error_setg_errno(errp, -ret, "Could not read log superblock");
                goto fail_log;
            }
        }

        if (log_sb.magic != cpu_to_le64(WRITE_LOG_MAGIC)) {
            ret = -EINVAL;
            error_setg(errp, "Invalid log superblock magic");
            goto fail_log;
        }

        if (log_sb.version != cpu_to_le64(WRITE_LOG_VERSION)) {
            ret = -EINVAL;
            error_setg(errp, "Unsupported log version %"PRIu64,
                       le64_to_cpu(log_sb.version));
            goto fail_log;
        }

        log_sector_size = le32_to_cpu(log_sb.sectorsize);
        s->cur_log_sector = 1;
        s->nr_entries = 0;

        if (blk_log_writes_sector_size_valid(log_sector_size)) {
            s->cur_log_sector =
                blk_log_writes_find_cur_log_sector(s->log_file, log_sector_size,
                                    le64_to_cpu(log_sb.nr_entries), &local_err);
            if (local_err) {
                ret = -EINVAL;
                error_propagate(errp, local_err);
                goto fail_log;
            }

            s->nr_entries = le64_to_cpu(log_sb.nr_entries);
        }
    } else {
        log_sector_size = qemu_opt_get_size(opts, "log-sector-size",
                                            BDRV_SECTOR_SIZE);
        s->cur_log_sector = 1;
        s->nr_entries = 0;
    }

    if (!blk_log_writes_sector_size_valid(log_sector_size)) {
        ret = -EINVAL;
        error_setg(errp, "Invalid log sector size %"PRIu64, log_sector_size);
        goto fail_log;
    }

    s->sectorsize = log_sector_size;
    s->sectorbits = blk_log_writes_log2(log_sector_size);
    s->update_interval = qemu_opt_get_number(opts, "log-super-update-interval",
                                             4096);
    if (!s->update_interval) {
        ret = -EINVAL;
        error_setg(errp, "Invalid log superblock update interval %"PRIu64,
                   s->update_interval);
        goto fail_log;
    }

    ret = 0;
fail_log:
    if (ret < 0) {
        bdrv_unref_child(bs, s->log_file);
        s->log_file = NULL;
    }
fail:
    if (ret < 0) {
        bdrv_unref_child(bs, bs->file);
        bs->file = NULL;
    }
    qemu_opts_del(opts);
    return ret;
}

static void blk_log_writes_close(BlockDriverState *bs)
{
    BDRVBlkLogWritesState *s = bs->opaque;

    bdrv_unref_child(bs, s->log_file);
    s->log_file = NULL;
}

static int64_t blk_log_writes_getlength(BlockDriverState *bs)
{
    return bdrv_getlength(bs->file->bs);
}

static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
                                      const BdrvChildRole *role,
                                      BlockReopenQueue *ro_q,
                                      uint64_t perm, uint64_t shrd,
                                      uint64_t *nperm, uint64_t *nshrd)
{
    if (!c) {
        *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
        *nshrd = (shrd & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
        return;
    }

    if (!strcmp(c->name, "log")) {
        bdrv_format_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
    } else {
        bdrv_filter_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
    }
}

static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
{
    BDRVBlkLogWritesState *s = bs->opaque;
    bs->bl.request_alignment = s->sectorsize;
}

static int coroutine_fn
blk_log_writes_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
                         QEMUIOVector *qiov, int flags)
{
    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
}

typedef struct BlkLogWritesFileReq {
    BlockDriverState *bs;
    uint64_t offset;
    uint64_t bytes;
    int file_flags;
    QEMUIOVector *qiov;
    int (*func)(struct BlkLogWritesFileReq *r);
    int file_ret;
} BlkLogWritesFileReq;

typedef struct {
    BlockDriverState *bs;
    QEMUIOVector *qiov;
    struct log_write_entry entry;
    uint64_t zero_size;
    int log_ret;
} BlkLogWritesLogReq;

static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
{
    BDRVBlkLogWritesState *s = lr->bs->opaque;
    uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;

    s->nr_entries++;
    s->cur_log_sector +=
            ROUND_UP(lr->qiov->size, s->sectorsize) >> s->sectorbits;

    lr->log_ret = bdrv_co_pwritev(s->log_file, cur_log_offset, lr->qiov->size,
                                  lr->qiov, 0);

    /* Logging for the "write zeroes" operation */
    if (lr->log_ret == 0 && lr->zero_size) {
        cur_log_offset = s->cur_log_sector << s->sectorbits;
        s->cur_log_sector +=
                ROUND_UP(lr->zero_size, s->sectorsize) >> s->sectorbits;

        lr->log_ret = bdrv_co_pwrite_zeroes(s->log_file, cur_log_offset,
                                            lr->zero_size, 0);
    }

    /* Update super block on flush or every update interval */
    if (lr->log_ret == 0 && ((lr->entry.flags & LOG_FLUSH_FLAG)
        || (s->nr_entries % s->update_interval == 0)))
    {
        struct log_write_super super = {
            .magic      = cpu_to_le64(WRITE_LOG_MAGIC),
            .version    = cpu_to_le64(WRITE_LOG_VERSION),
            .nr_entries = cpu_to_le64(s->nr_entries),
            .sectorsize = cpu_to_le32(s->sectorsize),
        };
        void *zeroes = g_malloc0(s->sectorsize - sizeof(super));
        QEMUIOVector qiov;

        qemu_iovec_init(&qiov, 2);
        qemu_iovec_add(&qiov, &super, sizeof(super));
        qemu_iovec_add(&qiov, zeroes, s->sectorsize - sizeof(super));

        lr->log_ret =
            bdrv_co_pwritev(s->log_file, 0, s->sectorsize, &qiov, 0);
        if (lr->log_ret == 0) {
            lr->log_ret = bdrv_co_flush(s->log_file->bs);
        }
        qemu_iovec_destroy(&qiov);
        g_free(zeroes);
    }
}

static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
{
    fr->file_ret = fr->func(fr);
}

static int coroutine_fn
blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
                      QEMUIOVector *qiov, int flags,
                      int (*file_func)(BlkLogWritesFileReq *r),
                      uint64_t entry_flags, bool is_zero_write)
{
    QEMUIOVector log_qiov;
    size_t niov = qiov ? qiov->niov : 0;
    BDRVBlkLogWritesState *s = bs->opaque;
    BlkLogWritesFileReq fr = {
        .bs         = bs,
        .offset     = offset,
        .bytes      = bytes,
        .file_flags = flags,
        .qiov       = qiov,
        .func       = file_func,
    };
    BlkLogWritesLogReq lr = {
        .bs             = bs,
        .qiov           = &log_qiov,
        .entry = {
            .sector     = cpu_to_le64(offset >> s->sectorbits),
            .nr_sectors = cpu_to_le64(bytes >> s->sectorbits),
            .flags      = cpu_to_le64(entry_flags),
            .data_len   = 0,
        },
        .zero_size = is_zero_write ? bytes : 0,
    };
    void *zeroes = g_malloc0(s->sectorsize - sizeof(lr.entry));

    assert((1 << s->sectorbits) == s->sectorsize);
    assert(bs->bl.request_alignment == s->sectorsize);
    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
    assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));

    qemu_iovec_init(&log_qiov, niov + 2);
    qemu_iovec_add(&log_qiov, &lr.entry, sizeof(lr.entry));
    qemu_iovec_add(&log_qiov, zeroes, s->sectorsize - sizeof(lr.entry));
    if (qiov) {
        qemu_iovec_concat(&log_qiov, qiov, 0, qiov->size);
    }

    blk_log_writes_co_do_file(&fr);
    blk_log_writes_co_do_log(&lr);

    qemu_iovec_destroy(&log_qiov);
    g_free(zeroes);

    if (lr.log_ret < 0) {
        return lr.log_ret;
    }

    return fr.file_ret;
}

static int coroutine_fn
blk_log_writes_co_do_file_pwritev(BlkLogWritesFileReq *fr)
{
    return bdrv_co_pwritev(fr->bs->file, fr->offset, fr->bytes,
                           fr->qiov, fr->file_flags);
}

static int coroutine_fn
blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
{
    return bdrv_co_pwrite_zeroes(fr->bs->file, fr->offset, fr->bytes,
                                 fr->file_flags);
}

static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
{
    return bdrv_co_flush(fr->bs->file->bs);
}

static int coroutine_fn
blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
{
    return bdrv_co_pdiscard(fr->bs->file, fr->offset, fr->bytes);
}

static int coroutine_fn
blk_log_writes_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
                          QEMUIOVector *qiov, int flags)
{
    return blk_log_writes_co_log(bs, offset, bytes, qiov, flags,
                                 blk_log_writes_co_do_file_pwritev, 0, false);
}

static int coroutine_fn
blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
                                BdrvRequestFlags flags)
{
    return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
                                 blk_log_writes_co_do_file_pwrite_zeroes, 0,
                                 true);
}

static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
{
    return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
                                 blk_log_writes_co_do_file_flush,
                                 LOG_FLUSH_FLAG, false);
}

static int coroutine_fn
blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
{
    return blk_log_writes_co_log(bs, offset, count, NULL, 0,
                                 blk_log_writes_co_do_file_pdiscard,
                                 LOG_DISCARD_FLAG, false);
}

static const char *const blk_log_writes_strong_runtime_opts[] = {
    "log-append",
    "log-sector-size",

    NULL
};

static BlockDriver bdrv_blk_log_writes = {
    .format_name            = "blklogwrites",
    .instance_size          = sizeof(BDRVBlkLogWritesState),

    .bdrv_open              = blk_log_writes_open,
    .bdrv_close             = blk_log_writes_close,
    .bdrv_getlength         = blk_log_writes_getlength,
    .bdrv_child_perm        = blk_log_writes_child_perm,
    .bdrv_refresh_limits    = blk_log_writes_refresh_limits,

    .bdrv_co_preadv         = blk_log_writes_co_preadv,
    .bdrv_co_pwritev        = blk_log_writes_co_pwritev,
    .bdrv_co_pwrite_zeroes  = blk_log_writes_co_pwrite_zeroes,
    .bdrv_co_flush_to_disk  = blk_log_writes_co_flush_to_disk,
    .bdrv_co_pdiscard       = blk_log_writes_co_pdiscard,
    .bdrv_co_block_status   = bdrv_co_block_status_from_file,

    .is_filter              = true,
    .strong_runtime_opts    = blk_log_writes_strong_runtime_opts,
};

static void bdrv_blk_log_writes_init(void)
{
    bdrv_register(&bdrv_blk_log_writes);
}

block_init(bdrv_blk_log_writes_init);
Commit	Line	Data
bfcc224e AV	1	/*
	2	* Write logging blk driver based on blkverify and blkdebug.
	3	*
	4	* Copyright (c) 2017 Tuomas Tynkkynen <[email protected]>
	5	* Copyright (c) 2018 Aapo Vienamo <[email protected]>
	6	* Copyright (c) 2018 Ari Sundholm <[email protected]>
	7	*
	8	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	9	* See the COPYING file in the top-level directory.
	10	*/
	11
	12	#include "qemu/osdep.h"
	13	#include "qapi/error.h"
	14	#include "qemu/sockets.h" /* for EINPROGRESS on Windows */
	15	#include "block/block_int.h"
	16	#include "qapi/qmp/qdict.h"
	17	#include "qapi/qmp/qstring.h"
	18	#include "qemu/cutils.h"
	19	#include "qemu/option.h"
	20
	21	/* Disk format stuff - taken from Linux drivers/md/dm-log-writes.c */
	22
	23	#define LOG_FLUSH_FLAG (1 << 0)
	24	#define LOG_FUA_FLAG (1 << 1)
	25	#define LOG_DISCARD_FLAG (1 << 2)
	26	#define LOG_MARK_FLAG (1 << 3)
0878b3c1 AS	27	#define LOG_FLAG_MASK (LOG_FLUSH_FLAG \
	28	\| LOG_FUA_FLAG \
	29	\| LOG_DISCARD_FLAG \
	30	\| LOG_MARK_FLAG)
bfcc224e AV	31
	32	#define WRITE_LOG_VERSION 1ULL
	33	#define WRITE_LOG_MAGIC 0x6a736677736872ULL
	34
	35	/* All fields are little-endian. */
	36	struct log_write_super {
	37	uint64_t magic;
	38	uint64_t version;
	39	uint64_t nr_entries;
	40	uint32_t sectorsize;
	41	} QEMU_PACKED;
	42
	43	struct log_write_entry {
	44	uint64_t sector;
	45	uint64_t nr_sectors;
	46	uint64_t flags;
	47	uint64_t data_len;
	48	} QEMU_PACKED;
	49
	50	/* End of disk format structures. */
	51
	52	typedef struct {
	53	BdrvChild *log_file;
	54	uint32_t sectorsize;
	55	uint32_t sectorbits;
	56	uint64_t cur_log_sector;
	57	uint64_t nr_entries;
1dce698e	58	uint64_t update_interval;
bfcc224e AV	59	} BDRVBlkLogWritesState;
	60
	61	static QemuOptsList runtime_opts = {
	62	.name = "blklogwrites",
	63	.head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
	64	.desc = {
0878b3c1 AS	65	{
	66	.name = "log-append",
	67	.type = QEMU_OPT_BOOL,
	68	.help = "Append to an existing log",
	69	},
bfcc224e AV	70	{
	71	.name = "log-sector-size",
	72	.type = QEMU_OPT_SIZE,
	73	.help = "Log sector size",
	74	},
1dce698e AS	75	{
	76	.name = "log-super-update-interval",
	77	.type = QEMU_OPT_NUMBER,
	78	.help = "Log superblock update interval (# of write requests)",
	79	},
bfcc224e AV	80	{ /* end of list */ }
	81	},
	82	};
	83
	84	static inline uint32_t blk_log_writes_log2(uint32_t value)
	85	{
	86	assert(value > 0);
	87	return 31 - clz32(value);
	88	}
	89
0878b3c1 AS	90	static inline bool blk_log_writes_sector_size_valid(uint32_t sector_size)
0878b3c1 AS	91	{
ba814c82 AS	92	return is_power_of_2(sector_size) &&
	93	sector_size >= sizeof(struct log_write_super) &&
	94	sector_size >= sizeof(struct log_write_entry) &&
	95	sector_size < (1ull << 24);
0878b3c1 AS	96	}
	97
	98	static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
	99	uint32_t sector_size,
	100	uint64_t nr_entries,
	101	Error **errp)
	102	{
	103	uint64_t cur_sector = 1;
	104	uint64_t cur_idx = 0;
	105	uint32_t sector_bits = blk_log_writes_log2(sector_size);
	106	struct log_write_entry cur_entry;
	107
	108	while (cur_idx < nr_entries) {
	109	int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
	110	sizeof(cur_entry));
	111	if (read_ret < 0) {
	112	error_setg_errno(errp, -read_ret,
	113	"Failed to read log entry %"PRIu64, cur_idx);
	114	return (uint64_t)-1ull;
	115	}
	116
	117	if (cur_entry.flags & ~cpu_to_le64(LOG_FLAG_MASK)) {
	118	error_setg(errp, "Invalid flags 0x%"PRIx64" in log entry %"PRIu64,
	119	le64_to_cpu(cur_entry.flags), cur_idx);
	120	return (uint64_t)-1ull;
	121	}
	122
	123	/* Account for the sector of the entry itself */
	124	++cur_sector;
	125
	126	/*
	127	* Account for the data of the write.
	128	* For discards, this data is not present.
	129	*/
	130	if (!(cur_entry.flags & cpu_to_le64(LOG_DISCARD_FLAG))) {
	131	cur_sector += le64_to_cpu(cur_entry.nr_sectors);
	132	}
	133
	134	++cur_idx;
	135	}
	136
	137	return cur_sector;
	138	}
	139
bfcc224e AV	140	static int blk_log_writes_open(BlockDriverState bs, QDict options, int flags,
	141	Error **errp)
	142	{
	143	BDRVBlkLogWritesState *s = bs->opaque;
	144	QemuOpts *opts;
	145	Error *local_err = NULL;
	146	int ret;
2dacaf7c	147	uint64_t log_sector_size;
0878b3c1	148	bool log_append;
bfcc224e AV	149
	150	opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
	151	qemu_opts_absorb_qdict(opts, options, &local_err);
	152	if (local_err) {
	153	ret = -EINVAL;
	154	error_propagate(errp, local_err);
	155	goto fail;
	156	}
	157
	158	/* Open the file */
	159	bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false,
	160	&local_err);
	161	if (local_err) {
	162	ret = -EINVAL;
	163	error_propagate(errp, local_err);
	164	goto fail;
	165	}
	166
bfcc224e AV	167	/* Open the log file */
	168	s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
	169	&local_err);
	170	if (local_err) {
	171	ret = -EINVAL;
	172	error_propagate(errp, local_err);
	173	goto fail;
	174	}
	175
0878b3c1 AS	176	log_append = qemu_opt_get_bool(opts, "log-append", false);
	177
	178	if (log_append) {
	179	struct log_write_super log_sb = { 0, 0, 0, 0 };
	180
	181	if (qemu_opt_find(opts, "log-sector-size")) {
	182	ret = -EINVAL;
	183	error_setg(errp, "log-append and log-sector-size are mutually "
	184	"exclusive");
	185	goto fail_log;
	186	}
	187
	188	/* Read log superblock or fake one for an empty log */
	189	if (!bdrv_getlength(s->log_file->bs)) {
	190	log_sb.magic = cpu_to_le64(WRITE_LOG_MAGIC);
	191	log_sb.version = cpu_to_le64(WRITE_LOG_VERSION);
	192	log_sb.nr_entries = cpu_to_le64(0);
	193	log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
	194	} else {
	195	ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb));
	196	if (ret < 0) {
	197	error_setg_errno(errp, -ret, "Could not read log superblock");
	198	goto fail_log;
	199	}
	200	}
	201
	202	if (log_sb.magic != cpu_to_le64(WRITE_LOG_MAGIC)) {
	203	ret = -EINVAL;
	204	error_setg(errp, "Invalid log superblock magic");
	205	goto fail_log;
	206	}
	207
	208	if (log_sb.version != cpu_to_le64(WRITE_LOG_VERSION)) {
	209	ret = -EINVAL;
	210	error_setg(errp, "Unsupported log version %"PRIu64,
	211	le64_to_cpu(log_sb.version));
	212	goto fail_log;
	213	}
	214
	215	log_sector_size = le32_to_cpu(log_sb.sectorsize);
	216	s->cur_log_sector = 1;
	217	s->nr_entries = 0;
	218
	219	if (blk_log_writes_sector_size_valid(log_sector_size)) {
	220	s->cur_log_sector =
	221	blk_log_writes_find_cur_log_sector(s->log_file, log_sector_size,
	222	le64_to_cpu(log_sb.nr_entries), &local_err);
	223	if (local_err) {
	224	ret = -EINVAL;
	225	error_propagate(errp, local_err);
	226	goto fail_log;
	227	}
	228
	229	s->nr_entries = le64_to_cpu(log_sb.nr_entries);
	230	}
	231	} else {
	232	log_sector_size = qemu_opt_get_size(opts, "log-sector-size",
	233	BDRV_SECTOR_SIZE);
	234	s->cur_log_sector = 1;
	235	s->nr_entries = 0;
	236	}
	237
	238	if (!blk_log_writes_sector_size_valid(log_sector_size)) {
	239	ret = -EINVAL;
240	error_setg(errp, "Invalid log sector size %"PRIu64, log_sector_size);
241	goto fail_log;
242	}
243
244	s->sectorsize = log_sector_size;
245	s->sectorbits = blk_log_writes_log2(log_sector_size);
1dce698e AS	246	s->update_interval = qemu_opt_get_number(opts, "log-super-update-interval",
	247	4096);
	248	if (!s->update_interval) {
	249	ret = -EINVAL;
	250	error_setg(errp, "Invalid log superblock update interval %"PRIu64,
	251	s->update_interval);
	252	goto fail_log;
	253	}
0878b3c1	254
bfcc224e	255	ret = 0;
0878b3c1 AS	256	fail_log:
	257	if (ret < 0) {
	258	bdrv_unref_child(bs, s->log_file);
	259	s->log_file = NULL;
	260	}
bfcc224e AV	261	fail:
	262	if (ret < 0) {
	263	bdrv_unref_child(bs, bs->file);
	264	bs->file = NULL;
	265	}
	266	qemu_opts_del(opts);
	267	return ret;
	268	}
	269
	270	static void blk_log_writes_close(BlockDriverState *bs)
	271	{
	272	BDRVBlkLogWritesState *s = bs->opaque;
	273
	274	bdrv_unref_child(bs, s->log_file);
	275	s->log_file = NULL;
	276	}
	277
	278	static int64_t blk_log_writes_getlength(BlockDriverState *bs)
	279	{
	280	return bdrv_getlength(bs->file->bs);
	281	}
	282
bfcc224e AV	283	static void blk_log_writes_child_perm(BlockDriverState bs, BdrvChild c,
	284	const BdrvChildRole *role,
	285	BlockReopenQueue *ro_q,
	286	uint64_t perm, uint64_t shrd,
	287	uint64_t nperm, uint64_t nshrd)
	288	{
	289	if (!c) {
	290	*nperm = perm & DEFAULT_PERM_PASSTHROUGH;
	291	*nshrd = (shrd & DEFAULT_PERM_PASSTHROUGH) \| DEFAULT_PERM_UNCHANGED;
	292	return;
	293	}
	294
	295	if (!strcmp(c->name, "log")) {
	296	bdrv_format_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
	297	} else {
	298	bdrv_filter_default_perms(bs, c, role, ro_q, perm, shrd, nperm, nshrd);
	299	}
	300	}
	301
	302	static void blk_log_writes_refresh_limits(BlockDriverState bs, Error *errp)
	303	{
	304	BDRVBlkLogWritesState *s = bs->opaque;
	305	bs->bl.request_alignment = s->sectorsize;
	306	}
	307
	308	static int coroutine_fn
	309	blk_log_writes_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
	310	QEMUIOVector *qiov, int flags)
	311	{
	312	return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
	313	}
	314
	315	typedef struct BlkLogWritesFileReq {
	316	BlockDriverState *bs;
	317	uint64_t offset;
	318	uint64_t bytes;
	319	int file_flags;
	320	QEMUIOVector *qiov;
	321	int (func)(struct BlkLogWritesFileReq r);
	322	int file_ret;
	323	} BlkLogWritesFileReq;
	324
	325	typedef struct {
	326	BlockDriverState *bs;
	327	QEMUIOVector *qiov;
	328	struct log_write_entry entry;
	329	uint64_t zero_size;
	330	int log_ret;
	331	} BlkLogWritesLogReq;
	332
	333	static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
	334	{
	335	BDRVBlkLogWritesState *s = lr->bs->opaque;
	336	uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;
	337
	338	s->nr_entries++;
	339	s->cur_log_sector +=
	340	ROUND_UP(lr->qiov->size, s->sectorsize) >> s->sectorbits;
	341
	342	lr->log_ret = bdrv_co_pwritev(s->log_file, cur_log_offset, lr->qiov->size,
	343	lr->qiov, 0);
	344
	345	/* Logging for the "write zeroes" operation */
	346	if (lr->log_ret == 0 && lr->zero_size) {
347	cur_log_offset = s->cur_log_sector << s->sectorbits;
348	s->cur_log_sector +=
349	ROUND_UP(lr->zero_size, s->sectorsize) >> s->sectorbits;
350
351	lr->log_ret = bdrv_co_pwrite_zeroes(s->log_file, cur_log_offset,
352	lr->zero_size, 0);
353	}
354
1dce698e AS	355	/* Update super block on flush or every update interval */
	356	if (lr->log_ret == 0 && ((lr->entry.flags & LOG_FLUSH_FLAG)
	357	\|\| (s->nr_entries % s->update_interval == 0)))
	358	{
bfcc224e AV	359	struct log_write_super super = {
	360	.magic = cpu_to_le64(WRITE_LOG_MAGIC),
	361	.version = cpu_to_le64(WRITE_LOG_VERSION),
	362	.nr_entries = cpu_to_le64(s->nr_entries),
	363	.sectorsize = cpu_to_le32(s->sectorsize),
	364	};
	365	void *zeroes = g_malloc0(s->sectorsize - sizeof(super));
	366	QEMUIOVector qiov;
	367
	368	qemu_iovec_init(&qiov, 2);
	369	qemu_iovec_add(&qiov, &super, sizeof(super));
	370	qemu_iovec_add(&qiov, zeroes, s->sectorsize - sizeof(super));
	371
	372	lr->log_ret =
	373	bdrv_co_pwritev(s->log_file, 0, s->sectorsize, &qiov, 0);
	374	if (lr->log_ret == 0) {
	375	lr->log_ret = bdrv_co_flush(s->log_file->bs);
	376	}
	377	qemu_iovec_destroy(&qiov);
	378	g_free(zeroes);
	379	}
	380	}
	381
	382	static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
	383	{
	384	fr->file_ret = fr->func(fr);
	385	}
	386
	387	static int coroutine_fn
	388	blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
	389	QEMUIOVector *qiov, int flags,
	390	int (file_func)(BlkLogWritesFileReq r),
	391	uint64_t entry_flags, bool is_zero_write)
	392	{
	393	QEMUIOVector log_qiov;
	394	size_t niov = qiov ? qiov->niov : 0;
	395	BDRVBlkLogWritesState *s = bs->opaque;
	396	BlkLogWritesFileReq fr = {
	397	.bs = bs,
	398	.offset = offset,
	399	.bytes = bytes,
	400	.file_flags = flags,
	401	.qiov = qiov,
	402	.func = file_func,
	403	};
	404	BlkLogWritesLogReq lr = {
	405	.bs = bs,
	406	.qiov = &log_qiov,
	407	.entry = {
	408	.sector = cpu_to_le64(offset >> s->sectorbits),
	409	.nr_sectors = cpu_to_le64(bytes >> s->sectorbits),
	410	.flags = cpu_to_le64(entry_flags),
	411	.data_len = 0,
	412	},
	413	.zero_size = is_zero_write ? bytes : 0,
	414	};
	415	void *zeroes = g_malloc0(s->sectorsize - sizeof(lr.entry));
	416
	417	assert((1 << s->sectorbits) == s->sectorsize);
	418	assert(bs->bl.request_alignment == s->sectorsize);
	419	assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
	420	assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
	421
	422	qemu_iovec_init(&log_qiov, niov + 2);
423	qemu_iovec_add(&log_qiov, &lr.entry, sizeof(lr.entry));
424	qemu_iovec_add(&log_qiov, zeroes, s->sectorsize - sizeof(lr.entry));
425	if (qiov) {
426	qemu_iovec_concat(&log_qiov, qiov, 0, qiov->size);
427	}
428
429	blk_log_writes_co_do_file(&fr);
430	blk_log_writes_co_do_log(&lr);
431
432	qemu_iovec_destroy(&log_qiov);
433	g_free(zeroes);
434
435	if (lr.log_ret < 0) {
436	return lr.log_ret;
437	}
438
439	return fr.file_ret;
440	}
441
442	static int coroutine_fn
443	blk_log_writes_co_do_file_pwritev(BlkLogWritesFileReq *fr)
444	{
445	return bdrv_co_pwritev(fr->bs->file, fr->offset, fr->bytes,
446	fr->qiov, fr->file_flags);
447	}
448
449	static int coroutine_fn
450	blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
451	{
452	return bdrv_co_pwrite_zeroes(fr->bs->file, fr->offset, fr->bytes,
453	fr->file_flags);
454	}
455
456	static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
457	{
458	return bdrv_co_flush(fr->bs->file->bs);
459	}
460
461	static int coroutine_fn
462	blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
463	{
0b9fd3f4	464	return bdrv_co_pdiscard(fr->bs->file, fr->offset, fr->bytes);
bfcc224e AV	465	}
	466
	467	static int coroutine_fn
	468	blk_log_writes_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
	469	QEMUIOVector *qiov, int flags)
	470	{
	471	return blk_log_writes_co_log(bs, offset, bytes, qiov, flags,
	472	blk_log_writes_co_do_file_pwritev, 0, false);
	473	}
	474
	475	static int coroutine_fn
	476	blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
	477	BdrvRequestFlags flags)
	478	{
	479	return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
	480	blk_log_writes_co_do_file_pwrite_zeroes, 0,
	481	true);
	482	}
	483
	484	static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
	485	{
	486	return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
	487	blk_log_writes_co_do_file_flush,
	488	LOG_FLUSH_FLAG, false);
	489	}
	490
	491	static int coroutine_fn
	492	blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
	493	{
	494	return blk_log_writes_co_log(bs, offset, count, NULL, 0,
	495	blk_log_writes_co_do_file_pdiscard,
	496	LOG_DISCARD_FLAG, false);
	497	}
	498
2654267c HR	499	static const char *const blk_log_writes_strong_runtime_opts[] = {
	500	"log-append",
	501	"log-sector-size",
	502
	503	NULL
	504	};
	505
bfcc224e AV	506	static BlockDriver bdrv_blk_log_writes = {
	507	.format_name = "blklogwrites",
	508	.instance_size = sizeof(BDRVBlkLogWritesState),
	509
	510	.bdrv_open = blk_log_writes_open,
	511	.bdrv_close = blk_log_writes_close,
	512	.bdrv_getlength = blk_log_writes_getlength,
bfcc224e AV	513	.bdrv_child_perm = blk_log_writes_child_perm,
	514	.bdrv_refresh_limits = blk_log_writes_refresh_limits,
	515
	516	.bdrv_co_preadv = blk_log_writes_co_preadv,
	517	.bdrv_co_pwritev = blk_log_writes_co_pwritev,
	518	.bdrv_co_pwrite_zeroes = blk_log_writes_co_pwrite_zeroes,
	519	.bdrv_co_flush_to_disk = blk_log_writes_co_flush_to_disk,
	520	.bdrv_co_pdiscard = blk_log_writes_co_pdiscard,
	521	.bdrv_co_block_status = bdrv_co_block_status_from_file,
	522
	523	.is_filter = true,
2654267c	524	.strong_runtime_opts = blk_log_writes_strong_runtime_opts,
bfcc224e AV	525	};
	526
	527	static void bdrv_blk_log_writes_init(void)
	528	{
	529	bdrv_register(&bdrv_blk_log_writes);
	530	}
	531
	532	block_init(bdrv_blk_log_writes_init);