Re: [Qemu-devel] [PATCH 08/17] aio: add non-blocking variant of aio_wait

[Anthony Liguori]

Paolo Bonzini <address@hidden> writes:

> This will be used when polling the GSource attached to an AioContext.
>
> Signed-off-by: Paolo Bonzini <address@hidden>

Reviewed-by: Anthony Liguori <address@hidden>

Regards,

Anthony Liguori

> ---
>  aio.c       | 16 ++++++++++++----
>  async.c     |  2 +-
>  main-loop.c |  2 +-
>  qemu-aio.h  | 21 +++++++++++++++------
>  4 file modificati, 29 inserzioni(+), 12 rimozioni(-)
>
> diff --git a/aio.c b/aio.c
> index c89f1e9..95ad467 100644
> --- a/aio.c
> +++ b/aio.c
> @@ -93,13 +93,16 @@ void aio_set_event_notifier(AioContext *ctx,
>                         (AioFlushHandler *)io_flush, notifier);
>  }
>  
> -bool aio_wait(AioContext *ctx)
> +bool aio_poll(AioContext *ctx, bool blocking)
>  {
> +    static struct timeval tv0;
>      AioHandler *node;
>      fd_set rdfds, wrfds;
>      int max_fd = -1;
>      int ret;
> -    bool busy;
> +    bool busy, progress;
> +
> +    progress = false;
>  
>      /*
>       * If there are callbacks left that have been queued, we need to call 
> then.
> @@ -107,6 +110,11 @@ bool aio_wait(AioContext *ctx)
>       * does not need a complete flush (as is the case for qemu_aio_wait 
> loops).
>       */
>      if (aio_bh_poll(ctx)) {
> +        blocking = false;
> +        progress = true;
> +    }
> +
> +    if (progress && !blocking) {
>          return true;
>      }
>  
> @@ -142,11 +150,11 @@ bool aio_wait(AioContext *ctx)
>  
>      /* No AIO operations?  Get us out of here */
>      if (!busy) {
> -        return false;
> +        return progress;
>      }
>  
>      /* wait until next event */
> -    ret = select(max_fd, &rdfds, &wrfds, NULL, NULL);
> +    ret = select(max_fd, &rdfds, &wrfds, NULL, blocking ? NULL : &tv0);
>  
>      /* if we have any readable fds, dispatch event */
>      if (ret > 0) {
> diff --git a/async.c b/async.c
> index c99db79..513bdd7 100644
> --- a/async.c
> +++ b/async.c
> @@ -144,5 +144,5 @@ AioContext *aio_context_new(void)
>  
>  void aio_flush(AioContext *ctx)
>  {
> -    while (aio_wait(ctx));
> +    while (aio_poll(ctx, true));
>  }
> diff --git a/main-loop.c b/main-loop.c
> index 8301fe9..67800fe 100644
> --- a/main-loop.c
> +++ b/main-loop.c
> @@ -531,7 +531,7 @@ void qemu_aio_flush(void)
>  
>  bool qemu_aio_wait(void)
>  {
> -    return aio_wait(qemu_aio_context);
> +    return aio_poll(qemu_aio_context, true);
>  }
>  
>  void qemu_aio_set_fd_handler(int fd,
> diff --git a/qemu-aio.h b/qemu-aio.h
> index f8a93d8..f19201e 100644
> --- a/qemu-aio.h
> +++ b/qemu-aio.h
> @@ -133,13 +133,22 @@ void qemu_bh_delete(QEMUBH *bh);
>   * outstanding AIO operations have been completed or cancelled. */
>  void aio_flush(AioContext *ctx);
>  
> -/* Wait for a single AIO completion to occur.  This function will wait
> - * until a single AIO event has completed and it will ensure something
> - * has moved before returning. This can issue new pending aio as
> - * result of executing I/O completion or bh callbacks.
> +/* Progress in completing AIO work to occur.  This can issue new pending
> + * aio as a result of executing I/O completion or bh callbacks.
>   *
> - * Return whether there is still any pending AIO operation.  */
> -bool aio_wait(AioContext *ctx);
> + * If there is no pending AIO operation or completion (bottom half),
> + * return false.  If there are pending bottom halves, return true.
> + *
> + * If there are no pending bottom halves, but there are pending AIO
> + * operations, it may not be possible to make any progress without
> + * blocking.  If @blocking is true, this function will wait until one
> + * or more AIO events have completed, to ensure something has moved
> + * before returning.
> + *
> + * If @blocking is false, this function will also return false if the
> + * function cannot make any progress without blocking.
> + */
> +bool aio_poll(AioContext *ctx, bool blocking);
>  
>  #ifdef CONFIG_POSIX
>  /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
> -- 
> 1.7.12