block: fix preallocate filter: don't do unaligned preallocate requests

Commit Message

Vladimir Sementsov-Ogievskiy Feb. 15, 2022, 12:16 p.m. UTC

There is a bug in handling BDRV_REQ_NO_WAIT flag: we still may wait in
wait_serialising_requests() if request is unaligned. And this is
possible for the only user of this flag (preallocate filter) if
underlying file is unaligned to its request_alignment on start.

So, we have to fix preallocate filter to do only aligned preallocate
requests.

Next, we should fix generic block/io.c somehow. Keeping in mind that
preallocate is the only user of BDRV_REQ_NO_WAIT and that we have to
fix its behavior now, it seems more safe to just assert that we never
use BDRV_REQ_NO_WAIT with unaligned requests and add corresponding
comment. Let's do so.

Signed-off-by: Vladimir Sementsov-Ogievskiy <[e-mail]>
Reviewed-by: Denis V. Lunev <[e-mail]>
---
 include/block/block.h |  3 ++-
 block/io.c            |  4 ++++
 block/preallocate.c   | 15 ++++++++++++---
 3 files changed, 18 insertions(+), 4 deletions(-)

Comments

Hanna Czenczek Feb. 24, 2022, 3:06 p.m. UTC | #1

On 15.02.22 13:16, Vladimir Sementsov-Ogievskiy wrote:
> There is a bug in handling BDRV_REQ_NO_WAIT flag: we still may wait in
> wait_serialising_requests() if request is unaligned. And this is
> possible for the only user of this flag (preallocate filter) if
> underlying file is unaligned to its request_alignment on start.
>
> So, we have to fix preallocate filter to do only aligned preallocate
> requests.
>
> Next, we should fix generic block/io.c somehow. Keeping in mind that
> preallocate is the only user of BDRV_REQ_NO_WAIT and that we have to
> fix its behavior now, it seems more safe to just assert that we never
> use BDRV_REQ_NO_WAIT with unaligned requests and add corresponding
> comment. Let's do so.
>
> Signed-off-by: Vladimir Sementsov-Ogievskiy <[e-mail]>
> Reviewed-by: Denis V. Lunev <[e-mail]>
> ---
>   include/block/block.h |  3 ++-
>   block/io.c            |  4 ++++
>   block/preallocate.c   | 15 ++++++++++++---
>   3 files changed, 18 insertions(+), 4 deletions(-)

Thanks, applied to my block branch:

https://gitlab.com/hreitz/qemu/-/commits/block

Patch

diff --git a/include/block/block.h b/include/block/block.h
index e1713ee306..f73203af4a 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -83,7 +83,8 @@  typedef enum {
 
     /*
      * If we need to wait for other requests, just fail immediately. Used
-     * only together with BDRV_REQ_SERIALISING.
+     * only together with BDRV_REQ_SERIALISING. Used only with requests aligned
+     * to request_alignment (corresponding assertions are in block/io.c).
      */
     BDRV_REQ_NO_WAIT = 0x400,
 
diff --git a/block/io.c b/block/io.c
index 4e4cb556c5..eb562a1cb8 100644
--- a/block/io.c
+++ b/block/io.c
@@ -2173,6 +2173,7 @@  static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
 
     padding = bdrv_init_padding(bs, offset, bytes, &pad);
     if (padding) {
+        assert(!(flags & BDRV_REQ_NO_WAIT));
         bdrv_make_request_serialising(req, align);
 
         bdrv_padding_rmw_read(child, req, &pad, true);
@@ -2307,6 +2308,7 @@  int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
          * serialize the request to prevent interactions of the
          * widened region with other transactions.
          */
+        assert(!(flags & BDRV_REQ_NO_WAIT));
         bdrv_make_request_serialising(&req, align);
         bdrv_padding_rmw_read(child, &req, &pad, false);
     }
@@ -3328,6 +3330,8 @@  static int coroutine_fn bdrv_co_copy_range_internal(
     /* TODO We can support BDRV_REQ_NO_FALLBACK here */
     assert(!(read_flags & BDRV_REQ_NO_FALLBACK));
     assert(!(write_flags & BDRV_REQ_NO_FALLBACK));
+    assert(!(read_flags & BDRV_REQ_NO_WAIT));
+    assert(!(write_flags & BDRV_REQ_NO_WAIT));
 
     if (!dst || !dst->bs || !bdrv_is_inserted(dst->bs)) {
         return -ENOMEDIUM;
diff --git a/block/preallocate.c b/block/preallocate.c
index 1d4233f730..e15cb8c74a 100644
--- a/block/preallocate.c
+++ b/block/preallocate.c
@@ -276,6 +276,10 @@  static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
     int64_t end = offset + bytes;
     int64_t prealloc_start, prealloc_end;
     int ret;
+    uint32_t file_align = bs->file->bs->bl.request_alignment;
+    uint32_t prealloc_align = MAX(s->opts.prealloc_align, file_align);
+
+    assert(QEMU_IS_ALIGNED(prealloc_align, file_align));
 
     if (!has_prealloc_perms(bs)) {
         /* We don't have state neither should try to recover it */
@@ -320,9 +324,14 @@  static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
 
     /* Now we want new preallocation, as request writes beyond s->file_end. */
 
-    prealloc_start = want_merge_zero ? MIN(offset, s->file_end) : s->file_end;
-    prealloc_end = QEMU_ALIGN_UP(end + s->opts.prealloc_size,
-                                 s->opts.prealloc_align);
+    prealloc_start = QEMU_ALIGN_UP(
+            want_merge_zero ? MIN(offset, s->file_end) : s->file_end,
+            file_align);
+    prealloc_end = QEMU_ALIGN_UP(
+            MAX(prealloc_start, end) + s->opts.prealloc_size,
+            prealloc_align);
+
+    want_merge_zero = want_merge_zero && (prealloc_start <= offset);
 
     ret = bdrv_co_pwrite_zeroes(
             bs->file, prealloc_start, prealloc_end - prealloc_start,