RBD reopen, read_only cleanup
v2 cover RBD reopen, read_only cleanup
Changes from v1:
Patch 2: Has v1 patch 8 (do not blindly xset bs->read_only) squashed into it
(thanks Stefan)
COW -> "copy-on-read" (Thanks John)
Drop unneeded call in vvfat, and bypass enable_write_target (Stefan)
Patch 5: Rename bdrv_try_... to bdrv_can_set_read_only() (Thanks John, Stefan)
Patch 6: Use "reopen_state->flags" not "reopen_state->bs->open_flags"
(Thanks John)
This series does two things:
1.) Cleans up some of the logic behind setting the read_only flag
for a BDS in the block layer, so that it is done consistently (and rules are applied consistently), and
2.) Adds .bdrv_reopen_prepare() implementation for RBD, so that block
jobs can be run on backing chains that have rbd protocol nodes.
Jeff Cody (8):
block: add bdrv_set_read_only() helper function
block: do not set BDS read_only if copy_on_read enabled
block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
block: code movement
block: introduce bdrv_can_set_read_only()
block: use bdrv_can_set_read_only() during reopen block/rbd - update variable names to more apt names block/rbd: Add support for reopen()
block.c | 56 +++++++++++++++++++++++++++++++++++--------- block/bochs.c | 5 +++- block/cloop.c | 5 +++- block/dmg.c | 6 ++++- block/rbd.c | 65 +++++++++++++++++++++++++++++++++++++-------------- block/vvfat.c | 19 +++++++++++---- include/block/block.h | 2 ++ 7 files changed, 123 insertions(+), 35 deletions(-)
Signature · 1 line
2.9.3
PATCH v2 1/8 block: add bdrv_set_read_only() helper function
We have a helper wrapper for checking for the BDS read_only flag, add a helper wrapper to set the read_only flag as well.
--- block.c | 5 +++++ block/bochs.c | 2 +- block/cloop.c | 2 +- block/dmg.c | 2 +- block/rbd.c | 2 +- block/vvfat.c | 4 ++-- include/block/block.h | 1 + 7 files changed, 12 insertions(+), 6 deletions(-)
block.c +5 -0
@@ -192,6 +192,11 @@ void path_combine(char *dest, int dest_size, } } +void bdrv_set_read_only (BlockDriverState *bs,bool read_only) +{ + bs->read_only = read_only; +} + void bdrv_get_full_backing_filename_from_filename(const char *backed, const char *backing, char *dest, size_t sz,
block/bochs.c +1 -1
@@ -110,7 +110,7 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,return -EINVAL ; } - bs->read_only = true;/* no write support yet */ +bdrv_set_read_only (bs, true);/* no write support yet */ ret =bdrv_pread (bs->file,0 , &bochs,sizeof (bochs));if (ret <0 ) {
block/cloop.c +1 -1
@@ -72,7 +72,7 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,return -EINVAL ; } - bs->read_only = true; +bdrv_set_read_only (bs, true);/* read header */ ret =bdrv_pread (bs->file,128 , &s->block_size,4 );
block/dmg.c +1 -1
@@ -420,7 +420,7 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags, }block_module_load_one ("dmg-bz2" ); - bs->read_only = true; +bdrv_set_read_only (bs, true); s->n_chunks =0 ; s->offsets = s->lengths = s->sectors = s->sectorcounts =NULL ;
block/rbd.c +1 -1
@@ -641,7 +641,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, goto failed_open; } - bs->read_only = (s->snap !=NULL ); +bdrv_set_read_only (bs, (s->snap !=NULL ));qemu_opts_del (opts);return 0 ;
block/vvfat.c +2 -2
@@ -1157,7 +1157,7 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags, s->current_cluster=0xffffffff ;/* read only is the default for safety */ - bs->read_only = true; +bdrv_set_read_only (bs, true); s->qcow =NULL ; s->qcow_filename =NULL ; s->fat2 =NULL ;
@@ -1173,7 +1173,7 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,if (ret <0 ) { goto fail; } - bs->read_only = false; +bdrv_set_read_only (bs, false); } bs->total_sectors = cyls * heads * secs;
include/block/block.h +1 -0
@@ -426,6 +426,7 @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base, int64_t sector_num, int nb_sectors, int *pnum);bool bdrv_is_read_only (BlockDriverState *bs); +void bdrv_set_read_only (BlockDriverState *bs,bool read_only);bool bdrv_is_sg (BlockDriverState *bs);bool bdrv_is_inserted (BlockDriverState *bs);int bdrv_media_changed (BlockDriverState *bs);
Signature · 1 line
2.9.3
PATCH v2 2/8 block: do not set BDS read_only if copy_on_read enabled
In reply to Jeff CodyA few block drivers will set the BDS read_only flag from their .bdrv_open() function. This means the bs->read_only flag could be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ flag check occurs prior to the call to bdrv->bdrv_open().
This adds an error return to bdrv_set_read_only(), and an error will be return if we try to set the BDS to read_only while copy_on_read is enabled.
This patch also changes the behavior of vvfat. Before, vvfat could override the drive 'readonly' flag with its own, internal 'rw' flag.
For instance, this -drive parameter would result in a writable image:
"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"
This is not correct. Now, attempting to use the above -drive parameter will result in an error (i.e., 'rw' is incompatible with 'readonly=on').
--- block.c | 10 +++++++++- block/bochs.c | 5 ++++- block/cloop.c | 5 ++++- block/dmg.c | 6 +++++- block/rbd.c | 11 ++++++++++- block/vvfat.c | 19 +++++++++++++++---- include/block/block.h | 2 +- 7 files changed, 48 insertions(+), 10 deletions(-)
block.c +9 -1
@@ -192,9 +192,17 @@ void path_combine(char *dest, int dest_size, } } -void bdrv_set_read_only (BlockDriverState *bs,bool read_only) +int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp) { +/* Do not set read_only if copy_on_read is enabled */ +if (bs->copy_on_read && read_only) { +error_setg (errp,"Can't set node '%s' to r/o with copy-on-read enabled" , +bdrv_get_device_or_node_name (bs)); +return -EINVAL ; + } + bs->read_only = read_only; +return 0 ; } void bdrv_get_full_backing_filename_from_filename(const char *backed,
block/bochs.c +4 -1
@@ -110,7 +110,10 @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,return -EINVAL ; } -bdrv_set_read_only (bs, true);/* no write support yet */ + ret =bdrv_set_read_only (bs, true, errp);/* no write support yet */ +if (ret <0 ) { +return ret; + } ret =bdrv_pread (bs->file,0 , &bochs,sizeof (bochs));if (ret <0 ) {
block/cloop.c +4 -1
@@ -72,7 +72,10 @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,return -EINVAL ; } -bdrv_set_read_only (bs, true); + ret =bdrv_set_read_only (bs, true, errp); +if (ret <0 ) { +return ret; + }/* read header */ ret =bdrv_pread (bs->file,128 , &s->block_size,4 );
block/dmg.c +5 -1
@@ -419,8 +419,12 @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,return -EINVAL ; } + ret =bdrv_set_read_only (bs, true, errp); +if (ret <0 ) { +return ret; + } +block_module_load_one ("dmg-bz2" ); -bdrv_set_read_only (bs, true); s->n_chunks =0 ; s->offsets = s->lengths = s->sectors = s->sectorcounts =NULL ;
block/rbd.c +10 -1
@@ -635,13 +635,22 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, goto failed_shutdown; } +/* rbd_open is always r/w */ r =rbd_open (s->io_ctx, s->name, &s->image, s->snap);if (r <0 ) {error_setg_errno (errp, -r,"error reading header from %s" , s->name); goto failed_open; } -bdrv_set_read_only (bs, (s->snap !=NULL )); +/* If we are using an rbd snapshot, we must be r/o, otherwise +* leave as-is */ +if (s->snap !=NULL ) { + r =bdrv_set_read_only (bs, true, &local_err); +if (r <0 ) { +error_propagate (errp, local_err); + goto failed_open; + } + }qemu_opts_del (opts);return 0 ;
block/vvfat.c +15 -4
@@ -1156,8 +1156,6 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags, s->current_cluster=0xffffffff ; -/* read only is the default for safety */ -bdrv_set_read_only (bs, true); s->qcow =NULL ; s->qcow_filename =NULL ; s->fat2 =NULL ;
@@ -1169,11 +1167,24 @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags, s->sector_count = cyls * heads * secs - (s->first_sectors_number -1 );if (qemu_opt_get_bool (opts,"rw" , false)) { - ret =enable_write_target (bs, errp); +if (!bdrv_is_read_only (bs)) { + ret =enable_write_target (bs, errp); +if (ret <0 ) { + goto fail; + } + }else { + ret = -EPERM ; +error_setg (errp, +"Unable to set VVFAT to 'rw' when drive is read-only" ); + goto fail; + } + }else { +/* read only is the default for safety */ + ret =bdrv_set_read_only (bs, true, &local_err);if (ret <0 ) { +error_propagate (errp, local_err); goto fail; } -bdrv_set_read_only (bs, false); } bs->total_sectors = cyls * heads * secs;
include/block/block.h +1 -1
@@ -426,7 +426,7 @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base, int64_t sector_num, int nb_sectors, int *pnum);bool bdrv_is_read_only (BlockDriverState *bs); -void bdrv_set_read_only (BlockDriverState *bs,bool read_only); +int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp);bool bdrv_is_sg (BlockDriverState *bs);bool bdrv_is_inserted (BlockDriverState *bs);int bdrv_media_changed (BlockDriverState *bs);
Signature · 1 line
2.9.3
PATCH v2 3/8 block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
In reply to Jeff CodyThe BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of the BDS 'read_only' state, but there are a few places where it is ignored. In the bdrv_set_read_only() helper, make sure to honor the flag.
--- block.c | 7 +++++++ 1 file changed, 7 insertions(+)
block.c +7 -0
@@ -201,6 +201,13 @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)return -EINVAL ; } +/* Do not clear read_only if it is prohibited */ +if (!read_only && !(bs->open_flags &BDRV_O_ALLOW_RDWR )) { +error_setg (errp,"Node '%s' is read only" , +bdrv_get_device_or_node_name (bs)); +return -EPERM ; + } + bs->read_only = read_only;return 0 ; }
Signature · 1 line
2.9.3
PATCH v2 4/8 block: code movement
In reply to Jeff CodyMove bdrv_is_read_only() up with its friends.
--- block.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
block.c +5 -5
@@ -192,6 +192,11 @@ void path_combine(char *dest, int dest_size, } } +bool bdrv_is_read_only (BlockDriverState *bs) +{ +return bs->read_only; +} +int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp) {/* Do not set read_only if copy_on_read is enabled */
@@ -3367,11 +3372,6 @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) *nb_sectors_ptr = nb_sectors <0 ?0 : nb_sectors; } -bool bdrv_is_read_only (BlockDriverState *bs) -{ -return bs->read_only; -} -bool bdrv_is_sg (BlockDriverState *bs) {return bs->sg;
Signature · 1 line
2.9.3
PATCH v2 5/8 block: introduce bdrv_can_set_read_only()
In reply to Jeff CodyIntroduce check function for setting read_only flags. Will return < 0 on error, with appropriate Error value set. Does not alter any flags.
--- block.c | 14 +++++++++++++- include/block/block.h | 1 + 2 files changed, 14 insertions(+), 1 deletion(-)
block.c +13 -1
@@ -197,7 +197,7 @@ bool bdrv_is_read_only(BlockDriverState *bs)return bs->read_only; } -int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp) +int bdrv_can_set_read_only (BlockDriverState *bs,bool read_only,Error **errp) {/* Do not set read_only if copy_on_read is enabled */ if (bs->copy_on_read && read_only) {
@@ -213,6 +213,18 @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)return -EPERM ; } +return 0 ; +} + +int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp) +{ +int ret =0 ; + + ret =bdrv_can_set_read_only (bs, read_only, errp); +if (ret <0 ) { +return ret; + } + bs->read_only = read_only;return 0 ; }
include/block/block.h +1 -0
@@ -426,6 +426,7 @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base, int64_t sector_num, int nb_sectors, int *pnum);bool bdrv_is_read_only (BlockDriverState *bs); +int bdrv_can_set_read_only (BlockDriverState *bs,bool read_only,Error **errp);int bdrv_set_read_only (BlockDriverState *bs,bool read_only,Error **errp);bool bdrv_is_sg (BlockDriverState *bs);bool bdrv_is_inserted (BlockDriverState *bs);
Signature · 1 line
2.9.3
PATCH v2 6/8 block: use bdrv_can_set_read_only() during reopen
In reply to Jeff Cody--- block.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)
block.c +8 -6
@@ -2785,6 +2785,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,BlockDriver *drv;QemuOpts *opts;const char *value; +bool read_only;assert (reopen_state !=NULL );assert (reopen_state->bs->drv !=NULL );
@@ -2813,12 +2814,13 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,qdict_put (reopen_state->options,"driver" ,qstring_from_str (value)); } -/* if we are to stay read-only, do not allow permission change -* to r/w */ -if (!(reopen_state->bs->open_flags &BDRV_O_ALLOW_RDWR ) && - reopen_state->flags &BDRV_O_RDWR ) { -error_setg (errp,"Node '%s' is read only" , -bdrv_get_device_or_node_name (reopen_state->bs)); +/* If we are to stay read-only, do not allow permission change +* to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is +* not set, or if the BDS still has copy_on_read enabled */ + read_only = !(reopen_state->flags &BDRV_O_RDWR ); + ret =bdrv_can_set_read_only (reopen_state->bs, read_only, &local_err); +if (local_err) { +error_propagate (errp, local_err); goto error; }
Signature · 1 line
2.9.3
PATCH v2 7/8 block/rbd - update variable names to more apt names
In reply to Jeff CodyUpdate 'clientname' to be 'user', which tracks better with both the QAPI and rados variable naming.
Update 'name' to be 'image_name', as it indicates the rbd image. Naming it 'image' would have been ideal, but we are using that for the rados_image_t value returned by rbd_open().
--- block/rbd.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-)
block/rbd.c +17 -16
@@ -94,7 +94,7 @@ typedef struct BDRVRBDState {rados_t cluster;rados_ioctx_t io_ctx;rbd_image_t image; -char *name; +char *image_name;char *snap; } BDRVRBDState;
@@ -350,7 +350,7 @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)int64_t bytes =0 ;int64_t objsize;int obj_order =0 ; -const char *pool, *name, *conf, *clientname, *keypairs; +const char *pool, *image_name, *conf, *user, *keypairs;const char *secretid;rados_t cluster;rados_ioctx_t io_ctx;
@@ -393,11 +393,11 @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)*/ pool =qdict_get_try_str (options,"pool" ); conf =qdict_get_try_str (options,"conf" ); - clientname =qdict_get_try_str (options,"user" ); - name =qdict_get_try_str (options,"image" ); + user =qdict_get_try_str (options,"user" ); + image_name =qdict_get_try_str (options,"image" ); keypairs =qdict_get_try_str (options,"=keyvalue-pairs" ); - ret =rados_create (&cluster, clientname); + ret =rados_create (&cluster, user);if (ret <0 ) {error_setg_errno (errp, -ret,"error initializing" ); goto exit;
@@ -434,7 +434,7 @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp) goto shutdown; } - ret =rbd_create (io_ctx, name, bytes, &obj_order); + ret =rbd_create (io_ctx, image_name, bytes, &obj_order);if (ret <0 ) {error_setg_errno (errp, -ret,"error rbd create" ); }
@@ -540,7 +540,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, Error **errp) {BDRVRBDState *s = bs->opaque; -const char *pool, *snap, *conf, *clientname, *name, *keypairs; +const char *pool, *snap, *conf, *user, *image_name, *keypairs;const char *secretid;QemuOpts *opts;Error *local_err =NULL ;
@@ -567,24 +567,24 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, pool =qemu_opt_get (opts,"pool" ); conf =qemu_opt_get (opts,"conf" ); snap =qemu_opt_get (opts,"snapshot" ); - clientname =qemu_opt_get (opts,"user" ); - name =qemu_opt_get (opts,"image" ); + user =qemu_opt_get (opts,"user" ); + image_name =qemu_opt_get (opts,"image" ); keypairs =qemu_opt_get (opts,"=keyvalue-pairs" ); -if (!pool || !name) { +if (!pool || !image_name) {error_setg (errp,"Parameters 'pool' and 'image' are required" ); r = -EINVAL ; goto failed_opts; } - r =rados_create (&s->cluster, clientname); + r =rados_create (&s->cluster, user);if (r <0 ) {error_setg_errno (errp, -r,"error initializing" ); goto failed_opts; } s->snap =g_strdup (snap); - s->name =g_strdup (name); + s->image_name =g_strdup (image_name);/* try default location when conf=NULL, but ignore failure */ r =rados_conf_read_file (s->cluster, conf);
@@ -636,9 +636,10 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, }/* rbd_open is always r/w */ - r =rbd_open (s->io_ctx, s->name, &s->image, s->snap); + r =rbd_open (s->io_ctx, s->image_name, &s->image, s->snap);if (r <0 ) { -error_setg_errno (errp, -r,"error reading header from %s" , s->name); +error_setg_errno (errp, -r,"error reading header from %s" , + s->image_name); goto failed_open; }
@@ -660,7 +661,7 @@ failed_open: failed_shutdown:rados_shutdown (s->cluster);g_free (s->snap); -g_free (s->name); +g_free (s->image_name); failed_opts:qemu_opts_del (opts);g_free (mon_host);
@@ -674,7 +675,7 @@ static void qemu_rbd_close(BlockDriverState *bs)rbd_close (s->image);rados_ioctx_destroy (s->io_ctx);g_free (s->snap); -g_free (s->name); +g_free (s->image_name);rados_shutdown (s->cluster); }
Signature · 1 line
2.9.3
PATCH v2 8/8 block/rbd: Add support for reopen()
In reply to Jeff CodyThis adds support for reopen in rbd, for changing between r/w and r/o.
Note, that this is only a flag change, but we will block a change from r/o to r/w if we are using an RBD internal snapshot.
--- block/rbd.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
block/rbd.c +21 -0
@@ -668,6 +668,26 @@ failed_opts:return r; } + +/* Since RBD is currently always opened R/W via the API, +* we just need to check if we are using a snapshot or not, in +* order to determine if we will allow it to be R/W */ +static int qemu_rbd_reopen_prepare (BDRVReopenState *state, +BlockReopenQueue *queue,Error **errp) +{ +BDRVRBDState *s = state->bs->opaque; +int ret =0 ; + +if (s->snap && state->flags &BDRV_O_RDWR ) { +error_setg (errp, +"Cannot change node '%s' to r/w when using RBD snapshot" , +bdrv_get_device_or_node_name (state->bs)); + ret = -EINVAL ; + } + +return ret; +} +static void qemu_rbd_close (BlockDriverState *bs) {BDRVRBDState *s = bs->opaque;
@@ -1074,6 +1094,7 @@ static BlockDriver bdrv_rbd = { .bdrv_parse_filename = qemu_rbd_parse_filename, .bdrv_file_open = qemu_rbd_open, .bdrv_close = qemu_rbd_close, + .bdrv_reopen_prepare = qemu_rbd_reopen_prepare, .bdrv_create = qemu_rbd_create, .bdrv_has_zero_init = bdrv_has_zero_init_1, .bdrv_get_info = qemu_rbd_getinfo,
Signature · 1 line
2.9.3
Quoted 34 lines · Jeff Cody
Changes from v1:
Patch 2: Has v1 patch 8 (do not blindly xset
bs->read_only) squashed into it
(thanks Stefan)
COW -> "copy-on-read" (Thanks John)
Drop unneeded call in vvfat, and bypassenable_write_target(Stefan)Patch 5: Rename
bdrv_try_... tobdrv_can_set_read_only()(Thanks John, Stefan)Patch 6: Use "
reopen_state->flags" not "reopen_state->bs->open_flags"
(Thanks John)This series does two things:
1.) Cleans up some of the logic behind setting the
read_onlyflag
for a BDS in the block layer, so that it is done consistently (and rules are applied consistently), and2.) Adds .bdrv_reopen_prepare() implementation for RBD, so that block
jobs can be run on backing chains that have rbd protocol nodes.Jeff Cody (8):
block: addbdrv_set_read_only()helper function
block: do not set BDSread_onlyifcopy_on_readenabled
block: honorBDRV_O_ALLOW_RDWRwhen clearingbs->read_only
block: code movement
block: introducebdrv_can_set_read_only()
block: usebdrv_can_set_read_only()during reopen block/rbd - update variable names to more apt names block/rbd: Add support forreopen()
Quoted 12 lines
block.c | 56 +++++++++++++++++++++++++++++++++++--------- block/bochs.c | 5 +++- block/cloop.c | 5 +++- block/dmg.c | 6 ++++- block/rbd.c | 65 +++++++++++++++++++++++++++++++++++++-------------- block/vvfat.c | 19 +++++++++++---- include/block/block.h | 2 ++ 7 files changed, 123 insertions(+), 35 deletions(-)Signature · 1 line
2.9.3
Quoted 33 lines · Jeff Cody
Changes from v1:
Patch 2: Has v1 patch 8 (do not blindly xset
bs->read_only) squashed into it
(thanks Stefan)
COW -> "copy-on-read" (Thanks John)
Drop unneeded call in vvfat, and bypassenable_write_target(Stefan)Patch 5: Rename
bdrv_try_... tobdrv_can_set_read_only()(Thanks John, Stefan)Patch 6: Use "
reopen_state->flags" not "reopen_state->bs->open_flags"
(Thanks John)This series does two things:
1.) Cleans up some of the logic behind setting the
read_onlyflag
for a BDS in the block layer, so that it is done consistently (and rules are applied consistently), and2.) Adds .bdrv_reopen_prepare() implementation for RBD, so that block
jobs can be run on backing chains that have rbd protocol nodes.Jeff Cody (8):
block: addbdrv_set_read_only()helper function
block: do not set BDSread_onlyifcopy_on_readenabled
block: honorBDRV_O_ALLOW_RDWRwhen clearingbs->read_only
block: code movement
block: introducebdrv_can_set_read_only()
block: usebdrv_can_set_read_only()during reopen block/rbd - update variable names to more apt names block/rbd: Add support forreopen()
Quoted 9 lines
block.c | 56 +++++++++++++++++++++++++++++++++++--------- block/bochs.c | 5 +++- block/cloop.c | 5 +++- block/dmg.c | 6 ++++- block/rbd.c | 65 +++++++++++++++++++++++++++++++++++++-------------- block/vvfat.c | 19 +++++++++++---- include/block/block.h | 2 ++ 7 files changed, 123 insertions(+), 35 deletions(-)
Jeff Cody
AppliedQuoted 34 lines · Jeff Cody
Changes from v1:
Patch 2: Has v1 patch 8 (do not blindly xset
bs->read_only) squashed into it
(thanks Stefan)
COW -> "copy-on-read" (Thanks John)
Drop unneeded call in vvfat, and bypassenable_write_target(Stefan)Patch 5: Rename
bdrv_try_... tobdrv_can_set_read_only()(Thanks John, Stefan)Patch 6: Use "
reopen_state->flags" not "reopen_state->bs->open_flags"
(Thanks John)This series does two things:
1.) Cleans up some of the logic behind setting the
read_onlyflag
for a BDS in the block layer, so that it is done consistently (and rules are applied consistently), and2.) Adds .bdrv_reopen_prepare() implementation for RBD, so that block
jobs can be run on backing chains that have rbd protocol nodes.Jeff Cody (8):
block: addbdrv_set_read_only()helper function
block: do not set BDSread_onlyifcopy_on_readenabled
block: honorBDRV_O_ALLOW_RDWRwhen clearingbs->read_only
block: code movement
block: introducebdrv_can_set_read_only()
block: usebdrv_can_set_read_only()during reopen block/rbd - update variable names to more apt names block/rbd: Add support forreopen()
Quoted 12 lines
block.c | 56 +++++++++++++++++++++++++++++++++++--------- block/bochs.c | 5 +++- block/cloop.c | 5 +++- block/dmg.c | 6 ++++- block/rbd.c | 65 +++++++++++++++++++++++++++++++++++++-------------- block/vvfat.c | 19 +++++++++++---- include/block/block.h | 2 ++ 7 files changed, 123 insertions(+), 35 deletions(-)Signature · 1 line
2.9.3
Thanks,
Applied to my block branch:
git://github.com/codyprime/qemu-kvm-jtc block
-Jeff