From f64042620963059859d0bbae60e8655ccc44736e Mon Sep 17 00:00:00 2001

From: Kevin Wolf <kwolf@redhat.com>

Date: Fri, 15 Mar 2019 18:10:01 +0100

Subject: [PATCH 005/163] block: Make permission changes in reopen less wrong

RH-Author: Kevin Wolf <kwolf@redhat.com>

Message-id: <20190315181010.14964-6-kwolf@redhat.com>

Patchwork-id: 84882

O-Subject: [RHEL-7.7 qemu-kvm-rhev PATCH 05/14] block: Make permission changes in reopen less wrong

Bugzilla: 1685989

RH-Acked-by: John Snow <jsnow@redhat.com>

RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>

RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>

The way that reopen interacts with permission changes has one big

problem: Both operations are recursive, and the permissions are changes

for each node in the reopen queue.

For a simple graph that consists just of parent and child,

.bdrv_check_perm will be called twice for the child, once recursively

when adjusting the permissions of parent, and once again when the child

itself is reopened.

Even worse, the first .bdrv_check_perm call happens before

.bdrv_reopen_prepare was called for the child and the second one is

called afterwards.

Making sure that .bdrv_check_perm (and the other permission callbacks)

are called only once is hard. We can cope with multiple calls right now,

but as soon as file-posix gets a dynamic auto-read-only that may need to

open a new file descriptor, we get the additional requirement that all

of them are after the .bdrv_reopen_prepare call.

So reorder things in bdrv_reopen_multiple() to first call

.bdrv_reopen_prepare for all involved nodes and only then adjust

permissions.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

(cherry picked from commit 69b736e76567ecbc9b9e55570bc0afc840614a98)

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 block.c | 35 ++++++++++++++++++++++++-----------

 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/block.c b/block.c

index 2f1b4d1..b31124c 100644

--- a/block.c

+++ b/block.c

@@ -1661,6 +1661,7 @@ static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);

 typedef struct BlockReopenQueueEntry {

      bool prepared;

+     bool perms_checked;

      BDRVReopenState state;

      QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry;

 } BlockReopenQueueEntry;

@@ -3072,6 +3073,16 @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er

         bs_entry->prepared = true;

     }

+    QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {

+        BDRVReopenState *state = &bs_entry->state;

+        ret = bdrv_check_perm(state->bs, bs_queue, state->perm,

+                              state->shared_perm, NULL, errp);

+        if (ret < 0) {

+            goto cleanup_perm;

+        }

+        bs_entry->perms_checked = true;

+    }

+

     /* If we reach this point, we have success and just need to apply the

      * changes

      */

@@ -3080,7 +3091,20 @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er

     }

     ret = 0;

+cleanup_perm:

+    QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {

+        BDRVReopenState *state = &bs_entry->state;

+

+        if (!bs_entry->perms_checked) {

+            continue;

+        }

+        if (ret == 0) {

+            bdrv_set_perm(state->bs, state->perm, state->shared_perm);

+        } else {

+            bdrv_abort_perm_update(state->bs);

+        }

+    }

 cleanup:

     QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) {

         if (ret) {

@@ -3297,12 +3321,6 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,

         } while ((entry = qdict_next(reopen_state->options, entry)));

     }

-    ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm,

-                          reopen_state->shared_perm, NULL, errp);

-    if (ret < 0) {

-        goto error;

-    }

-

     ret = 0;

 error:

@@ -3352,9 +3370,6 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)

     bdrv_refresh_limits(bs, NULL);

-    bdrv_set_perm(reopen_state->bs, reopen_state->perm,

-                  reopen_state->shared_perm);

-

     new_can_write =

         !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE);

     if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) {

@@ -3386,8 +3401,6 @@ void bdrv_reopen_abort(BDRVReopenState *reopen_state)

     if (drv->bdrv_reopen_abort) {

         drv->bdrv_reopen_abort(reopen_state);

     }

-

-    bdrv_abort_perm_update(reopen_state->bs);

 }

-- 

1.8.3.1