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