#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/sockets.h" /* for EINPROGRESS on Windows */
+#include "block/block-io.h"
#include "block/block_int.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qstring.h"
#include "qemu/cutils.h"
+#include "qemu/module.h"
#include "qemu/option.h"
/* Disk format stuff - taken from Linux drivers/md/dm-log-writes.c */
#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
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 */ }
},
};
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,
+ sizeof(cur_entry), &cur_entry, 0);
+ 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)
{
QemuOpts *opts;
Error *local_err = NULL;
int ret;
- int64_t log_sector_size;
+ 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) {
+ if (!qemu_opts_absorb_qdict(opts, options, errp)) {
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 = bdrv_open_file_child(NULL, options, "file", bs, errp);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ /* Open the log file */
+ s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_of_bds,
+ BDRV_CHILD_METADATA, false, errp);
+ if (!s->log_file) {
ret = -EINVAL;
- error_propagate(errp, local_err);
goto fail;
}
- log_sector_size = qemu_opt_get_size(opts, "log-sector-size",
- BDRV_SECTOR_SIZE);
+ log_append = qemu_opt_get_bool(opts, "log-append", false);
- if (log_sector_size < 0 || log_sector_size > (1ull << 23) ||
- !is_power_of_2(log_sector_size))
- {
+ 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, sizeof(log_sb), &log_sb, 0);
+ 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 %"PRId64, log_sector_size);
- goto fail;
+ 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->cur_log_sector = 1;
- s->nr_entries = 0;
-
- /* Open the log file */
- s->log_file = bdrv_open_child(NULL, options, "log", bs, &child_file, false,
- &local_err);
- if (local_err) {
+ s->update_interval = qemu_opt_get_number(opts, "log-super-update-interval",
+ 4096);
+ if (!s->update_interval) {
ret = -EINVAL;
- error_propagate(errp, local_err);
- goto fail;
+ error_setg(errp, "Invalid log superblock update interval %"PRIu64,
+ s->update_interval);
+ goto fail_log;
}
ret = 0;
-fail:
+fail_log:
if (ret < 0) {
- bdrv_unref_child(bs, bs->file);
- bs->file = NULL;
+ bdrv_unref_child(bs, s->log_file);
+ s->log_file = NULL;
}
+fail:
qemu_opts_del(opts);
return ret;
}
return bdrv_getlength(bs->file->bs);
}
-static void blk_log_writes_refresh_filename(BlockDriverState *bs,
- QDict *options)
-{
- BDRVBlkLogWritesState *s = bs->opaque;
-
- /* bs->file->bs has already been refreshed */
- bdrv_refresh_filename(s->log_file->bs);
-
- if (bs->file->bs->full_open_options
- && s->log_file->bs->full_open_options)
- {
- QDict *opts = qdict_new();
- qdict_put_str(opts, "driver", "blklogwrites");
-
- qobject_ref(bs->file->bs->full_open_options);
- qdict_put_obj(opts, "file", QOBJECT(bs->file->bs->full_open_options));
- qobject_ref(s->log_file->bs->full_open_options);
- qdict_put_obj(opts, "log",
- QOBJECT(s->log_file->bs->full_open_options));
- qdict_put_int(opts, "log-sector-size", s->sectorsize);
-
- bs->full_open_options = opts;
- }
-}
-
static void blk_log_writes_child_perm(BlockDriverState *bs, BdrvChild *c,
- const BdrvChildRole *role,
+ BdrvChildRole role,
BlockReopenQueue *ro_q,
uint64_t perm, uint64_t shrd,
uint64_t *nperm, uint64_t *nshrd)
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);
- }
+ bdrv_default_perms(bs, c, role, ro_q, perm, shrd,
+ nperm, nshrd);
}
static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
}
static int coroutine_fn
-blk_log_writes_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
- QEMUIOVector *qiov, int flags)
+blk_log_writes_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
+ QEMUIOVector *qiov, BdrvRequestFlags flags)
{
return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
}
lr->zero_size, 0);
}
- /* Update super block on flush */
- if (lr->log_ret == 0 && lr->entry.flags & LOG_FLUSH_FLAG) {
+ /* 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),
static int coroutine_fn
blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
{
- return bdrv_co_pdiscard(fr->bs->file->bs, fr->offset, fr->bytes);
+ 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)
+blk_log_writes_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
+ QEMUIOVector *qiov, BdrvRequestFlags 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)
+blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
+ int64_t bytes, BdrvRequestFlags flags)
{
return blk_log_writes_co_log(bs, offset, bytes, NULL, flags,
blk_log_writes_co_do_file_pwrite_zeroes, 0,
}
static int coroutine_fn
-blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
+blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
{
- return blk_log_writes_co_log(bs, offset, count, NULL, 0,
+ return blk_log_writes_co_log(bs, offset, bytes, 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_refresh_filename = blk_log_writes_refresh_filename,
.bdrv_child_perm = blk_log_writes_child_perm,
.bdrv_refresh_limits = blk_log_writes_refresh_limits,
.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)
projects / mirror_qemu.git / blobdiff