qemu-img.c 57.3 KB
Newer Older
B
bellard 已提交
1
/*
B
bellard 已提交
2
 * QEMU disk image utility
3
 *
B
bellard 已提交
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24 25 26
#include "qapi-visit.h"
#include "qapi/qmp-output-visitor.h"
#include "qjson.h"
P
pbrook 已提交
27
#include "qemu-common.h"
28
#include "qemu-option.h"
K
Kevin Wolf 已提交
29
#include "qemu-error.h"
30
#include "osdep.h"
31
#include "sysemu.h"
32
#include "block_int.h"
33
#include <getopt.h>
34
#include <stdio.h>
B
bellard 已提交
35

36 37 38 39
#ifdef _WIN32
#include <windows.h>
#endif

A
Anthony Liguori 已提交
40
typedef struct img_cmd_t {
41 42
    const char *name;
    int (*handler)(int argc, char **argv);
A
Anthony Liguori 已提交
43
} img_cmd_t;
44

45
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
46
#define BDRV_O_FLAGS BDRV_O_CACHE_WB
47
#define BDRV_DEFAULT_CACHE "writeback"
48

B
bellard 已提交
49 50 51 52 53
static void format_print(void *opaque, const char *name)
{
    printf(" %s", name);
}

B
blueswir1 已提交
54
/* Please keep in synch with qemu-img.texi */
P
pbrook 已提交
55
static void help(void)
B
bellard 已提交
56
{
57 58
    const char *help_msg =
           "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
59 60 61 62
           "usage: qemu-img command [command options]\n"
           "QEMU disk image utility\n"
           "\n"
           "Command syntax:\n"
63 64 65 66 67
#define DEF(option, callback, arg_string)        \
           "  " arg_string "\n"
#include "qemu-img-cmds.h"
#undef DEF
#undef GEN_DOCS
68 69 70 71
           "\n"
           "Command parameters:\n"
           "  'filename' is a disk image filename\n"
           "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
72
           "  'cache' is the cache mode used to write the output disk image, the valid\n"
73 74
           "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
           "    'directsync' and 'unsafe' (default for convert)\n"
75 76 77 78 79 80 81 82 83 84 85 86 87
           "  'size' is the disk image size in bytes. Optional suffixes\n"
           "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
           "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
           "  'output_filename' is the destination disk image filename\n"
           "  'output_fmt' is the destination format\n"
           "  'options' is a comma separated list of format specific options in a\n"
           "    name=value format. Use -o ? for an overview of the options supported by the\n"
           "    used format\n"
           "  '-c' indicates that target image must be compressed (qcow format only)\n"
           "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
           "       match exactly. The image doesn't need a working backing file before\n"
           "       rebasing in this case (useful for renaming the backing file)\n"
           "  '-h' with or without a command shows this help and lists the supported formats\n"
88
           "  '-p' show progress of command (only certain commands)\n"
89 90
           "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
           "       for qemu-img to create a sparse image during conversion\n"
91
           "  '--output' takes the format in which the output must be done (human or json)\n"
92
           "\n"
93 94 95 96
           "Parameters to check subcommand:\n"
           "  '-r' tries to repair any inconsistencies that are found during the check.\n"
           "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
           "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
97
           "       hiding corruption that has already occurred.\n"
98
           "\n"
99 100 101 102 103
           "Parameters to snapshot subcommand:\n"
           "  'snapshot' is the name of the snapshot to create, apply or delete\n"
           "  '-a' applies a snapshot (revert disk to saved state)\n"
           "  '-c' creates a snapshot\n"
           "  '-d' deletes a snapshot\n"
104 105 106
           "  '-l' lists all snapshots in the given image\n";

    printf("%s\nSupported formats:", help_msg);
B
bellard 已提交
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
    bdrv_iterate_format(format_print, NULL);
    printf("\n");
    exit(1);
}

#if defined(WIN32)
/* XXX: put correct support for win32 */
static int read_password(char *buf, int buf_size)
{
    int c, i;
    printf("Password: ");
    fflush(stdout);
    i = 0;
    for(;;) {
        c = getchar();
        if (c == '\n')
            break;
        if (i < (buf_size - 1))
            buf[i++] = c;
    }
    buf[i] = '\0';
    return 0;
}

#else

#include <termios.h>

static struct termios oldtty;

static void term_exit(void)
{
    tcsetattr (0, TCSANOW, &oldtty);
}

static void term_init(void)
{
    struct termios tty;

    tcgetattr (0, &tty);
    oldtty = tty;

    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                          |INLCR|IGNCR|ICRNL|IXON);
    tty.c_oflag |= OPOST;
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
    tty.c_cflag &= ~(CSIZE|PARENB);
    tty.c_cflag |= CS8;
    tty.c_cc[VMIN] = 1;
    tty.c_cc[VTIME] = 0;
157

B
bellard 已提交
158 159 160 161 162
    tcsetattr (0, TCSANOW, &tty);

    atexit(term_exit);
}

P
pbrook 已提交
163
static int read_password(char *buf, int buf_size)
B
bellard 已提交
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
{
    uint8_t ch;
    int i, ret;

    printf("password: ");
    fflush(stdout);
    term_init();
    i = 0;
    for(;;) {
        ret = read(0, &ch, 1);
        if (ret == -1) {
            if (errno == EAGAIN || errno == EINTR) {
                continue;
            } else {
                ret = -1;
                break;
            }
        } else if (ret == 0) {
            ret = -1;
            break;
        } else {
            if (ch == '\r') {
                ret = 0;
                break;
            }
            if (i < (buf_size - 1))
                buf[i++] = ch;
        }
    }
    term_exit();
    buf[i] = '\0';
    printf("\n");
    return ret;
}
#endif

200 201 202 203 204 205 206 207
static int print_block_option_help(const char *filename, const char *fmt)
{
    BlockDriver *drv, *proto_drv;
    QEMUOptionParameter *create_options = NULL;

    /* Find driver and parse its options */
    drv = bdrv_find_format(fmt);
    if (!drv) {
208
        error_report("Unknown file format '%s'", fmt);
209 210 211 212 213
        return 1;
    }

    proto_drv = bdrv_find_protocol(filename);
    if (!proto_drv) {
214
        error_report("Unknown protocol '%s'", filename);
215 216 217 218 219 220 221 222 223 224 225 226
        return 1;
    }

    create_options = append_option_parameters(create_options,
                                              drv->create_options);
    create_options = append_option_parameters(create_options,
                                              proto_drv->create_options);
    print_option_help(create_options);
    free_option_parameters(create_options);
    return 0;
}

227
static BlockDriverState *bdrv_new_open(const char *filename,
228
                                       const char *fmt,
229 230
                                       int flags,
                                       bool require_io)
231 232 233 234
{
    BlockDriverState *bs;
    BlockDriver *drv;
    char password[256];
235
    int ret;
236

237
    bs = bdrv_new("image");
238

239 240
    if (fmt) {
        drv = bdrv_find_format(fmt);
241
        if (!drv) {
242
            error_report("Unknown file format '%s'", fmt);
243 244
            goto fail;
        }
245 246 247
    } else {
        drv = NULL;
    }
248 249 250 251

    ret = bdrv_open(bs, filename, flags, drv);
    if (ret < 0) {
        error_report("Could not open '%s': %s", filename, strerror(-ret));
252
        goto fail;
253
    }
254

255
    if (bdrv_is_encrypted(bs) && require_io) {
256
        printf("Disk image '%s' is encrypted.\n", filename);
257
        if (read_password(password, sizeof(password)) < 0) {
258
            error_report("No password given");
259 260 261
            goto fail;
        }
        if (bdrv_set_key(bs, password) < 0) {
262
            error_report("invalid password");
263 264
            goto fail;
        }
265 266
    }
    return bs;
267 268 269 270 271
fail:
    if (bs) {
        bdrv_delete(bs);
    }
    return NULL;
272 273
}

274
static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
275 276
                                 const char *base_filename,
                                 const char *base_fmt)
277 278 279
{
    if (base_filename) {
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
280 281
            error_report("Backing file not supported for file format '%s'",
                         fmt);
282
            return -1;
283 284 285 286
        }
    }
    if (base_fmt) {
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
287 288
            error_report("Backing file format not supported for file "
                         "format '%s'", fmt);
289
            return -1;
290 291
        }
    }
292
    return 0;
293 294
}

B
bellard 已提交
295 296
static int img_create(int argc, char **argv)
{
297
    int c;
298
    uint64_t img_size = -1;
B
bellard 已提交
299
    const char *fmt = "raw";
300
    const char *base_fmt = NULL;
B
bellard 已提交
301 302
    const char *filename;
    const char *base_filename = NULL;
303
    char *options = NULL;
304
    Error *local_err = NULL;
305

B
bellard 已提交
306
    for(;;) {
307
        c = getopt(argc, argv, "F:b:f:he6o:");
308
        if (c == -1) {
B
bellard 已提交
309
            break;
310
        }
B
bellard 已提交
311
        switch(c) {
J
Jes Sorensen 已提交
312
        case '?':
B
bellard 已提交
313 314 315
        case 'h':
            help();
            break;
316 317 318
        case 'F':
            base_fmt = optarg;
            break;
B
bellard 已提交
319 320 321 322 323 324 325
        case 'b':
            base_filename = optarg;
            break;
        case 'f':
            fmt = optarg;
            break;
        case 'e':
326
            error_report("option -e is deprecated, please use \'-o "
327 328
                  "encryption\' instead!");
            return 1;
329
        case '6':
330
            error_report("option -6 is deprecated, please use \'-o "
331 332
                  "compat6\' instead!");
            return 1;
333 334 335
        case 'o':
            options = optarg;
            break;
B
bellard 已提交
336 337
        }
    }
338

339
    /* Get the filename */
340
    if (optind >= argc) {
341
        help();
342
    }
343 344
    filename = argv[optind++];

345 346
    /* Get image size, if specified */
    if (optind < argc) {
347
        int64_t sval;
348 349 350
        char *end;
        sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
        if (sval < 0 || *end) {
351
            error_report("Invalid image size specified! You may use k, M, G or "
352
                  "T suffixes for ");
353
            error_report("kilobytes, megabytes, gigabytes and terabytes.");
354
            return 1;
355 356 357 358
        }
        img_size = (uint64_t)sval;
    }

359
    if (options && is_help_option(options)) {
360
        return print_block_option_help(filename, fmt);
361 362
    }

363 364 365 366 367
    bdrv_img_create(filename, fmt, base_filename, base_fmt,
                    options, img_size, BDRV_O_FLAGS, &local_err);
    if (error_is_set(&local_err)) {
        error_report("%s", error_get_pretty(local_err));
        error_free(local_err);
368 369
        return 1;
    }
370

B
bellard 已提交
371 372 373
    return 0;
}

374 375 376 377 378 379 380 381
/*
 * Checks an image for consistency. Exit codes:
 *
 * 0 - Check completed, image is good
 * 1 - Check not completed because of internal errors
 * 2 - Check completed, image is corrupted
 * 3 - Check completed, image has leaked clusters, but is good otherwise
 */
382 383 384 385 386
static int img_check(int argc, char **argv)
{
    int c, ret;
    const char *filename, *fmt;
    BlockDriverState *bs;
387
    BdrvCheckResult result;
388
    int fix = 0;
389
    int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
390 391 392

    fmt = NULL;
    for(;;) {
393
        c = getopt(argc, argv, "f:hr:");
394
        if (c == -1) {
395
            break;
396
        }
397
        switch(c) {
J
Jes Sorensen 已提交
398
        case '?':
399 400 401 402 403 404
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
405 406 407 408 409 410 411 412 413 414 415
        case 'r':
            flags |= BDRV_O_RDWR;

            if (!strcmp(optarg, "leaks")) {
                fix = BDRV_FIX_LEAKS;
            } else if (!strcmp(optarg, "all")) {
                fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
            } else {
                help();
            }
            break;
416 417
        }
    }
418
    if (optind >= argc) {
419
        help();
420
    }
421 422
    filename = argv[optind++];

423
    bs = bdrv_new_open(filename, fmt, flags, true);
424 425 426
    if (!bs) {
        return 1;
    }
427
    ret = bdrv_check(bs, &result, fix);
428 429

    if (ret == -ENOTSUP) {
430
        error_report("This image format does not support checks");
431 432 433 434
        bdrv_delete(bs);
        return 1;
    }

435 436 437 438 439 440 441 442 443 444
    if (result.corruptions_fixed || result.leaks_fixed) {
        printf("The following inconsistencies were found and repaired:\n\n"
               "    %d leaked clusters\n"
               "    %d corruptions\n\n"
               "Double checking the fixed image now...\n",
               result.leaks_fixed,
               result.corruptions_fixed);
        ret = bdrv_check(bs, &result, 0);
    }

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
    if (!(result.corruptions || result.leaks || result.check_errors)) {
        printf("No errors were found on the image.\n");
    } else {
        if (result.corruptions) {
            printf("\n%d errors were found on the image.\n"
                "Data may be corrupted, or further writes to the image "
                "may corrupt it.\n",
                result.corruptions);
        }

        if (result.leaks) {
            printf("\n%d leaked clusters were found on the image.\n"
                "This means waste of disk space, but no harm to data.\n",
                result.leaks);
        }

        if (result.check_errors) {
            printf("\n%d internal errors have occurred during the check.\n",
                result.check_errors);
464 465 466
        }
    }

467 468 469 470 471 472 473
    if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
        printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
        result.bfi.allocated_clusters, result.bfi.total_clusters,
        result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
        result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
    }

474
    bdrv_delete(bs);
475 476 477 478 479

    if (ret < 0 || result.check_errors) {
        printf("\nAn error has occurred during the check: %s\n"
            "The check is not complete and may have missed error.\n",
            strerror(-ret));
480 481
        return 1;
    }
482 483 484 485 486 487 488 489

    if (result.corruptions) {
        return 2;
    } else if (result.leaks) {
        return 3;
    } else {
        return 0;
    }
490 491
}

B
bellard 已提交
492 493
static int img_commit(int argc, char **argv)
{
494 495
    int c, ret, flags;
    const char *filename, *fmt, *cache;
B
bellard 已提交
496 497 498
    BlockDriverState *bs;

    fmt = NULL;
499
    cache = BDRV_DEFAULT_CACHE;
B
bellard 已提交
500
    for(;;) {
501
        c = getopt(argc, argv, "f:ht:");
502
        if (c == -1) {
B
bellard 已提交
503
            break;
504
        }
B
bellard 已提交
505
        switch(c) {
J
Jes Sorensen 已提交
506
        case '?':
B
bellard 已提交
507 508 509 510 511 512
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
513 514 515
        case 't':
            cache = optarg;
            break;
B
bellard 已提交
516 517
        }
    }
518
    if (optind >= argc) {
B
bellard 已提交
519
        help();
520
    }
B
bellard 已提交
521 522
    filename = argv[optind++];

523
    flags = BDRV_O_RDWR;
524
    ret = bdrv_parse_cache_flags(cache, &flags);
525 526 527 528 529
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

530
    bs = bdrv_new_open(filename, fmt, flags, true);
531 532 533
    if (!bs) {
        return 1;
    }
B
bellard 已提交
534 535 536 537 538 539
    ret = bdrv_commit(bs);
    switch(ret) {
    case 0:
        printf("Image committed.\n");
        break;
    case -ENOENT:
540
        error_report("No disk inserted");
B
bellard 已提交
541 542
        break;
    case -EACCES:
543
        error_report("Image is read-only");
B
bellard 已提交
544 545
        break;
    case -ENOTSUP:
546
        error_report("Image is already committed");
B
bellard 已提交
547 548
        break;
    default:
549
        error_report("Error while committing image");
B
bellard 已提交
550 551 552 553
        break;
    }

    bdrv_delete(bs);
554 555 556
    if (ret) {
        return 1;
    }
B
bellard 已提交
557 558 559
    return 0;
}

560 561 562 563 564 565 566
/*
 * Returns true iff the first sector pointed to by 'buf' contains at least
 * a non-NUL byte.
 *
 * 'pnum' is set to the number of sectors (including and immediately following
 * the first one) that are known to be in the same allocated/unallocated state.
 */
B
bellard 已提交
567 568
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
{
569 570
    bool is_zero;
    int i;
B
bellard 已提交
571 572 573 574 575

    if (n <= 0) {
        *pnum = 0;
        return 0;
    }
576
    is_zero = buffer_is_zero(buf, 512);
B
bellard 已提交
577 578
    for(i = 1; i < n; i++) {
        buf += 512;
579
        if (is_zero != buffer_is_zero(buf, 512)) {
B
bellard 已提交
580
            break;
581
        }
B
bellard 已提交
582 583
    }
    *pnum = i;
584
    return !is_zero;
B
bellard 已提交
585 586
}

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
/*
 * Like is_allocated_sectors, but if the buffer starts with a used sector,
 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
 * breaking up write requests for only small sparse areas.
 */
static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
    int min)
{
    int ret;
    int num_checked, num_used;

    if (n < min) {
        min = n;
    }

    ret = is_allocated_sectors(buf, n, pnum);
    if (!ret) {
        return ret;
    }

    num_used = *pnum;
    buf += BDRV_SECTOR_SIZE * *pnum;
    n -= *pnum;
    num_checked = num_used;

    while (n > 0) {
        ret = is_allocated_sectors(buf, n, pnum);

        buf += BDRV_SECTOR_SIZE * *pnum;
        n -= *pnum;
        num_checked += *pnum;
        if (ret) {
            num_used = num_checked;
        } else if (*pnum >= min) {
            break;
        }
    }

    *pnum = num_used;
    return 1;
}

K
Kevin Wolf 已提交
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
/*
 * Compares two buffers sector by sector. Returns 0 if the first sector of both
 * buffers matches, non-zero otherwise.
 *
 * pnum is set to the number of sectors (including and immediately following
 * the first one) that are known to have the same comparison result
 */
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
    int *pnum)
{
    int res, i;

    if (n <= 0) {
        *pnum = 0;
        return 0;
    }

    res = !!memcmp(buf1, buf2, 512);
    for(i = 1; i < n; i++) {
        buf1 += 512;
        buf2 += 512;

        if (!!memcmp(buf1, buf2, 512) != res) {
            break;
        }
    }

    *pnum = i;
    return res;
}

660
#define IO_BUF_SIZE (2 * 1024 * 1024)
B
bellard 已提交
661 662 663

static int img_convert(int argc, char **argv)
{
664
    int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
665 666
    int progress = 0, flags;
    const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
667
    BlockDriver *drv, *proto_drv;
668
    BlockDriverState **bs = NULL, *out_bs = NULL;
669 670
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
    uint64_t bs_sectors;
671
    uint8_t * buf = NULL;
B
bellard 已提交
672
    const uint8_t *buf1;
B
bellard 已提交
673
    BlockDriverInfo bdi;
674
    QEMUOptionParameter *param = NULL, *create_options = NULL;
675
    QEMUOptionParameter *out_baseimg_param;
676
    char *options = NULL;
E
edison 已提交
677
    const char *snapshot_name = NULL;
678
    float local_progress = 0;
679
    int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
B
bellard 已提交
680 681 682

    fmt = NULL;
    out_fmt = "raw";
683
    cache = "unsafe";
684
    out_baseimg = NULL;
685
    compress = 0;
B
bellard 已提交
686
    for(;;) {
687
        c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
688
        if (c == -1) {
B
bellard 已提交
689
            break;
690
        }
B
bellard 已提交
691
        switch(c) {
J
Jes Sorensen 已提交
692
        case '?':
B
bellard 已提交
693 694 695 696 697 698 699 700 701
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
        case 'O':
            out_fmt = optarg;
            break;
702 703 704
        case 'B':
            out_baseimg = optarg;
            break;
B
bellard 已提交
705
        case 'c':
706
            compress = 1;
B
bellard 已提交
707 708
            break;
        case 'e':
709
            error_report("option -e is deprecated, please use \'-o "
710 711
                  "encryption\' instead!");
            return 1;
712
        case '6':
713
            error_report("option -6 is deprecated, please use \'-o "
714 715
                  "compat6\' instead!");
            return 1;
716 717 718
        case 'o':
            options = optarg;
            break;
E
edison 已提交
719 720 721
        case 's':
            snapshot_name = optarg;
            break;
722 723 724
        case 'S':
        {
            int64_t sval;
725 726 727
            char *end;
            sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
            if (sval < 0 || *end) {
728 729 730 731 732 733 734
                error_report("Invalid minimum zero buffer size for sparse output specified");
                return 1;
            }

            min_sparse = sval / BDRV_SECTOR_SIZE;
            break;
        }
735 736 737
        case 'p':
            progress = 1;
            break;
738 739 740
        case 't':
            cache = optarg;
            break;
B
bellard 已提交
741 742
        }
    }
743

744
    bs_n = argc - optind - 1;
745 746 747
    if (bs_n < 1) {
        help();
    }
748 749

    out_filename = argv[argc - 1];
750

751 752 753
    /* Initialize before goto out */
    qemu_progress_init(progress, 2.0);

754
    if (options && is_help_option(options)) {
755 756 757 758
        ret = print_block_option_help(out_filename, out_fmt);
        goto out;
    }

759
    if (bs_n > 1 && out_baseimg) {
760 761
        error_report("-B makes no sense when concatenating multiple input "
                     "images");
762 763
        ret = -1;
        goto out;
764
    }
765

766 767
    qemu_progress_print(0, 100);

768
    bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
769 770 771

    total_sectors = 0;
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
772
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true);
773
        if (!bs[bs_i]) {
774
            error_report("Could not open '%s'", argv[optind + bs_i]);
775 776 777
            ret = -1;
            goto out;
        }
778 779 780
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
        total_sectors += bs_sectors;
    }
B
bellard 已提交
781

E
edison 已提交
782 783
    if (snapshot_name != NULL) {
        if (bs_n > 1) {
784
            error_report("No support for concatenating multiple snapshot");
E
edison 已提交
785 786 787 788
            ret = -1;
            goto out;
        }
        if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
789
            error_report("Failed to load snapshot");
E
edison 已提交
790 791 792 793 794
            ret = -1;
            goto out;
        }
    }

795
    /* Find driver and parse its options */
B
bellard 已提交
796
    drv = bdrv_find_format(out_fmt);
797
    if (!drv) {
798
        error_report("Unknown file format '%s'", out_fmt);
799 800 801
        ret = -1;
        goto out;
    }
802

803
    proto_drv = bdrv_find_protocol(out_filename);
804
    if (!proto_drv) {
805
        error_report("Unknown protocol '%s'", out_filename);
806 807 808
        ret = -1;
        goto out;
    }
809 810 811 812 813

    create_options = append_option_parameters(create_options,
                                              drv->create_options);
    create_options = append_option_parameters(create_options,
                                              proto_drv->create_options);
814

815
    if (options) {
816
        param = parse_option_parameters(options, create_options, param);
817
        if (param == NULL) {
818
            error_report("Invalid options for file format '%s'.", out_fmt);
819 820
            ret = -1;
            goto out;
821 822
        }
    } else {
823
        param = parse_option_parameters("", create_options, param);
824 825 826
    }

    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
827
    ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
828 829 830
    if (ret < 0) {
        goto out;
    }
831

832 833 834 835 836 837
    /* Get backing file name if -o backing_file was used */
    out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
    if (out_baseimg_param) {
        out_baseimg = out_baseimg_param->value.s;
    }

838
    /* Check if compression is supported */
839
    if (compress) {
840 841
        QEMUOptionParameter *encryption =
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
842 843
        QEMUOptionParameter *preallocation =
            get_option_parameter(param, BLOCK_OPT_PREALLOC);
844 845

        if (!drv->bdrv_write_compressed) {
846
            error_report("Compression not supported for this file format");
847 848
            ret = -1;
            goto out;
849 850 851
        }

        if (encryption && encryption->value.n) {
852 853
            error_report("Compression and encryption not supported at "
                         "the same time");
854 855
            ret = -1;
            goto out;
856
        }
857 858 859 860 861 862 863 864 865

        if (preallocation && preallocation->value.s
            && strcmp(preallocation->value.s, "off"))
        {
            error_report("Compression and preallocation not supported at "
                         "the same time");
            ret = -1;
            goto out;
        }
866 867 868 869
    }

    /* Create the new image */
    ret = bdrv_create(drv, out_filename, param);
B
bellard 已提交
870 871
    if (ret < 0) {
        if (ret == -ENOTSUP) {
872 873
            error_report("Formatting not supported for file format '%s'",
                         out_fmt);
874
        } else if (ret == -EFBIG) {
875 876
            error_report("The image size is too large for file format '%s'",
                         out_fmt);
B
bellard 已提交
877
        } else {
878 879
            error_report("%s: error while converting %s: %s",
                         out_filename, out_fmt, strerror(-ret));
B
bellard 已提交
880
        }
881
        goto out;
B
bellard 已提交
882
    }
883

884
    flags = BDRV_O_RDWR;
885
    ret = bdrv_parse_cache_flags(cache, &flags);
886 887 888 889 890
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

891
    out_bs = bdrv_new_open(out_filename, out_fmt, flags, true);
892 893 894 895
    if (!out_bs) {
        ret = -1;
        goto out;
    }
B
bellard 已提交
896

897 898 899
    bs_i = 0;
    bs_offset = 0;
    bdrv_get_geometry(bs[0], &bs_sectors);
K
Kevin Wolf 已提交
900
    buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
901

902
    if (compress) {
903 904
        ret = bdrv_get_info(out_bs, &bdi);
        if (ret < 0) {
905
            error_report("could not get block driver info");
906 907
            goto out;
        }
B
bellard 已提交
908
        cluster_size = bdi.cluster_size;
909
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
910
            error_report("invalid cluster size");
911 912 913
            ret = -1;
            goto out;
        }
B
bellard 已提交
914 915
        cluster_sectors = cluster_size >> 9;
        sector_num = 0;
916 917

        nb_sectors = total_sectors;
918 919 920 921
        if (nb_sectors != 0) {
            local_progress = (float)100 /
                (nb_sectors / MIN(nb_sectors, cluster_sectors));
        }
922

B
bellard 已提交
923
        for(;;) {
924 925 926 927
            int64_t bs_num;
            int remainder;
            uint8_t *buf2;

B
bellard 已提交
928 929 930 931 932 933 934
            nb_sectors = total_sectors - sector_num;
            if (nb_sectors <= 0)
                break;
            if (nb_sectors >= cluster_sectors)
                n = cluster_sectors;
            else
                n = nb_sectors;
935 936 937 938 939 940 941 942 943 944 945 946 947

            bs_num = sector_num - bs_offset;
            assert (bs_num >= 0);
            remainder = n;
            buf2 = buf;
            while (remainder > 0) {
                int nlow;
                while (bs_num == bs_sectors) {
                    bs_i++;
                    assert (bs_i < bs_n);
                    bs_offset += bs_sectors;
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    bs_num = 0;
B
Blue Swirl 已提交
948 949 950
                    /* printf("changing part: sector_num=%" PRId64 ", "
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
951 952 953 954 955
                }
                assert (bs_num < bs_sectors);

                nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;

956 957
                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
                if (ret < 0) {
958 959
                    error_report("error while reading sector %" PRId64 ": %s",
                                 bs_num, strerror(-ret));
960 961
                    goto out;
                }
962 963 964 965 966 967 968 969

                buf2 += nlow * 512;
                bs_num += nlow;

                remainder -= nlow;
            }
            assert (remainder == 0);

970
            if (n < cluster_sectors) {
B
bellard 已提交
971
                memset(buf + n * 512, 0, cluster_size - n * 512);
972
            }
973
            if (!buffer_is_zero(buf, cluster_size)) {
974 975 976
                ret = bdrv_write_compressed(out_bs, sector_num, buf,
                                            cluster_sectors);
                if (ret != 0) {
977 978
                    error_report("error while compressing sector %" PRId64
                                 ": %s", sector_num, strerror(-ret));
979 980
                    goto out;
                }
B
bellard 已提交
981 982
            }
            sector_num += n;
983
            qemu_progress_print(local_progress, 100);
B
bellard 已提交
984
        }
B
bellard 已提交
985 986
        /* signal EOF to align */
        bdrv_write_compressed(out_bs, 0, NULL, 0);
B
bellard 已提交
987
    } else {
K
Kevin Wolf 已提交
988 989
        int has_zero_init = bdrv_has_zero_init(out_bs);

990
        sector_num = 0; // total number of sectors converted so far
991
        nb_sectors = total_sectors - sector_num;
992 993 994 995
        if (nb_sectors != 0) {
            local_progress = (float)100 /
                (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
        }
996

B
bellard 已提交
997 998
        for(;;) {
            nb_sectors = total_sectors - sector_num;
999
            if (nb_sectors <= 0) {
B
bellard 已提交
1000
                break;
1001 1002
            }
            if (nb_sectors >= (IO_BUF_SIZE / 512)) {
B
bellard 已提交
1003
                n = (IO_BUF_SIZE / 512);
1004
            } else {
B
bellard 已提交
1005
                n = nb_sectors;
1006
            }
1007 1008 1009 1010 1011 1012

            while (sector_num - bs_offset >= bs_sectors) {
                bs_i ++;
                assert (bs_i < bs_n);
                bs_offset += bs_sectors;
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
B
Blue Swirl 已提交
1013 1014
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1015 1016 1017
                   sector_num, bs_i, bs_offset, bs_sectors); */
            }

1018
            if (n > bs_offset + bs_sectors - sector_num) {
1019
                n = bs_offset + bs_sectors - sector_num;
1020
            }
1021

K
Kevin Wolf 已提交
1022
            if (has_zero_init) {
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
                /* If the output image is being created as a copy on write image,
                   assume that sectors which are unallocated in the input image
                   are present in both the output's and input's base images (no
                   need to copy them). */
                if (out_baseimg) {
                    if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
                                           n, &n1)) {
                        sector_num += n1;
                        continue;
                    }
                    /* The next 'n1' sectors are allocated in the input image. Copy
                       only those as they may be followed by unallocated sectors. */
                    n = n1;
1036 1037 1038
                }
            } else {
                n1 = n;
1039 1040
            }

1041 1042
            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
            if (ret < 0) {
1043 1044
                error_report("error while reading sector %" PRId64 ": %s",
                             sector_num - bs_offset, strerror(-ret));
1045 1046
                goto out;
            }
B
bellard 已提交
1047 1048 1049 1050 1051
            /* NOTE: at the same time we convert, we do not write zero
               sectors to have a chance to compress the image. Ideally, we
               should add a specific call to have the info to go faster */
            buf1 = buf;
            while (n > 0) {
1052 1053
                /* If the output image is being created as a copy on write image,
                   copy all sectors even the ones containing only NUL bytes,
1054 1055 1056 1057 1058
                   because they may differ from the sectors in the base image.

                   If the output is to a host device, we also write out
                   sectors that are entirely 0, since whatever data was
                   already there is garbage, not 0s. */
K
Kevin Wolf 已提交
1059
                if (!has_zero_init || out_baseimg ||
1060
                    is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1061 1062
                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
                    if (ret < 0) {
1063 1064
                        error_report("error while writing sector %" PRId64
                                     ": %s", sector_num, strerror(-ret));
1065 1066
                        goto out;
                    }
B
bellard 已提交
1067 1068 1069 1070 1071
                }
                sector_num += n1;
                n -= n1;
                buf1 += n1 * 512;
            }
1072
            qemu_progress_print(local_progress, 100);
B
bellard 已提交
1073 1074
        }
    }
1075
out:
1076
    qemu_progress_end();
1077 1078
    free_option_parameters(create_options);
    free_option_parameters(param);
K
Kevin Wolf 已提交
1079
    qemu_vfree(buf);
1080 1081 1082
    if (out_bs) {
        bdrv_delete(out_bs);
    }
1083 1084 1085 1086 1087
    if (bs) {
        for (bs_i = 0; bs_i < bs_n; bs_i++) {
            if (bs[bs_i]) {
                bdrv_delete(bs[bs_i]);
            }
1088
        }
1089
        g_free(bs);
1090 1091 1092 1093
    }
    if (ret) {
        return 1;
    }
B
bellard 已提交
1094 1095 1096
    return 0;
}

B
bellard 已提交
1097

B
bellard 已提交
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
static void dump_snapshots(BlockDriverState *bs)
{
    QEMUSnapshotInfo *sn_tab, *sn;
    int nb_sns, i;
    char buf[256];

    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
    if (nb_sns <= 0)
        return;
    printf("Snapshot list:\n");
    printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
    for(i = 0; i < nb_sns; i++) {
        sn = &sn_tab[i];
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
    }
1113
    g_free(sn_tab);
B
bellard 已提交
1114 1115
}

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
static void dump_json_image_info_list(ImageInfoList *list)
{
    Error *errp = NULL;
    QString *str;
    QmpOutputVisitor *ov = qmp_output_visitor_new();
    QObject *obj;
    visit_type_ImageInfoList(qmp_output_get_visitor(ov),
                             &list, NULL, &errp);
    obj = qmp_output_get_qobject(ov);
    str = qobject_to_json_pretty(obj);
    assert(str != NULL);
    printf("%s\n", qstring_get_str(str));
    qobject_decref(obj);
    qmp_output_visitor_cleanup(ov);
    QDECREF(str);
}

1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
static void collect_snapshots(BlockDriverState *bs , ImageInfo *info)
{
    int i, sn_count;
    QEMUSnapshotInfo *sn_tab = NULL;
    SnapshotInfoList *info_list, *cur_item = NULL;
    sn_count = bdrv_snapshot_list(bs, &sn_tab);

    for (i = 0; i < sn_count; i++) {
        info->has_snapshots = true;
        info_list = g_new0(SnapshotInfoList, 1);

        info_list->value                = g_new0(SnapshotInfo, 1);
        info_list->value->id            = g_strdup(sn_tab[i].id_str);
        info_list->value->name          = g_strdup(sn_tab[i].name);
        info_list->value->vm_state_size = sn_tab[i].vm_state_size;
        info_list->value->date_sec      = sn_tab[i].date_sec;
        info_list->value->date_nsec     = sn_tab[i].date_nsec;
        info_list->value->vm_clock_sec  = sn_tab[i].vm_clock_nsec / 1000000000;
        info_list->value->vm_clock_nsec = sn_tab[i].vm_clock_nsec % 1000000000;

        /* XXX: waiting for the qapi to support qemu-queue.h types */
        if (!cur_item) {
            info->snapshots = cur_item = info_list;
        } else {
            cur_item->next = info_list;
            cur_item = info_list;
        }

    }

    g_free(sn_tab);
}

static void dump_json_image_info(ImageInfo *info)
{
    Error *errp = NULL;
    QString *str;
    QmpOutputVisitor *ov = qmp_output_visitor_new();
    QObject *obj;
    visit_type_ImageInfo(qmp_output_get_visitor(ov),
                         &info, NULL, &errp);
    obj = qmp_output_get_qobject(ov);
    str = qobject_to_json_pretty(obj);
    assert(str != NULL);
    printf("%s\n", qstring_get_str(str));
    qobject_decref(obj);
    qmp_output_visitor_cleanup(ov);
    QDECREF(str);
}

static void collect_image_info(BlockDriverState *bs,
                   ImageInfo *info,
                   const char *filename,
                   const char *fmt)
B
bellard 已提交
1187
{
1188
    uint64_t total_sectors;
B
bellard 已提交
1189 1190
    char backing_filename[1024];
    char backing_filename2[1024];
B
bellard 已提交
1191
    BlockDriverInfo bdi;
B
bellard 已提交
1192

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
    bdrv_get_geometry(bs, &total_sectors);

    info->filename        = g_strdup(filename);
    info->format          = g_strdup(bdrv_get_format_name(bs));
    info->virtual_size    = total_sectors * 512;
    info->actual_size     = bdrv_get_allocated_file_size(bs);
    info->has_actual_size = info->actual_size >= 0;
    if (bdrv_is_encrypted(bs)) {
        info->encrypted = true;
        info->has_encrypted = true;
    }
    if (bdrv_get_info(bs, &bdi) >= 0) {
        if (bdi.cluster_size != 0) {
            info->cluster_size = bdi.cluster_size;
            info->has_cluster_size = true;
        }
        info->dirty_flag = bdi.is_dirty;
        info->has_dirty_flag = true;
    }
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
    if (backing_filename[0] != '\0') {
        info->backing_filename = g_strdup(backing_filename);
        info->has_backing_filename = true;
        bdrv_get_full_backing_filename(bs, backing_filename2,
                                       sizeof(backing_filename2));

        if (strcmp(backing_filename, backing_filename2) != 0) {
            info->full_backing_filename =
                        g_strdup(backing_filename2);
            info->has_full_backing_filename = true;
        }

        if (bs->backing_format[0]) {
            info->backing_filename_format = g_strdup(bs->backing_format);
            info->has_backing_filename_format = true;
        }
    }
}

static void dump_human_image_info(ImageInfo *info)
{
    char size_buf[128], dsize_buf[128];
    if (!info->has_actual_size) {
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
    } else {
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
                                info->actual_size);
    }
    get_human_readable_size(size_buf, sizeof(size_buf), info->virtual_size);
    printf("image: %s\n"
           "file format: %s\n"
           "virtual size: %s (%" PRId64 " bytes)\n"
           "disk size: %s\n",
           info->filename, info->format, size_buf,
           info->virtual_size,
           dsize_buf);

    if (info->has_encrypted && info->encrypted) {
        printf("encrypted: yes\n");
    }

    if (info->has_cluster_size) {
        printf("cluster_size: %" PRId64 "\n", info->cluster_size);
    }

    if (info->has_dirty_flag && info->dirty_flag) {
        printf("cleanly shut down: no\n");
    }

    if (info->has_backing_filename) {
        printf("backing file: %s", info->backing_filename);
        if (info->has_full_backing_filename) {
            printf(" (actual path: %s)", info->full_backing_filename);
        }
        putchar('\n');
        if (info->has_backing_filename_format) {
            printf("backing file format: %s\n", info->backing_filename_format);
        }
    }
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296

    if (info->has_snapshots) {
        SnapshotInfoList *elem;
        char buf[256];

        printf("Snapshot list:\n");
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));

        /* Ideally bdrv_snapshot_dump() would operate on SnapshotInfoList but
         * we convert to the block layer's native QEMUSnapshotInfo for now.
         */
        for (elem = info->snapshots; elem; elem = elem->next) {
            QEMUSnapshotInfo sn = {
                .vm_state_size = elem->value->vm_state_size,
                .date_sec = elem->value->date_sec,
                .date_nsec = elem->value->date_nsec,
                .vm_clock_nsec = elem->value->vm_clock_sec * 1000000000ULL +
                                 elem->value->vm_clock_nsec,
            };

            pstrcpy(sn.id_str, sizeof(sn.id_str), elem->value->id);
            pstrcpy(sn.name, sizeof(sn.name), elem->value->name);
            printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), &sn));
        }
    }
1297 1298
}

1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
static void dump_human_image_info_list(ImageInfoList *list)
{
    ImageInfoList *elem;
    bool delim = false;

    for (elem = list; elem; elem = elem->next) {
        if (delim) {
            printf("\n");
        }
        delim = true;

        dump_human_image_info(elem->value);
    }
}

static gboolean str_equal_func(gconstpointer a, gconstpointer b)
{
    return strcmp(a, b) == 0;
}

/**
 * Open an image file chain and return an ImageInfoList
 *
 * @filename: topmost image filename
 * @fmt: topmost image format (may be NULL to autodetect)
 * @chain: true  - enumerate entire backing file chain
 *         false - only topmost image file
 *
 * Returns a list of ImageInfo objects or NULL if there was an error opening an
 * image file.  If there was an error a message will have been printed to
 * stderr.
 */
static ImageInfoList *collect_image_info_list(const char *filename,
                                              const char *fmt,
                                              bool chain)
{
    ImageInfoList *head = NULL;
    ImageInfoList **last = &head;
    GHashTable *filenames;

    filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);

    while (filename) {
        BlockDriverState *bs;
        ImageInfo *info;
        ImageInfoList *elem;

        if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
            error_report("Backing file '%s' creates an infinite loop.",
                         filename);
            goto err;
        }
        g_hash_table_insert(filenames, (gpointer)filename, NULL);

        bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
                           false);
        if (!bs) {
            goto err;
        }

        info = g_new0(ImageInfo, 1);
        collect_image_info(bs, info, filename, fmt);
        collect_snapshots(bs, info);

        elem = g_new0(ImageInfoList, 1);
        elem->value = info;
        *last = elem;
        last = &elem->next;

        bdrv_delete(bs);

        filename = fmt = NULL;
        if (chain) {
            if (info->has_full_backing_filename) {
                filename = info->full_backing_filename;
            } else if (info->has_backing_filename) {
                filename = info->backing_filename;
            }
            if (info->has_backing_filename_format) {
                fmt = info->backing_filename_format;
            }
        }
    }
    g_hash_table_destroy(filenames);
    return head;

err:
    qapi_free_ImageInfoList(head);
    g_hash_table_destroy(filenames);
    return NULL;
}

enum {
    OPTION_OUTPUT = 256,
    OPTION_BACKING_CHAIN = 257,
};
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404

typedef enum OutputFormat {
    OFORMAT_JSON,
    OFORMAT_HUMAN,
} OutputFormat;

static int img_info(int argc, char **argv)
{
    int c;
    OutputFormat output_format = OFORMAT_HUMAN;
1405
    bool chain = false;
1406
    const char *filename, *fmt, *output;
1407
    ImageInfoList *list;
1408

B
bellard 已提交
1409
    fmt = NULL;
1410
    output = NULL;
B
bellard 已提交
1411
    for(;;) {
1412 1413 1414 1415 1416
        int option_index = 0;
        static const struct option long_options[] = {
            {"help", no_argument, 0, 'h'},
            {"format", required_argument, 0, 'f'},
            {"output", required_argument, 0, OPTION_OUTPUT},
1417
            {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1418 1419 1420 1421
            {0, 0, 0, 0}
        };
        c = getopt_long(argc, argv, "f:h",
                        long_options, &option_index);
1422
        if (c == -1) {
B
bellard 已提交
1423
            break;
1424
        }
B
bellard 已提交
1425
        switch(c) {
J
Jes Sorensen 已提交
1426
        case '?':
B
bellard 已提交
1427 1428 1429 1430 1431 1432
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
1433 1434 1435
        case OPTION_OUTPUT:
            output = optarg;
            break;
1436 1437 1438
        case OPTION_BACKING_CHAIN:
            chain = true;
            break;
B
bellard 已提交
1439 1440
        }
    }
1441
    if (optind >= argc) {
B
bellard 已提交
1442
        help();
1443
    }
B
bellard 已提交
1444 1445
    filename = argv[optind++];

1446 1447 1448 1449 1450 1451
    if (output && !strcmp(output, "json")) {
        output_format = OFORMAT_JSON;
    } else if (output && !strcmp(output, "human")) {
        output_format = OFORMAT_HUMAN;
    } else if (output) {
        error_report("--output must be used with human or json as argument.");
1452 1453
        return 1;
    }
1454

1455 1456
    list = collect_image_info_list(filename, fmt, chain);
    if (!list) {
1457
        return 1;
B
bellard 已提交
1458
    }
1459 1460 1461

    switch (output_format) {
    case OFORMAT_HUMAN:
1462
        dump_human_image_info_list(list);
1463 1464
        break;
    case OFORMAT_JSON:
1465 1466 1467 1468 1469
        if (chain) {
            dump_json_image_info_list(list);
        } else {
            dump_json_image_info(list->value);
        }
1470
        break;
B
bellard 已提交
1471
    }
1472

1473
    qapi_free_ImageInfoList(list);
B
bellard 已提交
1474 1475 1476
    return 0;
}

1477 1478 1479 1480 1481
#define SNAPSHOT_LIST   1
#define SNAPSHOT_CREATE 2
#define SNAPSHOT_APPLY  3
#define SNAPSHOT_DELETE 4

1482
static int img_snapshot(int argc, char **argv)
1483 1484 1485 1486
{
    BlockDriverState *bs;
    QEMUSnapshotInfo sn;
    char *filename, *snapshot_name = NULL;
1487
    int c, ret = 0, bdrv_oflags;
1488 1489 1490
    int action = 0;
    qemu_timeval tv;

1491
    bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1492 1493 1494
    /* Parse commandline parameters */
    for(;;) {
        c = getopt(argc, argv, "la:c:d:h");
1495
        if (c == -1) {
1496
            break;
1497
        }
1498
        switch(c) {
J
Jes Sorensen 已提交
1499
        case '?':
1500 1501
        case 'h':
            help();
1502
            return 0;
1503 1504 1505
        case 'l':
            if (action) {
                help();
1506
                return 0;
1507 1508
            }
            action = SNAPSHOT_LIST;
1509
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1510 1511 1512 1513
            break;
        case 'a':
            if (action) {
                help();
1514
                return 0;
1515 1516 1517 1518 1519 1520 1521
            }
            action = SNAPSHOT_APPLY;
            snapshot_name = optarg;
            break;
        case 'c':
            if (action) {
                help();
1522
                return 0;
1523 1524 1525 1526 1527 1528 1529
            }
            action = SNAPSHOT_CREATE;
            snapshot_name = optarg;
            break;
        case 'd':
            if (action) {
                help();
1530
                return 0;
1531 1532 1533 1534 1535 1536 1537
            }
            action = SNAPSHOT_DELETE;
            snapshot_name = optarg;
            break;
        }
    }

1538
    if (optind >= argc) {
1539
        help();
1540
    }
1541 1542 1543
    filename = argv[optind++];

    /* Open the image */
1544
    bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1545 1546 1547
    if (!bs) {
        return 1;
    }
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563

    /* Perform the requested action */
    switch(action) {
    case SNAPSHOT_LIST:
        dump_snapshots(bs);
        break;

    case SNAPSHOT_CREATE:
        memset(&sn, 0, sizeof(sn));
        pstrcpy(sn.name, sizeof(sn.name), snapshot_name);

        qemu_gettimeofday(&tv);
        sn.date_sec = tv.tv_sec;
        sn.date_nsec = tv.tv_usec * 1000;

        ret = bdrv_snapshot_create(bs, &sn);
1564
        if (ret) {
1565
            error_report("Could not create snapshot '%s': %d (%s)",
1566
                snapshot_name, ret, strerror(-ret));
1567
        }
1568 1569 1570 1571
        break;

    case SNAPSHOT_APPLY:
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1572
        if (ret) {
1573
            error_report("Could not apply snapshot '%s': %d (%s)",
1574
                snapshot_name, ret, strerror(-ret));
1575
        }
1576 1577 1578 1579
        break;

    case SNAPSHOT_DELETE:
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1580
        if (ret) {
1581
            error_report("Could not delete snapshot '%s': %d (%s)",
1582
                snapshot_name, ret, strerror(-ret));
1583
        }
1584 1585 1586 1587 1588
        break;
    }

    /* Cleanup */
    bdrv_delete(bs);
1589 1590 1591
    if (ret) {
        return 1;
    }
1592
    return 0;
1593 1594
}

K
Kevin Wolf 已提交
1595 1596
static int img_rebase(int argc, char **argv)
{
1597
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1598
    BlockDriver *old_backing_drv, *new_backing_drv;
K
Kevin Wolf 已提交
1599
    char *filename;
1600
    const char *fmt, *cache, *out_basefmt, *out_baseimg;
K
Kevin Wolf 已提交
1601 1602
    int c, flags, ret;
    int unsafe = 0;
1603
    int progress = 0;
K
Kevin Wolf 已提交
1604 1605

    /* Parse commandline parameters */
K
Kevin Wolf 已提交
1606
    fmt = NULL;
1607
    cache = BDRV_DEFAULT_CACHE;
K
Kevin Wolf 已提交
1608 1609 1610
    out_baseimg = NULL;
    out_basefmt = NULL;
    for(;;) {
1611
        c = getopt(argc, argv, "uhf:F:b:pt:");
1612
        if (c == -1) {
K
Kevin Wolf 已提交
1613
            break;
1614
        }
K
Kevin Wolf 已提交
1615
        switch(c) {
J
Jes Sorensen 已提交
1616
        case '?':
K
Kevin Wolf 已提交
1617 1618 1619
        case 'h':
            help();
            return 0;
K
Kevin Wolf 已提交
1620 1621 1622
        case 'f':
            fmt = optarg;
            break;
K
Kevin Wolf 已提交
1623 1624 1625 1626 1627 1628 1629 1630 1631
        case 'F':
            out_basefmt = optarg;
            break;
        case 'b':
            out_baseimg = optarg;
            break;
        case 'u':
            unsafe = 1;
            break;
1632 1633 1634
        case 'p':
            progress = 1;
            break;
1635 1636 1637
        case 't':
            cache = optarg;
            break;
K
Kevin Wolf 已提交
1638 1639 1640
        }
    }

1641
    if ((optind >= argc) || (!unsafe && !out_baseimg)) {
K
Kevin Wolf 已提交
1642
        help();
1643
    }
K
Kevin Wolf 已提交
1644 1645
    filename = argv[optind++];

1646 1647 1648
    qemu_progress_init(progress, 2.0);
    qemu_progress_print(0, 100);

1649
    flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1650
    ret = bdrv_parse_cache_flags(cache, &flags);
1651 1652 1653 1654 1655
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

K
Kevin Wolf 已提交
1656 1657 1658 1659 1660 1661
    /*
     * Open the images.
     *
     * Ignore the old backing file for unsafe rebase in case we want to correct
     * the reference to a renamed or moved backing file.
     */
1662
    bs = bdrv_new_open(filename, fmt, flags, true);
1663 1664 1665
    if (!bs) {
        return 1;
    }
K
Kevin Wolf 已提交
1666 1667 1668 1669 1670 1671 1672 1673

    /* Find the right drivers for the backing files */
    old_backing_drv = NULL;
    new_backing_drv = NULL;

    if (!unsafe && bs->backing_format[0] != '\0') {
        old_backing_drv = bdrv_find_format(bs->backing_format);
        if (old_backing_drv == NULL) {
1674
            error_report("Invalid format name: '%s'", bs->backing_format);
1675 1676
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1677 1678 1679 1680 1681 1682
        }
    }

    if (out_basefmt != NULL) {
        new_backing_drv = bdrv_find_format(out_basefmt);
        if (new_backing_drv == NULL) {
1683
            error_report("Invalid format name: '%s'", out_basefmt);
1684 1685
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
        }
    }

    /* For safe rebasing we need to compare old and new backing file */
    if (unsafe) {
        /* Make the compiler happy */
        bs_old_backing = NULL;
        bs_new_backing = NULL;
    } else {
        char backing_name[1024];

        bs_old_backing = bdrv_new("old_backing");
        bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1699 1700 1701
        ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
                        old_backing_drv);
        if (ret) {
1702
            error_report("Could not open old backing file '%s'", backing_name);
1703
            goto out;
K
Kevin Wolf 已提交
1704
        }
1705 1706 1707
        if (out_baseimg[0]) {
            bs_new_backing = bdrv_new("new_backing");
            ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1708
                        new_backing_drv);
1709 1710 1711 1712 1713
            if (ret) {
                error_report("Could not open new backing file '%s'",
                             out_baseimg);
                goto out;
            }
K
Kevin Wolf 已提交
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
        }
    }

    /*
     * Check each unallocated cluster in the COW file. If it is unallocated,
     * accesses go to the backing file. We must therefore compare this cluster
     * in the old and new backing file, and if they differ we need to copy it
     * from the old backing file into the COW file.
     *
     * If qemu-img crashes during this step, no harm is done. The content of
     * the image is the same as the original one at any time.
     */
    if (!unsafe) {
        uint64_t num_sectors;
1728
        uint64_t old_backing_num_sectors;
1729
        uint64_t new_backing_num_sectors = 0;
K
Kevin Wolf 已提交
1730
        uint64_t sector;
1731
        int n;
1732 1733
        uint8_t * buf_old;
        uint8_t * buf_new;
1734
        float local_progress = 0;
1735

K
Kevin Wolf 已提交
1736 1737
        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
K
Kevin Wolf 已提交
1738 1739

        bdrv_get_geometry(bs, &num_sectors);
1740
        bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1741 1742 1743
        if (bs_new_backing) {
            bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
        }
K
Kevin Wolf 已提交
1744

1745 1746 1747 1748 1749
        if (num_sectors != 0) {
            local_progress = (float)100 /
                (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
        }

K
Kevin Wolf 已提交
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
        for (sector = 0; sector < num_sectors; sector += n) {

            /* How many sectors can we handle with the next read? */
            if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
                n = (IO_BUF_SIZE / 512);
            } else {
                n = num_sectors - sector;
            }

            /* If the cluster is allocated, we don't need to take action */
1760 1761
            ret = bdrv_is_allocated(bs, sector, n, &n);
            if (ret) {
K
Kevin Wolf 已提交
1762 1763 1764
                continue;
            }

1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
            /*
             * Read old and new backing file and take into consideration that
             * backing files may be smaller than the COW image.
             */
            if (sector >= old_backing_num_sectors) {
                memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
            } else {
                if (sector + n > old_backing_num_sectors) {
                    n = old_backing_num_sectors - sector;
                }

                ret = bdrv_read(bs_old_backing, sector, buf_old, n);
                if (ret < 0) {
                    error_report("error while reading from old backing file");
                    goto out;
                }
K
Kevin Wolf 已提交
1781
            }
1782

1783
            if (sector >= new_backing_num_sectors || !bs_new_backing) {
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
                memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
            } else {
                if (sector + n > new_backing_num_sectors) {
                    n = new_backing_num_sectors - sector;
                }

                ret = bdrv_read(bs_new_backing, sector, buf_new, n);
                if (ret < 0) {
                    error_report("error while reading from new backing file");
                    goto out;
                }
K
Kevin Wolf 已提交
1795 1796 1797 1798 1799 1800 1801 1802 1803
            }

            /* If they differ, we need to write to the COW file */
            uint64_t written = 0;

            while (written < n) {
                int pnum;

                if (compare_sectors(buf_old + written * 512,
1804
                    buf_new + written * 512, n - written, &pnum))
K
Kevin Wolf 已提交
1805 1806 1807 1808
                {
                    ret = bdrv_write(bs, sector + written,
                        buf_old + written * 512, pnum);
                    if (ret < 0) {
1809
                        error_report("Error while writing to COW image: %s",
K
Kevin Wolf 已提交
1810
                            strerror(-ret));
1811
                        goto out;
K
Kevin Wolf 已提交
1812 1813 1814 1815 1816
                    }
                }

                written += pnum;
            }
1817
            qemu_progress_print(local_progress, 100);
K
Kevin Wolf 已提交
1818
        }
1819

K
Kevin Wolf 已提交
1820 1821
        qemu_vfree(buf_old);
        qemu_vfree(buf_new);
K
Kevin Wolf 已提交
1822 1823 1824 1825 1826 1827 1828
    }

    /*
     * Change the backing file. All clusters that are different from the old
     * backing file are overwritten in the COW file now, so the visible content
     * doesn't change when we switch the backing file.
     */
1829 1830 1831 1832 1833 1834
    if (out_baseimg && *out_baseimg) {
        ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
    } else {
        ret = bdrv_change_backing_file(bs, NULL, NULL);
    }

K
Kevin Wolf 已提交
1835
    if (ret == -ENOSPC) {
1836 1837
        error_report("Could not change the backing file to '%s': No "
                     "space left in the file header", out_baseimg);
K
Kevin Wolf 已提交
1838
    } else if (ret < 0) {
1839
        error_report("Could not change the backing file to '%s': %s",
K
Kevin Wolf 已提交
1840 1841 1842
            out_baseimg, strerror(-ret));
    }

1843
    qemu_progress_print(100, 0);
K
Kevin Wolf 已提交
1844 1845 1846 1847 1848 1849
    /*
     * TODO At this point it is possible to check if any clusters that are
     * allocated in the COW file are the same in the backing file. If so, they
     * could be dropped from the COW file. Don't do this before switching the
     * backing file, in case of a crash this would lead to corruption.
     */
1850
out:
1851
    qemu_progress_end();
K
Kevin Wolf 已提交
1852 1853
    /* Cleanup */
    if (!unsafe) {
1854 1855 1856 1857 1858 1859
        if (bs_old_backing != NULL) {
            bdrv_delete(bs_old_backing);
        }
        if (bs_new_backing != NULL) {
            bdrv_delete(bs_new_backing);
        }
K
Kevin Wolf 已提交
1860 1861 1862
    }

    bdrv_delete(bs);
1863 1864 1865
    if (ret) {
        return 1;
    }
K
Kevin Wolf 已提交
1866 1867 1868
    return 0;
}

1869 1870 1871 1872 1873
static int img_resize(int argc, char **argv)
{
    int c, ret, relative;
    const char *filename, *fmt, *size;
    int64_t n, total_size;
1874
    BlockDriverState *bs = NULL;
1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
    QemuOpts *param;
    static QemuOptsList resize_options = {
        .name = "resize_options",
        .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
        .desc = {
            {
                .name = BLOCK_OPT_SIZE,
                .type = QEMU_OPT_SIZE,
                .help = "Virtual disk size"
            }, {
                /* end of list */
            }
1887 1888 1889
        },
    };

K
Kevin Wolf 已提交
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
    /* Remove size from argv manually so that negative numbers are not treated
     * as options by getopt. */
    if (argc < 3) {
        help();
        return 1;
    }

    size = argv[--argc];

    /* Parse getopt arguments */
1900 1901 1902 1903 1904 1905 1906
    fmt = NULL;
    for(;;) {
        c = getopt(argc, argv, "f:h");
        if (c == -1) {
            break;
        }
        switch(c) {
J
Jes Sorensen 已提交
1907
        case '?':
1908 1909 1910 1911 1912 1913 1914 1915
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
        }
    }
K
Kevin Wolf 已提交
1916
    if (optind >= argc) {
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
        help();
    }
    filename = argv[optind++];

    /* Choose grow, shrink, or absolute resize mode */
    switch (size[0]) {
    case '+':
        relative = 1;
        size++;
        break;
    case '-':
        relative = -1;
        size++;
        break;
    default:
        relative = 0;
        break;
    }

    /* Parse size */
1937 1938
    param = qemu_opts_create(&resize_options, NULL, 0, NULL);
    if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1939
        /* Error message already printed when size parsing fails */
1940
        ret = -1;
1941
        qemu_opts_del(param);
1942
        goto out;
1943
    }
1944 1945
    n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
    qemu_opts_del(param);
1946

1947
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1948
    if (!bs) {
1949 1950
        ret = -1;
        goto out;
1951
    }
1952 1953 1954 1955 1956 1957 1958

    if (relative) {
        total_size = bdrv_getlength(bs) + n * relative;
    } else {
        total_size = n;
    }
    if (total_size <= 0) {
1959
        error_report("New image size must be positive");
1960 1961
        ret = -1;
        goto out;
1962 1963 1964 1965 1966 1967 1968 1969
    }

    ret = bdrv_truncate(bs, total_size);
    switch (ret) {
    case 0:
        printf("Image resized.\n");
        break;
    case -ENOTSUP:
1970
        error_report("This image does not support resize");
1971 1972
        break;
    case -EACCES:
1973
        error_report("Image is read-only");
1974 1975
        break;
    default:
1976
        error_report("Error resizing image (%d)", -ret);
1977 1978
        break;
    }
1979
out:
1980 1981 1982
    if (bs) {
        bdrv_delete(bs);
    }
1983 1984 1985
    if (ret) {
        return 1;
    }
1986 1987 1988
    return 0;
}

A
Anthony Liguori 已提交
1989
static const img_cmd_t img_cmds[] = {
1990 1991 1992 1993 1994 1995 1996 1997
#define DEF(option, callback, arg_string)        \
    { option, callback },
#include "qemu-img-cmds.h"
#undef DEF
#undef GEN_DOCS
    { NULL, NULL, },
};

B
bellard 已提交
1998 1999
int main(int argc, char **argv)
{
A
Anthony Liguori 已提交
2000
    const img_cmd_t *cmd;
2001
    const char *cmdname;
B
bellard 已提交
2002

K
Kevin Wolf 已提交
2003 2004
    error_set_progname(argv[0]);

2005
    qemu_init_main_loop();
B
bellard 已提交
2006 2007 2008
    bdrv_init();
    if (argc < 2)
        help();
2009
    cmdname = argv[1];
2010
    argc--; argv++;
2011 2012 2013 2014 2015 2016

    /* find the command */
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
        if (!strcmp(cmdname, cmd->name)) {
            return cmd->handler(argc, argv);
        }
B
bellard 已提交
2017
    }
2018 2019 2020

    /* not found */
    help();
B
bellard 已提交
2021 2022
    return 0;
}