Introduce qemuDomainBlockRebase2 which validates and parses list of
params.

Since new heavily reuses qemuDomainBlockRebase logic let's now make
qemuDomainBlockPull and qemuDomainBlockRebase stub functions.

Signed-off-by: Nikolai Barybin <nikolai.barybin@virtuozzo.com>
---
 src/qemu/qemu_driver.c | 113 +++++++++++++++++++++++++++++++++--------
 1 file changed, 93 insertions(+), 20 deletions(-)

diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index ac72ea5cb0..405c20045c 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14559,16 +14559,19 @@ qemuDomainBlockCopyCommon(virDomainObj *vm,
     return ret;
 }
 
+
 static int
-qemuDomainBlockRebase(virDomainPtr dom,
-                      const char *path,
-                      const char *base,
-                      unsigned long bandwidth,
-                      unsigned int flags)
+qemuDomainBlockRebase2(virDomainPtr dom,
+                       const char *path,
+                       virTypedParameterPtr params,
+                       int nparams,
+                       unsigned int flags)
 {
     virDomainObj *vm;
     int ret = -1;
-    unsigned long long speed = bandwidth;
+    size_t i = 0;
+    unsigned long long bandwidth = 0;
+    const char *base = NULL;
     g_autoptr(virStorageSource) dest = NULL;
 
     virCheckFlags(VIR_DOMAIN_BLOCK_REBASE_SHALLOW |
@@ -14579,12 +14582,30 @@ qemuDomainBlockRebase(virDomainPtr dom,
                   VIR_DOMAIN_BLOCK_REBASE_COPY_DEV |
                   VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES, -1);
 
+    if (virTypedParamsValidate(params, nparams,
+                               VIR_DOMAIN_BLOCK_REBASE_PARAM_BASE,
+                               VIR_TYPED_PARAM_STRING,
+                               VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH,
+                               VIR_TYPED_PARAM_ULLONG,
+                               NULL) < 0)
+        return -1;
+
     if (!(vm = qemuDomainObjFromDomain(dom)))
         return -1;
 
-    if (virDomainBlockRebaseEnsureACL(dom->conn, vm->def) < 0)
+    if (virDomainBlockRebase2EnsureACL(dom->conn, vm->def) < 0)
         goto cleanup;
 
+    for (i = 0; i < nparams; i++) {
+        virTypedParameterPtr param = &params[i];
+
+        if (STREQ(param->field, VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH)) {
+            bandwidth = param->value.ul;
+        } else if (STREQ(param->field, VIR_DOMAIN_BLOCK_REBASE_PARAM_BASE)) {
+            base = param->value.s;
+        }
+    }
+
     /* For normal rebase (enhanced blockpull), the common code handles
      * everything, including vm cleanup. */
     if (!(flags & VIR_DOMAIN_BLOCK_REBASE_COPY))
@@ -14602,13 +14623,13 @@ qemuDomainBlockRebase(virDomainPtr dom,
 
     /* Convert bandwidth MiB to bytes, if necessary */
     if (!(flags & VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES)) {
-        if (speed > LLONG_MAX >> 20) {
+        if (bandwidth > LLONG_MAX >> 20) {
             virReportError(VIR_ERR_OVERFLOW,
                            _("bandwidth must be less than %1$llu"),
                            LLONG_MAX >> 20);
             goto cleanup;
         }
-        speed <<= 20;
+        bandwidth <<= 20;
     }
 
     /* XXX: If we are doing a shallow copy but not reusing an external
@@ -14626,7 +14647,7 @@ qemuDomainBlockRebase(virDomainPtr dom,
     flags &= (VIR_DOMAIN_BLOCK_REBASE_SHALLOW |
               VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT);
     ret = qemuDomainBlockCopyCommon(vm, dom->conn, path, dest,
-                                    speed, 0, 0, flags, true);
+                                    bandwidth, 0, 0, flags, true);
     dest = NULL;
 
  cleanup:
@@ -14635,6 +14656,48 @@ qemuDomainBlockRebase(virDomainPtr dom,
 }
 
 
+static int
+qemuDomainBlockRebase(virDomainPtr dom,
+                      const char *path,
+                      const char *base,
+                      unsigned long bandwidth,
+                      unsigned int flags)
+{
+    int nparams = 0;
+    int maxparams = 0;
+    virTypedParameterPtr params = NULL;
+    int ret = -1;
+
+    if (base &&
+        virTypedParamsAddString(&params, &nparams, &maxparams,
+                                VIR_DOMAIN_BLOCK_REBASE_PARAM_BASE,
+                                base) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Failed to add param %1$s:%2$s to params list"),
+                       VIR_DOMAIN_BLOCK_REBASE_PARAM_BASE, base);
+        goto end;
+    }
+
+    if (bandwidth > 0 &&
+        virTypedParamsAddULLong(&params, &nparams, &maxparams,
+                                VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH,
+                                bandwidth) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Failed to add param %1$s:%2$lu to params list"),
+                       VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH, bandwidth);
+        goto end;
+    }
+
+    ret = qemuDomainBlockRebase2(dom, path, params, nparams, flags);
+
+ end:
+    virTypedParamsFree(params, nparams);
+    params = NULL;
+    nparams = 0;
+    return ret;
+}
+
+
 static int
 qemuDomainBlockCopy(virDomainPtr dom,
                     const char *disk,
@@ -14722,19 +14785,28 @@ qemuDomainBlockPull(virDomainPtr dom,
                     unsigned long bandwidth,
                     unsigned int flags)
 {
-    virDomainObj *vm;
-    virCheckFlags(VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES, -1);
-
-    if (!(vm = qemuDomainObjFromDomain(dom)))
-        return -1;
+    int nparams = 0;
+    int maxparams = 0;
+    virTypedParameterPtr params = NULL;
+    int ret = -1;
 
-    if (virDomainBlockPullEnsureACL(dom->conn, vm->def) < 0) {
-        virDomainObjEndAPI(&vm);
-        return -1;
+    if (bandwidth > 0 &&
+        virTypedParamsAddULLong(&params, &nparams, &maxparams,
+                                VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH,
+                                bandwidth) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Failed to add param %1$s:%2$lu to params list"),
+                       VIR_DOMAIN_BLOCK_REBASE_PARAM_BANDWIDTH, bandwidth);
+        goto end;
     }
 
-    /* qemuDomainBlockPullCommon consumes the reference on @vm */
-    return qemuDomainBlockPullCommon(vm, path, NULL, bandwidth, flags);
+    ret = qemuDomainBlockRebase2(dom, path, params, nparams, flags);
+
+ end:
+    virTypedParamsFree(params, nparams);
+    params = NULL;
+    nparams = 0;
+    return ret;
 }
 
 
@@ -20579,6 +20651,7 @@ static virHypervisorDriver qemuHypervisorDriver = {
     .domainBlockJobSetSpeed = qemuDomainBlockJobSetSpeed, /* 0.9.4 */
     .domainBlockPull = qemuDomainBlockPull, /* 0.9.4 */
     .domainBlockRebase = qemuDomainBlockRebase, /* 0.9.10 */
+    .domainBlockRebase2 = qemuDomainBlockRebase2, /* 11.6.0 */
     .domainBlockCopy = qemuDomainBlockCopy, /* 1.2.9 */
     .domainBlockCommit = qemuDomainBlockCommit, /* 1.0.0 */
     .connectIsAlive = qemuConnectIsAlive, /* 0.9.8 */
-- 
2.47.3