diff mbox series

[17/18] block: Reorganize some declarations in block-backend-io.h

Message ID 20220517113907.200001-6-afaria@redhat.com
State New
Headers show
Series Make block-backend-io.h API more consistent | expand

Commit Message

Alberto Faria May 17, 2022, 11:39 a.m. UTC 
Keep generated_co_wrapper and coroutine_fn pairs together. This should
make it clear that each I/O function has these two versions.

Also move blk_co_{pread,pwrite}()'s implementations out of the header
file for consistency.

Signed-off-by: Alberto Faria <afaria@redhat.com>
---
 block/block-backend.c             | 22 ++++++++
 include/sysemu/block-backend-io.h | 87 +++++++++++++------------------
 2 files changed, 59 insertions(+), 50 deletions(-)

Comments

Paolo Bonzini May 17, 2022, 2:29 p.m. UTC | #1 
On 5/17/22 13:39, Alberto Faria wrote:
> Keep generated_co_wrapper and coroutine_fn pairs together. This should
> make it clear that each I/O function has these two versions.
> 
> Also move blk_co_{pread,pwrite}()'s implementations out of the header
> file for consistency.
> 
> Signed-off-by: Alberto Faria <afaria@redhat.com>

Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>

> ---
>   block/block-backend.c             | 22 ++++++++
>   include/sysemu/block-backend-io.h | 87 +++++++++++++------------------
>   2 files changed, 59 insertions(+), 50 deletions(-)
> 
> diff --git a/block/block-backend.c b/block/block-backend.c
> index 52be1d9116..920ba0dd1f 100644
> --- a/block/block-backend.c
> +++ b/block/block-backend.c
> @@ -1318,6 +1318,17 @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
>       return ret;
>   }
>   
> +int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
> +                              void *buf, BdrvRequestFlags flags)
> +{
> +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
> +    IO_OR_GS_CODE();
> +
> +    assert(bytes <= SIZE_MAX);
> +
> +    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
> +}
> +
>   int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
>                                  int64_t bytes, QEMUIOVector *qiov,
>                                  BdrvRequestFlags flags)
> @@ -1399,6 +1410,17 @@ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
>       return ret;
>   }
>   
> +int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
> +                               const void *buf, BdrvRequestFlags flags)
> +{
> +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
> +    IO_OR_GS_CODE();
> +
> +    assert(bytes <= SIZE_MAX);
> +
> +    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
> +}
> +
>   int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
>                                   int64_t bytes, QEMUIOVector *qiov,
>                                   BdrvRequestFlags flags)
> diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
> index 004493ec36..30ed979fb1 100644
> --- a/include/sysemu/block-backend-io.h
> +++ b/include/sysemu/block-backend-io.h
> @@ -88,11 +88,6 @@ uint32_t blk_get_request_alignment(BlockBackend *blk);
>   uint32_t blk_get_max_transfer(BlockBackend *blk);
>   uint64_t blk_get_max_hw_transfer(BlockBackend *blk);
>   
> -int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
> -                                   BlockBackend *blk_out, int64_t off_out,
> -                                   int64_t bytes, BdrvRequestFlags read_flags,
> -                                   BdrvRequestFlags write_flags);
> -
>   
>   /*
>    * "I/O or GS" API functions. These functions can run without
> @@ -105,9 +100,16 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
>   int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
>                                      int64_t bytes, void *buf,
>                                      BdrvRequestFlags flags);
> -int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
> -                                    int64_t bytes, const void *buf,
> +int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
> +                              void *buf, BdrvRequestFlags flags);
> +
> +int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
> +                                    int64_t bytes, QEMUIOVector *qiov,
>                                       BdrvRequestFlags flags);
> +int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
> +                               int64_t bytes, QEMUIOVector *qiov,
> +                               BdrvRequestFlags flags);
> +
>   int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
>                                            int64_t bytes, QEMUIOVector *qiov,
>                                            size_t qiov_offset,
> @@ -115,12 +117,20 @@ int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
>   int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
>                                       int64_t bytes, QEMUIOVector *qiov,
>                                       size_t qiov_offset, BdrvRequestFlags flags);
> -int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
> -                                    int64_t bytes, QEMUIOVector *qiov,
> +
> +int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
> +                                    int64_t bytes, const void *buf,
>                                       BdrvRequestFlags flags);
> -int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
> -                               int64_t bytes, QEMUIOVector *qiov,
> -                               BdrvRequestFlags flags);
> +int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
> +                               const void *buf, BdrvRequestFlags flags);
> +
> +int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
> +                                     int64_t bytes, QEMUIOVector *qiov,
> +                                     BdrvRequestFlags flags);
> +int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
> +                                int64_t bytes, QEMUIOVector *qiov,
> +                                BdrvRequestFlags flags);
> +
>   int generated_co_wrapper blk_pwritev_part(BlockBackend *blk, int64_t offset,
>                                             int64_t bytes, QEMUIOVector *qiov,
>                                             size_t qiov_offset,
> @@ -129,36 +139,18 @@ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
>                                        int64_t bytes,
>                                        QEMUIOVector *qiov, size_t qiov_offset,
>                                        BdrvRequestFlags flags);
> -int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
> -                                     int64_t bytes, QEMUIOVector *qiov,
> -                                     BdrvRequestFlags flags);
> -int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
> -                                int64_t bytes, QEMUIOVector *qiov,
> -                                BdrvRequestFlags flags);
> -
> -static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset,
> -                                            int64_t bytes, void *buf,
> -                                            BdrvRequestFlags flags)
> -{
> -    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
> -    IO_OR_GS_CODE();
>   
> -    assert(bytes <= SIZE_MAX);
> -
> -    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
> -}
> -
> -static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
> -                                             int64_t bytes, const void *buf,
> -                                             BdrvRequestFlags flags)
> -{
> -    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
> -    IO_OR_GS_CODE();
> -
> -    assert(bytes <= SIZE_MAX);
> +int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
> +                                               int64_t offset, int64_t bytes,
> +                                               const void *buf);
> +int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
> +                                          int64_t bytes, const void *buf);
>   
> -    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
> -}
> +int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
> +                                           int64_t bytes,
> +                                           BdrvRequestFlags flags);
> +int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
> +                                      int64_t bytes, BdrvRequestFlags flags);
>   
>   int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
>                                         int64_t bytes);
> @@ -173,16 +165,6 @@ int generated_co_wrapper blk_ioctl(BlockBackend *blk, unsigned long int req,
>   int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
>                                 void *buf);
>   
> -int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
> -                                               int64_t offset, int64_t bytes,
> -                                               const void *buf);
> -int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
> -                                          int64_t bytes, const void *buf);
> -int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
> -                                           int64_t bytes,
> -                                           BdrvRequestFlags flags);
> -int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
> -                                      int64_t bytes, BdrvRequestFlags flags);
>   int generated_co_wrapper blk_truncate(BlockBackend *blk, int64_t offset,
>                                         bool exact, PreallocMode prealloc,
>                                         BdrvRequestFlags flags, Error **errp);
> @@ -190,4 +172,9 @@ int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
>                                    PreallocMode prealloc, BdrvRequestFlags flags,
>                                    Error **errp);
>   
> +int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
> +                                   BlockBackend *blk_out, int64_t off_out,
> +                                   int64_t bytes, BdrvRequestFlags read_flags,
> +                                   BdrvRequestFlags write_flags);
> +
>   #endif /* BLOCK_BACKEND_IO_H */
Hanna Czenczek July 5, 2022, 9:18 a.m. UTC | #2 
On 17.05.22 13:39, Alberto Faria wrote:
> Keep generated_co_wrapper and coroutine_fn pairs together. This should
> make it clear that each I/O function has these two versions.
>
> Also move blk_co_{pread,pwrite}()'s implementations out of the header
> file for consistency.
>
> Signed-off-by: Alberto Faria <afaria@redhat.com>
> ---
>   block/block-backend.c             | 22 ++++++++
>   include/sysemu/block-backend-io.h | 87 +++++++++++++------------------
>   2 files changed, 59 insertions(+), 50 deletions(-)

[...]

> diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
> index 004493ec36..30ed979fb1 100644
> --- a/include/sysemu/block-backend-io.h
> +++ b/include/sysemu/block-backend-io.h
> @@ -88,11 +88,6 @@ uint32_t blk_get_request_alignment(BlockBackend *blk);
>   uint32_t blk_get_max_transfer(BlockBackend *blk);
>   uint64_t blk_get_max_hw_transfer(BlockBackend *blk);
>   
> -int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
> -                                   BlockBackend *blk_out, int64_t off_out,
> -                                   int64_t bytes, BdrvRequestFlags read_flags,
> -                                   BdrvRequestFlags write_flags);
> -
>   
>   /*
>    * "I/O or GS" API functions. These functions can run without

[...]

> @@ -190,4 +172,9 @@ int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
>                                    PreallocMode prealloc, BdrvRequestFlags flags,
>                                    Error **errp);
>   
> +int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
> +                                   BlockBackend *blk_out, int64_t off_out,
> +                                   int64_t bytes, BdrvRequestFlags read_flags,
> +                                   BdrvRequestFlags write_flags);
> +
>   #endif /* BLOCK_BACKEND_IO_H */

This moves blk_co_copy_range() from the “I/O API functions” section of 
this header into the “"I/O or GS" API functions” section.  Is that intended?

The rest looks good to me, but I wonder about this one function.

Hanna
Alberto Faria July 5, 2022, 3:26 p.m. UTC | #3 
On Tue, Jul 5, 2022 at 10:18 AM Hanna Reitz <hreitz@redhat.com> wrote:
> This moves blk_co_copy_range() from the “I/O API functions” section of
> this header into the “"I/O or GS" API functions” section.  Is that intended?

Oops, thanks, it wasn't intended. Will fix.

Alberto
diff mbox series

Patch

diff --git a/block/block-backend.c b/block/block-backend.c
index 52be1d9116..920ba0dd1f 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -1318,6 +1318,17 @@  blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
     return ret;
 }
 
+int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
+                              void *buf, BdrvRequestFlags flags)
+{
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+    IO_OR_GS_CODE();
+
+    assert(bytes <= SIZE_MAX);
+
+    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
+}
+
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                int64_t bytes, QEMUIOVector *qiov,
                                BdrvRequestFlags flags)
@@ -1399,6 +1410,17 @@  int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
     return ret;
 }
 
+int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
+                               const void *buf, BdrvRequestFlags flags)
+{
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+    IO_OR_GS_CODE();
+
+    assert(bytes <= SIZE_MAX);
+
+    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
+}
+
 int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
                                 int64_t bytes, QEMUIOVector *qiov,
                                 BdrvRequestFlags flags)
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index 004493ec36..30ed979fb1 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -88,11 +88,6 @@  uint32_t blk_get_request_alignment(BlockBackend *blk);
 uint32_t blk_get_max_transfer(BlockBackend *blk);
 uint64_t blk_get_max_hw_transfer(BlockBackend *blk);
 
-int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
-                                   BlockBackend *blk_out, int64_t off_out,
-                                   int64_t bytes, BdrvRequestFlags read_flags,
-                                   BdrvRequestFlags write_flags);
-
 
 /*
  * "I/O or GS" API functions. These functions can run without
@@ -105,9 +100,16 @@  int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
 int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
                                    int64_t bytes, void *buf,
                                    BdrvRequestFlags flags);
-int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
-                                    int64_t bytes, const void *buf,
+int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
+                              void *buf, BdrvRequestFlags flags);
+
+int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
+                                    int64_t bytes, QEMUIOVector *qiov,
                                     BdrvRequestFlags flags);
+int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                               int64_t bytes, QEMUIOVector *qiov,
+                               BdrvRequestFlags flags);
+
 int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
                                          int64_t bytes, QEMUIOVector *qiov,
                                          size_t qiov_offset,
@@ -115,12 +117,20 @@  int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
 int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
                                     int64_t bytes, QEMUIOVector *qiov,
                                     size_t qiov_offset, BdrvRequestFlags flags);
-int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
-                                    int64_t bytes, QEMUIOVector *qiov,
+
+int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
+                                    int64_t bytes, const void *buf,
                                     BdrvRequestFlags flags);
-int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
-                               int64_t bytes, QEMUIOVector *qiov,
-                               BdrvRequestFlags flags);
+int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
+                               const void *buf, BdrvRequestFlags flags);
+
+int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
+                                     int64_t bytes, QEMUIOVector *qiov,
+                                     BdrvRequestFlags flags);
+int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+                                BdrvRequestFlags flags);
+
 int generated_co_wrapper blk_pwritev_part(BlockBackend *blk, int64_t offset,
                                           int64_t bytes, QEMUIOVector *qiov,
                                           size_t qiov_offset,
@@ -129,36 +139,18 @@  int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
                                      int64_t bytes,
                                      QEMUIOVector *qiov, size_t qiov_offset,
                                      BdrvRequestFlags flags);
-int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
-                                     int64_t bytes, QEMUIOVector *qiov,
-                                     BdrvRequestFlags flags);
-int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
-                                int64_t bytes, QEMUIOVector *qiov,
-                                BdrvRequestFlags flags);
-
-static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset,
-                                            int64_t bytes, void *buf,
-                                            BdrvRequestFlags flags)
-{
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_OR_GS_CODE();
 
-    assert(bytes <= SIZE_MAX);
-
-    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
-}
-
-static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
-                                             int64_t bytes, const void *buf,
-                                             BdrvRequestFlags flags)
-{
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_OR_GS_CODE();
-
-    assert(bytes <= SIZE_MAX);
+int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
+                                               int64_t offset, int64_t bytes,
+                                               const void *buf);
+int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
+                                          int64_t bytes, const void *buf);
 
-    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
-}
+int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                           int64_t bytes,
+                                           BdrvRequestFlags flags);
+int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                      int64_t bytes, BdrvRequestFlags flags);
 
 int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
                                       int64_t bytes);
@@ -173,16 +165,6 @@  int generated_co_wrapper blk_ioctl(BlockBackend *blk, unsigned long int req,
 int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
                               void *buf);
 
-int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
-                                               int64_t offset, int64_t bytes,
-                                               const void *buf);
-int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
-                                          int64_t bytes, const void *buf);
-int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
-                                           int64_t bytes,
-                                           BdrvRequestFlags flags);
-int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
-                                      int64_t bytes, BdrvRequestFlags flags);
 int generated_co_wrapper blk_truncate(BlockBackend *blk, int64_t offset,
                                       bool exact, PreallocMode prealloc,
                                       BdrvRequestFlags flags, Error **errp);
@@ -190,4 +172,9 @@  int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
                                  PreallocMode prealloc, BdrvRequestFlags flags,
                                  Error **errp);
 
+int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+                                   BlockBackend *blk_out, int64_t off_out,
+                                   int64_t bytes, BdrvRequestFlags read_flags,
+                                   BdrvRequestFlags write_flags);
+
 #endif /* BLOCK_BACKEND_IO_H */