qemu-img.c 47.9 KB
Newer Older
bellard's avatar
bellard committed
1
/*
bellard's avatar
bellard committed
2
 * QEMU disk image utility
3
 *
bellard's avatar
bellard committed
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
bellard's avatar
bellard committed
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.
 */
pbrook's avatar
pbrook committed
24
#include "qemu-common.h"
25
#include "qemu-option.h"
Kevin Wolf's avatar
Kevin Wolf committed
26
#include "qemu-error.h"
27
#include "osdep.h"
28
#include "sysemu.h"
29
#include "block_int.h"
30
#include <stdio.h>
bellard's avatar
bellard committed
31

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

36
typedef struct img_cmd_t {
37
38
    const char *name;
    int (*handler)(int argc, char **argv);
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

bellard's avatar
bellard committed
45
46
47
48
49
static void format_print(void *opaque, const char *name)
{
    printf(" %s", name);
}

blueswir1's avatar
blueswir1 committed
50
/* Please keep in synch with qemu-img.texi */
pbrook's avatar
pbrook committed
51
static void help(void)
bellard's avatar
bellard committed
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);
bellard's avatar
bellard committed
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

bellard's avatar
bellard committed
153
154
155
156
157
    tcsetattr (0, TCSANOW, &tty);

    atexit(term_exit);
}

pbrook's avatar
pbrook committed
158
static int read_password(char *buf, int buf_size)
bellard's avatar
bellard committed
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
}

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

bellard's avatar
bellard committed
299
    for(;;) {
300
        c = getopt(argc, argv, "F:b:f:he6o:");
301
        if (c == -1) {
bellard's avatar
bellard committed
302
            break;
303
        }
bellard's avatar
bellard committed
304
        switch(c) {
305
        case '?':
bellard's avatar
bellard committed
306
307
308
        case 'h':
            help();
            break;
309
310
311
        case 'F':
            base_fmt = optarg;
            break;
bellard's avatar
bellard committed
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;
bellard's avatar
bellard committed
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
354
355
356
357
    if (options && !strcmp(options, "?")) {
        ret = print_block_option_help(filename, fmt);
        goto out;
    }

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;
    }
bellard's avatar
bellard committed
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
382
    int fix = 0;
    int flags = BDRV_O_FLAGS;
383
384
385

    fmt = NULL;
    for(;;) {
386
        c = getopt(argc, argv, "f:hr:");
387
        if (c == -1) {
388
            break;
389
        }
390
        switch(c) {
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
}

bellard's avatar
bellard committed
485
486
static int img_commit(int argc, char **argv)
{
487
488
    int c, ret, flags;
    const char *filename, *fmt, *cache;
bellard's avatar
bellard committed
489
490
491
    BlockDriverState *bs;

    fmt = NULL;
492
    cache = BDRV_DEFAULT_CACHE;
bellard's avatar
bellard committed
493
    for(;;) {
494
        c = getopt(argc, argv, "f:ht:");
495
        if (c == -1) {
bellard's avatar
bellard committed
496
            break;
497
        }
bellard's avatar
bellard committed
498
        switch(c) {
499
        case '?':
bellard's avatar
bellard committed
500
501
502
503
504
505
        case 'h':
            help();
            break;
        case 'f':
            fmt = optarg;
            break;
506
507
508
        case 't':
            cache = optarg;
            break;
bellard's avatar
bellard committed
509
510
        }
    }
511
    if (optind >= argc) {
bellard's avatar
bellard committed
512
        help();
513
    }
bellard's avatar
bellard committed
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;
    }
bellard's avatar
bellard committed
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");
bellard's avatar
bellard committed
534
535
        break;
    case -EACCES:
536
        error_report("Image is read-only");
bellard's avatar
bellard committed
537
538
        break;
    case -ENOTSUP:
539
        error_report("Image is already committed");
bellard's avatar
bellard committed
540
541
        break;
    default:
542
        error_report("Error while committing image");
bellard's avatar
bellard committed
543
544
545
546
        break;
    }

    bdrv_delete(bs);
547
548
549
    if (ret) {
        return 1;
    }
bellard's avatar
bellard committed
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.
 */
bellard's avatar
bellard committed
560
561
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
{
562
563
    bool is_zero;
    int i;
bellard's avatar
bellard committed
564
565
566
567
568

    if (n <= 0) {
        *pnum = 0;
        return 0;
    }
569
    is_zero = buffer_is_zero(buf, 512);
bellard's avatar
bellard committed
570
571
    for(i = 1; i < n; i++) {
        buf += 512;
572
        if (is_zero != buffer_is_zero(buf, 512)) {
bellard's avatar
bellard committed
573
            break;
574
        }
bellard's avatar
bellard committed
575
576
    }
    *pnum = i;
577
    return !is_zero;
bellard's avatar
bellard committed
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;
}

Kevin Wolf's avatar
Kevin Wolf committed
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)
bellard's avatar
bellard committed
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;
bellard's avatar
bellard committed
665
    const uint8_t *buf1;
bellard's avatar
bellard committed
666
    BlockDriverInfo bdi;
667
    QEMUOptionParameter *param = NULL, *create_options = NULL;
668
    QEMUOptionParameter *out_baseimg_param;
669
    char *options = NULL;
edison's avatar
edison committed
670
    const char *snapshot_name = NULL;
671
    float local_progress;
672
    int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
bellard's avatar
bellard committed
673
674
675

    fmt = NULL;
    out_fmt = "raw";
676
    cache = "unsafe";
677
    out_baseimg = NULL;
678
    compress = 0;
bellard's avatar
bellard committed
679
    for(;;) {
680
        c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
681
        if (c == -1) {
bellard's avatar
bellard committed
682
            break;
683
        }
bellard's avatar
bellard committed
684
        switch(c) {
685
        case '?':
bellard's avatar
bellard committed
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;
bellard's avatar
bellard committed
698
        case 'c':
699
            compress = 1;
bellard's avatar
bellard committed
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;
edison's avatar
edison committed
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;
bellard's avatar
bellard committed
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
748
749
750
751
    if (options && !strcmp(options, "?")) {
        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;
    }
bellard's avatar
bellard committed
774

edison's avatar
edison committed
775
776
    if (snapshot_name != NULL) {
        if (bs_n > 1) {
777
            error_report("No support for concatenating multiple snapshot");
edison's avatar
edison committed
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");
edison's avatar
edison committed
783
784
785
786
787
            ret = -1;
            goto out;
        }
    }

788
    /* Find driver and parse its options */
bellard's avatar
bellard committed
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);
bellard's avatar
bellard committed
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);
bellard's avatar
bellard committed
870
        } else {
871
872
            error_report("%s: error while converting %s: %s",
                         out_filename, out_fmt, strerror(-ret));
bellard's avatar
bellard committed
873
        }
874
        goto out;
bellard's avatar
bellard committed
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;
    }
bellard's avatar
bellard committed
889

890
891
892
    bs_i = 0;
    bs_offset = 0;
    bdrv_get_geometry(bs[0], &bs_sectors);
Kevin Wolf's avatar
Kevin Wolf committed
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;
        }
bellard's avatar
bellard committed
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;
        }
bellard's avatar
bellard committed
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

bellard's avatar
bellard committed
914
        for(;;) {
915
916
917
918
            int64_t bs_num;
            int remainder;
            uint8_t *buf2;

bellard's avatar
bellard committed
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;
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) {
bellard's avatar
bellard committed
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;
                }
bellard's avatar
bellard committed
972
973
            }
            sector_num += n;
974
            qemu_progress_print(local_progress, 100);
bellard's avatar
bellard committed
975
        }
bellard's avatar
bellard committed
976
977
        /* signal EOF to align */
        bdrv_write_compressed(out_bs, 0, NULL, 0);
bellard's avatar
bellard committed
978
    } else {
Kevin Wolf's avatar
Kevin Wolf committed
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

bellard's avatar
bellard committed
986
987
        for(;;) {
            nb_sectors = total_sectors - sector_num;
988
            if (nb_sectors <= 0) {
bellard's avatar
bellard committed
989
                break;
990
991
            }
            if (nb_sectors >= (IO_BUF_SIZE / 512)) {
bellard's avatar
bellard committed
992
                n = (IO_BUF_SIZE / 512);
993
            } else {
bellard's avatar
bellard committed
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);
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

Kevin Wolf's avatar
Kevin Wolf committed
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;
            }
bellard's avatar
bellard committed
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. */
Kevin Wolf's avatar
Kevin Wolf committed
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;
                    }
bellard's avatar
bellard committed
1056
1057
1058
1059
1060
                }
                sector_num += n1;
                n -= n1;
                buf1 += n1 * 512;
            }
1061
            qemu_progress_print(local_progress, 100);
bellard's avatar
bellard committed
1062
1063
        }
    }
1064
out:
1065
    qemu_progress_end();
1066
1067
    free_option_parameters(create_options);
    free_option_parameters(param);
Kevin Wolf's avatar
Kevin Wolf committed
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;
    }
bellard's avatar
bellard committed
1083
1084
1085
    return 0;
}

bellard's avatar
bellard committed
1086

bellard's avatar
bellard committed
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);
bellard's avatar
bellard committed
1103
1104
}

bellard's avatar
bellard committed
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;
bellard's avatar
bellard committed
1113
1114
    char backing_filename[1024];
    char backing_filename2[1024];
bellard's avatar
bellard committed
1115
    BlockDriverInfo bdi;
bellard's avatar
bellard committed
1116
1117
1118
1119

    fmt = NULL;
    for(;;) {
        c = getopt(argc, argv, "f:h");
1120
        if (c == -1) {
bellard's avatar