From 882d09226b7f45b72c5b7763c4c4aba182e0f8a1 Mon Sep 17 00:00:00 2001

From: Maxim Levitsky <mlevitsk@redhat.com>

Date: Wed, 11 Mar 2020 10:51:43 +0000

Subject: [PATCH 02/20] block: Generic file creation fallback

RH-Author: Maxim Levitsky <mlevitsk@redhat.com>

Message-id: <20200311105147.13208-3-mlevitsk@redhat.com>

Patchwork-id: 94227

O-Subject: [RHEL-AV-8.2.0 qemu-kvm PATCH v2 2/6] block: Generic file creation fallback

Bugzilla: 1640894

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

RH-Acked-by: John Snow <jsnow@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

From: Max Reitz <mreitz@redhat.com>

If a protocol driver does not support image creation, we can see whether

maybe the file exists already.  If so, just truncating it will be

sufficient.

Signed-off-by: Max Reitz <mreitz@redhat.com>

Message-Id: <20200122164532.178040-3-mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

(cherry picked from commit fd17146cd93d1704cd96d7c2757b325fc7aac6fd)

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>

Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>

---

 block.c | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----

 1 file changed, 147 insertions(+), 12 deletions(-)

diff --git a/block.c b/block.c

index 2e5e8b6..3beec7f 100644

--- a/block.c

+++ b/block.c

@@ -532,20 +532,139 @@ out:

     return ret;

 }

-int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)

+/**

+ * Helper function for bdrv_create_file_fallback(): Resize @blk to at

+ * least the given @minimum_size.

+ *

+ * On success, return @blk's actual length.

+ * Otherwise, return -errno.

+ */

+static int64_t create_file_fallback_truncate(BlockBackend *blk,

+                                             int64_t minimum_size, Error **errp)

 {

-    BlockDriver *drv;

+    Error *local_err = NULL;

+    int64_t size;

+    int ret;

+

+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);

+    if (ret < 0 && ret != -ENOTSUP) {

+        error_propagate(errp, local_err);

+        return ret;

+    }

+

+    size = blk_getlength(blk);

+    if (size < 0) {

+        error_free(local_err);

+        error_setg_errno(errp, -size,

+                         "Failed to inquire the new image file's length");

+        return size;

+    }

+

+    if (size < minimum_size) {

+        /* Need to grow the image, but we failed to do that */

+        error_propagate(errp, local_err);

+        return -ENOTSUP;

+    }

+

+    error_free(local_err);

+    local_err = NULL;

+

+    return size;

+}

+

+/**

+ * Helper function for bdrv_create_file_fallback(): Zero the first

+ * sector to remove any potentially pre-existing image header.

+ */

+static int create_file_fallback_zero_first_sector(BlockBackend *blk,

+                                                  int64_t current_size,

+                                                  Error **errp)

+{

+    int64_t bytes_to_clear;

+    int ret;

+

+    bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);

+    if (bytes_to_clear) {

+        ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);

+        if (ret < 0) {

+            error_setg_errno(errp, -ret,

+                             "Failed to clear the new image's first sector");

+            return ret;

+        }

+    }

+

+    return 0;

+}

+

+static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,

+                                     QemuOpts *opts, Error **errp)

+{

+    BlockBackend *blk;

+    QDict *options = qdict_new();

+    int64_t size = 0;

+    char *buf = NULL;

+    PreallocMode prealloc;

     Error *local_err = NULL;

     int ret;

+    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);

+    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

+    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,

+                               PREALLOC_MODE_OFF, &local_err);

+    g_free(buf);

+    if (local_err) {

+        error_propagate(errp, local_err);

+        return -EINVAL;

+    }

+

+    if (prealloc != PREALLOC_MODE_OFF) {

+        error_setg(errp, "Unsupported preallocation mode '%s'",

+                   PreallocMode_str(prealloc));

+        return -ENOTSUP;

+    }

+

+    qdict_put_str(options, "driver", drv->format_name);

+

+    blk = blk_new_open(filename, NULL, options,

+                       BDRV_O_RDWR | BDRV_O_RESIZE, errp);

+    if (!blk) {

+        error_prepend(errp, "Protocol driver '%s' does not support image "

+                      "creation, and opening the image failed: ",

+                      drv->format_name);

+        return -EINVAL;

+    }

+

+    size = create_file_fallback_truncate(blk, size, errp);

+    if (size < 0) {

+        ret = size;

+        goto out;

+    }

+

+    ret = create_file_fallback_zero_first_sector(blk, size, errp);

+    if (ret < 0) {

+        goto out;

+    }

+

+    ret = 0;

+out:

+    blk_unref(blk);

+    return ret;

+}

+

+int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)

+{

+    BlockDriver *drv;

+

     drv = bdrv_find_protocol(filename, true, errp);

     if (drv == NULL) {

         return -ENOENT;

     }

-    ret = bdrv_create(drv, filename, opts, &local_err);

-    error_propagate(errp, local_err);

-    return ret;

+    if (drv->bdrv_co_create_opts) {

+        return bdrv_create(drv, filename, opts, errp);

+    } else {

+        return bdrv_create_file_fallback(filename, drv, opts, errp);

+    }

 }

 /**

@@ -1422,6 +1541,24 @@ QemuOptsList bdrv_runtime_opts = {

     },

 };

+static QemuOptsList fallback_create_opts = {

+    .name = "fallback-create-opts",

+    .head = QTAILQ_HEAD_INITIALIZER(fallback_create_opts.head),

+    .desc = {

+        {

+            .name = BLOCK_OPT_SIZE,

+            .type = QEMU_OPT_SIZE,

+            .help = "Virtual disk size"

+        },

+        {

+            .name = BLOCK_OPT_PREALLOC,

+            .type = QEMU_OPT_STRING,

+            .help = "Preallocation mode (allowed values: off)"

+        },

+        { /* end of list */ }

+    }

+};

+

 /*

  * Common part for opening disk images and files

  *

@@ -5743,14 +5880,12 @@ void bdrv_img_create(const char *filename, const char *fmt,

         return;

     }

-    if (!proto_drv->create_opts) {

-        error_setg(errp, "Protocol driver '%s' does not support image creation",

-                   proto_drv->format_name);

-        return;

-    }

-

     create_opts = qemu_opts_append(create_opts, drv->create_opts);

-    create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);

+    if (proto_drv->create_opts) {

+        create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);

+    } else {

+        create_opts = qemu_opts_append(create_opts, &fallback_create_opts);

+    }

     /* Create parameter list with default values */

     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);

-- 

1.8.3.1