]> git.proxmox.com Git - qemu.git/blob - qemu-img.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
w32: Fix access to host devices (regression)
[qemu.git] / qemu-img.c
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"
107 "Parameters to check subcommand:\n"
108 " '-r' tries to repair any inconsistencies that are found during the check.\n"
109 " '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
110 " kinds of errors, with a higher risk of choosing the wrong fix or\n"
111 " hiding corruption that has already occurred.\n"
112 "\n"
113 "Parameters to snapshot subcommand:\n"
114 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
115 " '-a' applies a snapshot (revert disk to saved state)\n"
116 " '-c' creates a snapshot\n"
117 " '-d' deletes a snapshot\n"
118 " '-l' lists all snapshots in the given image\n"
119 "\n"
120 "Parameters to compare subcommand:\n"
121 " '-f' first image format\n"
122 " '-F' second image format\n"
123 " '-s' run in Strict mode - fail on different image size or sector allocation\n";
124
125 printf("%s\nSupported formats:", help_msg);
126 bdrv_iterate_format(format_print, NULL);
127 printf("\n");
128 exit(1);
129 }
130
131 static int GCC_FMT_ATTR(2, 3) qprintf(bool quiet, const char *fmt, ...)
132 {
133 int ret = 0;
134 if (!quiet) {
135 va_list args;
136 va_start(args, fmt);
137 ret = vprintf(fmt, args);
138 va_end(args);
139 }
140 return ret;
141 }
142
143 #if defined(WIN32)
144 /* XXX: put correct support for win32 */
145 static int read_password(char *buf, int buf_size)
146 {
147 int c, i;
148 printf("Password: ");
149 fflush(stdout);
150 i = 0;
151 for(;;) {
152 c = getchar();
153 if (c == '\n')
154 break;
155 if (i < (buf_size - 1))
156 buf[i++] = c;
157 }
158 buf[i] = '\0';
159 return 0;
160 }
161
162 #else
163
164 #include <termios.h>
165
166 static struct termios oldtty;
167
168 static void term_exit(void)
169 {
170 tcsetattr (0, TCSANOW, &oldtty);
171 }
172
173 static void term_init(void)
174 {
175 struct termios tty;
176
177 tcgetattr (0, &tty);
178 oldtty = tty;
179
180 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
181 |INLCR|IGNCR|ICRNL|IXON);
182 tty.c_oflag |= OPOST;
183 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
184 tty.c_cflag &= ~(CSIZE|PARENB);
185 tty.c_cflag |= CS8;
186 tty.c_cc[VMIN] = 1;
187 tty.c_cc[VTIME] = 0;
188
189 tcsetattr (0, TCSANOW, &tty);
190
191 atexit(term_exit);
192 }
193
194 static int read_password(char *buf, int buf_size)
195 {
196 uint8_t ch;
197 int i, ret;
198
199 printf("password: ");
200 fflush(stdout);
201 term_init();
202 i = 0;
203 for(;;) {
204 ret = read(0, &ch, 1);
205 if (ret == -1) {
206 if (errno == EAGAIN || errno == EINTR) {
207 continue;
208 } else {
209 ret = -1;
210 break;
211 }
212 } else if (ret == 0) {
213 ret = -1;
214 break;
215 } else {
216 if (ch == '\r') {
217 ret = 0;
218 break;
219 }
220 if (i < (buf_size - 1))
221 buf[i++] = ch;
222 }
223 }
224 term_exit();
225 buf[i] = '\0';
226 printf("\n");
227 return ret;
228 }
229 #endif
230
231 static int print_block_option_help(const char *filename, const char *fmt)
232 {
233 BlockDriver *drv, *proto_drv;
234 QEMUOptionParameter *create_options = NULL;
235
236 /* Find driver and parse its options */
237 drv = bdrv_find_format(fmt);
238 if (!drv) {
239 error_report("Unknown file format '%s'", fmt);
240 return 1;
241 }
242
243 proto_drv = bdrv_find_protocol(filename, true);
244 if (!proto_drv) {
245 error_report("Unknown protocol '%s'", filename);
246 return 1;
247 }
248
249 create_options = append_option_parameters(create_options,
250 drv->create_options);
251 create_options = append_option_parameters(create_options,
252 proto_drv->create_options);
253 print_option_help(create_options);
254 free_option_parameters(create_options);
255 return 0;
256 }
257
258 static BlockDriverState *bdrv_new_open(const char *filename,
259 const char *fmt,
260 int flags,
261 bool require_io,
262 bool quiet)
263 {
264 BlockDriverState *bs;
265 BlockDriver *drv;
266 char password[256];
267 int ret;
268
269 bs = bdrv_new("image");
270
271 if (fmt) {
272 drv = bdrv_find_format(fmt);
273 if (!drv) {
274 error_report("Unknown file format '%s'", fmt);
275 goto fail;
276 }
277 } else {
278 drv = NULL;
279 }
280
281 ret = bdrv_open(bs, filename, NULL, flags, drv);
282 if (ret < 0) {
283 error_report("Could not open '%s': %s", filename, strerror(-ret));
284 goto fail;
285 }
286
287 if (bdrv_is_encrypted(bs) && require_io) {
288 qprintf(quiet, "Disk image '%s' is encrypted.\n", filename);
289 if (read_password(password, sizeof(password)) < 0) {
290 error_report("No password given");
291 goto fail;
292 }
293 if (bdrv_set_key(bs, password) < 0) {
294 error_report("invalid password");
295 goto fail;
296 }
297 }
298 return bs;
299 fail:
300 if (bs) {
301 bdrv_delete(bs);
302 }
303 return NULL;
304 }
305
306 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
307 const char *base_filename,
308 const char *base_fmt)
309 {
310 if (base_filename) {
311 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
312 error_report("Backing file not supported for file format '%s'",
313 fmt);
314 return -1;
315 }
316 }
317 if (base_fmt) {
318 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
319 error_report("Backing file format not supported for file "
320 "format '%s'", fmt);
321 return -1;
322 }
323 }
324 return 0;
325 }
326
327 static int img_create(int argc, char **argv)
328 {
329 int c;
330 uint64_t img_size = -1;
331 const char *fmt = "raw";
332 const char *base_fmt = NULL;
333 const char *filename;
334 const char *base_filename = NULL;
335 char *options = NULL;
336 Error *local_err = NULL;
337 bool quiet = false;
338
339 for(;;) {
340 c = getopt(argc, argv, "F:b:f:he6o:q");
341 if (c == -1) {
342 break;
343 }
344 switch(c) {
345 case '?':
346 case 'h':
347 help();
348 break;
349 case 'F':
350 base_fmt = optarg;
351 break;
352 case 'b':
353 base_filename = optarg;
354 break;
355 case 'f':
356 fmt = optarg;
357 break;
358 case 'e':
359 error_report("option -e is deprecated, please use \'-o "
360 "encryption\' instead!");
361 return 1;
362 case '6':
363 error_report("option -6 is deprecated, please use \'-o "
364 "compat6\' instead!");
365 return 1;
366 case 'o':
367 options = optarg;
368 break;
369 case 'q':
370 quiet = true;
371 break;
372 }
373 }
374
375 /* Get the filename */
376 if (optind >= argc) {
377 help();
378 }
379 filename = argv[optind++];
380
381 /* Get image size, if specified */
382 if (optind < argc) {
383 int64_t sval;
384 char *end;
385 sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
386 if (sval < 0 || *end) {
387 if (sval == -ERANGE) {
388 error_report("Image size must be less than 8 EiB!");
389 } else {
390 error_report("Invalid image size specified! You may use k, M, "
391 "G, T, P or E suffixes for ");
392 error_report("kilobytes, megabytes, gigabytes, terabytes, "
393 "petabytes and exabytes.");
394 }
395 return 1;
396 }
397 img_size = (uint64_t)sval;
398 }
399 if (optind != argc) {
400 help();
401 }
402
403 if (options && is_help_option(options)) {
404 return print_block_option_help(filename, fmt);
405 }
406
407 bdrv_img_create(filename, fmt, base_filename, base_fmt,
408 options, img_size, BDRV_O_FLAGS, &local_err, quiet);
409 if (error_is_set(&local_err)) {
410 error_report("%s", error_get_pretty(local_err));
411 error_free(local_err);
412 return 1;
413 }
414
415 return 0;
416 }
417
418 static void dump_json_image_check(ImageCheck *check, bool quiet)
419 {
420 Error *errp = NULL;
421 QString *str;
422 QmpOutputVisitor *ov = qmp_output_visitor_new();
423 QObject *obj;
424 visit_type_ImageCheck(qmp_output_get_visitor(ov),
425 &check, NULL, &errp);
426 obj = qmp_output_get_qobject(ov);
427 str = qobject_to_json_pretty(obj);
428 assert(str != NULL);
429 qprintf(quiet, "%s\n", qstring_get_str(str));
430 qobject_decref(obj);
431 qmp_output_visitor_cleanup(ov);
432 QDECREF(str);
433 }
434
435 static void dump_human_image_check(ImageCheck *check, bool quiet)
436 {
437 if (!(check->corruptions || check->leaks || check->check_errors)) {
438 qprintf(quiet, "No errors were found on the image.\n");
439 } else {
440 if (check->corruptions) {
441 qprintf(quiet, "\n%" PRId64 " errors were found on the image.\n"
442 "Data may be corrupted, or further writes to the image "
443 "may corrupt it.\n",
444 check->corruptions);
445 }
446
447 if (check->leaks) {
448 qprintf(quiet,
449 "\n%" PRId64 " leaked clusters were found on the image.\n"
450 "This means waste of disk space, but no harm to data.\n",
451 check->leaks);
452 }
453
454 if (check->check_errors) {
455 qprintf(quiet,
456 "\n%" PRId64
457 " internal errors have occurred during the check.\n",
458 check->check_errors);
459 }
460 }
461
462 if (check->total_clusters != 0 && check->allocated_clusters != 0) {
463 qprintf(quiet, "%" PRId64 "/%" PRId64 " = %0.2f%% allocated, "
464 "%0.2f%% fragmented, %0.2f%% compressed clusters\n",
465 check->allocated_clusters, check->total_clusters,
466 check->allocated_clusters * 100.0 / check->total_clusters,
467 check->fragmented_clusters * 100.0 / check->allocated_clusters,
468 check->compressed_clusters * 100.0 /
469 check->allocated_clusters);
470 }
471
472 if (check->image_end_offset) {
473 qprintf(quiet,
474 "Image end offset: %" PRId64 "\n", check->image_end_offset);
475 }
476 }
477
478 static int collect_image_check(BlockDriverState *bs,
479 ImageCheck *check,
480 const char *filename,
481 const char *fmt,
482 int fix)
483 {
484 int ret;
485 BdrvCheckResult result;
486
487 ret = bdrv_check(bs, &result, fix);
488 if (ret < 0) {
489 return ret;
490 }
491
492 check->filename = g_strdup(filename);
493 check->format = g_strdup(bdrv_get_format_name(bs));
494 check->check_errors = result.check_errors;
495 check->corruptions = result.corruptions;
496 check->has_corruptions = result.corruptions != 0;
497 check->leaks = result.leaks;
498 check->has_leaks = result.leaks != 0;
499 check->corruptions_fixed = result.corruptions_fixed;
500 check->has_corruptions_fixed = result.corruptions != 0;
501 check->leaks_fixed = result.leaks_fixed;
502 check->has_leaks_fixed = result.leaks != 0;
503 check->image_end_offset = result.image_end_offset;
504 check->has_image_end_offset = result.image_end_offset != 0;
505 check->total_clusters = result.bfi.total_clusters;
506 check->has_total_clusters = result.bfi.total_clusters != 0;
507 check->allocated_clusters = result.bfi.allocated_clusters;
508 check->has_allocated_clusters = result.bfi.allocated_clusters != 0;
509 check->fragmented_clusters = result.bfi.fragmented_clusters;
510 check->has_fragmented_clusters = result.bfi.fragmented_clusters != 0;
511 check->compressed_clusters = result.bfi.compressed_clusters;
512 check->has_compressed_clusters = result.bfi.compressed_clusters != 0;
513
514 return 0;
515 }
516
517 /*
518 * Checks an image for consistency. Exit codes:
519 *
520 * 0 - Check completed, image is good
521 * 1 - Check not completed because of internal errors
522 * 2 - Check completed, image is corrupted
523 * 3 - Check completed, image has leaked clusters, but is good otherwise
524 */
525 static int img_check(int argc, char **argv)
526 {
527 int c, ret;
528 OutputFormat output_format = OFORMAT_HUMAN;
529 const char *filename, *fmt, *output;
530 BlockDriverState *bs;
531 int fix = 0;
532 int flags = BDRV_O_FLAGS | BDRV_O_CHECK;
533 ImageCheck *check;
534 bool quiet = false;
535
536 fmt = NULL;
537 output = NULL;
538 for(;;) {
539 int option_index = 0;
540 static const struct option long_options[] = {
541 {"help", no_argument, 0, 'h'},
542 {"format", required_argument, 0, 'f'},
543 {"repair", no_argument, 0, 'r'},
544 {"output", required_argument, 0, OPTION_OUTPUT},
545 {0, 0, 0, 0}
546 };
547 c = getopt_long(argc, argv, "f:hr:q",
548 long_options, &option_index);
549 if (c == -1) {
550 break;
551 }
552 switch(c) {
553 case '?':
554 case 'h':
555 help();
556 break;
557 case 'f':
558 fmt = optarg;
559 break;
560 case 'r':
561 flags |= BDRV_O_RDWR;
562
563 if (!strcmp(optarg, "leaks")) {
564 fix = BDRV_FIX_LEAKS;
565 } else if (!strcmp(optarg, "all")) {
566 fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
567 } else {
568 help();
569 }
570 break;
571 case OPTION_OUTPUT:
572 output = optarg;
573 break;
574 case 'q':
575 quiet = true;
576 break;
577 }
578 }
579 if (optind != argc - 1) {
580 help();
581 }
582 filename = argv[optind++];
583
584 if (output && !strcmp(output, "json")) {
585 output_format = OFORMAT_JSON;
586 } else if (output && !strcmp(output, "human")) {
587 output_format = OFORMAT_HUMAN;
588 } else if (output) {
589 error_report("--output must be used with human or json as argument.");
590 return 1;
591 }
592
593 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
594 if (!bs) {
595 return 1;
596 }
597
598 check = g_new0(ImageCheck, 1);
599 ret = collect_image_check(bs, check, filename, fmt, fix);
600
601 if (ret == -ENOTSUP) {
602 if (output_format == OFORMAT_HUMAN) {
603 error_report("This image format does not support checks");
604 }
605 ret = 1;
606 goto fail;
607 }
608
609 if (check->corruptions_fixed || check->leaks_fixed) {
610 int corruptions_fixed, leaks_fixed;
611
612 leaks_fixed = check->leaks_fixed;
613 corruptions_fixed = check->corruptions_fixed;
614
615 if (output_format == OFORMAT_HUMAN) {
616 qprintf(quiet,
617 "The following inconsistencies were found and repaired:\n\n"
618 " %" PRId64 " leaked clusters\n"
619 " %" PRId64 " corruptions\n\n"
620 "Double checking the fixed image now...\n",
621 check->leaks_fixed,
622 check->corruptions_fixed);
623 }
624
625 ret = collect_image_check(bs, check, filename, fmt, 0);
626
627 check->leaks_fixed = leaks_fixed;
628 check->corruptions_fixed = corruptions_fixed;
629 }
630
631 switch (output_format) {
632 case OFORMAT_HUMAN:
633 dump_human_image_check(check, quiet);
634 break;
635 case OFORMAT_JSON:
636 dump_json_image_check(check, quiet);
637 break;
638 }
639
640 if (ret || check->check_errors) {
641 ret = 1;
642 goto fail;
643 }
644
645 if (check->corruptions) {
646 ret = 2;
647 } else if (check->leaks) {
648 ret = 3;
649 } else {
650 ret = 0;
651 }
652
653 fail:
654 qapi_free_ImageCheck(check);
655 bdrv_delete(bs);
656
657 return ret;
658 }
659
660 static int img_commit(int argc, char **argv)
661 {
662 int c, ret, flags;
663 const char *filename, *fmt, *cache;
664 BlockDriverState *bs;
665 bool quiet = false;
666
667 fmt = NULL;
668 cache = BDRV_DEFAULT_CACHE;
669 for(;;) {
670 c = getopt(argc, argv, "f:ht:q");
671 if (c == -1) {
672 break;
673 }
674 switch(c) {
675 case '?':
676 case 'h':
677 help();
678 break;
679 case 'f':
680 fmt = optarg;
681 break;
682 case 't':
683 cache = optarg;
684 break;
685 case 'q':
686 quiet = true;
687 break;
688 }
689 }
690 if (optind != argc - 1) {
691 help();
692 }
693 filename = argv[optind++];
694
695 flags = BDRV_O_RDWR;
696 ret = bdrv_parse_cache_flags(cache, &flags);
697 if (ret < 0) {
698 error_report("Invalid cache option: %s", cache);
699 return -1;
700 }
701
702 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
703 if (!bs) {
704 return 1;
705 }
706 ret = bdrv_commit(bs);
707 switch(ret) {
708 case 0:
709 qprintf(quiet, "Image committed.\n");
710 break;
711 case -ENOENT:
712 error_report("No disk inserted");
713 break;
714 case -EACCES:
715 error_report("Image is read-only");
716 break;
717 case -ENOTSUP:
718 error_report("Image is already committed");
719 break;
720 default:
721 error_report("Error while committing image");
722 break;
723 }
724
725 bdrv_delete(bs);
726 if (ret) {
727 return 1;
728 }
729 return 0;
730 }
731
732 /*
733 * Returns true iff the first sector pointed to by 'buf' contains at least
734 * a non-NUL byte.
735 *
736 * 'pnum' is set to the number of sectors (including and immediately following
737 * the first one) that are known to be in the same allocated/unallocated state.
738 */
739 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
740 {
741 bool is_zero;
742 int i;
743
744 if (n <= 0) {
745 *pnum = 0;
746 return 0;
747 }
748 is_zero = buffer_is_zero(buf, 512);
749 for(i = 1; i < n; i++) {
750 buf += 512;
751 if (is_zero != buffer_is_zero(buf, 512)) {
752 break;
753 }
754 }
755 *pnum = i;
756 return !is_zero;
757 }
758
759 /*
760 * Like is_allocated_sectors, but if the buffer starts with a used sector,
761 * up to 'min' consecutive sectors containing zeros are ignored. This avoids
762 * breaking up write requests for only small sparse areas.
763 */
764 static int is_allocated_sectors_min(const uint8_t *buf, int n, int *pnum,
765 int min)
766 {
767 int ret;
768 int num_checked, num_used;
769
770 if (n < min) {
771 min = n;
772 }
773
774 ret = is_allocated_sectors(buf, n, pnum);
775 if (!ret) {
776 return ret;
777 }
778
779 num_used = *pnum;
780 buf += BDRV_SECTOR_SIZE * *pnum;
781 n -= *pnum;
782 num_checked = num_used;
783
784 while (n > 0) {
785 ret = is_allocated_sectors(buf, n, pnum);
786
787 buf += BDRV_SECTOR_SIZE * *pnum;
788 n -= *pnum;
789 num_checked += *pnum;
790 if (ret) {
791 num_used = num_checked;
792 } else if (*pnum >= min) {
793 break;
794 }
795 }
796
797 *pnum = num_used;
798 return 1;
799 }
800
801 /*
802 * Compares two buffers sector by sector. Returns 0 if the first sector of both
803 * buffers matches, non-zero otherwise.
804 *
805 * pnum is set to the number of sectors (including and immediately following
806 * the first one) that are known to have the same comparison result
807 */
808 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
809 int *pnum)
810 {
811 int res, i;
812
813 if (n <= 0) {
814 *pnum = 0;
815 return 0;
816 }
817
818 res = !!memcmp(buf1, buf2, 512);
819 for(i = 1; i < n; i++) {
820 buf1 += 512;
821 buf2 += 512;
822
823 if (!!memcmp(buf1, buf2, 512) != res) {
824 break;
825 }
826 }
827
828 *pnum = i;
829 return res;
830 }
831
832 #define IO_BUF_SIZE (2 * 1024 * 1024)
833
834 static int64_t sectors_to_bytes(int64_t sectors)
835 {
836 return sectors << BDRV_SECTOR_BITS;
837 }
838
839 static int64_t sectors_to_process(int64_t total, int64_t from)
840 {
841 return MIN(total - from, IO_BUF_SIZE >> BDRV_SECTOR_BITS);
842 }
843
844 /*
845 * Check if passed sectors are empty (not allocated or contain only 0 bytes)
846 *
847 * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
848 * data and negative value on error.
849 *
850 * @param bs: Driver used for accessing file
851 * @param sect_num: Number of first sector to check
852 * @param sect_count: Number of sectors to check
853 * @param filename: Name of disk file we are checking (logging purpose)
854 * @param buffer: Allocated buffer for storing read data
855 * @param quiet: Flag for quiet mode
856 */
857 static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
858 int sect_count, const char *filename,
859 uint8_t *buffer, bool quiet)
860 {
861 int pnum, ret = 0;
862 ret = bdrv_read(bs, sect_num, buffer, sect_count);
863 if (ret < 0) {
864 error_report("Error while reading offset %" PRId64 " of %s: %s",
865 sectors_to_bytes(sect_num), filename, strerror(-ret));
866 return ret;
867 }
868 ret = is_allocated_sectors(buffer, sect_count, &pnum);
869 if (ret || pnum != sect_count) {
870 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
871 sectors_to_bytes(ret ? sect_num : sect_num + pnum));
872 return 1;
873 }
874
875 return 0;
876 }
877
878 /*
879 * Compares two images. Exit codes:
880 *
881 * 0 - Images are identical
882 * 1 - Images differ
883 * >1 - Error occurred
884 */
885 static int img_compare(int argc, char **argv)
886 {
887 const char *fmt1 = NULL, *fmt2 = NULL, *filename1, *filename2;
888 BlockDriverState *bs1, *bs2;
889 int64_t total_sectors1, total_sectors2;
890 uint8_t *buf1 = NULL, *buf2 = NULL;
891 int pnum1, pnum2;
892 int allocated1, allocated2;
893 int ret = 0; /* return value - 0 Ident, 1 Different, >1 Error */
894 bool progress = false, quiet = false, strict = false;
895 int64_t total_sectors;
896 int64_t sector_num = 0;
897 int64_t nb_sectors;
898 int c, pnum;
899 uint64_t bs_sectors;
900 uint64_t progress_base;
901
902 for (;;) {
903 c = getopt(argc, argv, "hpf:F:sq");
904 if (c == -1) {
905 break;
906 }
907 switch (c) {
908 case '?':
909 case 'h':
910 help();
911 break;
912 case 'f':
913 fmt1 = optarg;
914 break;
915 case 'F':
916 fmt2 = optarg;
917 break;
918 case 'p':
919 progress = true;
920 break;
921 case 'q':
922 quiet = true;
923 break;
924 case 's':
925 strict = true;
926 break;
927 }
928 }
929
930 /* Progress is not shown in Quiet mode */
931 if (quiet) {
932 progress = false;
933 }
934
935
936 if (optind != argc - 2) {
937 help();
938 }
939 filename1 = argv[optind++];
940 filename2 = argv[optind++];
941
942 /* Initialize before goto out */
943 qemu_progress_init(progress, 2.0);
944
945 bs1 = bdrv_new_open(filename1, fmt1, BDRV_O_FLAGS, true, quiet);
946 if (!bs1) {
947 error_report("Can't open file %s", filename1);
948 ret = 2;
949 goto out3;
950 }
951
952 bs2 = bdrv_new_open(filename2, fmt2, BDRV_O_FLAGS, true, quiet);
953 if (!bs2) {
954 error_report("Can't open file %s", filename2);
955 ret = 2;
956 goto out2;
957 }
958
959 buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
960 buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
961 bdrv_get_geometry(bs1, &bs_sectors);
962 total_sectors1 = bs_sectors;
963 bdrv_get_geometry(bs2, &bs_sectors);
964 total_sectors2 = bs_sectors;
965 total_sectors = MIN(total_sectors1, total_sectors2);
966 progress_base = MAX(total_sectors1, total_sectors2);
967
968 qemu_progress_print(0, 100);
969
970 if (strict && total_sectors1 != total_sectors2) {
971 ret = 1;
972 qprintf(quiet, "Strict mode: Image size mismatch!\n");
973 goto out;
974 }
975
976 for (;;) {
977 nb_sectors = sectors_to_process(total_sectors, sector_num);
978 if (nb_sectors <= 0) {
979 break;
980 }
981 allocated1 = bdrv_is_allocated_above(bs1, NULL, sector_num, nb_sectors,
982 &pnum1);
983 if (allocated1 < 0) {
984 ret = 3;
985 error_report("Sector allocation test failed for %s", filename1);
986 goto out;
987 }
988
989 allocated2 = bdrv_is_allocated_above(bs2, NULL, sector_num, nb_sectors,
990 &pnum2);
991 if (allocated2 < 0) {
992 ret = 3;
993 error_report("Sector allocation test failed for %s", filename2);
994 goto out;
995 }
996 nb_sectors = MIN(pnum1, pnum2);
997
998 if (allocated1 == allocated2) {
999 if (allocated1) {
1000 ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
1001 if (ret < 0) {
1002 error_report("Error while reading offset %" PRId64 " of %s:"
1003 " %s", sectors_to_bytes(sector_num), filename1,
1004 strerror(-ret));
1005 ret = 4;
1006 goto out;
1007 }
1008 ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
1009 if (ret < 0) {
1010 error_report("Error while reading offset %" PRId64
1011 " of %s: %s", sectors_to_bytes(sector_num),
1012 filename2, strerror(-ret));
1013 ret = 4;
1014 goto out;
1015 }
1016 ret = compare_sectors(buf1, buf2, nb_sectors, &pnum);
1017 if (ret || pnum != nb_sectors) {
1018 ret = 1;
1019 qprintf(quiet, "Content mismatch at offset %" PRId64 "!\n",
1020 sectors_to_bytes(
1021 ret ? sector_num : sector_num + pnum));
1022 goto out;
1023 }
1024 }
1025 } else {
1026 if (strict) {
1027 ret = 1;
1028 qprintf(quiet, "Strict mode: Offset %" PRId64
1029 " allocation mismatch!\n",
1030 sectors_to_bytes(sector_num));
1031 goto out;
1032 }
1033
1034 if (allocated1) {
1035 ret = check_empty_sectors(bs1, sector_num, nb_sectors,
1036 filename1, buf1, quiet);
1037 } else {
1038 ret = check_empty_sectors(bs2, sector_num, nb_sectors,
1039 filename2, buf1, quiet);
1040 }
1041 if (ret) {
1042 if (ret < 0) {
1043 ret = 4;
1044 error_report("Error while reading offset %" PRId64 ": %s",
1045 sectors_to_bytes(sector_num), strerror(-ret));
1046 }
1047 goto out;
1048 }
1049 }
1050 sector_num += nb_sectors;
1051 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1052 }
1053
1054 if (total_sectors1 != total_sectors2) {
1055 BlockDriverState *bs_over;
1056 int64_t total_sectors_over;
1057 const char *filename_over;
1058
1059 qprintf(quiet, "Warning: Image size mismatch!\n");
1060 if (total_sectors1 > total_sectors2) {
1061 total_sectors_over = total_sectors1;
1062 bs_over = bs1;
1063 filename_over = filename1;
1064 } else {
1065 total_sectors_over = total_sectors2;
1066 bs_over = bs2;
1067 filename_over = filename2;
1068 }
1069
1070 for (;;) {
1071 nb_sectors = sectors_to_process(total_sectors_over, sector_num);
1072 if (nb_sectors <= 0) {
1073 break;
1074 }
1075 ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
1076 nb_sectors, &pnum);
1077 if (ret < 0) {
1078 ret = 3;
1079 error_report("Sector allocation test failed for %s",
1080 filename_over);
1081 goto out;
1082
1083 }
1084 nb_sectors = pnum;
1085 if (ret) {
1086 ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
1087 filename_over, buf1, quiet);
1088 if (ret) {
1089 if (ret < 0) {
1090 ret = 4;
1091 error_report("Error while reading offset %" PRId64
1092 " of %s: %s", sectors_to_bytes(sector_num),
1093 filename_over, strerror(-ret));
1094 }
1095 goto out;
1096 }
1097 }
1098 sector_num += nb_sectors;
1099 qemu_progress_print(((float) nb_sectors / progress_base)*100, 100);
1100 }
1101 }
1102
1103 qprintf(quiet, "Images are identical.\n");
1104 ret = 0;
1105
1106 out:
1107 bdrv_delete(bs2);
1108 qemu_vfree(buf1);
1109 qemu_vfree(buf2);
1110 out2:
1111 bdrv_delete(bs1);
1112 out3:
1113 qemu_progress_end();
1114 return ret;
1115 }
1116
1117 static int img_convert(int argc, char **argv)
1118 {
1119 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
1120 int progress = 0, flags;
1121 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1122 BlockDriver *drv, *proto_drv;
1123 BlockDriverState **bs = NULL, *out_bs = NULL;
1124 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
1125 uint64_t bs_sectors;
1126 uint8_t * buf = NULL;
1127 const uint8_t *buf1;
1128 BlockDriverInfo bdi;
1129 QEMUOptionParameter *param = NULL, *create_options = NULL;
1130 QEMUOptionParameter *out_baseimg_param;
1131 char *options = NULL;
1132 const char *snapshot_name = NULL;
1133 float local_progress = 0;
1134 int min_sparse = 8; /* Need at least 4k of zeros for sparse detection */
1135 bool quiet = false;
1136
1137 fmt = NULL;
1138 out_fmt = "raw";
1139 cache = "unsafe";
1140 out_baseimg = NULL;
1141 compress = 0;
1142 for(;;) {
1143 c = getopt(argc, argv, "f:O:B:s:hce6o:pS:t:q");
1144 if (c == -1) {
1145 break;
1146 }
1147 switch(c) {
1148 case '?':
1149 case 'h':
1150 help();
1151 break;
1152 case 'f':
1153 fmt = optarg;
1154 break;
1155 case 'O':
1156 out_fmt = optarg;
1157 break;
1158 case 'B':
1159 out_baseimg = optarg;
1160 break;
1161 case 'c':
1162 compress = 1;
1163 break;
1164 case 'e':
1165 error_report("option -e is deprecated, please use \'-o "
1166 "encryption\' instead!");
1167 return 1;
1168 case '6':
1169 error_report("option -6 is deprecated, please use \'-o "
1170 "compat6\' instead!");
1171 return 1;
1172 case 'o':
1173 options = optarg;
1174 break;
1175 case 's':
1176 snapshot_name = optarg;
1177 break;
1178 case 'S':
1179 {
1180 int64_t sval;
1181 char *end;
1182 sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
1183 if (sval < 0 || *end) {
1184 error_report("Invalid minimum zero buffer size for sparse output specified");
1185 return 1;
1186 }
1187
1188 min_sparse = sval / BDRV_SECTOR_SIZE;
1189 break;
1190 }
1191 case 'p':
1192 progress = 1;
1193 break;
1194 case 't':
1195 cache = optarg;
1196 break;
1197 case 'q':
1198 quiet = true;
1199 break;
1200 }
1201 }
1202
1203 if (quiet) {
1204 progress = 0;
1205 }
1206
1207 bs_n = argc - optind - 1;
1208 if (bs_n < 1) {
1209 help();
1210 }
1211
1212 out_filename = argv[argc - 1];
1213
1214 /* Initialize before goto out */
1215 qemu_progress_init(progress, 2.0);
1216
1217 if (options && is_help_option(options)) {
1218 ret = print_block_option_help(out_filename, out_fmt);
1219 goto out;
1220 }
1221
1222 if (bs_n > 1 && out_baseimg) {
1223 error_report("-B makes no sense when concatenating multiple input "
1224 "images");
1225 ret = -1;
1226 goto out;
1227 }
1228
1229 qemu_progress_print(0, 100);
1230
1231 bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
1232
1233 total_sectors = 0;
1234 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1235 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS, true,
1236 quiet);
1237 if (!bs[bs_i]) {
1238 error_report("Could not open '%s'", argv[optind + bs_i]);
1239 ret = -1;
1240 goto out;
1241 }
1242 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1243 total_sectors += bs_sectors;
1244 }
1245
1246 if (snapshot_name != NULL) {
1247 if (bs_n > 1) {
1248 error_report("No support for concatenating multiple snapshot");
1249 ret = -1;
1250 goto out;
1251 }
1252 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1253 error_report("Failed to load snapshot");
1254 ret = -1;
1255 goto out;
1256 }
1257 }
1258
1259 /* Find driver and parse its options */
1260 drv = bdrv_find_format(out_fmt);
1261 if (!drv) {
1262 error_report("Unknown file format '%s'", out_fmt);
1263 ret = -1;
1264 goto out;
1265 }
1266
1267 proto_drv = bdrv_find_protocol(out_filename, true);
1268 if (!proto_drv) {
1269 error_report("Unknown protocol '%s'", out_filename);
1270 ret = -1;
1271 goto out;
1272 }
1273
1274 create_options = append_option_parameters(create_options,
1275 drv->create_options);
1276 create_options = append_option_parameters(create_options,
1277 proto_drv->create_options);
1278
1279 if (options) {
1280 param = parse_option_parameters(options, create_options, param);
1281 if (param == NULL) {
1282 error_report("Invalid options for file format '%s'.", out_fmt);
1283 ret = -1;
1284 goto out;
1285 }
1286 } else {
1287 param = parse_option_parameters("", create_options, param);
1288 }
1289
1290 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1291 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1292 if (ret < 0) {
1293 goto out;
1294 }
1295
1296 /* Get backing file name if -o backing_file was used */
1297 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
1298 if (out_baseimg_param) {
1299 out_baseimg = out_baseimg_param->value.s;
1300 }
1301
1302 /* Check if compression is supported */
1303 if (compress) {
1304 QEMUOptionParameter *encryption =
1305 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
1306 QEMUOptionParameter *preallocation =
1307 get_option_parameter(param, BLOCK_OPT_PREALLOC);
1308
1309 if (!drv->bdrv_write_compressed) {
1310 error_report("Compression not supported for this file format");
1311 ret = -1;
1312 goto out;
1313 }
1314
1315 if (encryption && encryption->value.n) {
1316 error_report("Compression and encryption not supported at "
1317 "the same time");
1318 ret = -1;
1319 goto out;
1320 }
1321
1322 if (preallocation && preallocation->value.s
1323 && strcmp(preallocation->value.s, "off"))
1324 {
1325 error_report("Compression and preallocation not supported at "
1326 "the same time");
1327 ret = -1;
1328 goto out;
1329 }
1330 }
1331
1332 /* Create the new image */
1333 ret = bdrv_create(drv, out_filename, param);
1334 if (ret < 0) {
1335 if (ret == -ENOTSUP) {
1336 error_report("Formatting not supported for file format '%s'",
1337 out_fmt);
1338 } else if (ret == -EFBIG) {
1339 error_report("The image size is too large for file format '%s'",
1340 out_fmt);
1341 } else {
1342 error_report("%s: error while converting %s: %s",
1343 out_filename, out_fmt, strerror(-ret));
1344 }
1345 goto out;
1346 }
1347
1348 flags = BDRV_O_RDWR;
1349 ret = bdrv_parse_cache_flags(cache, &flags);
1350 if (ret < 0) {
1351 error_report("Invalid cache option: %s", cache);
1352 return -1;
1353 }
1354
1355 out_bs = bdrv_new_open(out_filename, out_fmt, flags, true, quiet);
1356 if (!out_bs) {
1357 ret = -1;
1358 goto out;
1359 }
1360
1361 bs_i = 0;
1362 bs_offset = 0;
1363 bdrv_get_geometry(bs[0], &bs_sectors);
1364 buf = qemu_blockalign(out_bs, IO_BUF_SIZE);
1365
1366 if (compress) {
1367 ret = bdrv_get_info(out_bs, &bdi);
1368 if (ret < 0) {
1369 error_report("could not get block driver info");
1370 goto out;
1371 }
1372 cluster_size = bdi.cluster_size;
1373 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1374 error_report("invalid cluster size");
1375 ret = -1;
1376 goto out;
1377 }
1378 cluster_sectors = cluster_size >> 9;
1379 sector_num = 0;
1380
1381 nb_sectors = total_sectors;
1382 if (nb_sectors != 0) {
1383 local_progress = (float)100 /
1384 (nb_sectors / MIN(nb_sectors, cluster_sectors));
1385 }
1386
1387 for(;;) {
1388 int64_t bs_num;
1389 int remainder;
1390 uint8_t *buf2;
1391
1392 nb_sectors = total_sectors - sector_num;
1393 if (nb_sectors <= 0)
1394 break;
1395 if (nb_sectors >= cluster_sectors)
1396 n = cluster_sectors;
1397 else
1398 n = nb_sectors;
1399
1400 bs_num = sector_num - bs_offset;
1401 assert (bs_num >= 0);
1402 remainder = n;
1403 buf2 = buf;
1404 while (remainder > 0) {
1405 int nlow;
1406 while (bs_num == bs_sectors) {
1407 bs_i++;
1408 assert (bs_i < bs_n);
1409 bs_offset += bs_sectors;
1410 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1411 bs_num = 0;
1412 /* printf("changing part: sector_num=%" PRId64 ", "
1413 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
1414 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
1415 }
1416 assert (bs_num < bs_sectors);
1417
1418 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
1419
1420 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
1421 if (ret < 0) {
1422 error_report("error while reading sector %" PRId64 ": %s",
1423 bs_num, strerror(-ret));
1424 goto out;
1425 }
1426
1427 buf2 += nlow * 512;
1428 bs_num += nlow;
1429
1430 remainder -= nlow;
1431 }
1432 assert (remainder == 0);
1433
1434 if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
1435 ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
1436 if (ret != 0) {
1437 error_report("error while compressing sector %" PRId64
1438 ": %s", sector_num, strerror(-ret));
1439 goto out;
1440 }
1441 }
1442 sector_num += n;
1443 qemu_progress_print(local_progress, 100);
1444 }
1445 /* signal EOF to align */
1446 bdrv_write_compressed(out_bs, 0, NULL, 0);
1447 } else {
1448 int has_zero_init = bdrv_has_zero_init(out_bs);
1449
1450 sector_num = 0; // total number of sectors converted so far
1451 nb_sectors = total_sectors - sector_num;
1452 if (nb_sectors != 0) {
1453 local_progress = (float)100 /
1454 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
1455 }
1456
1457 for(;;) {
1458 nb_sectors = total_sectors - sector_num;
1459 if (nb_sectors <= 0) {
1460 break;
1461 }
1462 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1463 n = (IO_BUF_SIZE / 512);
1464 } else {
1465 n = nb_sectors;
1466 }
1467
1468 while (sector_num - bs_offset >= bs_sectors) {
1469 bs_i ++;
1470 assert (bs_i < bs_n);
1471 bs_offset += bs_sectors;
1472 bdrv_get_geometry(bs[bs_i], &bs_sectors);
1473 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
1474 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1475 sector_num, bs_i, bs_offset, bs_sectors); */
1476 }
1477
1478 if (n > bs_offset + bs_sectors - sector_num) {
1479 n = bs_offset + bs_sectors - sector_num;
1480 }
1481
1482 if (has_zero_init) {
1483 /* If the output image is being created as a copy on write image,
1484 assume that sectors which are unallocated in the input image
1485 are present in both the output's and input's base images (no
1486 need to copy them). */
1487 if (out_baseimg) {
1488 ret = bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1489 n, &n1);
1490 if (ret < 0) {
1491 error_report("error while reading metadata for sector "
1492 "%" PRId64 ": %s",
1493 sector_num - bs_offset, strerror(-ret));
1494 goto out;
1495 }
1496 if (!ret) {
1497 sector_num += n1;
1498 continue;
1499 }
1500 /* The next 'n1' sectors are allocated in the input image. Copy
1501 only those as they may be followed by unallocated sectors. */
1502 n = n1;
1503 }
1504 } else {
1505 n1 = n;
1506 }
1507
1508 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1509 if (ret < 0) {
1510 error_report("error while reading sector %" PRId64 ": %s",
1511 sector_num - bs_offset, strerror(-ret));
1512 goto out;
1513 }
1514 /* NOTE: at the same time we convert, we do not write zero
1515 sectors to have a chance to compress the image. Ideally, we
1516 should add a specific call to have the info to go faster */
1517 buf1 = buf;
1518 while (n > 0) {
1519 /* If the output image is being created as a copy on write image,
1520 copy all sectors even the ones containing only NUL bytes,
1521 because they may differ from the sectors in the base image.
1522
1523 If the output is to a host device, we also write out
1524 sectors that are entirely 0, since whatever data was
1525 already there is garbage, not 0s. */
1526 if (!has_zero_init || out_baseimg ||
1527 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1528 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1529 if (ret < 0) {
1530 error_report("error while writing sector %" PRId64
1531 ": %s", sector_num, strerror(-ret));
1532 goto out;
1533 }
1534 }
1535 sector_num += n1;
1536 n -= n1;
1537 buf1 += n1 * 512;
1538 }
1539 qemu_progress_print(local_progress, 100);
1540 }
1541 }
1542 out:
1543 qemu_progress_end();
1544 free_option_parameters(create_options);
1545 free_option_parameters(param);
1546 qemu_vfree(buf);
1547 if (out_bs) {
1548 bdrv_delete(out_bs);
1549 }
1550 if (bs) {
1551 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1552 if (bs[bs_i]) {
1553 bdrv_delete(bs[bs_i]);
1554 }
1555 }
1556 g_free(bs);
1557 }
1558 if (ret) {
1559 return 1;
1560 }
1561 return 0;
1562 }
1563
1564
1565 static void dump_snapshots(BlockDriverState *bs)
1566 {
1567 QEMUSnapshotInfo *sn_tab, *sn;
1568 int nb_sns, i;
1569
1570 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1571 if (nb_sns <= 0)
1572 return;
1573 printf("Snapshot list:\n");
1574 bdrv_snapshot_dump(fprintf, stdout, NULL);
1575 printf("\n");
1576 for(i = 0; i < nb_sns; i++) {
1577 sn = &sn_tab[i];
1578 bdrv_snapshot_dump(fprintf, stdout, sn);
1579 printf("\n");
1580 }
1581 g_free(sn_tab);
1582 }
1583
1584 static void dump_json_image_info_list(ImageInfoList *list)
1585 {
1586 Error *errp = NULL;
1587 QString *str;
1588 QmpOutputVisitor *ov = qmp_output_visitor_new();
1589 QObject *obj;
1590 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1591 &list, NULL, &errp);
1592 obj = qmp_output_get_qobject(ov);
1593 str = qobject_to_json_pretty(obj);
1594 assert(str != NULL);
1595 printf("%s\n", qstring_get_str(str));
1596 qobject_decref(obj);
1597 qmp_output_visitor_cleanup(ov);
1598 QDECREF(str);
1599 }
1600
1601 static void dump_json_image_info(ImageInfo *info)
1602 {
1603 Error *errp = NULL;
1604 QString *str;
1605 QmpOutputVisitor *ov = qmp_output_visitor_new();
1606 QObject *obj;
1607 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1608 &info, NULL, &errp);
1609 obj = qmp_output_get_qobject(ov);
1610 str = qobject_to_json_pretty(obj);
1611 assert(str != NULL);
1612 printf("%s\n", qstring_get_str(str));
1613 qobject_decref(obj);
1614 qmp_output_visitor_cleanup(ov);
1615 QDECREF(str);
1616 }
1617
1618 static void dump_human_image_info_list(ImageInfoList *list)
1619 {
1620 ImageInfoList *elem;
1621 bool delim = false;
1622
1623 for (elem = list; elem; elem = elem->next) {
1624 if (delim) {
1625 printf("\n");
1626 }
1627 delim = true;
1628
1629 bdrv_image_info_dump(fprintf, stdout, elem->value);
1630 }
1631 }
1632
1633 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1634 {
1635 return strcmp(a, b) == 0;
1636 }
1637
1638 /**
1639 * Open an image file chain and return an ImageInfoList
1640 *
1641 * @filename: topmost image filename
1642 * @fmt: topmost image format (may be NULL to autodetect)
1643 * @chain: true - enumerate entire backing file chain
1644 * false - only topmost image file
1645 *
1646 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1647 * image file. If there was an error a message will have been printed to
1648 * stderr.
1649 */
1650 static ImageInfoList *collect_image_info_list(const char *filename,
1651 const char *fmt,
1652 bool chain)
1653 {
1654 ImageInfoList *head = NULL;
1655 ImageInfoList **last = &head;
1656 GHashTable *filenames;
1657 Error *err = NULL;
1658
1659 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1660
1661 while (filename) {
1662 BlockDriverState *bs;
1663 ImageInfo *info;
1664 ImageInfoList *elem;
1665
1666 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1667 error_report("Backing file '%s' creates an infinite loop.",
1668 filename);
1669 goto err;
1670 }
1671 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1672
1673 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1674 false, false);
1675 if (!bs) {
1676 goto err;
1677 }
1678
1679 bdrv_query_image_info(bs, &info, &err);
1680 if (error_is_set(&err)) {
1681 error_report("%s", error_get_pretty(err));
1682 error_free(err);
1683 goto err;
1684 }
1685
1686 elem = g_new0(ImageInfoList, 1);
1687 elem->value = info;
1688 *last = elem;
1689 last = &elem->next;
1690
1691 bdrv_delete(bs);
1692
1693 filename = fmt = NULL;
1694 if (chain) {
1695 if (info->has_full_backing_filename) {
1696 filename = info->full_backing_filename;
1697 } else if (info->has_backing_filename) {
1698 filename = info->backing_filename;
1699 }
1700 if (info->has_backing_filename_format) {
1701 fmt = info->backing_filename_format;
1702 }
1703 }
1704 }
1705 g_hash_table_destroy(filenames);
1706 return head;
1707
1708 err:
1709 qapi_free_ImageInfoList(head);
1710 g_hash_table_destroy(filenames);
1711 return NULL;
1712 }
1713
1714 static int img_info(int argc, char **argv)
1715 {
1716 int c;
1717 OutputFormat output_format = OFORMAT_HUMAN;
1718 bool chain = false;
1719 const char *filename, *fmt, *output;
1720 ImageInfoList *list;
1721
1722 fmt = NULL;
1723 output = NULL;
1724 for(;;) {
1725 int option_index = 0;
1726 static const struct option long_options[] = {
1727 {"help", no_argument, 0, 'h'},
1728 {"format", required_argument, 0, 'f'},
1729 {"output", required_argument, 0, OPTION_OUTPUT},
1730 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1731 {0, 0, 0, 0}
1732 };
1733 c = getopt_long(argc, argv, "f:h",
1734 long_options, &option_index);
1735 if (c == -1) {
1736 break;
1737 }
1738 switch(c) {
1739 case '?':
1740 case 'h':
1741 help();
1742 break;
1743 case 'f':
1744 fmt = optarg;
1745 break;
1746 case OPTION_OUTPUT:
1747 output = optarg;
1748 break;
1749 case OPTION_BACKING_CHAIN:
1750 chain = true;
1751 break;
1752 }
1753 }
1754 if (optind != argc - 1) {
1755 help();
1756 }
1757 filename = argv[optind++];
1758
1759 if (output && !strcmp(output, "json")) {
1760 output_format = OFORMAT_JSON;
1761 } else if (output && !strcmp(output, "human")) {
1762 output_format = OFORMAT_HUMAN;
1763 } else if (output) {
1764 error_report("--output must be used with human or json as argument.");
1765 return 1;
1766 }
1767
1768 list = collect_image_info_list(filename, fmt, chain);
1769 if (!list) {
1770 return 1;
1771 }
1772
1773 switch (output_format) {
1774 case OFORMAT_HUMAN:
1775 dump_human_image_info_list(list);
1776 break;
1777 case OFORMAT_JSON:
1778 if (chain) {
1779 dump_json_image_info_list(list);
1780 } else {
1781 dump_json_image_info(list->value);
1782 }
1783 break;
1784 }
1785
1786 qapi_free_ImageInfoList(list);
1787 return 0;
1788 }
1789
1790 #define SNAPSHOT_LIST 1
1791 #define SNAPSHOT_CREATE 2
1792 #define SNAPSHOT_APPLY 3
1793 #define SNAPSHOT_DELETE 4
1794
1795 static int img_snapshot(int argc, char **argv)
1796 {
1797 BlockDriverState *bs;
1798 QEMUSnapshotInfo sn;
1799 char *filename, *snapshot_name = NULL;
1800 int c, ret = 0, bdrv_oflags;
1801 int action = 0;
1802 qemu_timeval tv;
1803 bool quiet = false;
1804
1805 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1806 /* Parse commandline parameters */
1807 for(;;) {
1808 c = getopt(argc, argv, "la:c:d:hq");
1809 if (c == -1) {
1810 break;
1811 }
1812 switch(c) {
1813 case '?':
1814 case 'h':
1815 help();
1816 return 0;
1817 case 'l':
1818 if (action) {
1819 help();
1820 return 0;
1821 }
1822 action = SNAPSHOT_LIST;
1823 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1824 break;
1825 case 'a':
1826 if (action) {
1827 help();
1828 return 0;
1829 }
1830 action = SNAPSHOT_APPLY;
1831 snapshot_name = optarg;
1832 break;
1833 case 'c':
1834 if (action) {
1835 help();
1836 return 0;
1837 }
1838 action = SNAPSHOT_CREATE;
1839 snapshot_name = optarg;
1840 break;
1841 case 'd':
1842 if (action) {
1843 help();
1844 return 0;
1845 }
1846 action = SNAPSHOT_DELETE;
1847 snapshot_name = optarg;
1848 break;
1849 case 'q':
1850 quiet = true;
1851 break;
1852 }
1853 }
1854
1855 if (optind != argc - 1) {
1856 help();
1857 }
1858 filename = argv[optind++];
1859
1860 /* Open the image */
1861 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
1862 if (!bs) {
1863 return 1;
1864 }
1865
1866 /* Perform the requested action */
1867 switch(action) {
1868 case SNAPSHOT_LIST:
1869 dump_snapshots(bs);
1870 break;
1871
1872 case SNAPSHOT_CREATE:
1873 memset(&sn, 0, sizeof(sn));
1874 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1875
1876 qemu_gettimeofday(&tv);
1877 sn.date_sec = tv.tv_sec;
1878 sn.date_nsec = tv.tv_usec * 1000;
1879
1880 ret = bdrv_snapshot_create(bs, &sn);
1881 if (ret) {
1882 error_report("Could not create snapshot '%s': %d (%s)",
1883 snapshot_name, ret, strerror(-ret));
1884 }
1885 break;
1886
1887 case SNAPSHOT_APPLY:
1888 ret = bdrv_snapshot_goto(bs, snapshot_name);
1889 if (ret) {
1890 error_report("Could not apply snapshot '%s': %d (%s)",
1891 snapshot_name, ret, strerror(-ret));
1892 }
1893 break;
1894
1895 case SNAPSHOT_DELETE:
1896 ret = bdrv_snapshot_delete(bs, snapshot_name);
1897 if (ret) {
1898 error_report("Could not delete snapshot '%s': %d (%s)",
1899 snapshot_name, ret, strerror(-ret));
1900 }
1901 break;
1902 }
1903
1904 /* Cleanup */
1905 bdrv_delete(bs);
1906 if (ret) {
1907 return 1;
1908 }
1909 return 0;
1910 }
1911
1912 static int img_rebase(int argc, char **argv)
1913 {
1914 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1915 BlockDriver *old_backing_drv, *new_backing_drv;
1916 char *filename;
1917 const char *fmt, *cache, *out_basefmt, *out_baseimg;
1918 int c, flags, ret;
1919 int unsafe = 0;
1920 int progress = 0;
1921 bool quiet = false;
1922
1923 /* Parse commandline parameters */
1924 fmt = NULL;
1925 cache = BDRV_DEFAULT_CACHE;
1926 out_baseimg = NULL;
1927 out_basefmt = NULL;
1928 for(;;) {
1929 c = getopt(argc, argv, "uhf:F:b:pt:q");
1930 if (c == -1) {
1931 break;
1932 }
1933 switch(c) {
1934 case '?':
1935 case 'h':
1936 help();
1937 return 0;
1938 case 'f':
1939 fmt = optarg;
1940 break;
1941 case 'F':
1942 out_basefmt = optarg;
1943 break;
1944 case 'b':
1945 out_baseimg = optarg;
1946 break;
1947 case 'u':
1948 unsafe = 1;
1949 break;
1950 case 'p':
1951 progress = 1;
1952 break;
1953 case 't':
1954 cache = optarg;
1955 break;
1956 case 'q':
1957 quiet = true;
1958 break;
1959 }
1960 }
1961
1962 if (quiet) {
1963 progress = 0;
1964 }
1965
1966 if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
1967 help();
1968 }
1969 filename = argv[optind++];
1970
1971 qemu_progress_init(progress, 2.0);
1972 qemu_progress_print(0, 100);
1973
1974 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1975 ret = bdrv_parse_cache_flags(cache, &flags);
1976 if (ret < 0) {
1977 error_report("Invalid cache option: %s", cache);
1978 return -1;
1979 }
1980
1981 /*
1982 * Open the images.
1983 *
1984 * Ignore the old backing file for unsafe rebase in case we want to correct
1985 * the reference to a renamed or moved backing file.
1986 */
1987 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
1988 if (!bs) {
1989 return 1;
1990 }
1991
1992 /* Find the right drivers for the backing files */
1993 old_backing_drv = NULL;
1994 new_backing_drv = NULL;
1995
1996 if (!unsafe && bs->backing_format[0] != '\0') {
1997 old_backing_drv = bdrv_find_format(bs->backing_format);
1998 if (old_backing_drv == NULL) {
1999 error_report("Invalid format name: '%s'", bs->backing_format);
2000 ret = -1;
2001 goto out;
2002 }
2003 }
2004
2005 if (out_basefmt != NULL) {
2006 new_backing_drv = bdrv_find_format(out_basefmt);
2007 if (new_backing_drv == NULL) {
2008 error_report("Invalid format name: '%s'", out_basefmt);
2009 ret = -1;
2010 goto out;
2011 }
2012 }
2013
2014 /* For safe rebasing we need to compare old and new backing file */
2015 if (unsafe) {
2016 /* Make the compiler happy */
2017 bs_old_backing = NULL;
2018 bs_new_backing = NULL;
2019 } else {
2020 char backing_name[1024];
2021
2022 bs_old_backing = bdrv_new("old_backing");
2023 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2024 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2025 old_backing_drv);
2026 if (ret) {
2027 error_report("Could not open old backing file '%s'", backing_name);
2028 goto out;
2029 }
2030 if (out_baseimg[0]) {
2031 bs_new_backing = bdrv_new("new_backing");
2032 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2033 new_backing_drv);
2034 if (ret) {
2035 error_report("Could not open new backing file '%s'",
2036 out_baseimg);
2037 goto out;
2038 }
2039 }
2040 }
2041
2042 /*
2043 * Check each unallocated cluster in the COW file. If it is unallocated,
2044 * accesses go to the backing file. We must therefore compare this cluster
2045 * in the old and new backing file, and if they differ we need to copy it
2046 * from the old backing file into the COW file.
2047 *
2048 * If qemu-img crashes during this step, no harm is done. The content of
2049 * the image is the same as the original one at any time.
2050 */
2051 if (!unsafe) {
2052 uint64_t num_sectors;
2053 uint64_t old_backing_num_sectors;
2054 uint64_t new_backing_num_sectors = 0;
2055 uint64_t sector;
2056 int n;
2057 uint8_t * buf_old;
2058 uint8_t * buf_new;
2059 float local_progress = 0;
2060
2061 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2062 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2063
2064 bdrv_get_geometry(bs, &num_sectors);
2065 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2066 if (bs_new_backing) {
2067 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2068 }
2069
2070 if (num_sectors != 0) {
2071 local_progress = (float)100 /
2072 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2073 }
2074
2075 for (sector = 0; sector < num_sectors; sector += n) {
2076
2077 /* How many sectors can we handle with the next read? */
2078 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2079 n = (IO_BUF_SIZE / 512);
2080 } else {
2081 n = num_sectors - sector;
2082 }
2083
2084 /* If the cluster is allocated, we don't need to take action */
2085 ret = bdrv_is_allocated(bs, sector, n, &n);
2086 if (ret < 0) {
2087 error_report("error while reading image metadata: %s",
2088 strerror(-ret));
2089 goto out;
2090 }
2091 if (ret) {
2092 continue;
2093 }
2094
2095 /*
2096 * Read old and new backing file and take into consideration that
2097 * backing files may be smaller than the COW image.
2098 */
2099 if (sector >= old_backing_num_sectors) {
2100 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2101 } else {
2102 if (sector + n > old_backing_num_sectors) {
2103 n = old_backing_num_sectors - sector;
2104 }
2105
2106 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2107 if (ret < 0) {
2108 error_report("error while reading from old backing file");
2109 goto out;
2110 }
2111 }
2112
2113 if (sector >= new_backing_num_sectors || !bs_new_backing) {
2114 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2115 } else {
2116 if (sector + n > new_backing_num_sectors) {
2117 n = new_backing_num_sectors - sector;
2118 }
2119
2120 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2121 if (ret < 0) {
2122 error_report("error while reading from new backing file");
2123 goto out;
2124 }
2125 }
2126
2127 /* If they differ, we need to write to the COW file */
2128 uint64_t written = 0;
2129
2130 while (written < n) {
2131 int pnum;
2132
2133 if (compare_sectors(buf_old + written * 512,
2134 buf_new + written * 512, n - written, &pnum))
2135 {
2136 ret = bdrv_write(bs, sector + written,
2137 buf_old + written * 512, pnum);
2138 if (ret < 0) {
2139 error_report("Error while writing to COW image: %s",
2140 strerror(-ret));
2141 goto out;
2142 }
2143 }
2144
2145 written += pnum;
2146 }
2147 qemu_progress_print(local_progress, 100);
2148 }
2149
2150 qemu_vfree(buf_old);
2151 qemu_vfree(buf_new);
2152 }
2153
2154 /*
2155 * Change the backing file. All clusters that are different from the old
2156 * backing file are overwritten in the COW file now, so the visible content
2157 * doesn't change when we switch the backing file.
2158 */
2159 if (out_baseimg && *out_baseimg) {
2160 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2161 } else {
2162 ret = bdrv_change_backing_file(bs, NULL, NULL);
2163 }
2164
2165 if (ret == -ENOSPC) {
2166 error_report("Could not change the backing file to '%s': No "
2167 "space left in the file header", out_baseimg);
2168 } else if (ret < 0) {
2169 error_report("Could not change the backing file to '%s': %s",
2170 out_baseimg, strerror(-ret));
2171 }
2172
2173 qemu_progress_print(100, 0);
2174 /*
2175 * TODO At this point it is possible to check if any clusters that are
2176 * allocated in the COW file are the same in the backing file. If so, they
2177 * could be dropped from the COW file. Don't do this before switching the
2178 * backing file, in case of a crash this would lead to corruption.
2179 */
2180 out:
2181 qemu_progress_end();
2182 /* Cleanup */
2183 if (!unsafe) {
2184 if (bs_old_backing != NULL) {
2185 bdrv_delete(bs_old_backing);
2186 }
2187 if (bs_new_backing != NULL) {
2188 bdrv_delete(bs_new_backing);
2189 }
2190 }
2191
2192 bdrv_delete(bs);
2193 if (ret) {
2194 return 1;
2195 }
2196 return 0;
2197 }
2198
2199 static int img_resize(int argc, char **argv)
2200 {
2201 int c, ret, relative;
2202 const char *filename, *fmt, *size;
2203 int64_t n, total_size;
2204 bool quiet = false;
2205 BlockDriverState *bs = NULL;
2206 QemuOpts *param;
2207 static QemuOptsList resize_options = {
2208 .name = "resize_options",
2209 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2210 .desc = {
2211 {
2212 .name = BLOCK_OPT_SIZE,
2213 .type = QEMU_OPT_SIZE,
2214 .help = "Virtual disk size"
2215 }, {
2216 /* end of list */
2217 }
2218 },
2219 };
2220
2221 /* Remove size from argv manually so that negative numbers are not treated
2222 * as options by getopt. */
2223 if (argc < 3) {
2224 help();
2225 return 1;
2226 }
2227
2228 size = argv[--argc];
2229
2230 /* Parse getopt arguments */
2231 fmt = NULL;
2232 for(;;) {
2233 c = getopt(argc, argv, "f:hq");
2234 if (c == -1) {
2235 break;
2236 }
2237 switch(c) {
2238 case '?':
2239 case 'h':
2240 help();
2241 break;
2242 case 'f':
2243 fmt = optarg;
2244 break;
2245 case 'q':
2246 quiet = true;
2247 break;
2248 }
2249 }
2250 if (optind != argc - 1) {
2251 help();
2252 }
2253 filename = argv[optind++];
2254
2255 /* Choose grow, shrink, or absolute resize mode */
2256 switch (size[0]) {
2257 case '+':
2258 relative = 1;
2259 size++;
2260 break;
2261 case '-':
2262 relative = -1;
2263 size++;
2264 break;
2265 default:
2266 relative = 0;
2267 break;
2268 }
2269
2270 /* Parse size */
2271 param = qemu_opts_create_nofail(&resize_options);
2272 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2273 /* Error message already printed when size parsing fails */
2274 ret = -1;
2275 qemu_opts_del(param);
2276 goto out;
2277 }
2278 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2279 qemu_opts_del(param);
2280
2281 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2282 if (!bs) {
2283 ret = -1;
2284 goto out;
2285 }
2286
2287 if (relative) {
2288 total_size = bdrv_getlength(bs) + n * relative;
2289 } else {
2290 total_size = n;
2291 }
2292 if (total_size <= 0) {
2293 error_report("New image size must be positive");
2294 ret = -1;
2295 goto out;
2296 }
2297
2298 ret = bdrv_truncate(bs, total_size);
2299 switch (ret) {
2300 case 0:
2301 qprintf(quiet, "Image resized.\n");
2302 break;
2303 case -ENOTSUP:
2304 error_report("This image does not support resize");
2305 break;
2306 case -EACCES:
2307 error_report("Image is read-only");
2308 break;
2309 default:
2310 error_report("Error resizing image (%d)", -ret);
2311 break;
2312 }
2313 out:
2314 if (bs) {
2315 bdrv_delete(bs);
2316 }
2317 if (ret) {
2318 return 1;
2319 }
2320 return 0;
2321 }
2322
2323 static const img_cmd_t img_cmds[] = {
2324 #define DEF(option, callback, arg_string) \
2325 { option, callback },
2326 #include "qemu-img-cmds.h"
2327 #undef DEF
2328 #undef GEN_DOCS
2329 { NULL, NULL, },
2330 };
2331
2332 int main(int argc, char **argv)
2333 {
2334 const img_cmd_t *cmd;
2335 const char *cmdname;
2336
2337 #ifdef CONFIG_POSIX
2338 signal(SIGPIPE, SIG_IGN);
2339 #endif
2340
2341 error_set_progname(argv[0]);
2342
2343 qemu_init_main_loop();
2344 bdrv_init();
2345 if (argc < 2)
2346 help();
2347 cmdname = argv[1];
2348 argc--; argv++;
2349
2350 /* find the command */
2351 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2352 if (!strcmp(cmdname, cmd->name)) {
2353 return cmd->handler(argc, argv);
2354 }
2355 }
2356
2357 /* not found */
2358 help();
2359 return 0;
2360 }
Qemu copy for testing