Statistics
| Branch: | Revision:

root / qemu-img.c @ db08adf5

History | View | Annotate | Download (29.8 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
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
35
#define BRDV_O_FLAGS BDRV_O_CACHE_WB
36

    
37
static void QEMU_NORETURN error(const char *fmt, ...)
38
{
39
    va_list ap;
40
    va_start(ap, fmt);
41
    fprintf(stderr, "qemu-img: ");
42
    vfprintf(stderr, fmt, ap);
43
    fprintf(stderr, "\n");
44
    exit(1);
45
    va_end(ap);
46
}
47

    
48
static void format_print(void *opaque, const char *name)
49
{
50
    printf(" %s", name);
51
}
52

    
53
/* Please keep in synch with qemu-img.texi */
54
static void help(void)
55
{
56
    printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
57
           "usage: qemu-img command [command options]\n"
58
           "QEMU disk image utility\n"
59
           "\n"
60
           "Command syntax:\n"
61
           "  check [-f fmt] filename\n"
62
           "  create [-e] [-6] [-F fmt] [-b base_image] [-f fmt] filename [size]\n"
63
           "  commit [-f fmt] filename\n"
64
           "  convert [-c] [-e] [-6] [-f fmt] [-O output_fmt] [-B output_base_image] filename [filename2 [...]] output_filename\n"
65
           "  info [-f fmt] filename\n"
66
           "  snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\n"
67
           "\n"
68
           "Command parameters:\n"
69
           "  'filename' is a disk image filename\n"
70
           "  'base_image' is the read-only disk image which is used as base for a copy on\n"
71
           "    write image; the copy on write image only stores the modified data\n"
72
           "  'output_base_image' forces the output image to be created as a copy on write\n"
73
           "    image of the specified base image; 'output_base_image' should have the same\n"
74
           "    content as the input's base image, however the path, image format, etc may\n"
75
           "    differ\n"
76
           "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
77
           "  'size' is the disk image size in kilobytes. Optional suffixes\n"
78
           "    'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\n"
79
           "    supported any 'k' or 'K' is ignored\n"
80
           "  'output_filename' is the destination disk image filename\n"
81
           "  'output_fmt' is the destination format\n"
82
           "  '-c' indicates that target image must be compressed (qcow format only)\n"
83
           "  '-e' indicates that the target image must be encrypted (qcow format only)\n"
84
           "  '-6' indicates that the target image must use compatibility level 6 (vmdk format only)\n"
85
           "  '-h' with or without a command shows this help and lists the supported formats\n"
86
           "\n"
87
           "Parameters to snapshot subcommand:\n"
88
           "  'snapshot' is the name of the snapshot to create, apply or delete\n"
89
           "  '-a' applies a snapshot (revert disk to saved state)\n"
90
           "  '-c' creates a snapshot\n"
91
           "  '-d' deletes a snapshot\n"
92
           "  '-l' lists all snapshots in the given image\n"
93
           );
94
    printf("\nSupported formats:");
95
    bdrv_iterate_format(format_print, NULL);
96
    printf("\n");
97
    exit(1);
98
}
99

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

    
119
#else
120

    
121
#include <termios.h>
122

    
123
static struct termios oldtty;
124

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

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

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

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

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

    
148
    atexit(term_exit);
149
}
150

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

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

    
188
static BlockDriverState *bdrv_new_open(const char *filename,
189
                                       const char *fmt)
190
{
191
    BlockDriverState *bs;
192
    BlockDriver *drv;
193
    char password[256];
194

    
195
    bs = bdrv_new("");
196
    if (!bs)
197
        error("Not enough memory");
198
    if (fmt) {
199
        drv = bdrv_find_format(fmt);
200
        if (!drv)
201
            error("Unknown file format '%s'", fmt);
202
    } else {
203
        drv = NULL;
204
    }
205
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
206
        error("Could not open '%s'", filename);
207
    }
208
    if (bdrv_is_encrypted(bs)) {
209
        printf("Disk image '%s' is encrypted.\n", filename);
210
        if (read_password(password, sizeof(password)) < 0)
211
            error("No password given");
212
        if (bdrv_set_key(bs, password) < 0)
213
            error("invalid password");
214
    }
215
    return bs;
216
}
217

    
218
static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
219
    int flags, const char *base_filename, const char *base_fmt)
220
{
221
    if (flags & BLOCK_FLAG_ENCRYPT) {
222
        if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
223
            error("Encryption not supported for file format '%s'", fmt);
224
        }
225
    }
226
    if (flags & BLOCK_FLAG_COMPAT6) {
227
        if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
228
            error("VMDK version 6 not supported for file format '%s'", fmt);
229
        }
230
    }
231

    
232
    if (base_filename) {
233
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
234
            error("Backing file not supported for file format '%s'", fmt);
235
        }
236
    }
237
    if (base_fmt) {
238
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
239
            error("Backing file format not supported for file format '%s'", fmt);
240
        }
241
    }
242
}
243

    
244
static int img_create(int argc, char **argv)
245
{
246
    int c, ret, flags;
247
    const char *fmt = "raw";
248
    const char *base_fmt = NULL;
249
    const char *filename;
250
    const char *base_filename = NULL;
251
    BlockDriver *drv;
252
    QEMUOptionParameter *param = NULL;
253
    char *options = NULL;
254

    
255
    flags = 0;
256
    for(;;) {
257
        c = getopt(argc, argv, "F:b:f:he6o:");
258
        if (c == -1)
259
            break;
260
        switch(c) {
261
        case 'h':
262
            help();
263
            break;
264
        case 'F':
265
            base_fmt = optarg;
266
            break;
267
        case 'b':
268
            base_filename = optarg;
269
            break;
270
        case 'f':
271
            fmt = optarg;
272
            break;
273
        case 'e':
274
            flags |= BLOCK_FLAG_ENCRYPT;
275
            break;
276
        case '6':
277
            flags |= BLOCK_FLAG_COMPAT6;
278
            break;
279
        case 'o':
280
            options = optarg;
281
            break;
282
        }
283
    }
284

    
285
    /* Find driver and parse its options */
286
    drv = bdrv_find_format(fmt);
287
    if (!drv)
288
        error("Unknown file format '%s'", fmt);
289

    
290
    if (options && !strcmp(options, "?")) {
291
        print_option_help(drv->create_options);
292
        return 0;
293
    }
294

    
295
    if (options) {
296
        param = parse_option_parameters(options, drv->create_options, param);
297
        if (param == NULL) {
298
            error("Invalid options for file format '%s'.", fmt);
299
        }
300
    } else {
301
        param = parse_option_parameters("", drv->create_options, param);
302
    }
303

    
304
    /* Get the filename */
305
    if (optind >= argc)
306
        help();
307
    filename = argv[optind++];
308

    
309
    /* Add size to parameters */
310
    if (optind < argc) {
311
        set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
312
    }
313

    
314
    /* Add old-style options to parameters */
315
    add_old_style_options(fmt, param, flags, base_filename, base_fmt);
316

    
317
    // The size for the image must always be specified, with one exception:
318
    // If we are using a backing file, we can obtain the size from there
319
    if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {
320

    
321
        QEMUOptionParameter *backing_file =
322
            get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
323
        QEMUOptionParameter *backing_fmt =
324
            get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
325

    
326
        if (backing_file && backing_file->value.s) {
327
            BlockDriverState *bs;
328
            uint64_t size;
329
            const char *fmt = NULL;
330
            char buf[32];
331

    
332
            if (backing_fmt && backing_fmt->value.s) {
333
                 if (bdrv_find_format(backing_fmt->value.s)) {
334
                     fmt = backing_fmt->value.s;
335
                } else {
336
                     error("Unknown backing file format '%s'",
337
                        backing_fmt->value.s);
338
                }
339
            }
340

    
341
            bs = bdrv_new_open(backing_file->value.s, fmt);
342
            bdrv_get_geometry(bs, &size);
343
            size *= 512;
344
            bdrv_delete(bs);
345

    
346
            snprintf(buf, sizeof(buf), "%" PRId64, size);
347
            set_option_parameter(param, BLOCK_OPT_SIZE, buf);
348
        } else {
349
            error("Image creation needs a size parameter");
350
        }
351
    }
352

    
353
    printf("Formatting '%s', fmt=%s ", filename, fmt);
354
    print_option_parameters(param);
355
    puts("");
356

    
357
    ret = bdrv_create(drv, filename, param);
358
    free_option_parameters(param);
359

    
360
    if (ret < 0) {
361
        if (ret == -ENOTSUP) {
362
            error("Formatting or formatting option not supported for file format '%s'", fmt);
363
        } else if (ret == -EFBIG) {
364
            error("The image size is too large for file format '%s'", fmt);
365
        } else {
366
            error("Error while formatting");
367
        }
368
    }
369
    return 0;
370
}
371

    
372
static int img_check(int argc, char **argv)
373
{
374
    int c, ret;
375
    const char *filename, *fmt;
376
    BlockDriver *drv;
377
    BlockDriverState *bs;
378

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

    
397
    bs = bdrv_new("");
398
    if (!bs)
399
        error("Not enough memory");
400
    if (fmt) {
401
        drv = bdrv_find_format(fmt);
402
        if (!drv)
403
            error("Unknown file format '%s'", fmt);
404
    } else {
405
        drv = NULL;
406
    }
407
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
408
        error("Could not open '%s'", filename);
409
    }
410
    ret = bdrv_check(bs);
411
    switch(ret) {
412
    case 0:
413
        printf("No errors were found on the image.\n");
414
        break;
415
    case -ENOTSUP:
416
        error("This image format does not support checks");
417
        break;
418
    default:
419
        if (ret < 0) {
420
            error("An error occurred during the check");
421
        } else {
422
            printf("%d errors were found on the image.\n", ret);
423
        }
424
        break;
425
    }
426

    
427
    bdrv_delete(bs);
428
    return 0;
429
}
430

    
431
static int img_commit(int argc, char **argv)
432
{
433
    int c, ret;
434
    const char *filename, *fmt;
435
    BlockDriver *drv;
436
    BlockDriverState *bs;
437

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

    
456
    bs = bdrv_new("");
457
    if (!bs)
458
        error("Not enough memory");
459
    if (fmt) {
460
        drv = bdrv_find_format(fmt);
461
        if (!drv)
462
            error("Unknown file format '%s'", fmt);
463
    } else {
464
        drv = NULL;
465
    }
466
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
467
        error("Could not open '%s'", filename);
468
    }
469
    ret = bdrv_commit(bs);
470
    switch(ret) {
471
    case 0:
472
        printf("Image committed.\n");
473
        break;
474
    case -ENOENT:
475
        error("No disk inserted");
476
        break;
477
    case -EACCES:
478
        error("Image is read-only");
479
        break;
480
    case -ENOTSUP:
481
        error("Image is already committed");
482
        break;
483
    default:
484
        error("Error while committing image");
485
        break;
486
    }
487

    
488
    bdrv_delete(bs);
489
    return 0;
490
}
491

    
492
static int is_not_zero(const uint8_t *sector, int len)
493
{
494
    int i;
495
    len >>= 2;
496
    for(i = 0;i < len; i++) {
497
        if (((uint32_t *)sector)[i] != 0)
498
            return 1;
499
    }
500
    return 0;
501
}
502

    
503
/*
504
 * Returns true iff the first sector pointed to by 'buf' contains at least
505
 * a non-NUL byte.
506
 *
507
 * 'pnum' is set to the number of sectors (including and immediately following
508
 * the first one) that are known to be in the same allocated/unallocated state.
509
 */
510
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
511
{
512
    int v, i;
513

    
514
    if (n <= 0) {
515
        *pnum = 0;
516
        return 0;
517
    }
518
    v = is_not_zero(buf, 512);
519
    for(i = 1; i < n; i++) {
520
        buf += 512;
521
        if (v != is_not_zero(buf, 512))
522
            break;
523
    }
524
    *pnum = i;
525
    return v;
526
}
527

    
528
#define IO_BUF_SIZE 65536
529

    
530
static int img_convert(int argc, char **argv)
531
{
532
    int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
533
    const char *fmt, *out_fmt, *out_baseimg, *out_filename;
534
    BlockDriver *drv;
535
    BlockDriverState **bs, *out_bs;
536
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
537
    uint64_t bs_sectors;
538
    uint8_t buf[IO_BUF_SIZE];
539
    const uint8_t *buf1;
540
    BlockDriverInfo bdi;
541
    QEMUOptionParameter *param = NULL;
542
    char *options = NULL;
543

    
544
    fmt = NULL;
545
    out_fmt = "raw";
546
    out_baseimg = NULL;
547
    flags = 0;
548
    for(;;) {
549
        c = getopt(argc, argv, "f:O:B:hce6o:");
550
        if (c == -1)
551
            break;
552
        switch(c) {
553
        case 'h':
554
            help();
555
            break;
556
        case 'f':
557
            fmt = optarg;
558
            break;
559
        case 'O':
560
            out_fmt = optarg;
561
            break;
562
        case 'B':
563
            out_baseimg = optarg;
564
            break;
565
        case 'c':
566
            flags |= BLOCK_FLAG_COMPRESS;
567
            break;
568
        case 'e':
569
            flags |= BLOCK_FLAG_ENCRYPT;
570
            break;
571
        case '6':
572
            flags |= BLOCK_FLAG_COMPAT6;
573
            break;
574
        case 'o':
575
            options = optarg;
576
            break;
577
        }
578
    }
579

    
580
    bs_n = argc - optind - 1;
581
    if (bs_n < 1) help();
582

    
583
    out_filename = argv[argc - 1];
584

    
585
    if (bs_n > 1 && out_baseimg)
586
        error("-B makes no sense when concatenating multiple input images");
587
        
588
    bs = calloc(bs_n, sizeof(BlockDriverState *));
589
    if (!bs)
590
        error("Out of memory");
591

    
592
    total_sectors = 0;
593
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
594
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
595
        if (!bs[bs_i])
596
            error("Could not open '%s'", argv[optind + bs_i]);
597
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
598
        total_sectors += bs_sectors;
599
    }
600

    
601
    /* Find driver and parse its options */
602
    drv = bdrv_find_format(out_fmt);
603
    if (!drv)
604
        error("Unknown file format '%s'", out_fmt);
605

    
606
    if (options && !strcmp(options, "?")) {
607
        print_option_help(drv->create_options);
608
        return 0;
609
    }
610

    
611
    if (options) {
612
        param = parse_option_parameters(options, drv->create_options, param);
613
        if (param == NULL) {
614
            error("Invalid options for file format '%s'.", out_fmt);
615
        }
616
    } else {
617
        param = parse_option_parameters("", drv->create_options, param);
618
    }
619

    
620
    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
621
    add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
622

    
623
    /* Check if compression is supported */
624
    if (flags & BLOCK_FLAG_COMPRESS) {
625
        QEMUOptionParameter *encryption =
626
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
627

    
628
        if (!drv->bdrv_write_compressed) {
629
            error("Compression not supported for this file format");
630
        }
631

    
632
        if (encryption && encryption->value.n) {
633
            error("Compression and encryption not supported at the same time");
634
        }
635
    }
636

    
637
    /* Create the new image */
638
    ret = bdrv_create(drv, out_filename, param);
639
    free_option_parameters(param);
640

    
641
    if (ret < 0) {
642
        if (ret == -ENOTSUP) {
643
            error("Formatting not supported for file format '%s'", out_fmt);
644
        } else if (ret == -EFBIG) {
645
            error("The image size is too large for file format '%s'", out_fmt);
646
        } else {
647
            error("Error while formatting '%s'", out_filename);
648
        }
649
    }
650

    
651
    out_bs = bdrv_new_open(out_filename, out_fmt);
652

    
653
    bs_i = 0;
654
    bs_offset = 0;
655
    bdrv_get_geometry(bs[0], &bs_sectors);
656

    
657
    if (flags & BLOCK_FLAG_COMPRESS) {
658
        if (bdrv_get_info(out_bs, &bdi) < 0)
659
            error("could not get block driver info");
660
        cluster_size = bdi.cluster_size;
661
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
662
            error("invalid cluster size");
663
        cluster_sectors = cluster_size >> 9;
664
        sector_num = 0;
665
        for(;;) {
666
            int64_t bs_num;
667
            int remainder;
668
            uint8_t *buf2;
669

    
670
            nb_sectors = total_sectors - sector_num;
671
            if (nb_sectors <= 0)
672
                break;
673
            if (nb_sectors >= cluster_sectors)
674
                n = cluster_sectors;
675
            else
676
                n = nb_sectors;
677

    
678
            bs_num = sector_num - bs_offset;
679
            assert (bs_num >= 0);
680
            remainder = n;
681
            buf2 = buf;
682
            while (remainder > 0) {
683
                int nlow;
684
                while (bs_num == bs_sectors) {
685
                    bs_i++;
686
                    assert (bs_i < bs_n);
687
                    bs_offset += bs_sectors;
688
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
689
                    bs_num = 0;
690
                    /* printf("changing part: sector_num=%lld, "
691
                       "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
692
                       sector_num, bs_i, bs_offset, bs_sectors); */
693
                }
694
                assert (bs_num < bs_sectors);
695

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

    
698
                if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 
699
                    error("error while reading");
700

    
701
                buf2 += nlow * 512;
702
                bs_num += nlow;
703

    
704
                remainder -= nlow;
705
            }
706
            assert (remainder == 0);
707

    
708
            if (n < cluster_sectors)
709
                memset(buf + n * 512, 0, cluster_size - n * 512);
710
            if (is_not_zero(buf, cluster_size)) {
711
                if (bdrv_write_compressed(out_bs, sector_num, buf,
712
                                          cluster_sectors) != 0)
713
                    error("error while compressing sector %" PRId64,
714
                          sector_num);
715
            }
716
            sector_num += n;
717
        }
718
        /* signal EOF to align */
719
        bdrv_write_compressed(out_bs, 0, NULL, 0);
720
    } else {
721
        sector_num = 0; // total number of sectors converted so far
722
        for(;;) {
723
            nb_sectors = total_sectors - sector_num;
724
            if (nb_sectors <= 0)
725
                break;
726
            if (nb_sectors >= (IO_BUF_SIZE / 512))
727
                n = (IO_BUF_SIZE / 512);
728
            else
729
                n = nb_sectors;
730

    
731
            while (sector_num - bs_offset >= bs_sectors) {
732
                bs_i ++;
733
                assert (bs_i < bs_n);
734
                bs_offset += bs_sectors;
735
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
736
                /* printf("changing part: sector_num=%lld, bs_i=%d, "
737
                  "bs_offset=%lld, bs_sectors=%lld\n",
738
                   sector_num, bs_i, bs_offset, bs_sectors); */
739
            }
740

    
741
            if (n > bs_offset + bs_sectors - sector_num)
742
                n = bs_offset + bs_sectors - sector_num;
743

    
744
            if (strcmp(drv->format_name, "host_device")) {
745
                if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
746
                                       n, &n1)) {
747
                    sector_num += n1;
748
                    continue;
749
                }
750
                /* The next 'n1' sectors are allocated in the input image. Copy
751
                   only those as they may be followed by unallocated sectors. */
752
                n = n1;
753
            } else {
754
                n1 = n;
755
            }
756

    
757
            if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 
758
                error("error while reading");
759
            /* NOTE: at the same time we convert, we do not write zero
760
               sectors to have a chance to compress the image. Ideally, we
761
               should add a specific call to have the info to go faster */
762
            buf1 = buf;
763
            while (n > 0) {
764
                /* If the output image is being created as a copy on write image,
765
                   copy all sectors even the ones containing only NUL bytes,
766
                   because they may differ from the sectors in the base image.
767

768
                   If the output is to a host device, we also write out
769
                   sectors that are entirely 0, since whatever data was
770
                   already there is garbage, not 0s. */
771
                if (strcmp(drv->format_name, "host_device") == 0 || out_baseimg ||
772
                    is_allocated_sectors(buf1, n, &n1)) {
773
                    if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
774
                        error("error while writing");
775
                }
776
                sector_num += n1;
777
                n -= n1;
778
                buf1 += n1 * 512;
779
            }
780
        }
781
    }
782
    bdrv_delete(out_bs);
783
    for (bs_i = 0; bs_i < bs_n; bs_i++)
784
        bdrv_delete(bs[bs_i]);
785
    free(bs);
786
    return 0;
787
}
788

    
789
#ifdef _WIN32
790
static int64_t get_allocated_file_size(const char *filename)
791
{
792
    typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
793
    get_compressed_t get_compressed;
794
    struct _stati64 st;
795

    
796
    /* WinNT support GetCompressedFileSize to determine allocate size */
797
    get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
798
    if (get_compressed) {
799
            DWORD high, low;
800
            low = get_compressed(filename, &high);
801
            if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
802
            return (((int64_t) high) << 32) + low;
803
    }
804

    
805
    if (_stati64(filename, &st) < 0)
806
        return -1;
807
    return st.st_size;
808
}
809
#else
810
static int64_t get_allocated_file_size(const char *filename)
811
{
812
    struct stat st;
813
    if (stat(filename, &st) < 0)
814
        return -1;
815
    return (int64_t)st.st_blocks * 512;
816
}
817
#endif
818

    
819
static void dump_snapshots(BlockDriverState *bs)
820
{
821
    QEMUSnapshotInfo *sn_tab, *sn;
822
    int nb_sns, i;
823
    char buf[256];
824

    
825
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
826
    if (nb_sns <= 0)
827
        return;
828
    printf("Snapshot list:\n");
829
    printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
830
    for(i = 0; i < nb_sns; i++) {
831
        sn = &sn_tab[i];
832
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
833
    }
834
    qemu_free(sn_tab);
835
}
836

    
837
static int img_info(int argc, char **argv)
838
{
839
    int c;
840
    const char *filename, *fmt;
841
    BlockDriver *drv;
842
    BlockDriverState *bs;
843
    char fmt_name[128], size_buf[128], dsize_buf[128];
844
    uint64_t total_sectors;
845
    int64_t allocated_size;
846
    char backing_filename[1024];
847
    char backing_filename2[1024];
848
    BlockDriverInfo bdi;
849

    
850
    fmt = NULL;
851
    for(;;) {
852
        c = getopt(argc, argv, "f:h");
853
        if (c == -1)
854
            break;
855
        switch(c) {
856
        case 'h':
857
            help();
858
            break;
859
        case 'f':
860
            fmt = optarg;
861
            break;
862
        }
863
    }
864
    if (optind >= argc)
865
        help();
866
    filename = argv[optind++];
867

    
868
    bs = bdrv_new("");
869
    if (!bs)
870
        error("Not enough memory");
871
    if (fmt) {
872
        drv = bdrv_find_format(fmt);
873
        if (!drv)
874
            error("Unknown file format '%s'", fmt);
875
    } else {
876
        drv = NULL;
877
    }
878
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
879
        error("Could not open '%s'", filename);
880
    }
881
    bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
882
    bdrv_get_geometry(bs, &total_sectors);
883
    get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
884
    allocated_size = get_allocated_file_size(filename);
885
    if (allocated_size < 0)
886
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
887
    else
888
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
889
                                allocated_size);
890
    printf("image: %s\n"
891
           "file format: %s\n"
892
           "virtual size: %s (%" PRId64 " bytes)\n"
893
           "disk size: %s\n",
894
           filename, fmt_name, size_buf,
895
           (total_sectors * 512),
896
           dsize_buf);
897
    if (bdrv_is_encrypted(bs))
898
        printf("encrypted: yes\n");
899
    if (bdrv_get_info(bs, &bdi) >= 0) {
900
        if (bdi.cluster_size != 0)
901
            printf("cluster_size: %d\n", bdi.cluster_size);
902
    }
903
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
904
    if (backing_filename[0] != '\0') {
905
        path_combine(backing_filename2, sizeof(backing_filename2),
906
                     filename, backing_filename);
907
        printf("backing file: %s (actual path: %s)\n",
908
               backing_filename,
909
               backing_filename2);
910
    }
911
    dump_snapshots(bs);
912
    bdrv_delete(bs);
913
    return 0;
914
}
915

    
916
#define SNAPSHOT_LIST   1
917
#define SNAPSHOT_CREATE 2
918
#define SNAPSHOT_APPLY  3
919
#define SNAPSHOT_DELETE 4
920

    
921
static void img_snapshot(int argc, char **argv)
922
{
923
    BlockDriverState *bs;
924
    QEMUSnapshotInfo sn;
925
    char *filename, *snapshot_name = NULL;
926
    int c, ret;
927
    int action = 0;
928
    qemu_timeval tv;
929

    
930
    /* Parse commandline parameters */
931
    for(;;) {
932
        c = getopt(argc, argv, "la:c:d:h");
933
        if (c == -1)
934
            break;
935
        switch(c) {
936
        case 'h':
937
            help();
938
            return;
939
        case 'l':
940
            if (action) {
941
                help();
942
                return;
943
            }
944
            action = SNAPSHOT_LIST;
945
            break;
946
        case 'a':
947
            if (action) {
948
                help();
949
                return;
950
            }
951
            action = SNAPSHOT_APPLY;
952
            snapshot_name = optarg;
953
            break;
954
        case 'c':
955
            if (action) {
956
                help();
957
                return;
958
            }
959
            action = SNAPSHOT_CREATE;
960
            snapshot_name = optarg;
961
            break;
962
        case 'd':
963
            if (action) {
964
                help();
965
                return;
966
            }
967
            action = SNAPSHOT_DELETE;
968
            snapshot_name = optarg;
969
            break;
970
        }
971
    }
972

    
973
    if (optind >= argc)
974
        help();
975
    filename = argv[optind++];
976

    
977
    /* Open the image */
978
    bs = bdrv_new("");
979
    if (!bs)
980
        error("Not enough memory");
981

    
982
    if (bdrv_open2(bs, filename, 0, NULL) < 0) {
983
        error("Could not open '%s'", filename);
984
    }
985

    
986
    /* Perform the requested action */
987
    switch(action) {
988
    case SNAPSHOT_LIST:
989
        dump_snapshots(bs);
990
        break;
991

    
992
    case SNAPSHOT_CREATE:
993
        memset(&sn, 0, sizeof(sn));
994
        pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
995

    
996
        qemu_gettimeofday(&tv);
997
        sn.date_sec = tv.tv_sec;
998
        sn.date_nsec = tv.tv_usec * 1000;
999

    
1000
        ret = bdrv_snapshot_create(bs, &sn);
1001
        if (ret)
1002
            error("Could not create snapshot '%s': %d (%s)",
1003
                snapshot_name, ret, strerror(-ret));
1004
        break;
1005

    
1006
    case SNAPSHOT_APPLY:
1007
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1008
        if (ret)
1009
            error("Could not apply snapshot '%s': %d (%s)",
1010
                snapshot_name, ret, strerror(-ret));
1011
        break;
1012

    
1013
    case SNAPSHOT_DELETE:
1014
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1015
        if (ret)
1016
            error("Could not delete snapshot '%s': %d (%s)",
1017
                snapshot_name, ret, strerror(-ret));
1018
        break;
1019
    }
1020

    
1021
    /* Cleanup */
1022
    bdrv_delete(bs);
1023
}
1024

    
1025
int main(int argc, char **argv)
1026
{
1027
    const char *cmd;
1028

    
1029
    bdrv_init();
1030
    if (argc < 2)
1031
        help();
1032
    cmd = argv[1];
1033
    argc--; argv++;
1034
    if (!strcmp(cmd, "create")) {
1035
        img_create(argc, argv);
1036
    } else if (!strcmp(cmd, "check")) {
1037
        img_check(argc, argv);
1038
    } else if (!strcmp(cmd, "commit")) {
1039
        img_commit(argc, argv);
1040
    } else if (!strcmp(cmd, "convert")) {
1041
        img_convert(argc, argv);
1042
    } else if (!strcmp(cmd, "info")) {
1043
        img_info(argc, argv);
1044
    } else if (!strcmp(cmd, "snapshot")) {
1045
        img_snapshot(argc, argv);
1046
    } else {
1047
        help();
1048
    }
1049
    return 0;
1050
}