qemu-img.c 53.1 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, ret = 0;
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

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

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

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

359
    if (options && is_help_option(options)) {
360 361 362 363
        ret = print_block_option_help(filename, fmt);
        goto out;
    }

J
Jes Sorensen 已提交
364 365
    ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
                          options, img_size, BDRV_O_FLAGS);
366 367 368 369
out:
    if (ret) {
        return 1;
    }
B
bellard 已提交
370 371 372
    return 0;
}

373 374 375 376 377 378 379 380
/*
 * 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
 */
381 382 383 384 385
static int img_check(int argc, char **argv)
{
    int c, ret;
    const char *filename, *fmt;
    BlockDriverState *bs;
386
    BdrvCheckResult result;
387
    int fix = 0;
388
    int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
389 390 391

    fmt = NULL;
    for(;;) {
392
        c = getopt(argc, argv, "f:hr:");
393
        if (c == -1) {
394
            break;
395
        }
396
        switch(c) {
J
Jes Sorensen 已提交
397
        case '?':
398 399 400 401 402 403
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
404 405 406 407 408 409 410 411 412 413 414
        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;
415 416
        }
    }
417
    if (optind >= argc) {
418
        help();
419
    }
420 421
    filename = argv[optind++];

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

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

434 435 436 437 438 439 440 441 442 443
    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);
    }

444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
    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);
463 464 465
        }
    }

466 467 468 469 470 471 472
    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);
    }

473
    bdrv_delete(bs);
474 475 476 477 478

    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));
479 480
        return 1;
    }
481 482 483 484 485 486 487 488

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

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

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

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

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

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

559 560 561 562 563 564 565
/*
 * 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 已提交
566 567
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
{
568 569
    bool is_zero;
    int i;
B
bellard 已提交
570 571 572 573 574

    if (n <= 0) {
        *pnum = 0;
        return 0;
    }
575
    is_zero = buffer_is_zero(buf, 512);
B
bellard 已提交
576 577
    for(i = 1; i < n; i++) {
        buf += 512;
578
        if (is_zero != buffer_is_zero(buf, 512)) {
B
bellard 已提交
579
            break;
580
        }
B
bellard 已提交
581 582
    }
    *pnum = i;
583
    return !is_zero;
B
bellard 已提交
584 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
/*
 * 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 已提交
628 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
/*
 * 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;
}

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

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

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

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

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

    out_filename = argv[argc - 1];
749

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

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

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

765 766
    qemu_progress_print(0, 100);

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

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

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

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

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

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

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

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

831 832 833 834 835 836
    /* 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;
    }

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

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

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

        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;
        }
865 866 867 868
    }

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

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

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

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

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

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

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

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

            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 已提交
947 948 949
                    /* printf("changing part: sector_num=%" PRId64 ", "
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
950 951 952 953 954
                }
                assert (bs_num < bs_sectors);

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

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

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

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

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

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

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

            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 已提交
1012 1013
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1014 1015 1016
                   sector_num, bs_i, bs_offset, bs_sectors); */
            }

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

K
Kevin Wolf 已提交
1021
            if (has_zero_init) {
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
                /* 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;
1035 1036 1037
                }
            } else {
                n1 = n;
1038 1039
            }

1040 1041
            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
            if (ret < 0) {
1042 1043
                error_report("error while reading sector %" PRId64 ": %s",
                             sector_num - bs_offset, strerror(-ret));
1044 1045
                goto out;
            }
B
bellard 已提交
1046 1047 1048 1049 1050
            /* 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) {
1051 1052
                /* If the output image is being created as a copy on write image,
                   copy all sectors even the ones containing only NUL bytes,
1053 1054 1055 1056 1057
                   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 已提交
1058
                if (!has_zero_init || out_baseimg ||
1059
                    is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1060 1061
                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
                    if (ret < 0) {
1062 1063
                        error_report("error while writing sector %" PRId64
                                     ": %s", sector_num, strerror(-ret));
1064 1065
                        goto out;
                    }
B
bellard 已提交
1066 1067 1068 1069 1070
                }
                sector_num += n1;
                n -= n1;
                buf1 += n1 * 512;
            }
1071
            qemu_progress_print(local_progress, 100);
B
bellard 已提交
1072 1073
        }
    }
1074
out:
1075
    qemu_progress_end();
1076 1077
    free_option_parameters(create_options);
    free_option_parameters(param);
K
Kevin Wolf 已提交
1078
    qemu_vfree(buf);
1079 1080 1081
    if (out_bs) {
        bdrv_delete(out_bs);
    }
1082 1083 1084 1085 1086
    if (bs) {
        for (bs_i = 0; bs_i < bs_n; bs_i++) {
            if (bs[bs_i]) {
                bdrv_delete(bs[bs_i]);
            }
1087
        }
1088
        g_free(bs);
1089 1090 1091 1092
    }
    if (ret) {
        return 1;
    }
B
bellard 已提交
1093 1094 1095
    return 0;
}

B
bellard 已提交
1096

B
bellard 已提交
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
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));
    }
1112
    g_free(sn_tab);
B
bellard 已提交
1113 1114
}

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 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
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 已提交
1169
{
1170
    uint64_t total_sectors;
B
bellard 已提交
1171 1172
    char backing_filename[1024];
    char backing_filename2[1024];
B
bellard 已提交
1173
    BlockDriverInfo bdi;
B
bellard 已提交
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 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
    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);
        }
    }
}

enum {OPTION_OUTPUT = 256};

typedef enum OutputFormat {
    OFORMAT_JSON,
    OFORMAT_HUMAN,
} OutputFormat;

static int img_info(int argc, char **argv)
{
    int c;
    OutputFormat output_format = OFORMAT_HUMAN;
    const char *filename, *fmt, *output;
    BlockDriverState *bs;
    ImageInfo *info;

B
bellard 已提交
1271
    fmt = NULL;
1272
    output = NULL;
B
bellard 已提交
1273
    for(;;) {
1274 1275 1276 1277 1278 1279 1280 1281 1282
        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},
            {0, 0, 0, 0}
        };
        c = getopt_long(argc, argv, "f:h",
                        long_options, &option_index);
1283
        if (c == -1) {
B
bellard 已提交
1284
            break;
1285
        }
B
bellard 已提交
1286
        switch(c) {
J
Jes Sorensen 已提交
1287
        case '?':
B
bellard 已提交
1288 1289 1290 1291 1292 1293
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
1294 1295 1296
        case OPTION_OUTPUT:
            output = optarg;
            break;
B
bellard 已提交
1297 1298
        }
    }
1299
    if (optind >= argc) {
B
bellard 已提交
1300
        help();
1301
    }
B
bellard 已提交
1302 1303
    filename = argv[optind++];

1304 1305 1306 1307 1308 1309
    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.");
1310 1311
        return 1;
    }
1312

1313
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING, false);
1314 1315
    if (!bs) {
        return 1;
B
bellard 已提交
1316
    }
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329

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

    switch (output_format) {
    case OFORMAT_HUMAN:
        dump_human_image_info(info);
        dump_snapshots(bs);
        break;
    case OFORMAT_JSON:
        collect_snapshots(bs, info);
        dump_json_image_info(info);
        break;
B
bellard 已提交
1330
    }
1331 1332

    qapi_free_ImageInfo(info);
B
bellard 已提交
1333 1334 1335 1336
    bdrv_delete(bs);
    return 0;
}

1337 1338 1339 1340 1341
#define SNAPSHOT_LIST   1
#define SNAPSHOT_CREATE 2
#define SNAPSHOT_APPLY  3
#define SNAPSHOT_DELETE 4

1342
static int img_snapshot(int argc, char **argv)
1343 1344 1345 1346
{
    BlockDriverState *bs;
    QEMUSnapshotInfo sn;
    char *filename, *snapshot_name = NULL;
1347
    int c, ret = 0, bdrv_oflags;
1348 1349 1350
    int action = 0;
    qemu_timeval tv;

1351
    bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1352 1353 1354
    /* Parse commandline parameters */
    for(;;) {
        c = getopt(argc, argv, "la:c:d:h");
1355
        if (c == -1) {
1356
            break;
1357
        }
1358
        switch(c) {
J
Jes Sorensen 已提交
1359
        case '?':
1360 1361
        case 'h':
            help();
1362
            return 0;
1363 1364 1365
        case 'l':
            if (action) {
                help();
1366
                return 0;
1367 1368
            }
            action = SNAPSHOT_LIST;
1369
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1370 1371 1372 1373
            break;
        case 'a':
            if (action) {
                help();
1374
                return 0;
1375 1376 1377 1378 1379 1380 1381
            }
            action = SNAPSHOT_APPLY;
            snapshot_name = optarg;
            break;
        case 'c':
            if (action) {
                help();
1382
                return 0;
1383 1384 1385 1386 1387 1388 1389
            }
            action = SNAPSHOT_CREATE;
            snapshot_name = optarg;
            break;
        case 'd':
            if (action) {
                help();
1390
                return 0;
1391 1392 1393 1394 1395 1396 1397
            }
            action = SNAPSHOT_DELETE;
            snapshot_name = optarg;
            break;
        }
    }

1398
    if (optind >= argc) {
1399
        help();
1400
    }
1401 1402 1403
    filename = argv[optind++];

    /* Open the image */
1404
    bs = bdrv_new_open(filename, NULL, bdrv_oflags, true);
1405 1406 1407
    if (!bs) {
        return 1;
    }
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423

    /* 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);
1424
        if (ret) {
1425
            error_report("Could not create snapshot '%s': %d (%s)",
1426
                snapshot_name, ret, strerror(-ret));
1427
        }
1428 1429 1430 1431
        break;

    case SNAPSHOT_APPLY:
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1432
        if (ret) {
1433
            error_report("Could not apply snapshot '%s': %d (%s)",
1434
                snapshot_name, ret, strerror(-ret));
1435
        }
1436 1437 1438 1439
        break;

    case SNAPSHOT_DELETE:
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1440
        if (ret) {
1441
            error_report("Could not delete snapshot '%s': %d (%s)",
1442
                snapshot_name, ret, strerror(-ret));
1443
        }
1444 1445 1446 1447 1448
        break;
    }

    /* Cleanup */
    bdrv_delete(bs);
1449 1450 1451
    if (ret) {
        return 1;
    }
1452
    return 0;
1453 1454
}

K
Kevin Wolf 已提交
1455 1456
static int img_rebase(int argc, char **argv)
{
1457
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1458
    BlockDriver *old_backing_drv, *new_backing_drv;
K
Kevin Wolf 已提交
1459
    char *filename;
1460
    const char *fmt, *cache, *out_basefmt, *out_baseimg;
K
Kevin Wolf 已提交
1461 1462
    int c, flags, ret;
    int unsafe = 0;
1463
    int progress = 0;
K
Kevin Wolf 已提交
1464 1465

    /* Parse commandline parameters */
K
Kevin Wolf 已提交
1466
    fmt = NULL;
1467
    cache = BDRV_DEFAULT_CACHE;
K
Kevin Wolf 已提交
1468 1469 1470
    out_baseimg = NULL;
    out_basefmt = NULL;
    for(;;) {
1471
        c = getopt(argc, argv, "uhf:F:b:pt:");
1472
        if (c == -1) {
K
Kevin Wolf 已提交
1473
            break;
1474
        }
K
Kevin Wolf 已提交
1475
        switch(c) {
J
Jes Sorensen 已提交
1476
        case '?':
K
Kevin Wolf 已提交
1477 1478 1479
        case 'h':
            help();
            return 0;
K
Kevin Wolf 已提交
1480 1481 1482
        case 'f':
            fmt = optarg;
            break;
K
Kevin Wolf 已提交
1483 1484 1485 1486 1487 1488 1489 1490 1491
        case 'F':
            out_basefmt = optarg;
            break;
        case 'b':
            out_baseimg = optarg;
            break;
        case 'u':
            unsafe = 1;
            break;
1492 1493 1494
        case 'p':
            progress = 1;
            break;
1495 1496 1497
        case 't':
            cache = optarg;
            break;
K
Kevin Wolf 已提交
1498 1499 1500
        }
    }

1501
    if ((optind >= argc) || (!unsafe && !out_baseimg)) {
K
Kevin Wolf 已提交
1502
        help();
1503
    }
K
Kevin Wolf 已提交
1504 1505
    filename = argv[optind++];

1506 1507 1508
    qemu_progress_init(progress, 2.0);
    qemu_progress_print(0, 100);

1509
    flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1510
    ret = bdrv_parse_cache_flags(cache, &flags);
1511 1512 1513 1514 1515
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

K
Kevin Wolf 已提交
1516 1517 1518 1519 1520 1521
    /*
     * 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.
     */
1522
    bs = bdrv_new_open(filename, fmt, flags, true);
1523 1524 1525
    if (!bs) {
        return 1;
    }
K
Kevin Wolf 已提交
1526 1527 1528 1529 1530 1531 1532 1533

    /* 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) {
1534
            error_report("Invalid format name: '%s'", bs->backing_format);
1535 1536
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1537 1538 1539 1540 1541 1542
        }
    }

    if (out_basefmt != NULL) {
        new_backing_drv = bdrv_find_format(out_basefmt);
        if (new_backing_drv == NULL) {
1543
            error_report("Invalid format name: '%s'", out_basefmt);
1544 1545
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
        }
    }

    /* 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));
1559 1560 1561
        ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
                        old_backing_drv);
        if (ret) {
1562
            error_report("Could not open old backing file '%s'", backing_name);
1563
            goto out;
K
Kevin Wolf 已提交
1564
        }
1565 1566 1567
        if (out_baseimg[0]) {
            bs_new_backing = bdrv_new("new_backing");
            ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1568
                        new_backing_drv);
1569 1570 1571 1572 1573
            if (ret) {
                error_report("Could not open new backing file '%s'",
                             out_baseimg);
                goto out;
            }
K
Kevin Wolf 已提交
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
        }
    }

    /*
     * 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;
1588
        uint64_t old_backing_num_sectors;
1589
        uint64_t new_backing_num_sectors = 0;
K
Kevin Wolf 已提交
1590
        uint64_t sector;
1591
        int n;
1592 1593
        uint8_t * buf_old;
        uint8_t * buf_new;
1594
        float local_progress = 0;
1595

K
Kevin Wolf 已提交
1596 1597
        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
K
Kevin Wolf 已提交
1598 1599

        bdrv_get_geometry(bs, &num_sectors);
1600
        bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
1601 1602 1603
        if (bs_new_backing) {
            bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
        }
K
Kevin Wolf 已提交
1604

1605 1606 1607 1608 1609
        if (num_sectors != 0) {
            local_progress = (float)100 /
                (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
        }

K
Kevin Wolf 已提交
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
        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 */
1620 1621
            ret = bdrv_is_allocated(bs, sector, n, &n);
            if (ret) {
K
Kevin Wolf 已提交
1622 1623 1624
                continue;
            }

1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
            /*
             * 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 已提交
1641
            }
1642

1643
            if (sector >= new_backing_num_sectors || !bs_new_backing) {
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
                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 已提交
1655 1656 1657 1658 1659 1660 1661 1662 1663
            }

            /* 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,
1664
                    buf_new + written * 512, n - written, &pnum))
K
Kevin Wolf 已提交
1665 1666 1667 1668
                {
                    ret = bdrv_write(bs, sector + written,
                        buf_old + written * 512, pnum);
                    if (ret < 0) {
1669
                        error_report("Error while writing to COW image: %s",
K
Kevin Wolf 已提交
1670
                            strerror(-ret));
1671
                        goto out;
K
Kevin Wolf 已提交
1672 1673 1674 1675 1676
                    }
                }

                written += pnum;
            }
1677
            qemu_progress_print(local_progress, 100);
K
Kevin Wolf 已提交
1678
        }
1679

K
Kevin Wolf 已提交
1680 1681
        qemu_vfree(buf_old);
        qemu_vfree(buf_new);
K
Kevin Wolf 已提交
1682 1683 1684 1685 1686 1687 1688
    }

    /*
     * 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.
     */
1689 1690 1691 1692 1693 1694
    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 已提交
1695
    if (ret == -ENOSPC) {
1696 1697
        error_report("Could not change the backing file to '%s': No "
                     "space left in the file header", out_baseimg);
K
Kevin Wolf 已提交
1698
    } else if (ret < 0) {
1699
        error_report("Could not change the backing file to '%s': %s",
K
Kevin Wolf 已提交
1700 1701 1702
            out_baseimg, strerror(-ret));
    }

1703
    qemu_progress_print(100, 0);
K
Kevin Wolf 已提交
1704 1705 1706 1707 1708 1709
    /*
     * 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.
     */
1710
out:
1711
    qemu_progress_end();
K
Kevin Wolf 已提交
1712 1713
    /* Cleanup */
    if (!unsafe) {
1714 1715 1716 1717 1718 1719
        if (bs_old_backing != NULL) {
            bdrv_delete(bs_old_backing);
        }
        if (bs_new_backing != NULL) {
            bdrv_delete(bs_new_backing);
        }
K
Kevin Wolf 已提交
1720 1721 1722
    }

    bdrv_delete(bs);
1723 1724 1725
    if (ret) {
        return 1;
    }
K
Kevin Wolf 已提交
1726 1727 1728
    return 0;
}

1729 1730 1731 1732 1733
static int img_resize(int argc, char **argv)
{
    int c, ret, relative;
    const char *filename, *fmt, *size;
    int64_t n, total_size;
1734
    BlockDriverState *bs = NULL;
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
    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 */
            }
1747 1748 1749
        },
    };

K
Kevin Wolf 已提交
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
    /* 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 */
1760 1761 1762 1763 1764 1765 1766
    fmt = NULL;
    for(;;) {
        c = getopt(argc, argv, "f:h");
        if (c == -1) {
            break;
        }
        switch(c) {
J
Jes Sorensen 已提交
1767
        case '?':
1768 1769 1770 1771 1772 1773 1774 1775
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
        }
    }
K
Kevin Wolf 已提交
1776
    if (optind >= argc) {
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
        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 */
1797 1798
    param = qemu_opts_create(&resize_options, NULL, 0, NULL);
    if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1799
        /* Error message already printed when size parsing fails */
1800
        ret = -1;
1801
        qemu_opts_del(param);
1802
        goto out;
1803
    }
1804 1805
    n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
    qemu_opts_del(param);
1806

1807
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true);
1808
    if (!bs) {
1809 1810
        ret = -1;
        goto out;
1811
    }
1812 1813 1814 1815 1816 1817 1818

    if (relative) {
        total_size = bdrv_getlength(bs) + n * relative;
    } else {
        total_size = n;
    }
    if (total_size <= 0) {
1819
        error_report("New image size must be positive");
1820 1821
        ret = -1;
        goto out;
1822 1823 1824 1825 1826 1827 1828 1829
    }

    ret = bdrv_truncate(bs, total_size);
    switch (ret) {
    case 0:
        printf("Image resized.\n");
        break;
    case -ENOTSUP:
1830
        error_report("This image does not support resize");
1831 1832
        break;
    case -EACCES:
1833
        error_report("Image is read-only");
1834 1835
        break;
    default:
1836
        error_report("Error resizing image (%d)", -ret);
1837 1838
        break;
    }
1839
out:
1840 1841 1842
    if (bs) {
        bdrv_delete(bs);
    }
1843 1844 1845
    if (ret) {
        return 1;
    }
1846 1847 1848
    return 0;
}

A
Anthony Liguori 已提交
1849
static const img_cmd_t img_cmds[] = {
1850 1851 1852 1853 1854 1855 1856 1857
#define DEF(option, callback, arg_string)        \
    { option, callback },
#include "qemu-img-cmds.h"
#undef DEF
#undef GEN_DOCS
    { NULL, NULL, },
};

B
bellard 已提交
1858 1859
int main(int argc, char **argv)
{
A
Anthony Liguori 已提交
1860
    const img_cmd_t *cmd;
1861
    const char *cmdname;
B
bellard 已提交
1862

K
Kevin Wolf 已提交
1863 1864
    error_set_progname(argv[0]);

B
bellard 已提交
1865 1866 1867
    bdrv_init();
    if (argc < 2)
        help();
1868
    cmdname = argv[1];
1869
    argc--; argv++;
1870

1871 1872
    qemu_init_main_loop();

1873 1874 1875 1876 1877
    /* find the command */
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
        if (!strcmp(cmdname, cmd->name)) {
            return cmd->handler(argc, argv);
        }
B
bellard 已提交
1878
    }
1879 1880 1881

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