ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

nbd: Allow export of multiple bitmaps for one device 

With this, 'qemu-nbd -B b0 -B b1 -f qcow2 img.qcow2' can let you sniff
out multiple bitmaps from one server.  qemu-img as client can still
only read one bitmap per client connection, but other NBD clients
(hello libnbd) can now read multiple bitmaps in a single pass.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20201027050556.269064-8-eblake@redhat.com>
This commit is contained in:
Eric Blake 2020-10-27 00:05:52 -05:00
parent 47ec485e8d
commit 3b1f244c59
2 changed files with 72 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
nbd/server.c
View File

@ -27,6 +27,7 @@
#include "qemu/units.h" #include "qemu/units.h"
#define NBD_META_ID_BASE_ALLOCATION 0 #define NBD_META_ID_BASE_ALLOCATION 0
/* Dirty bitmaps use 'NBD_META_ID_DIRTY_BITMAP + i', so keep this id last. */
#define NBD_META_ID_DIRTY_BITMAP 1 #define NBD_META_ID_DIRTY_BITMAP 1
/* /*
@ -94,7 +95,8 @@ struct NBDExport {
BlockBackend *eject_notifier_blk; BlockBackend *eject_notifier_blk;
Notifier eject_notifier; Notifier eject_notifier;
BdrvDirtyBitmap *export_bitmap; BdrvDirtyBitmap **export_bitmaps;
size_t nr_export_bitmaps;
}; };
static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports); static QTAILQ_HEAD(, NBDExport) exports = QTAILQ_HEAD_INITIALIZER(exports);
@ -106,7 +108,10 @@ typedef struct NBDExportMetaContexts {
NBDExport *exp; NBDExport *exp;
size_t count; /* number of negotiated contexts */ size_t count; /* number of negotiated contexts */
bool base_allocation; /* export base:allocation context (block status) */ bool base_allocation; /* export base:allocation context (block status) */
bool bitmap; /* export qemu:dirty-bitmap:<export bitmap name> */ bool *bitmaps; /*
* export qemu:dirty-bitmap:<export bitmap name>,
* sized by exp->nr_export_bitmaps
*/
} NBDExportMetaContexts; } NBDExportMetaContexts;
struct NBDClient { struct NBDClient {
@ -857,6 +862,8 @@ static bool nbd_meta_base_query(NBDClient *client, NBDExportMetaContexts *meta,
static bool nbd_meta_qemu_query(NBDClient *client, NBDExportMetaContexts *meta, static bool nbd_meta_qemu_query(NBDClient *client, NBDExportMetaContexts *meta,
const char *query) const char *query)
{ {
size_t i;
if (!nbd_strshift(&query, "qemu:")) { if (!nbd_strshift(&query, "qemu:")) {
return false; return false;
} }
@ -864,24 +871,33 @@ static bool nbd_meta_qemu_query(NBDClient *client, NBDExportMetaContexts *meta,
if (!*query) { if (!*query) {
if (client->opt == NBD_OPT_LIST_META_CONTEXT) { if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
meta->bitmap = !!meta->exp->export_bitmap; memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
} }
trace_nbd_negotiate_meta_query_parse("empty"); trace_nbd_negotiate_meta_query_parse("empty");
return true; return true;
} }
if (nbd_strshift(&query, "dirty-bitmap:")) { if (nbd_strshift(&query, "dirty-bitmap:")) {
const char *bm_name;
trace_nbd_negotiate_meta_query_parse("dirty-bitmap:"); trace_nbd_negotiate_meta_query_parse("dirty-bitmap:");
if (!meta->exp->export_bitmap) { if (!*query) {
trace_nbd_negotiate_meta_query_skip("no dirty-bitmap exported"); if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
}
trace_nbd_negotiate_meta_query_parse("empty");
return true; return true;
} }
bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmap);
if (nbd_meta_empty_or_pattern(client, bm_name, query)) { for (i = 0; i < meta->exp->nr_export_bitmaps; i++) {
meta->bitmap = true; const char *bm_name;
bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmaps[i]);
if (strcmp(bm_name, query) == 0) {
meta->bitmaps[i] = true;
trace_nbd_negotiate_meta_query_parse(query);
return true;
}
} }
trace_nbd_negotiate_meta_query_skip("no dirty-bitmap match");
return true; return true;
} }
@ -943,9 +959,10 @@ static int nbd_negotiate_meta_queries(NBDClient *client,
{ {
int ret; int ret;
g_autofree char *export_name = NULL; g_autofree char *export_name = NULL;
NBDExportMetaContexts local_meta; g_autofree bool *bitmaps = NULL;
NBDExportMetaContexts local_meta = {0};
uint32_t nb_queries; uint32_t nb_queries;
int i; size_t i;
size_t count = 0; size_t count = 0;
if (!client->structured_reply) { if (!client->structured_reply) {
@ -960,6 +977,7 @@ static int nbd_negotiate_meta_queries(NBDClient *client,
meta = &local_meta; meta = &local_meta;
} }
g_free(meta->bitmaps);
memset(meta, 0, sizeof(*meta)); memset(meta, 0, sizeof(*meta));
ret = nbd_opt_read_name(client, &export_name, NULL, errp); ret = nbd_opt_read_name(client, &export_name, NULL, errp);
@ -974,6 +992,10 @@ static int nbd_negotiate_meta_queries(NBDClient *client,
return nbd_opt_drop(client, NBD_REP_ERR_UNKNOWN, errp, return nbd_opt_drop(client, NBD_REP_ERR_UNKNOWN, errp,
"export '%s' not present", sane_name); "export '%s' not present", sane_name);
} }
meta->bitmaps = g_new0(bool, meta->exp->nr_export_bitmaps);
if (client->opt == NBD_OPT_LIST_META_CONTEXT) {
bitmaps = meta->bitmaps;
}
ret = nbd_opt_read(client, &nb_queries, sizeof(nb_queries), false, errp); ret = nbd_opt_read(client, &nb_queries, sizeof(nb_queries), false, errp);
if (ret <= 0) { if (ret <= 0) {
@ -986,7 +1008,7 @@ static int nbd_negotiate_meta_queries(NBDClient *client,
if (client->opt == NBD_OPT_LIST_META_CONTEXT && !nb_queries) { if (client->opt == NBD_OPT_LIST_META_CONTEXT && !nb_queries) {
/* enable all known contexts */ /* enable all known contexts */
meta->base_allocation = true; meta->base_allocation = true;
meta->bitmap = !!meta->exp->export_bitmap; memset(meta->bitmaps, 1, meta->exp->nr_export_bitmaps);
} else { } else {
for (i = 0; i < nb_queries; ++i) { for (i = 0; i < nb_queries; ++i) {
ret = nbd_negotiate_meta_query(client, meta, errp); ret = nbd_negotiate_meta_query(client, meta, errp);
@ -1006,13 +1028,19 @@ static int nbd_negotiate_meta_queries(NBDClient *client,
count++; count++;
} }
if (meta->bitmap) { for (i = 0; i < meta->exp->nr_export_bitmaps; i++) {
const char *bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmap); const char *bm_name;
g_autofree char *context = g_strdup_printf("qemu:dirty-bitmap:%s", g_autofree char *context = NULL;
bm_name);
if (!meta->bitmaps[i]) {
continue;
}
bm_name = bdrv_dirty_bitmap_name(meta->exp->export_bitmaps[i]);
context = g_strdup_printf("qemu:dirty-bitmap:%s", bm_name);
ret = nbd_negotiate_send_meta_context(client, context, ret = nbd_negotiate_send_meta_context(client, context,
NBD_META_ID_DIRTY_BITMAP, NBD_META_ID_DIRTY_BITMAP + i,
errp); errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
@ -1366,6 +1394,7 @@ void nbd_client_put(NBDClient *client)
QTAILQ_REMOVE(&client->exp->clients, client, next); QTAILQ_REMOVE(&client->exp->clients, client, next);
blk_exp_unref(&client->exp->common); blk_exp_unref(&client->exp->common);
} }
g_free(client->export_meta.bitmaps);
g_free(client); g_free(client);
} }
} }
@ -1482,6 +1511,7 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
bool readonly = !exp_args->writable; bool readonly = !exp_args->writable;
bool shared = !exp_args->writable; bool shared = !exp_args->writable;
strList *bitmaps; strList *bitmaps;
size_t i;
int ret; int ret;
assert(exp_args->type == BLOCK_EXPORT_TYPE_NBD); assert(exp_args->type == BLOCK_EXPORT_TYPE_NBD);
@ -1541,12 +1571,12 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
} }
exp->size = QEMU_ALIGN_DOWN(size, BDRV_SECTOR_SIZE); exp->size = QEMU_ALIGN_DOWN(size, BDRV_SECTOR_SIZE);
/* XXX Allow more than one bitmap */
if (arg->bitmaps && arg->bitmaps->next) {
error_setg(errp, "multiple bitmaps per export not supported yet");
return -EOPNOTSUPP;
}
for (bitmaps = arg->bitmaps; bitmaps; bitmaps = bitmaps->next) { for (bitmaps = arg->bitmaps; bitmaps; bitmaps = bitmaps->next) {
exp->nr_export_bitmaps++;
}
exp->export_bitmaps = g_new0(BdrvDirtyBitmap *, exp->nr_export_bitmaps);
for (i = 0, bitmaps = arg->bitmaps; bitmaps;
i++, bitmaps = bitmaps->next) {
const char *bitmap = bitmaps->value; const char *bitmap = bitmaps->value;
BlockDriverState *bs = blk_bs(blk); BlockDriverState *bs = blk_bs(blk);
BdrvDirtyBitmap *bm = NULL; BdrvDirtyBitmap *bm = NULL;
@ -1580,11 +1610,15 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
goto fail; goto fail;
} }
bdrv_dirty_bitmap_set_busy(bm, true); exp->export_bitmaps[i] = bm;
exp->export_bitmap = bm;
assert(strlen(bitmap) <= BDRV_BITMAP_MAX_NAME_SIZE); assert(strlen(bitmap) <= BDRV_BITMAP_MAX_NAME_SIZE);
} }
/* Mark bitmaps busy in a separate loop, to simplify roll-back concerns. */
for (i = 0; i < exp->nr_export_bitmaps; i++) {
bdrv_dirty_bitmap_set_busy(exp->export_bitmaps[i], true);
}
blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp); blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
QTAILQ_INSERT_TAIL(&exports, exp, next); QTAILQ_INSERT_TAIL(&exports, exp, next);
@ -1592,6 +1626,7 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
return 0; return 0;
fail: fail:
g_free(exp->export_bitmaps);
g_free(exp->name); g_free(exp->name);
g_free(exp->description); g_free(exp->description);
return ret; return ret;
@ -1641,6 +1676,7 @@ static void nbd_export_request_shutdown(BlockExport *blk_exp)
static void nbd_export_delete(BlockExport *blk_exp) static void nbd_export_delete(BlockExport *blk_exp)
{ {
size_t i;
NBDExport *exp = container_of(blk_exp, NBDExport, common); NBDExport *exp = container_of(blk_exp, NBDExport, common);
assert(exp->name == NULL); assert(exp->name == NULL);
@ -1658,8 +1694,8 @@ static void nbd_export_delete(BlockExport *blk_exp)
blk_aio_detach, exp); blk_aio_detach, exp);
} }
if (exp->export_bitmap) { for (i = 0; i < exp->nr_export_bitmaps; i++) {
bdrv_dirty_bitmap_set_busy(exp->export_bitmap, false); bdrv_dirty_bitmap_set_busy(exp->export_bitmaps[i], false);
} }
} }
@ -2268,6 +2304,7 @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
int flags; int flags;
NBDExport *exp = client->exp; NBDExport *exp = client->exp;
char *msg; char *msg;
size_t i;
switch (request->type) { switch (request->type) {
case NBD_CMD_CACHE: case NBD_CMD_CACHE:
@ -2358,12 +2395,15 @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
} }
} }
if (client->export_meta.bitmap) { for (i = 0; i < client->exp->nr_export_bitmaps; i++) {
if (!client->export_meta.bitmaps[i]) {
continue;
}
ret = nbd_co_send_bitmap(client, request->handle, ret = nbd_co_send_bitmap(client, request->handle,
client->exp->export_bitmap, client->exp->export_bitmaps[i],
request->from, request->len, request->from, request->len,
dont_fragment, !--contexts_remaining, dont_fragment, !--contexts_remaining,
NBD_META_ID_DIRTY_BITMAP, errp); NBD_META_ID_DIRTY_BITMAP + i, errp);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }

6
tests/qemu-iotests/291
View File

@ -115,16 +115,14 @@ echo
# x-dirty-bitmap is a hack for reading bitmaps; it abuses block status to # x-dirty-bitmap is a hack for reading bitmaps; it abuses block status to
# report "data":false for portions of the bitmap which are set # report "data":false for portions of the bitmap which are set
IMG="driver=nbd,server.type=unix,server.path=$nbd_unix_socket" IMG="driver=nbd,server.type=unix,server.path=$nbd_unix_socket"
nbd_server_start_unix_socket -r -f qcow2 -B b0 "$TEST_IMG" nbd_server_start_unix_socket -r -f qcow2 \
-B b0 -B b1 -B b2 -B b3 "$TEST_IMG"
$QEMU_IMG map --output=json --image-opts \ $QEMU_IMG map --output=json --image-opts \
"$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b0" | _filter_qemu_img_map "$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b0" | _filter_qemu_img_map
nbd_server_start_unix_socket -r -f qcow2 -B b1 "$TEST_IMG"
$QEMU_IMG map --output=json --image-opts \ $QEMU_IMG map --output=json --image-opts \
"$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b1" | _filter_qemu_img_map "$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b1" | _filter_qemu_img_map
nbd_server_start_unix_socket -r -f qcow2 -B b2 "$TEST_IMG"
$QEMU_IMG map --output=json --image-opts \ $QEMU_IMG map --output=json --image-opts \
"$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b2" | _filter_qemu_img_map "$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b2" | _filter_qemu_img_map
nbd_server_start_unix_socket -r -f qcow2 -B b3 "$TEST_IMG"
$QEMU_IMG map --output=json --image-opts \ $QEMU_IMG map --output=json --image-opts \
"$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b3" | _filter_qemu_img_map "$IMG,x-dirty-bitmap=qemu:dirty-bitmap:b3" | _filter_qemu_img_map