diff mbox series

[v3,08/19] block/reqlist: add reqlist_wait_all()

Message ID 20211222174018.257550-9-vsementsov@virtuozzo.com (mailing list archive)
State New, archived
Headers show
Series Make image fleecing more usable | expand

Commit Message

Vladimir Sementsov-Ogievskiy Dec. 22, 2021, 5:40 p.m. UTC
Add function to wait for all intersecting requests.
To be used in the further commit.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
---
 include/block/reqlist.h | 8 ++++++++
 block/reqlist.c         | 8 ++++++++
 2 files changed, 16 insertions(+)

Comments

Nikta Lapshin Jan. 17, 2022, 12:34 p.m. UTC | #1
On 12/22/21 20:40, Vladimir Sementsov-Ogievskiy wrote:

> Add function to wait for all intersecting requests.
> To be used in the further commit.
>
> Signed-off-by: Vladimir Sementsov-Ogievskiy<vsementsov@virtuozzo.com>
> ---
>   include/block/reqlist.h | 8 ++++++++
>   block/reqlist.c         | 8 ++++++++
>   2 files changed, 16 insertions(+)
>
> diff --git a/include/block/reqlist.h b/include/block/reqlist.h
> index b904d80216..4695623bb3 100644
> --- a/include/block/reqlist.h
> +++ b/include/block/reqlist.h
> @@ -53,6 +53,14 @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
>   bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
>                                      int64_t bytes, CoMutex *lock);
>   
> +/*
> + * Wait for all intersecting requests. It just calls reqlist_wait_one() in a
> + * loops, caller is responsible to stop producing new requests in this region
> + * in parallel, otherwise reqlist_wait_all() may never return.
> + */
> +void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
> +                                   int64_t bytes, CoMutex *lock);
> +
>   /*
>    * Shrink request and wake all waiting coroutines (may be some of them are not
>    * intersecting with shrunk request).
> diff --git a/block/reqlist.c b/block/reqlist.c
> index 5e320ba649..52a362a1d8 100644
> --- a/block/reqlist.c
> +++ b/block/reqlist.c
> @@ -57,6 +57,14 @@ bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
>       return true;
>   }
>   
> +void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
> +                                   int64_t bytes, CoMutex *lock)
> +{
> +    while (reqlist_wait_one(reqs, offset, bytes, lock)) {
> +        /* continue */
> +    }
> +}
> +
>   void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
>   {
>       if (new_bytes == req->bytes) {


Reviewed-by: Nikita Lapshin<nikita.lapshin@virtuozzo.com>
Hanna Czenczek Jan. 18, 2022, 1:44 p.m. UTC | #2
On 22.12.21 18:40, Vladimir Sementsov-Ogievskiy wrote:
> Add function to wait for all intersecting requests.
> To be used in the further commit.
>
> Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
> ---
>   include/block/reqlist.h | 8 ++++++++
>   block/reqlist.c         | 8 ++++++++
>   2 files changed, 16 insertions(+)
>
> diff --git a/include/block/reqlist.h b/include/block/reqlist.h
> index b904d80216..4695623bb3 100644
> --- a/include/block/reqlist.h
> +++ b/include/block/reqlist.h
> @@ -53,6 +53,14 @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
>   bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
>                                      int64_t bytes, CoMutex *lock);
>   
> +/*
> + * Wait for all intersecting requests. It just calls reqlist_wait_one() in a
> + * loops, caller is responsible to stop producing new requests in this region

s/loops/loop/

Reviewed-by: Hanna Reitz <hreitz@redhat.com>

> + * in parallel, otherwise reqlist_wait_all() may never return.
> + */
> +void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
> +                                   int64_t bytes, CoMutex *lock);
> +
>   /*
>    * Shrink request and wake all waiting coroutines (may be some of them are not
>    * intersecting with shrunk request).
diff mbox series

Patch

diff --git a/include/block/reqlist.h b/include/block/reqlist.h
index b904d80216..4695623bb3 100644
--- a/include/block/reqlist.h
+++ b/include/block/reqlist.h
@@ -53,6 +53,14 @@  BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
 bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
                                    int64_t bytes, CoMutex *lock);
 
+/*
+ * Wait for all intersecting requests. It just calls reqlist_wait_one() in a
+ * loops, caller is responsible to stop producing new requests in this region
+ * in parallel, otherwise reqlist_wait_all() may never return.
+ */
+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock);
+
 /*
  * Shrink request and wake all waiting coroutines (may be some of them are not
  * intersecting with shrunk request).
diff --git a/block/reqlist.c b/block/reqlist.c
index 5e320ba649..52a362a1d8 100644
--- a/block/reqlist.c
+++ b/block/reqlist.c
@@ -57,6 +57,14 @@  bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
     return true;
 }
 
+void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
+                                   int64_t bytes, CoMutex *lock)
+{
+    while (reqlist_wait_one(reqs, offset, bytes, lock)) {
+        /* continue */
+    }
+}
+
 void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
 {
     if (new_bytes == req->bytes) {