Statistics
| Branch: | Revision:

root / qemu-img.c @ d6771bfa

History | View | Annotate | Download (36.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
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 BRDV_O_FLAGS BDRV_O_CACHE_WB
41

    
42
static void QEMU_NORETURN 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
    exit(1);
50
    va_end(ap);
51
}
52

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

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

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

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

    
122
#else
123

    
124
#include <termios.h>
125

    
126
static struct termios oldtty;
127

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

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

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

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

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

    
151
    atexit(term_exit);
152
}
153

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

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

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

    
200
    bs = bdrv_new("");
201
    if (!bs)
202
        error("Not enough memory");
203
    if (fmt) {
204
        drv = bdrv_find_format(fmt);
205
        if (!drv)
206
            error("Unknown file format '%s'", fmt);
207
    } else {
208
        drv = NULL;
209
    }
210
    if (!readonly) {
211
        flags |= BDRV_O_RDWR;
212
    }
213
    if (bdrv_open2(bs, filename, flags, drv) < 0) {
214
        error("Could not open '%s'", filename);
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
        if (bdrv_set_key(bs, password) < 0)
221
            error("invalid password");
222
    }
223
    return bs;
224
}
225

    
226
static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
227
    int flags, const char *base_filename, const char *base_fmt)
228
{
229
    if (flags & BLOCK_FLAG_ENCRYPT) {
230
        if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
231
            error("Encryption not supported for file format '%s'", fmt);
232
        }
233
    }
234
    if (flags & BLOCK_FLAG_COMPAT6) {
235
        if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
236
            error("VMDK version 6 not supported for file format '%s'", fmt);
237
        }
238
    }
239

    
240
    if (base_filename) {
241
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
242
            error("Backing file not supported for file format '%s'", fmt);
243
        }
244
    }
245
    if (base_fmt) {
246
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
247
            error("Backing file format not supported for file format '%s'", fmt);
248
        }
249
    }
250
}
251

    
252
static int img_create(int argc, char **argv)
253
{
254
    int c, ret, flags;
255
    const char *fmt = "raw";
256
    const char *base_fmt = NULL;
257
    const char *filename;
258
    const char *base_filename = NULL;
259
    BlockDriver *drv;
260
    QEMUOptionParameter *param = NULL;
261
    char *options = NULL;
262

    
263
    flags = 0;
264
    for(;;) {
265
        c = getopt(argc, argv, "F:b:f:he6o:");
266
        if (c == -1)
267
            break;
268
        switch(c) {
269
        case 'h':
270
            help();
271
            break;
272
        case 'F':
273
            base_fmt = optarg;
274
            break;
275
        case 'b':
276
            base_filename = optarg;
277
            break;
278
        case 'f':
279
            fmt = optarg;
280
            break;
281
        case 'e':
282
            flags |= BLOCK_FLAG_ENCRYPT;
283
            break;
284
        case '6':
285
            flags |= BLOCK_FLAG_COMPAT6;
286
            break;
287
        case 'o':
288
            options = optarg;
289
            break;
290
        }
291
    }
292

    
293
    /* Find driver and parse its options */
294
    drv = bdrv_find_format(fmt);
295
    if (!drv)
296
        error("Unknown file format '%s'", fmt);
297

    
298
    if (options && !strcmp(options, "?")) {
299
        print_option_help(drv->create_options);
300
        return 0;
301
    }
302

    
303
    /* Create parameter list with default values */
304
    param = parse_option_parameters("", drv->create_options, param);
305
    set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
306

    
307
    /* Parse -o options */
308
    if (options) {
309
        param = parse_option_parameters(options, drv->create_options, param);
310
        if (param == NULL) {
311
            error("Invalid options for file format '%s'.", fmt);
312
        }
313
    }
314

    
315
    /* Get the filename */
316
    if (optind >= argc)
317
        help();
318
    filename = argv[optind++];
319

    
320
    /* Add size to parameters */
321
    if (optind < argc) {
322
        set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
323
    }
324

    
325
    /* Add old-style options to parameters */
326
    add_old_style_options(fmt, param, flags, base_filename, base_fmt);
327

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

    
332
        QEMUOptionParameter *backing_file =
333
            get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
334
        QEMUOptionParameter *backing_fmt =
335
            get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
336

    
337
        if (backing_file && backing_file->value.s) {
338
            BlockDriverState *bs;
339
            uint64_t size;
340
            const char *fmt = NULL;
341
            char buf[32];
342

    
343
            if (backing_fmt && backing_fmt->value.s) {
344
                 if (bdrv_find_format(backing_fmt->value.s)) {
345
                     fmt = backing_fmt->value.s;
346
                } else {
347
                     error("Unknown backing file format '%s'",
348
                        backing_fmt->value.s);
349
                }
350
            }
351

    
352
            bs = bdrv_new_open(backing_file->value.s, fmt, 1);
353
            bdrv_get_geometry(bs, &size);
354
            size *= 512;
355
            bdrv_delete(bs);
356

    
357
            snprintf(buf, sizeof(buf), "%" PRId64, size);
358
            set_option_parameter(param, BLOCK_OPT_SIZE, buf);
359
        } else {
360
            error("Image creation needs a size parameter");
361
        }
362
    }
363

    
364
    printf("Formatting '%s', fmt=%s ", filename, fmt);
365
    print_option_parameters(param);
366
    puts("");
367

    
368
    ret = bdrv_create(drv, filename, param);
369
    free_option_parameters(param);
370

    
371
    if (ret < 0) {
372
        if (ret == -ENOTSUP) {
373
            error("Formatting or formatting option not supported for file format '%s'", fmt);
374
        } else if (ret == -EFBIG) {
375
            error("The image size is too large for file format '%s'", fmt);
376
        } else {
377
            error("Error while formatting");
378
        }
379
    }
380
    return 0;
381
}
382

    
383
static int img_check(int argc, char **argv)
384
{
385
    int c, ret;
386
    const char *filename, *fmt;
387
    BlockDriver *drv;
388
    BlockDriverState *bs;
389

    
390
    fmt = NULL;
391
    for(;;) {
392
        c = getopt(argc, argv, "f:h");
393
        if (c == -1)
394
            break;
395
        switch(c) {
396
        case 'h':
397
            help();
398
            break;
399
        case 'f':
400
            fmt = optarg;
401
            break;
402
        }
403
    }
404
    if (optind >= argc)
405
        help();
406
    filename = argv[optind++];
407

    
408
    bs = bdrv_new("");
409
    if (!bs)
410
        error("Not enough memory");
411
    if (fmt) {
412
        drv = bdrv_find_format(fmt);
413
        if (!drv)
414
            error("Unknown file format '%s'", fmt);
415
    } else {
416
        drv = NULL;
417
    }
418
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
419
        error("Could not open '%s'", filename);
420
    }
421
    ret = bdrv_check(bs);
422
    switch(ret) {
423
    case 0:
424
        printf("No errors were found on the image.\n");
425
        break;
426
    case -ENOTSUP:
427
        error("This image format does not support checks");
428
        break;
429
    default:
430
        if (ret < 0) {
431
            error("An error occurred during the check");
432
        } else {
433
            printf("%d errors were found on the image.\n", ret);
434
        }
435
        break;
436
    }
437

    
438
    bdrv_delete(bs);
439
    return 0;
440
}
441

    
442
static int img_commit(int argc, char **argv)
443
{
444
    int c, ret;
445
    const char *filename, *fmt;
446
    BlockDriver *drv;
447
    BlockDriverState *bs;
448

    
449
    fmt = NULL;
450
    for(;;) {
451
        c = getopt(argc, argv, "f:h");
452
        if (c == -1)
453
            break;
454
        switch(c) {
455
        case 'h':
456
            help();
457
            break;
458
        case 'f':
459
            fmt = optarg;
460
            break;
461
        }
462
    }
463
    if (optind >= argc)
464
        help();
465
    filename = argv[optind++];
466

    
467
    bs = bdrv_new("");
468
    if (!bs)
469
        error("Not enough memory");
470
    if (fmt) {
471
        drv = bdrv_find_format(fmt);
472
        if (!drv)
473
            error("Unknown file format '%s'", fmt);
474
    } else {
475
        drv = NULL;
476
    }
477
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_RDWR, drv) < 0) {
478
        error("Could not open '%s'", filename);
479
    }
480
    ret = bdrv_commit(bs);
481
    switch(ret) {
482
    case 0:
483
        printf("Image committed.\n");
484
        break;
485
    case -ENOENT:
486
        error("No disk inserted");
487
        break;
488
    case -EACCES:
489
        error("Image is read-only");
490
        break;
491
    case -ENOTSUP:
492
        error("Image is already committed");
493
        break;
494
    default:
495
        error("Error while committing image");
496
        break;
497
    }
498

    
499
    bdrv_delete(bs);
500
    return 0;
501
}
502

    
503
static int is_not_zero(const uint8_t *sector, int len)
504
{
505
    int i;
506
    len >>= 2;
507
    for(i = 0;i < len; i++) {
508
        if (((uint32_t *)sector)[i] != 0)
509
            return 1;
510
    }
511
    return 0;
512
}
513

    
514
/*
515
 * Returns true iff the first sector pointed to by 'buf' contains at least
516
 * a non-NUL byte.
517
 *
518
 * 'pnum' is set to the number of sectors (including and immediately following
519
 * the first one) that are known to be in the same allocated/unallocated state.
520
 */
521
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
522
{
523
    int v, i;
524

    
525
    if (n <= 0) {
526
        *pnum = 0;
527
        return 0;
528
    }
529
    v = is_not_zero(buf, 512);
530
    for(i = 1; i < n; i++) {
531
        buf += 512;
532
        if (v != is_not_zero(buf, 512))
533
            break;
534
    }
535
    *pnum = i;
536
    return v;
537
}
538

    
539
/*
540
 * Compares two buffers sector by sector. Returns 0 if the first sector of both
541
 * buffers matches, non-zero otherwise.
542
 *
543
 * pnum is set to the number of sectors (including and immediately following
544
 * the first one) that are known to have the same comparison result
545
 */
546
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
547
    int *pnum)
548
{
549
    int res, i;
550

    
551
    if (n <= 0) {
552
        *pnum = 0;
553
        return 0;
554
    }
555

    
556
    res = !!memcmp(buf1, buf2, 512);
557
    for(i = 1; i < n; i++) {
558
        buf1 += 512;
559
        buf2 += 512;
560

    
561
        if (!!memcmp(buf1, buf2, 512) != res) {
562
            break;
563
        }
564
    }
565

    
566
    *pnum = i;
567
    return res;
568
}
569

    
570
#define IO_BUF_SIZE (2 * 1024 * 1024)
571

    
572
static int img_convert(int argc, char **argv)
573
{
574
    int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
575
    const char *fmt, *out_fmt, *out_baseimg, *out_filename;
576
    BlockDriver *drv;
577
    BlockDriverState **bs, *out_bs;
578
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
579
    uint64_t bs_sectors;
580
    uint8_t * buf;
581
    const uint8_t *buf1;
582
    BlockDriverInfo bdi;
583
    QEMUOptionParameter *param = NULL;
584
    char *options = NULL;
585

    
586
    fmt = NULL;
587
    out_fmt = "raw";
588
    out_baseimg = NULL;
589
    flags = 0;
590
    for(;;) {
591
        c = getopt(argc, argv, "f:O:B:hce6o:");
592
        if (c == -1)
593
            break;
594
        switch(c) {
595
        case 'h':
596
            help();
597
            break;
598
        case 'f':
599
            fmt = optarg;
600
            break;
601
        case 'O':
602
            out_fmt = optarg;
603
            break;
604
        case 'B':
605
            out_baseimg = optarg;
606
            break;
607
        case 'c':
608
            flags |= BLOCK_FLAG_COMPRESS;
609
            break;
610
        case 'e':
611
            flags |= BLOCK_FLAG_ENCRYPT;
612
            break;
613
        case '6':
614
            flags |= BLOCK_FLAG_COMPAT6;
615
            break;
616
        case 'o':
617
            options = optarg;
618
            break;
619
        }
620
    }
621

    
622
    bs_n = argc - optind - 1;
623
    if (bs_n < 1) help();
624

    
625
    out_filename = argv[argc - 1];
626

    
627
    if (bs_n > 1 && out_baseimg)
628
        error("-B makes no sense when concatenating multiple input images");
629
        
630
    bs = calloc(bs_n, sizeof(BlockDriverState *));
631
    if (!bs)
632
        error("Out of memory");
633

    
634
    total_sectors = 0;
635
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
636
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, 1);
637
        if (!bs[bs_i])
638
            error("Could not open '%s'", argv[optind + bs_i]);
639
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
640
        total_sectors += bs_sectors;
641
    }
642

    
643
    /* Find driver and parse its options */
644
    drv = bdrv_find_format(out_fmt);
645
    if (!drv)
646
        error("Unknown file format '%s'", out_fmt);
647

    
648
    if (options && !strcmp(options, "?")) {
649
        print_option_help(drv->create_options);
650
        free(bs);
651
        return 0;
652
    }
653

    
654
    if (options) {
655
        param = parse_option_parameters(options, drv->create_options, param);
656
        if (param == NULL) {
657
            error("Invalid options for file format '%s'.", out_fmt);
658
        }
659
    } else {
660
        param = parse_option_parameters("", drv->create_options, param);
661
    }
662

    
663
    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
664
    add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
665

    
666
    /* Check if compression is supported */
667
    if (flags & BLOCK_FLAG_COMPRESS) {
668
        QEMUOptionParameter *encryption =
669
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
670

    
671
        if (!drv->bdrv_write_compressed) {
672
            error("Compression not supported for this file format");
673
        }
674

    
675
        if (encryption && encryption->value.n) {
676
            error("Compression and encryption not supported at the same time");
677
        }
678
    }
679

    
680
    /* Create the new image */
681
    ret = bdrv_create(drv, out_filename, param);
682
    free_option_parameters(param);
683

    
684
    if (ret < 0) {
685
        if (ret == -ENOTSUP) {
686
            error("Formatting not supported for file format '%s'", out_fmt);
687
        } else if (ret == -EFBIG) {
688
            error("The image size is too large for file format '%s'", out_fmt);
689
        } else {
690
            error("Error while formatting '%s'", out_filename);
691
        }
692
    }
693

    
694
    out_bs = bdrv_new_open(out_filename, out_fmt, 0);
695

    
696
    bs_i = 0;
697
    bs_offset = 0;
698
    bdrv_get_geometry(bs[0], &bs_sectors);
699
    buf = qemu_malloc(IO_BUF_SIZE);
700

    
701
    if (flags & BLOCK_FLAG_COMPRESS) {
702
        if (bdrv_get_info(out_bs, &bdi) < 0)
703
            error("could not get block driver info");
704
        cluster_size = bdi.cluster_size;
705
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
706
            error("invalid cluster size");
707
        cluster_sectors = cluster_size >> 9;
708
        sector_num = 0;
709
        for(;;) {
710
            int64_t bs_num;
711
            int remainder;
712
            uint8_t *buf2;
713

    
714
            nb_sectors = total_sectors - sector_num;
715
            if (nb_sectors <= 0)
716
                break;
717
            if (nb_sectors >= cluster_sectors)
718
                n = cluster_sectors;
719
            else
720
                n = nb_sectors;
721

    
722
            bs_num = sector_num - bs_offset;
723
            assert (bs_num >= 0);
724
            remainder = n;
725
            buf2 = buf;
726
            while (remainder > 0) {
727
                int nlow;
728
                while (bs_num == bs_sectors) {
729
                    bs_i++;
730
                    assert (bs_i < bs_n);
731
                    bs_offset += bs_sectors;
732
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
733
                    bs_num = 0;
734
                    /* printf("changing part: sector_num=%lld, "
735
                       "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
736
                       sector_num, bs_i, bs_offset, bs_sectors); */
737
                }
738
                assert (bs_num < bs_sectors);
739

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

    
742
                if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 
743
                    error("error while reading");
744

    
745
                buf2 += nlow * 512;
746
                bs_num += nlow;
747

    
748
                remainder -= nlow;
749
            }
750
            assert (remainder == 0);
751

    
752
            if (n < cluster_sectors)
753
                memset(buf + n * 512, 0, cluster_size - n * 512);
754
            if (is_not_zero(buf, cluster_size)) {
755
                if (bdrv_write_compressed(out_bs, sector_num, buf,
756
                                          cluster_sectors) != 0)
757
                    error("error while compressing sector %" PRId64,
758
                          sector_num);
759
            }
760
            sector_num += n;
761
        }
762
        /* signal EOF to align */
763
        bdrv_write_compressed(out_bs, 0, NULL, 0);
764
    } else {
765
        sector_num = 0; // total number of sectors converted so far
766
        for(;;) {
767
            nb_sectors = total_sectors - sector_num;
768
            if (nb_sectors <= 0)
769
                break;
770
            if (nb_sectors >= (IO_BUF_SIZE / 512))
771
                n = (IO_BUF_SIZE / 512);
772
            else
773
                n = nb_sectors;
774

    
775
            while (sector_num - bs_offset >= bs_sectors) {
776
                bs_i ++;
777
                assert (bs_i < bs_n);
778
                bs_offset += bs_sectors;
779
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
780
                /* printf("changing part: sector_num=%lld, bs_i=%d, "
781
                  "bs_offset=%lld, bs_sectors=%lld\n",
782
                   sector_num, bs_i, bs_offset, bs_sectors); */
783
            }
784

    
785
            if (n > bs_offset + bs_sectors - sector_num)
786
                n = bs_offset + bs_sectors - sector_num;
787

    
788
            if (!drv->no_zero_init) {
789
                /* If the output image is being created as a copy on write image,
790
                   assume that sectors which are unallocated in the input image
791
                   are present in both the output's and input's base images (no
792
                   need to copy them). */
793
                if (out_baseimg) {
794
                    if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
795
                                           n, &n1)) {
796
                        sector_num += n1;
797
                        continue;
798
                    }
799
                    /* The next 'n1' sectors are allocated in the input image. Copy
800
                       only those as they may be followed by unallocated sectors. */
801
                    n = n1;
802
                }
803
            } else {
804
                n1 = n;
805
            }
806

    
807
            if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 
808
                error("error while reading");
809
            /* NOTE: at the same time we convert, we do not write zero
810
               sectors to have a chance to compress the image. Ideally, we
811
               should add a specific call to have the info to go faster */
812
            buf1 = buf;
813
            while (n > 0) {
814
                /* If the output image is being created as a copy on write image,
815
                   copy all sectors even the ones containing only NUL bytes,
816
                   because they may differ from the sectors in the base image.
817

818
                   If the output is to a host device, we also write out
819
                   sectors that are entirely 0, since whatever data was
820
                   already there is garbage, not 0s. */
821
                if (drv->no_zero_init || out_baseimg ||
822
                    is_allocated_sectors(buf1, n, &n1)) {
823
                    if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
824
                        error("error while writing");
825
                }
826
                sector_num += n1;
827
                n -= n1;
828
                buf1 += n1 * 512;
829
            }
830
        }
831
    }
832
    qemu_free(buf);
833
    bdrv_delete(out_bs);
834
    for (bs_i = 0; bs_i < bs_n; bs_i++)
835
        bdrv_delete(bs[bs_i]);
836
    free(bs);
837
    return 0;
838
}
839

    
840
#ifdef _WIN32
841
static int64_t get_allocated_file_size(const char *filename)
842
{
843
    typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
844
    get_compressed_t get_compressed;
845
    struct _stati64 st;
846

    
847
    /* WinNT support GetCompressedFileSize to determine allocate size */
848
    get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
849
    if (get_compressed) {
850
            DWORD high, low;
851
            low = get_compressed(filename, &high);
852
            if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
853
            return (((int64_t) high) << 32) + low;
854
    }
855

    
856
    if (_stati64(filename, &st) < 0)
857
        return -1;
858
    return st.st_size;
859
}
860
#else
861
static int64_t get_allocated_file_size(const char *filename)
862
{
863
    struct stat st;
864
    if (stat(filename, &st) < 0)
865
        return -1;
866
    return (int64_t)st.st_blocks * 512;
867
}
868
#endif
869

    
870
static void dump_snapshots(BlockDriverState *bs)
871
{
872
    QEMUSnapshotInfo *sn_tab, *sn;
873
    int nb_sns, i;
874
    char buf[256];
875

    
876
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
877
    if (nb_sns <= 0)
878
        return;
879
    printf("Snapshot list:\n");
880
    printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
881
    for(i = 0; i < nb_sns; i++) {
882
        sn = &sn_tab[i];
883
        printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
884
    }
885
    qemu_free(sn_tab);
886
}
887

    
888
static int img_info(int argc, char **argv)
889
{
890
    int c;
891
    const char *filename, *fmt;
892
    BlockDriver *drv;
893
    BlockDriverState *bs;
894
    char fmt_name[128], size_buf[128], dsize_buf[128];
895
    uint64_t total_sectors;
896
    int64_t allocated_size;
897
    char backing_filename[1024];
898
    char backing_filename2[1024];
899
    BlockDriverInfo bdi;
900

    
901
    fmt = NULL;
902
    for(;;) {
903
        c = getopt(argc, argv, "f:h");
904
        if (c == -1)
905
            break;
906
        switch(c) {
907
        case 'h':
908
            help();
909
            break;
910
        case 'f':
911
            fmt = optarg;
912
            break;
913
        }
914
    }
915
    if (optind >= argc)
916
        help();
917
    filename = argv[optind++];
918

    
919
    bs = bdrv_new("");
920
    if (!bs)
921
        error("Not enough memory");
922
    if (fmt) {
923
        drv = bdrv_find_format(fmt);
924
        if (!drv)
925
            error("Unknown file format '%s'", fmt);
926
    } else {
927
        drv = NULL;
928
    }
929
    if (bdrv_open2(bs, filename, BRDV_O_FLAGS | BDRV_O_NO_BACKING, drv) < 0) {
930
        error("Could not open '%s'", filename);
931
    }
932
    bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
933
    bdrv_get_geometry(bs, &total_sectors);
934
    get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
935
    allocated_size = get_allocated_file_size(filename);
936
    if (allocated_size < 0)
937
        snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
938
    else
939
        get_human_readable_size(dsize_buf, sizeof(dsize_buf),
940
                                allocated_size);
941
    printf("image: %s\n"
942
           "file format: %s\n"
943
           "virtual size: %s (%" PRId64 " bytes)\n"
944
           "disk size: %s\n",
945
           filename, fmt_name, size_buf,
946
           (total_sectors * 512),
947
           dsize_buf);
948
    if (bdrv_is_encrypted(bs))
949
        printf("encrypted: yes\n");
950
    if (bdrv_get_info(bs, &bdi) >= 0) {
951
        if (bdi.cluster_size != 0)
952
            printf("cluster_size: %d\n", bdi.cluster_size);
953
    }
954
    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
955
    if (backing_filename[0] != '\0') {
956
        path_combine(backing_filename2, sizeof(backing_filename2),
957
                     filename, backing_filename);
958
        printf("backing file: %s (actual path: %s)\n",
959
               backing_filename,
960
               backing_filename2);
961
    }
962
    dump_snapshots(bs);
963
    bdrv_delete(bs);
964
    return 0;
965
}
966

    
967
#define SNAPSHOT_LIST   1
968
#define SNAPSHOT_CREATE 2
969
#define SNAPSHOT_APPLY  3
970
#define SNAPSHOT_DELETE 4
971

    
972
static int img_snapshot(int argc, char **argv)
973
{
974
    BlockDriverState *bs;
975
    QEMUSnapshotInfo sn;
976
    char *filename, *snapshot_name = NULL;
977
    int c, ret, bdrv_oflags;
978
    int action = 0;
979
    qemu_timeval tv;
980

    
981
    bdrv_oflags = BDRV_O_RDWR;
982
    /* Parse commandline parameters */
983
    for(;;) {
984
        c = getopt(argc, argv, "la:c:d:h");
985
        if (c == -1)
986
            break;
987
        switch(c) {
988
        case 'h':
989
            help();
990
            return 0;
991
        case 'l':
992
            if (action) {
993
                help();
994
                return 0;
995
            }
996
            action = SNAPSHOT_LIST;
997
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
998
            break;
999
        case 'a':
1000
            if (action) {
1001
                help();
1002
                return 0;
1003
            }
1004
            action = SNAPSHOT_APPLY;
1005
            snapshot_name = optarg;
1006
            break;
1007
        case 'c':
1008
            if (action) {
1009
                help();
1010
                return 0;
1011
            }
1012
            action = SNAPSHOT_CREATE;
1013
            snapshot_name = optarg;
1014
            break;
1015
        case 'd':
1016
            if (action) {
1017
                help();
1018
                return 0;
1019
            }
1020
            action = SNAPSHOT_DELETE;
1021
            snapshot_name = optarg;
1022
            break;
1023
        }
1024
    }
1025

    
1026
    if (optind >= argc)
1027
        help();
1028
    filename = argv[optind++];
1029

    
1030
    /* Open the image */
1031
    bs = bdrv_new("");
1032
    if (!bs)
1033
        error("Not enough memory");
1034

    
1035
    if (bdrv_open2(bs, filename, bdrv_oflags, NULL) < 0) {
1036
        error("Could not open '%s'", filename);
1037
    }
1038

    
1039
    /* Perform the requested action */
1040
    switch(action) {
1041
    case SNAPSHOT_LIST:
1042
        dump_snapshots(bs);
1043
        break;
1044

    
1045
    case SNAPSHOT_CREATE:
1046
        memset(&sn, 0, sizeof(sn));
1047
        pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1048

    
1049
        qemu_gettimeofday(&tv);
1050
        sn.date_sec = tv.tv_sec;
1051
        sn.date_nsec = tv.tv_usec * 1000;
1052

    
1053
        ret = bdrv_snapshot_create(bs, &sn);
1054
        if (ret)
1055
            error("Could not create snapshot '%s': %d (%s)",
1056
                snapshot_name, ret, strerror(-ret));
1057
        break;
1058

    
1059
    case SNAPSHOT_APPLY:
1060
        ret = bdrv_snapshot_goto(bs, snapshot_name);
1061
        if (ret)
1062
            error("Could not apply snapshot '%s': %d (%s)",
1063
                snapshot_name, ret, strerror(-ret));
1064
        break;
1065

    
1066
    case SNAPSHOT_DELETE:
1067
        ret = bdrv_snapshot_delete(bs, snapshot_name);
1068
        if (ret)
1069
            error("Could not delete snapshot '%s': %d (%s)",
1070
                snapshot_name, ret, strerror(-ret));
1071
        break;
1072
    }
1073

    
1074
    /* Cleanup */
1075
    bdrv_delete(bs);
1076

    
1077
    return 0;
1078
}
1079

    
1080
static int img_rebase(int argc, char **argv)
1081
{
1082
    BlockDriverState *bs, *bs_old_backing, *bs_new_backing;
1083
    BlockDriver *old_backing_drv, *new_backing_drv;
1084
    char *filename;
1085
    const char *out_basefmt, *out_baseimg;
1086
    int c, flags, ret;
1087
    int unsafe = 0;
1088

    
1089
    /* Parse commandline parameters */
1090
    out_baseimg = NULL;
1091
    out_basefmt = NULL;
1092

    
1093
    for(;;) {
1094
        c = getopt(argc, argv, "uhF:b:");
1095
        if (c == -1)
1096
            break;
1097
        switch(c) {
1098
        case 'h':
1099
            help();
1100
            return 0;
1101
        case 'F':
1102
            out_basefmt = optarg;
1103
            break;
1104
        case 'b':
1105
            out_baseimg = optarg;
1106
            break;
1107
        case 'u':
1108
            unsafe = 1;
1109
            break;
1110
        }
1111
    }
1112

    
1113
    if ((optind >= argc) || !out_baseimg)
1114
        help();
1115
    filename = argv[optind++];
1116

    
1117
    /*
1118
     * Open the images.
1119
     *
1120
     * Ignore the old backing file for unsafe rebase in case we want to correct
1121
     * the reference to a renamed or moved backing file.
1122
     */
1123
    bs = bdrv_new("");
1124
    if (!bs)
1125
        error("Not enough memory");
1126

    
1127
    flags = BRDV_O_FLAGS | BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1128
    if (bdrv_open2(bs, filename, flags, NULL) < 0) {
1129
        error("Could not open '%s'", filename);
1130
    }
1131

    
1132
    /* Find the right drivers for the backing files */
1133
    old_backing_drv = NULL;
1134
    new_backing_drv = NULL;
1135

    
1136
    if (!unsafe && bs->backing_format[0] != '\0') {
1137
        old_backing_drv = bdrv_find_format(bs->backing_format);
1138
        if (old_backing_drv == NULL) {
1139
            error("Invalid format name: '%s'", bs->backing_format);
1140
        }
1141
    }
1142

    
1143
    if (out_basefmt != NULL) {
1144
        new_backing_drv = bdrv_find_format(out_basefmt);
1145
        if (new_backing_drv == NULL) {
1146
            error("Invalid format name: '%s'", out_basefmt);
1147
        }
1148
    }
1149

    
1150
    /* For safe rebasing we need to compare old and new backing file */
1151
    if (unsafe) {
1152
        /* Make the compiler happy */
1153
        bs_old_backing = NULL;
1154
        bs_new_backing = NULL;
1155
    } else {
1156
        char backing_name[1024];
1157

    
1158
        bs_old_backing = bdrv_new("old_backing");
1159
        bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1160
        if (bdrv_open2(bs_old_backing, backing_name, BRDV_O_FLAGS,
1161
            old_backing_drv))
1162
        {
1163
            error("Could not open old backing file '%s'", backing_name);
1164
            return -1;
1165
        }
1166

    
1167
        bs_new_backing = bdrv_new("new_backing");
1168
        if (bdrv_open2(bs_new_backing, out_baseimg, BRDV_O_FLAGS | BDRV_O_RDWR,
1169
            new_backing_drv))
1170
        {
1171
            error("Could not open new backing file '%s'", backing_name);
1172
            return -1;
1173
        }
1174
    }
1175

    
1176
    /*
1177
     * Check each unallocated cluster in the COW file. If it is unallocated,
1178
     * accesses go to the backing file. We must therefore compare this cluster
1179
     * in the old and new backing file, and if they differ we need to copy it
1180
     * from the old backing file into the COW file.
1181
     *
1182
     * If qemu-img crashes during this step, no harm is done. The content of
1183
     * the image is the same as the original one at any time.
1184
     */
1185
    if (!unsafe) {
1186
        uint64_t num_sectors;
1187
        uint64_t sector;
1188
        int n, n1;
1189
        uint8_t * buf_old;
1190
        uint8_t * buf_new;
1191

    
1192
        buf_old = qemu_malloc(IO_BUF_SIZE);
1193
        buf_new = qemu_malloc(IO_BUF_SIZE);
1194

    
1195
        bdrv_get_geometry(bs, &num_sectors);
1196

    
1197
        for (sector = 0; sector < num_sectors; sector += n) {
1198

    
1199
            /* How many sectors can we handle with the next read? */
1200
            if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1201
                n = (IO_BUF_SIZE / 512);
1202
            } else {
1203
                n = num_sectors - sector;
1204
            }
1205

    
1206
            /* If the cluster is allocated, we don't need to take action */
1207
            if (bdrv_is_allocated(bs, sector, n, &n1)) {
1208
                n = n1;
1209
                continue;
1210
            }
1211

    
1212
            /* Read old and new backing file */
1213
            if (bdrv_read(bs_old_backing, sector, buf_old, n) < 0) {
1214
                error("error while reading from old backing file");
1215
            }
1216
            if (bdrv_read(bs_new_backing, sector, buf_new, n) < 0) {
1217
                error("error while reading from new backing file");
1218
            }
1219

    
1220
            /* If they differ, we need to write to the COW file */
1221
            uint64_t written = 0;
1222

    
1223
            while (written < n) {
1224
                int pnum;
1225

    
1226
                if (compare_sectors(buf_old + written * 512,
1227
                    buf_new + written * 512, n, &pnum))
1228
                {
1229
                    ret = bdrv_write(bs, sector + written,
1230
                        buf_old + written * 512, pnum);
1231
                    if (ret < 0) {
1232
                        error("Error while writing to COW image: %s",
1233
                            strerror(-ret));
1234
                    }
1235
                }
1236

    
1237
                written += pnum;
1238
            }
1239
        }
1240

    
1241
        qemu_free(buf_old);
1242
        qemu_free(buf_new);
1243
    }
1244

    
1245
    /*
1246
     * Change the backing file. All clusters that are different from the old
1247
     * backing file are overwritten in the COW file now, so the visible content
1248
     * doesn't change when we switch the backing file.
1249
     */
1250
    ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1251
    if (ret == -ENOSPC) {
1252
        error("Could not change the backing file to '%s': No space left in "
1253
            "the file header", out_baseimg);
1254
    } else if (ret < 0) {
1255
        error("Could not change the backing file to '%s': %s",
1256
            out_baseimg, strerror(-ret));
1257
    }
1258

    
1259
    /*
1260
     * TODO At this point it is possible to check if any clusters that are
1261
     * allocated in the COW file are the same in the backing file. If so, they
1262
     * could be dropped from the COW file. Don't do this before switching the
1263
     * backing file, in case of a crash this would lead to corruption.
1264
     */
1265

    
1266
    /* Cleanup */
1267
    if (!unsafe) {
1268
        bdrv_delete(bs_old_backing);
1269
        bdrv_delete(bs_new_backing);
1270
    }
1271

    
1272
    bdrv_delete(bs);
1273

    
1274
    return 0;
1275
}
1276

    
1277
static const img_cmd_t img_cmds[] = {
1278
#define DEF(option, callback, arg_string)        \
1279
    { option, callback },
1280
#include "qemu-img-cmds.h"
1281
#undef DEF
1282
#undef GEN_DOCS
1283
    { NULL, NULL, },
1284
};
1285

    
1286
int main(int argc, char **argv)
1287
{
1288
    const img_cmd_t *cmd;
1289
    const char *cmdname;
1290

    
1291
    bdrv_init();
1292
    if (argc < 2)
1293
        help();
1294
    cmdname = argv[1];
1295
    argc--; argv++;
1296

    
1297
    /* find the command */
1298
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1299
        if (!strcmp(cmdname, cmd->name)) {
1300
            return cmd->handler(argc, argv);
1301
        }
1302
    }
1303

    
1304
    /* not found */
1305
    help();
1306
    return 0;
1307
}