diff mbox series

[RFC,4/8] Fix some direct calls from non-coroutine_fn to coroutine_fn

Message ID 20220702113331.2003820-5-afaria@redhat.com (mailing list archive)
State New, archived
Headers show
Series Introduce an extensible static analyzer | expand

Commit Message

Alberto Faria July 2, 2022, 11:33 a.m. UTC 
These problems were found by static-analyzer.py. Only a few of the
reported cases were fixed.

Signed-off-by: Alberto Faria <afaria@redhat.com>
---
 block/block-backend.c     | 13 ++++++++-----
 block/copy-before-write.c |  3 ++-
 block/dirty-bitmap.c      |  6 ++++--
 block/iscsi.c             |  3 ++-
 block/qcow2.h             | 14 +++++++-------
 block/qed.c               |  6 +++---
 include/block/block-io.h  |  7 ++++---
 7 files changed, 30 insertions(+), 22 deletions(-)

Comments

Paolo Bonzini July 2, 2022, 2:13 p.m. UTC | #1 
On 7/2/22 13:33, Alberto Faria wrote:
> @@ -1537,8 +1537,9 @@ static void blk_aio_read_entry(void *opaque)
>       QEMUIOVector *qiov = rwco->iobuf;
>   
>       assert(qiov->size == acb->bytes);
> -    rwco->ret = blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes,
> -                                 qiov, rwco->flags);
> +    rwco->ret = __allow_coroutine_fn_call(
> +        blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes, qiov,
> +                         rwco->flags));
>       blk_aio_complete(acb);
>   }
>   
> @@ -1682,7 +1683,8 @@ static void blk_aio_ioctl_entry(void *opaque)
>       BlkAioEmAIOCB *acb = opaque;
>       BlkRwCo *rwco = &acb->rwco;
>   
> -    rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
> +    rwco->ret = __allow_coroutine_fn_call(
> +        blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf));
>   
>       blk_aio_complete(acb);
>   }
> @@ -1716,7 +1718,8 @@ static void blk_aio_pdiscard_entry(void *opaque)
>       BlkAioEmAIOCB *acb = opaque;
>       BlkRwCo *rwco = &acb->rwco;
>   
> -    rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
> +    rwco->ret = __allow_coroutine_fn_call(
> +        blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes));
>       blk_aio_complete(acb);
>   }
>   
> @@ -1772,7 +1775,7 @@ static void blk_aio_flush_entry(void *opaque)
>       BlkAioEmAIOCB *acb = opaque;
>       BlkRwCo *rwco = &acb->rwco;
>   
> -    rwco->ret = blk_co_do_flush(rwco->blk);
> +    rwco->ret = __allow_coroutine_fn_call(blk_co_do_flush(rwco->blk));
>       blk_aio_complete(acb);
>   }
>   

These functions should be coroutine_fn (all coroutine entry points 
should be).

Paolo
Alberto Faria July 3, 2022, 10:20 p.m. UTC | #2 
On Sat, Jul 2, 2022 at 3:13 PM Paolo Bonzini <pbonzini@redhat.com> wrote:
> These functions should be coroutine_fn (all coroutine entry points
> should be).

Thanks, I see now that you fixed this in [1].

Alberto

[1] https://patchew.org/QEMU/20220509103019.215041-1-pbonzini@redhat.com/
diff mbox series

Patch

diff --git a/block/block-backend.c b/block/block-backend.c
index f425b00793..5f2a912a59 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -1537,8 +1537,9 @@  static void blk_aio_read_entry(void *opaque)
     QEMUIOVector *qiov = rwco->iobuf;
 
     assert(qiov->size == acb->bytes);
-    rwco->ret = blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes,
-                                 qiov, rwco->flags);
+    rwco->ret = __allow_coroutine_fn_call(
+        blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes, qiov,
+                         rwco->flags));
     blk_aio_complete(acb);
 }
 
@@ -1682,7 +1683,8 @@  static void blk_aio_ioctl_entry(void *opaque)
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
 
-    rwco->ret = blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
+    rwco->ret = __allow_coroutine_fn_call(
+        blk_co_do_ioctl(rwco->blk, rwco->offset, rwco->iobuf));
 
     blk_aio_complete(acb);
 }
@@ -1716,7 +1718,8 @@  static void blk_aio_pdiscard_entry(void *opaque)
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
 
-    rwco->ret = blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes);
+    rwco->ret = __allow_coroutine_fn_call(
+        blk_co_do_pdiscard(rwco->blk, rwco->offset, acb->bytes));
     blk_aio_complete(acb);
 }
 
@@ -1772,7 +1775,7 @@  static void blk_aio_flush_entry(void *opaque)
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
 
-    rwco->ret = blk_co_do_flush(rwco->blk);
+    rwco->ret = __allow_coroutine_fn_call(blk_co_do_flush(rwco->blk));
     blk_aio_complete(acb);
 }
 
diff --git a/block/copy-before-write.c b/block/copy-before-write.c
index c24b8dd117..5096abbc08 100644
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -240,7 +240,8 @@  static BlockReq *cbw_snapshot_read_lock(BlockDriverState *bs,
     return req;
 }
 
-static void cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
+static coroutine_fn void
+cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
 {
     BDRVCopyBeforeWriteState *s = bs->opaque;
 
diff --git a/block/dirty-bitmap.c b/block/dirty-bitmap.c
index bf3dc0512a..ccf46c0b1f 100644
--- a/block/dirty-bitmap.c
+++ b/block/dirty-bitmap.c
@@ -419,7 +419,8 @@  int bdrv_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
                                         Error **errp)
 {
     if (qemu_in_coroutine()) {
-        return bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp);
+        return __allow_coroutine_fn_call(
+            bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp));
     } else {
         Coroutine *co;
         BdrvRemovePersistentDirtyBitmapCo s = {
@@ -495,7 +496,8 @@  bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
 {
     IO_CODE();
     if (qemu_in_coroutine()) {
-        return bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp);
+        return __allow_coroutine_fn_call(
+            bdrv_co_can_store_new_dirty_bitmap(bs, name, granularity, errp));
     } else {
         Coroutine *co;
         BdrvCanStoreNewDirtyBitmapCo s = {
diff --git a/block/iscsi.c b/block/iscsi.c
index d707d0b354..967438b4bd 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -290,7 +290,8 @@  iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
     }
 }
 
-static void iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
+static void coroutine_fn
+iscsi_co_init_iscsitask(IscsiLun *iscsilun, struct IscsiTask *iTask)
 {
     *iTask = (struct IscsiTask) {
         .co         = qemu_coroutine_self(),
diff --git a/block/qcow2.h b/block/qcow2.h
index ba436a8d0d..e68d127d8e 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -990,13 +990,13 @@  int qcow2_truncate_bitmaps_check(BlockDriverState *bs, Error **errp);
 bool qcow2_store_persistent_dirty_bitmaps(BlockDriverState *bs,
                                           bool release_stored, Error **errp);
 int qcow2_reopen_bitmaps_ro(BlockDriverState *bs, Error **errp);
-bool qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs,
-                                         const char *name,
-                                         uint32_t granularity,
-                                         Error **errp);
-int qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState *bs,
-                                            const char *name,
-                                            Error **errp);
+bool coroutine_fn qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs,
+                                                      const char *name,
+                                                      uint32_t granularity,
+                                                      Error **errp);
+int coroutine_fn qcow2_co_remove_persistent_dirty_bitmap(BlockDriverState *bs,
+                                                         const char *name,
+                                                         Error **errp);
 bool qcow2_supports_persistent_dirty_bitmap(BlockDriverState *bs);
 uint64_t qcow2_get_persistent_dirty_bitmap_size(BlockDriverState *bs,
                                                 uint32_t cluster_size);
diff --git a/block/qed.c b/block/qed.c
index f34d9a3ac1..96f4cda83f 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -259,7 +259,7 @@  static CachedL2Table *qed_new_l2_table(BDRVQEDState *s)
     return l2_table;
 }
 
-static bool qed_plug_allocating_write_reqs(BDRVQEDState *s)
+static bool coroutine_fn qed_plug_allocating_write_reqs(BDRVQEDState *s)
 {
     qemu_co_mutex_lock(&s->table_lock);
 
@@ -278,7 +278,7 @@  static bool qed_plug_allocating_write_reqs(BDRVQEDState *s)
     return true;
 }
 
-static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)
+static void coroutine_fn qed_unplug_allocating_write_reqs(BDRVQEDState *s)
 {
     qemu_co_mutex_lock(&s->table_lock);
     assert(s->allocating_write_reqs_plugged);
@@ -568,7 +568,7 @@  static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
 
     bdrv_qed_init_state(bs);
     if (qemu_in_coroutine()) {
-        bdrv_qed_open_entry(&qoc);
+        __allow_coroutine_fn_call(bdrv_qed_open_entry(&qoc));
     } else {
         assert(qemu_get_current_aio_context() == qemu_get_aio_context());
         qemu_coroutine_enter(qemu_coroutine_create(bdrv_qed_open_entry, &qoc));
diff --git a/include/block/block-io.h b/include/block/block-io.h
index 053a27141a..cefe3494fe 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -80,7 +80,8 @@  int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf);
 /* Ensure contents are flushed to disk.  */
 int coroutine_fn bdrv_co_flush(BlockDriverState *bs);
 
-int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
+int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
+                                  int64_t bytes);
 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
 int bdrv_block_status(BlockDriverState *bs, int64_t offset,
                       int64_t bytes, int64_t *pnum, int64_t *map,
@@ -88,8 +89,8 @@  int bdrv_block_status(BlockDriverState *bs, int64_t offset,
 int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
                             int64_t offset, int64_t bytes, int64_t *pnum,
                             int64_t *map, BlockDriverState **file);
-int bdrv_is_allocated(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                      int64_t *pnum);
+int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
+                                   int64_t bytes, int64_t *pnum);
 int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             bool include_base, int64_t offset, int64_t bytes,
                             int64_t *pnum);