Statistics
| Branch: | Revision:

root / qemu-img.c @ a18953fb

History | View | Annotate | Download (43 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 "osdep.h"
27
#include "block_int.h"
28
#include <stdio.h>
29

    
30
#ifdef _WIN32
31
#include <windows.h>
32
#endif
33

    
34
typedef struct img_cmd_t {
35
    const char *name;
36
    int (*handler)(int argc, char **argv);
37
} img_cmd_t;
38

    
39
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
40
#define BDRV_O_FLAGS BDRV_O_CACHE_WB
41

    
42
static void GCC_FMT_ATTR(1, 2) error(const char *fmt, ...)
43
{
44
    va_list ap;
45
    va_start(ap, fmt);
46
    fprintf(stderr, "qemu-img: ");
47
    vfprintf(stderr, fmt, ap);
48
    fprintf(stderr, "\n");
49
    va_end(ap);
50
}
51

    
52
static void format_print(void *opaque, const char *name)
53
{
54
    printf(" %s", name);
55
}
56

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

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

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

    
121
#else
122

    
123
#include <termios.h>
124

    
125
static struct termios oldtty;
126

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

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

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

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

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

    
150
    atexit(term_exit);
151
}
152

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

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

    
190
static BlockDriverState *bdrv_new_open(const char *filename,
191
                                       const char *fmt,
192
                                       int flags)
193
{
194
    BlockDriverState *bs;
195
    BlockDriver *drv;
196
    char password[256];
197

    
198
    bs = bdrv_new("");
199
    if (!bs) {
200
        error("Not enough memory");
201
        goto fail;
202
    }
203
    if (fmt) {
204
        drv = bdrv_find_format(fmt);
205
        if (!drv) {
206
            error("Unknown file format '%s'", fmt);
207
            goto fail;
208
        }
209
    } else {
210
        drv = NULL;
211
    }
212
    if (bdrv_open(bs, filename, flags, drv) < 0) {
213
        error("Could not open '%s'", filename);
214
        goto fail;
215
    }
216
    if (bdrv_is_encrypted(bs)) {
217
        printf("Disk image '%s' is encrypted.\n", filename);
218
        if (read_password(password, sizeof(password)) < 0) {
219
            error("No password given");
220
            goto fail;
221
        }
222
        if (bdrv_set_key(bs, password) < 0) {
223
            error("invalid password");
224
            goto fail;
225
        }
226
    }
227
    return bs;
228
fail:
229
    if (bs) {
230
        bdrv_delete(bs);
231
    }
232
    return NULL;
233
}
234

    
235
static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
236
    int flags, const char *base_filename, const char *base_fmt)
237
{
238
    if (flags & BLOCK_FLAG_ENCRYPT) {
239
        if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
240
            error("Encryption not supported for file format '%s'", fmt);
241
            return -1;
242
        }
243
    }
244
    if (flags & BLOCK_FLAG_COMPAT6) {
245
        if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
246
            error("VMDK version 6 not supported for file format '%s'", fmt);
247
            return -1;
248
        }
249
    }
250

    
251
    if (base_filename) {
252
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
253
            error("Backing file not supported for file format '%s'", fmt);
254
            return -1;
255
        }
256
    }
257
    if (base_fmt) {
258
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
259
            error("Backing file format not supported for file format '%s'", fmt);
260
            return -1;
261
        }
262
    }
263
    return 0;
264
}
265

    
266
static int img_create(int argc, char **argv)
267
{
268
    int c, ret = 0, flags;
269
    const char *fmt = "raw";
270
    const char *base_fmt = NULL;
271
    const char *filename;
272
    const char *base_filename = NULL;
273
    BlockDriver *drv, *proto_drv;
274
    QEMUOptionParameter *param = NULL, *create_options = NULL;
275
    char *options = NULL;
276

    
277
    flags = 0;
278
    for(;;) {
279
        c = getopt(argc, argv, "F:b:f:he6o:");
280
        if (c == -1)
281
            break;
282
        switch(c) {
283
        case 'h':
284
            help();
285
            break;
286
        case 'F':
287
            base_fmt = optarg;
288
            break;
289
        case 'b':
290
            base_filename = optarg;
291
            break;
292
        case 'f':
293
            fmt = optarg;
294
            break;
295
        case 'e':
296
            flags |= BLOCK_FLAG_ENCRYPT;
297
            break;
298
        case '6':
299
            flags |= BLOCK_FLAG_COMPAT6;
300
            break;
301
        case 'o':
302
            options = optarg;
303
            break;
304
        }
305
    }
306

    
307
    /* Get the filename */
308
    if (optind >= argc)
309
        help();
310
    filename = argv[optind++];
311

    
312
    /* Find driver and parse its options */
313
    drv = bdrv_find_format(fmt);
314
    if (!drv) {
315
        error("Unknown file format '%s'", fmt);
316
        return 1;
317
    }
318

    
319
    proto_drv = bdrv_find_protocol(filename);
320
    if (!proto_drv) {
321
        error("Unknown protocol '%s'", filename);
322
        return 1;
323
    }
324

    
325
    create_options = append_option_parameters(create_options,
326
                                              drv->create_options);
327
    create_options = append_option_parameters(create_options,
328
                                              proto_drv->create_options);
329

    
330
    if (options && !strcmp(options, "?")) {
331
        print_option_help(create_options);
332
        goto out;
333
    }
334

    
335
    /* Create parameter list with default values */
336
    param = parse_option_parameters("", create_options, param);
337
    set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
338

    
339
    /* Parse -o options */
340
    if (options) {
341
        param = parse_option_parameters(options, create_options, param);
342
        if (param == NULL) {
343
            error("Invalid options for file format '%s'.", fmt);
344
            ret = -1;
345
            goto out;
346
        }
347
    }
348

    
349
    /* Add size to parameters */
350
    if (optind < argc) {
351
        set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
352
    }
353

    
354
    /* Add old-style options to parameters */
355
    ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
356
    if (ret < 0) {
357
        goto out;
358
    }
359

    
360
    // The size for the image must always be specified, with one exception:
361
    // If we are using a backing file, we can obtain the size from there
362
    if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
363

    
364
        QEMUOptionParameter *backing_file =
365
            get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
366
        QEMUOptionParameter *backing_fmt =
367
            get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
368

    
369
        if (backing_file && backing_file->value.s) {
370
            BlockDriverState *bs;
371
            uint64_t size;
372
            const char *fmt = NULL;
373
            char buf[32];
374

    
375
            if (backing_fmt && backing_fmt->value.s) {
376
                 if (bdrv_find_format(backing_fmt->value.s)) {
377
                     fmt = backing_fmt->value.s;
378
                } else {
379
                     error("Unknown backing file format '%s'",
380
                        backing_fmt->value.s);
381
                     ret = -1;
382
                     goto out;
383
                }
384
            }
385

    
386
            bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
387
            if (!bs) {
388
                ret = -1;
389
                goto out;
390
            }
391
            bdrv_get_geometry(bs, &size);
392
            size *= 512;
393
            bdrv_delete(bs);
394

    
395
            snprintf(buf, sizeof(buf), "%" PRId64, size);
396
            set_option_parameter(param, BLOCK_OPT_SIZE, buf);
397
        } else {
398
            error("Image creation needs a size parameter");
399
            ret = -1;
400
            goto out;
401
        }
402
    }
403

    
404
    printf("Formatting '%s', fmt=%s ", filename, fmt);
405
    print_option_parameters(param);
406
    puts("");
407

    
408
    ret = bdrv_create(drv, filename, param);
409
    free_option_parameters(create_options);
410
    free_option_parameters(param);
411

    
412
    if (ret < 0) {
413
        if (ret == -ENOTSUP) {
414
            error("Formatting or formatting option not supported for file format '%s'", fmt);
415
        } else if (ret == -EFBIG) {
416
            error("The image size is too large for file format '%s'", fmt);
417
        } else {
418
            error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
419
        }
420
    }
421
out:
422
    if (ret) {
423
        return 1;
424
    }
425
    return 0;
426
}
427

    
428
/*
429
 * Checks an image for consistency. Exit codes:
430
 *
431
 * 0 - Check completed, image is good
432
 * 1 - Check not completed because of internal errors
433
 * 2 - Check completed, image is corrupted
434
 * 3 - Check completed, image has leaked clusters, but is good otherwise
435
 */
436
static int img_check(int argc, char **argv)
437
{
438
    int c, ret;
439
    const char *filename, *fmt;
440
    BlockDriverState *bs;
441
    BdrvCheckResult result;
442

    
443
    fmt = NULL;
444
    for(;;) {
445
        c = getopt(argc, argv, "f:h");
446
        if (c == -1)
447
            break;
448
        switch(c) {
449
        case 'h':
450
            help();
451
            break;
452
        case 'f':
453
            fmt = optarg;
454
            break;
455
        }
456
    }
457
    if (optind >= argc)
458
        help();
459
    filename = argv[optind++];
460

    
461
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
462
    if (!bs) {
463
        return 1;
464
    }
465
    ret = bdrv_check(bs, &result);
466

    
467
    if (ret == -ENOTSUP) {
468
        error("This image format does not support checks");
469
        bdrv_delete(bs);
470
        return 1;
471
    }
472

    
473
    if (!(result.corruptions || result.leaks || result.check_errors)) {
474
        printf("No errors were found on the image.\n");
475
    } else {
476
        if (result.corruptions) {
477
            printf("\n%d errors were found on the image.\n"
478
                "Data may be corrupted, or further writes to the image "
479
                "may corrupt it.\n",
480
                result.corruptions);
481
        }
482

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

    
489
        if (result.check_errors) {
490
            printf("\n%d internal errors have occurred during the check.\n",
491
                result.check_errors);
492
        }
493
    }
494

    
495
    bdrv_delete(bs);
496

    
497
    if (ret < 0 || result.check_errors) {
498
        printf("\nAn error has occurred during the check: %s\n"
499
            "The check is not complete and may have missed error.\n",
500
            strerror(-ret));
501
        return 1;
502
    }
503

    
504
    if (result.corruptions) {
505
        return 2;
506
    } else if (result.leaks) {
507
        return 3;
508
    } else {
509
        return 0;
510
    }
511
}
512

    
513
static int img_commit(int argc, char **argv)
514
{
515
    int c, ret;
516
    const char *filename, *fmt;
517
    BlockDriverState *bs;
518

    
519
    fmt = NULL;
520
    for(;;) {
521
        c = getopt(argc, argv, "f:h");
522
        if (c == -1)
523
            break;
524
        switch(c) {
525
        case 'h':
526
            help();
527
            break;
528
        case 'f':
529
            fmt = optarg;
530
            break;
531
        }
532
    }
533
    if (optind >= argc)
534
        help();
535
    filename = argv[optind++];
536

    
537
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
538
    if (!bs) {
539
        return 1;
540
    }
541
    ret = bdrv_commit(bs);
542
    switch(ret) {
543
    case 0:
544
        printf("Image committed.\n");
545
        break;
546
    case -ENOENT:
547
        error("No disk inserted");
548
        break;
549
    case -EACCES:
550
        error("Image is read-only");
551
        break;
552
    case -ENOTSUP:
553
        error("Image is already committed");
554
        break;
555
    default:
556
        error("Error while committing image");
557
        break;
558
    }
559

    
560
    bdrv_delete(bs);
561
    if (ret) {
562
        return 1;
563
    }
564
    return 0;
565
}
566

    
567
static int is_not_zero(const uint8_t *sector, int len)
568
{
569
    int i;
570
    len >>= 2;
571
    for(i = 0;i < len; i++) {
572
        if (((uint32_t *)sector)[i] != 0)
573
            return 1;
574
    }
575
    return 0;
576
}
577

    
578
/*
579
 * Returns true iff the first sector pointed to by 'buf' contains at least
580
 * a non-NUL byte.
581
 *
582
 * 'pnum' is set to the number of sectors (including and immediately following
583
 * the first one) that are known to be in the same allocated/unallocated state.
584
 */
585
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
586
{
587
    int v, i;
588

    
589
    if (n <= 0) {
590
        *pnum = 0;
591
        return 0;
592
    }
593
    v = is_not_zero(buf, 512);
594
    for(i = 1; i < n; i++) {
595
        buf += 512;
596
        if (v != is_not_zero(buf, 512))
597
            break;
598
    }
599
    *pnum = i;
600
    return v;
601
}
602

    
603
/*
604
 * Compares two buffers sector by sector. Returns 0 if the first sector of both
605
 * buffers matches, non-zero otherwise.
606
 *
607
 * pnum is set to the number of sectors (including and immediately following
608
 * the first one) that are known to have the same comparison result
609
 */
610
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
611
    int *pnum)
612
{
613
    int res, i;
614

    
615
    if (n <= 0) {
616
        *pnum = 0;
617
        return 0;
618
    }
619

    
620
    res = !!memcmp(buf1, buf2, 512);
621
    for(i = 1; i < n; i++) {
622
        buf1 += 512;
623
        buf2 += 512;
624

    
625
        if (!!memcmp(buf1, buf2, 512) != res) {
626
            break;
627
        }
628
    }
629

    
630
    *pnum = i;
631
    return res;
632
}
633

    
634
#define IO_BUF_SIZE (2 * 1024 * 1024)
635

    
636
static int img_convert(int argc, char **argv)
637
{
638
    int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
639
    const char *fmt, *out_fmt, *out_baseimg, *out_filename;
640
    BlockDriver *drv, *proto_drv;
641
    BlockDriverState **bs = NULL, *out_bs = NULL;
642
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
643
    uint64_t bs_sectors;
644
    uint8_t * buf = NULL;
645
    const uint8_t *buf1;
646
    BlockDriverInfo bdi;
647
    QEMUOptionParameter *param = NULL, *create_options = NULL;
648
    QEMUOptionParameter *out_baseimg_param;
649
    char *options = NULL;
650
    const char *snapshot_name = NULL;
651

    
652
    fmt = NULL;
653
    out_fmt = "raw";
654
    out_baseimg = NULL;
655
    flags = 0;
656
    for(;;) {
657
        c = getopt(argc, argv, "f:O:B:s:hce6o:");
658
        if (c == -1)
659
            break;
660
        switch(c) {
661
        case 'h':
662
            help();
663
            break;
664
        case 'f':
665
            fmt = optarg;
666
            break;
667
        case 'O':
668
            out_fmt = optarg;
669
            break;
670
        case 'B':
671
            out_baseimg = optarg;
672
            break;
673
        case 'c':
674
            flags |= BLOCK_FLAG_COMPRESS;
675
            break;
676
        case 'e':
677
            flags |= BLOCK_FLAG_ENCRYPT;
678
            break;
679
        case '6':
680
            flags |= BLOCK_FLAG_COMPAT6;
681
            break;
682
        case 'o':
683
            options = optarg;
684
            break;
685
        case 's':
686
            snapshot_name = optarg;
687
            break;
688
        }
689
    }
690

    
691
    bs_n = argc - optind - 1;
692
    if (bs_n < 1) help();
693

    
694
    out_filename = argv[argc - 1];
695

    
696
    if (bs_n > 1 && out_baseimg) {
697
        error("-B makes no sense when concatenating multiple input images");
698
        return 1;
699
    }
700
        
701
    bs = calloc(bs_n, sizeof(BlockDriverState *));
702
    if (!bs) {
703
        error("Out of memory");
704
        return 1;
705
    }
706

    
707
    total_sectors = 0;
708
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
709
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
710
        if (!bs[bs_i]) {
711
            error("Could not open '%s'", argv[optind + bs_i]);
712
            ret = -1;
713
            goto out;
714
        }
715
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
716
        total_sectors += bs_sectors;
717
    }
718

    
719
    if (snapshot_name != NULL) {
720
        if (bs_n > 1) {
721
            error("No support for concatenating multiple snapshot\n");
722
            ret = -1;
723
            goto out;
724
        }
725
        if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
726
            error("Failed to load snapshot\n");
727
            ret = -1;
728
            goto out;
729
        }
730
    }
731

    
732
    /* Find driver and parse its options */
733
    drv = bdrv_find_format(out_fmt);
734
    if (!drv) {
735
        error("Unknown file format '%s'", out_fmt);
736
        ret = -1;
737
        goto out;
738
    }
739

    
740
    proto_drv = bdrv_find_protocol(out_filename);
741
    if (!proto_drv) {
742
        error("Unknown protocol '%s'", out_filename);
743
        ret = -1;
744
        goto out;
745
    }
746

    
747
    create_options = append_option_parameters(create_options,
748
                                              drv->create_options);
749
    create_options = append_option_parameters(create_options,
750
                                              proto_drv->create_options);
751
    if (options && !strcmp(options, "?")) {
752
        print_option_help(create_options);
753
        goto out;
754
    }
755

    
756
    if (options) {
757
        param = parse_option_parameters(options, create_options, param);
758
        if (param == NULL) {
759
            error("Invalid options for file format '%s'.", out_fmt);
760
            ret = -1;
761
            goto out;
762
        }
763
    } else {
764
        param = parse_option_parameters("", create_options, param);
765
    }
766

    
767
    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
768
    ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
769
    if (ret < 0) {
770
        goto out;
771
    }
772

    
773
    /* Get backing file name if -o backing_file was used */
774
    out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
775
    if (out_baseimg_param) {
776
        out_baseimg = out_baseimg_param->value.s;
777
    }
778

    
779
    /* Check if compression is supported */
780
    if (flags & BLOCK_FLAG_COMPRESS) {
781
        QEMUOptionParameter *encryption =
782
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
783

    
784
        if (!drv->bdrv_write_compressed) {
785
            error("Compression not supported for this file format");
786
            ret = -1;
787
            goto out;
788
        }
789

    
790
        if (encryption && encryption->value.n) {
791
            error("Compression and encryption not supported at the same time");
792
            ret = -1;
793
            goto out;
794
        }
795
    }
796

    
797
    /* Create the new image */
798
    ret = bdrv_create(drv, out_filename, param);
799
    if (ret < 0) {
800
        if (ret == -ENOTSUP) {
801
            error("Formatting not supported for file format '%s'", out_fmt);
802
        } else if (ret == -EFBIG) {
803
            error("The image size is too large for file format '%s'", out_fmt);
804
        } else {
805
            error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
806
        }
807
        goto out;
808
    }
809

    
810
    out_bs = bdrv_new_open(out_filename, out_fmt,
811
        BDRV_O_FLAGS | BDRV_O_RDWR | BDRV_O_NO_FLUSH);
812
    if (!out_bs) {
813
        ret = -1;
814
        goto out;
815
    }
816

    
817
    bs_i = 0;
818
    bs_offset = 0;
819
    bdrv_get_geometry(bs[0], &bs_sectors);
820
    buf = qemu_malloc(IO_BUF_SIZE);
821

    
822
    if (flags & BLOCK_FLAG_COMPRESS) {
823
        ret = bdrv_get_info(out_bs, &bdi);
824
        if (ret < 0) {
825
            error("could not get block driver info");
826
            goto out;
827
        }
828
        cluster_size = bdi.cluster_size;
829
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
830
            error("invalid cluster size");
831
            ret = -1;
832
            goto out;
833
        }
834
        cluster_sectors = cluster_size >> 9;
835
        sector_num = 0;
836
        for(;;) {
837
            int64_t bs_num;
838
            int remainder;
839
            uint8_t *buf2;
840

    
841
            nb_sectors = total_sectors - sector_num;
842
            if (nb_sectors <= 0)
843
                break;
844
            if (nb_sectors >= cluster_sectors)
845
                n = cluster_sectors;
846
            else
847
                n = nb_sectors;
848

    
849
            bs_num = sector_num - bs_offset;
850
            assert (bs_num >= 0);
851
            remainder = n;
852
            buf2 = buf;
853
            while (remainder > 0) {
854
                int nlow;
855
                while (bs_num == bs_sectors) {
856
                    bs_i++;
857
                    assert (bs_i < bs_n);
858
                    bs_offset += bs_sectors;
859
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
860
                    bs_num = 0;
861
                    /* printf("changing part: sector_num=%" PRId64 ", "
862
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
863
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
864
                }
865
                assert (bs_num < bs_sectors);
866

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

    
869
                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
870
                if (ret < 0) {
871
                    error("error while reading");
872
                    goto out;
873
                }
874

    
875
                buf2 += nlow * 512;
876
                bs_num += nlow;
877

    
878
                remainder -= nlow;
879
            }
880
            assert (remainder == 0);
881

    
882
            if (n < cluster_sectors)
883
                memset(buf + n * 512, 0, cluster_size - n * 512);
884
            if (is_not_zero(buf, cluster_size)) {
885
                ret = bdrv_write_compressed(out_bs, sector_num, buf,
886
                                            cluster_sectors);
887
                if (ret != 0) {
888
                    error("error while compressing sector %" PRId64,
889
                          sector_num);
890
                    goto out;
891
                }
892
            }
893
            sector_num += n;
894
        }
895
        /* signal EOF to align */
896
        bdrv_write_compressed(out_bs, 0, NULL, 0);
897
    } else {
898
        int has_zero_init = bdrv_has_zero_init(out_bs);
899

    
900
        sector_num = 0; // total number of sectors converted so far
901
        for(;;) {
902
            nb_sectors = total_sectors - sector_num;
903
            if (nb_sectors <= 0)
904
                break;
905
            if (nb_sectors >= (IO_BUF_SIZE / 512))
906
                n = (IO_BUF_SIZE / 512);
907
            else
908
                n = nb_sectors;
909

    
910
            while (sector_num - bs_offset >= bs_sectors) {
911
                bs_i ++;
912
                assert (bs_i < bs_n);
913
                bs_offset += bs_sectors;
914
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
915
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
916
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
917
                   sector_num, bs_i, bs_offset, bs_sectors); */
918
            }
919

    
920
            if (n > bs_offset + bs_sectors - sector_num)
921
                n = bs_offset + bs_sectors - sector_num;
922

    
923
            if (has_zero_init) {
924
                /* If the output image is being created as a copy on write image,
925
                   assume that sectors which are unallocated in the input image
926
                   are present in both the output's and input's base images (no
927
                   need to copy them). */
928
                if (out_baseimg) {
929
                    if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
930
                                           n, &n1)) {
931
                        sector_num += n1;
932
                        continue;
933
                    }
934
                    /* The next 'n1' sectors are allocated in the input image. Copy
935
                       only those as they may be followed by unallocated sectors. */
936
                    n = n1;
937
                }
938
            } else {
939
                n1 = n;
940
            }
941

    
942
            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
943
            if (ret < 0) {
944
                error("error while reading");
945
                goto out;
946
            }
947
            /* NOTE: at the same time we convert, we do not write zero
948
               sectors to have a chance to compress the image. Ideally, we
949
               should add a specific call to have the info to go faster */
950
            buf1 = buf;
951
            while (n > 0) {
952
                /* If the output image is being created as a copy on write image,
953
                   copy all sectors even the ones containing only NUL bytes,
954
                   because they may differ from the sectors in the base image.
955

956
                   If the output is to a host device, we also write out
957
                   sectors that are entirely 0, since whatever data was
958
                   already there is garbage, not 0s. */
959
                if (!has_zero_init || out_baseimg ||
960
                    is_allocated_sectors(buf1, n, &n1)) {
961
                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
962
                    if (ret < 0) {
963
                        error("error while writing");
964
                        goto out;
965
                    }
966
                }
967
                sector_num += n1;
968
                n -= n1;
969
                buf1 += n1 * 512;
970
            }
971
        }
972
    }
973
out:
974
    free_option_parameters(create_options);
975
    free_option_parameters(param);
976
    qemu_free(buf);
977
    if (out_bs) {
978
        bdrv_delete(out_bs);
979
    }
980
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
981
        if (bs[bs_i]) {
982
            bdrv_delete(bs[bs_i]);
983
        }
984
    }
985
    free(bs);
986
    if (ret) {
987
        return 1;
988
    }
989
    return 0;
990
}
991

    
992
#ifdef _WIN32
993
static int64_t get_allocated_file_size(const char *filename)
994
{
995
    typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
996
    get_compressed_t get_compressed;
997
    struct _stati64 st;
998

    
999
    /* WinNT support GetCompressedFileSize to determine allocate size */
1000
    get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
1001
    if (get_compressed) {
1002
            DWORD high, low;
1003
            low = get_compressed(filename, &high);
1004
            if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
1005
            return (((int64_t) high) << 32) + low;
1006
    }
1007

    
1008
    if (_stati64(filename, &st) < 0)
1009
        return -1;
1010
    return st.st_size;
1011
}
1012
#else
1013
static int64_t get_allocated_file_size(const char *filename)
1014
{
1015
    struct stat st;
1016
    if (stat(filename, &st) < 0)
1017
        return -1;
1018
    return (int64_t)st.st_blocks * 512;
1019
}
1020
#endif
1021

    
1022
static void dump_snapshots(BlockDriverState *bs)
1023
{
1024
    QEMUSnapshotInfo *sn_tab, *sn;
1025
    int nb_sns, i;
1026
    char buf[256];
1027

    
1028
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1029
    if (nb_sns <= 0)
1030
        return;
1031
    printf("Snapshot list:\n");
1032
    printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1033
    for(i = 0; i < nb_sns; i++) {
1034
        sn = &sn_tab[i];
1035
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1036
    }
1037
    qemu_free(sn_tab);
1038
}
1039

    
1040
static int img_info(int argc, char **argv)
1041
{
1042
    int c;
1043
    const char *filename, *fmt;
1044
    BlockDriverState *bs;
1045
    char fmt_name[128], size_buf[128], dsize_buf[128];
1046
    uint64_t total_sectors;
1047
    int64_t allocated_size;
1048
    char backing_filename[1024];
1049
    char backing_filename2[1024];
1050
    BlockDriverInfo bdi;
1051

    
1052
    fmt = NULL;
1053
    for(;;) {
1054
        c = getopt(argc, argv, "f:h");
1055
        if (c == -1)
1056
            break;
1057
        switch(c) {
1058
        case 'h':
1059
            help();
1060
            break;
1061
        case 'f':
1062
            fmt = optarg;
1063
            break;
1064
        }
1065
    }
1066
    if (optind >= argc)
1067
        help();
1068
    filename = argv[optind++];
1069

    
1070
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1071
    if (!bs) {
1072
        return 1;
1073
    }
1074
    bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1075
    bdrv_get_geometry(bs, &total_sectors);
1076
    get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1077
    allocated_size = get_allocated_file_size(filename);
1078
    if (allocated_size < 0)
1079
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1080
    else
1081
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1082
                                allocated_size);
1083
    printf("image: %s\n"
1084
           "file format: %s\n"
1085
           "virtual size: %s (%" PRId64 " bytes)\n"
1086
           "disk size: %s\n",
1087
           filename, fmt_name, size_buf,
1088
           (total_sectors * 512),
1089
           dsize_buf);
1090
    if (bdrv_is_encrypted(bs))
1091
        printf("encrypted: yes\n");
1092
    if (bdrv_get_info(bs, &bdi) >= 0) {
1093
        if (bdi.cluster_size != 0)
1094
            printf("cluster_size: %d\n", bdi.cluster_size);
1095
    }
1096
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1097
    if (backing_filename[0] != '\0') {
1098
        path_combine(backing_filename2, sizeof(backing_filename2),
1099
                     filename, backing_filename);
1100
        printf("backing file: %s (actual path: %s)\n",
1101
               backing_filename,
1102
               backing_filename2);
1103
    }
1104
    dump_snapshots(bs);
1105
    bdrv_delete(bs);
1106
    return 0;
1107
}
1108

    
1109
#define SNAPSHOT_LIST   1
1110
#define SNAPSHOT_CREATE 2
1111
#define SNAPSHOT_APPLY  3
1112
#define SNAPSHOT_DELETE 4
1113

    
1114
static int img_snapshot(int argc, char **argv)
1115
{
1116
    BlockDriverState *bs;
1117
    QEMUSnapshotInfo sn;
1118
    char *filename, *snapshot_name = NULL;
1119
    int c, ret = 0, bdrv_oflags;
1120
    int action = 0;
1121
    qemu_timeval tv;
1122

    
1123
    bdrv_oflags = BDRV_O_RDWR;
1124
    /* Parse commandline parameters */
1125
    for(;;) {
1126
        c = getopt(argc, argv, "la:c:d:h");
1127
        if (c == -1)
1128
            break;
1129
        switch(c) {
1130
        case 'h':
1131
            help();
1132
            return 0;
1133
        case 'l':
1134
            if (action) {
1135
                help();
1136
                return 0;
1137
            }
1138
            action = SNAPSHOT_LIST;
1139
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1140
            break;
1141
        case 'a':
1142
            if (action) {
1143
                help();
1144
                return 0;
1145
            }
1146
            action = SNAPSHOT_APPLY;
1147
            snapshot_name = optarg;
1148
            break;
1149
        case 'c':
1150
            if (action) {
1151
                help();
1152
                return 0;
1153
            }
1154
            action = SNAPSHOT_CREATE;
1155
            snapshot_name = optarg;
1156
            break;
1157
        case 'd':
1158
            if (action) {
1159
                help();
1160
                return 0;
1161
            }
1162
            action = SNAPSHOT_DELETE;
1163
            snapshot_name = optarg;
1164
            break;
1165
        }
1166
    }
1167

    
1168
    if (optind >= argc)
1169
        help();
1170
    filename = argv[optind++];
1171

    
1172
    /* Open the image */
1173
    bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1174
    if (!bs) {
1175
        return 1;
1176
    }
1177

    
1178
    /* Perform the requested action */
1179
    switch(action) {
1180
    case SNAPSHOT_LIST:
1181
        dump_snapshots(bs);
1182
        break;
1183

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

    
1188
        qemu_gettimeofday(&tv);
1189
        sn.date_sec = tv.tv_sec;
1190
        sn.date_nsec = tv.tv_usec * 1000;
1191

    
1192
        ret = bdrv_snapshot_create(bs, &sn);
1193
        if (ret)
1194
            error("Could not create snapshot '%s': %d (%s)",
1195
                snapshot_name, ret, strerror(-ret));
1196
        break;
1197

    
1198
    case SNAPSHOT_APPLY:
1199
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1200
        if (ret)
1201
            error("Could not apply snapshot '%s': %d (%s)",
1202
                snapshot_name, ret, strerror(-ret));
1203
        break;
1204

    
1205
    case SNAPSHOT_DELETE:
1206
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1207
        if (ret)
1208
            error("Could not delete snapshot '%s': %d (%s)",
1209
                snapshot_name, ret, strerror(-ret));
1210
        break;
1211
    }
1212

    
1213
    /* Cleanup */
1214
    bdrv_delete(bs);
1215
    if (ret) {
1216
        return 1;
1217
    }
1218
    return 0;
1219
}
1220

    
1221
static int img_rebase(int argc, char **argv)
1222
{
1223
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1224
    BlockDriver *old_backing_drv, *new_backing_drv;
1225
    char *filename;
1226
    const char *fmt, *out_basefmt, *out_baseimg;
1227
    int c, flags, ret;
1228
    int unsafe = 0;
1229

    
1230
    /* Parse commandline parameters */
1231
    fmt = NULL;
1232
    out_baseimg = NULL;
1233
    out_basefmt = NULL;
1234

    
1235
    for(;;) {
1236
        c = getopt(argc, argv, "uhf:F:b:");
1237
        if (c == -1)
1238
            break;
1239
        switch(c) {
1240
        case 'h':
1241
            help();
1242
            return 0;
1243
        case 'f':
1244
            fmt = optarg;
1245
            break;
1246
        case 'F':
1247
            out_basefmt = optarg;
1248
            break;
1249
        case 'b':
1250
            out_baseimg = optarg;
1251
            break;
1252
        case 'u':
1253
            unsafe = 1;
1254
            break;
1255
        }
1256
    }
1257

    
1258
    if ((optind >= argc) || !out_baseimg)
1259
        help();
1260
    filename = argv[optind++];
1261

    
1262
    /*
1263
     * Open the images.
1264
     *
1265
     * Ignore the old backing file for unsafe rebase in case we want to correct
1266
     * the reference to a renamed or moved backing file.
1267
     */
1268
    flags = BDRV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1269
    bs = bdrv_new_open(filename, fmt, flags);
1270
    if (!bs) {
1271
        return 1;
1272
    }
1273

    
1274
    /* Find the right drivers for the backing files */
1275
    old_backing_drv = NULL;
1276
    new_backing_drv = NULL;
1277

    
1278
    if (!unsafe && bs->backing_format[0] != '\0') {
1279
        old_backing_drv = bdrv_find_format(bs->backing_format);
1280
        if (old_backing_drv == NULL) {
1281
            error("Invalid format name: '%s'", bs->backing_format);
1282
            ret = -1;
1283
            goto out;
1284
        }
1285
    }
1286

    
1287
    if (out_basefmt != NULL) {
1288
        new_backing_drv = bdrv_find_format(out_basefmt);
1289
        if (new_backing_drv == NULL) {
1290
            error("Invalid format name: '%s'", out_basefmt);
1291
            ret = -1;
1292
            goto out;
1293
        }
1294
    }
1295

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

    
1304
        bs_old_backing = bdrv_new("old_backing");
1305
        bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1306
        ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1307
                        old_backing_drv);
1308
        if (ret) {
1309
            error("Could not open old backing file '%s'", backing_name);
1310
            goto out;
1311
        }
1312

    
1313
        bs_new_backing = bdrv_new("new_backing");
1314
        ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1315
                        new_backing_drv);
1316
        if (ret) {
1317
            error("Could not open new backing file '%s'", out_baseimg);
1318
            goto out;
1319
        }
1320
    }
1321

    
1322
    /*
1323
     * Check each unallocated cluster in the COW file. If it is unallocated,
1324
     * accesses go to the backing file. We must therefore compare this cluster
1325
     * in the old and new backing file, and if they differ we need to copy it
1326
     * from the old backing file into the COW file.
1327
     *
1328
     * If qemu-img crashes during this step, no harm is done. The content of
1329
     * the image is the same as the original one at any time.
1330
     */
1331
    if (!unsafe) {
1332
        uint64_t num_sectors;
1333
        uint64_t sector;
1334
        int n;
1335
        uint8_t * buf_old;
1336
        uint8_t * buf_new;
1337

    
1338
        buf_old = qemu_malloc(IO_BUF_SIZE);
1339
        buf_new = qemu_malloc(IO_BUF_SIZE);
1340

    
1341
        bdrv_get_geometry(bs, &num_sectors);
1342

    
1343
        for (sector = 0; sector < num_sectors; sector += n) {
1344

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

    
1352
            /* If the cluster is allocated, we don't need to take action */
1353
            ret = bdrv_is_allocated(bs, sector, n, &n);
1354
            if (ret) {
1355
                continue;
1356
            }
1357

    
1358
            /* Read old and new backing file */
1359
            ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1360
            if (ret < 0) {
1361
                error("error while reading from old backing file");
1362
                goto out;
1363
            }
1364
            ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1365
            if (ret < 0) {
1366
                error("error while reading from new backing file");
1367
                goto out;
1368
            }
1369

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

    
1373
            while (written < n) {
1374
                int pnum;
1375

    
1376
                if (compare_sectors(buf_old + written * 512,
1377
                    buf_new + written * 512, n - written, &pnum))
1378
                {
1379
                    ret = bdrv_write(bs, sector + written,
1380
                        buf_old + written * 512, pnum);
1381
                    if (ret < 0) {
1382
                        error("Error while writing to COW image: %s",
1383
                            strerror(-ret));
1384
                        goto out;
1385
                    }
1386
                }
1387

    
1388
                written += pnum;
1389
            }
1390
        }
1391

    
1392
        qemu_free(buf_old);
1393
        qemu_free(buf_new);
1394
    }
1395

    
1396
    /*
1397
     * Change the backing file. All clusters that are different from the old
1398
     * backing file are overwritten in the COW file now, so the visible content
1399
     * doesn't change when we switch the backing file.
1400
     */
1401
    ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1402
    if (ret == -ENOSPC) {
1403
        error("Could not change the backing file to '%s': No space left in "
1404
            "the file header", out_baseimg);
1405
    } else if (ret < 0) {
1406
        error("Could not change the backing file to '%s': %s",
1407
            out_baseimg, strerror(-ret));
1408
    }
1409

    
1410
    /*
1411
     * TODO At this point it is possible to check if any clusters that are
1412
     * allocated in the COW file are the same in the backing file. If so, they
1413
     * could be dropped from the COW file. Don't do this before switching the
1414
     * backing file, in case of a crash this would lead to corruption.
1415
     */
1416
out:
1417
    /* Cleanup */
1418
    if (!unsafe) {
1419
        bdrv_delete(bs_old_backing);
1420
        bdrv_delete(bs_new_backing);
1421
    }
1422

    
1423
    bdrv_delete(bs);
1424
    if (ret) {
1425
        return 1;
1426
    }
1427
    return 0;
1428
}
1429

    
1430
static int img_resize(int argc, char **argv)
1431
{
1432
    int c, ret, relative;
1433
    const char *filename, *fmt, *size;
1434
    int64_t n, total_size;
1435
    BlockDriverState *bs;
1436
    QEMUOptionParameter *param;
1437
    QEMUOptionParameter resize_options[] = {
1438
        {
1439
            .name = BLOCK_OPT_SIZE,
1440
            .type = OPT_SIZE,
1441
            .help = "Virtual disk size"
1442
        },
1443
        { NULL }
1444
    };
1445

    
1446
    fmt = NULL;
1447
    for(;;) {
1448
        c = getopt(argc, argv, "f:h");
1449
        if (c == -1) {
1450
            break;
1451
        }
1452
        switch(c) {
1453
        case 'h':
1454
            help();
1455
            break;
1456
        case 'f':
1457
            fmt = optarg;
1458
            break;
1459
        }
1460
    }
1461
    if (optind + 1 >= argc) {
1462
        help();
1463
    }
1464
    filename = argv[optind++];
1465
    size = argv[optind++];
1466

    
1467
    /* Choose grow, shrink, or absolute resize mode */
1468
    switch (size[0]) {
1469
    case '+':
1470
        relative = 1;
1471
        size++;
1472
        break;
1473
    case '-':
1474
        relative = -1;
1475
        size++;
1476
        break;
1477
    default:
1478
        relative = 0;
1479
        break;
1480
    }
1481

    
1482
    /* Parse size */
1483
    param = parse_option_parameters("", resize_options, NULL);
1484
    if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1485
        /* Error message already printed when size parsing fails */
1486
        exit(1);
1487
    }
1488
    n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1489
    free_option_parameters(param);
1490

    
1491
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1492
    if (!bs) {
1493
        return 1;
1494
    }
1495

    
1496
    if (relative) {
1497
        total_size = bdrv_getlength(bs) + n * relative;
1498
    } else {
1499
        total_size = n;
1500
    }
1501
    if (total_size <= 0) {
1502
        error("New image size must be positive");
1503
        ret = -1;
1504
        goto out;
1505
    }
1506

    
1507
    ret = bdrv_truncate(bs, total_size);
1508
    switch (ret) {
1509
    case 0:
1510
        printf("Image resized.\n");
1511
        break;
1512
    case -ENOTSUP:
1513
        error("This image format does not support resize");
1514
        break;
1515
    case -EACCES:
1516
        error("Image is read-only");
1517
        break;
1518
    default:
1519
        error("Error resizing image (%d)", -ret);
1520
        break;
1521
    }
1522
out:
1523
    bdrv_delete(bs);
1524
    if (ret) {
1525
        return 1;
1526
    }
1527
    return 0;
1528
}
1529

    
1530
static const img_cmd_t img_cmds[] = {
1531
#define DEF(option, callback, arg_string)        \
1532
    { option, callback },
1533
#include "qemu-img-cmds.h"
1534
#undef DEF
1535
#undef GEN_DOCS
1536
    { NULL, NULL, },
1537
};
1538

    
1539
int main(int argc, char **argv)
1540
{
1541
    const img_cmd_t *cmd;
1542
    const char *cmdname;
1543

    
1544
    bdrv_init();
1545
    if (argc < 2)
1546
        help();
1547
    cmdname = argv[1];
1548
    argc--; argv++;
1549

    
1550
    /* find the command */
1551
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1552
        if (!strcmp(cmdname, cmd->name)) {
1553
            return cmd->handler(argc, argv);
1554
        }
1555
    }
1556

    
1557
    /* not found */
1558
    help();
1559
    return 0;
1560
}