As we want to do per-queue polling, extract the nvme_poll_queue()
method which operates on a single queue.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
---
 block/nvme.c | 44 +++++++++++++++++++++++++++-----------------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/block/nvme.c b/block/nvme.c
index 1f67e888c84..a61e86a83eb 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -590,31 +590,41 @@ out:
     qemu_vfree(id);
 }
 
+static bool nvme_poll_queue(NVMeQueuePair *q)
+{
+    bool progress = false;
+
+    const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
+    NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
+
+    /*
+     * Do an early check for completions. q->lock isn't needed because
+     * nvme_process_completion() only runs in the event loop thread and
+     * cannot race with itself.
+     */
+    if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
+        return false;
+    }
+
+    qemu_mutex_lock(&q->lock);
+    while (nvme_process_completion(q)) {
+        /* Keep polling */
+        progress = true;
+    }
+    qemu_mutex_unlock(&q->lock);
+
+    return progress;
+}
+
 static bool nvme_poll_queues(BDRVNVMeState *s)
 {
     bool progress = false;
     int i;
 
     for (i = 0; i < s->nr_queues; i++) {
-        NVMeQueuePair *q = s->queues[i];
-        const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
-        NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
-
-        /*
-         * Do an early check for completions. q->lock isn't needed because
-         * nvme_process_completion() only runs in the event loop thread and
-         * cannot race with itself.
-         */
-        if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
-            continue;
-        }
-
-        qemu_mutex_lock(&q->lock);
-        while (nvme_process_completion(q)) {
-            /* Keep polling */
+        if (nvme_poll_queue(s->queues[i])) {
             progress = true;
         }
-        qemu_mutex_unlock(&q->lock);
     }
     return progress;
 }
-- 
2.26.2

On Thu, Aug 20, 2020 at 06:59:00PM +0200, Philippe Mathieu-Daudé wrote:
> As we want to do per-queue polling, extract the nvme_poll_queue()
> method which operates on a single queue.
> 
> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
> Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
> ---
>  block/nvme.c | 44 +++++++++++++++++++++++++++-----------------
>  1 file changed, 27 insertions(+), 17 deletions(-)

Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>

> 
> diff --git a/block/nvme.c b/block/nvme.c
> index 1f67e888c84..a61e86a83eb 100644
> --- a/block/nvme.c
> +++ b/block/nvme.c
> @@ -590,31 +590,41 @@ out:
>      qemu_vfree(id);
>  }
>  
> +static bool nvme_poll_queue(NVMeQueuePair *q)
> +{
> +    bool progress = false;
> +
> +    const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
> +    NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
> +
> +    /*
> +     * Do an early check for completions. q->lock isn't needed because
> +     * nvme_process_completion() only runs in the event loop thread and
> +     * cannot race with itself.
> +     */
> +    if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
> +        return false;
> +    }
> +
> +    qemu_mutex_lock(&q->lock);
> +    while (nvme_process_completion(q)) {
> +        /* Keep polling */
> +        progress = true;
> +    }
> +    qemu_mutex_unlock(&q->lock);
> +
> +    return progress;
> +}
> +
>  static bool nvme_poll_queues(BDRVNVMeState *s)
>  {
>      bool progress = false;
>      int i;
>  
>      for (i = 0; i < s->nr_queues; i++) {
> -        NVMeQueuePair *q = s->queues[i];
> -        const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
> -        NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
> -
> -        /*
> -         * Do an early check for completions. q->lock isn't needed because
> -         * nvme_process_completion() only runs in the event loop thread and
> -         * cannot race with itself.
> -         */
> -        if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
> -            continue;
> -        }
> -
> -        qemu_mutex_lock(&q->lock);
> -        while (nvme_process_completion(q)) {
> -            /* Keep polling */
> +        if (nvme_poll_queue(s->queues[i])) {
>              progress = true;
>          }
> -        qemu_mutex_unlock(&q->lock);
>      }
>      return progress;
>  }
> -- 
> 2.26.2
> 
>