david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

block: Clean up reopen_backing_file() in block/replication.c

Browse Source 
This function is used to put the hidden and secondary disks in
read-write mode before launching the backup job, and back in read-only
mode afterwards.

This patch does the following changes:

  - Use an options QDict with the "read-only" option instead of
    passing the changes as flags only.

  - Simplify the code (it was unnecessarily complicated and verbose).

  - Fix a bug due to which the secondary disk was not being put back
    in read-only mode when writable=false (because in this case
    orig_secondary_flags always had the BDRV_O_RDWR flag set).

  - Stop clearing the BDRV_O_INACTIVE flag.

The flags parameter to bdrv_reopen_queue() becomes redundant and we'll
be able to get rid of it in a subsequent patch.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Alberto Garcia 2018-11-12 16:00:43 +02:00 committed by Kevin Wolf
parent dc900c3523
commit 3c4e964762
1 changed files with 21 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
block/replication.c
View File

@ -20,6 +20,7 @@
#include "block/block_backup.h" #include "block/block_backup.h"
#include "sysemu/block-backend.h" #include "sysemu/block-backend.h"
#include "qapi/error.h" #include "qapi/error.h"
#include "qapi/qmp/qdict.h"
#include "replication.h" #include "replication.h"
typedef enum { typedef enum {
@ -39,8 +40,8 @@ typedef struct BDRVReplicationState {
char *top_id; char *top_id;
ReplicationState *rs; ReplicationState *rs;
Error *blocker; Error *blocker;
int orig_hidden_flags; bool orig_hidden_read_only;
int orig_secondary_flags; bool orig_secondary_read_only;
int error; int error;
} BDRVReplicationState; } BDRVReplicationState;
@ -349,44 +350,40 @@ static void secondary_do_checkpoint(BDRVReplicationState *s, Error **errp)
} }
} }
/* This function is supposed to be called twice:
* first with writable = true, then with writable = false.
* The first call puts s->hidden_disk and s->secondary_disk in
* r/w mode, and the second puts them back in their original state.
*/
static void reopen_backing_file(BlockDriverState *bs, bool writable, static void reopen_backing_file(BlockDriverState *bs, bool writable,
Error **errp) Error **errp)
{ {
BDRVReplicationState *s = bs->opaque; BDRVReplicationState *s = bs->opaque;
BlockReopenQueue *reopen_queue = NULL; BlockReopenQueue *reopen_queue = NULL;
int orig_hidden_flags, orig_secondary_flags;
int new_hidden_flags, new_secondary_flags;
Error *local_err = NULL; Error *local_err = NULL;
if (writable) { if (writable) {
orig_hidden_flags = s->orig_hidden_flags = s->orig_hidden_read_only = bdrv_is_read_only(s->hidden_disk->bs);
bdrv_get_flags(s->hidden_disk->bs); s->orig_secondary_read_only = bdrv_is_read_only(s->secondary_disk->bs);
new_hidden_flags = (orig_hidden_flags | BDRV_O_RDWR) &
~BDRV_O_INACTIVE;
orig_secondary_flags = s->orig_secondary_flags =
bdrv_get_flags(s->secondary_disk->bs);
new_secondary_flags = (orig_secondary_flags | BDRV_O_RDWR) &
~BDRV_O_INACTIVE;
} else {
orig_hidden_flags = (s->orig_hidden_flags | BDRV_O_RDWR) &
~BDRV_O_INACTIVE;
new_hidden_flags = s->orig_hidden_flags;
orig_secondary_flags = (s->orig_secondary_flags | BDRV_O_RDWR) &
~BDRV_O_INACTIVE;
new_secondary_flags = s->orig_secondary_flags;
} }
bdrv_subtree_drained_begin(s->hidden_disk->bs); bdrv_subtree_drained_begin(s->hidden_disk->bs);
bdrv_subtree_drained_begin(s->secondary_disk->bs); bdrv_subtree_drained_begin(s->secondary_disk->bs);
if (orig_hidden_flags != new_hidden_flags) { if (s->orig_hidden_read_only) {
reopen_queue = bdrv_reopen_queue(reopen_queue, s->hidden_disk->bs, NULL, int flags = bdrv_get_flags(s->hidden_disk->bs);
new_hidden_flags); QDict *opts = qdict_new();
qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable);
reopen_queue = bdrv_reopen_queue(reopen_queue, s->hidden_disk->bs,
opts, flags);
} }
if (!(orig_secondary_flags & BDRV_O_RDWR)) { if (s->orig_secondary_read_only) {
int flags = bdrv_get_flags(s->secondary_disk->bs);
QDict *opts = qdict_new();
qdict_put_bool(opts, BDRV_OPT_READ_ONLY, !writable);
reopen_queue = bdrv_reopen_queue(reopen_queue, s->secondary_disk->bs, reopen_queue = bdrv_reopen_queue(reopen_queue, s->secondary_disk->bs,
NULL, new_secondary_flags); opts, flags);
} }
if (reopen_queue) { if (reopen_queue) {