Series comparison

-[Qemu-devel] [PULL 0/5] Block patches
+[PULL for-6.1 0/3] Block patches
-The following changes since commit d147f7e815f97cb477e223586bcb80c316ae10ea:
+The following changes since commit 3521ade3510eb5cefb2e27a101667f25dad89935:
-  Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging (2017-10-03 16:27:24 +0100)
+  Merge remote-tracking branch 'remotes/thuth-gitlab/tags/pull-request-2021-07-29' into staging (2021-07-29 13:17:20 +0100)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to f708a5e71cba0d784e307334c07ade5f56f827ab:
+for you to fetch changes up to cc8eecd7f105a1dff5876adeb238a14696061a4a:
-  aio: fix assert when remove poll during destroy (2017-10-03 14:36:19 -0400)
+  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver (2021-07-29 17:17:34 +0100)
 ----------------------------------------------------------------
 Pull request
 The main fix here is for io_uring. Spurious -EAGAIN errors can happen and the
 request needs to be resubmitted.
 The MAINTAINERS changes carry no risk and we might as well include them in QEMU
 .1.
 ----------------------------------------------------------------
-----------------------------------------------------------------
+Fabian Ebner (1):
   block/io_uring: resubmit when result is -EAGAIN
-Peter Xu (4):
+Philippe Mathieu-Daudé (1):
-  qom: provide root container for internal objs
+  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver
   iothread: provide helpers for internal use
   iothread: export iothread_stop()
   iothread: delay the context release to finalize
-Stefan Hajnoczi (1):
+Stefano Garzarella (1):
-  aio: fix assert when remove poll during destroy
+  MAINTAINERS: add Stefano Garzarella as io_uring reviewer
- include/qom/object.h      | 11 +++++++++++
+ MAINTAINERS      |  2 ++
- include/sysemu/iothread.h |  9 +++++++++
+ block/io_uring.c | 16 +++++++++++++++-
- iothread.c                | 46 ++++++++++++++++++++++++++++++++++++----------
+files changed, 17 insertions(+), 1 deletion(-)
  qom/object.c              | 11 +++++++++++
  util/aio-posix.c          |  9 ++++++++-
 files changed, 75 insertions(+), 11 deletions(-)
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL 1/5] qom: provide root container for internal objs
+Deleted patch
-From: Peter Xu <peterx@redhat.com>
-We have object_get_objects_root() to keep user created objects, however
-no place for objects that will be used internally.  Create such a
-container for internal objects.
-CC: Andreas Färber <afaerber@suse.de>
-CC: Markus Armbruster <armbru@redhat.com>
-CC: Paolo Bonzini <pbonzini@redhat.com>
-Suggested-by: Daniel P. Berrange <berrange@redhat.com>
-Signed-off-by: Peter Xu <peterx@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Message-id: 20170928025958.1420-2-peterx@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- include/qom/object.h | 11 +++++++++++
- qom/object.c         | 11 +++++++++++
-files changed, 22 insertions(+)
-diff --git a/include/qom/object.h b/include/qom/object.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/qom/object.h
-+++ b/include/qom/object.h
-@@ -XXX,XX +XXX,XX @@ Object *object_get_root(void);
- Object *object_get_objects_root(void);
- /**
-+ * object_get_internal_root:
-+ *
-+ * Get the container object that holds internally used object
-+ * instances.  Any object which is put into this container must not be
-+ * user visible, and it will not be exposed in the QOM tree.
-+ *
-+ * Returns: the internal object container
-+ */
-+Object *object_get_internal_root(void);
-+
-+/**
-  * object_get_canonical_path_component:
-  *
-  * Returns: The final component in the object's canonical path.  The canonical
-diff --git a/qom/object.c b/qom/object.c
-index XXXXXXX..XXXXXXX 100644
---- a/qom/object.c
-+++ b/qom/object.c
-@@ -XXX,XX +XXX,XX @@ Object *object_get_objects_root(void)
-     return container_get(object_get_root(), "/objects");
- }
-+Object *object_get_internal_root(void)
-+{
-+    static Object *internal_root;
-+
-+    if (!internal_root) {
-+        internal_root = object_new("container");
-+    }
-+
-+    return internal_root;
-+}
-+
- static void object_get_child_property(Object *obj, Visitor *v,
-                                       const char *name, void *opaque,
-                                       Error **errp)
---
-.13.6

-[Qemu-devel] [PULL 2/5] iothread: provide helpers for internal use
+Deleted patch
-From: Peter Xu <peterx@redhat.com>
-IOThread is a general framework that contains IO loop environment and a
-real thread behind.  It's also good to be used internally inside qemu.
-Provide some helpers for it to create iothreads to be used internally.
-Put all the internal used iothreads into the internal object container.
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Peter Xu <peterx@redhat.com>
-Message-id: 20170928025958.1420-3-peterx@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- include/sysemu/iothread.h |  8 ++++++++
- iothread.c                | 16 ++++++++++++++++
-files changed, 24 insertions(+)
-diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/iothread.h
-+++ b/include/sysemu/iothread.h
-@@ -XXX,XX +XXX,XX @@ AioContext *iothread_get_aio_context(IOThread *iothread);
- void iothread_stop_all(void);
- GMainContext *iothread_get_g_main_context(IOThread *iothread);
-+/*
-+ * Helpers used to allocate iothreads for internal use.  These
-+ * iothreads will not be seen by monitor clients when query using
-+ * "query-iothreads".
-+ */
-+IOThread *iothread_create(const char *id, Error **errp);
-+void iothread_destroy(IOThread *iothread);
-+
- #endif /* IOTHREAD_H */
-diff --git a/iothread.c b/iothread.c
-index XXXXXXX..XXXXXXX 100644
---- a/iothread.c
-+++ b/iothread.c
-@@ -XXX,XX +XXX,XX @@ GMainContext *iothread_get_g_main_context(IOThread *iothread)
-     return iothread->worker_context;
- }
-+
-+IOThread *iothread_create(const char *id, Error **errp)
-+{
-+    Object *obj;
-+
-+    obj = object_new_with_props(TYPE_IOTHREAD,
-+                                object_get_internal_root(),
-+                                id, errp, NULL);
-+
-+    return IOTHREAD(obj);
-+}
-+
-+void iothread_destroy(IOThread *iothread)
-+{
-+    object_unparent(OBJECT(iothread));
-+}
---
-.13.6

-[Qemu-devel] [PULL 5/5] aio: fix assert when remove poll during destroy
+[PULL for-6.1 1/3] MAINTAINERS: add Stefano Garzarella as io_uring reviewer
-After iothread is enabled internally inside QEMU with GMainContext, we
+From: Stefano Garzarella <sgarzare@redhat.com>
 may encounter this warning when destroying the iothread:
-(qemu-system-x86_64:19925): GLib-CRITICAL **: g_source_remove_poll:
+I've been working with io_uring for a while so I'd like to help
- assertion '!SOURCE_DESTROYED (source)' failed
+with reviews.
-The problem is that g_source_remove_poll() does not allow to remove one
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-source from array if the source is detached from its owner
+Message-Id: <20210728131515.131045-1-sgarzare@redhat.com>
 context. (peterx: which IMHO does not make much sense)
 Fix it on QEMU side by avoid calling g_source_remove_poll() if we know
 the object is during destruction, and we won't leak anything after all
 since the array will be gone soon cleanly even with that fd.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Signed-off-by: Peter Xu <peterx@redhat.com>
 Message-id: 20170928025958.1420-6-peterx@redhat.com
 [peterx: write the commit message]
 Signed-off-by: Peter Xu <peterx@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/aio-posix.c | 9 ++++++++-
+ MAINTAINERS | 1 +
-file changed, 8 insertions(+), 1 deletion(-)
+file changed, 1 insertion(+)
-diff --git a/util/aio-posix.c b/util/aio-posix.c
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/util/aio-posix.c
+--- a/MAINTAINERS
-+++ b/util/aio-posix.c
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
+@@ -XXX,XX +XXX,XX @@ Linux io_uring
-             return;
+ M: Aarushi Mehta <mehta.aaru20@gmail.com>
-         }
+ M: Julia Suvorova <jusual@redhat.com>
+ M: Stefan Hajnoczi <stefanha@redhat.com>
--        g_source_remove_poll(&ctx->source, &node->pfd);
++R: Stefano Garzarella <sgarzare@redhat.com>
-+        /* If the GSource is in the process of being destroyed then
+ L: qemu-block@nongnu.org
-+         * g_source_remove_poll() causes an assertion failure.  Skip
+ S: Maintained
-+         * removal in that case, because glib cleans up its state during
+ F: block/io_uring.c
 +         * destruction anyway.
 +         */
 +        if (!g_source_is_destroyed(&ctx->source)) {
 +            g_source_remove_poll(&ctx->source, &node->pfd);
 +        }
          /* If the lock is held, just mark the node as deleted */
          if (qemu_lockcnt_count(&ctx->list_lock)) {
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL 4/5] iothread: delay the context release to finalize
+[PULL for-6.1 2/3] block/io_uring: resubmit when result is -EAGAIN
-From: Peter Xu <peterx@redhat.com>
+From: Fabian Ebner <f.ebner@proxmox.com>
-When gcontext is used with iothread, the context will be destroyed
+Linux SCSI can throw spurious -EAGAIN in some corner cases in its
-during iothread_stop().  That's not good since sometimes we would like
+completion path, which will end up being the result in the completed
-to keep the resources until iothread is destroyed, but we may want to
+io_uring request.
 stop the thread before that point.
-Delay the destruction of gcontext to iothread finalize.  Then we can do:
+Resubmitting such requests should allow block jobs to complete, even
 if such spurious errors are encountered.
-  iothread_stop(thread);
+Co-authored-by: Stefan Hajnoczi <stefanha@gmail.com>
-  some_cleanup_on_resources();
+Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
-  iothread_destroy(thread);
+Signed-off-by: Fabian Ebner <f.ebner@proxmox.com>
+Message-id: 20210729091029.65369-1-f.ebner@proxmox.com
 We may need this patch if we want to run chardev IOs in iothreads and
 hopefully clean them up correctly.  For more specific information,
 please see 2b316774f6 ("qemu-char: do not operate on sources from
 finalize callbacks").
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Peter Xu <peterx@redhat.com>
 Message-id: 20170928025958.1420-5-peterx@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- iothread.c | 6 ++++--
+ block/io_uring.c | 16 +++++++++++++++-
-file changed, 4 insertions(+), 2 deletions(-)
+file changed, 15 insertions(+), 1 deletion(-)
-diff --git a/iothread.c b/iothread.c
+diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
---- a/iothread.c
+--- a/block/io_uring.c
-+++ b/iothread.c
++++ b/block/io_uring.c
-@@ -XXX,XX +XXX,XX @@ static void *iothread_run(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static void luring_process_completions(LuringState *s)
-             g_main_loop_unref(loop);
+         total_bytes = ret + luringcb->total_read;
-             g_main_context_pop_thread_default(iothread->worker_context);
+         if (ret < 0) {
--            g_main_context_unref(iothread->worker_context);
+-            if (ret == -EINTR) {
--            iothread->worker_context = NULL;
++            /*
-         }
++             * Only writev/readv/fsync requests on regular files or host block
-     }
++             * devices are submitted. Therefore -EAGAIN is not expected but it's
++             * known to happen sometimes with Linux SCSI. Submit again and hope
-@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)
++             * the request completes successfully.
-     IOThread *iothread = IOTHREAD(obj);
++             *
++             * For more information, see:
-     iothread_stop(iothread);
++             * https://lore.kernel.org/io-uring/20210727165811.284510-3-axboe@kernel.dk/T/#u
-+    if (iothread->worker_context) {
++             *
-+        g_main_context_unref(iothread->worker_context);
++             * If the code is changed to submit other types of requests in the
-+        iothread->worker_context = NULL;
++             * future, then this workaround may need to be extended to deal with
-+    }
++             * genuine -EAGAIN results that should not be resubmitted
-     qemu_cond_destroy(&iothread->init_done_cond);
++             * immediately.
-     qemu_mutex_destroy(&iothread->init_done_lock);
++             */
-     if (!iothread->ctx) {
++            if (ret == -EINTR || ret == -EAGAIN) {
                  luring_resubmit(s, luringcb);
                  continue;
              }
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL 3/5] iothread: export iothread_stop()
+[PULL for-6.1 3/3] MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver
-From: Peter Xu <peterx@redhat.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-So that internal iothread users can explicitly stop one iothread without
+I'm interested in following the activity around the NVMe bdrv.
 destroying it.
-Since at it, fix iothread_stop() to allow it to be called multiple
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-times.  Before this patch we may call iothread_stop() more than once on
+Message-id: 20210728183340.2018313-1-philmd@redhat.com
 single iothread, while that may not be correct since qemu_thread_join()
 is not allowed to run twice.  From manual of pthread_join():
   Joining with a thread that has previously been joined results in
   undefined behavior.
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Peter Xu <peterx@redhat.com>
 Message-id: 20170928025958.1420-4-peterx@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/sysemu/iothread.h |  1 +
+ MAINTAINERS | 1 +
- iothread.c                | 24 ++++++++++++++++--------
+file changed, 1 insertion(+)
 files changed, 17 insertions(+), 8 deletions(-)
-diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/iothread.h
+--- a/MAINTAINERS
-+++ b/include/sysemu/iothread.h
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ GMainContext *iothread_get_g_main_context(IOThread *iothread);
+@@ -XXX,XX +XXX,XX @@ F: block/null.c
-  * "query-iothreads".
+ NVMe Block Driver
-  */
+ M: Stefan Hajnoczi <stefanha@redhat.com>
- IOThread *iothread_create(const char *id, Error **errp);
+ R: Fam Zheng <fam@euphon.net>
-+void iothread_stop(IOThread *iothread);
++R: Philippe Mathieu-Daudé <philmd@redhat.com>
- void iothread_destroy(IOThread *iothread);
+ L: qemu-block@nongnu.org
+ S: Supported
- #endif /* IOTHREAD_H */
+ F: block/nvme*
 diff --git a/iothread.c b/iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/iothread.c
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void *iothread_run(void *opaque)
      return NULL;
  }
 -static int iothread_stop(Object *object, void *opaque)
 +void iothread_stop(IOThread *iothread)
  {
 -    IOThread *iothread;
 -
 -    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
 -    if (!iothread || !iothread->ctx || iothread->stopping) {
 -        return 0;
 +    if (!iothread->ctx || iothread->stopping) {
 +        return;
      }
      iothread->stopping = true;
      aio_notify(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static int iothread_stop(Object *object, void *opaque)
          g_main_loop_quit(iothread->main_loop);
      }
      qemu_thread_join(&iothread->thread);
 +}
 +
 +static int iothread_stop_iter(Object *object, void *opaque)
 +{
 +    IOThread *iothread;
 +
 +    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
 +    if (!iothread) {
 +        return 0;
 +    }
 +    iothread_stop(iothread);
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)
  {
      IOThread *iothread = IOTHREAD(obj);
 -    iothread_stop(obj, NULL);
 +    iothread_stop(iothread);
      qemu_cond_destroy(&iothread->init_done_cond);
      qemu_mutex_destroy(&iothread->init_done_lock);
      if (!iothread->ctx) {
@@ -XXX,XX +XXX,XX @@ void iothread_stop_all(void)
          aio_context_release(ctx);
      }
 -    object_child_foreach(container, iothread_stop, NULL);
 +    object_child_foreach(container, iothread_stop_iter, NULL);
  }
  static gpointer iothread_g_main_context_init(gpointer opaque)
 --
-.13.6
+.31.1

The following changes since commit d147f7e815f97cb477e223586bcb80c316ae10ea:

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging (2017-10-03 16:27:24 +0100)

are available in the git repository at:

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to f708a5e71cba0d784e307334c07ade5f56f827ab:

aio: fix assert when remove poll during destroy (2017-10-03 14:36:19 -0400)

----------------------------------------------------------------

Peter Xu (4):
  qom: provide root container for internal objs
  iothread: provide helpers for internal use
  iothread: export iothread_stop()
  iothread: delay the context release to finalize

Stefan Hajnoczi (1):
  aio: fix assert when remove poll during destroy

-- 
2.13.6

From: Peter Xu <peterx@redhat.com>

We have object_get_objects_root() to keep user created objects, however
no place for objects that will be used internally.  Create such a
container for internal objects.

CC: Andreas Färber <afaerber@suse.de>
CC: Markus Armbruster <armbru@redhat.com>
CC: Paolo Bonzini <pbonzini@redhat.com>
Suggested-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170928025958.1420-2-peterx@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qom/object.h | 11 +++++++++++
 qom/object.c         | 11 +++++++++++
 2 files changed, 22 insertions(+)

diff --git a/include/qom/object.h b/include/qom/object.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object.h
+++ b/include/qom/object.h
@@ -XXX,XX +XXX,XX @@ Object *object_get_root(void);
 Object *object_get_objects_root(void);
 
 /**
+ * object_get_internal_root:
+ *
+ * Get the container object that holds internally used object
+ * instances.  Any object which is put into this container must not be
+ * user visible, and it will not be exposed in the QOM tree.
+ *
+ * Returns: the internal object container
+ */
+Object *object_get_internal_root(void);
+
+/**
  * object_get_canonical_path_component:
  *
  * Returns: The final component in the object's canonical path.  The canonical
diff --git a/qom/object.c b/qom/object.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object.c
+++ b/qom/object.c
@@ -XXX,XX +XXX,XX @@ Object *object_get_objects_root(void)
     return container_get(object_get_root(), "/objects");
 }
 
+Object *object_get_internal_root(void)
+{
+    static Object *internal_root;
+
+    if (!internal_root) {
+        internal_root = object_new("container");
+    }
+
+    return internal_root;
+}
+
 static void object_get_child_property(Object *obj, Visitor *v,
                                       const char *name, void *opaque,
                                       Error **errp)
-- 
2.13.6

From: Peter Xu <peterx@redhat.com>

IOThread is a general framework that contains IO loop environment and a
real thread behind.  It's also good to be used internally inside qemu.
Provide some helpers for it to create iothreads to be used internally.

Put all the internal used iothreads into the internal object container.

Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-id: 20170928025958.1420-3-peterx@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/sysemu/iothread.h |  8 ++++++++
 iothread.c                | 16 ++++++++++++++++
 2 files changed, 24 insertions(+)

From: Peter Xu <peterx@redhat.com>

So that internal iothread users can explicitly stop one iothread without
destroying it.

Since at it, fix iothread_stop() to allow it to be called multiple
times.  Before this patch we may call iothread_stop() more than once on
single iothread, while that may not be correct since qemu_thread_join()
is not allowed to run twice.  From manual of pthread_join():

Joining with a thread that has previously been joined results in
  undefined behavior.

Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-id: 20170928025958.1420-4-peterx@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/sysemu/iothread.h |  1 +
 iothread.c                | 24 ++++++++++++++++--------
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/iothread.h
+++ b/include/sysemu/iothread.h
@@ -XXX,XX +XXX,XX @@ GMainContext *iothread_get_g_main_context(IOThread *iothread);
  * "query-iothreads".
  */
 IOThread *iothread_create(const char *id, Error **errp);
+void iothread_stop(IOThread *iothread);
 void iothread_destroy(IOThread *iothread);
 
 #endif /* IOTHREAD_H */
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void *iothread_run(void *opaque)
     return NULL;
 }
 
-static int iothread_stop(Object *object, void *opaque)
+void iothread_stop(IOThread *iothread)
 {
-    IOThread *iothread;
-
-    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
-    if (!iothread || !iothread->ctx || iothread->stopping) {
-        return 0;
+    if (!iothread->ctx || iothread->stopping) {
+        return;
     }
     iothread->stopping = true;
     aio_notify(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static int iothread_stop(Object *object, void *opaque)
         g_main_loop_quit(iothread->main_loop);
     }
     qemu_thread_join(&iothread->thread);
+}
+
+static int iothread_stop_iter(Object *object, void *opaque)
+{
+    IOThread *iothread;
+
+    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
+    if (!iothread) {
+        return 0;
+    }
+    iothread_stop(iothread);
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)
 {
     IOThread *iothread = IOTHREAD(obj);
 
-    iothread_stop(obj, NULL);
+    iothread_stop(iothread);
     qemu_cond_destroy(&iothread->init_done_cond);
     qemu_mutex_destroy(&iothread->init_done_lock);
     if (!iothread->ctx) {
@@ -XXX,XX +XXX,XX @@ void iothread_stop_all(void)
         aio_context_release(ctx);
     }
 
-    object_child_foreach(container, iothread_stop, NULL);
+    object_child_foreach(container, iothread_stop_iter, NULL);
 }
 
 static gpointer iothread_g_main_context_init(gpointer opaque)
-- 
2.13.6

From: Peter Xu <peterx@redhat.com>

When gcontext is used with iothread, the context will be destroyed
during iothread_stop().  That's not good since sometimes we would like
to keep the resources until iothread is destroyed, but we may want to
stop the thread before that point.

Delay the destruction of gcontext to iothread finalize.  Then we can do:

iothread_stop(thread);
  some_cleanup_on_resources();
  iothread_destroy(thread);

We may need this patch if we want to run chardev IOs in iothreads and
hopefully clean them up correctly.  For more specific information,
please see 2b316774f6 ("qemu-char: do not operate on sources from
finalize callbacks").

Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-id: 20170928025958.1420-5-peterx@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 iothread.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void *iothread_run(void *opaque)
             g_main_loop_unref(loop);
 
             g_main_context_pop_thread_default(iothread->worker_context);
-            g_main_context_unref(iothread->worker_context);
-            iothread->worker_context = NULL;
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static void iothread_instance_finalize(Object *obj)
     IOThread *iothread = IOTHREAD(obj);
 
     iothread_stop(iothread);
+    if (iothread->worker_context) {
+        g_main_context_unref(iothread->worker_context);
+        iothread->worker_context = NULL;
+    }
     qemu_cond_destroy(&iothread->init_done_cond);
     qemu_mutex_destroy(&iothread->init_done_lock);
     if (!iothread->ctx) {
-- 
2.13.6

After iothread is enabled internally inside QEMU with GMainContext, we
may encounter this warning when destroying the iothread:

(qemu-system-x86_64:19925): GLib-CRITICAL **: g_source_remove_poll:
 assertion '!SOURCE_DESTROYED (source)' failed

The problem is that g_source_remove_poll() does not allow to remove one
source from array if the source is detached from its owner
context. (peterx: which IMHO does not make much sense)

Fix it on QEMU side by avoid calling g_source_remove_poll() if we know
the object is during destruction, and we won't leak anything after all
since the array will be gone soon cleanly even with that fd.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Peter Xu <peterx@redhat.com>
Message-id: 20170928025958.1420-6-peterx@redhat.com
[peterx: write the commit message]
Signed-off-by: Peter Xu <peterx@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/aio-posix.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
             return;
         }
 
-        g_source_remove_poll(&ctx->source, &node->pfd);
+        /* If the GSource is in the process of being destroyed then
+         * g_source_remove_poll() causes an assertion failure.  Skip
+         * removal in that case, because glib cleans up its state during
+         * destruction anyway.
+         */
+        if (!g_source_is_destroyed(&ctx->source)) {
+            g_source_remove_poll(&ctx->source, &node->pfd);
+        }
 
         /* If the lock is held, just mark the node as deleted */
         if (qemu_lockcnt_count(&ctx->list_lock)) {
-- 
2.13.6

The following changes since commit 3521ade3510eb5cefb2e27a101667f25dad89935:

Merge remote-tracking branch 'remotes/thuth-gitlab/tags/pull-request-2021-07-29' into staging (2021-07-29 13:17:20 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to cc8eecd7f105a1dff5876adeb238a14696061a4a:

MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver (2021-07-29 17:17:34 +0100)

----------------------------------------------------------------
Pull request

The main fix here is for io_uring. Spurious -EAGAIN errors can happen and the
request needs to be resubmitted.

The MAINTAINERS changes carry no risk and we might as well include them in QEMU
6.1.

----------------------------------------------------------------

Fabian Ebner (1):
  block/io_uring: resubmit when result is -EAGAIN

Philippe Mathieu-Daudé (1):
  MAINTAINERS: Added myself as a reviewer for the NVMe Block Driver

Stefano Garzarella (1):
  MAINTAINERS: add Stefano Garzarella as io_uring reviewer

MAINTAINERS      |  2 ++
 block/io_uring.c | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 1 deletion(-)

-- 
2.31.1

From: Fabian Ebner <f.ebner@proxmox.com>

Linux SCSI can throw spurious -EAGAIN in some corner cases in its
completion path, which will end up being the result in the completed
io_uring request.

Resubmitting such requests should allow block jobs to complete, even
if such spurious errors are encountered.

Co-authored-by: Stefan Hajnoczi <stefanha@gmail.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Fabian Ebner <f.ebner@proxmox.com>
Message-id: 20210729091029.65369-1-f.ebner@proxmox.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io_uring.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@ static void luring_process_completions(LuringState *s)
         total_bytes = ret + luringcb->total_read;
 
         if (ret < 0) {
-            if (ret == -EINTR) {
+            /*
+             * Only writev/readv/fsync requests on regular files or host block
+             * devices are submitted. Therefore -EAGAIN is not expected but it's
+             * known to happen sometimes with Linux SCSI. Submit again and hope
+             * the request completes successfully.
+             *
+             * For more information, see:
+             * https://lore.kernel.org/io-uring/20210727165811.284510-3-axboe@kernel.dk/T/#u
+             *
+             * If the code is changed to submit other types of requests in the
+             * future, then this workaround may need to be extended to deal with
+             * genuine -EAGAIN results that should not be resubmitted
+             * immediately.
+             */
+            if (ret == -EINTR || ret == -EAGAIN) {
                 luring_resubmit(s, luringcb);
                 continue;
             }
-- 
2.31.1