Series comparison

-[Qemu-devel] [PULL 0/9] Block patches
+[PULL 0/3] Block patches
-The following changes since commit a1cf5fac2b929ffa2abd1285401f2535ff8c6fea:
+The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-block-2017-02-21' into staging (2017-02-21 13:58:50 +0000)
+  Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)
-are available in the git repository at:
+are available in the Git repository at:
-  git@github.com:codyprime/qemu-kvm-jtc.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 6135c5e12606b8413708384e3e7d43f6010c5941:
+for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:
-  qemu-options: Fix broken sheepdog URL (2017-02-21 10:38:09 -0500)
+  util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)
 ----------------------------------------------------------------
-Block patches
+Pull request
 Add new thread-pool-min/thread-pool-max parameters to control the thread pool
 used for async I/O.
 ----------------------------------------------------------------
-Anton Nefedov (1):
+Nicolas Saenz Julienne (3):
-  mirror: do not increase offset during initial zero_or_discard phase
+  Introduce event-loop-base abstract class
   util/main-loop: Introduce the main loop into QOM
   util/event-loop-base: Introduce options to set the thread pool size
-Jeff Cody (1):
+ qapi/qom.json                    |  43 ++++++++--
-  QAPI: Fix blockdev-add example documentation
+ meson.build                      |  26 +++---
+ include/block/aio.h              |  10 +++
-Kevin Wolf (6):
+ include/block/thread-pool.h      |   3 +
-  iscsi: Split URL into individual options
+ include/qemu/main-loop.h         |  10 +++
-  iscsi: Handle -iscsi user/password in bdrv_parse_filename()
+ include/sysemu/event-loop-base.h |  41 +++++++++
-  iscsi: Add initiator-name option
+ include/sysemu/iothread.h        |   6 +-
-  iscsi: Add header-digest option
+ event-loop-base.c                | 140 +++++++++++++++++++++++++++++++
-  iscsi: Add timeout option
+ iothread.c                       |  68 +++++----------
-  iscsi: Add blockdev-add support
+ util/aio-posix.c                 |   1 +
+ util/async.c                     |  20 +++++
-Thomas Huth (1):
+ util/main-loop.c                 |  65 ++++++++++++++
-  qemu-options: Fix broken sheepdog URL
+ util/thread-pool.c               |  55 +++++++++++-
+files changed, 419 insertions(+), 69 deletions(-)
- block/iscsi.c        | 353 +++++++++++++++++++++++++++++++--------------------
+ create mode 100644 include/sysemu/event-loop-base.h
- block/mirror.c       |   9 +-
+ create mode 100644 event-loop-base.c
  qapi/block-core.json | 125 +++++++++++++-----
  qemu-options.hx      |   2 +-
 files changed, 317 insertions(+), 172 deletions(-)
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 4/9] iscsi: Add header-digest option
+[PULL 1/3] Introduce event-loop-base abstract class
-From: Kevin Wolf <kwolf@redhat.com>
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-This was previously only available with -iscsi. Again, after this patch,
+Introduce the 'event-loop-base' abstract class, it'll hold the
-the -iscsi option only takes effect if an URL is given. New users are
+properties common to all event loops and provide the necessary hooks for
-supposed to use the new driver-specific option.
+their creation and maintenance. Then have iothread inherit from it.
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+EventLoopBaseClass is defined as user creatable and provides a hook for
-Reviewed-by: Fam Zheng <famz@redhat.com>
+its children to attach themselves to the user creatable class 'complete'
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+function. It also provides an update_params() callback to propagate
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+property changes onto its children.
 The new 'event-loop-base' class will live in the root directory. It is
 built on its own using the 'link_whole' option (there are no direct
 function dependencies between the class and its children, it all happens
 trough 'constructor' magic). And also imposes new compilation
 dependencies:
     qom <- event-loop-base <- blockdev (iothread.c)
 And in subsequent patches:
     qom <- event-loop-base <- qemuutil (util/main-loop.c)
 All this forced some amount of reordering in meson.build:
  - Moved qom build definition before qemuutil. Doing it the other way
    around (i.e. moving qemuutil after qom) isn't possible as a lot of
    core libraries that live in between the two depend on it.
  - Process the 'hw' subdir earlier, as it introduces files into the
    'qom' source set.
 No functional changes intended.
 Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/iscsi.c | 39 +++++++++++++++------------------------
+ qapi/qom.json                    |  22 +++++--
-file changed, 15 insertions(+), 24 deletions(-)
+ meson.build                      |  23 ++++---
+ include/sysemu/event-loop-base.h |  36 +++++++++++
-diff --git a/block/iscsi.c b/block/iscsi.c
+ include/sysemu/iothread.h        |   6 +-
  event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
  iothread.c                       |  65 ++++++-------------
 files changed, 192 insertions(+), 64 deletions(-)
  create mode 100644 include/sysemu/event-loop-base.h
  create mode 100644 event-loop-base.c
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+--- a/qapi/qom.json
-+++ b/block/iscsi.c
++++ b/qapi/qom.json
-@@ -XXX,XX +XXX,XX @@ static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
+@@ -XXX,XX +XXX,XX @@
-     g_free(secret);
+             '*repeat': 'bool',
              '*grab-toggle': 'GrabToggleKeys' } }
 +##
 +# @EventLoopBaseProperties:
 +#
 +# Common properties for event loops
 +#
 +# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
 +#                 0 means that the engine will use its default.
 +#                 (default: 0)
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'EventLoopBaseProperties',
 +  'data': { '*aio-max-batch': 'int' } }
 +
  ##
  # @IothreadProperties:
  #
@@ -XXX,XX +XXX,XX @@
  #               algorithm detects it is spending too long polling without
  #               encountering events. 0 selects a default behaviour (default: 0)
  #
 -# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
 -#                 0 means that the engine will use its default
 -#                 (default:0, since 6.1)
 +# The @aio-max-batch option is available since 6.1.
  #
  # Since: 2.0
  ##
  { 'struct': 'IothreadProperties',
 +  'base': 'EventLoopBaseProperties',
    'data': { '*poll-max-ns': 'int',
              '*poll-grow': 'int',
 -            '*poll-shrink': 'int',
 -            '*aio-max-batch': 'int' } }
 +            '*poll-shrink': 'int' } }
  ##
  # @MemoryBackendProperties:
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/meson.build
 +++ b/meson.build
@@ -XXX,XX +XXX,XX @@ subdir('qom')
  subdir('authz')
  subdir('crypto')
  subdir('ui')
 +subdir('hw')
  if enable_modules
@@ -XXX,XX +XXX,XX @@ if enable_modules
    modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
  endif
 +qom_ss = qom_ss.apply(config_host, strict: false)
 +libqom = static_library('qom', qom_ss.sources() + genh,
 +                        dependencies: [qom_ss.dependencies()],
 +                        name_suffix: 'fa')
 +qom = declare_dependency(link_whole: libqom)
 +
 +event_loop_base = files('event-loop-base.c')
 +event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
 +                                 build_by_default: true)
 +event_loop_base = declare_dependency(link_whole: event_loop_base,
 +                                     dependencies: [qom])
 +
  stub_ss = stub_ss.apply(config_all, strict: false)
  util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
  subdir('net')
  subdir('replay')
  subdir('semihosting')
 -subdir('hw')
  subdir('tcg')
  subdir('fpu')
  subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                               capture: true,
                               command: [undefsym, nm, '@INPUT@'])
 -qom_ss = qom_ss.apply(config_host, strict: false)
 -libqom = static_library('qom', qom_ss.sources() + genh,
 -                        dependencies: [qom_ss.dependencies()],
 -                        name_suffix: 'fa')
 -
 -qom = declare_dependency(link_whole: libqom)
 -
  authz_ss = authz_ss.apply(config_host, strict: false)
  libauthz = static_library('authz', authz_ss.sources() + genh,
                            dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                               build_by_default: false)
  blockdev = declare_dependency(link_whole: [libblockdev],
 -                              dependencies: [block])
 +                              dependencies: [block, event_loop_base])
  qmp_ss = qmp_ss.apply(config_host, strict: false)
  libqmp = static_library('qmp', qmp_ss.sources() + genh,
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QEMU event-loop backend
 + *
 + * Copyright (C) 2022 Red Hat Inc
 + *
 + * Authors:
 + *  Nicolas Saenz Julienne <nsaenzju@redhat.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +#ifndef QEMU_EVENT_LOOP_BASE_H
 +#define QEMU_EVENT_LOOP_BASE_H
 +
 +#include "qom/object.h"
 +#include "block/aio.h"
 +#include "qemu/typedefs.h"
 +
 +#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
 +OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
 +                    EVENT_LOOP_BASE)
 +
 +struct EventLoopBaseClass {
 +    ObjectClass parent_class;
 +
 +    void (*init)(EventLoopBase *base, Error **errp);
 +    void (*update_params)(EventLoopBase *base, Error **errp);
 +};
 +
 +struct EventLoopBase {
 +    Object parent;
 +
 +    /* AioContext AIO engine parameters */
 +    int64_t aio_max_batch;
 +};
 +#endif
 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 @@
  #include "block/aio.h"
  #include "qemu/thread.h"
  #include "qom/object.h"
 +#include "sysemu/event-loop-base.h"
  #define TYPE_IOTHREAD "iothread"
  struct IOThread {
 -    Object parent_obj;
 +    EventLoopBase parent_obj;
      QemuThread thread;
      AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ struct IOThread {
      int64_t poll_max_ns;
      int64_t poll_grow;
      int64_t poll_shrink;
 -
 -    /* AioContext AIO engine parameters */
 -    int64_t aio_max_batch;
  };
  typedef struct IOThread IOThread;
 diff --git a/event-loop-base.c b/event-loop-base.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QEMU event-loop base
 + *
 + * Copyright (C) 2022 Red Hat Inc
 + *
 + * Authors:
 + *  Stefan Hajnoczi <stefanha@redhat.com>
 + *  Nicolas Saenz Julienne <nsaenzju@redhat.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qom/object_interfaces.h"
 +#include "qapi/error.h"
 +#include "sysemu/event-loop-base.h"
 +
 +typedef struct {
 +    const char *name;
 +    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
 +} EventLoopBaseParamInfo;
 +
 +static EventLoopBaseParamInfo aio_max_batch_info = {
 +    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
 +};
 +
 +static void event_loop_base_get_param(Object *obj, Visitor *v,
 +        const char *name, void *opaque, Error **errp)
 +{
 +    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
 +    EventLoopBaseParamInfo *info = opaque;
 +    int64_t *field = (void *)event_loop_base + info->offset;
 +
 +    visit_type_int64(v, name, field, errp);
 +}
 +
 +static void event_loop_base_set_param(Object *obj, Visitor *v,
 +        const char *name, void *opaque, Error **errp)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
 +    EventLoopBase *base = EVENT_LOOP_BASE(obj);
 +    EventLoopBaseParamInfo *info = opaque;
 +    int64_t *field = (void *)base + info->offset;
 +    int64_t value;
 +
 +    if (!visit_type_int64(v, name, &value, errp)) {
 +        return;
 +    }
 +
 +    if (value < 0) {
 +        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
 +                   info->name, INT64_MAX);
 +        return;
 +    }
 +
 +    *field = value;
 +
 +    if (bc->update_params) {
 +        bc->update_params(base, errp);
 +    }
 +
 +    return;
 +}
 +
 +static void event_loop_base_complete(UserCreatable *uc, Error **errp)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
 +    EventLoopBase *base = EVENT_LOOP_BASE(uc);
 +
 +    if (bc->init) {
 +        bc->init(base, errp);
 +    }
 +}
 +
 +static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 +{
 +    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
 +    ucc->complete = event_loop_base_complete;
 +
 +    object_class_property_add(klass, "aio-max-batch", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &aio_max_batch_info);
 +}
 +
 +static const TypeInfo event_loop_base_info = {
 +    .name = TYPE_EVENT_LOOP_BASE,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(EventLoopBase),
 +    .class_size = sizeof(EventLoopBaseClass),
 +    .class_init = event_loop_base_class_init,
 +    .abstract = true,
 +    .interfaces = (InterfaceInfo[]) {
 +        { TYPE_USER_CREATABLE },
 +        { }
 +    }
 +};
 +
 +static void register_types(void)
 +{
 +    type_register_static(&event_loop_base_info);
 +}
 +type_init(register_types);
 diff --git a/iothread.c b/iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/iothread.c
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/module.h"
  #include "block/aio.h"
  #include "block/block.h"
 +#include "sysemu/event-loop-base.h"
  #include "sysemu/iothread.h"
  #include "qapi/error.h"
  #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
      iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
  }
--static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
+-static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
-+static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
++static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
                                  Error **errp)
  {
--    QemuOptsList *list;
++    IOThread *iothread = IOTHREAD(base);
--    QemuOpts *opts;
+     ERRP_GUARD();
-     const char *digest = NULL;
++    if (!iothread->ctx) {
--    list = qemu_find_opts("iscsi");
++        return;
--    if (!list) {
++    }
 +
      aio_context_set_poll_params(iothread->ctx,
                                  iothread->poll_max_ns,
                                  iothread->poll_grow,
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
      }
      aio_context_set_aio_params(iothread->ctx,
 -                               iothread->aio_max_batch,
 +                               iothread->parent_obj.aio_max_batch,
                                 errp);
  }
 -static void iothread_complete(UserCreatable *obj, Error **errp)
 +
 +static void iothread_init(EventLoopBase *base, Error **errp)
  {
      Error *local_error = NULL;
 -    IOThread *iothread = IOTHREAD(obj);
 +    IOThread *iothread = IOTHREAD(base);
      char *thread_name;
      iothread->stopping = false;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
       */
      iothread_init_gcontext(iothread);
 -    iothread_set_aio_context_params(iothread, &local_error);
 +    iothread_set_aio_context_params(base, &local_error);
      if (local_error) {
          error_propagate(errp, local_error);
          aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
       * to inherit.
       */
      thread_name = g_strdup_printf("IO %s",
 -                        object_get_canonical_path_component(OBJECT(obj)));
 +                        object_get_canonical_path_component(OBJECT(base)));
      qemu_thread_create(&iothread->thread, thread_name, iothread_run,
                         iothread, QEMU_THREAD_JOINABLE);
      g_free(thread_name);
@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
  static IOThreadParamInfo poll_shrink_info = {
      "poll-shrink", offsetof(IOThread, poll_shrink),
  };
 -static IOThreadParamInfo aio_max_batch_info = {
 -    "aio-max-batch", offsetof(IOThread, aio_max_batch),
 -};
  static void iothread_get_param(Object *obj, Visitor *v,
          const char *name, IOThreadParamInfo *info, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
      }
  }
 -static void iothread_get_aio_param(Object *obj, Visitor *v,
 -        const char *name, void *opaque, Error **errp)
 -{
 -    IOThreadParamInfo *info = opaque;
 -
 -    iothread_get_param(obj, v, name, info, errp);
 -}
 -
 -static void iothread_set_aio_param(Object *obj, Visitor *v,
 -        const char *name, void *opaque, Error **errp)
 -{
 -    IOThread *iothread = IOTHREAD(obj);
 -    IOThreadParamInfo *info = opaque;
 -
 -    if (!iothread_set_param(obj, v, name, info, errp)) {
 -        return;
 -    }
 -
--    opts = qemu_opts_find(list, target);
+-    if (iothread->ctx) {
--    if (opts == NULL) {
+-        aio_context_set_aio_params(iothread->ctx,
--        opts = QTAILQ_FIRST(&list->head);
+-                                   iothread->aio_max_batch,
--        if (!opts) {
+-                                   errp);
 -            return;
 -        }
 -    }
--
+-}
-     digest = qemu_opt_get(opts, "header-digest");
+-
-     if (!digest) {
+ static void iothread_class_init(ObjectClass *klass, void *class_data)
 -        return;
 -    }
 -
 -    if (!strcmp(digest, "CRC32C")) {
 +        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
 +    } else if (!strcmp(digest, "CRC32C")) {
          iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
      } else if (!strcmp(digest, "NONE")) {
          iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
  {
-     QemuOptsList *list;
+-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-     QemuOpts *opts;
+-    ucc->complete = iothread_complete;
--    const char *user, *password, *password_secret, *initiator_name;
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
-+    const char *user, *password, *password_secret, *initiator_name,
++
-+               *header_digest;
++    bc->init = iothread_init;
++    bc->update_params = iothread_set_aio_context_params;
-     list = qemu_find_opts("iscsi");
-     if (!list) {
+     object_class_property_add(klass, "poll-max-ns", "int",
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
+                               iothread_get_poll_param,
-     if (initiator_name) {
+@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
-         qdict_set_default_str(options, "initiator-name", initiator_name);
+                               iothread_get_poll_param,
-     }
+                               iothread_set_poll_param,
-+
+                               NULL, &poll_shrink_info);
-+    header_digest = qemu_opt_get(opts, "header-digest");
+-    object_class_property_add(klass, "aio-max-batch", "int",
-+    if (header_digest) {
+-                              iothread_get_aio_param,
-+        qdict_set_default_str(options, "header-digest", header_digest);
+-                              iothread_set_aio_param,
-+    }
+-                              NULL, &aio_max_batch_info);
  }
- /*
+ static const TypeInfo iothread_info = {
-@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
+     .name = TYPE_IOTHREAD,
-             .name = "initiator-name",
+-    .parent = TYPE_OBJECT,
-             .type = QEMU_OPT_STRING,
++    .parent = TYPE_EVENT_LOOP_BASE,
-         },
+     .class_init = iothread_class_init,
-+        {
+     .instance_size = sizeof(IOThread),
-+            .name = "header-digest",
+     .instance_init = iothread_instance_init,
-+            .type = QEMU_OPT_STRING,
+     .instance_finalize = iothread_instance_finalize,
-+        },
+-    .interfaces = (InterfaceInfo[]) {
-         { /* end of list */ }
+-        {TYPE_USER_CREATABLE},
-     },
+-        {}
 -    },
  };
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
-         goto out;
+ static void iothread_register_types(void)
-     }
+@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
+     info->poll_max_ns = iothread->poll_max_ns;
--    iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
+     info->poll_grow = iothread->poll_grow;
--
+     info->poll_shrink = iothread->poll_shrink;
-     /* check if we got HEADER_DIGEST via the options */
+-    info->aio_max_batch = iothread->aio_max_batch;
--    parse_header_digest(iscsi, target, &local_err);
++    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
-+    apply_header_digest(iscsi, opts, &local_err);
-     if (local_err != NULL) {
+     QAPI_LIST_APPEND(*tail, info);
-         error_propagate(errp, local_err);
+     return 0;
          ret = -EINVAL;
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 1/9] iscsi: Split URL into individual options
+[PULL 2/3] util/main-loop: Introduce the main loop into QOM
-From: Kevin Wolf <kwolf@redhat.com>
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-This introduces a .bdrv_parse_filename handler for iscsi which parses an
+'event-loop-base' provides basic property handling for all 'AioContext'
-URL if given and translates it to individual options.
+based event loops. So let's define a new 'MainLoopClass' that inherits
+from it. This will permit tweaking the main loop's properties through
-Reviewed-by: Fam Zheng <famz@redhat.com>
+qapi as well as through the command line using the '-object' keyword[1].
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Only one instance of 'MainLoopClass' might be created at any time.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
 'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
 mark 'MainLoop' as non-deletable.
 [1] For example:
       -object main-loop,id=main-loop,aio-max-batch=<value>
 Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/iscsi.c | 193 ++++++++++++++++++++++++++++++++++++++++++----------------
+ qapi/qom.json                    | 13 ++++++++
-file changed, 140 insertions(+), 53 deletions(-)
+ meson.build                      |  3 +-
+ include/qemu/main-loop.h         | 10 ++++++
-diff --git a/block/iscsi.c b/block/iscsi.c
+ include/sysemu/event-loop-base.h |  1 +
-index XXXXXXX..XXXXXXX 100644
+ event-loop-base.c                | 13 ++++++++
---- a/block/iscsi.c
+ util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
-+++ b/block/iscsi.c
+files changed, 95 insertions(+), 1 deletion(-)
-@@ -XXX,XX +XXX,XX @@ static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/qom.json
 +++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
              '*poll-grow': 'int',
              '*poll-shrink': 'int' } }
 +##
 +# @MainLoopProperties:
 +#
 +# Properties for the main-loop object.
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'MainLoopProperties',
 +  'base': 'EventLoopBaseProperties',
 +  'data': {} }
 +
  ##
  # @MemoryBackendProperties:
  #
@@ -XXX,XX +XXX,XX @@
      { 'name': 'input-linux',
        'if': 'CONFIG_LINUX' },
      'iothread',
 +    'main-loop',
      { 'name': 'memory-backend-epc',
        'if': 'CONFIG_LINUX' },
      'memory-backend-file',
@@ -XXX,XX +XXX,XX @@
        'input-linux':                { 'type': 'InputLinuxProperties',
                                        'if': 'CONFIG_LINUX' },
        'iothread':                   'IothreadProperties',
 +      'main-loop':                  'MainLoopProperties',
        'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
                                        'if': 'CONFIG_LINUX' },
        'memory-backend-file':        'MemoryBackendFileProperties',
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/meson.build
 +++ b/meson.build
@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
                               sources: util_ss.sources() + stub_ss.sources() + genh,
                               dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
  qemuutil = declare_dependency(link_with: libqemuutil,
 -                              sources: genh + version_res)
 +                              sources: genh + version_res,
 +                              dependencies: [event_loop_base])
  if have_system or have_user
    decodetree = generator(find_program('scripts/decodetree.py'),
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/main-loop.h
 +++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
  #define QEMU_MAIN_LOOP_H
  #include "block/aio.h"
 +#include "qom/object.h"
 +#include "sysemu/event-loop-base.h"
  #define SIG_IPI SIGUSR1
 +#define TYPE_MAIN_LOOP  "main-loop"
 +OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
 +
 +struct MainLoop {
 +    EventLoopBase parent_obj;
 +};
 +typedef struct MainLoop MainLoop;
 +
  /**
   * qemu_init_main_loop: Set up the process so that it can run the main loop.
   *
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
      void (*init)(EventLoopBase *base, Error **errp);
      void (*update_params)(EventLoopBase *base, Error **errp);
 +    bool (*can_be_deleted)(EventLoopBase *base);
  };
  struct EventLoopBase {
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
      }
  }
--/* TODO Convert to fine grained options */
++static bool event_loop_base_can_be_deleted(UserCreatable *uc)
--static QemuOptsList runtime_opts = {
++{
--    .name = "iscsi",
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
--    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
++    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
--    .desc = {
++
--        {
++    if (bc->can_be_deleted) {
--            .name = "filename",
++        return bc->can_be_deleted(backend);
--            .type = QEMU_OPT_STRING,
++    }
--            .help = "URL to the iscsi image",
++
--        },
++    return true;
--        { /* end of list */ }
++}
--    },
++
--};
+ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 -
  static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
                                            int evpd, int pc, void **inq, Error **errp)
  {
-@@ -XXX,XX +XXX,XX @@ out:
+     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-  * We support iscsi url's on the form
+     ucc->complete = event_loop_base_complete;
-  * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
++    ucc->can_be_deleted = event_loop_base_can_be_deleted;
-  */
-+static void iscsi_parse_filename(const char *filename, QDict *options,
+     object_class_property_add(klass, "aio-max-batch", "int",
-+                                 Error **errp)
+                               event_loop_base_get_param,
-+{
+diff --git a/util/main-loop.c b/util/main-loop.c
-+    struct iscsi_url *iscsi_url;
+index XXXXXXX..XXXXXXX 100644
-+    const char *transport_name;
+--- a/util/main-loop.c
-+    char *lun_str;
++++ b/util/main-loop.c
-+
+@@ -XXX,XX +XXX,XX @@
-+    iscsi_url = iscsi_parse_full_url(NULL, filename);
+ #include "qemu/error-report.h"
-+    if (iscsi_url == NULL) {
+ #include "qemu/queue.h"
-+        error_setg(errp, "Failed to parse URL : %s", filename);
+ #include "qemu/compiler.h"
 +#include "qom/object.h"
  #ifndef _WIN32
  #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
      return 0;
  }
 +static void main_loop_update_params(EventLoopBase *base, Error **errp)
 +{
 +    if (!qemu_aio_context) {
 +        error_setg(errp, "qemu aio context not ready");
 +        return;
 +    }
 +
-+#if LIBISCSI_API_VERSION >= (20160603)
++    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
-+    switch (iscsi_url->transport) {
++}
-+    case TCP_TRANSPORT:
++
-+        transport_name = "tcp";
++MainLoop *mloop;
-+        break;
++
-+    case ISER_TRANSPORT:
++static void main_loop_init(EventLoopBase *base, Error **errp)
-+        transport_name = "iser";
++{
-+        break;
++    MainLoop *m = MAIN_LOOP(base);
-+    default:
++
-+        error_setg(errp, "Unknown transport type (%d)",
++    if (mloop) {
-+                   iscsi_url->transport);
++        error_setg(errp, "only one main-loop instance allowed");
 +        return;
 +    }
-+#else
++
-+    transport_name = "tcp";
++    main_loop_update_params(base, errp);
-+#endif
++
-+
++    mloop = m;
-+    qdict_set_default_str(options, "transport", transport_name);
++    return;
-+    qdict_set_default_str(options, "portal", iscsi_url->portal);
++}
-+    qdict_set_default_str(options, "target", iscsi_url->target);
++
-+
++static bool main_loop_can_be_deleted(EventLoopBase *base)
-+    lun_str = g_strdup_printf("%d", iscsi_url->lun);
++{
-+    qdict_set_default_str(options, "lun", lun_str);
++    return false;
-+    g_free(lun_str);
++}
 +
-+    if (iscsi_url->user[0] != '\0') {
++static void main_loop_class_init(ObjectClass *oc, void *class_data)
-+        qdict_set_default_str(options, "user", iscsi_url->user);
++{
-+        qdict_set_default_str(options, "password", iscsi_url->passwd);
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
-+    }
++
-+
++    bc->init = main_loop_init;
-+    iscsi_destroy_url(iscsi_url);
++    bc->update_params = main_loop_update_params;
-+}
++    bc->can_be_deleted = main_loop_can_be_deleted;
-+
++}
-+/* TODO Add -iscsi options */
++
-+static QemuOptsList runtime_opts = {
++static const TypeInfo main_loop_info = {
-+    .name = "iscsi",
++    .name = TYPE_MAIN_LOOP,
-+    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
++    .parent = TYPE_EVENT_LOOP_BASE,
-+    .desc = {
++    .class_init = main_loop_class_init,
-+        {
++    .instance_size = sizeof(MainLoop),
 +            .name = "transport",
 +            .type = QEMU_OPT_STRING,
 +        },
 +        {
 +            .name = "portal",
 +            .type = QEMU_OPT_STRING,
 +        },
 +        {
 +            .name = "target",
 +            .type = QEMU_OPT_STRING,
 +        },
 +        {
 +            .name = "user",
 +            .type = QEMU_OPT_STRING,
 +        },
 +        {
 +            .name = "password",
 +            .type = QEMU_OPT_STRING,
 +        },
 +        {
 +            .name = "lun",
 +            .type = QEMU_OPT_NUMBER,
 +        },
 +        { /* end of list */ }
 +    },
 +};
 +
- static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
++static void main_loop_register_types(void)
-                       Error **errp)
++{
- {
++    type_register_static(&main_loop_info);
-     IscsiLun *iscsilun = bs->opaque;
++}
-     struct iscsi_context *iscsi = NULL;
++
--    struct iscsi_url *iscsi_url = NULL;
++type_init(main_loop_register_types)
-     struct scsi_task *task = NULL;
++
-     struct scsi_inquiry_standard *inq = NULL;
+ static int max_priority;
-     struct scsi_inquiry_supported_pages *inq_vpd;
-     char *initiator_name = NULL;
+ #ifndef _WIN32
      QemuOpts *opts;
      Error *local_err = NULL;
 -    const char *filename;
 -    int i, ret = 0, timeout = 0;
 +    const char *transport_name, *portal, *target;
 +    const char *user, *password;
 +#if LIBISCSI_API_VERSION >= (20160603)
 +    enum iscsi_transport_type transport;
 +#endif
 +    int i, ret = 0, timeout = 0, lun;
      opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
      qemu_opts_absorb_qdict(opts, options, &local_err);
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
          goto out;
      }
 -    filename = qemu_opt_get(opts, "filename");
 +    transport_name = qemu_opt_get(opts, "transport");
 +    portal = qemu_opt_get(opts, "portal");
 +    target = qemu_opt_get(opts, "target");
 +    user = qemu_opt_get(opts, "user");
 +    password = qemu_opt_get(opts, "password");
 +    lun = qemu_opt_get_number(opts, "lun", 0);
 -    iscsi_url = iscsi_parse_full_url(iscsi, filename);
 -    if (iscsi_url == NULL) {
 -        error_setg(errp, "Failed to parse URL : %s", filename);
 +    if (!transport_name || !portal || !target) {
 +        error_setg(errp, "Need all of transport, portal and target options");
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +    if (user && !password) {
 +        error_setg(errp, "If a user name is given, a password is required");
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    if (!strcmp(transport_name, "tcp")) {
 +#if LIBISCSI_API_VERSION >= (20160603)
 +        transport = TCP_TRANSPORT;
 +    } else if (!strcmp(transport_name, "iser")) {
 +        transport = ISER_TRANSPORT;
 +#else
 +        /* TCP is what older libiscsi versions always use */
 +#endif
 +    } else {
 +        error_setg(errp, "Unknown transport: %s", transport_name);
          ret = -EINVAL;
          goto out;
      }
      memset(iscsilun, 0, sizeof(IscsiLun));
 -    initiator_name = parse_initiator_name(iscsi_url->target);
 +    initiator_name = parse_initiator_name(target);
      iscsi = iscsi_create_context(initiator_name);
      if (iscsi == NULL) {
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
          goto out;
      }
  #if LIBISCSI_API_VERSION >= (20160603)
 -    if (iscsi_init_transport(iscsi, iscsi_url->transport)) {
 +    if (iscsi_init_transport(iscsi, transport)) {
          error_setg(errp, ("Error initializing transport."));
          ret = -EINVAL;
          goto out;
      }
  #endif
 -    if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
 +    if (iscsi_set_targetname(iscsi, target)) {
          error_setg(errp, "iSCSI: Failed to set target name.");
          ret = -EINVAL;
          goto out;
      }
 -    if (iscsi_url->user[0] != '\0') {
 -        ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
 -                                              iscsi_url->passwd);
 +    if (user) {
 +        ret = iscsi_set_initiator_username_pwd(iscsi, user, password);
          if (ret != 0) {
              error_setg(errp, "Failed to set initiator username and password");
              ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      }
      /* check if we got CHAP username/password via the options */
 -    parse_chap(iscsi, iscsi_url->target, &local_err);
 +    parse_chap(iscsi, target, &local_err);
      if (local_err != NULL) {
          error_propagate(errp, local_err);
          ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
      /* check if we got HEADER_DIGEST via the options */
 -    parse_header_digest(iscsi, iscsi_url->target, &local_err);
 +    parse_header_digest(iscsi, target, &local_err);
      if (local_err != NULL) {
          error_propagate(errp, local_err);
          ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      }
      /* timeout handling is broken in libiscsi before 1.15.0 */
 -    timeout = parse_timeout(iscsi_url->target);
 +    timeout = parse_timeout(target);
  #if LIBISCSI_API_VERSION >= 20150621
      iscsi_set_timeout(iscsi, timeout);
  #else
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      }
  #endif
 -    if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
 +    if (iscsi_full_connect_sync(iscsi, portal, lun) != 0) {
          error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
              iscsi_get_error(iscsi));
          ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      iscsilun->iscsi = iscsi;
      iscsilun->aio_context = bdrv_get_aio_context(bs);
 -    iscsilun->lun   = iscsi_url->lun;
 +    iscsilun->lun = lun;
      iscsilun->has_write_same = true;
      task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
  out:
      qemu_opts_del(opts);
      g_free(initiator_name);
 -    if (iscsi_url != NULL) {
 -        iscsi_destroy_url(iscsi_url);
 -    }
      if (task != NULL) {
          scsi_free_scsi_task(task);
      }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {
      .format_name     = "iscsi",
      .protocol_name   = "iscsi",
 -    .instance_size   = sizeof(IscsiLun),
 -    .bdrv_needs_filename = true,
 -    .bdrv_file_open  = iscsi_open,
 -    .bdrv_close      = iscsi_close,
 -    .bdrv_create     = iscsi_create,
 -    .create_opts     = &iscsi_create_opts,
 -    .bdrv_reopen_prepare   = iscsi_reopen_prepare,
 -    .bdrv_reopen_commit    = iscsi_reopen_commit,
 -    .bdrv_invalidate_cache = iscsi_invalidate_cache,
 +    .instance_size          = sizeof(IscsiLun),
 +    .bdrv_parse_filename    = iscsi_parse_filename,
 +    .bdrv_file_open         = iscsi_open,
 +    .bdrv_close             = iscsi_close,
 +    .bdrv_create            = iscsi_create,
 +    .create_opts            = &iscsi_create_opts,
 +    .bdrv_reopen_prepare    = iscsi_reopen_prepare,
 +    .bdrv_reopen_commit     = iscsi_reopen_commit,
 +    .bdrv_invalidate_cache  = iscsi_invalidate_cache,
      .bdrv_getlength  = iscsi_getlength,
      .bdrv_get_info   = iscsi_get_info,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {
      .format_name     = "iser",
      .protocol_name   = "iser",
 -    .instance_size   = sizeof(IscsiLun),
 -    .bdrv_needs_filename = true,
 -    .bdrv_file_open  = iscsi_open,
 -    .bdrv_close      = iscsi_close,
 -    .bdrv_create     = iscsi_create,
 -    .create_opts     = &iscsi_create_opts,
 -    .bdrv_reopen_prepare   = iscsi_reopen_prepare,
 -    .bdrv_reopen_commit    = iscsi_reopen_commit,
 -    .bdrv_invalidate_cache = iscsi_invalidate_cache,
 +    .instance_size          = sizeof(IscsiLun),
 +    .bdrv_parse_filename    = iscsi_parse_filename,
 +    .bdrv_file_open         = iscsi_open,
 +    .bdrv_close             = iscsi_close,
 +    .bdrv_create            = iscsi_create,
 +    .create_opts            = &iscsi_create_opts,
 +    .bdrv_reopen_prepare    = iscsi_reopen_prepare,
 +    .bdrv_reopen_commit     = iscsi_reopen_commit,
 +    .bdrv_invalidate_cache  = iscsi_invalidate_cache,
      .bdrv_getlength  = iscsi_getlength,
      .bdrv_get_info   = iscsi_get_info,
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 2/9] iscsi: Handle -iscsi user/password in bdrv_parse_filename()
+[PULL 3/3] util/event-loop-base: Introduce options to set the thread pool size
-From: Kevin Wolf <kwolf@redhat.com>
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-This splits the logic in the old parse_chap() function into a part that
+The thread pool regulates itself: when idle, it kills threads until
-parses the -iscsi options into the new driver-specific options, and
+empty, when in demand, it creates new threads until full. This behaviour
-another part that actually applies those options (called apply_chap()
+doesn't play well with latency sensitive workloads where the price of
-now).
+creating a new thread is too high. For example, when paired with qemu's
 '-mlock', or using safety features like SafeStack, creating a new thread
 has been measured take multiple milliseconds.
-Note that this means that username and password specified with -iscsi
+In order to mitigate this let's introduce a new 'EventLoopBase'
-only take effect when a URL is provided. This is intentional, -iscsi is
+property to set the thread pool size. The threads will be created during
-a legacy interface only supported for compatibility, new users should
+the pool's initialization or upon updating the property's value, remain
-use the proper driver-specific options.
+available during its lifetime regardless of demand, and destroyed upon
 freeing it. A properly characterized workload will then be able to
 configure the pool to avoid any latency spikes.
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/iscsi.c | 78 +++++++++++++++++++++++++++++++++--------------------------
+ qapi/qom.json                    | 10 +++++-
-file changed, 44 insertions(+), 34 deletions(-)
+ include/block/aio.h              | 10 ++++++
  include/block/thread-pool.h      |  3 ++
  include/sysemu/event-loop-base.h |  4 +++
  event-loop-base.c                | 23 +++++++++++++
  iothread.c                       |  3 ++
  util/aio-posix.c                 |  1 +
  util/async.c                     | 20 ++++++++++++
  util/main-loop.c                 |  9 ++++++
  util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 files changed, 133 insertions(+), 5 deletions(-)
-diff --git a/block/iscsi.c b/block/iscsi.c
+diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+--- a/qapi/qom.json
-+++ b/block/iscsi.c
++++ b/qapi/qom.json
-@@ -XXX,XX +XXX,XX @@ retry:
+@@ -XXX,XX +XXX,XX @@
-     return 0;
+ #                 0 means that the engine will use its default.
- }
+ #                 (default: 0)
+ #
--static void parse_chap(struct iscsi_context *iscsi, const char *target,
++# @thread-pool-min: minimum number of threads reserved in the thread pool
-+static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
++#                   (default:0)
-                        Error **errp)
++#
 +# @thread-pool-max: maximum number of threads the thread pool can contain
 +#                   (default:64)
 +#
  # Since: 7.1
  ##
  { 'struct': 'EventLoopBaseProperties',
 -  'data': { '*aio-max-batch': 'int' } }
 +  'data': { '*aio-max-batch': 'int',
 +            '*thread-pool-min': 'int',
 +            '*thread-pool-max': 'int' } }
  ##
  # @IothreadProperties:
 diff --git a/include/block/aio.h b/include/block/aio.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/aio.h
 +++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
      QSLIST_HEAD(, Coroutine) scheduled_coroutines;
      QEMUBH *co_schedule_bh;
 +    int thread_pool_min;
 +    int thread_pool_max;
      /* Thread pool for performing work and receiving completion callbacks.
       * Has its own locking.
       */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
  void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                  Error **errp);
 +/**
 + * aio_context_set_thread_pool_params:
 + * @ctx: the aio context
 + * @min: min number of threads to have readily available in the thread pool
 + * @min: max number of threads the thread pool can contain
 + */
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp);
  #endif
 diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/thread-pool.h
 +++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
  #include "block/block.h"
 +#define THREAD_POOL_MAX_THREADS_DEFAULT         64
 +
  typedef int ThreadPoolFunc(void *opaque);
  typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
  int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
          ThreadPoolFunc *func, void *arg);
  void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
 +void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
  #endif
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
      /* AioContext AIO engine parameters */
      int64_t aio_max_batch;
 +
 +    /* AioContext thread pool parameters */
 +    int64_t thread_pool_min;
 +    int64_t thread_pool_max;
  };
  #endif
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qom/object_interfaces.h"
  #include "qapi/error.h"
 +#include "block/thread-pool.h"
  #include "sysemu/event-loop-base.h"
  typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
      ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
  } EventLoopBaseParamInfo;
 +static void event_loop_base_instance_init(Object *obj)
 +{
 +    EventLoopBase *base = EVENT_LOOP_BASE(obj);
 +
 +    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +}
 +
  static EventLoopBaseParamInfo aio_max_batch_info = {
      "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
  };
 +static EventLoopBaseParamInfo thread_pool_min_info = {
 +    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
 +};
 +static EventLoopBaseParamInfo thread_pool_max_info = {
 +    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
 +};
  static void event_loop_base_get_param(Object *obj, Visitor *v,
          const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                                event_loop_base_get_param,
                                event_loop_base_set_param,
                                NULL, &aio_max_batch_info);
 +    object_class_property_add(klass, "thread-pool-min", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_min_info);
 +    object_class_property_add(klass, "thread-pool-max", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_max_info);
  }
  static const TypeInfo event_loop_base_info = {
      .name = TYPE_EVENT_LOOP_BASE,
      .parent = TYPE_OBJECT,
      .instance_size = sizeof(EventLoopBase),
 +    .instance_init = event_loop_base_instance_init,
      .class_size = sizeof(EventLoopBaseClass),
      .class_init = event_loop_base_class_init,
      .abstract = true,
 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_set_aio_context_params(EventLoopBase *base, Error **errp)
      aio_context_set_aio_params(iothread->ctx,
                                 iothread->parent_obj.aio_max_batch,
                                 errp);
 +
 +    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
 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 @@
  #include "qemu/osdep.h"
  #include "block/block.h"
 +#include "block/thread-pool.h"
  #include "qemu/main-loop.h"
  #include "qemu/rcu.h"
  #include "qemu/rcu_queue.h"
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
      ctx->aio_max_batch = 0;
 +    ctx->thread_pool_min = 0;
 +    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +
      return ctx;
  fail:
      g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
      assert(!get_my_aiocontext());
      set_my_aiocontext(ctx);
  }
 +
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp)
 +{
 +
 +    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
 +        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
 +        return;
 +    }
 +
 +    ctx->thread_pool_min = min;
 +    ctx->thread_pool_max = max;
 +
 +    if (ctx->thread_pool) {
 +        thread_pool_update_params(ctx->thread_pool, ctx);
 +    }
 +}
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/replay.h"
  #include "qemu/main-loop.h"
  #include "block/aio.h"
 +#include "block/thread-pool.h"
  #include "qemu/error-report.h"
  #include "qemu/queue.h"
  #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
  static void main_loop_update_params(EventLoopBase *base, Error **errp)
  {
--    QemuOptsList *list;
++    ERRP_GUARD();
--    QemuOpts *opts;
++
-     const char *user = NULL;
+     if (!qemu_aio_context) {
-     const char *password = NULL;
+         error_setg(errp, "qemu aio context not ready");
      const char *secretid;
      char *secret = NULL;
 -    list = qemu_find_opts("iscsi");
 -    if (!list) {
 -        return;
 -    }
 -
 -    opts = qemu_opts_find(list, target);
 -    if (opts == NULL) {
 -        opts = QTAILQ_FIRST(&list->head);
 -        if (!opts) {
 -            return;
 -        }
 -    }
 -
      user = qemu_opt_get(opts, "user");
      if (!user) {
          return;
-@@ -XXX,XX +XXX,XX @@ out:
      }
- }
+     aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
-+static void iscsi_parse_iscsi_option(const char *target, QDict *options)
++    if (*errp) {
 +        return;
 +    }
 +
 +    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
  MainLoop *mloop;
 diff --git a/util/thread-pool.c b/util/thread-pool.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/thread-pool.c
 +++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
      QemuMutex lock;
      QemuCond worker_stopped;
      QemuSemaphore sem;
 -    int max_threads;
      QEMUBH *new_thread_bh;
      /* The following variables are only accessed from one AioContext. */
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
      int new_threads;     /* backlog of threads we need to create */
      int pending_threads; /* threads created but not running yet */
      bool stopping;
 +    int min_threads;
 +    int max_threads;
  };
 +static inline bool back_to_sleep(ThreadPool *pool, int ret)
 +{
-+    QemuOptsList *list;
++    /*
-+    QemuOpts *opts;
++     * The semaphore timed out, we should exit the loop except when:
-+    const char *user, *password, *password_secret;
++     *  - There is work to do, we raced with the signal.
-+
++     *  - The max threads threshold just changed, we raced with the signal.
-+    list = qemu_find_opts("iscsi");
++     *  - The thread pool forces a minimum number of readily available threads.
-+    if (!list) {
++     */
-+        return;
++    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
-+    }
++            pool->cur_threads > pool->max_threads ||
-+
++            pool->cur_threads <= pool->min_threads)) {
-+    opts = qemu_opts_find(list, target);
++            return true;
-+    if (opts == NULL) {
++    }
-+        opts = QTAILQ_FIRST(&list->head);
++
-+        if (!opts) {
++    return false;
 +            return;
 +        }
 +    }
 +
 +    user = qemu_opt_get(opts, "user");
 +    if (user) {
 +        qdict_set_default_str(options, "user", user);
 +    }
 +
 +    password = qemu_opt_get(opts, "password");
 +    if (password) {
 +        qdict_set_default_str(options, "password", password);
 +    }
 +
 +    password_secret = qemu_opt_get(opts, "password-secret");
 +    if (password_secret) {
 +        qdict_set_default_str(options, "password-secret", password_secret);
 +    }
 +}
 +
- /*
+ static void *worker_thread(void *opaque)
-  * We support iscsi url's on the form
+ {
-  * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
+     ThreadPool *pool = opaque;
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_filename(const char *filename, QDict *options,
+@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
-     qdict_set_default_str(options, "lun", lun_str);
+             ret = qemu_sem_timedwait(&pool->sem, 10000);
-     g_free(lun_str);
+             qemu_mutex_lock(&pool->lock);
+             pool->idle_threads--;
-+    /* User/password from -iscsi take precedence over those from the URL */
+-        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
-+    iscsi_parse_iscsi_option(iscsi_url->target, options);
+-        if (ret == -1 || pool->stopping) {
-+
++        } while (back_to_sleep(pool, ret));
-     if (iscsi_url->user[0] != '\0') {
++        if (ret == -1 || pool->stopping ||
-         qdict_set_default_str(options, "user", iscsi_url->user);
++            pool->cur_threads > pool->max_threads) {
-         qdict_set_default_str(options, "password", iscsi_url->passwd);
+             break;
-@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
+         }
-             .type = QEMU_OPT_STRING,
-         },
+@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
-         {
+     thread_pool_submit_aio(pool, func, arg, NULL, NULL);
-+            .name = "password-secret",
+ }
-+            .type = QEMU_OPT_STRING,
-+        },
++void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
-+        {
++{
-             .name = "lun",
++    qemu_mutex_lock(&pool->lock);
-             .type = QEMU_OPT_NUMBER,
++
-         },
++    pool->min_threads = ctx->thread_pool_min;
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
++    pool->max_threads = ctx->thread_pool_max;
-     QemuOpts *opts;
++
-     Error *local_err = NULL;
++    /*
-     const char *transport_name, *portal, *target;
++     * We either have to:
--    const char *user, *password;
++     *  - Increase the number available of threads until over the min_threads
- #if LIBISCSI_API_VERSION >= (20160603)
++     *    threshold.
-     enum iscsi_transport_type transport;
++     *  - Decrease the number of available threads until under the max_threads
- #endif
++     *    threshold.
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
++     *  - Do nothing. The current number of threads fall in between the min and
-     transport_name = qemu_opt_get(opts, "transport");
++     *    max thresholds. We'll let the pool manage itself.
-     portal = qemu_opt_get(opts, "portal");
++     */
-     target = qemu_opt_get(opts, "target");
++    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
--    user = qemu_opt_get(opts, "user");
++        spawn_thread(pool);
--    password = qemu_opt_get(opts, "password");
++    }
-     lun = qemu_opt_get_number(opts, "lun", 0);
++
++    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
-     if (!transport_name || !portal || !target) {
++        qemu_sem_post(&pool->sem);
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
++    }
-         ret = -EINVAL;
++
-         goto out;
++    qemu_mutex_unlock(&pool->lock);
-     }
++}
--    if (user && !password) {
++
--        error_setg(errp, "If a user name is given, a password is required");
+ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
--        ret = -EINVAL;
+ {
--        goto out;
+     if (!ctx) {
--    }
+@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
+     qemu_mutex_init(&pool->lock);
-     if (!strcmp(transport_name, "tcp")) {
+     qemu_cond_init(&pool->worker_stopped);
- #if LIBISCSI_API_VERSION >= (20160603)
+     qemu_sem_init(&pool->sem, 0);
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
+-    pool->max_threads = 64;
-         goto out;
+     pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
-     }
+     QLIST_INIT(&pool->head);
--    if (user) {
+     QTAILQ_INIT(&pool->request_list);
--        ret = iscsi_set_initiator_username_pwd(iscsi, user, password);
++
--        if (ret != 0) {
++    thread_pool_update_params(pool, ctx);
--            error_setg(errp, "Failed to set initiator username and password");
+ }
--            ret = -EINVAL;
--            goto out;
+ ThreadPool *thread_pool_new(AioContext *ctx)
 -        }
 -    }
 -
      /* check if we got CHAP username/password via the options */
 -    parse_chap(iscsi, target, &local_err);
 +    apply_chap(iscsi, opts, &local_err);
      if (local_err != NULL) {
          error_propagate(errp, local_err);
          ret = -EINVAL;
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 3/9] iscsi: Add initiator-name option
+Deleted patch
-From: Kevin Wolf <kwolf@redhat.com>
-This was previously only available with -iscsi. Again, after this patch,
-the -iscsi option only takes effect if an URL is given. New users are
-supposed to use the new driver-specific option.
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- block/iscsi.c | 32 +++++++++++++++-----------------
-file changed, 15 insertions(+), 17 deletions(-)
-diff --git a/block/iscsi.c b/block/iscsi.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
-+++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
-     }
- }
--static char *parse_initiator_name(const char *target)
-+static char *get_initiator_name(QemuOpts *opts)
- {
--    QemuOptsList *list;
--    QemuOpts *opts;
-     const char *name;
-     char *iscsi_name;
-     UuidInfo *uuid_info;
--    list = qemu_find_opts("iscsi");
--    if (list) {
--        opts = qemu_opts_find(list, target);
--        if (!opts) {
--            opts = QTAILQ_FIRST(&list->head);
--        }
--        if (opts) {
--            name = qemu_opt_get(opts, "initiator-name");
--            if (name) {
--                return g_strdup(name);
--            }
--        }
-+    name = qemu_opt_get(opts, "initiator-name");
-+    if (name) {
-+        return g_strdup(name);
-     }
-     uuid_info = qmp_query_uuid(NULL);
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
- {
-     QemuOptsList *list;
-     QemuOpts *opts;
--    const char *user, *password, *password_secret;
-+    const char *user, *password, *password_secret, *initiator_name;
-     list = qemu_find_opts("iscsi");
-     if (!list) {
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
-     if (password_secret) {
-         qdict_set_default_str(options, "password-secret", password_secret);
-     }
-+
-+    initiator_name = qemu_opt_get(opts, "initiator-name");
-+    if (initiator_name) {
-+        qdict_set_default_str(options, "initiator-name", initiator_name);
-+    }
- }
- /*
-@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
-             .name = "lun",
-             .type = QEMU_OPT_NUMBER,
-         },
-+        {
-+            .name = "initiator-name",
-+            .type = QEMU_OPT_STRING,
-+        },
-         { /* end of list */ }
-     },
- };
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
-     memset(iscsilun, 0, sizeof(IscsiLun));
--    initiator_name = parse_initiator_name(target);
-+    initiator_name = get_initiator_name(opts);
-     iscsi = iscsi_create_context(initiator_name);
-     if (iscsi == NULL) {
---
-.9.3

-[Qemu-devel] [PULL 5/9] iscsi: Add timeout option
+Deleted patch
-From: Kevin Wolf <kwolf@redhat.com>
-This was previously only available with -iscsi. Again, after this patch,
-the -iscsi option only takes effect if an URL is given. New users are
-supposed to use the new driver-specific option.
-All -iscsi options have a corresponding driver-specific option for the
-iscsi block driver now.
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- block/iscsi.c | 37 +++++++++++--------------------------
-file changed, 11 insertions(+), 26 deletions(-)
-diff --git a/block/iscsi.c b/block/iscsi.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
-+++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static char *get_initiator_name(QemuOpts *opts)
-     return iscsi_name;
- }
--static int parse_timeout(const char *target)
--{
--    QemuOptsList *list;
--    QemuOpts *opts;
--    const char *timeout;
--
--    list = qemu_find_opts("iscsi");
--    if (list) {
--        opts = qemu_opts_find(list, target);
--        if (!opts) {
--            opts = QTAILQ_FIRST(&list->head);
--        }
--        if (opts) {
--            timeout = qemu_opt_get(opts, "timeout");
--            if (timeout) {
--                return atoi(timeout);
--            }
--        }
--    }
--
--    return 0;
--}
--
- static void iscsi_nop_timed_event(void *opaque)
- {
-     IscsiLun *iscsilun = opaque;
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
-     QemuOptsList *list;
-     QemuOpts *opts;
-     const char *user, *password, *password_secret, *initiator_name,
--               *header_digest;
-+               *header_digest, *timeout;
-     list = qemu_find_opts("iscsi");
-     if (!list) {
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
-     if (header_digest) {
-         qdict_set_default_str(options, "header-digest", header_digest);
-     }
-+
-+    timeout = qemu_opt_get(opts, "timeout");
-+    if (timeout) {
-+        qdict_set_default_str(options, "timeout", timeout);
-+    }
- }
- /*
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_filename(const char *filename, QDict *options,
-     iscsi_destroy_url(iscsi_url);
- }
--/* TODO Add -iscsi options */
- static QemuOptsList runtime_opts = {
-     .name = "iscsi",
-     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
-@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
-             .name = "header-digest",
-             .type = QEMU_OPT_STRING,
-         },
-+        {
-+            .name = "timeout",
-+            .type = QEMU_OPT_NUMBER,
-+        },
-         { /* end of list */ }
-     },
- };
-@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
-     }
-     /* timeout handling is broken in libiscsi before 1.15.0 */
--    timeout = parse_timeout(target);
-+    timeout = qemu_opt_get_number(opts, "timeout", 0);
- #if LIBISCSI_API_VERSION >= 20150621
-     iscsi_set_timeout(iscsi, timeout);
- #else
---
-.9.3

-[Qemu-devel] [PULL 6/9] iscsi: Add blockdev-add support
+Deleted patch
-From: Kevin Wolf <kwolf@redhat.com>
-This adds blockdev-add support for iscsi devices.
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- block/iscsi.c        | 14 ++++++----
- qapi/block-core.json | 75 ++++++++++++++++++++++++++++++++++++++++++++++++----
-files changed, 79 insertions(+), 10 deletions(-)
-diff --git a/block/iscsi.c b/block/iscsi.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
-+++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
-     digest = qemu_opt_get(opts, "header-digest");
-     if (!digest) {
-         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
--    } else if (!strcmp(digest, "CRC32C")) {
-+    } else if (!strcmp(digest, "crc32c")) {
-         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
--    } else if (!strcmp(digest, "NONE")) {
-+    } else if (!strcmp(digest, "none")) {
-         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
--    } else if (!strcmp(digest, "CRC32C-NONE")) {
-+    } else if (!strcmp(digest, "crc32c-none")) {
-         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
--    } else if (!strcmp(digest, "NONE-CRC32C")) {
-+    } else if (!strcmp(digest, "none-crc32c")) {
-         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
-     } else {
-         error_setg(errp, "Invalid header-digest setting : %s", digest);
-@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
-     header_digest = qemu_opt_get(opts, "header-digest");
-     if (header_digest) {
--        qdict_set_default_str(options, "header-digest", header_digest);
-+        /* -iscsi takes upper case values, but QAPI only supports lower case
-+         * enum constant names, so we have to convert here. */
-+        char *qapi_value = g_ascii_strdown(header_digest, -1);
-+        qdict_set_default_str(options, "header-digest", qapi_value);
-+        g_free(qapi_value);
-     }
-     timeout = qemu_opt_get(opts, "timeout");
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
- # @nfs: Since 2.8
- # @replication: Since 2.8
- # @ssh: Since 2.8
-+# @iscsi: Since 2.9
- #
- # Since: 2.0
- ##
- { 'enum': 'BlockdevDriver',
-   'data': [ 'archipelago', 'blkdebug', 'blkverify', 'bochs', 'cloop',
-             'dmg', 'file', 'ftp', 'ftps', 'gluster', 'host_cdrom',
--            'host_device', 'http', 'https', 'luks', 'nbd', 'nfs', 'null-aio',
--            'null-co', 'parallels', 'qcow', 'qcow2', 'qed', 'quorum', 'raw',
--            'replication', 'ssh', 'vdi', 'vhdx', 'vmdk', 'vpc',
--            'vvfat' ] }
-+            'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
-+            'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
-+            'quorum', 'raw', 'replication', 'ssh', 'vdi', 'vhdx', 'vmdk',
-+            'vpc', 'vvfat' ] }
- ##
- # @BlockdevOptionsFile:
-@@ -XXX,XX +XXX,XX @@
-             '*logfile': 'str' } }
- ##
-+# @IscsiTransport:
-+#
-+# An enumeration of libiscsi transport types
-+#
-+# Since: 2.9
-+##
-+{ 'enum': 'IscsiTransport',
-+  'data': [ 'tcp', 'iser' ] }
-+
-+##
-+# @IscsiHeaderDigest:
-+#
-+# An enumeration of header digests supported by libiscsi
-+#
-+# Since: 2.9
-+##
-+{ 'enum': 'IscsiHeaderDigest',
-+  'prefix': 'QAPI_ISCSI_HEADER_DIGEST',
-+  'data': [ 'crc32c', 'none', 'crc32c-none', 'none-crc32c' ] }
-+
-+##
-+# @BlockdevOptionsIscsi:
-+#
-+# @transport        The iscsi transport type
-+#
-+# @portal           The address of the iscsi portal
-+#
-+# @target           The target iqn name
-+#
-+# @lun              #optional LUN to connect to. Defaults to 0.
-+#
-+# @user             #optional User name to log in with. If omitted, no CHAP
-+#                   authentication is performed.
-+#
-+# @password-secret  #optional The ID of a QCryptoSecret object providing
-+#                   the password for the login. This option is required if
-+#                   @user is specified.
-+#
-+# @initiator-name   #optional The iqn name we want to identify to the target
-+#                   as. If this option is not specified, an initiator name is
-+#                   generated automatically.
-+#
-+# @header-digest    #optional The desired header digest. Defaults to
-+#                   none-crc32c.
-+#
-+# @timeout          #optional Timeout in seconds after which a request will
-+#                   timeout. 0 means no timeout and is the default.
-+#
-+# Driver specific block device options for iscsi
-+#
-+# Since: 2.9
-+##
-+{ 'struct': 'BlockdevOptionsIscsi',
-+  'data': { 'transport': 'IscsiTransport',
-+            'portal': 'str',
-+            'target': 'str',
-+            '*lun': 'int',
-+            '*user': 'str',
-+            '*password-secret': 'str',
-+            '*initiator-name': 'str',
-+            '*header-digest': 'IscsiHeaderDigest',
-+            '*timeout': 'int' } }
-+
-+##
- # @ReplicationMode:
- #
- # An enumeration of replication modes.
-@@ -XXX,XX +XXX,XX @@
-       'host_device':'BlockdevOptionsFile',
-       'http':       'BlockdevOptionsCurl',
-       'https':      'BlockdevOptionsCurl',
--# TODO iscsi: Wait for structured options
-+      'iscsi':      'BlockdevOptionsIscsi',
-       'luks':       'BlockdevOptionsLUKS',
-       'nbd':        'BlockdevOptionsNbd',
-       'nfs':        'BlockdevOptionsNfs',
---
-.9.3

-[Qemu-devel] [PULL 7/9] QAPI: Fix blockdev-add example documentation
+Deleted patch
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- qapi/block-core.json | 50 +++++++++++++++++++++++++-------------------------
-file changed, 25 insertions(+), 25 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
- # 1.
- # -> { "execute": "blockdev-add",
- #      "arguments": {
--#          "options" : { "driver": "qcow2",
--#                        "file": { "driver": "file",
--#                                  "filename": "test.qcow2" } } } }
-+#           "driver": "qcow2",
-+#           "node-name": "test1",
-+#           "file": {
-+#               "driver": "file",
-+#               "filename": "test.qcow2"
-+#            }
-+#       }
-+#     }
- # <- { "return": {} }
- #
- # 2.
- # -> { "execute": "blockdev-add",
- #      "arguments": {
--#          "options": {
--#            "driver": "qcow2",
--#            "node-name": "node0",
--#            "discard": "unmap",
--#            "cache": {
--#                "direct": true,
--#                "writeback": true
-+#           "driver": "qcow2",
-+#           "node-name": "node0",
-+#           "discard": "unmap",
-+#           "cache": {
-+#              "direct": true
- #            },
- #            "file": {
--#                "driver": "file",
--#                "filename": "/tmp/test.qcow2"
-+#              "driver": "file",
-+#              "filename": "/tmp/test.qcow2"
- #            },
- #            "backing": {
--#                "driver": "raw",
--#                "file": {
--#                    "driver": "file",
--#                    "filename": "/dev/fdset/4"
-+#               "driver": "raw",
-+#               "file": {
-+#                  "driver": "file",
-+#                  "filename": "/dev/fdset/4"
- #                }
- #            }
--#          }
- #        }
- #      }
- #
-@@ -XXX,XX +XXX,XX @@
- #
- # -> { "execute": "blockdev-add",
- #      "arguments": {
--#          "options": {
--#              "driver": "qcow2",
--#              "node-name": "node0",
--#              "file": {
--#                  "driver": "file",
--#                  "filename": "test.qcow2"
--#              }
--#          }
-+#           "driver": "qcow2",
-+#           "node-name": "node0",
-+#           "file": {
-+#               "driver": "file",
-+#               "filename": "test.qcow2"
-+#           }
- #      }
- #    }
- # <- { "return": {} }
---
-.9.3

-[Qemu-devel] [PULL 8/9] mirror: do not increase offset during initial zero_or_discard phase
+Deleted patch
-From: Anton Nefedov <anton.nefedov@virtuozzo.com>
-If explicit zeroing out before mirroring is required for the target image,
-it moves the block job offset counter to EOF, then offset and len counters
-count the image size twice. There is no harm but stats are confusing,
-specifically the progress of the operation is always reported as 99% by
-management tools.
-The patch skips offset increase for the first "technical" pass over the
-image. This should not cause any further harm.
-Signed-off-by: Anton Nefedov <anton.nefedov@virtuozzo.com>
-Signed-off-by: Denis V. Lunev <den@openvz.org>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 1486045515-8009-1-git-send-email-den@openvz.org
-CC: Jeff Cody <jcody@redhat.com>
-CC: Kevin Wolf <kwolf@redhat.com>
-CC: Max Reitz <mreitz@redhat.com>
-CC: Eric Blake <eblake@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- block/mirror.c | 9 +++++++--
-file changed, 7 insertions(+), 2 deletions(-)
-diff --git a/block/mirror.c b/block/mirror.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob {
-     bool waiting_for_io;
-     int target_cluster_sectors;
-     int max_iov;
-+    bool initial_zeroing_ongoing;
- } MirrorBlockJob;
- typedef struct MirrorOp {
-@@ -XXX,XX +XXX,XX @@ static void mirror_iteration_done(MirrorOp *op, int ret)
-         if (s->cow_bitmap) {
-             bitmap_set(s->cow_bitmap, chunk_num, nb_chunks);
-         }
--        s->common.offset += (uint64_t)op->nb_sectors * BDRV_SECTOR_SIZE;
-+        if (!s->initial_zeroing_ongoing) {
-+            s->common.offset += (uint64_t)op->nb_sectors * BDRV_SECTOR_SIZE;
-+        }
-     }
--
-     qemu_iovec_destroy(&op->qiov);
-     g_free(op);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
-             return 0;
-         }
-+        s->initial_zeroing_ongoing = true;
-         for (sector_num = 0; sector_num < end; ) {
-             int nb_sectors = MIN(end - sector_num,
-                 QEMU_ALIGN_DOWN(INT_MAX, s->granularity) >> BDRV_SECTOR_BITS);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
-             mirror_throttle(s);
-             if (block_job_is_cancelled(&s->common)) {
-+                s->initial_zeroing_ongoing = false;
-                 return 0;
-             }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
-         }
-         mirror_wait_for_all_io(s);
-+        s->initial_zeroing_ongoing = false;
-     }
-     /* First part, loop on the sectors and initialize the dirty bitmap.  */
---
-.9.3

-[Qemu-devel] [PULL 9/9] qemu-options: Fix broken sheepdog URL
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-The sheepdog URL is broken twice: First it uses a duplicated
-http:// prefix, second the website seems to have moved to
-https://sheepdog.github.io/sheepdog/ instead.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- qemu-options.hx | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/qemu-options.hx b/qemu-options.hx
-index XXXXXXX..XXXXXXX 100644
---- a/qemu-options.hx
-+++ b/qemu-options.hx
-@@ -XXX,XX +XXX,XX @@ Example
- qemu-system-i386 --drive file=sheepdog://192.0.2.1:30000/MyVirtualMachine
- @end example
--See also @url{http://http://www.osrg.net/sheepdog/}.
-+See also @url{https://sheepdog.github.io/sheepdog/}.
- @item GlusterFS
- GlusterFS is a user space distributed file system.
---
-.9.3

The following changes since commit a1cf5fac2b929ffa2abd1285401f2535ff8c6fea:

Merge remote-tracking branch 'remotes/armbru/tags/pull-block-2017-02-21' into staging (2017-02-21 13:58:50 +0000)

are available in the git repository at:

git@github.com:codyprime/qemu-kvm-jtc.git tags/block-pull-request

for you to fetch changes up to 6135c5e12606b8413708384e3e7d43f6010c5941:

qemu-options: Fix broken sheepdog URL (2017-02-21 10:38:09 -0500)

----------------------------------------------------------------
Block patches
----------------------------------------------------------------

Anton Nefedov (1):
  mirror: do not increase offset during initial zero_or_discard phase

Jeff Cody (1):
  QAPI: Fix blockdev-add example documentation

Kevin Wolf (6):
  iscsi: Split URL into individual options
  iscsi: Handle -iscsi user/password in bdrv_parse_filename()
  iscsi: Add initiator-name option
  iscsi: Add header-digest option
  iscsi: Add timeout option
  iscsi: Add blockdev-add support

Thomas Huth (1):
  qemu-options: Fix broken sheepdog URL

block/iscsi.c        | 353 +++++++++++++++++++++++++++++++--------------------
 block/mirror.c       |   9 +-
 qapi/block-core.json | 125 +++++++++++++-----
 qemu-options.hx      |   2 +-
 4 files changed, 317 insertions(+), 172 deletions(-)

-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This introduces a .bdrv_parse_filename handler for iscsi which parses an
URL if given and translates it to individual options.

Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c | 193 ++++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 140 insertions(+), 53 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
     }
 }
 
-/* TODO Convert to fine grained options */
-static QemuOptsList runtime_opts = {
-    .name = "iscsi",
-    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
-    .desc = {
-        {
-            .name = "filename",
-            .type = QEMU_OPT_STRING,
-            .help = "URL to the iscsi image",
-        },
-        { /* end of list */ }
-    },
-};
-
 static struct scsi_task *iscsi_do_inquiry(struct iscsi_context *iscsi, int lun,
                                           int evpd, int pc, void **inq, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ out:
  * We support iscsi url's on the form
  * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
  */
+static void iscsi_parse_filename(const char *filename, QDict *options,
+                                 Error **errp)
+{
+    struct iscsi_url *iscsi_url;
+    const char *transport_name;
+    char *lun_str;
+
+    iscsi_url = iscsi_parse_full_url(NULL, filename);
+    if (iscsi_url == NULL) {
+        error_setg(errp, "Failed to parse URL : %s", filename);
+        return;
+    }
+
+#if LIBISCSI_API_VERSION >= (20160603)
+    switch (iscsi_url->transport) {
+    case TCP_TRANSPORT:
+        transport_name = "tcp";
+        break;
+    case ISER_TRANSPORT:
+        transport_name = "iser";
+        break;
+    default:
+        error_setg(errp, "Unknown transport type (%d)",
+                   iscsi_url->transport);
+        return;
+    }
+#else
+    transport_name = "tcp";
+#endif
+
+    qdict_set_default_str(options, "transport", transport_name);
+    qdict_set_default_str(options, "portal", iscsi_url->portal);
+    qdict_set_default_str(options, "target", iscsi_url->target);
+
+    lun_str = g_strdup_printf("%d", iscsi_url->lun);
+    qdict_set_default_str(options, "lun", lun_str);
+    g_free(lun_str);
+
+    if (iscsi_url->user[0] != '\0') {
+        qdict_set_default_str(options, "user", iscsi_url->user);
+        qdict_set_default_str(options, "password", iscsi_url->passwd);
+    }
+
+    iscsi_destroy_url(iscsi_url);
+}
+
+/* TODO Add -iscsi options */
+static QemuOptsList runtime_opts = {
+    .name = "iscsi",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
+    .desc = {
+        {
+            .name = "transport",
+            .type = QEMU_OPT_STRING,
+        },
+        {
+            .name = "portal",
+            .type = QEMU_OPT_STRING,
+        },
+        {
+            .name = "target",
+            .type = QEMU_OPT_STRING,
+        },
+        {
+            .name = "user",
+            .type = QEMU_OPT_STRING,
+        },
+        {
+            .name = "password",
+            .type = QEMU_OPT_STRING,
+        },
+        {
+            .name = "lun",
+            .type = QEMU_OPT_NUMBER,
+        },
+        { /* end of list */ }
+    },
+};
+
 static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
                       Error **errp)
 {
     IscsiLun *iscsilun = bs->opaque;
     struct iscsi_context *iscsi = NULL;
-    struct iscsi_url *iscsi_url = NULL;
     struct scsi_task *task = NULL;
     struct scsi_inquiry_standard *inq = NULL;
     struct scsi_inquiry_supported_pages *inq_vpd;
     char *initiator_name = NULL;
     QemuOpts *opts;
     Error *local_err = NULL;
-    const char *filename;
-    int i, ret = 0, timeout = 0;
+    const char *transport_name, *portal, *target;
+    const char *user, *password;
+#if LIBISCSI_API_VERSION >= (20160603)
+    enum iscsi_transport_type transport;
+#endif
+    int i, ret = 0, timeout = 0, lun;
 
     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, options, &local_err);
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 
-    filename = qemu_opt_get(opts, "filename");
+    transport_name = qemu_opt_get(opts, "transport");
+    portal = qemu_opt_get(opts, "portal");
+    target = qemu_opt_get(opts, "target");
+    user = qemu_opt_get(opts, "user");
+    password = qemu_opt_get(opts, "password");
+    lun = qemu_opt_get_number(opts, "lun", 0);
 
-    iscsi_url = iscsi_parse_full_url(iscsi, filename);
-    if (iscsi_url == NULL) {
-        error_setg(errp, "Failed to parse URL : %s", filename);
+    if (!transport_name || !portal || !target) {
+        error_setg(errp, "Need all of transport, portal and target options");
+        ret = -EINVAL;
+        goto out;
+    }
+    if (user && !password) {
+        error_setg(errp, "If a user name is given, a password is required");
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (!strcmp(transport_name, "tcp")) {
+#if LIBISCSI_API_VERSION >= (20160603)
+        transport = TCP_TRANSPORT;
+    } else if (!strcmp(transport_name, "iser")) {
+        transport = ISER_TRANSPORT;
+#else
+        /* TCP is what older libiscsi versions always use */
+#endif
+    } else {
+        error_setg(errp, "Unknown transport: %s", transport_name);
         ret = -EINVAL;
         goto out;
     }
 
     memset(iscsilun, 0, sizeof(IscsiLun));
 
-    initiator_name = parse_initiator_name(iscsi_url->target);
+    initiator_name = parse_initiator_name(target);
 
     iscsi = iscsi_create_context(initiator_name);
     if (iscsi == NULL) {
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 #if LIBISCSI_API_VERSION >= (20160603)
-    if (iscsi_init_transport(iscsi, iscsi_url->transport)) {
+    if (iscsi_init_transport(iscsi, transport)) {
         error_setg(errp, ("Error initializing transport."));
         ret = -EINVAL;
         goto out;
     }
 #endif
-    if (iscsi_set_targetname(iscsi, iscsi_url->target)) {
+    if (iscsi_set_targetname(iscsi, target)) {
         error_setg(errp, "iSCSI: Failed to set target name.");
         ret = -EINVAL;
         goto out;
     }
 
-    if (iscsi_url->user[0] != '\0') {
-        ret = iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
-                                              iscsi_url->passwd);
+    if (user) {
+        ret = iscsi_set_initiator_username_pwd(iscsi, user, password);
         if (ret != 0) {
             error_setg(errp, "Failed to set initiator username and password");
             ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* check if we got CHAP username/password via the options */
-    parse_chap(iscsi, iscsi_url->target, &local_err);
+    parse_chap(iscsi, target, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
         ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
 
     /* check if we got HEADER_DIGEST via the options */
-    parse_header_digest(iscsi, iscsi_url->target, &local_err);
+    parse_header_digest(iscsi, target, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
         ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* timeout handling is broken in libiscsi before 1.15.0 */
-    timeout = parse_timeout(iscsi_url->target);
+    timeout = parse_timeout(target);
 #if LIBISCSI_API_VERSION >= 20150621
     iscsi_set_timeout(iscsi, timeout);
 #else
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     }
 #endif
 
-    if (iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun) != 0) {
+    if (iscsi_full_connect_sync(iscsi, portal, lun) != 0) {
         error_setg(errp, "iSCSI: Failed to connect to LUN : %s",
             iscsi_get_error(iscsi));
         ret = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
 
     iscsilun->iscsi = iscsi;
     iscsilun->aio_context = bdrv_get_aio_context(bs);
-    iscsilun->lun   = iscsi_url->lun;
+    iscsilun->lun = lun;
     iscsilun->has_write_same = true;
 
     task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 0, 0,
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
 out:
     qemu_opts_del(opts);
     g_free(initiator_name);
-    if (iscsi_url != NULL) {
-        iscsi_destroy_url(iscsi_url);
-    }
     if (task != NULL) {
         scsi_free_scsi_task(task);
     }
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {
     .format_name     = "iscsi",
     .protocol_name   = "iscsi",
 
-    .instance_size   = sizeof(IscsiLun),
-    .bdrv_needs_filename = true,
-    .bdrv_file_open  = iscsi_open,
-    .bdrv_close      = iscsi_close,
-    .bdrv_create     = iscsi_create,
-    .create_opts     = &iscsi_create_opts,
-    .bdrv_reopen_prepare   = iscsi_reopen_prepare,
-    .bdrv_reopen_commit    = iscsi_reopen_commit,
-    .bdrv_invalidate_cache = iscsi_invalidate_cache,
+    .instance_size          = sizeof(IscsiLun),
+    .bdrv_parse_filename    = iscsi_parse_filename,
+    .bdrv_file_open         = iscsi_open,
+    .bdrv_close             = iscsi_close,
+    .bdrv_create            = iscsi_create,
+    .create_opts            = &iscsi_create_opts,
+    .bdrv_reopen_prepare    = iscsi_reopen_prepare,
+    .bdrv_reopen_commit     = iscsi_reopen_commit,
+    .bdrv_invalidate_cache  = iscsi_invalidate_cache,
 
     .bdrv_getlength  = iscsi_getlength,
     .bdrv_get_info   = iscsi_get_info,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {
     .format_name     = "iser",
     .protocol_name   = "iser",
 
-    .instance_size   = sizeof(IscsiLun),
-    .bdrv_needs_filename = true,
-    .bdrv_file_open  = iscsi_open,
-    .bdrv_close      = iscsi_close,
-    .bdrv_create     = iscsi_create,
-    .create_opts     = &iscsi_create_opts,
-    .bdrv_reopen_prepare   = iscsi_reopen_prepare,
-    .bdrv_reopen_commit    = iscsi_reopen_commit,
-    .bdrv_invalidate_cache = iscsi_invalidate_cache,
+    .instance_size          = sizeof(IscsiLun),
+    .bdrv_parse_filename    = iscsi_parse_filename,
+    .bdrv_file_open         = iscsi_open,
+    .bdrv_close             = iscsi_close,
+    .bdrv_create            = iscsi_create,
+    .create_opts            = &iscsi_create_opts,
+    .bdrv_reopen_prepare    = iscsi_reopen_prepare,
+    .bdrv_reopen_commit     = iscsi_reopen_commit,
+    .bdrv_invalidate_cache  = iscsi_invalidate_cache,
 
     .bdrv_getlength  = iscsi_getlength,
     .bdrv_get_info   = iscsi_get_info,
-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This splits the logic in the old parse_chap() function into a part that
parses the -iscsi options into the new driver-specific options, and
another part that actually applies those options (called apply_chap()
now).

Note that this means that username and password specified with -iscsi
only take effect when a URL is provided. This is intentional, -iscsi is
a legacy interface only supported for compatibility, new users should
use the proper driver-specific options.

Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c | 78 +++++++++++++++++++++++++++++++++--------------------------
 1 file changed, 44 insertions(+), 34 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ retry:
     return 0;
 }
 
-static void parse_chap(struct iscsi_context *iscsi, const char *target,
+static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
                        Error **errp)
 {
-    QemuOptsList *list;
-    QemuOpts *opts;
     const char *user = NULL;
     const char *password = NULL;
     const char *secretid;
     char *secret = NULL;
 
-    list = qemu_find_opts("iscsi");
-    if (!list) {
-        return;
-    }
-
-    opts = qemu_opts_find(list, target);
-    if (opts == NULL) {
-        opts = QTAILQ_FIRST(&list->head);
-        if (!opts) {
-            return;
-        }
-    }
-
     user = qemu_opt_get(opts, "user");
     if (!user) {
         return;
@@ -XXX,XX +XXX,XX @@ out:
     }
 }
 
+static void iscsi_parse_iscsi_option(const char *target, QDict *options)
+{
+    QemuOptsList *list;
+    QemuOpts *opts;
+    const char *user, *password, *password_secret;
+
+    list = qemu_find_opts("iscsi");
+    if (!list) {
+        return;
+    }
+
+    opts = qemu_opts_find(list, target);
+    if (opts == NULL) {
+        opts = QTAILQ_FIRST(&list->head);
+        if (!opts) {
+            return;
+        }
+    }
+
+    user = qemu_opt_get(opts, "user");
+    if (user) {
+        qdict_set_default_str(options, "user", user);
+    }
+
+    password = qemu_opt_get(opts, "password");
+    if (password) {
+        qdict_set_default_str(options, "password", password);
+    }
+
+    password_secret = qemu_opt_get(opts, "password-secret");
+    if (password_secret) {
+        qdict_set_default_str(options, "password-secret", password_secret);
+    }
+}
+
 /*
  * We support iscsi url's on the form
  * iscsi://[<username>%<password>@]<host>[:<port>]/<targetname>/<lun>
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_filename(const char *filename, QDict *options,
     qdict_set_default_str(options, "lun", lun_str);
     g_free(lun_str);
 
+    /* User/password from -iscsi take precedence over those from the URL */
+    iscsi_parse_iscsi_option(iscsi_url->target, options);
+
     if (iscsi_url->user[0] != '\0') {
         qdict_set_default_str(options, "user", iscsi_url->user);
         qdict_set_default_str(options, "password", iscsi_url->passwd);
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
             .type = QEMU_OPT_STRING,
         },
         {
+            .name = "password-secret",
+            .type = QEMU_OPT_STRING,
+        },
+        {
             .name = "lun",
             .type = QEMU_OPT_NUMBER,
         },
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     QemuOpts *opts;
     Error *local_err = NULL;
     const char *transport_name, *portal, *target;
-    const char *user, *password;
 #if LIBISCSI_API_VERSION >= (20160603)
     enum iscsi_transport_type transport;
 #endif
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     transport_name = qemu_opt_get(opts, "transport");
     portal = qemu_opt_get(opts, "portal");
     target = qemu_opt_get(opts, "target");
-    user = qemu_opt_get(opts, "user");
-    password = qemu_opt_get(opts, "password");
     lun = qemu_opt_get_number(opts, "lun", 0);
 
     if (!transport_name || !portal || !target) {
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
         ret = -EINVAL;
         goto out;
     }
-    if (user && !password) {
-        error_setg(errp, "If a user name is given, a password is required");
-        ret = -EINVAL;
-        goto out;
-    }
 
     if (!strcmp(transport_name, "tcp")) {
 #if LIBISCSI_API_VERSION >= (20160603)
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 
-    if (user) {
-        ret = iscsi_set_initiator_username_pwd(iscsi, user, password);
-        if (ret != 0) {
-            error_setg(errp, "Failed to set initiator username and password");
-            ret = -EINVAL;
-            goto out;
-        }
-    }
-
     /* check if we got CHAP username/password via the options */
-    parse_chap(iscsi, target, &local_err);
+    apply_chap(iscsi, opts, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
         ret = -EINVAL;
-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This was previously only available with -iscsi. Again, after this patch,
the -iscsi option only takes effect if an URL is given. New users are
supposed to use the new driver-specific option.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
     }
 }
 
-static char *parse_initiator_name(const char *target)
+static char *get_initiator_name(QemuOpts *opts)
 {
-    QemuOptsList *list;
-    QemuOpts *opts;
     const char *name;
     char *iscsi_name;
     UuidInfo *uuid_info;
 
-    list = qemu_find_opts("iscsi");
-    if (list) {
-        opts = qemu_opts_find(list, target);
-        if (!opts) {
-            opts = QTAILQ_FIRST(&list->head);
-        }
-        if (opts) {
-            name = qemu_opt_get(opts, "initiator-name");
-            if (name) {
-                return g_strdup(name);
-            }
-        }
+    name = qemu_opt_get(opts, "initiator-name");
+    if (name) {
+        return g_strdup(name);
     }
 
     uuid_info = qmp_query_uuid(NULL);
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
 {
     QemuOptsList *list;
     QemuOpts *opts;
-    const char *user, *password, *password_secret;
+    const char *user, *password, *password_secret, *initiator_name;
 
     list = qemu_find_opts("iscsi");
     if (!list) {
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
     if (password_secret) {
         qdict_set_default_str(options, "password-secret", password_secret);
     }
+
+    initiator_name = qemu_opt_get(opts, "initiator-name");
+    if (initiator_name) {
+        qdict_set_default_str(options, "initiator-name", initiator_name);
+    }
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
             .name = "lun",
             .type = QEMU_OPT_NUMBER,
         },
+        {
+            .name = "initiator-name",
+            .type = QEMU_OPT_STRING,
+        },
         { /* end of list */ }
     },
 };
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
 
     memset(iscsilun, 0, sizeof(IscsiLun));
 
-    initiator_name = parse_initiator_name(target);
+    initiator_name = get_initiator_name(opts);
 
     iscsi = iscsi_create_context(initiator_name);
     if (iscsi == NULL) {
-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This was previously only available with -iscsi. Again, after this patch,
the -iscsi option only takes effect if an URL is given. New users are
supposed to use the new driver-specific option.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c | 39 +++++++++++++++------------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
     g_free(secret);
 }
 
-static void parse_header_digest(struct iscsi_context *iscsi, const char *target,
+static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
                                 Error **errp)
 {
-    QemuOptsList *list;
-    QemuOpts *opts;
     const char *digest = NULL;
 
-    list = qemu_find_opts("iscsi");
-    if (!list) {
-        return;
-    }
-
-    opts = qemu_opts_find(list, target);
-    if (opts == NULL) {
-        opts = QTAILQ_FIRST(&list->head);
-        if (!opts) {
-            return;
-        }
-    }
-
     digest = qemu_opt_get(opts, "header-digest");
     if (!digest) {
-        return;
-    }
-
-    if (!strcmp(digest, "CRC32C")) {
+        iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
+    } else if (!strcmp(digest, "CRC32C")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
     } else if (!strcmp(digest, "NONE")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
 {
     QemuOptsList *list;
     QemuOpts *opts;
-    const char *user, *password, *password_secret, *initiator_name;
+    const char *user, *password, *password_secret, *initiator_name,
+               *header_digest;
 
     list = qemu_find_opts("iscsi");
     if (!list) {
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
     if (initiator_name) {
         qdict_set_default_str(options, "initiator-name", initiator_name);
     }
+
+    header_digest = qemu_opt_get(opts, "header-digest");
+    if (header_digest) {
+        qdict_set_default_str(options, "header-digest", header_digest);
+    }
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
             .name = "initiator-name",
             .type = QEMU_OPT_STRING,
         },
+        {
+            .name = "header-digest",
+            .type = QEMU_OPT_STRING,
+        },
         { /* end of list */ }
     },
 };
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
         goto out;
     }
 
-    iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
-
     /* check if we got HEADER_DIGEST via the options */
-    parse_header_digest(iscsi, target, &local_err);
+    apply_header_digest(iscsi, opts, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
         ret = -EINVAL;
-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This was previously only available with -iscsi. Again, after this patch,
the -iscsi option only takes effect if an URL is given. New users are
supposed to use the new driver-specific option.

All -iscsi options have a corresponding driver-specific option for the
iscsi block driver now.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c | 37 +++++++++++--------------------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static char *get_initiator_name(QemuOpts *opts)
     return iscsi_name;
 }
 
-static int parse_timeout(const char *target)
-{
-    QemuOptsList *list;
-    QemuOpts *opts;
-    const char *timeout;
-
-    list = qemu_find_opts("iscsi");
-    if (list) {
-        opts = qemu_opts_find(list, target);
-        if (!opts) {
-            opts = QTAILQ_FIRST(&list->head);
-        }
-        if (opts) {
-            timeout = qemu_opt_get(opts, "timeout");
-            if (timeout) {
-                return atoi(timeout);
-            }
-        }
-    }
-
-    return 0;
-}
-
 static void iscsi_nop_timed_event(void *opaque)
 {
     IscsiLun *iscsilun = opaque;
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
     QemuOptsList *list;
     QemuOpts *opts;
     const char *user, *password, *password_secret, *initiator_name,
-               *header_digest;
+               *header_digest, *timeout;
 
     list = qemu_find_opts("iscsi");
     if (!list) {
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
     if (header_digest) {
         qdict_set_default_str(options, "header-digest", header_digest);
     }
+
+    timeout = qemu_opt_get(opts, "timeout");
+    if (timeout) {
+        qdict_set_default_str(options, "timeout", timeout);
+    }
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_filename(const char *filename, QDict *options,
     iscsi_destroy_url(iscsi_url);
 }
 
-/* TODO Add -iscsi options */
 static QemuOptsList runtime_opts = {
     .name = "iscsi",
     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
             .name = "header-digest",
             .type = QEMU_OPT_STRING,
         },
+        {
+            .name = "timeout",
+            .type = QEMU_OPT_NUMBER,
+        },
         { /* end of list */ }
     },
 };
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* timeout handling is broken in libiscsi before 1.15.0 */
-    timeout = parse_timeout(target);
+    timeout = qemu_opt_get_number(opts, "timeout", 0);
 #if LIBISCSI_API_VERSION >= 20150621
     iscsi_set_timeout(iscsi, timeout);
 #else
-- 
2.9.3

From: Kevin Wolf <kwolf@redhat.com>

This adds blockdev-add support for iscsi devices.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/iscsi.c        | 14 ++++++----
 qapi/block-core.json | 75 ++++++++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 79 insertions(+), 10 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void apply_header_digest(struct iscsi_context *iscsi, QemuOpts *opts,
     digest = qemu_opt_get(opts, "header-digest");
     if (!digest) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
-    } else if (!strcmp(digest, "CRC32C")) {
+    } else if (!strcmp(digest, "crc32c")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C);
-    } else if (!strcmp(digest, "NONE")) {
+    } else if (!strcmp(digest, "none")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE);
-    } else if (!strcmp(digest, "CRC32C-NONE")) {
+    } else if (!strcmp(digest, "crc32c-none")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_CRC32C_NONE);
-    } else if (!strcmp(digest, "NONE-CRC32C")) {
+    } else if (!strcmp(digest, "none-crc32c")) {
         iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
     } else {
         error_setg(errp, "Invalid header-digest setting : %s", digest);
@@ -XXX,XX +XXX,XX @@ static void iscsi_parse_iscsi_option(const char *target, QDict *options)
 
     header_digest = qemu_opt_get(opts, "header-digest");
     if (header_digest) {
-        qdict_set_default_str(options, "header-digest", header_digest);
+        /* -iscsi takes upper case values, but QAPI only supports lower case
+         * enum constant names, so we have to convert here. */
+        char *qapi_value = g_ascii_strdown(header_digest, -1);
+        qdict_set_default_str(options, "header-digest", qapi_value);
+        g_free(qapi_value);
     }
 
     timeout = qemu_opt_get(opts, "timeout");
diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @nfs: Since 2.8
 # @replication: Since 2.8
 # @ssh: Since 2.8
+# @iscsi: Since 2.9
 #
 # Since: 2.0
 ##
 { 'enum': 'BlockdevDriver',
   'data': [ 'archipelago', 'blkdebug', 'blkverify', 'bochs', 'cloop',
             'dmg', 'file', 'ftp', 'ftps', 'gluster', 'host_cdrom',
-            'host_device', 'http', 'https', 'luks', 'nbd', 'nfs', 'null-aio',
-            'null-co', 'parallels', 'qcow', 'qcow2', 'qed', 'quorum', 'raw',
-            'replication', 'ssh', 'vdi', 'vhdx', 'vmdk', 'vpc',
-            'vvfat' ] }
+            'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
+            'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
+            'quorum', 'raw', 'replication', 'ssh', 'vdi', 'vhdx', 'vmdk',
+            'vpc', 'vvfat' ] }
 
 ##
 # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
             '*logfile': 'str' } }
 
 ##
+# @IscsiTransport:
+#
+# An enumeration of libiscsi transport types
+#
+# Since: 2.9
+##
+{ 'enum': 'IscsiTransport',
+  'data': [ 'tcp', 'iser' ] }
+
+##
+# @IscsiHeaderDigest:
+#
+# An enumeration of header digests supported by libiscsi
+#
+# Since: 2.9
+##
+{ 'enum': 'IscsiHeaderDigest',
+  'prefix': 'QAPI_ISCSI_HEADER_DIGEST',
+  'data': [ 'crc32c', 'none', 'crc32c-none', 'none-crc32c' ] }
+
+##
+# @BlockdevOptionsIscsi:
+#
+# @transport        The iscsi transport type
+#
+# @portal           The address of the iscsi portal
+#
+# @target           The target iqn name
+#
+# @lun              #optional LUN to connect to. Defaults to 0.
+#
+# @user             #optional User name to log in with. If omitted, no CHAP
+#                   authentication is performed.
+#
+# @password-secret  #optional The ID of a QCryptoSecret object providing
+#                   the password for the login. This option is required if
+#                   @user is specified.
+#
+# @initiator-name   #optional The iqn name we want to identify to the target
+#                   as. If this option is not specified, an initiator name is
+#                   generated automatically.
+#
+# @header-digest    #optional The desired header digest. Defaults to
+#                   none-crc32c.
+#
+# @timeout          #optional Timeout in seconds after which a request will
+#                   timeout. 0 means no timeout and is the default.
+#
+# Driver specific block device options for iscsi
+#
+# Since: 2.9
+##
+{ 'struct': 'BlockdevOptionsIscsi',
+  'data': { 'transport': 'IscsiTransport',
+            'portal': 'str',
+            'target': 'str',
+            '*lun': 'int',
+            '*user': 'str',
+            '*password-secret': 'str',
+            '*initiator-name': 'str',
+            '*header-digest': 'IscsiHeaderDigest',
+            '*timeout': 'int' } }
+
+##
 # @ReplicationMode:
 #
 # An enumeration of replication modes.
@@ -XXX,XX +XXX,XX @@
       'host_device':'BlockdevOptionsFile',
       'http':       'BlockdevOptionsCurl',
       'https':      'BlockdevOptionsCurl',
-# TODO iscsi: Wait for structured options
+      'iscsi':      'BlockdevOptionsIscsi',
       'luks':       'BlockdevOptionsLUKS',
       'nbd':        'BlockdevOptionsNbd',
       'nfs':        'BlockdevOptionsNfs',
-- 
2.9.3

Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 qapi/block-core.json | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # 1.
 # -> { "execute": "blockdev-add",
 #      "arguments": {
-#          "options" : { "driver": "qcow2",
-#                        "file": { "driver": "file",
-#                                  "filename": "test.qcow2" } } } }
+#           "driver": "qcow2",
+#           "node-name": "test1",
+#           "file": {
+#               "driver": "file",
+#               "filename": "test.qcow2"
+#            }
+#       }
+#     }
 # <- { "return": {} }
 #
 # 2.
 # -> { "execute": "blockdev-add",
 #      "arguments": {
-#          "options": {
-#            "driver": "qcow2",
-#            "node-name": "node0",
-#            "discard": "unmap",
-#            "cache": {
-#                "direct": true,
-#                "writeback": true
+#           "driver": "qcow2",
+#           "node-name": "node0",
+#           "discard": "unmap",
+#           "cache": {
+#              "direct": true
 #            },
 #            "file": {
-#                "driver": "file",
-#                "filename": "/tmp/test.qcow2"
+#              "driver": "file",
+#              "filename": "/tmp/test.qcow2"
 #            },
 #            "backing": {
-#                "driver": "raw",
-#                "file": {
-#                    "driver": "file",
-#                    "filename": "/dev/fdset/4"
+#               "driver": "raw",
+#               "file": {
+#                  "driver": "file",
+#                  "filename": "/dev/fdset/4"
 #                }
 #            }
-#          }
 #        }
 #      }
 #
@@ -XXX,XX +XXX,XX @@
 #
 # -> { "execute": "blockdev-add",
 #      "arguments": {
-#          "options": {
-#              "driver": "qcow2",
-#              "node-name": "node0",
-#              "file": {
-#                  "driver": "file",
-#                  "filename": "test.qcow2"
-#              }
-#          }
+#           "driver": "qcow2",
+#           "node-name": "node0",
+#           "file": {
+#               "driver": "file",
+#               "filename": "test.qcow2"
+#           }
 #      }
 #    }
 # <- { "return": {} }
-- 
2.9.3

From: Anton Nefedov <anton.nefedov@virtuozzo.com>

If explicit zeroing out before mirroring is required for the target image,
it moves the block job offset counter to EOF, then offset and len counters
count the image size twice. There is no harm but stats are confusing,
specifically the progress of the operation is always reported as 99% by
management tools.

The patch skips offset increase for the first "technical" pass over the
image. This should not cause any further harm.

Signed-off-by: Anton Nefedov <anton.nefedov@virtuozzo.com>
Signed-off-by: Denis V. Lunev <den@openvz.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1486045515-8009-1-git-send-email-den@openvz.org
CC: Jeff Cody <jcody@redhat.com>
CC: Kevin Wolf <kwolf@redhat.com>
CC: Max Reitz <mreitz@redhat.com>
CC: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/mirror.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob {
     bool waiting_for_io;
     int target_cluster_sectors;
     int max_iov;
+    bool initial_zeroing_ongoing;
 } MirrorBlockJob;
 
 typedef struct MirrorOp {
@@ -XXX,XX +XXX,XX @@ static void mirror_iteration_done(MirrorOp *op, int ret)
         if (s->cow_bitmap) {
             bitmap_set(s->cow_bitmap, chunk_num, nb_chunks);
         }
-        s->common.offset += (uint64_t)op->nb_sectors * BDRV_SECTOR_SIZE;
+        if (!s->initial_zeroing_ongoing) {
+            s->common.offset += (uint64_t)op->nb_sectors * BDRV_SECTOR_SIZE;
+        }
     }
-
     qemu_iovec_destroy(&op->qiov);
     g_free(op);
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
             return 0;
         }
 
+        s->initial_zeroing_ongoing = true;
         for (sector_num = 0; sector_num < end; ) {
             int nb_sectors = MIN(end - sector_num,
                 QEMU_ALIGN_DOWN(INT_MAX, s->granularity) >> BDRV_SECTOR_BITS);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
             mirror_throttle(s);
 
             if (block_job_is_cancelled(&s->common)) {
+                s->initial_zeroing_ongoing = false;
                 return 0;
             }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
         }
 
         mirror_wait_for_all_io(s);
+        s->initial_zeroing_ongoing = false;
     }
 
     /* First part, loop on the sectors and initialize the dirty bitmap.  */
-- 
2.9.3

The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:

Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)

are available in the Git repository at:

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

for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:

util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)

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

Add new thread-pool-min/thread-pool-max parameters to control the thread pool
used for async I/O.

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

Nicolas Saenz Julienne (3):
  Introduce event-loop-base abstract class
  util/main-loop: Introduce the main loop into QOM
  util/event-loop-base: Introduce options to set the thread pool size

-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

Introduce the 'event-loop-base' abstract class, it'll hold the
properties common to all event loops and provide the necessary hooks for
their creation and maintenance. Then have iothread inherit from it.

EventLoopBaseClass is defined as user creatable and provides a hook for
its children to attach themselves to the user creatable class 'complete'
function. It also provides an update_params() callback to propagate
property changes onto its children.

The new 'event-loop-base' class will live in the root directory. It is
built on its own using the 'link_whole' option (there are no direct
function dependencies between the class and its children, it all happens
trough 'constructor' magic). And also imposes new compilation
dependencies:

qom <- event-loop-base <- blockdev (iothread.c)

And in subsequent patches:

qom <- event-loop-base <- qemuutil (util/main-loop.c)

All this forced some amount of reordering in meson.build:

- Moved qom build definition before qemuutil. Doing it the other way
   around (i.e. moving qemuutil after qom) isn't possible as a lot of
   core libraries that live in between the two depend on it.

- Process the 'hw' subdir earlier, as it introduces files into the
   'qom' source set.

No functional changes intended.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    |  22 +++++--
 meson.build                      |  23 ++++---
 include/sysemu/event-loop-base.h |  36 +++++++++++
 include/sysemu/iothread.h        |   6 +-
 event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
 iothread.c                       |  65 ++++++-------------
 6 files changed, 192 insertions(+), 64 deletions(-)
 create mode 100644 include/sysemu/event-loop-base.h
 create mode 100644 event-loop-base.c

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*repeat': 'bool',
             '*grab-toggle': 'GrabToggleKeys' } }
 
+##
+# @EventLoopBaseProperties:
+#
+# Common properties for event loops
+#
+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+#                 0 means that the engine will use its default.
+#                 (default: 0)
+#
+# Since: 7.1
+##
+{ 'struct': 'EventLoopBaseProperties',
+  'data': { '*aio-max-batch': 'int' } }
+
 ##
 # @IothreadProperties:
 #
@@ -XXX,XX +XXX,XX @@
 #               algorithm detects it is spending too long polling without
 #               encountering events. 0 selects a default behaviour (default: 0)
 #
-# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
-#                 0 means that the engine will use its default
-#                 (default:0, since 6.1)
+# The @aio-max-batch option is available since 6.1.
 #
 # Since: 2.0
 ##
 { 'struct': 'IothreadProperties',
+  'base': 'EventLoopBaseProperties',
   'data': { '*poll-max-ns': 'int',
             '*poll-grow': 'int',
-            '*poll-shrink': 'int',
-            '*aio-max-batch': 'int' } }
+            '*poll-shrink': 'int' } }
 
 ##
 # @MemoryBackendProperties:
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ subdir('qom')
 subdir('authz')
 subdir('crypto')
 subdir('ui')
+subdir('hw')
 
 
 if enable_modules
@@ -XXX,XX +XXX,XX @@ if enable_modules
   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
 endif
 
+qom_ss = qom_ss.apply(config_host, strict: false)
+libqom = static_library('qom', qom_ss.sources() + genh,
+                        dependencies: [qom_ss.dependencies()],
+                        name_suffix: 'fa')
+qom = declare_dependency(link_whole: libqom)
+
+event_loop_base = files('event-loop-base.c')
+event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
+                                 build_by_default: true)
+event_loop_base = declare_dependency(link_whole: event_loop_base,
+                                     dependencies: [qom])
+
 stub_ss = stub_ss.apply(config_all, strict: false)
 
 util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
 subdir('net')
 subdir('replay')
 subdir('semihosting')
-subdir('hw')
 subdir('tcg')
 subdir('fpu')
 subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                              capture: true,
                              command: [undefsym, nm, '@INPUT@'])
 
-qom_ss = qom_ss.apply(config_host, strict: false)
-libqom = static_library('qom', qom_ss.sources() + genh,
-                        dependencies: [qom_ss.dependencies()],
-                        name_suffix: 'fa')
-
-qom = declare_dependency(link_whole: libqom)
-
 authz_ss = authz_ss.apply(config_host, strict: false)
 libauthz = static_library('authz', authz_ss.sources() + genh,
                           dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                              build_by_default: false)
 
 blockdev = declare_dependency(link_whole: [libblockdev],
-                              dependencies: [block])
+                              dependencies: [block, event_loop_base])
 
 qmp_ss = qmp_ss.apply(config_host, strict: false)
 libqmp = static_library('qmp', qmp_ss.sources() + genh,
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop backend
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+#ifndef QEMU_EVENT_LOOP_BASE_H
+#define QEMU_EVENT_LOOP_BASE_H
+
+#include "qom/object.h"
+#include "block/aio.h"
+#include "qemu/typedefs.h"
+
+#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
+OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
+                    EVENT_LOOP_BASE)
+
+struct EventLoopBaseClass {
+    ObjectClass parent_class;
+
+    void (*init)(EventLoopBase *base, Error **errp);
+    void (*update_params)(EventLoopBase *base, Error **errp);
+};
+
+struct EventLoopBase {
+    Object parent;
+
+    /* AioContext AIO engine parameters */
+    int64_t aio_max_batch;
+};
+#endif
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 @@
 #include "block/aio.h"
 #include "qemu/thread.h"
 #include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define TYPE_IOTHREAD "iothread"
 
 struct IOThread {
-    Object parent_obj;
+    EventLoopBase parent_obj;
 
     QemuThread thread;
     AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ struct IOThread {
     int64_t poll_max_ns;
     int64_t poll_grow;
     int64_t poll_shrink;
-
-    /* AioContext AIO engine parameters */
-    int64_t aio_max_batch;
 };
 typedef struct IOThread IOThread;
 
diff --git a/event-loop-base.c b/event-loop-base.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop base
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Stefan Hajnoczi <stefanha@redhat.com>
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "qom/object_interfaces.h"
+#include "qapi/error.h"
+#include "sysemu/event-loop-base.h"
+
+typedef struct {
+    const char *name;
+    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
+} EventLoopBaseParamInfo;
+
+static EventLoopBaseParamInfo aio_max_batch_info = {
+    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
+};
+
+static void event_loop_base_get_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)event_loop_base + info->offset;
+
+    visit_type_int64(v, name, field, errp);
+}
+
+static void event_loop_base_set_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)base + info->offset;
+    int64_t value;
+
+    if (!visit_type_int64(v, name, &value, errp)) {
+        return;
+    }
+
+    if (value < 0) {
+        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
+                   info->name, INT64_MAX);
+        return;
+    }
+
+    *field = value;
+
+    if (bc->update_params) {
+        bc->update_params(base, errp);
+    }
+
+    return;
+}
+
+static void event_loop_base_complete(UserCreatable *uc, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *base = EVENT_LOOP_BASE(uc);
+
+    if (bc->init) {
+        bc->init(base, errp);
+    }
+}
+
+static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
+{
+    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+    ucc->complete = event_loop_base_complete;
+
+    object_class_property_add(klass, "aio-max-batch", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &aio_max_batch_info);
+}
+
+static const TypeInfo event_loop_base_info = {
+    .name = TYPE_EVENT_LOOP_BASE,
+    .parent = TYPE_OBJECT,
+    .instance_size = sizeof(EventLoopBase),
+    .class_size = sizeof(EventLoopBaseClass),
+    .class_init = event_loop_base_class_init,
+    .abstract = true,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_USER_CREATABLE },
+        { }
+    }
+};
+
+static void register_types(void)
+{
+    type_register_static(&event_loop_base_info);
+}
+type_init(register_types);
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/module.h"
 #include "block/aio.h"
 #include "block/block.h"
+#include "sysemu/event-loop-base.h"
 #include "sysemu/iothread.h"
 #include "qapi/error.h"
 #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
     iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
 }
 
-static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
+static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
 {
+    IOThread *iothread = IOTHREAD(base);
     ERRP_GUARD();
 
+    if (!iothread->ctx) {
+        return;
+    }
+
     aio_context_set_poll_params(iothread->ctx,
                                 iothread->poll_max_ns,
                                 iothread->poll_grow,
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
     }
 
     aio_context_set_aio_params(iothread->ctx,
-                               iothread->aio_max_batch,
+                               iothread->parent_obj.aio_max_batch,
                                errp);
 }
 
-static void iothread_complete(UserCreatable *obj, Error **errp)
+
+static void iothread_init(EventLoopBase *base, Error **errp)
 {
     Error *local_error = NULL;
-    IOThread *iothread = IOTHREAD(obj);
+    IOThread *iothread = IOTHREAD(base);
     char *thread_name;
 
     iothread->stopping = false;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      */
     iothread_init_gcontext(iothread);
 
-    iothread_set_aio_context_params(iothread, &local_error);
+    iothread_set_aio_context_params(base, &local_error);
     if (local_error) {
         error_propagate(errp, local_error);
         aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      * to inherit.
      */
     thread_name = g_strdup_printf("IO %s",
-                        object_get_canonical_path_component(OBJECT(obj)));
+                        object_get_canonical_path_component(OBJECT(base)));
     qemu_thread_create(&iothread->thread, thread_name, iothread_run,
                        iothread, QEMU_THREAD_JOINABLE);
     g_free(thread_name);
@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
 static IOThreadParamInfo poll_shrink_info = {
     "poll-shrink", offsetof(IOThread, poll_shrink),
 };
-static IOThreadParamInfo aio_max_batch_info = {
-    "aio-max-batch", offsetof(IOThread, aio_max_batch),
-};
 
 static void iothread_get_param(Object *obj, Visitor *v,
         const char *name, IOThreadParamInfo *info, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
     }
 }
 
-static void iothread_get_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThreadParamInfo *info = opaque;
-
-    iothread_get_param(obj, v, name, info, errp);
-}
-
-static void iothread_set_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThread *iothread = IOTHREAD(obj);
-    IOThreadParamInfo *info = opaque;
-
-    if (!iothread_set_param(obj, v, name, info, errp)) {
-        return;
-    }
-
-    if (iothread->ctx) {
-        aio_context_set_aio_params(iothread->ctx,
-                                   iothread->aio_max_batch,
-                                   errp);
-    }
-}
-
 static void iothread_class_init(ObjectClass *klass, void *class_data)
 {
-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-    ucc->complete = iothread_complete;
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
+
+    bc->init = iothread_init;
+    bc->update_params = iothread_set_aio_context_params;
 
     object_class_property_add(klass, "poll-max-ns", "int",
                               iothread_get_poll_param,
@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
                               iothread_get_poll_param,
                               iothread_set_poll_param,
                               NULL, &poll_shrink_info);
-    object_class_property_add(klass, "aio-max-batch", "int",
-                              iothread_get_aio_param,
-                              iothread_set_aio_param,
-                              NULL, &aio_max_batch_info);
 }
 
 static const TypeInfo iothread_info = {
     .name = TYPE_IOTHREAD,
-    .parent = TYPE_OBJECT,
+    .parent = TYPE_EVENT_LOOP_BASE,
     .class_init = iothread_class_init,
     .instance_size = sizeof(IOThread),
     .instance_init = iothread_instance_init,
     .instance_finalize = iothread_instance_finalize,
-    .interfaces = (InterfaceInfo[]) {
-        {TYPE_USER_CREATABLE},
-        {}
-    },
 };
 
 static void iothread_register_types(void)
@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
     info->poll_max_ns = iothread->poll_max_ns;
     info->poll_grow = iothread->poll_grow;
     info->poll_shrink = iothread->poll_shrink;
-    info->aio_max_batch = iothread->aio_max_batch;
+    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
 
     QAPI_LIST_APPEND(*tail, info);
     return 0;
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

'event-loop-base' provides basic property handling for all 'AioContext'
based event loops. So let's define a new 'MainLoopClass' that inherits
from it. This will permit tweaking the main loop's properties through
qapi as well as through the command line using the '-object' keyword[1].
Only one instance of 'MainLoopClass' might be created at any time.

'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
mark 'MainLoop' as non-deletable.

[1] For example:
      -object main-loop,id=main-loop,aio-max-batch=<value>

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 13 ++++++++
 meson.build                      |  3 +-
 include/qemu/main-loop.h         | 10 ++++++
 include/sysemu/event-loop-base.h |  1 +
 event-loop-base.c                | 13 ++++++++
 util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
 6 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*poll-grow': 'int',
             '*poll-shrink': 'int' } }
 
+##
+# @MainLoopProperties:
+#
+# Properties for the main-loop object.
+#
+# Since: 7.1
+##
+{ 'struct': 'MainLoopProperties',
+  'base': 'EventLoopBaseProperties',
+  'data': {} }
+
 ##
 # @MemoryBackendProperties:
 #
@@ -XXX,XX +XXX,XX @@
     { 'name': 'input-linux',
       'if': 'CONFIG_LINUX' },
     'iothread',
+    'main-loop',
     { 'name': 'memory-backend-epc',
       'if': 'CONFIG_LINUX' },
     'memory-backend-file',
@@ -XXX,XX +XXX,XX @@
       'input-linux':                { 'type': 'InputLinuxProperties',
                                       'if': 'CONFIG_LINUX' },
       'iothread':                   'IothreadProperties',
+      'main-loop':                  'MainLoopProperties',
       'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
                                       'if': 'CONFIG_LINUX' },
       'memory-backend-file':        'MemoryBackendFileProperties',
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
                              sources: util_ss.sources() + stub_ss.sources() + genh,
                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
 qemuutil = declare_dependency(link_with: libqemuutil,
-                              sources: genh + version_res)
+                              sources: genh + version_res,
+                              dependencies: [event_loop_base])
 
 if have_system or have_user
   decodetree = generator(find_program('scripts/decodetree.py'),
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
 #define QEMU_MAIN_LOOP_H
 
 #include "block/aio.h"
+#include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define SIG_IPI SIGUSR1
 
+#define TYPE_MAIN_LOOP  "main-loop"
+OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
+
+struct MainLoop {
+    EventLoopBase parent_obj;
+};
+typedef struct MainLoop MainLoop;
+
 /**
  * qemu_init_main_loop: Set up the process so that it can run the main loop.
  *
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
 
     void (*init)(EventLoopBase *base, Error **errp);
     void (*update_params)(EventLoopBase *base, Error **errp);
+    bool (*can_be_deleted)(EventLoopBase *base);
 };
 
 struct EventLoopBase {
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
     }
 }
 
+static bool event_loop_base_can_be_deleted(UserCreatable *uc)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
+
+    if (bc->can_be_deleted) {
+        return bc->can_be_deleted(backend);
+    }
+
+    return true;
+}
+
 static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 {
     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
     ucc->complete = event_loop_base_complete;
+    ucc->can_be_deleted = event_loop_base_can_be_deleted;
 
     object_class_property_add(klass, "aio-max-batch", "int",
                               event_loop_base_get_param,
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
+#include "qom/object.h"
 
 #ifndef _WIN32
 #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
     return 0;
 }
 
+static void main_loop_update_params(EventLoopBase *base, Error **errp)
+{
+    if (!qemu_aio_context) {
+        error_setg(errp, "qemu aio context not ready");
+        return;
+    }
+
+    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+}
+
+MainLoop *mloop;
+
+static void main_loop_init(EventLoopBase *base, Error **errp)
+{
+    MainLoop *m = MAIN_LOOP(base);
+
+    if (mloop) {
+        error_setg(errp, "only one main-loop instance allowed");
+        return;
+    }
+
+    main_loop_update_params(base, errp);
+
+    mloop = m;
+    return;
+}
+
+static bool main_loop_can_be_deleted(EventLoopBase *base)
+{
+    return false;
+}
+
+static void main_loop_class_init(ObjectClass *oc, void *class_data)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
+
+    bc->init = main_loop_init;
+    bc->update_params = main_loop_update_params;
+    bc->can_be_deleted = main_loop_can_be_deleted;
+}
+
+static const TypeInfo main_loop_info = {
+    .name = TYPE_MAIN_LOOP,
+    .parent = TYPE_EVENT_LOOP_BASE,
+    .class_init = main_loop_class_init,
+    .instance_size = sizeof(MainLoop),
+};
+
+static void main_loop_register_types(void)
+{
+    type_register_static(&main_loop_info);
+}
+
+type_init(main_loop_register_types)
+
 static int max_priority;
 
 #ifndef _WIN32
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

The thread pool regulates itself: when idle, it kills threads until
empty, when in demand, it creates new threads until full. This behaviour
doesn't play well with latency sensitive workloads where the price of
creating a new thread is too high. For example, when paired with qemu's
'-mlock', or using safety features like SafeStack, creating a new thread
has been measured take multiple milliseconds.

In order to mitigate this let's introduce a new 'EventLoopBase'
property to set the thread pool size. The threads will be created during
the pool's initialization or upon updating the property's value, remain
available during its lifetime regardless of demand, and destroyed upon
freeing it. A properly characterized workload will then be able to
configure the pool to avoid any latency spikes.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 10 +++++-
 include/block/aio.h              | 10 ++++++
 include/block/thread-pool.h      |  3 ++
 include/sysemu/event-loop-base.h |  4 +++
 event-loop-base.c                | 23 +++++++++++++
 iothread.c                       |  3 ++
 util/aio-posix.c                 |  1 +
 util/async.c                     | 20 ++++++++++++
 util/main-loop.c                 |  9 ++++++
 util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 10 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
 #                 0 means that the engine will use its default.
 #                 (default: 0)
 #
+# @thread-pool-min: minimum number of threads reserved in the thread pool
+#                   (default:0)
+#
+# @thread-pool-max: maximum number of threads the thread pool can contain
+#                   (default:64)
+#
 # Since: 7.1
 ##
 { 'struct': 'EventLoopBaseProperties',
-  'data': { '*aio-max-batch': 'int' } }
+  'data': { '*aio-max-batch': 'int',
+            '*thread-pool-min': 'int',
+            '*thread-pool-max': 'int' } }
 
 ##
 # @IothreadProperties:
diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
     QSLIST_HEAD(, Coroutine) scheduled_coroutines;
     QEMUBH *co_schedule_bh;
 
+    int thread_pool_min;
+    int thread_pool_max;
     /* Thread pool for performing work and receiving completion callbacks.
      * Has its own locking.
      */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
 void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                 Error **errp);
 
+/**
+ * aio_context_set_thread_pool_params:
+ * @ctx: the aio context
+ * @min: min number of threads to have readily available in the thread pool
+ * @min: max number of threads the thread pool can contain
+ */
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp);
 #endif
diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/thread-pool.h
+++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
 
 #include "block/block.h"
 
+#define THREAD_POOL_MAX_THREADS_DEFAULT         64
+
 typedef int ThreadPoolFunc(void *opaque);
 
 typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
 int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
         ThreadPoolFunc *func, void *arg);
 void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
+void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
 
 #endif
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
 
     /* AioContext AIO engine parameters */
     int64_t aio_max_batch;
+
+    /* AioContext thread pool parameters */
+    int64_t thread_pool_min;
+    int64_t thread_pool_max;
 };
 #endif
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qom/object_interfaces.h"
 #include "qapi/error.h"
+#include "block/thread-pool.h"
 #include "sysemu/event-loop-base.h"
 
 typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
     ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
 } EventLoopBaseParamInfo;
 
+static void event_loop_base_instance_init(Object *obj)
+{
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+
+    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+}
+
 static EventLoopBaseParamInfo aio_max_batch_info = {
     "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
 };
+static EventLoopBaseParamInfo thread_pool_min_info = {
+    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
+};
+static EventLoopBaseParamInfo thread_pool_max_info = {
+    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
+};
 
 static void event_loop_base_get_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                               event_loop_base_get_param,
                               event_loop_base_set_param,
                               NULL, &aio_max_batch_info);
+    object_class_property_add(klass, "thread-pool-min", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_min_info);
+    object_class_property_add(klass, "thread-pool-max", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_max_info);
 }
 
 static const TypeInfo event_loop_base_info = {
     .name = TYPE_EVENT_LOOP_BASE,
     .parent = TYPE_OBJECT,
     .instance_size = sizeof(EventLoopBase),
+    .instance_init = event_loop_base_instance_init,
     .class_size = sizeof(EventLoopBaseClass),
     .class_init = event_loop_base_class_init,
     .abstract = true,
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_set_aio_context_params(EventLoopBase *base, Error **errp)
     aio_context_set_aio_params(iothread->ctx,
                                iothread->parent_obj.aio_max_batch,
                                errp);
+
+    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 
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 @@
 
 #include "qemu/osdep.h"
 #include "block/block.h"
+#include "block/thread-pool.h"
 #include "qemu/main-loop.h"
 #include "qemu/rcu.h"
 #include "qemu/rcu_queue.h"
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
 
     ctx->aio_max_batch = 0;
 
+    ctx->thread_pool_min = 0;
+    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+
     return ctx;
 fail:
     g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
     assert(!get_my_aiocontext());
     set_my_aiocontext(ctx);
 }
+
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp)
+{
+
+    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
+        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
+        return;
+    }
+
+    ctx->thread_pool_min = min;
+    ctx->thread_pool_max = max;
+
+    if (ctx->thread_pool) {
+        thread_pool_update_params(ctx->thread_pool, ctx);
+    }
+}
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/replay.h"
 #include "qemu/main-loop.h"
 #include "block/aio.h"
+#include "block/thread-pool.h"
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
 
 static void main_loop_update_params(EventLoopBase *base, Error **errp)
 {
+    ERRP_GUARD();
+
     if (!qemu_aio_context) {
         error_setg(errp, "qemu aio context not ready");
         return;
     }
 
     aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+    if (*errp) {
+        return;
+    }
+
+    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 MainLoop *mloop;
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     QemuMutex lock;
     QemuCond worker_stopped;
     QemuSemaphore sem;
-    int max_threads;
     QEMUBH *new_thread_bh;
 
     /* The following variables are only accessed from one AioContext. */
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     int new_threads;     /* backlog of threads we need to create */
     int pending_threads; /* threads created but not running yet */
     bool stopping;
+    int min_threads;
+    int max_threads;
 };
 
+static inline bool back_to_sleep(ThreadPool *pool, int ret)
+{
+    /*
+     * The semaphore timed out, we should exit the loop except when:
+     *  - There is work to do, we raced with the signal.
+     *  - The max threads threshold just changed, we raced with the signal.
+     *  - The thread pool forces a minimum number of readily available threads.
+     */
+    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
+            pool->cur_threads > pool->max_threads ||
+            pool->cur_threads <= pool->min_threads)) {
+            return true;
+    }
+
+    return false;
+}
+
 static void *worker_thread(void *opaque)
 {
     ThreadPool *pool = opaque;
@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
             ret = qemu_sem_timedwait(&pool->sem, 10000);
             qemu_mutex_lock(&pool->lock);
             pool->idle_threads--;
-        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
-        if (ret == -1 || pool->stopping) {
+        } while (back_to_sleep(pool, ret));
+        if (ret == -1 || pool->stopping ||
+            pool->cur_threads > pool->max_threads) {
             break;
         }
 
@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
     thread_pool_submit_aio(pool, func, arg, NULL, NULL);
 }
 
+void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
+{
+    qemu_mutex_lock(&pool->lock);
+
+    pool->min_threads = ctx->thread_pool_min;
+    pool->max_threads = ctx->thread_pool_max;
+
+    /*
+     * We either have to:
+     *  - Increase the number available of threads until over the min_threads
+     *    threshold.
+     *  - Decrease the number of available threads until under the max_threads
+     *    threshold.
+     *  - Do nothing. The current number of threads fall in between the min and
+     *    max thresholds. We'll let the pool manage itself.
+     */
+    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
+        spawn_thread(pool);
+    }
+
+    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
+        qemu_sem_post(&pool->sem);
+    }
+
+    qemu_mutex_unlock(&pool->lock);
+}
+
 static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
 {
     if (!ctx) {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
     qemu_mutex_init(&pool->lock);
     qemu_cond_init(&pool->worker_stopped);
     qemu_sem_init(&pool->sem, 0);
-    pool->max_threads = 64;
     pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
 
     QLIST_INIT(&pool->head);
     QTAILQ_INIT(&pool->request_list);
+
+    thread_pool_update_params(pool, ctx);
 }
 
 ThreadPool *thread_pool_new(AioContext *ctx)
-- 
2.35.1