Statistics
| Branch: | Revision:

root / qemu-img.c @ a22f123c

History | View | Annotate | Download (45.5 kB)

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

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

    
36
typedef struct img_cmd_t {
37
    const char *name;
38
    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

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

    
50
/* Please keep in synch with qemu-img.texi */
51
static void help(void)
52
{
53
    const char *help_msg =
54
           "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
55
           "usage: qemu-img command [command options]\n"
56
           "QEMU disk image utility\n"
57
           "\n"
58
           "Command syntax:\n"
59
#define DEF(option, callback, arg_string)        \
60
           "  " arg_string "\n"
61
#include "qemu-img-cmds.h"
62
#undef DEF
63
#undef GEN_DOCS
64
           "\n"
65
           "Command parameters:\n"
66
           "  'filename' is a disk image filename\n"
67
           "  '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
           "    options are: 'none', 'writeback' (default), 'writethrough', 'directsync'\n"
70
           "    and 'unsafe'\n"
71
           "  'size' is the disk image size in bytes. Optional suffixes\n"
72
           "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
73
           "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
74
           "  'output_filename' is the destination disk image filename\n"
75
           "  'output_fmt' is the destination format\n"
76
           "  'options' is a comma separated list of format specific options in a\n"
77
           "    name=value format. Use -o ? for an overview of the options supported by the\n"
78
           "    used format\n"
79
           "  '-c' indicates that target image must be compressed (qcow format only)\n"
80
           "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
81
           "       match exactly. The image doesn't need a working backing file before\n"
82
           "       rebasing in this case (useful for renaming the backing file)\n"
83
           "  '-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
           "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
86
           "       for qemu-img to create a sparse image during conversion\n"
87
           "\n"
88
           "Parameters to snapshot subcommand:\n"
89
           "  'snapshot' is the name of the snapshot to create, apply or delete\n"
90
           "  '-a' applies a snapshot (revert disk to saved state)\n"
91
           "  '-c' creates a snapshot\n"
92
           "  '-d' deletes a snapshot\n"
93
           "  '-l' lists all snapshots in the given image\n";
94

    
95
    printf("%s\nSupported formats:", help_msg);
96
    bdrv_iterate_format(format_print, NULL);
97
    printf("\n");
98
    exit(1);
99
}
100

    
101
#if defined(WIN32)
102
/* XXX: put correct support for win32 */
103
static int read_password(char *buf, int buf_size)
104
{
105
    int c, i;
106
    printf("Password: ");
107
    fflush(stdout);
108
    i = 0;
109
    for(;;) {
110
        c = getchar();
111
        if (c == '\n')
112
            break;
113
        if (i < (buf_size - 1))
114
            buf[i++] = c;
115
    }
116
    buf[i] = '\0';
117
    return 0;
118
}
119

    
120
#else
121

    
122
#include <termios.h>
123

    
124
static struct termios oldtty;
125

    
126
static void term_exit(void)
127
{
128
    tcsetattr (0, TCSANOW, &oldtty);
129
}
130

    
131
static void term_init(void)
132
{
133
    struct termios tty;
134

    
135
    tcgetattr (0, &tty);
136
    oldtty = tty;
137

    
138
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
139
                          |INLCR|IGNCR|ICRNL|IXON);
140
    tty.c_oflag |= OPOST;
141
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
142
    tty.c_cflag &= ~(CSIZE|PARENB);
143
    tty.c_cflag |= CS8;
144
    tty.c_cc[VMIN] = 1;
145
    tty.c_cc[VTIME] = 0;
146

    
147
    tcsetattr (0, TCSANOW, &tty);
148

    
149
    atexit(term_exit);
150
}
151

    
152
static int read_password(char *buf, int buf_size)
153
{
154
    uint8_t ch;
155
    int i, ret;
156

    
157
    printf("password: ");
158
    fflush(stdout);
159
    term_init();
160
    i = 0;
161
    for(;;) {
162
        ret = read(0, &ch, 1);
163
        if (ret == -1) {
164
            if (errno == EAGAIN || errno == EINTR) {
165
                continue;
166
            } else {
167
                ret = -1;
168
                break;
169
            }
170
        } else if (ret == 0) {
171
            ret = -1;
172
            break;
173
        } else {
174
            if (ch == '\r') {
175
                ret = 0;
176
                break;
177
            }
178
            if (i < (buf_size - 1))
179
                buf[i++] = ch;
180
        }
181
    }
182
    term_exit();
183
    buf[i] = '\0';
184
    printf("\n");
185
    return ret;
186
}
187
#endif
188

    
189
static int print_block_option_help(const char *filename, const char *fmt)
190
{
191
    BlockDriver *drv, *proto_drv;
192
    QEMUOptionParameter *create_options = NULL;
193

    
194
    /* Find driver and parse its options */
195
    drv = bdrv_find_format(fmt);
196
    if (!drv) {
197
        error_report("Unknown file format '%s'", fmt);
198
        return 1;
199
    }
200

    
201
    proto_drv = bdrv_find_protocol(filename);
202
    if (!proto_drv) {
203
        error_report("Unknown protocol '%s'", filename);
204
        return 1;
205
    }
206

    
207
    create_options = append_option_parameters(create_options,
208
                                              drv->create_options);
209
    create_options = append_option_parameters(create_options,
210
                                              proto_drv->create_options);
211
    print_option_help(create_options);
212
    free_option_parameters(create_options);
213
    return 0;
214
}
215

    
216
static BlockDriverState *bdrv_new_open(const char *filename,
217
                                       const char *fmt,
218
                                       int flags)
219
{
220
    BlockDriverState *bs;
221
    BlockDriver *drv;
222
    char password[256];
223
    int ret;
224

    
225
    bs = bdrv_new("image");
226

    
227
    if (fmt) {
228
        drv = bdrv_find_format(fmt);
229
        if (!drv) {
230
            error_report("Unknown file format '%s'", fmt);
231
            goto fail;
232
        }
233
    } else {
234
        drv = NULL;
235
    }
236

    
237
    ret = bdrv_open(bs, filename, flags, drv);
238
    if (ret < 0) {
239
        error_report("Could not open '%s': %s", filename, strerror(-ret));
240
        goto fail;
241
    }
242

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

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

    
283
static int img_create(int argc, char **argv)
284
{
285
    int c, ret = 0;
286
    uint64_t img_size = -1;
287
    const char *fmt = "raw";
288
    const char *base_fmt = NULL;
289
    const char *filename;
290
    const char *base_filename = NULL;
291
    char *options = NULL;
292

    
293
    for(;;) {
294
        c = getopt(argc, argv, "F:b:f:he6o:");
295
        if (c == -1) {
296
            break;
297
        }
298
        switch(c) {
299
        case '?':
300
        case 'h':
301
            help();
302
            break;
303
        case 'F':
304
            base_fmt = optarg;
305
            break;
306
        case 'b':
307
            base_filename = optarg;
308
            break;
309
        case 'f':
310
            fmt = optarg;
311
            break;
312
        case 'e':
313
            error_report("option -e is deprecated, please use \'-o "
314
                  "encryption\' instead!");
315
            return 1;
316
        case '6':
317
            error_report("option -6 is deprecated, please use \'-o "
318
                  "compat6\' instead!");
319
            return 1;
320
        case 'o':
321
            options = optarg;
322
            break;
323
        }
324
    }
325

    
326
    /* Get the filename */
327
    if (optind >= argc) {
328
        help();
329
    }
330
    filename = argv[optind++];
331

    
332
    /* Get image size, if specified */
333
    if (optind < argc) {
334
        int64_t sval;
335
        sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
336
        if (sval < 0) {
337
            error_report("Invalid image size specified! You may use k, M, G or "
338
                  "T suffixes for ");
339
            error_report("kilobytes, megabytes, gigabytes and terabytes.");
340
            ret = -1;
341
            goto out;
342
        }
343
        img_size = (uint64_t)sval;
344
    }
345

    
346
    if (options && !strcmp(options, "?")) {
347
        ret = print_block_option_help(filename, fmt);
348
        goto out;
349
    }
350

    
351
    ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
352
                          options, img_size, BDRV_O_FLAGS);
353
out:
354
    if (ret) {
355
        return 1;
356
    }
357
    return 0;
358
}
359

    
360
/*
361
 * Checks an image for consistency. Exit codes:
362
 *
363
 * 0 - Check completed, image is good
364
 * 1 - Check not completed because of internal errors
365
 * 2 - Check completed, image is corrupted
366
 * 3 - Check completed, image has leaked clusters, but is good otherwise
367
 */
368
static int img_check(int argc, char **argv)
369
{
370
    int c, ret;
371
    const char *filename, *fmt;
372
    BlockDriverState *bs;
373
    BdrvCheckResult result;
374

    
375
    fmt = NULL;
376
    for(;;) {
377
        c = getopt(argc, argv, "f:h");
378
        if (c == -1) {
379
            break;
380
        }
381
        switch(c) {
382
        case '?':
383
        case 'h':
384
            help();
385
            break;
386
        case 'f':
387
            fmt = optarg;
388
            break;
389
        }
390
    }
391
    if (optind >= argc) {
392
        help();
393
    }
394
    filename = argv[optind++];
395

    
396
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
397
    if (!bs) {
398
        return 1;
399
    }
400
    ret = bdrv_check(bs, &result);
401

    
402
    if (ret == -ENOTSUP) {
403
        error_report("This image format does not support checks");
404
        bdrv_delete(bs);
405
        return 1;
406
    }
407

    
408
    if (!(result.corruptions || result.leaks || result.check_errors)) {
409
        printf("No errors were found on the image.\n");
410
    } else {
411
        if (result.corruptions) {
412
            printf("\n%d errors were found on the image.\n"
413
                "Data may be corrupted, or further writes to the image "
414
                "may corrupt it.\n",
415
                result.corruptions);
416
        }
417

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

    
424
        if (result.check_errors) {
425
            printf("\n%d internal errors have occurred during the check.\n",
426
                result.check_errors);
427
        }
428
    }
429

    
430
    bdrv_delete(bs);
431

    
432
    if (ret < 0 || result.check_errors) {
433
        printf("\nAn error has occurred during the check: %s\n"
434
            "The check is not complete and may have missed error.\n",
435
            strerror(-ret));
436
        return 1;
437
    }
438

    
439
    if (result.corruptions) {
440
        return 2;
441
    } else if (result.leaks) {
442
        return 3;
443
    } else {
444
        return 0;
445
    }
446
}
447

    
448
static int img_commit(int argc, char **argv)
449
{
450
    int c, ret, flags;
451
    const char *filename, *fmt, *cache;
452
    BlockDriverState *bs;
453

    
454
    fmt = NULL;
455
    cache = BDRV_DEFAULT_CACHE;
456
    for(;;) {
457
        c = getopt(argc, argv, "f:ht:");
458
        if (c == -1) {
459
            break;
460
        }
461
        switch(c) {
462
        case '?':
463
        case 'h':
464
            help();
465
            break;
466
        case 'f':
467
            fmt = optarg;
468
            break;
469
        case 't':
470
            cache = optarg;
471
            break;
472
        }
473
    }
474
    if (optind >= argc) {
475
        help();
476
    }
477
    filename = argv[optind++];
478

    
479
    flags = BDRV_O_RDWR;
480
    ret = bdrv_parse_cache_flags(cache, &flags);
481
    if (ret < 0) {
482
        error_report("Invalid cache option: %s", cache);
483
        return -1;
484
    }
485

    
486
    bs = bdrv_new_open(filename, fmt, flags);
487
    if (!bs) {
488
        return 1;
489
    }
490
    ret = bdrv_commit(bs);
491
    switch(ret) {
492
    case 0:
493
        printf("Image committed.\n");
494
        break;
495
    case -ENOENT:
496
        error_report("No disk inserted");
497
        break;
498
    case -EACCES:
499
        error_report("Image is read-only");
500
        break;
501
    case -ENOTSUP:
502
        error_report("Image is already committed");
503
        break;
504
    default:
505
        error_report("Error while committing image");
506
        break;
507
    }
508

    
509
    bdrv_delete(bs);
510
    if (ret) {
511
        return 1;
512
    }
513
    return 0;
514
}
515

    
516
/*
517
 * Checks whether the sector is not a zero sector.
518
 *
519
 * Attention! The len must be a multiple of 4 * sizeof(long) due to
520
 * restriction of optimizations in this function.
521
 */
522
static int is_not_zero(const uint8_t *sector, int len)
523
{
524
    /*
525
     * Use long as the biggest available internal data type that fits into the
526
     * CPU register and unroll the loop to smooth out the effect of memory
527
     * latency.
528
     */
529

    
530
    int i;
531
    long d0, d1, d2, d3;
532
    const long * const data = (const long *) sector;
533

    
534
    len /= sizeof(long);
535

    
536
    for(i = 0; i < len; i += 4) {
537
        d0 = data[i + 0];
538
        d1 = data[i + 1];
539
        d2 = data[i + 2];
540
        d3 = data[i + 3];
541

    
542
        if (d0 || d1 || d2 || d3) {
543
            return 1;
544
        }
545
    }
546

    
547
    return 0;
548
}
549

    
550
/*
551
 * Returns true iff the first sector pointed to by 'buf' contains at least
552
 * a non-NUL byte.
553
 *
554
 * 'pnum' is set to the number of sectors (including and immediately following
555
 * the first one) that are known to be in the same allocated/unallocated state.
556
 */
557
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
558
{
559
    int v, i;
560

    
561
    if (n <= 0) {
562
        *pnum = 0;
563
        return 0;
564
    }
565
    v = is_not_zero(buf, 512);
566
    for(i = 1; i < n; i++) {
567
        buf += 512;
568
        if (v != is_not_zero(buf, 512))
569
            break;
570
    }
571
    *pnum = i;
572
    return v;
573
}
574

    
575
/*
576
 * Like is_allocated_sectors, but if the buffer starts with a used sector,
577
 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
578
 * breaking up write requests for only small sparse areas.
579
 */
580
static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
581
    int min)
582
{
583
    int ret;
584
    int num_checked, num_used;
585

    
586
    if (n < min) {
587
        min = n;
588
    }
589

    
590
    ret = is_allocated_sectors(buf, n, pnum);
591
    if (!ret) {
592
        return ret;
593
    }
594

    
595
    num_used = *pnum;
596
    buf += BDRV_SECTOR_SIZE * *pnum;
597
    n -= *pnum;
598
    num_checked = num_used;
599

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

    
603
        buf += BDRV_SECTOR_SIZE * *pnum;
604
        n -= *pnum;
605
        num_checked += *pnum;
606
        if (ret) {
607
            num_used = num_checked;
608
        } else if (*pnum >= min) {
609
            break;
610
        }
611
    }
612

    
613
    *pnum = num_used;
614
    return 1;
615
}
616

    
617
/*
618
 * Compares two buffers sector by sector. Returns 0 if the first sector of both
619
 * buffers matches, non-zero otherwise.
620
 *
621
 * pnum is set to the number of sectors (including and immediately following
622
 * the first one) that are known to have the same comparison result
623
 */
624
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
625
    int *pnum)
626
{
627
    int res, i;
628

    
629
    if (n <= 0) {
630
        *pnum = 0;
631
        return 0;
632
    }
633

    
634
    res = !!memcmp(buf1, buf2, 512);
635
    for(i = 1; i < n; i++) {
636
        buf1 += 512;
637
        buf2 += 512;
638

    
639
        if (!!memcmp(buf1, buf2, 512) != res) {
640
            break;
641
        }
642
    }
643

    
644
    *pnum = i;
645
    return res;
646
}
647

    
648
#define IO_BUF_SIZE (2 * 1024 * 1024)
649

    
650
static int img_convert(int argc, char **argv)
651
{
652
    int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
653
    int progress = 0, flags;
654
    const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
655
    BlockDriver *drv, *proto_drv;
656
    BlockDriverState **bs = NULL, *out_bs = NULL;
657
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
658
    uint64_t bs_sectors;
659
    uint8_t * buf = NULL;
660
    const uint8_t *buf1;
661
    BlockDriverInfo bdi;
662
    QEMUOptionParameter *param = NULL, *create_options = NULL;
663
    QEMUOptionParameter *out_baseimg_param;
664
    char *options = NULL;
665
    const char *snapshot_name = NULL;
666
    float local_progress;
667
    int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
668

    
669
    fmt = NULL;
670
    out_fmt = "raw";
671
    cache = "unsafe";
672
    out_baseimg = NULL;
673
    compress = 0;
674
    for(;;) {
675
        c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:");
676
        if (c == -1) {
677
            break;
678
        }
679
        switch(c) {
680
        case '?':
681
        case 'h':
682
            help();
683
            break;
684
        case 'f':
685
            fmt = optarg;
686
            break;
687
        case 'O':
688
            out_fmt = optarg;
689
            break;
690
        case 'B':
691
            out_baseimg = optarg;
692
            break;
693
        case 'c':
694
            compress = 1;
695
            break;
696
        case 'e':
697
            error_report("option -e is deprecated, please use \'-o "
698
                  "encryption\' instead!");
699
            return 1;
700
        case '6':
701
            error_report("option -6 is deprecated, please use \'-o "
702
                  "compat6\' instead!");
703
            return 1;
704
        case 'o':
705
            options = optarg;
706
            break;
707
        case 's':
708
            snapshot_name = optarg;
709
            break;
710
        case 'S':
711
        {
712
            int64_t sval;
713
            sval = strtosz_suffix(optarg, NULL, STRTOSZ_DEFSUFFIX_B);
714
            if (sval < 0) {
715
                error_report("Invalid minimum zero buffer size for sparse output specified");
716
                return 1;
717
            }
718

    
719
            min_sparse = sval / BDRV_SECTOR_SIZE;
720
            break;
721
        }
722
        case 'p':
723
            progress = 1;
724
            break;
725
        case 't':
726
            cache = optarg;
727
            break;
728
        }
729
    }
730

    
731
    bs_n = argc - optind - 1;
732
    if (bs_n < 1) {
733
        help();
734
    }
735

    
736
    out_filename = argv[argc - 1];
737

    
738
    if (options && !strcmp(options, "?")) {
739
        ret = print_block_option_help(out_filename, out_fmt);
740
        goto out;
741
    }
742

    
743
    if (bs_n > 1 && out_baseimg) {
744
        error_report("-B makes no sense when concatenating multiple input "
745
                     "images");
746
        ret = -1;
747
        goto out;
748
    }
749
        
750
    qemu_progress_init(progress, 2.0);
751
    qemu_progress_print(0, 100);
752

    
753
    bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
754

    
755
    total_sectors = 0;
756
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
757
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
758
        if (!bs[bs_i]) {
759
            error_report("Could not open '%s'", argv[optind + bs_i]);
760
            ret = -1;
761
            goto out;
762
        }
763
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
764
        total_sectors += bs_sectors;
765
    }
766

    
767
    if (snapshot_name != NULL) {
768
        if (bs_n > 1) {
769
            error_report("No support for concatenating multiple snapshot");
770
            ret = -1;
771
            goto out;
772
        }
773
        if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
774
            error_report("Failed to load snapshot");
775
            ret = -1;
776
            goto out;
777
        }
778
    }
779

    
780
    /* Find driver and parse its options */
781
    drv = bdrv_find_format(out_fmt);
782
    if (!drv) {
783
        error_report("Unknown file format '%s'", out_fmt);
784
        ret = -1;
785
        goto out;
786
    }
787

    
788
    proto_drv = bdrv_find_protocol(out_filename);
789
    if (!proto_drv) {
790
        error_report("Unknown protocol '%s'", out_filename);
791
        ret = -1;
792
        goto out;
793
    }
794

    
795
    create_options = append_option_parameters(create_options,
796
                                              drv->create_options);
797
    create_options = append_option_parameters(create_options,
798
                                              proto_drv->create_options);
799

    
800
    if (options) {
801
        param = parse_option_parameters(options, create_options, param);
802
        if (param == NULL) {
803
            error_report("Invalid options for file format '%s'.", out_fmt);
804
            ret = -1;
805
            goto out;
806
        }
807
    } else {
808
        param = parse_option_parameters("", create_options, param);
809
    }
810

    
811
    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
812
    ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
813
    if (ret < 0) {
814
        goto out;
815
    }
816

    
817
    /* Get backing file name if -o backing_file was used */
818
    out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
819
    if (out_baseimg_param) {
820
        out_baseimg = out_baseimg_param->value.s;
821
    }
822

    
823
    /* Check if compression is supported */
824
    if (compress) {
825
        QEMUOptionParameter *encryption =
826
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
827

    
828
        if (!drv->bdrv_write_compressed) {
829
            error_report("Compression not supported for this file format");
830
            ret = -1;
831
            goto out;
832
        }
833

    
834
        if (encryption && encryption->value.n) {
835
            error_report("Compression and encryption not supported at "
836
                         "the same time");
837
            ret = -1;
838
            goto out;
839
        }
840
    }
841

    
842
    /* Create the new image */
843
    ret = bdrv_create(drv, out_filename, param);
844
    if (ret < 0) {
845
        if (ret == -ENOTSUP) {
846
            error_report("Formatting not supported for file format '%s'",
847
                         out_fmt);
848
        } else if (ret == -EFBIG) {
849
            error_report("The image size is too large for file format '%s'",
850
                         out_fmt);
851
        } else {
852
            error_report("%s: error while converting %s: %s",
853
                         out_filename, out_fmt, strerror(-ret));
854
        }
855
        goto out;
856
    }
857

    
858
    flags = BDRV_O_RDWR;
859
    ret = bdrv_parse_cache_flags(cache, &flags);
860
    if (ret < 0) {
861
        error_report("Invalid cache option: %s", cache);
862
        return -1;
863
    }
864

    
865
    out_bs = bdrv_new_open(out_filename, out_fmt, flags);
866
    if (!out_bs) {
867
        ret = -1;
868
        goto out;
869
    }
870

    
871
    bs_i = 0;
872
    bs_offset = 0;
873
    bdrv_get_geometry(bs[0], &bs_sectors);
874
    buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
875

    
876
    if (compress) {
877
        ret = bdrv_get_info(out_bs, &bdi);
878
        if (ret < 0) {
879
            error_report("could not get block driver info");
880
            goto out;
881
        }
882
        cluster_size = bdi.cluster_size;
883
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
884
            error_report("invalid cluster size");
885
            ret = -1;
886
            goto out;
887
        }
888
        cluster_sectors = cluster_size >> 9;
889
        sector_num = 0;
890

    
891
        nb_sectors = total_sectors;
892
        local_progress = (float)100 /
893
            (nb_sectors / MIN(nb_sectors, cluster_sectors));
894

    
895
        for(;;) {
896
            int64_t bs_num;
897
            int remainder;
898
            uint8_t *buf2;
899

    
900
            nb_sectors = total_sectors - sector_num;
901
            if (nb_sectors <= 0)
902
                break;
903
            if (nb_sectors >= cluster_sectors)
904
                n = cluster_sectors;
905
            else
906
                n = nb_sectors;
907

    
908
            bs_num = sector_num - bs_offset;
909
            assert (bs_num >= 0);
910
            remainder = n;
911
            buf2 = buf;
912
            while (remainder > 0) {
913
                int nlow;
914
                while (bs_num == bs_sectors) {
915
                    bs_i++;
916
                    assert (bs_i < bs_n);
917
                    bs_offset += bs_sectors;
918
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
919
                    bs_num = 0;
920
                    /* printf("changing part: sector_num=%" PRId64 ", "
921
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
922
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
923
                }
924
                assert (bs_num < bs_sectors);
925

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

    
928
                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
929
                if (ret < 0) {
930
                    error_report("error while reading sector %" PRId64 ": %s",
931
                                 bs_num, strerror(-ret));
932
                    goto out;
933
                }
934

    
935
                buf2 += nlow * 512;
936
                bs_num += nlow;
937

    
938
                remainder -= nlow;
939
            }
940
            assert (remainder == 0);
941

    
942
            if (n < cluster_sectors) {
943
                memset(buf + n * 512, 0, cluster_size - n * 512);
944
            }
945
            if (is_not_zero(buf, cluster_size)) {
946
                ret = bdrv_write_compressed(out_bs, sector_num, buf,
947
                                            cluster_sectors);
948
                if (ret != 0) {
949
                    error_report("error while compressing sector %" PRId64
950
                                 ": %s", sector_num, strerror(-ret));
951
                    goto out;
952
                }
953
            }
954
            sector_num += n;
955
            qemu_progress_print(local_progress, 100);
956
        }
957
        /* signal EOF to align */
958
        bdrv_write_compressed(out_bs, 0, NULL, 0);
959
    } else {
960
        int has_zero_init = bdrv_has_zero_init(out_bs);
961

    
962
        sector_num = 0; // total number of sectors converted so far
963
        nb_sectors = total_sectors - sector_num;
964
        local_progress = (float)100 /
965
            (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
966

    
967
        for(;;) {
968
            nb_sectors = total_sectors - sector_num;
969
            if (nb_sectors <= 0) {
970
                break;
971
            }
972
            if (nb_sectors >= (IO_BUF_SIZE / 512)) {
973
                n = (IO_BUF_SIZE / 512);
974
            } else {
975
                n = nb_sectors;
976
            }
977

    
978
            while (sector_num - bs_offset >= bs_sectors) {
979
                bs_i ++;
980
                assert (bs_i < bs_n);
981
                bs_offset += bs_sectors;
982
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
983
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
984
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
985
                   sector_num, bs_i, bs_offset, bs_sectors); */
986
            }
987

    
988
            if (n > bs_offset + bs_sectors - sector_num) {
989
                n = bs_offset + bs_sectors - sector_num;
990
            }
991

    
992
            if (has_zero_init) {
993
                /* If the output image is being created as a copy on write image,
994
                   assume that sectors which are unallocated in the input image
995
                   are present in both the output's and input's base images (no
996
                   need to copy them). */
997
                if (out_baseimg) {
998
                    if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
999
                                           n, &n1)) {
1000
                        sector_num += n1;
1001
                        continue;
1002
                    }
1003
                    /* The next 'n1' sectors are allocated in the input image. Copy
1004
                       only those as they may be followed by unallocated sectors. */
1005
                    n = n1;
1006
                }
1007
            } else {
1008
                n1 = n;
1009
            }
1010

    
1011
            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1012
            if (ret < 0) {
1013
                error_report("error while reading sector %" PRId64 ": %s",
1014
                             sector_num - bs_offset, strerror(-ret));
1015
                goto out;
1016
            }
1017
            /* NOTE: at the same time we convert, we do not write zero
1018
               sectors to have a chance to compress the image. Ideally, we
1019
               should add a specific call to have the info to go faster */
1020
            buf1 = buf;
1021
            while (n > 0) {
1022
                /* If the output image is being created as a copy on write image,
1023
                   copy all sectors even the ones containing only NUL bytes,
1024
                   because they may differ from the sectors in the base image.
1025

1026
                   If the output is to a host device, we also write out
1027
                   sectors that are entirely 0, since whatever data was
1028
                   already there is garbage, not 0s. */
1029
                if (!has_zero_init || out_baseimg ||
1030
                    is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1031
                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
1032
                    if (ret < 0) {
1033
                        error_report("error while writing sector %" PRId64
1034
                                     ": %s", sector_num, strerror(-ret));
1035
                        goto out;
1036
                    }
1037
                }
1038
                sector_num += n1;
1039
                n -= n1;
1040
                buf1 += n1 * 512;
1041
            }
1042
            qemu_progress_print(local_progress, 100);
1043
        }
1044
    }
1045
out:
1046
    qemu_progress_end();
1047
    free_option_parameters(create_options);
1048
    free_option_parameters(param);
1049
    qemu_vfree(buf);
1050
    if (out_bs) {
1051
        bdrv_delete(out_bs);
1052
    }
1053
    if (bs) {
1054
        for (bs_i = 0; bs_i < bs_n; bs_i++) {
1055
            if (bs[bs_i]) {
1056
                bdrv_delete(bs[bs_i]);
1057
            }
1058
        }
1059
        g_free(bs);
1060
    }
1061
    if (ret) {
1062
        return 1;
1063
    }
1064
    return 0;
1065
}
1066

    
1067

    
1068
static void dump_snapshots(BlockDriverState *bs)
1069
{
1070
    QEMUSnapshotInfo *sn_tab, *sn;
1071
    int nb_sns, i;
1072
    char buf[256];
1073

    
1074
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1075
    if (nb_sns <= 0)
1076
        return;
1077
    printf("Snapshot list:\n");
1078
    printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1079
    for(i = 0; i < nb_sns; i++) {
1080
        sn = &sn_tab[i];
1081
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1082
    }
1083
    g_free(sn_tab);
1084
}
1085

    
1086
static int img_info(int argc, char **argv)
1087
{
1088
    int c;
1089
    const char *filename, *fmt;
1090
    BlockDriverState *bs;
1091
    char fmt_name[128], size_buf[128], dsize_buf[128];
1092
    uint64_t total_sectors;
1093
    int64_t allocated_size;
1094
    char backing_filename[1024];
1095
    char backing_filename2[1024];
1096
    BlockDriverInfo bdi;
1097

    
1098
    fmt = NULL;
1099
    for(;;) {
1100
        c = getopt(argc, argv, "f:h");
1101
        if (c == -1) {
1102
            break;
1103
        }
1104
        switch(c) {
1105
        case '?':
1106
        case 'h':
1107
            help();
1108
            break;
1109
        case 'f':
1110
            fmt = optarg;
1111
            break;
1112
        }
1113
    }
1114
    if (optind >= argc) {
1115
        help();
1116
    }
1117
    filename = argv[optind++];
1118

    
1119
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1120
    if (!bs) {
1121
        return 1;
1122
    }
1123
    bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1124
    bdrv_get_geometry(bs, &total_sectors);
1125
    get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1126
    allocated_size = bdrv_get_allocated_file_size(bs);
1127
    if (allocated_size < 0) {
1128
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1129
    } else {
1130
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1131
                                allocated_size);
1132
    }
1133
    printf("image: %s\n"
1134
           "file format: %s\n"
1135
           "virtual size: %s (%" PRId64 " bytes)\n"
1136
           "disk size: %s\n",
1137
           filename, fmt_name, size_buf,
1138
           (total_sectors * 512),
1139
           dsize_buf);
1140
    if (bdrv_is_encrypted(bs)) {
1141
        printf("encrypted: yes\n");
1142
    }
1143
    if (bdrv_get_info(bs, &bdi) >= 0) {
1144
        if (bdi.cluster_size != 0) {
1145
            printf("cluster_size: %d\n", bdi.cluster_size);
1146
        }
1147
    }
1148
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1149
    if (backing_filename[0] != '\0') {
1150
        path_combine(backing_filename2, sizeof(backing_filename2),
1151
                     filename, backing_filename);
1152
        printf("backing file: %s (actual path: %s)\n",
1153
               backing_filename,
1154
               backing_filename2);
1155
    }
1156
    dump_snapshots(bs);
1157
    bdrv_delete(bs);
1158
    return 0;
1159
}
1160

    
1161
#define SNAPSHOT_LIST   1
1162
#define SNAPSHOT_CREATE 2
1163
#define SNAPSHOT_APPLY  3
1164
#define SNAPSHOT_DELETE 4
1165

    
1166
static int img_snapshot(int argc, char **argv)
1167
{
1168
    BlockDriverState *bs;
1169
    QEMUSnapshotInfo sn;
1170
    char *filename, *snapshot_name = NULL;
1171
    int c, ret = 0, bdrv_oflags;
1172
    int action = 0;
1173
    qemu_timeval tv;
1174

    
1175
    bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1176
    /* Parse commandline parameters */
1177
    for(;;) {
1178
        c = getopt(argc, argv, "la:c:d:h");
1179
        if (c == -1) {
1180
            break;
1181
        }
1182
        switch(c) {
1183
        case '?':
1184
        case 'h':
1185
            help();
1186
            return 0;
1187
        case 'l':
1188
            if (action) {
1189
                help();
1190
                return 0;
1191
            }
1192
            action = SNAPSHOT_LIST;
1193
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1194
            break;
1195
        case 'a':
1196
            if (action) {
1197
                help();
1198
                return 0;
1199
            }
1200
            action = SNAPSHOT_APPLY;
1201
            snapshot_name = optarg;
1202
            break;
1203
        case 'c':
1204
            if (action) {
1205
                help();
1206
                return 0;
1207
            }
1208
            action = SNAPSHOT_CREATE;
1209
            snapshot_name = optarg;
1210
            break;
1211
        case 'd':
1212
            if (action) {
1213
                help();
1214
                return 0;
1215
            }
1216
            action = SNAPSHOT_DELETE;
1217
            snapshot_name = optarg;
1218
            break;
1219
        }
1220
    }
1221

    
1222
    if (optind >= argc) {
1223
        help();
1224
    }
1225
    filename = argv[optind++];
1226

    
1227
    /* Open the image */
1228
    bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1229
    if (!bs) {
1230
        return 1;
1231
    }
1232

    
1233
    /* Perform the requested action */
1234
    switch(action) {
1235
    case SNAPSHOT_LIST:
1236
        dump_snapshots(bs);
1237
        break;
1238

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

    
1243
        qemu_gettimeofday(&tv);
1244
        sn.date_sec = tv.tv_sec;
1245
        sn.date_nsec = tv.tv_usec * 1000;
1246

    
1247
        ret = bdrv_snapshot_create(bs, &sn);
1248
        if (ret) {
1249
            error_report("Could not create snapshot '%s': %d (%s)",
1250
                snapshot_name, ret, strerror(-ret));
1251
        }
1252
        break;
1253

    
1254
    case SNAPSHOT_APPLY:
1255
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1256
        if (ret) {
1257
            error_report("Could not apply snapshot '%s': %d (%s)",
1258
                snapshot_name, ret, strerror(-ret));
1259
        }
1260
        break;
1261

    
1262
    case SNAPSHOT_DELETE:
1263
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1264
        if (ret) {
1265
            error_report("Could not delete snapshot '%s': %d (%s)",
1266
                snapshot_name, ret, strerror(-ret));
1267
        }
1268
        break;
1269
    }
1270

    
1271
    /* Cleanup */
1272
    bdrv_delete(bs);
1273
    if (ret) {
1274
        return 1;
1275
    }
1276
    return 0;
1277
}
1278

    
1279
static int img_rebase(int argc, char **argv)
1280
{
1281
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1282
    BlockDriver *old_backing_drv, *new_backing_drv;
1283
    char *filename;
1284
    const char *fmt, *cache, *out_basefmt, *out_baseimg;
1285
    int c, flags, ret;
1286
    int unsafe = 0;
1287
    int progress = 0;
1288

    
1289
    /* Parse commandline parameters */
1290
    fmt = NULL;
1291
    cache = BDRV_DEFAULT_CACHE;
1292
    out_baseimg = NULL;
1293
    out_basefmt = NULL;
1294
    for(;;) {
1295
        c = getopt(argc, argv, "uhf:F:b:pt:");
1296
        if (c == -1) {
1297
            break;
1298
        }
1299
        switch(c) {
1300
        case '?':
1301
        case 'h':
1302
            help();
1303
            return 0;
1304
        case 'f':
1305
            fmt = optarg;
1306
            break;
1307
        case 'F':
1308
            out_basefmt = optarg;
1309
            break;
1310
        case 'b':
1311
            out_baseimg = optarg;
1312
            break;
1313
        case 'u':
1314
            unsafe = 1;
1315
            break;
1316
        case 'p':
1317
            progress = 1;
1318
            break;
1319
        case 't':
1320
            cache = optarg;
1321
            break;
1322
        }
1323
    }
1324

    
1325
    if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1326
        help();
1327
    }
1328
    filename = argv[optind++];
1329

    
1330
    qemu_progress_init(progress, 2.0);
1331
    qemu_progress_print(0, 100);
1332

    
1333
    flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1334
    ret = bdrv_parse_cache_flags(cache, &flags);
1335
    if (ret < 0) {
1336
        error_report("Invalid cache option: %s", cache);
1337
        return -1;
1338
    }
1339

    
1340
    /*
1341
     * Open the images.
1342
     *
1343
     * Ignore the old backing file for unsafe rebase in case we want to correct
1344
     * the reference to a renamed or moved backing file.
1345
     */
1346
    bs = bdrv_new_open(filename, fmt, flags);
1347
    if (!bs) {
1348
        return 1;
1349
    }
1350

    
1351
    /* Find the right drivers for the backing files */
1352
    old_backing_drv = NULL;
1353
    new_backing_drv = NULL;
1354

    
1355
    if (!unsafe && bs->backing_format[0] != '\0') {
1356
        old_backing_drv = bdrv_find_format(bs->backing_format);
1357
        if (old_backing_drv == NULL) {
1358
            error_report("Invalid format name: '%s'", bs->backing_format);
1359
            ret = -1;
1360
            goto out;
1361
        }
1362
    }
1363

    
1364
    if (out_basefmt != NULL) {
1365
        new_backing_drv = bdrv_find_format(out_basefmt);
1366
        if (new_backing_drv == NULL) {
1367
            error_report("Invalid format name: '%s'", out_basefmt);
1368
            ret = -1;
1369
            goto out;
1370
        }
1371
    }
1372

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

    
1381
        bs_old_backing = bdrv_new("old_backing");
1382
        bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1383
        ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1384
                        old_backing_drv);
1385
        if (ret) {
1386
            error_report("Could not open old backing file '%s'", backing_name);
1387
            goto out;
1388
        }
1389

    
1390
        bs_new_backing = bdrv_new("new_backing");
1391
        ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1392
                        new_backing_drv);
1393
        if (ret) {
1394
            error_report("Could not open new backing file '%s'", out_baseimg);
1395
            goto out;
1396
        }
1397
    }
1398

    
1399
    /*
1400
     * Check each unallocated cluster in the COW file. If it is unallocated,
1401
     * accesses go to the backing file. We must therefore compare this cluster
1402
     * in the old and new backing file, and if they differ we need to copy it
1403
     * from the old backing file into the COW file.
1404
     *
1405
     * If qemu-img crashes during this step, no harm is done. The content of
1406
     * the image is the same as the original one at any time.
1407
     */
1408
    if (!unsafe) {
1409
        uint64_t num_sectors;
1410
        uint64_t sector;
1411
        int n;
1412
        uint8_t * buf_old;
1413
        uint8_t * buf_new;
1414
        float local_progress;
1415

    
1416
        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
1417
        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
1418

    
1419
        bdrv_get_geometry(bs, &num_sectors);
1420

    
1421
        local_progress = (float)100 /
1422
            (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1423
        for (sector = 0; sector < num_sectors; sector += n) {
1424

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

    
1432
            /* If the cluster is allocated, we don't need to take action */
1433
            ret = bdrv_is_allocated(bs, sector, n, &n);
1434
            if (ret) {
1435
                continue;
1436
            }
1437

    
1438
            /* Read old and new backing file */
1439
            ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1440
            if (ret < 0) {
1441
                error_report("error while reading from old backing file");
1442
                goto out;
1443
            }
1444
            ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1445
            if (ret < 0) {
1446
                error_report("error while reading from new backing file");
1447
                goto out;
1448
            }
1449

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

    
1453
            while (written < n) {
1454
                int pnum;
1455

    
1456
                if (compare_sectors(buf_old + written * 512,
1457
                    buf_new + written * 512, n - written, &pnum))
1458
                {
1459
                    ret = bdrv_write(bs, sector + written,
1460
                        buf_old + written * 512, pnum);
1461
                    if (ret < 0) {
1462
                        error_report("Error while writing to COW image: %s",
1463
                            strerror(-ret));
1464
                        goto out;
1465
                    }
1466
                }
1467

    
1468
                written += pnum;
1469
            }
1470
            qemu_progress_print(local_progress, 100);
1471
        }
1472

    
1473
        qemu_vfree(buf_old);
1474
        qemu_vfree(buf_new);
1475
    }
1476

    
1477
    /*
1478
     * Change the backing file. All clusters that are different from the old
1479
     * backing file are overwritten in the COW file now, so the visible content
1480
     * doesn't change when we switch the backing file.
1481
     */
1482
    ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1483
    if (ret == -ENOSPC) {
1484
        error_report("Could not change the backing file to '%s': No "
1485
                     "space left in the file header", out_baseimg);
1486
    } else if (ret < 0) {
1487
        error_report("Could not change the backing file to '%s': %s",
1488
            out_baseimg, strerror(-ret));
1489
    }
1490

    
1491
    qemu_progress_print(100, 0);
1492
    /*
1493
     * TODO At this point it is possible to check if any clusters that are
1494
     * allocated in the COW file are the same in the backing file. If so, they
1495
     * could be dropped from the COW file. Don't do this before switching the
1496
     * backing file, in case of a crash this would lead to corruption.
1497
     */
1498
out:
1499
    qemu_progress_end();
1500
    /* Cleanup */
1501
    if (!unsafe) {
1502
        if (bs_old_backing != NULL) {
1503
            bdrv_delete(bs_old_backing);
1504
        }
1505
        if (bs_new_backing != NULL) {
1506
            bdrv_delete(bs_new_backing);
1507
        }
1508
    }
1509

    
1510
    bdrv_delete(bs);
1511
    if (ret) {
1512
        return 1;
1513
    }
1514
    return 0;
1515
}
1516

    
1517
static int img_resize(int argc, char **argv)
1518
{
1519
    int c, ret, relative;
1520
    const char *filename, *fmt, *size;
1521
    int64_t n, total_size;
1522
    BlockDriverState *bs = NULL;
1523
    QEMUOptionParameter *param;
1524
    QEMUOptionParameter resize_options[] = {
1525
        {
1526
            .name = BLOCK_OPT_SIZE,
1527
            .type = OPT_SIZE,
1528
            .help = "Virtual disk size"
1529
        },
1530
        { NULL }
1531
    };
1532

    
1533
    /* Remove size from argv manually so that negative numbers are not treated
1534
     * as options by getopt. */
1535
    if (argc < 3) {
1536
        help();
1537
        return 1;
1538
    }
1539

    
1540
    size = argv[--argc];
1541

    
1542
    /* Parse getopt arguments */
1543
    fmt = NULL;
1544
    for(;;) {
1545
        c = getopt(argc, argv, "f:h");
1546
        if (c == -1) {
1547
            break;
1548
        }
1549
        switch(c) {
1550
        case '?':
1551
        case 'h':
1552
            help();
1553
            break;
1554
        case 'f':
1555
            fmt = optarg;
1556
            break;
1557
        }
1558
    }
1559
    if (optind >= argc) {
1560
        help();
1561
    }
1562
    filename = argv[optind++];
1563

    
1564
    /* Choose grow, shrink, or absolute resize mode */
1565
    switch (size[0]) {
1566
    case '+':
1567
        relative = 1;
1568
        size++;
1569
        break;
1570
    case '-':
1571
        relative = -1;
1572
        size++;
1573
        break;
1574
    default:
1575
        relative = 0;
1576
        break;
1577
    }
1578

    
1579
    /* Parse size */
1580
    param = parse_option_parameters("", resize_options, NULL);
1581
    if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1582
        /* Error message already printed when size parsing fails */
1583
        ret = -1;
1584
        goto out;
1585
    }
1586
    n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1587
    free_option_parameters(param);
1588

    
1589
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1590
    if (!bs) {
1591
        ret = -1;
1592
        goto out;
1593
    }
1594

    
1595
    if (relative) {
1596
        total_size = bdrv_getlength(bs) + n * relative;
1597
    } else {
1598
        total_size = n;
1599
    }
1600
    if (total_size <= 0) {
1601
        error_report("New image size must be positive");
1602
        ret = -1;
1603
        goto out;
1604
    }
1605

    
1606
    ret = bdrv_truncate(bs, total_size);
1607
    switch (ret) {
1608
    case 0:
1609
        printf("Image resized.\n");
1610
        break;
1611
    case -ENOTSUP:
1612
        error_report("This image format does not support resize");
1613
        break;
1614
    case -EACCES:
1615
        error_report("Image is read-only");
1616
        break;
1617
    default:
1618
        error_report("Error resizing image (%d)", -ret);
1619
        break;
1620
    }
1621
out:
1622
    if (bs) {
1623
        bdrv_delete(bs);
1624
    }
1625
    if (ret) {
1626
        return 1;
1627
    }
1628
    return 0;
1629
}
1630

    
1631
static const img_cmd_t img_cmds[] = {
1632
#define DEF(option, callback, arg_string)        \
1633
    { option, callback },
1634
#include "qemu-img-cmds.h"
1635
#undef DEF
1636
#undef GEN_DOCS
1637
    { NULL, NULL, },
1638
};
1639

    
1640
int main(int argc, char **argv)
1641
{
1642
    const img_cmd_t *cmd;
1643
    const char *cmdname;
1644

    
1645
    error_set_progname(argv[0]);
1646

    
1647
    bdrv_init();
1648
    if (argc < 2)
1649
        help();
1650
    cmdname = argv[1];
1651
    argc--; argv++;
1652

    
1653
    /* find the command */
1654
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1655
        if (!strcmp(cmdname, cmd->name)) {
1656
            return cmd->handler(argc, argv);
1657
        }
1658
    }
1659

    
1660
    /* not found */
1661
    help();
1662
    return 0;
1663
}