Statistics
| Branch: | Revision:

root / qemu-img.c @ cc84d90f

History | View | Annotate | Download (74.9 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 "qapi-visit.h"
25
#include "qapi/qmp-output-visitor.h"
26
#include "qapi/qmp/qjson.h"
27
#include "qemu-common.h"
28
#include "qemu/option.h"
29
#include "qemu/error-report.h"
30
#include "qemu/osdep.h"
31
#include "sysemu/sysemu.h"
32
#include "block/block_int.h"
33
#include "block/qapi.h"
34
#include <getopt.h>
35
#include <stdio.h>
36
#include <stdarg.h>
37

    
38
#ifdef _WIN32
39
#include <windows.h>
40
#endif
41

    
42
typedef struct img_cmd_t {
43
    const char *name;
44
    int (*handler)(int argc, char **argv);
45
} img_cmd_t;
46

    
47
enum {
48
    OPTION_OUTPUT = 256,
49
    OPTION_BACKING_CHAIN = 257,
50
};
51

    
52
typedef enum OutputFormat {
53
    OFORMAT_JSON,
54
    OFORMAT_HUMAN,
55
} OutputFormat;
56

    
57
/* Default to cache=writeback as data integrity is not important for qemu-tcg. */
58
#define BDRV_O_FLAGS BDRV_O_CACHE_WB
59
#define BDRV_DEFAULT_CACHE "writeback"
60

    
61
static void format_print(void *opaque, const char *name)
62
{
63
    printf(" %s", name);
64
}
65

    
66
/* Please keep in synch with qemu-img.texi */
67
static void help(void)
68
{
69
    const char *help_msg =
70
           "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
71
           "usage: qemu-img command [command options]\n"
72
           "QEMU disk image utility\n"
73
           "\n"
74
           "Command syntax:\n"
75
#define DEF(option, callback, arg_string)        \
76
           "  " arg_string "\n"
77
#include "qemu-img-cmds.h"
78
#undef DEF
79
#undef GEN_DOCS
80
           "\n"
81
           "Command parameters:\n"
82
           "  'filename' is a disk image filename\n"
83
           "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
84
           "  'cache' is the cache mode used to write the output disk image, the valid\n"
85
           "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
86
           "    'directsync' and 'unsafe' (default for convert)\n"
87
           "  'size' is the disk image size in bytes. Optional suffixes\n"
88
           "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M),\n"
89
           "    'T' (terabyte, 1024G), 'P' (petabyte, 1024T) and 'E' (exabyte, 1024P)  are\n"
90
           "    supported. 'b' is ignored.\n"
91
           "  'output_filename' is the destination disk image filename\n"
92
           "  'output_fmt' is the destination format\n"
93
           "  'options' is a comma separated list of format specific options in a\n"
94
           "    name=value format. Use -o ? for an overview of the options supported by the\n"
95
           "    used format\n"
96
           "  '-c' indicates that target image must be compressed (qcow format only)\n"
97
           "  '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
98
           "       match exactly. The image doesn't need a working backing file before\n"
99
           "       rebasing in this case (useful for renaming the backing file)\n"
100
           "  '-h' with or without a command shows this help and lists the supported formats\n"
101
           "  '-p' show progress of command (only certain commands)\n"
102
           "  '-q' use Quiet mode - do not print any output (except errors)\n"
103
           "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
104
           "       for qemu-img to create a sparse image during conversion\n"
105
           "  '--output' takes the format in which the output must be done (human or json)\n"
106
           "  '-n' skips the target volume creation (useful if the volume is created\n"
107
           "       prior to running qemu-img)\n"
108
           "\n"
109
           "Parameters to check subcommand:\n"
110
           "  '-r' tries to repair any inconsistencies that are found during the check.\n"
111
           "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
112
           "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
113
           "       hiding corruption that has already occurred.\n"
114
           "\n"
115
           "Parameters to snapshot subcommand:\n"
116
           "  'snapshot' is the name of the snapshot to create, apply or delete\n"
117
           "  '-a' applies a snapshot (revert disk to saved state)\n"
118
           "  '-c' creates a snapshot\n"
119
           "  '-d' deletes a snapshot\n"
120
           "  '-l' lists all snapshots in the given image\n"
121
           "\n"
122
           "Parameters to compare subcommand:\n"
123
           "  '-f' first image format\n"
124
           "  '-F' second image format\n"
125
           "  '-s' run in Strict mode - fail on different image size or sector allocation\n";
126

    
127
    printf("%s\nSupported formats:", help_msg);
128
    bdrv_iterate_format(format_print, NULL);
129
    printf("\n");
130
    exit(1);
131
}
132

    
133
static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
134
{
135
    int ret = 0;
136
    if (!quiet) {
137
        va_list args;
138
        va_start(args, fmt);
139
        ret = vprintf(fmt, args);
140
        va_end(args);
141
    }
142
    return ret;
143
}
144

    
145
#if defined(WIN32)
146
/* XXX: put correct support for win32 */
147
static int read_password(char *buf, int buf_size)
148
{
149
    int c, i;
150
    printf("Password: ");
151
    fflush(stdout);
152
    i = 0;
153
    for(;;) {
154
        c = getchar();
155
        if (c == '\n')
156
            break;
157
        if (i < (buf_size - 1))
158
            buf[i++] = c;
159
    }
160
    buf[i] = '\0';
161
    return 0;
162
}
163

    
164
#else
165

    
166
#include <termios.h>
167

    
168
static struct termios oldtty;
169

    
170
static void term_exit(void)
171
{
172
    tcsetattr (0, TCSANOW, &oldtty);
173
}
174

    
175
static void term_init(void)
176
{
177
    struct termios tty;
178

    
179
    tcgetattr (0, &tty);
180
    oldtty = tty;
181

    
182
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
183
                          |INLCR|IGNCR|ICRNL|IXON);
184
    tty.c_oflag |= OPOST;
185
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
186
    tty.c_cflag &= ~(CSIZE|PARENB);
187
    tty.c_cflag |= CS8;
188
    tty.c_cc[VMIN] = 1;
189
    tty.c_cc[VTIME] = 0;
190

    
191
    tcsetattr (0, TCSANOW, &tty);
192

    
193
    atexit(term_exit);
194
}
195

    
196
static int read_password(char *buf, int buf_size)
197
{
198
    uint8_t ch;
199
    int i, ret;
200

    
201
    printf("password: ");
202
    fflush(stdout);
203
    term_init();
204
    i = 0;
205
    for(;;) {
206
        ret = read(0, &ch, 1);
207
        if (ret == -1) {
208
            if (errno == EAGAIN || errno == EINTR) {
209
                continue;
210
            } else {
211
                ret = -1;
212
                break;
213
            }
214
        } else if (ret == 0) {
215
            ret = -1;
216
            break;
217
        } else {
218
            if (ch == '\r') {
219
                ret = 0;
220
                break;
221
            }
222
            if (i < (buf_size - 1))
223
                buf[i++] = ch;
224
        }
225
    }
226
    term_exit();
227
    buf[i] = '\0';
228
    printf("\n");
229
    return ret;
230
}
231
#endif
232

    
233
static int print_block_option_help(const char *filename, const char *fmt)
234
{
235
    BlockDriver *drv, *proto_drv;
236
    QEMUOptionParameter *create_options = NULL;
237

    
238
    /* Find driver and parse its options */
239
    drv = bdrv_find_format(fmt);
240
    if (!drv) {
241
        error_report("Unknown file format '%s'", fmt);
242
        return 1;
243
    }
244

    
245
    proto_drv = bdrv_find_protocol(filename, true);
246
    if (!proto_drv) {
247
        error_report("Unknown protocol '%s'", filename);
248
        return 1;
249
    }
250

    
251
    create_options = append_option_parameters(create_options,
252
                                              drv->create_options);
253
    create_options = append_option_parameters(create_options,
254
                                              proto_drv->create_options);
255
    print_option_help(create_options);
256
    free_option_parameters(create_options);
257
    return 0;
258
}
259

    
260
static BlockDriverState *bdrv_new_open(const char *filename,
261
                                       const char *fmt,
262
                                       int flags,
263
                                       bool require_io,
264
                                       bool quiet)
265
{
266
    BlockDriverState *bs;
267
    BlockDriver *drv;
268
    char password[256];
269
    Error *local_err = NULL;
270
    int ret;
271

    
272
    bs = bdrv_new("image");
273

    
274
    if (fmt) {
275
        drv = bdrv_find_format(fmt);
276
        if (!drv) {
277
            error_report("Unknown file format '%s'", fmt);
278
            goto fail;
279
        }
280
    } else {
281
        drv = NULL;
282
    }
283

    
284
    ret = bdrv_open(bs, filename, NULL, flags, drv, &local_err);
285
    if (ret < 0) {
286
        error_report("Could not open '%s': %s", filename,
287
                     error_get_pretty(local_err));
288
        error_free(local_err);
289
        goto fail;
290
    }
291

    
292
    if (bdrv_is_encrypted(bs) && require_io) {
293
        qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
294
        if (read_password(password, sizeof(password)) < 0) {
295
            error_report("No password given");
296
            goto fail;
297
        }
298
        if (bdrv_set_key(bs, password) < 0) {
299
            error_report("invalid password");
300
            goto fail;
301
        }
302
    }
303
    return bs;
304
fail:
305
    if (bs) {
306
        bdrv_unref(bs);
307
    }
308
    return NULL;
309
}
310

    
311
static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
312
                                 const char *base_filename,
313
                                 const char *base_fmt)
314
{
315
    if (base_filename) {
316
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
317
            error_report("Backing file not supported for file format '%s'",
318
                         fmt);
319
            return -1;
320
        }
321
    }
322
    if (base_fmt) {
323
        if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
324
            error_report("Backing file format not supported for file "
325
                         "format '%s'", fmt);
326
            return -1;
327
        }
328
    }
329
    return 0;
330
}
331

    
332
static int img_create(int argc, char **argv)
333
{
334
    int c;
335
    uint64_t img_size = -1;
336
    const char *fmt = "raw";
337
    const char *base_fmt = NULL;
338
    const char *filename;
339
    const char *base_filename = NULL;
340
    char *options = NULL;
341
    Error *local_err = NULL;
342
    bool quiet = false;
343

    
344
    for(;;) {
345
        c = getopt(argc, argv, "F:b:f:he6o:q");
346
        if (c == -1) {
347
            break;
348
        }
349
        switch(c) {
350
        case '?':
351
        case 'h':
352
            help();
353
            break;
354
        case 'F':
355
            base_fmt = optarg;
356
            break;
357
        case 'b':
358
            base_filename = optarg;
359
            break;
360
        case 'f':
361
            fmt = optarg;
362
            break;
363
        case 'e':
364
            error_report("option -e is deprecated, please use \'-o "
365
                  "encryption\' instead!");
366
            return 1;
367
        case '6':
368
            error_report("option -6 is deprecated, please use \'-o "
369
                  "compat6\' instead!");
370
            return 1;
371
        case 'o':
372
            options = optarg;
373
            break;
374
        case 'q':
375
            quiet = true;
376
            break;
377
        }
378
    }
379

    
380
    /* Get the filename */
381
    if (optind >= argc) {
382
        help();
383
    }
384
    filename = argv[optind++];
385

    
386
    /* Get image size, if specified */
387
    if (optind < argc) {
388
        int64_t sval;
389
        char *end;
390
        sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
391
        if (sval < 0 || *end) {
392
            if (sval == -ERANGE) {
393
                error_report("Image size must be less than 8 EiB!");
394
            } else {
395
                error_report("Invalid image size specified! You may use k, M, "
396
                      "G, T, P or E suffixes for ");
397
                error_report("kilobytes, megabytes, gigabytes, terabytes, "
398
                             "petabytes and exabytes.");
399
            }
400
            return 1;
401
        }
402
        img_size = (uint64_t)sval;
403
    }
404
    if (optind != argc) {
405
        help();
406
    }
407

    
408
    if (options && is_help_option(options)) {
409
        return print_block_option_help(filename, fmt);
410
    }
411

    
412
    bdrv_img_create(filename, fmt, base_filename, base_fmt,
413
                    options, img_size, BDRV_O_FLAGS, &local_err, quiet);
414
    if (error_is_set(&local_err)) {
415
        error_report("%s", error_get_pretty(local_err));
416
        error_free(local_err);
417
        return 1;
418
    }
419

    
420
    return 0;
421
}
422

    
423
static void dump_json_image_check(ImageCheck *check, bool quiet)
424
{
425
    Error *errp = NULL;
426
    QString *str;
427
    QmpOutputVisitor *ov = qmp_output_visitor_new();
428
    QObject *obj;
429
    visit_type_ImageCheck(qmp_output_get_visitor(ov),
430
                          &check, NULL, &errp);
431
    obj = qmp_output_get_qobject(ov);
432
    str = qobject_to_json_pretty(obj);
433
    assert(str != NULL);
434
    qprintf(quiet, "%s\n", qstring_get_str(str));
435
    qobject_decref(obj);
436
    qmp_output_visitor_cleanup(ov);
437
    QDECREF(str);
438
}
439

    
440
static void dump_human_image_check(ImageCheck *check, bool quiet)
441
{
442
    if (!(check->corruptions || check->leaks || check->check_errors)) {
443
        qprintf(quiet, "No errors were found on the image.\n");
444
    } else {
445
        if (check->corruptions) {
446
            qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
447
                    "Data may be corrupted, or further writes to the image "
448
                    "may corrupt it.\n",
449
                    check->corruptions);
450
        }
451

    
452
        if (check->leaks) {
453
            qprintf(quiet,
454
                    "\n%" PRId64 " leaked clusters were found on the image.\n"
455
                    "This means waste of disk space, but no harm to data.\n",
456
                    check->leaks);
457
        }
458

    
459
        if (check->check_errors) {
460
            qprintf(quiet,
461
                    "\n%" PRId64
462
                    " internal errors have occurred during the check.\n",
463
                    check->check_errors);
464
        }
465
    }
466

    
467
    if (check->total_clusters != 0 && check->allocated_clusters != 0) {
468
        qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
469
                "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
470
                check->allocated_clusters, check->total_clusters,
471
                check->allocated_clusters * 100.0 / check->total_clusters,
472
                check->fragmented_clusters * 100.0 / check->allocated_clusters,
473
                check->compressed_clusters * 100.0 /
474
                check->allocated_clusters);
475
    }
476

    
477
    if (check->image_end_offset) {
478
        qprintf(quiet,
479
                "Image end offset: %" PRId64 "\n", check->image_end_offset);
480
    }
481
}
482

    
483
static int collect_image_check(BlockDriverState *bs,
484
                   ImageCheck *check,
485
                   const char *filename,
486
                   const char *fmt,
487
                   int fix)
488
{
489
    int ret;
490
    BdrvCheckResult result;
491

    
492
    ret = bdrv_check(bs, &result, fix);
493
    if (ret < 0) {
494
        return ret;
495
    }
496

    
497
    check->filename                 = g_strdup(filename);
498
    check->format                   = g_strdup(bdrv_get_format_name(bs));
499
    check->check_errors             = result.check_errors;
500
    check->corruptions              = result.corruptions;
501
    check->has_corruptions          = result.corruptions != 0;
502
    check->leaks                    = result.leaks;
503
    check->has_leaks                = result.leaks != 0;
504
    check->corruptions_fixed        = result.corruptions_fixed;
505
    check->has_corruptions_fixed    = result.corruptions != 0;
506
    check->leaks_fixed              = result.leaks_fixed;
507
    check->has_leaks_fixed          = result.leaks != 0;
508
    check->image_end_offset         = result.image_end_offset;
509
    check->has_image_end_offset     = result.image_end_offset != 0;
510
    check->total_clusters           = result.bfi.total_clusters;
511
    check->has_total_clusters       = result.bfi.total_clusters != 0;
512
    check->allocated_clusters       = result.bfi.allocated_clusters;
513
    check->has_allocated_clusters   = result.bfi.allocated_clusters != 0;
514
    check->fragmented_clusters      = result.bfi.fragmented_clusters;
515
    check->has_fragmented_clusters  = result.bfi.fragmented_clusters != 0;
516
    check->compressed_clusters      = result.bfi.compressed_clusters;
517
    check->has_compressed_clusters  = result.bfi.compressed_clusters != 0;
518

    
519
    return 0;
520
}
521

    
522
/*
523
 * Checks an image for consistency. Exit codes:
524
 *
525
 * 0 - Check completed, image is good
526
 * 1 - Check not completed because of internal errors
527
 * 2 - Check completed, image is corrupted
528
 * 3 - Check completed, image has leaked clusters, but is good otherwise
529
 */
530
static int img_check(int argc, char **argv)
531
{
532
    int c, ret;
533
    OutputFormat output_format = OFORMAT_HUMAN;
534
    const char *filename, *fmt, *output;
535
    BlockDriverState *bs;
536
    int fix = 0;
537
    int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
538
    ImageCheck *check;
539
    bool quiet = false;
540

    
541
    fmt = NULL;
542
    output = NULL;
543
    for(;;) {
544
        int option_index = 0;
545
        static const struct option long_options[] = {
546
            {"help", no_argument, 0, 'h'},
547
            {"format", required_argument, 0, 'f'},
548
            {"repair", no_argument, 0, 'r'},
549
            {"output", required_argument, 0, OPTION_OUTPUT},
550
            {0, 0, 0, 0}
551
        };
552
        c = getopt_long(argc, argv, "f:hr:q",
553
                        long_options, &option_index);
554
        if (c == -1) {
555
            break;
556
        }
557
        switch(c) {
558
        case '?':
559
        case 'h':
560
            help();
561
            break;
562
        case 'f':
563
            fmt = optarg;
564
            break;
565
        case 'r':
566
            flags |= BDRV_O_RDWR;
567

    
568
            if (!strcmp(optarg, "leaks")) {
569
                fix = BDRV_FIX_LEAKS;
570
            } else if (!strcmp(optarg, "all")) {
571
                fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
572
            } else {
573
                help();
574
            }
575
            break;
576
        case OPTION_OUTPUT:
577
            output = optarg;
578
            break;
579
        case 'q':
580
            quiet = true;
581
            break;
582
        }
583
    }
584
    if (optind != argc - 1) {
585
        help();
586
    }
587
    filename = argv[optind++];
588

    
589
    if (output && !strcmp(output, "json")) {
590
        output_format = OFORMAT_JSON;
591
    } else if (output && !strcmp(output, "human")) {
592
        output_format = OFORMAT_HUMAN;
593
    } else if (output) {
594
        error_report("--output must be used with human or json as argument.");
595
        return 1;
596
    }
597

    
598
    bs = bdrv_new_open(filename, fmt, flags, true, quiet);
599
    if (!bs) {
600
        return 1;
601
    }
602

    
603
    check = g_new0(ImageCheck, 1);
604
    ret = collect_image_check(bs, check, filename, fmt, fix);
605

    
606
    if (ret == -ENOTSUP) {
607
        if (output_format == OFORMAT_HUMAN) {
608
            error_report("This image format does not support checks");
609
        }
610
        ret = 1;
611
        goto fail;
612
    }
613

    
614
    if (check->corruptions_fixed || check->leaks_fixed) {
615
        int corruptions_fixed, leaks_fixed;
616

    
617
        leaks_fixed         = check->leaks_fixed;
618
        corruptions_fixed   = check->corruptions_fixed;
619

    
620
        if (output_format == OFORMAT_HUMAN) {
621
            qprintf(quiet,
622
                    "The following inconsistencies were found and repaired:\n\n"
623
                    "    %" PRId64 " leaked clusters\n"
624
                    "    %" PRId64 " corruptions\n\n"
625
                    "Double checking the fixed image now...\n",
626
                    check->leaks_fixed,
627
                    check->corruptions_fixed);
628
        }
629

    
630
        ret = collect_image_check(bs, check, filename, fmt, 0);
631

    
632
        check->leaks_fixed          = leaks_fixed;
633
        check->corruptions_fixed    = corruptions_fixed;
634
    }
635

    
636
    switch (output_format) {
637
    case OFORMAT_HUMAN:
638
        dump_human_image_check(check, quiet);
639
        break;
640
    case OFORMAT_JSON:
641
        dump_json_image_check(check, quiet);
642
        break;
643
    }
644

    
645
    if (ret || check->check_errors) {
646
        ret = 1;
647
        goto fail;
648
    }
649

    
650
    if (check->corruptions) {
651
        ret = 2;
652
    } else if (check->leaks) {
653
        ret = 3;
654
    } else {
655
        ret = 0;
656
    }
657

    
658
fail:
659
    qapi_free_ImageCheck(check);
660
    bdrv_unref(bs);
661

    
662
    return ret;
663
}
664

    
665
static int img_commit(int argc, char **argv)
666
{
667
    int c, ret, flags;
668
    const char *filename, *fmt, *cache;
669
    BlockDriverState *bs;
670
    bool quiet = false;
671

    
672
    fmt = NULL;
673
    cache = BDRV_DEFAULT_CACHE;
674
    for(;;) {
675
        c = getopt(argc, argv, "f:ht:q");
676
        if (c == -1) {
677
            break;
678
        }
679
        switch(c) {
680
        case '?':
681
        case 'h':
682
            help();
683
            break;
684
        case 'f':
685
            fmt = optarg;
686
            break;
687
        case 't':
688
            cache = optarg;
689
            break;
690
        case 'q':
691
            quiet = true;
692
            break;
693
        }
694
    }
695
    if (optind != argc - 1) {
696
        help();
697
    }
698
    filename = argv[optind++];
699

    
700
    flags = BDRV_O_RDWR;
701
    ret = bdrv_parse_cache_flags(cache, &flags);
702
    if (ret < 0) {
703
        error_report("Invalid cache option: %s", cache);
704
        return -1;
705
    }
706

    
707
    bs = bdrv_new_open(filename, fmt, flags, true, quiet);
708
    if (!bs) {
709
        return 1;
710
    }
711
    ret = bdrv_commit(bs);
712
    switch(ret) {
713
    case 0:
714
        qprintf(quiet, "Image committed.\n");
715
        break;
716
    case -ENOENT:
717
        error_report("No disk inserted");
718
        break;
719
    case -EACCES:
720
        error_report("Image is read-only");
721
        break;
722
    case -ENOTSUP:
723
        error_report("Image is already committed");
724
        break;
725
    default:
726
        error_report("Error while committing image");
727
        break;
728
    }
729

    
730
    bdrv_unref(bs);
731
    if (ret) {
732
        return 1;
733
    }
734
    return 0;
735
}
736

    
737
/*
738
 * Returns true iff the first sector pointed to by 'buf' contains at least
739
 * a non-NUL byte.
740
 *
741
 * 'pnum' is set to the number of sectors (including and immediately following
742
 * the first one) that are known to be in the same allocated/unallocated state.
743
 */
744
static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
745
{
746
    bool is_zero;
747
    int i;
748

    
749
    if (n <= 0) {
750
        *pnum = 0;
751
        return 0;
752
    }
753
    is_zero = buffer_is_zero(buf, 512);
754
    for(i = 1; i < n; i++) {
755
        buf += 512;
756
        if (is_zero != buffer_is_zero(buf, 512)) {
757
            break;
758
        }
759
    }
760
    *pnum = i;
761
    return !is_zero;
762
}
763

    
764
/*
765
 * Like is_allocated_sectors, but if the buffer starts with a used sector,
766
 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
767
 * breaking up write requests for only small sparse areas.
768
 */
769
static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
770
    int min)
771
{
772
    int ret;
773
    int num_checked, num_used;
774

    
775
    if (n < min) {
776
        min = n;
777
    }
778

    
779
    ret = is_allocated_sectors(buf, n, pnum);
780
    if (!ret) {
781
        return ret;
782
    }
783

    
784
    num_used = *pnum;
785
    buf += BDRV_SECTOR_SIZE * *pnum;
786
    n -= *pnum;
787
    num_checked = num_used;
788

    
789
    while (n > 0) {
790
        ret = is_allocated_sectors(buf, n, pnum);
791

    
792
        buf += BDRV_SECTOR_SIZE * *pnum;
793
        n -= *pnum;
794
        num_checked += *pnum;
795
        if (ret) {
796
            num_used = num_checked;
797
        } else if (*pnum >= min) {
798
            break;
799
        }
800
    }
801

    
802
    *pnum = num_used;
803
    return 1;
804
}
805

    
806
/*
807
 * Compares two buffers sector by sector. Returns 0 if the first sector of both
808
 * buffers matches, non-zero otherwise.
809
 *
810
 * pnum is set to the number of sectors (including and immediately following
811
 * the first one) that are known to have the same comparison result
812
 */
813
static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
814
    int *pnum)
815
{
816
    int res, i;
817

    
818
    if (n <= 0) {
819
        *pnum = 0;
820
        return 0;
821
    }
822

    
823
    res = !!memcmp(buf1, buf2, 512);
824
    for(i = 1; i < n; i++) {
825
        buf1 += 512;
826
        buf2 += 512;
827

    
828
        if (!!memcmp(buf1, buf2, 512) != res) {
829
            break;
830
        }
831
    }
832

    
833
    *pnum = i;
834
    return res;
835
}
836

    
837
#define IO_BUF_SIZE (2 * 1024 * 1024)
838

    
839
static int64_t sectors_to_bytes(int64_t sectors)
840
{
841
    return sectors << BDRV_SECTOR_BITS;
842
}
843

    
844
static int64_t sectors_to_process(int64_t total, int64_t from)
845
{
846
    return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
847
}
848

    
849
/*
850
 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
851
 *
852
 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
853
 * data and negative value on error.
854
 *
855
 * @param bs:  Driver used for accessing file
856
 * @param sect_num: Number of first sector to check
857
 * @param sect_count: Number of sectors to check
858
 * @param filename: Name of disk file we are checking (logging purpose)
859
 * @param buffer: Allocated buffer for storing read data
860
 * @param quiet: Flag for quiet mode
861
 */
862
static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
863
                               int sect_count, const char *filename,
864
                               uint8_t *buffer, bool quiet)
865
{
866
    int pnum, ret = 0;
867
    ret = bdrv_read(bs, sect_num, buffer, sect_count);
868
    if (ret < 0) {
869
        error_report("Error while reading offset %" PRId64 " of %s: %s",
870
                     sectors_to_bytes(sect_num), filename, strerror(-ret));
871
        return ret;
872
    }
873
    ret = is_allocated_sectors(buffer, sect_count, &pnum);
874
    if (ret || pnum != sect_count) {
875
        qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
876
                sectors_to_bytes(ret ? sect_num : sect_num + pnum));
877
        return 1;
878
    }
879

    
880
    return 0;
881
}
882

    
883
/*
884
 * Compares two images. Exit codes:
885
 *
886
 * 0 - Images are identical
887
 * 1 - Images differ
888
 * >1 - Error occurred
889
 */
890
static int img_compare(int argc, char **argv)
891
{
892
    const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
893
    BlockDriverState *bs1, *bs2;
894
    int64_t total_sectors1, total_sectors2;
895
    uint8_t *buf1 = NULL, *buf2 = NULL;
896
    int pnum1, pnum2;
897
    int allocated1, allocated2;
898
    int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
899
    bool progress = false, quiet = false, strict = false;
900
    int64_t total_sectors;
901
    int64_t sector_num = 0;
902
    int64_t nb_sectors;
903
    int c, pnum;
904
    uint64_t bs_sectors;
905
    uint64_t progress_base;
906

    
907
    for (;;) {
908
        c = getopt(argc, argv, "hpf:F:sq");
909
        if (c == -1) {
910
            break;
911
        }
912
        switch (c) {
913
        case '?':
914
        case 'h':
915
            help();
916
            break;
917
        case 'f':
918
            fmt1 = optarg;
919
            break;
920
        case 'F':
921
            fmt2 = optarg;
922
            break;
923
        case 'p':
924
            progress = true;
925
            break;
926
        case 'q':
927
            quiet = true;
928
            break;
929
        case 's':
930
            strict = true;
931
            break;
932
        }
933
    }
934

    
935
    /* Progress is not shown in Quiet mode */
936
    if (quiet) {
937
        progress = false;
938
    }
939

    
940

    
941
    if (optind != argc - 2) {
942
        help();
943
    }
944
    filename1 = argv[optind++];
945
    filename2 = argv[optind++];
946

    
947
    /* Initialize before goto out */
948
    qemu_progress_init(progress, 2.0);
949

    
950
    bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
951
    if (!bs1) {
952
        error_report("Can't open file %s", filename1);
953
        ret = 2;
954
        goto out3;
955
    }
956

    
957
    bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
958
    if (!bs2) {
959
        error_report("Can't open file %s", filename2);
960
        ret = 2;
961
        goto out2;
962
    }
963

    
964
    buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
965
    buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
966
    bdrv_get_geometry(bs1, &bs_sectors);
967
    total_sectors1 = bs_sectors;
968
    bdrv_get_geometry(bs2, &bs_sectors);
969
    total_sectors2 = bs_sectors;
970
    total_sectors = MIN(total_sectors1, total_sectors2);
971
    progress_base = MAX(total_sectors1, total_sectors2);
972

    
973
    qemu_progress_print(0, 100);
974

    
975
    if (strict && total_sectors1 != total_sectors2) {
976
        ret = 1;
977
        qprintf(quiet, "Strict mode: Image size mismatch!\n");
978
        goto out;
979
    }
980

    
981
    for (;;) {
982
        nb_sectors = sectors_to_process(total_sectors, sector_num);
983
        if (nb_sectors <= 0) {
984
            break;
985
        }
986
        allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
987
                                             &pnum1);
988
        if (allocated1 < 0) {
989
            ret = 3;
990
            error_report("Sector allocation test failed for %s", filename1);
991
            goto out;
992
        }
993

    
994
        allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
995
                                             &pnum2);
996
        if (allocated2 < 0) {
997
            ret = 3;
998
            error_report("Sector allocation test failed for %s", filename2);
999
            goto out;
1000
        }
1001
        nb_sectors = MIN(pnum1, pnum2);
1002

    
1003
        if (allocated1 == allocated2) {
1004
            if (allocated1) {
1005
                ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
1006
                if (ret < 0) {
1007
                    error_report("Error while reading offset %" PRId64 " of %s:"
1008
                                 " %s", sectors_to_bytes(sector_num), filename1,
1009
                                 strerror(-ret));
1010
                    ret = 4;
1011
                    goto out;
1012
                }
1013
                ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1014
                if (ret < 0) {
1015
                    error_report("Error while reading offset %" PRId64
1016
                                 " of %s: %s", sectors_to_bytes(sector_num),
1017
                                 filename2, strerror(-ret));
1018
                    ret = 4;
1019
                    goto out;
1020
                }
1021
                ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1022
                if (ret || pnum != nb_sectors) {
1023
                    ret = 1;
1024
                    qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1025
                            sectors_to_bytes(
1026
                                ret ? sector_num : sector_num + pnum));
1027
                    goto out;
1028
                }
1029
            }
1030
        } else {
1031
            if (strict) {
1032
                ret = 1;
1033
                qprintf(quiet, "Strict mode: Offset %" PRId64
1034
                        " allocation mismatch!\n",
1035
                        sectors_to_bytes(sector_num));
1036
                goto out;
1037
            }
1038

    
1039
            if (allocated1) {
1040
                ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1041
                                          filename1, buf1, quiet);
1042
            } else {
1043
                ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1044
                                          filename2, buf1, quiet);
1045
            }
1046
            if (ret) {
1047
                if (ret < 0) {
1048
                    ret = 4;
1049
                    error_report("Error while reading offset %" PRId64 ": %s",
1050
                                 sectors_to_bytes(sector_num), strerror(-ret));
1051
                }
1052
                goto out;
1053
            }
1054
        }
1055
        sector_num += nb_sectors;
1056
        qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1057
    }
1058

    
1059
    if (total_sectors1 != total_sectors2) {
1060
        BlockDriverState *bs_over;
1061
        int64_t total_sectors_over;
1062
        const char *filename_over;
1063

    
1064
        qprintf(quiet, "Warning: Image size mismatch!\n");
1065
        if (total_sectors1 > total_sectors2) {
1066
            total_sectors_over = total_sectors1;
1067
            bs_over = bs1;
1068
            filename_over = filename1;
1069
        } else {
1070
            total_sectors_over = total_sectors2;
1071
            bs_over = bs2;
1072
            filename_over = filename2;
1073
        }
1074

    
1075
        for (;;) {
1076
            nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1077
            if (nb_sectors <= 0) {
1078
                break;
1079
            }
1080
            ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1081
                                          nb_sectors, &pnum);
1082
            if (ret < 0) {
1083
                ret = 3;
1084
                error_report("Sector allocation test failed for %s",
1085
                             filename_over);
1086
                goto out;
1087

    
1088
            }
1089
            nb_sectors = pnum;
1090
            if (ret) {
1091
                ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1092
                                          filename_over, buf1, quiet);
1093
                if (ret) {
1094
                    if (ret < 0) {
1095
                        ret = 4;
1096
                        error_report("Error while reading offset %" PRId64
1097
                                     " of %s: %s", sectors_to_bytes(sector_num),
1098
                                     filename_over, strerror(-ret));
1099
                    }
1100
                    goto out;
1101
                }
1102
            }
1103
            sector_num += nb_sectors;
1104
            qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1105
        }
1106
    }
1107

    
1108
    qprintf(quiet, "Images are identical.\n");
1109
    ret = 0;
1110

    
1111
out:
1112
    bdrv_unref(bs2);
1113
    qemu_vfree(buf1);
1114
    qemu_vfree(buf2);
1115
out2:
1116
    bdrv_unref(bs1);
1117
out3:
1118
    qemu_progress_end();
1119
    return ret;
1120
}
1121

    
1122
static int img_convert(int argc, char **argv)
1123
{
1124
    int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size,
1125
        cluster_sectors, skip_create;
1126
    int progress = 0, flags;
1127
    const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1128
    BlockDriver *drv, *proto_drv;
1129
    BlockDriverState **bs = NULL, *out_bs = NULL;
1130
    int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1131
    uint64_t bs_sectors;
1132
    uint8_t * buf = NULL;
1133
    const uint8_t *buf1;
1134
    BlockDriverInfo bdi;
1135
    QEMUOptionParameter *param = NULL, *create_options = NULL;
1136
    QEMUOptionParameter *out_baseimg_param;
1137
    char *options = NULL;
1138
    const char *snapshot_name = NULL;
1139
    float local_progress = 0;
1140
    int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1141
    bool quiet = false;
1142
    Error *local_err = NULL;
1143

    
1144
    fmt = NULL;
1145
    out_fmt = "raw";
1146
    cache = "unsafe";
1147
    out_baseimg = NULL;
1148
    compress = 0;
1149
    skip_create = 0;
1150
    for(;;) {
1151
        c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:qn");
1152
        if (c == -1) {
1153
            break;
1154
        }
1155
        switch(c) {
1156
        case '?':
1157
        case 'h':
1158
            help();
1159
            break;
1160
        case 'f':
1161
            fmt = optarg;
1162
            break;
1163
        case 'O':
1164
            out_fmt = optarg;
1165
            break;
1166
        case 'B':
1167
            out_baseimg = optarg;
1168
            break;
1169
        case 'c':
1170
            compress = 1;
1171
            break;
1172
        case 'e':
1173
            error_report("option -e is deprecated, please use \'-o "
1174
                  "encryption\' instead!");
1175
            return 1;
1176
        case '6':
1177
            error_report("option -6 is deprecated, please use \'-o "
1178
                  "compat6\' instead!");
1179
            return 1;
1180
        case 'o':
1181
            options = optarg;
1182
            break;
1183
        case 's':
1184
            snapshot_name = optarg;
1185
            break;
1186
        case 'S':
1187
        {
1188
            int64_t sval;
1189
            char *end;
1190
            sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1191
            if (sval < 0 || *end) {
1192
                error_report("Invalid minimum zero buffer size for sparse output specified");
1193
                return 1;
1194
            }
1195

    
1196
            min_sparse = sval / BDRV_SECTOR_SIZE;
1197
            break;
1198
        }
1199
        case 'p':
1200
            progress = 1;
1201
            break;
1202
        case 't':
1203
            cache = optarg;
1204
            break;
1205
        case 'q':
1206
            quiet = true;
1207
            break;
1208
        case 'n':
1209
            skip_create = 1;
1210
            break;
1211
        }
1212
    }
1213

    
1214
    if (quiet) {
1215
        progress = 0;
1216
    }
1217

    
1218
    bs_n = argc - optind - 1;
1219
    if (bs_n < 1) {
1220
        help();
1221
    }
1222

    
1223
    out_filename = argv[argc - 1];
1224

    
1225
    /* Initialize before goto out */
1226
    qemu_progress_init(progress, 2.0);
1227

    
1228
    if (options && is_help_option(options)) {
1229
        ret = print_block_option_help(out_filename, out_fmt);
1230
        goto out;
1231
    }
1232

    
1233
    if (bs_n > 1 && out_baseimg) {
1234
        error_report("-B makes no sense when concatenating multiple input "
1235
                     "images");
1236
        ret = -1;
1237
        goto out;
1238
    }
1239

    
1240
    qemu_progress_print(0, 100);
1241

    
1242
    bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
1243

    
1244
    total_sectors = 0;
1245
    for (bs_i = 0; bs_i < bs_n; bs_i++) {
1246
        bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1247
                                 quiet);
1248
        if (!bs[bs_i]) {
1249
            error_report("Could not open '%s'", argv[optind + bs_i]);
1250
            ret = -1;
1251
            goto out;
1252
        }
1253
        bdrv_get_geometry(bs[bs_i], &bs_sectors);
1254
        total_sectors += bs_sectors;
1255
    }
1256

    
1257
    if (snapshot_name != NULL) {
1258
        if (bs_n > 1) {
1259
            error_report("No support for concatenating multiple snapshot");
1260
            ret = -1;
1261
            goto out;
1262
        }
1263
        if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1264
            error_report("Failed to load snapshot");
1265
            ret = -1;
1266
            goto out;
1267
        }
1268
    }
1269

    
1270
    /* Find driver and parse its options */
1271
    drv = bdrv_find_format(out_fmt);
1272
    if (!drv) {
1273
        error_report("Unknown file format '%s'", out_fmt);
1274
        ret = -1;
1275
        goto out;
1276
    }
1277

    
1278
    proto_drv = bdrv_find_protocol(out_filename, true);
1279
    if (!proto_drv) {
1280
        error_report("Unknown protocol '%s'", out_filename);
1281
        ret = -1;
1282
        goto out;
1283
    }
1284

    
1285
    create_options = append_option_parameters(create_options,
1286
                                              drv->create_options);
1287
    create_options = append_option_parameters(create_options,
1288
                                              proto_drv->create_options);
1289

    
1290
    if (options) {
1291
        param = parse_option_parameters(options, create_options, param);
1292
        if (param == NULL) {
1293
            error_report("Invalid options for file format '%s'.", out_fmt);
1294
            ret = -1;
1295
            goto out;
1296
        }
1297
    } else {
1298
        param = parse_option_parameters("", create_options, param);
1299
    }
1300

    
1301
    set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1302
    ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1303
    if (ret < 0) {
1304
        goto out;
1305
    }
1306

    
1307
    /* Get backing file name if -o backing_file was used */
1308
    out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1309
    if (out_baseimg_param) {
1310
        out_baseimg = out_baseimg_param->value.s;
1311
    }
1312

    
1313
    /* Check if compression is supported */
1314
    if (compress) {
1315
        QEMUOptionParameter *encryption =
1316
            get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1317
        QEMUOptionParameter *preallocation =
1318
            get_option_parameter(param, BLOCK_OPT_PREALLOC);
1319

    
1320
        if (!drv->bdrv_write_compressed) {
1321
            error_report("Compression not supported for this file format");
1322
            ret = -1;
1323
            goto out;
1324
        }
1325

    
1326
        if (encryption && encryption->value.n) {
1327
            error_report("Compression and encryption not supported at "
1328
                         "the same time");
1329
            ret = -1;
1330
            goto out;
1331
        }
1332

    
1333
        if (preallocation && preallocation->value.s
1334
            && strcmp(preallocation->value.s, "off"))
1335
        {
1336
            error_report("Compression and preallocation not supported at "
1337
                         "the same time");
1338
            ret = -1;
1339
            goto out;
1340
        }
1341
    }
1342

    
1343
    if (!skip_create) {
1344
        /* Create the new image */
1345
        ret = bdrv_create(drv, out_filename, param, &local_err);
1346
        if (ret < 0) {
1347
            error_report("%s: error while converting %s: %s",
1348
                         out_filename, out_fmt, error_get_pretty(local_err));
1349
            error_free(local_err);
1350
            goto out;
1351
        }
1352
    }
1353

    
1354
    flags = BDRV_O_RDWR;
1355
    ret = bdrv_parse_cache_flags(cache, &flags);
1356
    if (ret < 0) {
1357
        error_report("Invalid cache option: %s", cache);
1358
        return -1;
1359
    }
1360

    
1361
    out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1362
    if (!out_bs) {
1363
        ret = -1;
1364
        goto out;
1365
    }
1366

    
1367
    bs_i = 0;
1368
    bs_offset = 0;
1369
    bdrv_get_geometry(bs[0], &bs_sectors);
1370
    buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1371

    
1372
    if (skip_create) {
1373
        int64_t output_length = bdrv_getlength(out_bs);
1374
        if (output_length < 0) {
1375
            error_report("unable to get output image length: %s\n",
1376
                         strerror(-output_length));
1377
            ret = -1;
1378
            goto out;
1379
        } else if (output_length < total_sectors << BDRV_SECTOR_BITS) {
1380
            error_report("output file is smaller than input file");
1381
            ret = -1;
1382
            goto out;
1383
        }
1384
    }
1385

    
1386
    if (compress) {
1387
        ret = bdrv_get_info(out_bs, &bdi);
1388
        if (ret < 0) {
1389
            error_report("could not get block driver info");
1390
            goto out;
1391
        }
1392
        cluster_size = bdi.cluster_size;
1393
        if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1394
            error_report("invalid cluster size");
1395
            ret = -1;
1396
            goto out;
1397
        }
1398
        cluster_sectors = cluster_size >> 9;
1399
        sector_num = 0;
1400

    
1401
        nb_sectors = total_sectors;
1402
        if (nb_sectors != 0) {
1403
            local_progress = (float)100 /
1404
                (nb_sectors / MIN(nb_sectors, cluster_sectors));
1405
        }
1406

    
1407
        for(;;) {
1408
            int64_t bs_num;
1409
            int remainder;
1410
            uint8_t *buf2;
1411

    
1412
            nb_sectors = total_sectors - sector_num;
1413
            if (nb_sectors <= 0)
1414
                break;
1415
            if (nb_sectors >= cluster_sectors)
1416
                n = cluster_sectors;
1417
            else
1418
                n = nb_sectors;
1419

    
1420
            bs_num = sector_num - bs_offset;
1421
            assert (bs_num >= 0);
1422
            remainder = n;
1423
            buf2 = buf;
1424
            while (remainder > 0) {
1425
                int nlow;
1426
                while (bs_num == bs_sectors) {
1427
                    bs_i++;
1428
                    assert (bs_i < bs_n);
1429
                    bs_offset += bs_sectors;
1430
                    bdrv_get_geometry(bs[bs_i], &bs_sectors);
1431
                    bs_num = 0;
1432
                    /* printf("changing part: sector_num=%" PRId64 ", "
1433
                       "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1434
                       "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1435
                }
1436
                assert (bs_num < bs_sectors);
1437

    
1438
                nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1439

    
1440
                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1441
                if (ret < 0) {
1442
                    error_report("error while reading sector %" PRId64 ": %s",
1443
                                 bs_num, strerror(-ret));
1444
                    goto out;
1445
                }
1446

    
1447
                buf2 += nlow * 512;
1448
                bs_num += nlow;
1449

    
1450
                remainder -= nlow;
1451
            }
1452
            assert (remainder == 0);
1453

    
1454
            if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1455
                ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1456
                if (ret != 0) {
1457
                    error_report("error while compressing sector %" PRId64
1458
                                 ": %s", sector_num, strerror(-ret));
1459
                    goto out;
1460
                }
1461
            }
1462
            sector_num += n;
1463
            qemu_progress_print(local_progress, 100);
1464
        }
1465
        /* signal EOF to align */
1466
        bdrv_write_compressed(out_bs, 0, NULL, 0);
1467
    } else {
1468
        int has_zero_init = bdrv_has_zero_init(out_bs);
1469

    
1470
        sector_num = 0; // total number of sectors converted so far
1471
        nb_sectors = total_sectors - sector_num;
1472
        if (nb_sectors != 0) {
1473
            local_progress = (float)100 /
1474
                (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1475
        }
1476

    
1477
        for(;;) {
1478
            nb_sectors = total_sectors - sector_num;
1479
            if (nb_sectors <= 0) {
1480
                break;
1481
            }
1482
            if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1483
                n = (IO_BUF_SIZE / 512);
1484
            } else {
1485
                n = nb_sectors;
1486
            }
1487

    
1488
            while (sector_num - bs_offset >= bs_sectors) {
1489
                bs_i ++;
1490
                assert (bs_i < bs_n);
1491
                bs_offset += bs_sectors;
1492
                bdrv_get_geometry(bs[bs_i], &bs_sectors);
1493
                /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1494
                  "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1495
                   sector_num, bs_i, bs_offset, bs_sectors); */
1496
            }
1497

    
1498
            if (n > bs_offset + bs_sectors - sector_num) {
1499
                n = bs_offset + bs_sectors - sector_num;
1500
            }
1501

    
1502
            /* If the output image is being created as a copy on write image,
1503
               assume that sectors which are unallocated in the input image
1504
               are present in both the output's and input's base images (no
1505
               need to copy them). */
1506
            if (out_baseimg) {
1507
                ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1508
                                        n, &n1);
1509
                if (ret < 0) {
1510
                    error_report("error while reading metadata for sector "
1511
                                 "%" PRId64 ": %s",
1512
                                 sector_num - bs_offset, strerror(-ret));
1513
                    goto out;
1514
                }
1515
                if (!ret) {
1516
                    sector_num += n1;
1517
                    continue;
1518
                }
1519
                /* The next 'n1' sectors are allocated in the input image. Copy
1520
                   only those as they may be followed by unallocated sectors. */
1521
                n = n1;
1522
            } else {
1523
                n1 = n;
1524
            }
1525

    
1526
            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1527
            if (ret < 0) {
1528
                error_report("error while reading sector %" PRId64 ": %s",
1529
                             sector_num - bs_offset, strerror(-ret));
1530
                goto out;
1531
            }
1532
            /* NOTE: at the same time we convert, we do not write zero
1533
               sectors to have a chance to compress the image. Ideally, we
1534
               should add a specific call to have the info to go faster */
1535
            buf1 = buf;
1536
            while (n > 0) {
1537
                if (!has_zero_init ||
1538
                    is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1539
                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
1540
                    if (ret < 0) {
1541
                        error_report("error while writing sector %" PRId64
1542
                                     ": %s", sector_num, strerror(-ret));
1543
                        goto out;
1544
                    }
1545
                }
1546
                sector_num += n1;
1547
                n -= n1;
1548
                buf1 += n1 * 512;
1549
            }
1550
            qemu_progress_print(local_progress, 100);
1551
        }
1552
    }
1553
out:
1554
    qemu_progress_end();
1555
    free_option_parameters(create_options);
1556
    free_option_parameters(param);
1557
    qemu_vfree(buf);
1558
    if (out_bs) {
1559
        bdrv_unref(out_bs);
1560
    }
1561
    if (bs) {
1562
        for (bs_i = 0; bs_i < bs_n; bs_i++) {
1563
            if (bs[bs_i]) {
1564
                bdrv_unref(bs[bs_i]);
1565
            }
1566
        }
1567
        g_free(bs);
1568
    }
1569
    if (ret) {
1570
        return 1;
1571
    }
1572
    return 0;
1573
}
1574

    
1575

    
1576
static void dump_snapshots(BlockDriverState *bs)
1577
{
1578
    QEMUSnapshotInfo *sn_tab, *sn;
1579
    int nb_sns, i;
1580

    
1581
    nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1582
    if (nb_sns <= 0)
1583
        return;
1584
    printf("Snapshot list:\n");
1585
    bdrv_snapshot_dump(fprintf, stdout, NULL);
1586
    printf("\n");
1587
    for(i = 0; i < nb_sns; i++) {
1588
        sn = &sn_tab[i];
1589
        bdrv_snapshot_dump(fprintf, stdout, sn);
1590
        printf("\n");
1591
    }
1592
    g_free(sn_tab);
1593
}
1594

    
1595
static void dump_json_image_info_list(ImageInfoList *list)
1596
{
1597
    Error *errp = NULL;
1598
    QString *str;
1599
    QmpOutputVisitor *ov = qmp_output_visitor_new();
1600
    QObject *obj;
1601
    visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1602
                             &list, NULL, &errp);
1603
    obj = qmp_output_get_qobject(ov);
1604
    str = qobject_to_json_pretty(obj);
1605
    assert(str != NULL);
1606
    printf("%s\n", qstring_get_str(str));
1607
    qobject_decref(obj);
1608
    qmp_output_visitor_cleanup(ov);
1609
    QDECREF(str);
1610
}
1611

    
1612
static void dump_json_image_info(ImageInfo *info)
1613
{
1614
    Error *errp = NULL;
1615
    QString *str;
1616
    QmpOutputVisitor *ov = qmp_output_visitor_new();
1617
    QObject *obj;
1618
    visit_type_ImageInfo(qmp_output_get_visitor(ov),
1619
                         &info, NULL, &errp);
1620
    obj = qmp_output_get_qobject(ov);
1621
    str = qobject_to_json_pretty(obj);
1622
    assert(str != NULL);
1623
    printf("%s\n", qstring_get_str(str));
1624
    qobject_decref(obj);
1625
    qmp_output_visitor_cleanup(ov);
1626
    QDECREF(str);
1627
}
1628

    
1629
static void dump_human_image_info_list(ImageInfoList *list)
1630
{
1631
    ImageInfoList *elem;
1632
    bool delim = false;
1633

    
1634
    for (elem = list; elem; elem = elem->next) {
1635
        if (delim) {
1636
            printf("\n");
1637
        }
1638
        delim = true;
1639

    
1640
        bdrv_image_info_dump(fprintf, stdout, elem->value);
1641
    }
1642
}
1643

    
1644
static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1645
{
1646
    return strcmp(a, b) == 0;
1647
}
1648

    
1649
/**
1650
 * Open an image file chain and return an ImageInfoList
1651
 *
1652
 * @filename: topmost image filename
1653
 * @fmt: topmost image format (may be NULL to autodetect)
1654
 * @chain: true  - enumerate entire backing file chain
1655
 *         false - only topmost image file
1656
 *
1657
 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1658
 * image file.  If there was an error a message will have been printed to
1659
 * stderr.
1660
 */
1661
static ImageInfoList *collect_image_info_list(const char *filename,
1662
                                              const char *fmt,
1663
                                              bool chain)
1664
{
1665
    ImageInfoList *head = NULL;
1666
    ImageInfoList **last = &head;
1667
    GHashTable *filenames;
1668
    Error *err = NULL;
1669

    
1670
    filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1671

    
1672
    while (filename) {
1673
        BlockDriverState *bs;
1674
        ImageInfo *info;
1675
        ImageInfoList *elem;
1676

    
1677
        if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1678
            error_report("Backing file '%s' creates an infinite loop.",
1679
                         filename);
1680
            goto err;
1681
        }
1682
        g_hash_table_insert(filenames, (gpointer)filename, NULL);
1683

    
1684
        bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1685
                           false, false);
1686
        if (!bs) {
1687
            goto err;
1688
        }
1689

    
1690
        bdrv_query_image_info(bs, &info, &err);
1691
        if (error_is_set(&err)) {
1692
            error_report("%s", error_get_pretty(err));
1693
            error_free(err);
1694
            goto err;
1695
        }
1696

    
1697
        elem = g_new0(ImageInfoList, 1);
1698
        elem->value = info;
1699
        *last = elem;
1700
        last = &elem->next;
1701

    
1702
        bdrv_unref(bs);
1703

    
1704
        filename = fmt = NULL;
1705
        if (chain) {
1706
            if (info->has_full_backing_filename) {
1707
                filename = info->full_backing_filename;
1708
            } else if (info->has_backing_filename) {
1709
                filename = info->backing_filename;
1710
            }
1711
            if (info->has_backing_filename_format) {
1712
                fmt = info->backing_filename_format;
1713
            }
1714
        }
1715
    }
1716
    g_hash_table_destroy(filenames);
1717
    return head;
1718

    
1719
err:
1720
    qapi_free_ImageInfoList(head);
1721
    g_hash_table_destroy(filenames);
1722
    return NULL;
1723
}
1724

    
1725
static int img_info(int argc, char **argv)
1726
{
1727
    int c;
1728
    OutputFormat output_format = OFORMAT_HUMAN;
1729
    bool chain = false;
1730
    const char *filename, *fmt, *output;
1731
    ImageInfoList *list;
1732

    
1733
    fmt = NULL;
1734
    output = NULL;
1735
    for(;;) {
1736
        int option_index = 0;
1737
        static const struct option long_options[] = {
1738
            {"help", no_argument, 0, 'h'},
1739
            {"format", required_argument, 0, 'f'},
1740
            {"output", required_argument, 0, OPTION_OUTPUT},
1741
            {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1742
            {0, 0, 0, 0}
1743
        };
1744
        c = getopt_long(argc, argv, "f:h",
1745
                        long_options, &option_index);
1746
        if (c == -1) {
1747
            break;
1748
        }
1749
        switch(c) {
1750
        case '?':
1751
        case 'h':
1752
            help();
1753
            break;
1754
        case 'f':
1755
            fmt = optarg;
1756
            break;
1757
        case OPTION_OUTPUT:
1758
            output = optarg;
1759
            break;
1760
        case OPTION_BACKING_CHAIN:
1761
            chain = true;
1762
            break;
1763
        }
1764
    }
1765
    if (optind != argc - 1) {
1766
        help();
1767
    }
1768
    filename = argv[optind++];
1769

    
1770
    if (output && !strcmp(output, "json")) {
1771
        output_format = OFORMAT_JSON;
1772
    } else if (output && !strcmp(output, "human")) {
1773
        output_format = OFORMAT_HUMAN;
1774
    } else if (output) {
1775
        error_report("--output must be used with human or json as argument.");
1776
        return 1;
1777
    }
1778

    
1779
    list = collect_image_info_list(filename, fmt, chain);
1780
    if (!list) {
1781
        return 1;
1782
    }
1783

    
1784
    switch (output_format) {
1785
    case OFORMAT_HUMAN:
1786
        dump_human_image_info_list(list);
1787
        break;
1788
    case OFORMAT_JSON:
1789
        if (chain) {
1790
            dump_json_image_info_list(list);
1791
        } else {
1792
            dump_json_image_info(list->value);
1793
        }
1794
        break;
1795
    }
1796

    
1797
    qapi_free_ImageInfoList(list);
1798
    return 0;
1799
}
1800

    
1801

    
1802
typedef struct MapEntry {
1803
    int flags;
1804
    int depth;
1805
    int64_t start;
1806
    int64_t length;
1807
    int64_t offset;
1808
    BlockDriverState *bs;
1809
} MapEntry;
1810

    
1811
static void dump_map_entry(OutputFormat output_format, MapEntry *e,
1812
                           MapEntry *next)
1813
{
1814
    switch (output_format) {
1815
    case OFORMAT_HUMAN:
1816
        if ((e->flags & BDRV_BLOCK_DATA) &&
1817
            !(e->flags & BDRV_BLOCK_OFFSET_VALID)) {
1818
            error_report("File contains external, encrypted or compressed clusters.");
1819
            exit(1);
1820
        }
1821
        if ((e->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) == BDRV_BLOCK_DATA) {
1822
            printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
1823
                   e->start, e->length, e->offset, e->bs->filename);
1824
        }
1825
        /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
1826
         * Modify the flags here to allow more coalescing.
1827
         */
1828
        if (next &&
1829
            (next->flags & (BDRV_BLOCK_DATA|BDRV_BLOCK_ZERO)) != BDRV_BLOCK_DATA) {
1830
            next->flags &= ~BDRV_BLOCK_DATA;
1831
            next->flags |= BDRV_BLOCK_ZERO;
1832
        }
1833
        break;
1834
    case OFORMAT_JSON:
1835
        printf("%s{ \"start\": %"PRId64", \"length\": %"PRId64", \"depth\": %d,"
1836
               " \"zero\": %s, \"data\": %s",
1837
               (e->start == 0 ? "[" : ",\n"),
1838
               e->start, e->length, e->depth,
1839
               (e->flags & BDRV_BLOCK_ZERO) ? "true" : "false",
1840
               (e->flags & BDRV_BLOCK_DATA) ? "true" : "false");
1841
        if (e->flags & BDRV_BLOCK_OFFSET_VALID) {
1842
            printf(", 'offset': %"PRId64"", e->offset);
1843
        }
1844
        putchar('}');
1845

    
1846
        if (!next) {
1847
            printf("]\n");
1848
        }
1849
        break;
1850
    }
1851
}
1852

    
1853
static int get_block_status(BlockDriverState *bs, int64_t sector_num,
1854
                            int nb_sectors, MapEntry *e)
1855
{
1856
    int64_t ret;
1857
    int depth;
1858

    
1859
    /* As an optimization, we could cache the current range of unallocated
1860
     * clusters in each file of the chain, and avoid querying the same
1861
     * range repeatedly.
1862
     */
1863

    
1864
    depth = 0;
1865
    for (;;) {
1866
        ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &nb_sectors);
1867
        if (ret < 0) {
1868
            return ret;
1869
        }
1870
        assert(nb_sectors);
1871
        if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
1872
            break;
1873
        }
1874
        bs = bs->backing_hd;
1875
        if (bs == NULL) {
1876
            ret = 0;
1877
            break;
1878
        }
1879

    
1880
        depth++;
1881
    }
1882

    
1883
    e->start = sector_num * BDRV_SECTOR_SIZE;
1884
    e->length = nb_sectors * BDRV_SECTOR_SIZE;
1885
    e->flags = ret & ~BDRV_BLOCK_OFFSET_MASK;
1886
    e->offset = ret & BDRV_BLOCK_OFFSET_MASK;
1887
    e->depth = depth;
1888
    e->bs = bs;
1889
    return 0;
1890
}
1891

    
1892
static int img_map(int argc, char **argv)
1893
{
1894
    int c;
1895
    OutputFormat output_format = OFORMAT_HUMAN;
1896
    BlockDriverState *bs;
1897
    const char *filename, *fmt, *output;
1898
    int64_t length;
1899
    MapEntry curr = { .length = 0 }, next;
1900
    int ret = 0;
1901

    
1902
    fmt = NULL;
1903
    output = NULL;
1904
    for (;;) {
1905
        int option_index = 0;
1906
        static const struct option long_options[] = {
1907
            {"help", no_argument, 0, 'h'},
1908
            {"format", required_argument, 0, 'f'},
1909
            {"output", required_argument, 0, OPTION_OUTPUT},
1910
            {0, 0, 0, 0}
1911
        };
1912
        c = getopt_long(argc, argv, "f:h",
1913
                        long_options, &option_index);
1914
        if (c == -1) {
1915
            break;
1916
        }
1917
        switch (c) {
1918
        case '?':
1919
        case 'h':
1920
            help();
1921
            break;
1922
        case 'f':
1923
            fmt = optarg;
1924
            break;
1925
        case OPTION_OUTPUT:
1926
            output = optarg;
1927
            break;
1928
        }
1929
    }
1930
    if (optind >= argc) {
1931
        help();
1932
    }
1933
    filename = argv[optind++];
1934

    
1935
    if (output && !strcmp(output, "json")) {
1936
        output_format = OFORMAT_JSON;
1937
    } else if (output && !strcmp(output, "human")) {
1938
        output_format = OFORMAT_HUMAN;
1939
    } else if (output) {
1940
        error_report("--output must be used with human or json as argument.");
1941
        return 1;
1942
    }
1943

    
1944
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS, true, false);
1945
    if (!bs) {
1946
        return 1;
1947
    }
1948

    
1949
    if (output_format == OFORMAT_HUMAN) {
1950
        printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
1951
    }
1952

    
1953
    length = bdrv_getlength(bs);
1954
    while (curr.start + curr.length < length) {
1955
        int64_t nsectors_left;
1956
        int64_t sector_num;
1957
        int n;
1958

    
1959
        sector_num = (curr.start + curr.length) >> BDRV_SECTOR_BITS;
1960

    
1961
        /* Probe up to 1 GiB at a time.  */
1962
        nsectors_left = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE) - sector_num;
1963
        n = MIN(1 << (30 - BDRV_SECTOR_BITS), nsectors_left);
1964
        ret = get_block_status(bs, sector_num, n, &next);
1965

    
1966
        if (ret < 0) {
1967
            error_report("Could not read file metadata: %s", strerror(-ret));
1968
            goto out;
1969
        }
1970

    
1971
        if (curr.length != 0 && curr.flags == next.flags &&
1972
            curr.depth == next.depth &&
1973
            ((curr.flags & BDRV_BLOCK_OFFSET_VALID) == 0 ||
1974
             curr.offset + curr.length == next.offset)) {
1975
            curr.length += next.length;
1976
            continue;
1977
        }
1978

    
1979
        if (curr.length > 0) {
1980
            dump_map_entry(output_format, &curr, &next);
1981
        }
1982
        curr = next;
1983
    }
1984

    
1985
    dump_map_entry(output_format, &curr, NULL);
1986

    
1987
out:
1988
    bdrv_unref(bs);
1989
    return ret < 0;
1990
}
1991

    
1992
#define SNAPSHOT_LIST   1
1993
#define SNAPSHOT_CREATE 2
1994
#define SNAPSHOT_APPLY  3
1995
#define SNAPSHOT_DELETE 4
1996

    
1997
static int img_snapshot(int argc, char **argv)
1998
{
1999
    BlockDriverState *bs;
2000
    QEMUSnapshotInfo sn;
2001
    char *filename, *snapshot_name = NULL;
2002
    int c, ret = 0, bdrv_oflags;
2003
    int action = 0;
2004
    qemu_timeval tv;
2005
    bool quiet = false;
2006
    Error *err = NULL;
2007

    
2008
    bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
2009
    /* Parse commandline parameters */
2010
    for(;;) {
2011
        c = getopt(argc, argv, "la:c:d:hq");
2012
        if (c == -1) {
2013
            break;
2014
        }
2015
        switch(c) {
2016
        case '?':
2017
        case 'h':
2018
            help();
2019
            return 0;
2020
        case 'l':
2021
            if (action) {
2022
                help();
2023
                return 0;
2024
            }
2025
            action = SNAPSHOT_LIST;
2026
            bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
2027
            break;
2028
        case 'a':
2029
            if (action) {
2030
                help();
2031
                return 0;
2032
            }
2033
            action = SNAPSHOT_APPLY;
2034
            snapshot_name = optarg;
2035
            break;
2036
        case 'c':
2037
            if (action) {
2038
                help();
2039
                return 0;
2040
            }
2041
            action = SNAPSHOT_CREATE;
2042
            snapshot_name = optarg;
2043
            break;
2044
        case 'd':
2045
            if (action) {
2046
                help();
2047
                return 0;
2048
            }
2049
            action = SNAPSHOT_DELETE;
2050
            snapshot_name = optarg;
2051
            break;
2052
        case 'q':
2053
            quiet = true;
2054
            break;
2055
        }
2056
    }
2057

    
2058
    if (optind != argc - 1) {
2059
        help();
2060
    }
2061
    filename = argv[optind++];
2062

    
2063
    /* Open the image */
2064
    bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
2065
    if (!bs) {
2066
        return 1;
2067
    }
2068

    
2069
    /* Perform the requested action */
2070
    switch(action) {
2071
    case SNAPSHOT_LIST:
2072
        dump_snapshots(bs);
2073
        break;
2074

    
2075
    case SNAPSHOT_CREATE:
2076
        memset(&sn, 0, sizeof(sn));
2077
        pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
2078

    
2079
        qemu_gettimeofday(&tv);
2080
        sn.date_sec = tv.tv_sec;
2081
        sn.date_nsec = tv.tv_usec * 1000;
2082

    
2083
        ret = bdrv_snapshot_create(bs, &sn);
2084
        if (ret) {
2085
            error_report("Could not create snapshot '%s': %d (%s)",
2086
                snapshot_name, ret, strerror(-ret));
2087
        }
2088
        break;
2089

    
2090
    case SNAPSHOT_APPLY:
2091
        ret = bdrv_snapshot_goto(bs, snapshot_name);
2092
        if (ret) {
2093
            error_report("Could not apply snapshot '%s': %d (%s)",
2094
                snapshot_name, ret, strerror(-ret));
2095
        }
2096
        break;
2097

    
2098
    case SNAPSHOT_DELETE:
2099
        bdrv_snapshot_delete_by_id_or_name(bs, snapshot_name, &err);
2100
        if (error_is_set(&err)) {
2101
            error_report("Could not delete snapshot '%s': (%s)",
2102
                         snapshot_name, error_get_pretty(err));
2103
            error_free(err);
2104
            ret = 1;
2105
        }
2106
        break;
2107
    }
2108

    
2109
    /* Cleanup */
2110
    bdrv_unref(bs);
2111
    if (ret) {
2112
        return 1;
2113
    }
2114
    return 0;
2115
}
2116

    
2117
static int img_rebase(int argc, char **argv)
2118
{
2119
    BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
2120
    BlockDriver *old_backing_drv, *new_backing_drv;
2121
    char *filename;
2122
    const char *fmt, *cache, *out_basefmt, *out_baseimg;
2123
    int c, flags, ret;
2124
    int unsafe = 0;
2125
    int progress = 0;
2126
    bool quiet = false;
2127
    Error *local_err = NULL;
2128

    
2129
    /* Parse commandline parameters */
2130
    fmt = NULL;
2131
    cache = BDRV_DEFAULT_CACHE;
2132
    out_baseimg = NULL;
2133
    out_basefmt = NULL;
2134
    for(;;) {
2135
        c = getopt(argc, argv, "uhf:F:b:pt:q");
2136
        if (c == -1) {
2137
            break;
2138
        }
2139
        switch(c) {
2140
        case '?':
2141
        case 'h':
2142
            help();
2143
            return 0;
2144
        case 'f':
2145
            fmt = optarg;
2146
            break;
2147
        case 'F':
2148
            out_basefmt = optarg;
2149
            break;
2150
        case 'b':
2151
            out_baseimg = optarg;
2152
            break;
2153
        case 'u':
2154
            unsafe = 1;
2155
            break;
2156
        case 'p':
2157
            progress = 1;
2158
            break;
2159
        case 't':
2160
            cache = optarg;
2161
            break;
2162
        case 'q':
2163
            quiet = true;
2164
            break;
2165
        }
2166
    }
2167

    
2168
    if (quiet) {
2169
        progress = 0;
2170
    }
2171

    
2172
    if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
2173
        help();
2174
    }
2175
    filename = argv[optind++];
2176

    
2177
    qemu_progress_init(progress, 2.0);
2178
    qemu_progress_print(0, 100);
2179

    
2180
    flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
2181
    ret = bdrv_parse_cache_flags(cache, &flags);
2182
    if (ret < 0) {
2183
        error_report("Invalid cache option: %s", cache);
2184
        return -1;
2185
    }
2186

    
2187
    /*
2188
     * Open the images.
2189
     *
2190
     * Ignore the old backing file for unsafe rebase in case we want to correct
2191
     * the reference to a renamed or moved backing file.
2192
     */
2193
    bs = bdrv_new_open(filename, fmt, flags, true, quiet);
2194
    if (!bs) {
2195
        return 1;
2196
    }
2197

    
2198
    /* Find the right drivers for the backing files */
2199
    old_backing_drv = NULL;
2200
    new_backing_drv = NULL;
2201

    
2202
    if (!unsafe && bs->backing_format[0] != '\0') {
2203
        old_backing_drv = bdrv_find_format(bs->backing_format);
2204
        if (old_backing_drv == NULL) {
2205
            error_report("Invalid format name: '%s'", bs->backing_format);
2206
            ret = -1;
2207
            goto out;
2208
        }
2209
    }
2210

    
2211
    if (out_basefmt != NULL) {
2212
        new_backing_drv = bdrv_find_format(out_basefmt);
2213
        if (new_backing_drv == NULL) {
2214
            error_report("Invalid format name: '%s'", out_basefmt);
2215
            ret = -1;
2216
            goto out;
2217
        }
2218
    }
2219

    
2220
    /* For safe rebasing we need to compare old and new backing file */
2221
    if (unsafe) {
2222
        /* Make the compiler happy */
2223
        bs_old_backing = NULL;
2224
        bs_new_backing = NULL;
2225
    } else {
2226
        char backing_name[1024];
2227

    
2228
        bs_old_backing = bdrv_new("old_backing");
2229
        bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2230
        ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2231
                        old_backing_drv, &local_err);
2232
        if (ret) {
2233
            error_report("Could not open old backing file '%s': %s",
2234
                         backing_name, error_get_pretty(local_err));
2235
            error_free(local_err);
2236
            goto out;
2237
        }
2238
        if (out_baseimg[0]) {
2239
            bs_new_backing = bdrv_new("new_backing");
2240
            ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2241
                        new_backing_drv, &local_err);
2242
            if (ret) {
2243
                error_report("Could not open new backing file '%s': %s",
2244
                             out_baseimg, error_get_pretty(local_err));
2245
                error_free(local_err);
2246
                goto out;
2247
            }
2248
        }
2249
    }
2250

    
2251
    /*
2252
     * Check each unallocated cluster in the COW file. If it is unallocated,
2253
     * accesses go to the backing file. We must therefore compare this cluster
2254
     * in the old and new backing file, and if they differ we need to copy it
2255
     * from the old backing file into the COW file.
2256
     *
2257
     * If qemu-img crashes during this step, no harm is done. The content of
2258
     * the image is the same as the original one at any time.
2259
     */
2260
    if (!unsafe) {
2261
        uint64_t num_sectors;
2262
        uint64_t old_backing_num_sectors;
2263
        uint64_t new_backing_num_sectors = 0;
2264
        uint64_t sector;
2265
        int n;
2266
        uint8_t * buf_old;
2267
        uint8_t * buf_new;
2268
        float local_progress = 0;
2269

    
2270
        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2271
        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2272

    
2273
        bdrv_get_geometry(bs, &num_sectors);
2274
        bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2275
        if (bs_new_backing) {
2276
            bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2277
        }
2278

    
2279
        if (num_sectors != 0) {
2280
            local_progress = (float)100 /
2281
                (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2282
        }
2283

    
2284
        for (sector = 0; sector < num_sectors; sector += n) {
2285

    
2286
            /* How many sectors can we handle with the next read? */
2287
            if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2288
                n = (IO_BUF_SIZE / 512);
2289
            } else {
2290
                n = num_sectors - sector;
2291
            }
2292

    
2293
            /* If the cluster is allocated, we don't need to take action */
2294
            ret = bdrv_is_allocated(bs, sector, n, &n);
2295
            if (ret < 0) {
2296
                error_report("error while reading image metadata: %s",
2297
                             strerror(-ret));
2298
                goto out;
2299
            }
2300
            if (ret) {
2301
                continue;
2302
            }
2303

    
2304
            /*
2305
             * Read old and new backing file and take into consideration that
2306
             * backing files may be smaller than the COW image.
2307
             */
2308
            if (sector >= old_backing_num_sectors) {
2309
                memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2310
            } else {
2311
                if (sector + n > old_backing_num_sectors) {
2312
                    n = old_backing_num_sectors - sector;
2313
                }
2314

    
2315
                ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2316
                if (ret < 0) {
2317
                    error_report("error while reading from old backing file");
2318
                    goto out;
2319
                }
2320
            }
2321

    
2322
            if (sector >= new_backing_num_sectors || !bs_new_backing) {
2323
                memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2324
            } else {
2325
                if (sector + n > new_backing_num_sectors) {
2326
                    n = new_backing_num_sectors - sector;
2327
                }
2328

    
2329
                ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2330
                if (ret < 0) {
2331
                    error_report("error while reading from new backing file");
2332
                    goto out;
2333
                }
2334
            }
2335

    
2336
            /* If they differ, we need to write to the COW file */
2337
            uint64_t written = 0;
2338

    
2339
            while (written < n) {
2340
                int pnum;
2341

    
2342
                if (compare_sectors(buf_old + written * 512,
2343
                    buf_new + written * 512, n - written, &pnum))
2344
                {
2345
                    ret = bdrv_write(bs, sector + written,
2346
                        buf_old + written * 512, pnum);
2347
                    if (ret < 0) {
2348
                        error_report("Error while writing to COW image: %s",
2349
                            strerror(-ret));
2350
                        goto out;
2351
                    }
2352
                }
2353

    
2354
                written += pnum;
2355
            }
2356
            qemu_progress_print(local_progress, 100);
2357
        }
2358

    
2359
        qemu_vfree(buf_old);
2360
        qemu_vfree(buf_new);
2361
    }
2362

    
2363
    /*
2364
     * Change the backing file. All clusters that are different from the old
2365
     * backing file are overwritten in the COW file now, so the visible content
2366
     * doesn't change when we switch the backing file.
2367
     */
2368
    if (out_baseimg && *out_baseimg) {
2369
        ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2370
    } else {
2371
        ret = bdrv_change_backing_file(bs, NULL, NULL);
2372
    }
2373

    
2374
    if (ret == -ENOSPC) {
2375
        error_report("Could not change the backing file to '%s': No "
2376
                     "space left in the file header", out_baseimg);
2377
    } else if (ret < 0) {
2378
        error_report("Could not change the backing file to '%s': %s",
2379
            out_baseimg, strerror(-ret));
2380
    }
2381

    
2382
    qemu_progress_print(100, 0);
2383
    /*
2384
     * TODO At this point it is possible to check if any clusters that are
2385
     * allocated in the COW file are the same in the backing file. If so, they
2386
     * could be dropped from the COW file. Don't do this before switching the
2387
     * backing file, in case of a crash this would lead to corruption.
2388
     */
2389
out:
2390
    qemu_progress_end();
2391
    /* Cleanup */
2392
    if (!unsafe) {
2393
        if (bs_old_backing != NULL) {
2394
            bdrv_unref(bs_old_backing);
2395
        }
2396
        if (bs_new_backing != NULL) {
2397
            bdrv_unref(bs_new_backing);
2398
        }
2399
    }
2400

    
2401
    bdrv_unref(bs);
2402
    if (ret) {
2403
        return 1;
2404
    }
2405
    return 0;
2406
}
2407

    
2408
static int img_resize(int argc, char **argv)
2409
{
2410
    int c, ret, relative;
2411
    const char *filename, *fmt, *size;
2412
    int64_t n, total_size;
2413
    bool quiet = false;
2414
    BlockDriverState *bs = NULL;
2415
    QemuOpts *param;
2416
    static QemuOptsList resize_options = {
2417
        .name = "resize_options",
2418
        .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2419
        .desc = {
2420
            {
2421
                .name = BLOCK_OPT_SIZE,
2422
                .type = QEMU_OPT_SIZE,
2423
                .help = "Virtual disk size"
2424
            }, {
2425
                /* end of list */
2426
            }
2427
        },
2428
    };
2429

    
2430
    /* Remove size from argv manually so that negative numbers are not treated
2431
     * as options by getopt. */
2432
    if (argc < 3) {
2433
        help();
2434
        return 1;
2435
    }
2436

    
2437
    size = argv[--argc];
2438

    
2439
    /* Parse getopt arguments */
2440
    fmt = NULL;
2441
    for(;;) {
2442
        c = getopt(argc, argv, "f:hq");
2443
        if (c == -1) {
2444
            break;
2445
        }
2446
        switch(c) {
2447
        case '?':
2448
        case 'h':
2449
            help();
2450
            break;
2451
        case 'f':
2452
            fmt = optarg;
2453
            break;
2454
        case 'q':
2455
            quiet = true;
2456
            break;
2457
        }
2458
    }
2459
    if (optind != argc - 1) {
2460
        help();
2461
    }
2462
    filename = argv[optind++];
2463

    
2464
    /* Choose grow, shrink, or absolute resize mode */
2465
    switch (size[0]) {
2466
    case '+':
2467
        relative = 1;
2468
        size++;
2469
        break;
2470
    case '-':
2471
        relative = -1;
2472
        size++;
2473
        break;
2474
    default:
2475
        relative = 0;
2476
        break;
2477
    }
2478

    
2479
    /* Parse size */
2480
    param = qemu_opts_create_nofail(&resize_options);
2481
    if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2482
        /* Error message already printed when size parsing fails */
2483
        ret = -1;
2484
        qemu_opts_del(param);
2485
        goto out;
2486
    }
2487
    n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2488
    qemu_opts_del(param);
2489

    
2490
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2491
    if (!bs) {
2492
        ret = -1;
2493
        goto out;
2494
    }
2495

    
2496
    if (relative) {
2497
        total_size = bdrv_getlength(bs) + n * relative;
2498
    } else {
2499
        total_size = n;
2500
    }
2501
    if (total_size <= 0) {
2502
        error_report("New image size must be positive");
2503
        ret = -1;
2504
        goto out;
2505
    }
2506

    
2507
    ret = bdrv_truncate(bs, total_size);
2508
    switch (ret) {
2509
    case 0:
2510
        qprintf(quiet, "Image resized.\n");
2511
        break;
2512
    case -ENOTSUP:
2513
        error_report("This image does not support resize");
2514
        break;
2515
    case -EACCES:
2516
        error_report("Image is read-only");
2517
        break;
2518
    default:
2519
        error_report("Error resizing image (%d)", -ret);
2520
        break;
2521
    }
2522
out:
2523
    if (bs) {
2524
        bdrv_unref(bs);
2525
    }
2526
    if (ret) {
2527
        return 1;
2528
    }
2529
    return 0;
2530
}
2531

    
2532
static int img_amend(int argc, char **argv)
2533
{
2534
    int c, ret = 0;
2535
    char *options = NULL;
2536
    QEMUOptionParameter *create_options = NULL, *options_param = NULL;
2537
    const char *fmt = NULL, *filename;
2538
    bool quiet = false;
2539
    BlockDriverState *bs = NULL;
2540

    
2541
    for (;;) {
2542
        c = getopt(argc, argv, "hqf:o:");
2543
        if (c == -1) {
2544
            break;
2545
        }
2546

    
2547
        switch (c) {
2548
            case 'h':
2549
            case '?':
2550
                help();
2551
                break;
2552
            case 'o':
2553
                options = optarg;
2554
                break;
2555
            case 'f':
2556
                fmt = optarg;
2557
                break;
2558
            case 'q':
2559
                quiet = true;
2560
                break;
2561
        }
2562
    }
2563

    
2564
    if (optind != argc - 1) {
2565
        help();
2566
    }
2567

    
2568
    if (!options) {
2569
        help();
2570
    }
2571

    
2572
    filename = argv[argc - 1];
2573

    
2574
    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2575
    if (!bs) {
2576
        error_report("Could not open image '%s'", filename);
2577
        ret = -1;
2578
        goto out;
2579
    }
2580

    
2581
    fmt = bs->drv->format_name;
2582

    
2583
    if (is_help_option(options)) {
2584
        ret = print_block_option_help(filename, fmt);
2585
        goto out;
2586
    }
2587

    
2588
    create_options = append_option_parameters(create_options,
2589
            bs->drv->create_options);
2590
    options_param = parse_option_parameters(options, create_options,
2591
            options_param);
2592
    if (options_param == NULL) {
2593
        error_report("Invalid options for file format '%s'", fmt);
2594
        ret = -1;
2595
        goto out;
2596
    }
2597

    
2598
    ret = bdrv_amend_options(bs, options_param);
2599
    if (ret < 0) {
2600
        error_report("Error while amending options: %s", strerror(-ret));
2601
        goto out;
2602
    }
2603

    
2604
out:
2605
    if (bs) {
2606
        bdrv_unref(bs);
2607
    }
2608
    free_option_parameters(create_options);
2609
    free_option_parameters(options_param);
2610
    if (ret) {
2611
        return 1;
2612
    }
2613
    return 0;
2614
}
2615

    
2616
static const img_cmd_t img_cmds[] = {
2617
#define DEF(option, callback, arg_string)        \
2618
    { option, callback },
2619
#include "qemu-img-cmds.h"
2620
#undef DEF
2621
#undef GEN_DOCS
2622
    { NULL, NULL, },
2623
};
2624

    
2625
int main(int argc, char **argv)
2626
{
2627
    const img_cmd_t *cmd;
2628
    const char *cmdname;
2629

    
2630
#ifdef CONFIG_POSIX
2631
    signal(SIGPIPE, SIG_IGN);
2632
#endif
2633

    
2634
    error_set_progname(argv[0]);
2635

    
2636
    qemu_init_main_loop();
2637
    bdrv_init();
2638
    if (argc < 2)
2639
        help();
2640
    cmdname = argv[1];
2641
    argc--; argv++;
2642

    
2643
    /* find the command */
2644
    for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2645
        if (!strcmp(cmdname, cmd->name)) {
2646
            return cmd->handler(argc, argv);
2647
        }
2648
    }
2649

    
2650
    /* not found */
2651
    help();
2652
    return 0;
2653
}