qemu-img.c 48.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.
 */
P
pbrook 已提交
24
#include "qemu-common.h"
25
#include "qemu-option.h"
K
Kevin Wolf 已提交
26
#include "qemu-error.h"
27
#include "osdep.h"
28
#include "sysemu.h"
29
#include "block_int.h"
30
#include <stdio.h>
B
bellard 已提交
31

32 33 34 35
#ifdef _WIN32
#include <windows.h>
#endif

A
Anthony Liguori 已提交
36
typedef struct img_cmd_t {
37 38
    const char *name;
    int (*handler)(int argc, char **argv);
A
Anthony Liguori 已提交
39
} img_cmd_t;
40

41
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42
#define BDRV_O_FLAGS BDRV_O_CACHE_WB
43
#define BDRV_DEFAULT_CACHE "writeback"
44

B
bellard 已提交
45 46 47 48 49
static void format_print(void *opaque, const char *name)
{
    printf(" %s", name);
}

B
blueswir1 已提交
50
/* Please keep in synch with qemu-img.texi */
P
pbrook 已提交
51
static void help(void)
B
bellard 已提交
52
{
53 54
    const char *help_msg =
           "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
55 56 57 58
           "usage: qemu-img command [command options]\n"
           "QEMU disk image utility\n"
           "\n"
           "Command syntax:\n"
59 60 61 62 63
#define DEF(option, callback, arg_string)        \
           "  " arg_string "\n"
#include "qemu-img-cmds.h"
#undef DEF
#undef GEN_DOCS
64 65 66 67
           "\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"
68
           "  'cache' is the cache mode used to write the output disk image, the valid\n"
69 70
           "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
           "    'directsync' and 'unsafe' (default for convert)\n"
71 72 73 74 75 76 77 78 79 80 81 82 83
           "  '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"
84
           "  '-p' show progress of command (only certain commands)\n"
85 86
           "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
           "       for qemu-img to create a sparse image during conversion\n"
87
           "\n"
88 89 90 91 92 93
           "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"
           "       hiding corruption that has already occured.\n"
           "\n"
94 95 96 97 98
           "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"
99 100 101
           "  '-l' lists all snapshots in the given image\n";

    printf("%s\nSupported formats:", help_msg);
B
bellard 已提交
102 103 104 105 106 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
    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;
152

B
bellard 已提交
153 154 155 156 157
    tcsetattr (0, TCSANOW, &tty);

    atexit(term_exit);
}

P
pbrook 已提交
158
static int read_password(char *buf, int buf_size)
B
bellard 已提交
159 160 161 162 163 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
{
    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

195 196 197 198 199 200 201 202
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) {
203
        error_report("Unknown file format '%s'", fmt);
204 205 206 207 208
        return 1;
    }

    proto_drv = bdrv_find_protocol(filename);
    if (!proto_drv) {
209
        error_report("Unknown protocol '%s'", filename);
210 211 212 213 214 215 216 217 218 219 220 221
        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;
}

222
static BlockDriverState *bdrv_new_open(const char *filename,
223
                                       const char *fmt,
224
                                       int flags)
225 226 227 228
{
    BlockDriverState *bs;
    BlockDriver *drv;
    char password[256];
229
    int ret;
230

231
    bs = bdrv_new("image");
232

233 234
    if (fmt) {
        drv = bdrv_find_format(fmt);
235
        if (!drv) {
236
            error_report("Unknown file format '%s'", fmt);
237 238
            goto fail;
        }
239 240 241
    } else {
        drv = NULL;
    }
242 243 244 245

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

249 250
    if (bdrv_is_encrypted(bs)) {
        printf("Disk image '%s' is encrypted.\n", filename);
251
        if (read_password(password, sizeof(password)) < 0) {
252
            error_report("No password given");
253 254 255
            goto fail;
        }
        if (bdrv_set_key(bs, password) < 0) {
256
            error_report("invalid password");
257 258
            goto fail;
        }
259 260
    }
    return bs;
261 262 263 264 265
fail:
    if (bs) {
        bdrv_delete(bs);
    }
    return NULL;
266 267
}

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

B
bellard 已提交
289 290
static int img_create(int argc, char **argv)
{
291
    int c, ret = 0;
292
    uint64_t img_size = -1;
B
bellard 已提交
293
    const char *fmt = "raw";
294
    const char *base_fmt = NULL;
B
bellard 已提交
295 296
    const char *filename;
    const char *base_filename = NULL;
297
    char *options = NULL;
298

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

332
    /* Get the filename */
333
    if (optind >= argc) {
334
        help();
335
    }
336 337
    filename = argv[optind++];

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

353
    if (options && is_help_option(options)) {
354 355 356 357
        ret = print_block_option_help(filename, fmt);
        goto out;
    }

J
Jes Sorensen 已提交
358 359
    ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
                          options, img_size, BDRV_O_FLAGS);
360 361 362 363
out:
    if (ret) {
        return 1;
    }
B
bellard 已提交
364 365 366
    return 0;
}

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

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

416
    bs = bdrv_new_open(filename, fmt, flags);
417 418 419
    if (!bs) {
        return 1;
    }
420
    ret = bdrv_check(bs, &result, fix);
421 422

    if (ret == -ENOTSUP) {
423
        error_report("This image format does not support checks");
424 425 426 427
        bdrv_delete(bs);
        return 1;
    }

428 429 430 431 432 433 434 435 436 437
    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);
    }

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
    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);
457 458 459
        }
    }

460 461 462 463 464 465 466
    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);
    }

467
    bdrv_delete(bs);
468 469 470 471 472

    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));
473 474
        return 1;
    }
475 476 477 478 479 480 481 482

    if (result.corruptions) {
        return 2;
    } else if (result.leaks) {
        return 3;
    } else {
        return 0;
    }
483 484
}

B
bellard 已提交
485 486
static int img_commit(int argc, char **argv)
{
487 488
    int c, ret, flags;
    const char *filename, *fmt, *cache;
B
bellard 已提交
489 490 491
    BlockDriverState *bs;

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

516
    flags = BDRV_O_RDWR;
517
    ret = bdrv_parse_cache_flags(cache, &flags);
518 519 520 521 522 523
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

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

    bdrv_delete(bs);
547 548 549
    if (ret) {
        return 1;
    }
B
bellard 已提交
550 551 552
    return 0;
}

553 554 555 556 557 558 559
/*
 * 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 已提交
560 561
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
{
562 563
    bool is_zero;
    int i;
B
bellard 已提交
564 565 566 567 568

    if (n <= 0) {
        *pnum = 0;
        return 0;
    }
569
    is_zero = buffer_is_zero(buf, 512);
B
bellard 已提交
570 571
    for(i = 1; i < n; i++) {
        buf += 512;
572
        if (is_zero != buffer_is_zero(buf, 512)) {
B
bellard 已提交
573
            break;
574
        }
B
bellard 已提交
575 576
    }
    *pnum = i;
577
    return !is_zero;
B
bellard 已提交
578 579
}

580 581 582 583 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
/*
 * 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 已提交
622 623 624 625 626 627 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
/*
 * 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;
}

653
#define IO_BUF_SIZE (2 * 1024 * 1024)
B
bellard 已提交
654 655 656

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

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

            min_sparse = sval / BDRV_SECTOR_SIZE;
            break;
        }
728 729 730
        case 'p':
            progress = 1;
            break;
731 732 733
        case 't':
            cache = optarg;
            break;
B
bellard 已提交
734 735
        }
    }
736

737
    bs_n = argc - optind - 1;
738 739 740
    if (bs_n < 1) {
        help();
    }
741 742

    out_filename = argv[argc - 1];
743

744 745 746
    /* Initialize before goto out */
    qemu_progress_init(progress, 2.0);

747
    if (options && is_help_option(options)) {
748 749 750 751
        ret = print_block_option_help(out_filename, out_fmt);
        goto out;
    }

752
    if (bs_n > 1 && out_baseimg) {
753 754
        error_report("-B makes no sense when concatenating multiple input "
                     "images");
755 756
        ret = -1;
        goto out;
757
    }
758

759 760
    qemu_progress_print(0, 100);

761
    bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
762 763 764

    total_sectors = 0;
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
765
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
766
        if (!bs[bs_i]) {
767
            error_report("Could not open '%s'", argv[optind + bs_i]);
768 769 770
            ret = -1;
            goto out;
        }
771 772 773
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
        total_sectors += bs_sectors;
    }
B
bellard 已提交
774

E
edison 已提交
775 776
    if (snapshot_name != NULL) {
        if (bs_n > 1) {
777
            error_report("No support for concatenating multiple snapshot");
E
edison 已提交
778 779 780 781
            ret = -1;
            goto out;
        }
        if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
782
            error_report("Failed to load snapshot");
E
edison 已提交
783 784 785 786 787
            ret = -1;
            goto out;
        }
    }

788
    /* Find driver and parse its options */
B
bellard 已提交
789
    drv = bdrv_find_format(out_fmt);
790
    if (!drv) {
791
        error_report("Unknown file format '%s'", out_fmt);
792 793 794
        ret = -1;
        goto out;
    }
795

796
    proto_drv = bdrv_find_protocol(out_filename);
797
    if (!proto_drv) {
798
        error_report("Unknown protocol '%s'", out_filename);
799 800 801
        ret = -1;
        goto out;
    }
802 803 804 805 806

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

808
    if (options) {
809
        param = parse_option_parameters(options, create_options, param);
810
        if (param == NULL) {
811
            error_report("Invalid options for file format '%s'.", out_fmt);
812 813
            ret = -1;
            goto out;
814 815
        }
    } else {
816
        param = parse_option_parameters("", create_options, param);
817 818 819
    }

    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
820
    ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
821 822 823
    if (ret < 0) {
        goto out;
    }
824

825 826 827 828 829 830
    /* 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;
    }

831
    /* Check if compression is supported */
832
    if (compress) {
833 834
        QEMUOptionParameter *encryption =
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
835 836
        QEMUOptionParameter *preallocation =
            get_option_parameter(param, BLOCK_OPT_PREALLOC);
837 838

        if (!drv->bdrv_write_compressed) {
839
            error_report("Compression not supported for this file format");
840 841
            ret = -1;
            goto out;
842 843 844
        }

        if (encryption && encryption->value.n) {
845 846
            error_report("Compression and encryption not supported at "
                         "the same time");
847 848
            ret = -1;
            goto out;
849
        }
850 851 852 853 854 855 856 857 858

        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;
        }
859 860 861 862
    }

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

877
    flags = BDRV_O_RDWR;
878
    ret = bdrv_parse_cache_flags(cache, &flags);
879 880 881 882 883 884
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

    out_bs = bdrv_new_open(out_filename, out_fmt, flags);
885 886 887 888
    if (!out_bs) {
        ret = -1;
        goto out;
    }
B
bellard 已提交
889

890 891 892
    bs_i = 0;
    bs_offset = 0;
    bdrv_get_geometry(bs[0], &bs_sectors);
K
Kevin Wolf 已提交
893
    buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
894

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

        nb_sectors = total_sectors;
        local_progress = (float)100 /
912
            (nb_sectors / MIN(nb_sectors, cluster_sectors));
913

B
bellard 已提交
914
        for(;;) {
915 916 917 918
            int64_t bs_num;
            int remainder;
            uint8_t *buf2;

B
bellard 已提交
919 920 921 922 923 924 925
            nb_sectors = total_sectors - sector_num;
            if (nb_sectors <= 0)
                break;
            if (nb_sectors >= cluster_sectors)
                n = cluster_sectors;
            else
                n = nb_sectors;
926 927 928 929 930 931 932 933 934 935 936 937 938

            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 已提交
939 940 941
                    /* printf("changing part: sector_num=%" PRId64 ", "
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
942 943 944 945 946
                }
                assert (bs_num < bs_sectors);

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

947 948
                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
                if (ret < 0) {
949 950
                    error_report("error while reading sector %" PRId64 ": %s",
                                 bs_num, strerror(-ret));
951 952
                    goto out;
                }
953 954 955 956 957 958 959 960

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

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

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

981
        sector_num = 0; // total number of sectors converted so far
982 983
        nb_sectors = total_sectors - sector_num;
        local_progress = (float)100 /
984
            (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
985

B
bellard 已提交
986 987
        for(;;) {
            nb_sectors = total_sectors - sector_num;
988
            if (nb_sectors <= 0) {
B
bellard 已提交
989
                break;
990 991
            }
            if (nb_sectors >= (IO_BUF_SIZE / 512)) {
B
bellard 已提交
992
                n = (IO_BUF_SIZE / 512);
993
            } else {
B
bellard 已提交
994
                n = nb_sectors;
995
            }
996 997 998 999 1000 1001

            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 已提交
1002 1003
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1004 1005 1006
                   sector_num, bs_i, bs_offset, bs_sectors); */
            }

1007
            if (n > bs_offset + bs_sectors - sector_num) {
1008
                n = bs_offset + bs_sectors - sector_num;
1009
            }
1010

K
Kevin Wolf 已提交
1011
            if (has_zero_init) {
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
                /* 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;
1025 1026 1027
                }
            } else {
                n1 = n;
1028 1029
            }

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

B
bellard 已提交
1086

B
bellard 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
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));
    }
1102
    g_free(sn_tab);
B
bellard 已提交
1103 1104
}

B
bellard 已提交
1105 1106 1107 1108 1109
static int img_info(int argc, char **argv)
{
    int c;
    const char *filename, *fmt;
    BlockDriverState *bs;
1110
    char size_buf[128], dsize_buf[128];
1111 1112
    uint64_t total_sectors;
    int64_t allocated_size;
B
bellard 已提交
1113 1114
    char backing_filename[1024];
    char backing_filename2[1024];
B
bellard 已提交
1115
    BlockDriverInfo bdi;
B
bellard 已提交
1116 1117 1118 1119

    fmt = NULL;
    for(;;) {
        c = getopt(argc, argv, "f:h");
1120
        if (c == -1) {
B
bellard 已提交
1121
            break;
1122
        }
B
bellard 已提交
1123
        switch(c) {
J
Jes Sorensen 已提交
1124
        case '?':
B
bellard 已提交
1125 1126 1127 1128 1129 1130 1131 1132
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
        }
    }
1133
    if (optind >= argc) {
B
bellard 已提交
1134
        help();
1135
    }
B
bellard 已提交
1136 1137
    filename = argv[optind++];

1138
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1139 1140 1141
    if (!bs) {
        return 1;
    }
B
bellard 已提交
1142 1143
    bdrv_get_geometry(bs, &total_sectors);
    get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1144
    allocated_size = bdrv_get_allocated_file_size(bs);
1145
    if (allocated_size < 0) {
1146
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1147
    } else {
1148
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1149
                                allocated_size);
1150
    }
B
bellard 已提交
1151 1152
    printf("image: %s\n"
           "file format: %s\n"
1153
           "virtual size: %s (%" PRId64 " bytes)\n"
B
bellard 已提交
1154
           "disk size: %s\n",
1155
           filename, bdrv_get_format_name(bs), size_buf,
1156
           (total_sectors * 512),
B
bellard 已提交
1157
           dsize_buf);
1158
    if (bdrv_is_encrypted(bs)) {
B
bellard 已提交
1159
        printf("encrypted: yes\n");
1160
    }
B
bellard 已提交
1161
    if (bdrv_get_info(bs, &bdi) >= 0) {
1162
        if (bdi.cluster_size != 0) {
B
bellard 已提交
1163
            printf("cluster_size: %d\n", bdi.cluster_size);
1164
        }
D
Dong Xu Wang 已提交
1165 1166 1167
        if (bdi.is_dirty) {
            printf("cleanly shut down: no\n");
        }
B
bellard 已提交
1168
    }
B
bellard 已提交
1169
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
B
bellard 已提交
1170
    if (backing_filename[0] != '\0') {
1171 1172 1173 1174 1175 1176 1177
        bdrv_get_full_backing_filename(bs, backing_filename2,
                                       sizeof(backing_filename2));
        printf("backing file: %s", backing_filename);
        if (strcmp(backing_filename, backing_filename2) != 0) {
            printf(" (actual path: %s)", backing_filename2);
        }
        putchar('\n');
B
bellard 已提交
1178 1179
    }
    dump_snapshots(bs);
B
bellard 已提交
1180 1181 1182 1183
    bdrv_delete(bs);
    return 0;
}

1184 1185 1186 1187 1188
#define SNAPSHOT_LIST   1
#define SNAPSHOT_CREATE 2
#define SNAPSHOT_APPLY  3
#define SNAPSHOT_DELETE 4

1189
static int img_snapshot(int argc, char **argv)
1190 1191 1192 1193
{
    BlockDriverState *bs;
    QEMUSnapshotInfo sn;
    char *filename, *snapshot_name = NULL;
1194
    int c, ret = 0, bdrv_oflags;
1195 1196 1197
    int action = 0;
    qemu_timeval tv;

1198
    bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1199 1200 1201
    /* Parse commandline parameters */
    for(;;) {
        c = getopt(argc, argv, "la:c:d:h");
1202
        if (c == -1) {
1203
            break;
1204
        }
1205
        switch(c) {
J
Jes Sorensen 已提交
1206
        case '?':
1207 1208
        case 'h':
            help();
1209
            return 0;
1210 1211 1212
        case 'l':
            if (action) {
                help();
1213
                return 0;
1214 1215
            }
            action = SNAPSHOT_LIST;
1216
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1217 1218 1219 1220
            break;
        case 'a':
            if (action) {
                help();
1221
                return 0;
1222 1223 1224 1225 1226 1227 1228
            }
            action = SNAPSHOT_APPLY;
            snapshot_name = optarg;
            break;
        case 'c':
            if (action) {
                help();
1229
                return 0;
1230 1231 1232 1233 1234 1235 1236
            }
            action = SNAPSHOT_CREATE;
            snapshot_name = optarg;
            break;
        case 'd':
            if (action) {
                help();
1237
                return 0;
1238 1239 1240 1241 1242 1243 1244
            }
            action = SNAPSHOT_DELETE;
            snapshot_name = optarg;
            break;
        }
    }

1245
    if (optind >= argc) {
1246
        help();
1247
    }
1248 1249 1250
    filename = argv[optind++];

    /* Open the image */
1251
    bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1252 1253 1254
    if (!bs) {
        return 1;
    }
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270

    /* 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);
1271
        if (ret) {
1272
            error_report("Could not create snapshot '%s': %d (%s)",
1273
                snapshot_name, ret, strerror(-ret));
1274
        }
1275 1276 1277 1278
        break;

    case SNAPSHOT_APPLY:
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1279
        if (ret) {
1280
            error_report("Could not apply snapshot '%s': %d (%s)",
1281
                snapshot_name, ret, strerror(-ret));
1282
        }
1283 1284 1285 1286
        break;

    case SNAPSHOT_DELETE:
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1287
        if (ret) {
1288
            error_report("Could not delete snapshot '%s': %d (%s)",
1289
                snapshot_name, ret, strerror(-ret));
1290
        }
1291 1292 1293 1294 1295
        break;
    }

    /* Cleanup */
    bdrv_delete(bs);
1296 1297 1298
    if (ret) {
        return 1;
    }
1299
    return 0;
1300 1301
}

K
Kevin Wolf 已提交
1302 1303
static int img_rebase(int argc, char **argv)
{
1304
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1305
    BlockDriver *old_backing_drv, *new_backing_drv;
K
Kevin Wolf 已提交
1306
    char *filename;
1307
    const char *fmt, *cache, *out_basefmt, *out_baseimg;
K
Kevin Wolf 已提交
1308 1309
    int c, flags, ret;
    int unsafe = 0;
1310
    int progress = 0;
K
Kevin Wolf 已提交
1311 1312

    /* Parse commandline parameters */
K
Kevin Wolf 已提交
1313
    fmt = NULL;
1314
    cache = BDRV_DEFAULT_CACHE;
K
Kevin Wolf 已提交
1315 1316 1317
    out_baseimg = NULL;
    out_basefmt = NULL;
    for(;;) {
1318
        c = getopt(argc, argv, "uhf:F:b:pt:");
1319
        if (c == -1) {
K
Kevin Wolf 已提交
1320
            break;
1321
        }
K
Kevin Wolf 已提交
1322
        switch(c) {
J
Jes Sorensen 已提交
1323
        case '?':
K
Kevin Wolf 已提交
1324 1325 1326
        case 'h':
            help();
            return 0;
K
Kevin Wolf 已提交
1327 1328 1329
        case 'f':
            fmt = optarg;
            break;
K
Kevin Wolf 已提交
1330 1331 1332 1333 1334 1335 1336 1337 1338
        case 'F':
            out_basefmt = optarg;
            break;
        case 'b':
            out_baseimg = optarg;
            break;
        case 'u':
            unsafe = 1;
            break;
1339 1340 1341
        case 'p':
            progress = 1;
            break;
1342 1343 1344
        case 't':
            cache = optarg;
            break;
K
Kevin Wolf 已提交
1345 1346 1347
        }
    }

1348
    if ((optind >= argc) || (!unsafe && !out_baseimg)) {
K
Kevin Wolf 已提交
1349
        help();
1350
    }
K
Kevin Wolf 已提交
1351 1352
    filename = argv[optind++];

1353 1354 1355
    qemu_progress_init(progress, 2.0);
    qemu_progress_print(0, 100);

1356
    flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1357
    ret = bdrv_parse_cache_flags(cache, &flags);
1358 1359 1360 1361 1362
    if (ret < 0) {
        error_report("Invalid cache option: %s", cache);
        return -1;
    }

K
Kevin Wolf 已提交
1363 1364 1365 1366 1367 1368
    /*
     * 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.
     */
1369
    bs = bdrv_new_open(filename, fmt, flags);
1370 1371 1372
    if (!bs) {
        return 1;
    }
K
Kevin Wolf 已提交
1373 1374 1375 1376 1377 1378 1379 1380

    /* 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) {
1381
            error_report("Invalid format name: '%s'", bs->backing_format);
1382 1383
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1384 1385 1386 1387 1388 1389
        }
    }

    if (out_basefmt != NULL) {
        new_backing_drv = bdrv_find_format(out_basefmt);
        if (new_backing_drv == NULL) {
1390
            error_report("Invalid format name: '%s'", out_basefmt);
1391 1392
            ret = -1;
            goto out;
K
Kevin Wolf 已提交
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
        }
    }

    /* 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));
1406 1407 1408
        ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
                        old_backing_drv);
        if (ret) {
1409
            error_report("Could not open old backing file '%s'", backing_name);
1410
            goto out;
K
Kevin Wolf 已提交
1411 1412 1413
        }

        bs_new_backing = bdrv_new("new_backing");
1414
        ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1415 1416
                        new_backing_drv);
        if (ret) {
1417
            error_report("Could not open new backing file '%s'", out_baseimg);
1418
            goto out;
K
Kevin Wolf 已提交
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
        }
    }

    /*
     * 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;
1433 1434
        uint64_t old_backing_num_sectors;
        uint64_t new_backing_num_sectors;
K
Kevin Wolf 已提交
1435
        uint64_t sector;
1436
        int n;
1437 1438
        uint8_t * buf_old;
        uint8_t * buf_new;
1439
        float local_progress;
1440

K
Kevin Wolf 已提交
1441 1442
        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
K
Kevin Wolf 已提交
1443 1444

        bdrv_get_geometry(bs, &num_sectors);
1445 1446
        bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
        bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
K
Kevin Wolf 已提交
1447

1448
        local_progress = (float)100 /
1449
            (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
K
Kevin Wolf 已提交
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
        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 */
1460 1461
            ret = bdrv_is_allocated(bs, sector, n, &n);
            if (ret) {
K
Kevin Wolf 已提交
1462 1463 1464
                continue;
            }

1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
            /*
             * 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 已提交
1481
            }
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494

            if (sector >= new_backing_num_sectors) {
                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 已提交
1495 1496 1497 1498 1499 1500 1501 1502 1503
            }

            /* 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,
1504
                    buf_new + written * 512, n - written, &pnum))
K
Kevin Wolf 已提交
1505 1506 1507 1508
                {
                    ret = bdrv_write(bs, sector + written,
                        buf_old + written * 512, pnum);
                    if (ret < 0) {
1509
                        error_report("Error while writing to COW image: %s",
K
Kevin Wolf 已提交
1510
                            strerror(-ret));
1511
                        goto out;
K
Kevin Wolf 已提交
1512 1513 1514 1515 1516
                    }
                }

                written += pnum;
            }
1517
            qemu_progress_print(local_progress, 100);
K
Kevin Wolf 已提交
1518
        }
1519

K
Kevin Wolf 已提交
1520 1521
        qemu_vfree(buf_old);
        qemu_vfree(buf_new);
K
Kevin Wolf 已提交
1522 1523 1524 1525 1526 1527 1528 1529 1530
    }

    /*
     * 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.
     */
    ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
    if (ret == -ENOSPC) {
1531 1532
        error_report("Could not change the backing file to '%s': No "
                     "space left in the file header", out_baseimg);
K
Kevin Wolf 已提交
1533
    } else if (ret < 0) {
1534
        error_report("Could not change the backing file to '%s': %s",
K
Kevin Wolf 已提交
1535 1536 1537
            out_baseimg, strerror(-ret));
    }

1538
    qemu_progress_print(100, 0);
K
Kevin Wolf 已提交
1539 1540 1541 1542 1543 1544
    /*
     * 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.
     */
1545
out:
1546
    qemu_progress_end();
K
Kevin Wolf 已提交
1547 1548
    /* Cleanup */
    if (!unsafe) {
1549 1550 1551 1552 1553 1554
        if (bs_old_backing != NULL) {
            bdrv_delete(bs_old_backing);
        }
        if (bs_new_backing != NULL) {
            bdrv_delete(bs_new_backing);
        }
K
Kevin Wolf 已提交
1555 1556 1557
    }

    bdrv_delete(bs);
1558 1559 1560
    if (ret) {
        return 1;
    }
K
Kevin Wolf 已提交
1561 1562 1563
    return 0;
}

1564 1565 1566 1567 1568
static int img_resize(int argc, char **argv)
{
    int c, ret, relative;
    const char *filename, *fmt, *size;
    int64_t n, total_size;
1569
    BlockDriverState *bs = NULL;
1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
    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 */
            }
1582 1583 1584
        },
    };

K
Kevin Wolf 已提交
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
    /* 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 */
1595 1596 1597 1598 1599 1600 1601
    fmt = NULL;
    for(;;) {
        c = getopt(argc, argv, "f:h");
        if (c == -1) {
            break;
        }
        switch(c) {
J
Jes Sorensen 已提交
1602
        case '?':
1603 1604 1605 1606 1607 1608 1609 1610
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
        }
    }
K
Kevin Wolf 已提交
1611
    if (optind >= argc) {
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
        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 */
1632 1633
    param = qemu_opts_create(&resize_options, NULL, 0, NULL);
    if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
1634
        /* Error message already printed when size parsing fails */
1635
        ret = -1;
1636
        qemu_opts_del(param);
1637
        goto out;
1638
    }
1639 1640
    n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
    qemu_opts_del(param);
1641 1642

    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1643
    if (!bs) {
1644 1645
        ret = -1;
        goto out;
1646
    }
1647 1648 1649 1650 1651 1652 1653

    if (relative) {
        total_size = bdrv_getlength(bs) + n * relative;
    } else {
        total_size = n;
    }
    if (total_size <= 0) {
1654
        error_report("New image size must be positive");
1655 1656
        ret = -1;
        goto out;
1657 1658 1659 1660 1661 1662 1663 1664
    }

    ret = bdrv_truncate(bs, total_size);
    switch (ret) {
    case 0:
        printf("Image resized.\n");
        break;
    case -ENOTSUP:
1665
        error_report("This image does not support resize");
1666 1667
        break;
    case -EACCES:
1668
        error_report("Image is read-only");
1669 1670
        break;
    default:
1671
        error_report("Error resizing image (%d)", -ret);
1672 1673
        break;
    }
1674
out:
1675 1676 1677
    if (bs) {
        bdrv_delete(bs);
    }
1678 1679 1680
    if (ret) {
        return 1;
    }
1681 1682 1683
    return 0;
}

A
Anthony Liguori 已提交
1684
static const img_cmd_t img_cmds[] = {
1685 1686 1687 1688 1689 1690 1691 1692
#define DEF(option, callback, arg_string)        \
    { option, callback },
#include "qemu-img-cmds.h"
#undef DEF
#undef GEN_DOCS
    { NULL, NULL, },
};

B
bellard 已提交
1693 1694
int main(int argc, char **argv)
{
A
Anthony Liguori 已提交
1695
    const img_cmd_t *cmd;
1696
    const char *cmdname;
B
bellard 已提交
1697

K
Kevin Wolf 已提交
1698 1699
    error_set_progname(argv[0]);

B
bellard 已提交
1700 1701 1702
    bdrv_init();
    if (argc < 2)
        help();
1703
    cmdname = argv[1];
1704
    argc--; argv++;
1705

1706 1707
    qemu_init_main_loop();

1708 1709 1710 1711 1712
    /* find the command */
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
        if (!strcmp(cmdname, cmd->name)) {
            return cmd->handler(argc, argv);
        }
B
bellard 已提交
1713
    }
1714 1715 1716

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