mirror of
https://gitlab.com/qemu-project/qemu
synced 2024-09-06 18:05:37 +00:00
![Vladimir Sementsov-Ogievskiy](/assets/img/avatar_default.png)
We are generally moving to int64_t for both offset and bytes parameters on all io paths. Main motivation is realization of 64-bit write_zeroes operation for fast zeroing large disk chunks, up to the whole disk. We chose signed type, to be consistent with off_t (which is signed) and with possibility for signed return type (where negative value means error). So, convert driver discard handlers bytes parameter to int64_t. The only caller of all updated function is bdrv_co_pdiscard in block/io.c. It is already prepared to work with 64bit requests, but pass at most max(bs->bl.max_pdiscard, INT_MAX) to the driver. Let's look at all updated functions: blkdebug: all calculations are still OK, thanks to bdrv_check_qiov_request(). both rule_check and bdrv_co_pdiscard are 64bit blklogwrites: pass to blk_loc_writes_co_log which is 64bit blkreplay, copy-on-read, filter-compress: pass to bdrv_co_pdiscard, OK copy-before-write: pass to bdrv_co_pdiscard which is 64bit and to cbw_do_copy_before_write which is 64bit file-posix: one handler calls raw_account_discard() is 64bit and both handlers calls raw_do_pdiscard(). Update raw_do_pdiscard, which pass to RawPosixAIOData::aio_nbytes, which is 64bit (and calls raw_account_discard()) gluster: somehow, third argument of glfs_discard_async is size_t. Let's set max_pdiscard accordingly. iscsi: iscsi_allocmap_set_invalid is 64bit, !is_byte_request_lun_aligned is 64bit. list.num is uint32_t. Let's clarify max_pdiscard and pdiscard_alignment. mirror_top: pass to bdrv_mirror_top_do_write() which is 64bit nbd: protocol limitation. max_pdiscard is alredy set strict enough, keep it as is for now. nvme: buf.nlb is uint32_t and we do shift. So, add corresponding limits to nvme_refresh_limits(). preallocate: pass to bdrv_co_pdiscard() which is 64bit. rbd: pass to qemu_rbd_start_co() which is 64bit. qcow2: calculations are still OK, thanks to bdrv_check_qiov_request(), qcow2_cluster_discard() is 64bit. raw-format: raw_adjust_offset() is 64bit, bdrv_co_pdiscard too. throttle: pass to bdrv_co_pdiscard() which is 64bit and to throttle_group_co_io_limits_intercept() which is 64bit as well. test-block-iothread: bytes argument is unused Great! Now all drivers are prepared to handle 64bit discard requests, or else have explicit max_pdiscard limits. Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Message-Id: <20210903102807.27127-11-vsementsov@virtuozzo.com> Reviewed-by: Eric Blake <eblake@redhat.com> Signed-off-by: Eric Blake <eblake@redhat.com>
159 lines
4.4 KiB
C
159 lines
4.4 KiB
C
/*
|
|
* Block protocol for record/replay
|
|
*
|
|
* Copyright (c) 2010-2016 Institute for System Programming
|
|
* of the Russian Academy of Sciences.
|
|
*
|
|
* 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 "qemu/module.h"
|
|
#include "block/block_int.h"
|
|
#include "sysemu/replay.h"
|
|
#include "qapi/error.h"
|
|
|
|
typedef struct Request {
|
|
Coroutine *co;
|
|
QEMUBH *bh;
|
|
} Request;
|
|
|
|
static int blkreplay_open(BlockDriverState *bs, QDict *options, int flags,
|
|
Error **errp)
|
|
{
|
|
int ret;
|
|
|
|
/* Open the image file */
|
|
bs->file = bdrv_open_child(NULL, options, "image", bs, &child_of_bds,
|
|
BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
|
|
false, errp);
|
|
if (!bs->file) {
|
|
ret = -EINVAL;
|
|
goto fail;
|
|
}
|
|
|
|
bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;
|
|
bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED;
|
|
|
|
ret = 0;
|
|
fail:
|
|
return ret;
|
|
}
|
|
|
|
static int64_t blkreplay_getlength(BlockDriverState *bs)
|
|
{
|
|
return bdrv_getlength(bs->file->bs);
|
|
}
|
|
|
|
/* This bh is used for synchronization of return from coroutines.
|
|
It continues yielded coroutine which then finishes its execution.
|
|
BH is called adjusted to some replay checkpoint, therefore
|
|
record and replay will always finish coroutines deterministically.
|
|
*/
|
|
static void blkreplay_bh_cb(void *opaque)
|
|
{
|
|
Request *req = opaque;
|
|
aio_co_wake(req->co);
|
|
qemu_bh_delete(req->bh);
|
|
g_free(req);
|
|
}
|
|
|
|
static void block_request_create(uint64_t reqid, BlockDriverState *bs,
|
|
Coroutine *co)
|
|
{
|
|
Request *req = g_new(Request, 1);
|
|
*req = (Request) {
|
|
.co = co,
|
|
.bh = aio_bh_new(bdrv_get_aio_context(bs), blkreplay_bh_cb, req),
|
|
};
|
|
replay_block_event(req->bh, reqid);
|
|
}
|
|
|
|
static int coroutine_fn blkreplay_co_preadv(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
|
|
{
|
|
uint64_t reqid = blkreplay_next_id();
|
|
int ret = bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
qemu_coroutine_yield();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int coroutine_fn blkreplay_co_pwritev(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
|
|
{
|
|
uint64_t reqid = blkreplay_next_id();
|
|
int ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
qemu_coroutine_yield();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes, BdrvRequestFlags flags)
|
|
{
|
|
uint64_t reqid = blkreplay_next_id();
|
|
int ret = bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
qemu_coroutine_yield();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int coroutine_fn blkreplay_co_pdiscard(BlockDriverState *bs,
|
|
int64_t offset, int64_t bytes)
|
|
{
|
|
uint64_t reqid = blkreplay_next_id();
|
|
int ret = bdrv_co_pdiscard(bs->file, offset, bytes);
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
qemu_coroutine_yield();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs)
|
|
{
|
|
uint64_t reqid = blkreplay_next_id();
|
|
int ret = bdrv_co_flush(bs->file->bs);
|
|
block_request_create(reqid, bs, qemu_coroutine_self());
|
|
qemu_coroutine_yield();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int blkreplay_snapshot_goto(BlockDriverState *bs,
|
|
const char *snapshot_id)
|
|
{
|
|
return bdrv_snapshot_goto(bs->file->bs, snapshot_id, NULL);
|
|
}
|
|
|
|
static BlockDriver bdrv_blkreplay = {
|
|
.format_name = "blkreplay",
|
|
.instance_size = 0,
|
|
.is_filter = true,
|
|
|
|
.bdrv_open = blkreplay_open,
|
|
.bdrv_child_perm = bdrv_default_perms,
|
|
.bdrv_getlength = blkreplay_getlength,
|
|
|
|
.bdrv_co_preadv = blkreplay_co_preadv,
|
|
.bdrv_co_pwritev = blkreplay_co_pwritev,
|
|
|
|
.bdrv_co_pwrite_zeroes = blkreplay_co_pwrite_zeroes,
|
|
.bdrv_co_pdiscard = blkreplay_co_pdiscard,
|
|
.bdrv_co_flush = blkreplay_co_flush,
|
|
|
|
.bdrv_snapshot_goto = blkreplay_snapshot_goto,
|
|
};
|
|
|
|
static void bdrv_blkreplay_init(void)
|
|
{
|
|
bdrv_register(&bdrv_blkreplay);
|
|
}
|
|
|
|
block_init(bdrv_blkreplay_init);
|