hw/input/hid.c Fix capslock hid code

[qemu.git] / qemu-img.c

diff --git a/qemu-img.c b/qemu-img.c
index 09e7e72f5ac4c3fa4ac5eb343734bd735a68eaea..7876258fa92a254e9b64df239122e2df283b3707 100644 (file)
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -31,6 +31,7 @@
 #include "sysemu/sysemu.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"
 #include "sysemu/sysemu.h"
 #include "sysemu/block-backend.h"
 #include "block/block_int.h"

+#include "block/blockjob.h"

 #include "block/qapi.h"
 #include <getopt.h>
 
 #include "block/qapi.h"
 #include <getopt.h>
 


@@ -687,16 +688,23 @@ static int img_check(int argc, char **argv)
         check->corruptions_fixed    = corruptions_fixed;
     }
 
         check->corruptions_fixed    = corruptions_fixed;
     }
 

-    switch (output_format) {
-    case OFORMAT_HUMAN:
-        dump_human_image_check(check, quiet);
-        break;
-    case OFORMAT_JSON:
-        dump_json_image_check(check, quiet);
-        break;
+    if (!ret) {
+        switch (output_format) {
+        case OFORMAT_HUMAN:
+            dump_human_image_check(check, quiet);
+            break;
+        case OFORMAT_JSON:
+            dump_json_image_check(check, quiet);
+            break;
+        }

     }
 
     if (ret || check->check_errors) {
     }
 
     if (ret || check->check_errors) {

+        if (ret) {
+            error_report("Check failed: %s", strerror(-ret));
+        } else {
+            error_report("Check failed");
+        }

         ret = 1;
         goto fail;
     }
         ret = 1;
         goto fail;
     }


@@ -715,18 +723,54 @@ fail:
     return ret;
 }
 
     return ret;
 }
 

+typedef struct CommonBlockJobCBInfo {
+    BlockDriverState *bs;
+    Error **errp;
+} CommonBlockJobCBInfo;
+
+static void common_block_job_cb(void *opaque, int ret)
+{
+    CommonBlockJobCBInfo *cbi = opaque;
+
+    if (ret < 0) {
+        error_setg_errno(cbi->errp, -ret, "Block job failed");
+    }
+
+    /* Drop this block job's reference */
+    bdrv_unref(cbi->bs);
+}
+
+static void run_block_job(BlockJob *job, Error **errp)
+{
+    AioContext *aio_context = bdrv_get_aio_context(job->bs);
+
+    do {
+        aio_poll(aio_context, true);
+        qemu_progress_print((float)job->offset / job->len * 100.f, 0);
+    } while (!job->ready);
+
+    block_job_complete_sync(job, errp);
+
+    /* A block job may finish instantaneously without publishing any progress,
+     * so just signal completion here */
+    qemu_progress_print(100.f, 0);
+}
+

 static int img_commit(int argc, char **argv)
 {
     int c, ret, flags;
 static int img_commit(int argc, char **argv)
 {
     int c, ret, flags;

-    const char *filename, *fmt, *cache;
+    const char *filename, *fmt, *cache, *base;

     BlockBackend *blk;
     BlockBackend *blk;

-    BlockDriverState *bs;
-    bool quiet = false;
+    BlockDriverState *bs, *base_bs;
+    bool progress = false, quiet = false, drop = false;
+    Error *local_err = NULL;
+    CommonBlockJobCBInfo cbi;

 
     fmt = NULL;
     cache = BDRV_DEFAULT_CACHE;
 
     fmt = NULL;
     cache = BDRV_DEFAULT_CACHE;

+    base = NULL;

     for(;;) {
     for(;;) {

-        c = getopt(argc, argv, "f:ht:q");
+        c = getopt(argc, argv, "f:ht:b:dpq");

         if (c == -1) {
             break;
         }
         if (c == -1) {
             break;
         }


@@ -741,17 +785,34 @@ static int img_commit(int argc, char **argv)
         case 't':
             cache = optarg;
             break;
         case 't':
             cache = optarg;
             break;

+        case 'b':
+            base = optarg;
+            /* -b implies -d */
+            drop = true;
+            break;
+        case 'd':
+            drop = true;
+            break;
+        case 'p':
+            progress = true;
+            break;

         case 'q':
             quiet = true;
             break;
         }
     }
         case 'q':
             quiet = true;
             break;
         }
     }

+
+    /* Progress is not shown in Quiet mode */
+    if (quiet) {
+        progress = false;
+    }
+

     if (optind != argc - 1) {
         error_exit("Expecting one image file name");
     }
     filename = argv[optind++];
 
     if (optind != argc - 1) {
         error_exit("Expecting one image file name");
     }
     filename = argv[optind++];
 

-    flags = BDRV_O_RDWR;
+    flags = BDRV_O_RDWR | BDRV_O_UNMAP;

     ret = bdrv_parse_cache_flags(cache, &flags);
     if (ret < 0) {
         error_report("Invalid cache option: %s", cache);
     ret = bdrv_parse_cache_flags(cache, &flags);
     if (ret < 0) {
         error_report("Invalid cache option: %s", cache);


@@ -764,29 +825,76 @@ static int img_commit(int argc, char **argv)
     }
     bs = blk_bs(blk);
 
     }
     bs = blk_bs(blk);
 

-    ret = bdrv_commit(bs);
-    switch(ret) {
-    case 0:
-        qprintf(quiet, "Image committed.\n");
-        break;
-    case -ENOENT:
-        error_report("No disk inserted");
-        break;
-    case -EACCES:
-        error_report("Image is read-only");
-        break;
-    case -ENOTSUP:
-        error_report("Image is already committed");
-        break;
-    default:
-        error_report("Error while committing image");
-        break;
+    qemu_progress_init(progress, 1.f);
+    qemu_progress_print(0.f, 100);
+
+    if (base) {
+        base_bs = bdrv_find_backing_image(bs, base);
+        if (!base_bs) {
+            error_set(&local_err, QERR_BASE_NOT_FOUND, base);
+            goto done;
+        }
+    } else {
+        /* This is different from QMP, which by default uses the deepest file in
+         * the backing chain (i.e., the very base); however, the traditional
+         * behavior of qemu-img commit is using the immediate backing file. */
+        base_bs = bs->backing_hd;
+        if (!base_bs) {
+            error_setg(&local_err, "Image does not have a backing file");
+            goto done;
+        }
+    }
+
+    cbi = (CommonBlockJobCBInfo){
+        .errp = &local_err,
+        .bs   = bs,
+    };
+
+    commit_active_start(bs, base_bs, 0, BLOCKDEV_ON_ERROR_REPORT,
+                        common_block_job_cb, &cbi, &local_err);
+    if (local_err) {
+        goto done;
+    }
+
+    /* The block job will swap base_bs and bs (which is not what we really want
+     * here, but okay) and unref base_bs (after the swap, i.e., the old top
+     * image). In order to still be able to empty that top image afterwards,
+     * increment the reference counter here preemptively. */
+    if (!drop) {
+        bdrv_ref(base_bs);

     }
 
     }
 

+    run_block_job(bs->job, &local_err);
+    if (local_err) {
+        goto unref_backing;
+    }
+
+    if (!drop && base_bs->drv->bdrv_make_empty) {
+        ret = base_bs->drv->bdrv_make_empty(base_bs);
+        if (ret) {
+            error_setg_errno(&local_err, -ret, "Could not empty %s",
+                             filename);
+            goto unref_backing;
+        }
+    }
+
+unref_backing:
+    if (!drop) {
+        bdrv_unref(base_bs);
+    }
+
+done:
+    qemu_progress_end();
+

     blk_unref(blk);
     blk_unref(blk);

-    if (ret) {
+
+    if (local_err) {
+        qerror_report_err(local_err);
+        error_free(local_err);

         return 1;
     }
         return 1;
     }

+
+    qprintf(quiet, "Image committed.\n");

     return 0;
 }
 
     return 0;
 }
 


@@ -1018,7 +1126,6 @@ static int img_compare(int argc, char **argv)
 
     blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
     if (!blk1) {
 
     blk1 = img_open("image_1", filename1, fmt1, flags, true, quiet);
     if (!blk1) {

-        error_report("Can't open file %s", filename1);

         ret = 2;
         goto out3;
     }
         ret = 2;
         goto out3;
     }


@@ -1026,7 +1133,6 @@ static int img_compare(int argc, char **argv)
 
     blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
     if (!blk2) {
 
     blk2 = img_open("image_2", filename2, fmt2, flags, true, quiet);
     if (!blk2) {

-        error_report("Can't open file %s", filename2);

         ret = 2;
         goto out2;
     }
         ret = 2;
         goto out2;
     }


@@ -1374,7 +1480,6 @@ static int img_convert(int argc, char **argv)
                              true, quiet);
         g_free(id);
         if (!blk[bs_i]) {
                              true, quiet);
         g_free(id);
         if (!blk[bs_i]) {

-            error_report("Could not open '%s'", argv[optind + bs_i]);

             ret = -1;
             goto out;
         }
             ret = -1;
             goto out;
         }


@@ -1426,6 +1531,20 @@ static int img_convert(int argc, char **argv)
         goto out;
     }
 
         goto out;
     }
 

+    if (!drv->create_opts) {
+        error_report("Format driver '%s' does not support image creation",
+                     drv->format_name);
+        ret = -1;
+        goto out;
+    }
+
+    if (!proto_drv->create_opts) {
+        error_report("Protocol driver '%s' does not support image creation",
+                     proto_drv->format_name);
+        ret = -1;
+        goto out;
+    }
+

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


@@ -2763,6 +2882,12 @@ out:
     return 0;
 }
 
     return 0;
 }
 

+static void amend_status_cb(BlockDriverState *bs,
+                            int64_t offset, int64_t total_work_size)
+{
+    qemu_progress_print(100.f * offset / total_work_size, 0);
+}
+

 static int img_amend(int argc, char **argv)
 {
     int c, ret = 0;
 static int img_amend(int argc, char **argv)
 {
     int c, ret = 0;


@@ -2771,13 +2896,13 @@ static int img_amend(int argc, char **argv)
     QemuOpts *opts = NULL;
     const char *fmt = NULL, *filename, *cache;
     int flags;
     QemuOpts *opts = NULL;
     const char *fmt = NULL, *filename, *cache;
     int flags;

-    bool quiet = false;
+    bool quiet = false, progress = false;

     BlockBackend *blk = NULL;
     BlockDriverState *bs = NULL;
 
     cache = BDRV_DEFAULT_CACHE;
     for (;;) {
     BlockBackend *blk = NULL;
     BlockDriverState *bs = NULL;
 
     cache = BDRV_DEFAULT_CACHE;
     for (;;) {

-        c = getopt(argc, argv, "ho:f:t:q");
+        c = getopt(argc, argv, "ho:f:t:pq");

         if (c == -1) {
             break;
         }
         if (c == -1) {
             break;
         }


@@ -2807,6 +2932,9 @@ static int img_amend(int argc, char **argv)
             case 't':
                 cache = optarg;
                 break;
             case 't':
                 cache = optarg;
                 break;

+            case 'p':
+                progress = true;
+                break;

             case 'q':
                 quiet = true;
                 break;
             case 'q':
                 quiet = true;
                 break;


@@ -2817,6 +2945,11 @@ static int img_amend(int argc, char **argv)
         error_exit("Must specify options (-o)");
     }
 
         error_exit("Must specify options (-o)");
     }
 

+    if (quiet) {
+        progress = false;
+    }
+    qemu_progress_init(progress, 1.0);
+

     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
     if (fmt && has_help_option(options)) {
         /* If a format is explicitly specified (and possibly no filename is
     filename = (optind == argc - 1) ? argv[argc - 1] : NULL;
     if (fmt && has_help_option(options)) {
         /* If a format is explicitly specified (and possibly no filename is


@@ -2826,7 +2959,9 @@ static int img_amend(int argc, char **argv)
     }
 
     if (optind != argc - 1) {
     }
 
     if (optind != argc - 1) {

-        error_exit("Expecting one image file name");
+        error_report("Expecting one image file name");
+        ret = -1;
+        goto out;

     }
 
     flags = BDRV_O_FLAGS | BDRV_O_RDWR;
     }
 
     flags = BDRV_O_FLAGS | BDRV_O_RDWR;


@@ -2838,7 +2973,6 @@ static int img_amend(int argc, char **argv)
 
     blk = img_open("image", filename, fmt, flags, true, quiet);
     if (!blk) {
 
     blk = img_open("image", filename, fmt, flags, true, quiet);
     if (!blk) {

-        error_report("Could not open image '%s'", filename);

         ret = -1;
         goto out;
     }
         ret = -1;
         goto out;
     }


@@ -2852,6 +2986,13 @@ static int img_amend(int argc, char **argv)
         goto out;
     }
 
         goto out;
     }
 

+    if (!bs->drv->create_opts) {
+        error_report("Format driver '%s' does not support any options to amend",
+                     fmt);
+        ret = -1;
+        goto out;
+    }
+

     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
     if (options && qemu_opts_do_parse(opts, options, NULL)) {
     create_opts = qemu_opts_append(create_opts, bs->drv->create_opts);
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
     if (options && qemu_opts_do_parse(opts, options, NULL)) {


@@ -2860,13 +3001,18 @@ static int img_amend(int argc, char **argv)
         goto out;
     }
 
         goto out;
     }
 

-    ret = bdrv_amend_options(bs, opts);
+    /* In case the driver does not call amend_status_cb() */
+    qemu_progress_print(0.f, 0);
+    ret = bdrv_amend_options(bs, opts, &amend_status_cb);
+    qemu_progress_print(100.f, 0);

     if (ret < 0) {
         error_report("Error while amending options: %s", strerror(-ret));
         goto out;
     }
 
 out:
     if (ret < 0) {
         error_report("Error while amending options: %s", strerror(-ret));
         goto out;
     }
 
 out:

+    qemu_progress_end();
+

     blk_unref(blk);
     qemu_opts_del(opts);
     qemu_opts_free(create_opts);
     blk_unref(blk);
     qemu_opts_del(opts);
     qemu_opts_free(create_opts);