Series comparison

-[Qemu-devel] [PULL 0/4] Block patches
+[PULL for-6.1 0/3] Block patches
-The following changes since commit 20d6c7312f1b812bb9c750f4087f69ac8485cc90:
+The following changes since commit 3521ade3510eb5cefb2e27a101667f25dad89935:
-  Merge remote-tracking branch 'remotes/palmer/tags/riscv-for-master-3.2-part1' into staging (2019-01-03 13:26:30 +0000)
+  Merge remote-tracking branch 'remotes/thuth-gitlab/tags/pull-request-2021-07-29' into staging (2021-07-29 13:17:20 +0100)
 are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 39a0408e768cd00142f5b57d27ab234282bf4df5:
+for you to fetch changes up to cc8eecd7f105a1dff5876adeb238a14696061a4a:
-  dmg: don't skip zero chunk (2019-01-04 11:15:09 +0000)
+  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver (2021-07-29 17:17:34 +0100)
 ----------------------------------------------------------------
 Pull request
-Bug fixes for the .dmg image file format.
+The main fix here is for io_uring. Spurious -EAGAIN errors can happen and the
 request needs to be resubmitted.
 The MAINTAINERS changes carry no risk and we might as well include them in QEMU
 .1.
 ----------------------------------------------------------------
-Julio Faracco (1):
+Fabian Ebner (1):
-  dmg: Fixing wrong dmg block type value for block terminator.
+  block/io_uring: resubmit when result is -EAGAIN
-yuchenlin (3):
+Philippe Mathieu-Daudé (1):
-  dmg: fix binary search
+  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver
   dmg: use enumeration type instead of hard coding number
   dmg: don't skip zero chunk
- block/dmg.c | 31 ++++++++++++++++++++-----------
+Stefano Garzarella (1):
-file changed, 20 insertions(+), 11 deletions(-)
+  MAINTAINERS: add Stefano Garzarella as io_uring reviewer
  MAINTAINERS      |  2 ++
  block/io_uring.c | 16 +++++++++++++++-
 files changed, 17 insertions(+), 1 deletion(-)
 --
-.20.1
+.31.1

-[Qemu-devel] [PULL 1/4] dmg: Fixing wrong dmg block type value for block terminator.
+Deleted patch
-From: Julio Faracco <jcfaracco@gmail.com>
-This is a trivial patch to fix a wrong value for block terminator.
-The old value was 0x7fffffff which is wrong. It was not affecting the
-code because QEMU dmg block is not handling block terminator right now.
-Neverthless, it should be fixed.
-Signed-off-by: Julio Faracco <jcfaracco@gmail.com>
-Reviewed-by: yuchenlin <yuchenlin@synology.com>
-Message-id: 20181228145055.18039-1-jcfaracco@gmail.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- block/dmg.c | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/block/dmg.c b/block/dmg.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
-+++ b/block/dmg.c
-@@ -XXX,XX +XXX,XX @@ enum {
-     UDBZ,
-     ULFO,
-     UDCM = 0x7ffffffe, /* Comments */
--    UDLE               /* Last Entry */
-+    UDLE = 0xffffffff  /* Last Entry */
- };
- static int dmg_probe(const uint8_t *buf, int buf_size, const char *filename)
---
-.20.1

-[Qemu-devel] [PULL 4/4] dmg: don't skip zero chunk
+[PULL for-6.1 1/3] MAINTAINERS: add Stefano Garzarella as io_uring reviewer
-From: yuchenlin <npes87184@gmail.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-The dmg file has many tables which describe: "start from sector XXX to
+I've been working with io_uring for a while so I'd like to help
-sector XXX, the compression method is XXX and where the compressed data
+with reviews.
 resides on".
-Each sector in the expanded file should be covered by a table. The table
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-will describe the offset of compressed data (or raw depends on the type)
+Message-Id: <20210728131515.131045-1-sgarzare@redhat.com>
 in the dmg.
 For example:
 [-----------The expanded file------------]
 [---bzip table ---]/* zeros */[---zlib---]
     ^
     | if we want to read this sector.
 we will find bzip table which contains this sector, and get the
 compressed data offset, read it from dmg, uncompress it, finally write to
 expanded file.
 If we skip zero chunk (table), some sector cannot find the table which
 will cause search_chunk() return s->n_chunks, dmg_read_chunk() return -1
 and finally causing dmg_co_preadv() return EIO.
 See:
 [-----------The expanded file------------]
 [---bzip table ---]/* zeros */[---zlib---]
                     ^
                     | if we want to read this sector.
 Oops, we cannot find the table contains it...
 In the original implementation, we don't have zero table. When we try to
 read sector inside the zero chunk. We will get EIO, and skip reading.
 After this patch, we treat zero chunk the same as ignore chunk, it will
 directly write zero and avoid some sector may not find the table.
 After this patch:
 [-----------The expanded file------------]
 [---bzip table ---][--zeros--][---zlib---]
 Signed-off-by: yuchenlin <npes87184@gmail.com>
 Reviewed-by: Julio Faracco <jcfaracco@gmail.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190103114700.9686-4-npes87184@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/dmg.c | 19 ++++++++++++-------
+ MAINTAINERS | 1 +
-file changed, 12 insertions(+), 7 deletions(-)
+file changed, 1 insertion(+)
-diff --git a/block/dmg.c b/block/dmg.c
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
+--- a/MAINTAINERS
-+++ b/block/dmg.c
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ static void update_max_chunk_size(BDRVDMGState *s, uint32_t chunk,
+@@ -XXX,XX +XXX,XX @@ Linux io_uring
-     case UDRW: /* copy */
+ M: Aarushi Mehta <mehta.aaru20@gmail.com>
-         uncompressed_sectors = DIV_ROUND_UP(s->lengths[chunk], 512);
+ M: Julia Suvorova <jusual@redhat.com>
-         break;
+ M: Stefan Hajnoczi <stefanha@redhat.com>
--    case UDIG: /* zero */
++R: Stefano Garzarella <sgarzare@redhat.com>
-+    case UDZE: /* zero */
+ L: qemu-block@nongnu.org
-+    case UDIG: /* ignore */
+ S: Maintained
-         /* as the all-zeroes block may be large, it is treated specially: the
+ F: block/io_uring.c
           * sector is not copied from a large buffer, a simple memset is used
           * instead. Therefore uncompressed_sectors does not need to be set. */
@@ -XXX,XX +XXX,XX @@ typedef struct DmgHeaderState {
  static bool dmg_is_known_block_type(uint32_t entry_type)
  {
      switch (entry_type) {
 +    case UDZE:    /* zeros */
      case UDRW:    /* uncompressed */
 -    case UDIG:    /* zeroes */
 +    case UDIG:    /* ignore */
      case UDZO:    /* zlib */
          return true;
      case UDBZ:    /* bzip2 */
@@ -XXX,XX +XXX,XX @@ static int dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds,
          /* sector count */
          s->sectorcounts[i] = buff_read_uint64(buffer, offset + 0x10);
 -        /* all-zeroes sector (type 2) does not need to be "uncompressed" and can
 -         * therefore be unbounded. */
 -        if (s->types[i] != UDIG && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
 +        /* all-zeroes sector (type UDZE and UDIG) does not need to be
 +         * "uncompressed" and can therefore be unbounded. */
 +        if (s->types[i] != UDZE && s->types[i] != UDIG
 +            && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
              error_report("sector count %" PRIu64 " for chunk %" PRIu32
                           " is larger than max (%u)",
                           s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX);
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
                  return -1;
              }
              break;
 -        case UDIG: /* zero */
 +        case UDZE: /* zeros */
 +        case UDIG: /* ignore */
              /* see dmg_read, it is treated specially. No buffer needs to be
               * pre-filled, the zeroes can be set directly. */
              break;
@@ -XXX,XX +XXX,XX @@ dmg_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
          /* Special case: current chunk is all zeroes. Do not perform a memcpy as
           * s->uncompressed_chunk may be too small to cover the large all-zeroes
           * section. dmg_read_chunk is called to find s->current_chunk */
 -        if (s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
 +        if (s->types[s->current_chunk] == UDZE
 +            || s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
              qemu_iovec_memset(qiov, i * 512, 0, 512);
              continue;
          }
 --
-.20.1
+.31.1

-[Qemu-devel] [PULL 3/4] dmg: use enumeration type instead of hard coding number
+[PULL for-6.1 2/3] block/io_uring: resubmit when result is -EAGAIN
-From: yuchenlin <npes87184@gmail.com>
+From: Fabian Ebner <f.ebner@proxmox.com>
-Signed-off-by: yuchenlin <npes87184@gmail.com>
+Linux SCSI can throw spurious -EAGAIN in some corner cases in its
-Reviewed-by: Julio Faracco <jcfaracco@gmail.com>
+completion path, which will end up being the result in the completed
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+io_uring request.
-Message-id: 20190103114700.9686-3-npes87184@gmail.com
 Resubmitting such requests should allow block jobs to complete, even
 if such spurious errors are encountered.
 Co-authored-by: Stefan Hajnoczi <stefanha@gmail.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Signed-off-by: Fabian Ebner <f.ebner@proxmox.com>
 Message-id: 20210729091029.65369-1-f.ebner@proxmox.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/dmg.c | 4 ++--
+ block/io_uring.c | 16 +++++++++++++++-
-file changed, 2 insertions(+), 2 deletions(-)
+file changed, 15 insertions(+), 1 deletion(-)
-diff --git a/block/dmg.c b/block/dmg.c
+diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
+--- a/block/io_uring.c
-+++ b/block/dmg.c
++++ b/block/io_uring.c
-@@ -XXX,XX +XXX,XX @@ static int dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds,
+@@ -XXX,XX +XXX,XX @@ static void luring_process_completions(LuringState *s)
+         total_bytes = ret + luringcb->total_read;
-         /* all-zeroes sector (type 2) does not need to be "uncompressed" and can
-          * therefore be unbounded. */
+         if (ret < 0) {
--        if (s->types[i] != 2 && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
+-            if (ret == -EINTR) {
-+        if (s->types[i] != UDIG && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
++            /*
-             error_report("sector count %" PRIu64 " for chunk %" PRIu32
++             * Only writev/readv/fsync requests on regular files or host block
-                          " is larger than max (%u)",
++             * devices are submitted. Therefore -EAGAIN is not expected but it's
-                          s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX);
++             * known to happen sometimes with Linux SCSI. Submit again and hope
-@@ -XXX,XX +XXX,XX @@ dmg_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
++             * the request completes successfully.
-         /* Special case: current chunk is all zeroes. Do not perform a memcpy as
++             *
-          * s->uncompressed_chunk may be too small to cover the large all-zeroes
++             * For more information, see:
-          * section. dmg_read_chunk is called to find s->current_chunk */
++             * https://lore.kernel.org/io-uring/20210727165811.284510-3-axboe@kernel.dk/T/#u
--        if (s->types[s->current_chunk] == 2) { /* all zeroes block entry */
++             *
-+        if (s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
++             * If the code is changed to submit other types of requests in the
-             qemu_iovec_memset(qiov, i * 512, 0, 512);
++             * future, then this workaround may need to be extended to deal with
-             continue;
++             * genuine -EAGAIN results that should not be resubmitted
-         }
++             * immediately.
 +             */
 +            if (ret == -EINTR || ret == -EAGAIN) {
                  luring_resubmit(s, luringcb);
                  continue;
              }
 --
-.20.1
+.31.1

-[Qemu-devel] [PULL 2/4] dmg: fix binary search
+[PULL for-6.1 3/3] MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver
-From: yuchenlin <npes87184@gmail.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-There is a possible hang in original binary search implementation. That is
+I'm interested in following the activity around the NVMe bdrv.
 if chunk1 = 4, chunk2 = 5, chunk3 = 4, and we go else case.
-The chunk1 will be still 4, and so on.
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210728183340.2018313-1-philmd@redhat.com
 Signed-off-by: yuchenlin <npes87184@gmail.com>
 Message-id: 20190103114700.9686-2-npes87184@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/dmg.c | 10 +++++++---
+ MAINTAINERS | 1 +
-file changed, 7 insertions(+), 3 deletions(-)
+file changed, 1 insertion(+)
-diff --git a/block/dmg.c b/block/dmg.c
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
+--- a/MAINTAINERS
-+++ b/block/dmg.c
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ static inline uint32_t search_chunk(BDRVDMGState *s, uint64_t sector_num)
+@@ -XXX,XX +XXX,XX @@ F: block/null.c
- {
+ NVMe Block Driver
-     /* binary search */
+ M: Stefan Hajnoczi <stefanha@redhat.com>
-     uint32_t chunk1 = 0, chunk2 = s->n_chunks, chunk3;
+ R: Fam Zheng <fam@euphon.net>
--    while (chunk1 != chunk2) {
++R: Philippe Mathieu-Daudé <philmd@redhat.com>
-+    while (chunk1 <= chunk2) {
+ L: qemu-block@nongnu.org
-         chunk3 = (chunk1 + chunk2) / 2;
+ S: Supported
-         if (s->sectors[chunk3] > sector_num) {
+ F: block/nvme*
 -            chunk2 = chunk3;
 +            if (chunk3 == 0) {
 +                goto err;
 +            }
 +            chunk2 = chunk3 - 1;
          } else if (s->sectors[chunk3] + s->sectorcounts[chunk3] > sector_num) {
              return chunk3;
          } else {
 -            chunk1 = chunk3;
 +            chunk1 = chunk3 + 1;
          }
      }
 +err:
      return s->n_chunks; /* error */
  }
 --
-.20.1
+.31.1

From: yuchenlin <npes87184@gmail.com>

There is a possible hang in original binary search implementation. That is
if chunk1 = 4, chunk2 = 5, chunk3 = 4, and we go else case.

The chunk1 will be still 4, and so on.

Signed-off-by: yuchenlin <npes87184@gmail.com>
Message-id: 20190103114700.9686-2-npes87184@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/dmg.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static inline uint32_t search_chunk(BDRVDMGState *s, uint64_t sector_num)
 {
     /* binary search */
     uint32_t chunk1 = 0, chunk2 = s->n_chunks, chunk3;
-    while (chunk1 != chunk2) {
+    while (chunk1 <= chunk2) {
         chunk3 = (chunk1 + chunk2) / 2;
         if (s->sectors[chunk3] > sector_num) {
-            chunk2 = chunk3;
+            if (chunk3 == 0) {
+                goto err;
+            }
+            chunk2 = chunk3 - 1;
         } else if (s->sectors[chunk3] + s->sectorcounts[chunk3] > sector_num) {
             return chunk3;
         } else {
-            chunk1 = chunk3;
+            chunk1 = chunk3 + 1;
         }
     }
+err:
     return s->n_chunks; /* error */
 }
 
-- 
2.20.1

From: yuchenlin <npes87184@gmail.com>

Signed-off-by: yuchenlin <npes87184@gmail.com>
Reviewed-by: Julio Faracco <jcfaracco@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190103114700.9686-3-npes87184@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/dmg.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds,
 
         /* all-zeroes sector (type 2) does not need to be "uncompressed" and can
          * therefore be unbounded. */
-        if (s->types[i] != 2 && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
+        if (s->types[i] != UDIG && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
             error_report("sector count %" PRIu64 " for chunk %" PRIu32
                          " is larger than max (%u)",
                          s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX);
@@ -XXX,XX +XXX,XX @@ dmg_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
         /* Special case: current chunk is all zeroes. Do not perform a memcpy as
          * s->uncompressed_chunk may be too small to cover the large all-zeroes
          * section. dmg_read_chunk is called to find s->current_chunk */
-        if (s->types[s->current_chunk] == 2) { /* all zeroes block entry */
+        if (s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
             qemu_iovec_memset(qiov, i * 512, 0, 512);
             continue;
         }
-- 
2.20.1

From: yuchenlin <npes87184@gmail.com>

The dmg file has many tables which describe: "start from sector XXX to
sector XXX, the compression method is XXX and where the compressed data
resides on".

Each sector in the expanded file should be covered by a table. The table
will describe the offset of compressed data (or raw depends on the type)
in the dmg.

For example:

[-----------The expanded file------------]
[---bzip table ---]/* zeros */[---zlib---]
    ^
    | if we want to read this sector.

we will find bzip table which contains this sector, and get the
compressed data offset, read it from dmg, uncompress it, finally write to
expanded file.

If we skip zero chunk (table), some sector cannot find the table which
will cause search_chunk() return s->n_chunks, dmg_read_chunk() return -1
and finally causing dmg_co_preadv() return EIO.

See:

[-----------The expanded file------------]
[---bzip table ---]/* zeros */[---zlib---]
                    ^
                    | if we want to read this sector.

Oops, we cannot find the table contains it...

In the original implementation, we don't have zero table. When we try to
read sector inside the zero chunk. We will get EIO, and skip reading.

After this patch, we treat zero chunk the same as ignore chunk, it will
directly write zero and avoid some sector may not find the table.

After this patch:

[-----------The expanded file------------]
[---bzip table ---][--zeros--][---zlib---]

Signed-off-by: yuchenlin <npes87184@gmail.com>
Reviewed-by: Julio Faracco <jcfaracco@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190103114700.9686-4-npes87184@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/dmg.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static void update_max_chunk_size(BDRVDMGState *s, uint32_t chunk,
     case UDRW: /* copy */
         uncompressed_sectors = DIV_ROUND_UP(s->lengths[chunk], 512);
         break;
-    case UDIG: /* zero */
+    case UDZE: /* zero */
+    case UDIG: /* ignore */
         /* as the all-zeroes block may be large, it is treated specially: the
          * sector is not copied from a large buffer, a simple memset is used
          * instead. Therefore uncompressed_sectors does not need to be set. */
@@ -XXX,XX +XXX,XX @@ typedef struct DmgHeaderState {
 static bool dmg_is_known_block_type(uint32_t entry_type)
 {
     switch (entry_type) {
+    case UDZE:    /* zeros */
     case UDRW:    /* uncompressed */
-    case UDIG:    /* zeroes */
+    case UDIG:    /* ignore */
     case UDZO:    /* zlib */
         return true;
     case UDBZ:    /* bzip2 */
@@ -XXX,XX +XXX,XX @@ static int dmg_read_mish_block(BDRVDMGState *s, DmgHeaderState *ds,
         /* sector count */
         s->sectorcounts[i] = buff_read_uint64(buffer, offset + 0x10);
 
-        /* all-zeroes sector (type 2) does not need to be "uncompressed" and can
-         * therefore be unbounded. */
-        if (s->types[i] != UDIG && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
+        /* all-zeroes sector (type UDZE and UDIG) does not need to be
+         * "uncompressed" and can therefore be unbounded. */
+        if (s->types[i] != UDZE && s->types[i] != UDIG
+            && s->sectorcounts[i] > DMG_SECTORCOUNTS_MAX) {
             error_report("sector count %" PRIu64 " for chunk %" PRIu32
                          " is larger than max (%u)",
                          s->sectorcounts[i], i, DMG_SECTORCOUNTS_MAX);
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
                 return -1;
             }
             break;
-        case UDIG: /* zero */
+        case UDZE: /* zeros */
+        case UDIG: /* ignore */
             /* see dmg_read, it is treated specially. No buffer needs to be
              * pre-filled, the zeroes can be set directly. */
             break;
@@ -XXX,XX +XXX,XX @@ dmg_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
         /* Special case: current chunk is all zeroes. Do not perform a memcpy as
          * s->uncompressed_chunk may be too small to cover the large all-zeroes
          * section. dmg_read_chunk is called to find s->current_chunk */
-        if (s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
+        if (s->types[s->current_chunk] == UDZE
+            || s->types[s->current_chunk] == UDIG) { /* all zeroes block entry */
             qemu_iovec_memset(qiov, i * 512, 0, 512);
             continue;
         }
-- 
2.20.1

The following changes since commit 3521ade3510eb5cefb2e27a101667f25dad89935:

Merge remote-tracking branch 'remotes/thuth-gitlab/tags/pull-request-2021-07-29' into staging (2021-07-29 13:17:20 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to cc8eecd7f105a1dff5876adeb238a14696061a4a:

MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver (2021-07-29 17:17:34 +0100)

----------------------------------------------------------------
Pull request

The main fix here is for io_uring. Spurious -EAGAIN errors can happen and the
request needs to be resubmitted.

The MAINTAINERS changes carry no risk and we might as well include them in QEMU
6.1.

----------------------------------------------------------------

Fabian Ebner (1):
  block/io_uring: resubmit when result is -EAGAIN

Philippe Mathieu-Daudé (1):
  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver

Stefano Garzarella (1):
  MAINTAINERS: add Stefano Garzarella as io_uring reviewer

MAINTAINERS      |  2 ++
 block/io_uring.c | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 1 deletion(-)

-- 
2.31.1

From: Fabian Ebner <f.ebner@proxmox.com>

Linux SCSI can throw spurious -EAGAIN in some corner cases in its
completion path, which will end up being the result in the completed
io_uring request.

Resubmitting such requests should allow block jobs to complete, even
if such spurious errors are encountered.

Co-authored-by: Stefan Hajnoczi <stefanha@gmail.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Fabian Ebner <f.ebner@proxmox.com>
Message-id: 20210729091029.65369-1-f.ebner@proxmox.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io_uring.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@ static void luring_process_completions(LuringState *s)
         total_bytes = ret + luringcb->total_read;
 
         if (ret < 0) {
-            if (ret == -EINTR) {
+            /*
+             * Only writev/readv/fsync requests on regular files or host block
+             * devices are submitted. Therefore -EAGAIN is not expected but it's
+             * known to happen sometimes with Linux SCSI. Submit again and hope
+             * the request completes successfully.
+             *
+             * For more information, see:
+             * https://lore.kernel.org/io-uring/20210727165811.284510-3-axboe@kernel.dk/T/#u
+             *
+             * If the code is changed to submit other types of requests in the
+             * future, then this workaround may need to be extended to deal with
+             * genuine -EAGAIN results that should not be resubmitted
+             * immediately.
+             */
+            if (ret == -EINTR || ret == -EAGAIN) {
                 luring_resubmit(s, luringcb);
                 continue;
             }
-- 
2.31.1