?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
aio / timers: Split QEMUClock into QEMUClock and QEMUTimerList
[qemu/ar7.git] / qemu-img.c
blobb9a848db74de8c77e8a009669ac72fe048bc71cc
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 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
1489 n, &n1)) {
1490 sector_num += n1;
1491 continue;
1492 }
1493 /* The next 'n1' sectors are allocated in the input image. Copy
1494 only those as they may be followed by unallocated sectors. */
1495 n = n1;
1496 }
1497 } else {
1498 n1 = n;
1499 }
1500
1501 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
1502 if (ret < 0) {
1503 error_report("error while reading sector %" PRId64 ": %s",
1504 sector_num - bs_offset, strerror(-ret));
1505 goto out;
1506 }
1507 /* NOTE: at the same time we convert, we do not write zero
1508 sectors to have a chance to compress the image. Ideally, we
1509 should add a specific call to have the info to go faster */
1510 buf1 = buf;
1511 while (n > 0) {
1512 /* If the output image is being created as a copy on write image,
1513 copy all sectors even the ones containing only NUL bytes,
1514 because they may differ from the sectors in the base image.
1515
1516 If the output is to a host device, we also write out
1517 sectors that are entirely 0, since whatever data was
1518 already there is garbage, not 0s. */
1519 if (!has_zero_init || out_baseimg ||
1520 is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
1521 ret = bdrv_write(out_bs, sector_num, buf1, n1);
1522 if (ret < 0) {
1523 error_report("error while writing sector %" PRId64
1524 ": %s", sector_num, strerror(-ret));
1525 goto out;
1526 }
1527 }
1528 sector_num += n1;
1529 n -= n1;
1530 buf1 += n1 * 512;
1531 }
1532 qemu_progress_print(local_progress, 100);
1533 }
1534 }
1535 out:
1536 qemu_progress_end();
1537 free_option_parameters(create_options);
1538 free_option_parameters(param);
1539 qemu_vfree(buf);
1540 if (out_bs) {
1541 bdrv_delete(out_bs);
1542 }
1543 if (bs) {
1544 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1545 if (bs[bs_i]) {
1546 bdrv_delete(bs[bs_i]);
1547 }
1548 }
1549 g_free(bs);
1550 }
1551 if (ret) {
1552 return 1;
1553 }
1554 return 0;
1555 }
1556
1557
1558 static void dump_snapshots(BlockDriverState *bs)
1559 {
1560 QEMUSnapshotInfo *sn_tab, *sn;
1561 int nb_sns, i;
1562
1563 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1564 if (nb_sns <= 0)
1565 return;
1566 printf("Snapshot list:\n");
1567 bdrv_snapshot_dump(fprintf, stdout, NULL);
1568 printf("\n");
1569 for(i = 0; i < nb_sns; i++) {
1570 sn = &sn_tab[i];
1571 bdrv_snapshot_dump(fprintf, stdout, sn);
1572 printf("\n");
1573 }
1574 g_free(sn_tab);
1575 }
1576
1577 static void dump_json_image_info_list(ImageInfoList *list)
1578 {
1579 Error *errp = NULL;
1580 QString *str;
1581 QmpOutputVisitor *ov = qmp_output_visitor_new();
1582 QObject *obj;
1583 visit_type_ImageInfoList(qmp_output_get_visitor(ov),
1584 &list, NULL, &errp);
1585 obj = qmp_output_get_qobject(ov);
1586 str = qobject_to_json_pretty(obj);
1587 assert(str != NULL);
1588 printf("%s\n", qstring_get_str(str));
1589 qobject_decref(obj);
1590 qmp_output_visitor_cleanup(ov);
1591 QDECREF(str);
1592 }
1593
1594 static void dump_json_image_info(ImageInfo *info)
1595 {
1596 Error *errp = NULL;
1597 QString *str;
1598 QmpOutputVisitor *ov = qmp_output_visitor_new();
1599 QObject *obj;
1600 visit_type_ImageInfo(qmp_output_get_visitor(ov),
1601 &info, NULL, &errp);
1602 obj = qmp_output_get_qobject(ov);
1603 str = qobject_to_json_pretty(obj);
1604 assert(str != NULL);
1605 printf("%s\n", qstring_get_str(str));
1606 qobject_decref(obj);
1607 qmp_output_visitor_cleanup(ov);
1608 QDECREF(str);
1609 }
1610
1611 static void dump_human_image_info_list(ImageInfoList *list)
1612 {
1613 ImageInfoList *elem;
1614 bool delim = false;
1615
1616 for (elem = list; elem; elem = elem->next) {
1617 if (delim) {
1618 printf("\n");
1619 }
1620 delim = true;
1621
1622 bdrv_image_info_dump(fprintf, stdout, elem->value);
1623 }
1624 }
1625
1626 static gboolean str_equal_func(gconstpointer a, gconstpointer b)
1627 {
1628 return strcmp(a, b) == 0;
1629 }
1630
1631 /**
1632 * Open an image file chain and return an ImageInfoList
1633 *
1634 * @filename: topmost image filename
1635 * @fmt: topmost image format (may be NULL to autodetect)
1636 * @chain: true - enumerate entire backing file chain
1637 * false - only topmost image file
1638 *
1639 * Returns a list of ImageInfo objects or NULL if there was an error opening an
1640 * image file. If there was an error a message will have been printed to
1641 * stderr.
1642 */
1643 static ImageInfoList *collect_image_info_list(const char *filename,
1644 const char *fmt,
1645 bool chain)
1646 {
1647 ImageInfoList *head = NULL;
1648 ImageInfoList **last = &head;
1649 GHashTable *filenames;
1650 Error *err = NULL;
1651
1652 filenames = g_hash_table_new_full(g_str_hash, str_equal_func, NULL, NULL);
1653
1654 while (filename) {
1655 BlockDriverState *bs;
1656 ImageInfo *info;
1657 ImageInfoList *elem;
1658
1659 if (g_hash_table_lookup_extended(filenames, filename, NULL, NULL)) {
1660 error_report("Backing file '%s' creates an infinite loop.",
1661 filename);
1662 goto err;
1663 }
1664 g_hash_table_insert(filenames, (gpointer)filename, NULL);
1665
1666 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING,
1667 false, false);
1668 if (!bs) {
1669 goto err;
1670 }
1671
1672 bdrv_query_image_info(bs, &info, &err);
1673 if (error_is_set(&err)) {
1674 error_report("%s", error_get_pretty(err));
1675 error_free(err);
1676 goto err;
1677 }
1678
1679 elem = g_new0(ImageInfoList, 1);
1680 elem->value = info;
1681 *last = elem;
1682 last = &elem->next;
1683
1684 bdrv_delete(bs);
1685
1686 filename = fmt = NULL;
1687 if (chain) {
1688 if (info->has_full_backing_filename) {
1689 filename = info->full_backing_filename;
1690 } else if (info->has_backing_filename) {
1691 filename = info->backing_filename;
1692 }
1693 if (info->has_backing_filename_format) {
1694 fmt = info->backing_filename_format;
1695 }
1696 }
1697 }
1698 g_hash_table_destroy(filenames);
1699 return head;
1700
1701 err:
1702 qapi_free_ImageInfoList(head);
1703 g_hash_table_destroy(filenames);
1704 return NULL;
1705 }
1706
1707 static int img_info(int argc, char **argv)
1708 {
1709 int c;
1710 OutputFormat output_format = OFORMAT_HUMAN;
1711 bool chain = false;
1712 const char *filename, *fmt, *output;
1713 ImageInfoList *list;
1714
1715 fmt = NULL;
1716 output = NULL;
1717 for(;;) {
1718 int option_index = 0;
1719 static const struct option long_options[] = {
1720 {"help", no_argument, 0, 'h'},
1721 {"format", required_argument, 0, 'f'},
1722 {"output", required_argument, 0, OPTION_OUTPUT},
1723 {"backing-chain", no_argument, 0, OPTION_BACKING_CHAIN},
1724 {0, 0, 0, 0}
1725 };
1726 c = getopt_long(argc, argv, "f:h",
1727 long_options, &option_index);
1728 if (c == -1) {
1729 break;
1730 }
1731 switch(c) {
1732 case '?':
1733 case 'h':
1734 help();
1735 break;
1736 case 'f':
1737 fmt = optarg;
1738 break;
1739 case OPTION_OUTPUT:
1740 output = optarg;
1741 break;
1742 case OPTION_BACKING_CHAIN:
1743 chain = true;
1744 break;
1745 }
1746 }
1747 if (optind != argc - 1) {
1748 help();
1749 }
1750 filename = argv[optind++];
1751
1752 if (output && !strcmp(output, "json")) {
1753 output_format = OFORMAT_JSON;
1754 } else if (output && !strcmp(output, "human")) {
1755 output_format = OFORMAT_HUMAN;
1756 } else if (output) {
1757 error_report("--output must be used with human or json as argument.");
1758 return 1;
1759 }
1760
1761 list = collect_image_info_list(filename, fmt, chain);
1762 if (!list) {
1763 return 1;
1764 }
1765
1766 switch (output_format) {
1767 case OFORMAT_HUMAN:
1768 dump_human_image_info_list(list);
1769 break;
1770 case OFORMAT_JSON:
1771 if (chain) {
1772 dump_json_image_info_list(list);
1773 } else {
1774 dump_json_image_info(list->value);
1775 }
1776 break;
1777 }
1778
1779 qapi_free_ImageInfoList(list);
1780 return 0;
1781 }
1782
1783 #define SNAPSHOT_LIST 1
1784 #define SNAPSHOT_CREATE 2
1785 #define SNAPSHOT_APPLY 3
1786 #define SNAPSHOT_DELETE 4
1787
1788 static int img_snapshot(int argc, char **argv)
1789 {
1790 BlockDriverState *bs;
1791 QEMUSnapshotInfo sn;
1792 char *filename, *snapshot_name = NULL;
1793 int c, ret = 0, bdrv_oflags;
1794 int action = 0;
1795 qemu_timeval tv;
1796 bool quiet = false;
1797
1798 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1799 /* Parse commandline parameters */
1800 for(;;) {
1801 c = getopt(argc, argv, "la:c:d:hq");
1802 if (c == -1) {
1803 break;
1804 }
1805 switch(c) {
1806 case '?':
1807 case 'h':
1808 help();
1809 return 0;
1810 case 'l':
1811 if (action) {
1812 help();
1813 return 0;
1814 }
1815 action = SNAPSHOT_LIST;
1816 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1817 break;
1818 case 'a':
1819 if (action) {
1820 help();
1821 return 0;
1822 }
1823 action = SNAPSHOT_APPLY;
1824 snapshot_name = optarg;
1825 break;
1826 case 'c':
1827 if (action) {
1828 help();
1829 return 0;
1830 }
1831 action = SNAPSHOT_CREATE;
1832 snapshot_name = optarg;
1833 break;
1834 case 'd':
1835 if (action) {
1836 help();
1837 return 0;
1838 }
1839 action = SNAPSHOT_DELETE;
1840 snapshot_name = optarg;
1841 break;
1842 case 'q':
1843 quiet = true;
1844 break;
1845 }
1846 }
1847
1848 if (optind != argc - 1) {
1849 help();
1850 }
1851 filename = argv[optind++];
1852
1853 /* Open the image */
1854 bs = bdrv_new_open(filename, NULL, bdrv_oflags, true, quiet);
1855 if (!bs) {
1856 return 1;
1857 }
1858
1859 /* Perform the requested action */
1860 switch(action) {
1861 case SNAPSHOT_LIST:
1862 dump_snapshots(bs);
1863 break;
1864
1865 case SNAPSHOT_CREATE:
1866 memset(&sn, 0, sizeof(sn));
1867 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1868
1869 qemu_gettimeofday(&tv);
1870 sn.date_sec = tv.tv_sec;
1871 sn.date_nsec = tv.tv_usec * 1000;
1872
1873 ret = bdrv_snapshot_create(bs, &sn);
1874 if (ret) {
1875 error_report("Could not create snapshot '%s': %d (%s)",
1876 snapshot_name, ret, strerror(-ret));
1877 }
1878 break;
1879
1880 case SNAPSHOT_APPLY:
1881 ret = bdrv_snapshot_goto(bs, snapshot_name);
1882 if (ret) {
1883 error_report("Could not apply snapshot '%s': %d (%s)",
1884 snapshot_name, ret, strerror(-ret));
1885 }
1886 break;
1887
1888 case SNAPSHOT_DELETE:
1889 ret = bdrv_snapshot_delete(bs, snapshot_name);
1890 if (ret) {
1891 error_report("Could not delete snapshot '%s': %d (%s)",
1892 snapshot_name, ret, strerror(-ret));
1893 }
1894 break;
1895 }
1896
1897 /* Cleanup */
1898 bdrv_delete(bs);
1899 if (ret) {
1900 return 1;
1901 }
1902 return 0;
1903 }
1904
1905 static int img_rebase(int argc, char **argv)
1906 {
1907 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1908 BlockDriver *old_backing_drv, *new_backing_drv;
1909 char *filename;
1910 const char *fmt, *cache, *out_basefmt, *out_baseimg;
1911 int c, flags, ret;
1912 int unsafe = 0;
1913 int progress = 0;
1914 bool quiet = false;
1915
1916 /* Parse commandline parameters */
1917 fmt = NULL;
1918 cache = BDRV_DEFAULT_CACHE;
1919 out_baseimg = NULL;
1920 out_basefmt = NULL;
1921 for(;;) {
1922 c = getopt(argc, argv, "uhf:F:b:pt:q");
1923 if (c == -1) {
1924 break;
1925 }
1926 switch(c) {
1927 case '?':
1928 case 'h':
1929 help();
1930 return 0;
1931 case 'f':
1932 fmt = optarg;
1933 break;
1934 case 'F':
1935 out_basefmt = optarg;
1936 break;
1937 case 'b':
1938 out_baseimg = optarg;
1939 break;
1940 case 'u':
1941 unsafe = 1;
1942 break;
1943 case 'p':
1944 progress = 1;
1945 break;
1946 case 't':
1947 cache = optarg;
1948 break;
1949 case 'q':
1950 quiet = true;
1951 break;
1952 }
1953 }
1954
1955 if (quiet) {
1956 progress = 0;
1957 }
1958
1959 if ((optind != argc - 1) || (!unsafe && !out_baseimg)) {
1960 help();
1961 }
1962 filename = argv[optind++];
1963
1964 qemu_progress_init(progress, 2.0);
1965 qemu_progress_print(0, 100);
1966
1967 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1968 ret = bdrv_parse_cache_flags(cache, &flags);
1969 if (ret < 0) {
1970 error_report("Invalid cache option: %s", cache);
1971 return -1;
1972 }
1973
1974 /*
1975 * Open the images.
1976 *
1977 * Ignore the old backing file for unsafe rebase in case we want to correct
1978 * the reference to a renamed or moved backing file.
1979 */
1980 bs = bdrv_new_open(filename, fmt, flags, true, quiet);
1981 if (!bs) {
1982 return 1;
1983 }
1984
1985 /* Find the right drivers for the backing files */
1986 old_backing_drv = NULL;
1987 new_backing_drv = NULL;
1988
1989 if (!unsafe && bs->backing_format[0] != '\0') {
1990 old_backing_drv = bdrv_find_format(bs->backing_format);
1991 if (old_backing_drv == NULL) {
1992 error_report("Invalid format name: '%s'", bs->backing_format);
1993 ret = -1;
1994 goto out;
1995 }
1996 }
1997
1998 if (out_basefmt != NULL) {
1999 new_backing_drv = bdrv_find_format(out_basefmt);
2000 if (new_backing_drv == NULL) {
2001 error_report("Invalid format name: '%s'", out_basefmt);
2002 ret = -1;
2003 goto out;
2004 }
2005 }
2006
2007 /* For safe rebasing we need to compare old and new backing file */
2008 if (unsafe) {
2009 /* Make the compiler happy */
2010 bs_old_backing = NULL;
2011 bs_new_backing = NULL;
2012 } else {
2013 char backing_name[1024];
2014
2015 bs_old_backing = bdrv_new("old_backing");
2016 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
2017 ret = bdrv_open(bs_old_backing, backing_name, NULL, BDRV_O_FLAGS,
2018 old_backing_drv);
2019 if (ret) {
2020 error_report("Could not open old backing file '%s'", backing_name);
2021 goto out;
2022 }
2023 if (out_baseimg[0]) {
2024 bs_new_backing = bdrv_new("new_backing");
2025 ret = bdrv_open(bs_new_backing, out_baseimg, NULL, BDRV_O_FLAGS,
2026 new_backing_drv);
2027 if (ret) {
2028 error_report("Could not open new backing file '%s'",
2029 out_baseimg);
2030 goto out;
2031 }
2032 }
2033 }
2034
2035 /*
2036 * Check each unallocated cluster in the COW file. If it is unallocated,
2037 * accesses go to the backing file. We must therefore compare this cluster
2038 * in the old and new backing file, and if they differ we need to copy it
2039 * from the old backing file into the COW file.
2040 *
2041 * If qemu-img crashes during this step, no harm is done. The content of
2042 * the image is the same as the original one at any time.
2043 */
2044 if (!unsafe) {
2045 uint64_t num_sectors;
2046 uint64_t old_backing_num_sectors;
2047 uint64_t new_backing_num_sectors = 0;
2048 uint64_t sector;
2049 int n;
2050 uint8_t * buf_old;
2051 uint8_t * buf_new;
2052 float local_progress = 0;
2053
2054 buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
2055 buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
2056
2057 bdrv_get_geometry(bs, &num_sectors);
2058 bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
2059 if (bs_new_backing) {
2060 bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);
2061 }
2062
2063 if (num_sectors != 0) {
2064 local_progress = (float)100 /
2065 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
2066 }
2067
2068 for (sector = 0; sector < num_sectors; sector += n) {
2069
2070 /* How many sectors can we handle with the next read? */
2071 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
2072 n = (IO_BUF_SIZE / 512);
2073 } else {
2074 n = num_sectors - sector;
2075 }
2076
2077 /* If the cluster is allocated, we don't need to take action */
2078 ret = bdrv_is_allocated(bs, sector, n, &n);
2079 if (ret) {
2080 continue;
2081 }
2082
2083 /*
2084 * Read old and new backing file and take into consideration that
2085 * backing files may be smaller than the COW image.
2086 */
2087 if (sector >= old_backing_num_sectors) {
2088 memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
2089 } else {
2090 if (sector + n > old_backing_num_sectors) {
2091 n = old_backing_num_sectors - sector;
2092 }
2093
2094 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
2095 if (ret < 0) {
2096 error_report("error while reading from old backing file");
2097 goto out;
2098 }
2099 }
2100
2101 if (sector >= new_backing_num_sectors || !bs_new_backing) {
2102 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
2103 } else {
2104 if (sector + n > new_backing_num_sectors) {
2105 n = new_backing_num_sectors - sector;
2106 }
2107
2108 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
2109 if (ret < 0) {
2110 error_report("error while reading from new backing file");
2111 goto out;
2112 }
2113 }
2114
2115 /* If they differ, we need to write to the COW file */
2116 uint64_t written = 0;
2117
2118 while (written < n) {
2119 int pnum;
2120
2121 if (compare_sectors(buf_old + written * 512,
2122 buf_new + written * 512, n - written, &pnum))
2123 {
2124 ret = bdrv_write(bs, sector + written,
2125 buf_old + written * 512, pnum);
2126 if (ret < 0) {
2127 error_report("Error while writing to COW image: %s",
2128 strerror(-ret));
2129 goto out;
2130 }
2131 }
2132
2133 written += pnum;
2134 }
2135 qemu_progress_print(local_progress, 100);
2136 }
2137
2138 qemu_vfree(buf_old);
2139 qemu_vfree(buf_new);
2140 }
2141
2142 /*
2143 * Change the backing file. All clusters that are different from the old
2144 * backing file are overwritten in the COW file now, so the visible content
2145 * doesn't change when we switch the backing file.
2146 */
2147 if (out_baseimg && *out_baseimg) {
2148 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
2149 } else {
2150 ret = bdrv_change_backing_file(bs, NULL, NULL);
2151 }
2152
2153 if (ret == -ENOSPC) {
2154 error_report("Could not change the backing file to '%s': No "
2155 "space left in the file header", out_baseimg);
2156 } else if (ret < 0) {
2157 error_report("Could not change the backing file to '%s': %s",
2158 out_baseimg, strerror(-ret));
2159 }
2160
2161 qemu_progress_print(100, 0);
2162 /*
2163 * TODO At this point it is possible to check if any clusters that are
2164 * allocated in the COW file are the same in the backing file. If so, they
2165 * could be dropped from the COW file. Don't do this before switching the
2166 * backing file, in case of a crash this would lead to corruption.
2167 */
2168 out:
2169 qemu_progress_end();
2170 /* Cleanup */
2171 if (!unsafe) {
2172 if (bs_old_backing != NULL) {
2173 bdrv_delete(bs_old_backing);
2174 }
2175 if (bs_new_backing != NULL) {
2176 bdrv_delete(bs_new_backing);
2177 }
2178 }
2179
2180 bdrv_delete(bs);
2181 if (ret) {
2182 return 1;
2183 }
2184 return 0;
2185 }
2186
2187 static int img_resize(int argc, char **argv)
2188 {
2189 int c, ret, relative;
2190 const char *filename, *fmt, *size;
2191 int64_t n, total_size;
2192 bool quiet = false;
2193 BlockDriverState *bs = NULL;
2194 QemuOpts *param;
2195 static QemuOptsList resize_options = {
2196 .name = "resize_options",
2197 .head = QTAILQ_HEAD_INITIALIZER(resize_options.head),
2198 .desc = {
2199 {
2200 .name = BLOCK_OPT_SIZE,
2201 .type = QEMU_OPT_SIZE,
2202 .help = "Virtual disk size"
2203 }, {
2204 /* end of list */
2205 }
2206 },
2207 };
2208
2209 /* Remove size from argv manually so that negative numbers are not treated
2210 * as options by getopt. */
2211 if (argc < 3) {
2212 help();
2213 return 1;
2214 }
2215
2216 size = argv[--argc];
2217
2218 /* Parse getopt arguments */
2219 fmt = NULL;
2220 for(;;) {
2221 c = getopt(argc, argv, "f:hq");
2222 if (c == -1) {
2223 break;
2224 }
2225 switch(c) {
2226 case '?':
2227 case 'h':
2228 help();
2229 break;
2230 case 'f':
2231 fmt = optarg;
2232 break;
2233 case 'q':
2234 quiet = true;
2235 break;
2236 }
2237 }
2238 if (optind != argc - 1) {
2239 help();
2240 }
2241 filename = argv[optind++];
2242
2243 /* Choose grow, shrink, or absolute resize mode */
2244 switch (size[0]) {
2245 case '+':
2246 relative = 1;
2247 size++;
2248 break;
2249 case '-':
2250 relative = -1;
2251 size++;
2252 break;
2253 default:
2254 relative = 0;
2255 break;
2256 }
2257
2258 /* Parse size */
2259 param = qemu_opts_create_nofail(&resize_options);
2260 if (qemu_opt_set(param, BLOCK_OPT_SIZE, size)) {
2261 /* Error message already printed when size parsing fails */
2262 ret = -1;
2263 qemu_opts_del(param);
2264 goto out;
2265 }
2266 n = qemu_opt_get_size(param, BLOCK_OPT_SIZE, 0);
2267 qemu_opts_del(param);
2268
2269 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR, true, quiet);
2270 if (!bs) {
2271 ret = -1;
2272 goto out;
2273 }
2274
2275 if (relative) {
2276 total_size = bdrv_getlength(bs) + n * relative;
2277 } else {
2278 total_size = n;
2279 }
2280 if (total_size <= 0) {
2281 error_report("New image size must be positive");
2282 ret = -1;
2283 goto out;
2284 }
2285
2286 ret = bdrv_truncate(bs, total_size);
2287 switch (ret) {
2288 case 0:
2289 qprintf(quiet, "Image resized.\n");
2290 break;
2291 case -ENOTSUP:
2292 error_report("This image does not support resize");
2293 break;
2294 case -EACCES:
2295 error_report("Image is read-only");
2296 break;
2297 default:
2298 error_report("Error resizing image (%d)", -ret);
2299 break;
2300 }
2301 out:
2302 if (bs) {
2303 bdrv_delete(bs);
2304 }
2305 if (ret) {
2306 return 1;
2307 }
2308 return 0;
2309 }
2310
2311 static const img_cmd_t img_cmds[] = {
2312 #define DEF(option, callback, arg_string) \
2313 { option, callback },
2314 #include "qemu-img-cmds.h"
2315 #undef DEF
2316 #undef GEN_DOCS
2317 { NULL, NULL, },
2318 };
2319
2320 int main(int argc, char **argv)
2321 {
2322 const img_cmd_t *cmd;
2323 const char *cmdname;
2324
2325 #ifdef CONFIG_POSIX
2326 signal(SIGPIPE, SIG_IGN);
2327 #endif
2328
2329 error_set_progname(argv[0]);
2330
2331 qemu_init_main_loop();
2332 bdrv_init();
2333 if (argc < 2)
2334 help();
2335 cmdname = argv[1];
2336 argc--; argv++;
2337
2338 /* find the command */
2339 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
2340 if (!strcmp(cmdname, cmd->name)) {
2341 return cmd->handler(argc, argv);
2342 }
2343 }
2344
2345 /* not found */
2346 help();
2347 return 0;
2348 }
AR7 emulation for QEMU