bdrv_set_aio_context can take care of children recursively, so it is
okay to pass down the perm.

Signed-off-by: Fam Zheng <famz@redhat.com>
---
 block.c       | 18 ++++++++++--------
 block/vvfat.c |  2 +-
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/block.c b/block.c
index ae9327b..0190087 100644
--- a/block.c
+++ b/block.c
@@ -1670,7 +1670,8 @@ int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared,
 #define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \
                                  | BLK_PERM_WRITE \
                                  | BLK_PERM_WRITE_UNCHANGED \
-                                 | BLK_PERM_RESIZE)
+                                 | BLK_PERM_RESIZE \
+                                 | BLK_PERM_AIO_CONTEXT_CHANGE)
 #define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH)
 
 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
@@ -1713,21 +1714,22 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
         perm |= BLK_PERM_CONSISTENT_READ;
         shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
     } else {
-        /* We want consistent read from backing files if the parent needs it.
+        /* We want consistent read and aio context change from backing files if
+         * the parent needs it.
          * No other operations are performed on backing files. */
-        perm &= BLK_PERM_CONSISTENT_READ;
+        perm &= BLK_PERM_CONSISTENT_READ | BLK_PERM_AIO_CONTEXT_CHANGE;
 
-        /* If the parent can deal with changing data, we're okay with a
+        /* If the parent can deal with changing aio context, we're okay too;
+         * If the parent can deal with changing data, we're okay with a
          * writable and resizable backing file. */
         /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
+        shared &= BLK_PERM_AIO_CONTEXT_CHANGE | BLK_PERM_WRITE;
         if (shared & BLK_PERM_WRITE) {
-            shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
-        } else {
-            shared = 0;
+            shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
         }
 
         shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
-                  BLK_PERM_WRITE_UNCHANGED;
+                  BLK_PERM_WRITE_UNCHANGED | BLK_PERM_AIO_CONTEXT_CHANGE;
     }
 
     *nperm = perm;
diff --git a/block/vvfat.c b/block/vvfat.c
index af5153d..70ce452 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -3080,7 +3080,7 @@ static void vvfat_child_perm(BlockDriverState *bs, BdrvChild *c,
     if (c == s->qcow) {
         /* This is a private node, nobody should try to attach to it */
         *nperm = BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE;
-        *nshared = BLK_PERM_WRITE_UNCHANGED;
+        *nshared = BLK_PERM_WRITE_UNCHANGED | BLK_PERM_AIO_CONTEXT_CHANGE;
     } else {
         /* The backing file is there so 'commit' can use it. vvfat doesn't
          * access it in any way. */
-- 
2.9.3

On Tue, Mar 21, 2017 at 11:16:23AM +0800, Fam Zheng wrote:
> @@ -1713,21 +1714,22 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
>          perm |= BLK_PERM_CONSISTENT_READ;
>          shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
>      } else {
> -        /* We want consistent read from backing files if the parent needs it.
> +        /* We want consistent read and aio context change from backing files if
> +         * the parent needs it.
>           * No other operations are performed on backing files. */
> -        perm &= BLK_PERM_CONSISTENT_READ;
> +        perm &= BLK_PERM_CONSISTENT_READ | BLK_PERM_AIO_CONTEXT_CHANGE;
>  
> -        /* If the parent can deal with changing data, we're okay with a
> +        /* If the parent can deal with changing aio context, we're okay too;
> +         * If the parent can deal with changing data, we're okay with a
>           * writable and resizable backing file. */
>          /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
> +        shared &= BLK_PERM_AIO_CONTEXT_CHANGE | BLK_PERM_WRITE;
>          if (shared & BLK_PERM_WRITE) {
> -            shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
> -        } else {
> -            shared = 0;
> +            shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;

We already have BLK_PERM_WRITE so we're just adding BLK_PERM_RESIZE.
The following is clearer:

  shared |= BLK_PERM_RESIZE;

>          }
>  
>          shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
> -                  BLK_PERM_WRITE_UNCHANGED;
> +                  BLK_PERM_WRITE_UNCHANGED | BLK_PERM_AIO_CONTEXT_CHANGE;

Why was shared &= BLK_PERM_AIO_CONTEXT_CHANGE necessary above if we
unconditionally OR it here?

On Mon, 04/10 09:57, Stefan Hajnoczi wrote:
> On Tue, Mar 21, 2017 at 11:16:23AM +0800, Fam Zheng wrote:
> > @@ -1713,21 +1714,22 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
> >          perm |= BLK_PERM_CONSISTENT_READ;
> >          shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
> >      } else {
> > -        /* We want consistent read from backing files if the parent needs it.
> > +        /* We want consistent read and aio context change from backing files if
> > +         * the parent needs it.
> >           * No other operations are performed on backing files. */
> > -        perm &= BLK_PERM_CONSISTENT_READ;
> > +        perm &= BLK_PERM_CONSISTENT_READ | BLK_PERM_AIO_CONTEXT_CHANGE;
> >  
> > -        /* If the parent can deal with changing data, we're okay with a
> > +        /* If the parent can deal with changing aio context, we're okay too;
> > +         * If the parent can deal with changing data, we're okay with a
> >           * writable and resizable backing file. */
> >          /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */
> > +        shared &= BLK_PERM_AIO_CONTEXT_CHANGE | BLK_PERM_WRITE;
> >          if (shared & BLK_PERM_WRITE) {
> > -            shared = BLK_PERM_WRITE | BLK_PERM_RESIZE;
> > -        } else {
> > -            shared = 0;
> > +            shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;
> 
> We already have BLK_PERM_WRITE so we're just adding BLK_PERM_RESIZE.
> The following is clearer:
> 
>   shared |= BLK_PERM_RESIZE;
> 
> >          }
> >  
> >          shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD |
> > -                  BLK_PERM_WRITE_UNCHANGED;
> > +                  BLK_PERM_WRITE_UNCHANGED | BLK_PERM_AIO_CONTEXT_CHANGE;
> 
> Why was shared &= BLK_PERM_AIO_CONTEXT_CHANGE necessary above if we
> unconditionally OR it here?

It's redundant. Will fix both.

Fam