]> git.proxmox.com Git - qemu.git/blob - qemu-img.c
Merge branch 'stable-0.15' of git://git.qemu.org/qemu
[qemu.git] / qemu-img.c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu-common.h"
25 #include "qemu-option.h"
26 #include "qemu-error.h"
27 #include "osdep.h"
28 #include "sysemu.h"
29 #include "block_int.h"
30 #include <stdio.h>
31
32 #ifdef _WIN32
33 #include <windows.h>
34 #endif
35
36 typedef struct img_cmd_t {
37 const char *name;
38 int (*handler)(int argc, char **argv);
39 } img_cmd_t;
40
41 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
42 #define BDRV_O_FLAGS BDRV_O_CACHE_WB
43 #define BDRV_DEFAULT_CACHE "writeback"
44
45 static void format_print(void *opaque, const char *name)
46 {
47 printf(" %s", name);
48 }
49
50 /* Please keep in synch with qemu-img.texi */
51 static void help(void)
52 {
53 const char *help_msg =
54 "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
55 "usage: qemu-img command [command options]\n"
56 "QEMU disk image utility\n"
57 "\n"
58 "Command syntax:\n"
59 #define DEF(option, callback, arg_string) \
60 " " arg_string "\n"
61 #include "qemu-img-cmds.h"
62 #undef DEF
63 #undef GEN_DOCS
64 "\n"
65 "Command parameters:\n"
66 " 'filename' is a disk image filename\n"
67 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
68 " 'cache' is the cache mode used to write the output disk image, the valid\n"
69 " options are: 'none', 'writeback' (default), 'writethrough' and 'unsafe'\n"
70 " 'size' is the disk image size in bytes. Optional suffixes\n"
71 " 'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
72 " and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
73 " 'output_filename' is the destination disk image filename\n"
74 " 'output_fmt' is the destination format\n"
75 " 'options' is a comma separated list of format specific options in a\n"
76 " name=value format. Use -o ? for an overview of the options supported by the\n"
77 " used format\n"
78 " '-c' indicates that target image must be compressed (qcow format only)\n"
79 " '-u' enables unsafe rebasing. It is assumed that old and new backing file\n"
80 " match exactly. The image doesn't need a working backing file before\n"
81 " rebasing in this case (useful for renaming the backing file)\n"
82 " '-h' with or without a command shows this help and lists the supported formats\n"
83 " '-p' show progress of command (only certain commands)\n"
84 "\n"
85 "Parameters to snapshot subcommand:\n"
86 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
87 " '-a' applies a snapshot (revert disk to saved state)\n"
88 " '-c' creates a snapshot\n"
89 " '-d' deletes a snapshot\n"
90 " '-l' lists all snapshots in the given image\n";
91
92 printf("%s\nSupported formats:", help_msg);
93 bdrv_iterate_format(format_print, NULL);
94 printf("\n");
95 exit(1);
96 }
97
98 #if defined(WIN32)
99 /* XXX: put correct support for win32 */
100 static int read_password(char *buf, int buf_size)
101 {
102 int c, i;
103 printf("Password: ");
104 fflush(stdout);
105 i = 0;
106 for(;;) {
107 c = getchar();
108 if (c == '\n')
109 break;
110 if (i < (buf_size - 1))
111 buf[i++] = c;
112 }
113 buf[i] = '\0';
114 return 0;
115 }
116
117 #else
118
119 #include <termios.h>
120
121 static struct termios oldtty;
122
123 static void term_exit(void)
124 {
125 tcsetattr (0, TCSANOW, &oldtty);
126 }
127
128 static void term_init(void)
129 {
130 struct termios tty;
131
132 tcgetattr (0, &tty);
133 oldtty = tty;
134
135 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
136 |INLCR|IGNCR|ICRNL|IXON);
137 tty.c_oflag |= OPOST;
138 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
139 tty.c_cflag &= ~(CSIZE|PARENB);
140 tty.c_cflag |= CS8;
141 tty.c_cc[VMIN] = 1;
142 tty.c_cc[VTIME] = 0;
143
144 tcsetattr (0, TCSANOW, &tty);
145
146 atexit(term_exit);
147 }
148
149 static int read_password(char *buf, int buf_size)
150 {
151 uint8_t ch;
152 int i, ret;
153
154 printf("password: ");
155 fflush(stdout);
156 term_init();
157 i = 0;
158 for(;;) {
159 ret = read(0, &ch, 1);
160 if (ret == -1) {
161 if (errno == EAGAIN || errno == EINTR) {
162 continue;
163 } else {
164 ret = -1;
165 break;
166 }
167 } else if (ret == 0) {
168 ret = -1;
169 break;
170 } else {
171 if (ch == '\r') {
172 ret = 0;
173 break;
174 }
175 if (i < (buf_size - 1))
176 buf[i++] = ch;
177 }
178 }
179 term_exit();
180 buf[i] = '\0';
181 printf("\n");
182 return ret;
183 }
184 #endif
185
186 static int set_cache_flag(const char *mode, int *flags)
187 {
188 *flags &= ~BDRV_O_CACHE_MASK;
189
190 if (!strcmp(mode, "none") || !strcmp(mode, "off")) {
191 *flags |= BDRV_O_CACHE_WB;
192 *flags |= BDRV_O_NOCACHE;
193 } else if (!strcmp(mode, "writeback")) {
194 *flags |= BDRV_O_CACHE_WB;
195 } else if (!strcmp(mode, "unsafe")) {
196 *flags |= BDRV_O_CACHE_WB;
197 *flags |= BDRV_O_NO_FLUSH;
198 } else if (!strcmp(mode, "writethrough")) {
199 /* this is the default */
200 } else {
201 return -1;
202 }
203
204 return 0;
205 }
206
207 static int print_block_option_help(const char *filename, const char *fmt)
208 {
209 BlockDriver *drv, *proto_drv;
210 QEMUOptionParameter *create_options = NULL;
211
212 /* Find driver and parse its options */
213 drv = bdrv_find_format(fmt);
214 if (!drv) {
215 error_report("Unknown file format '%s'", fmt);
216 return 1;
217 }
218
219 proto_drv = bdrv_find_protocol(filename);
220 if (!proto_drv) {
221 error_report("Unknown protocol '%s'", filename);
222 return 1;
223 }
224
225 create_options = append_option_parameters(create_options,
226 drv->create_options);
227 create_options = append_option_parameters(create_options,
228 proto_drv->create_options);
229 print_option_help(create_options);
230 free_option_parameters(create_options);
231 return 0;
232 }
233
234 static BlockDriverState *bdrv_new_open(const char *filename,
235 const char *fmt,
236 int flags)
237 {
238 BlockDriverState *bs;
239 BlockDriver *drv;
240 char password[256];
241 int ret;
242
243 bs = bdrv_new("image");
244
245 if (fmt) {
246 drv = bdrv_find_format(fmt);
247 if (!drv) {
248 error_report("Unknown file format '%s'", fmt);
249 goto fail;
250 }
251 } else {
252 drv = NULL;
253 }
254
255 ret = bdrv_open(bs, filename, flags, drv);
256 if (ret < 0) {
257 error_report("Could not open '%s': %s", filename, strerror(-ret));
258 goto fail;
259 }
260
261 if (bdrv_is_encrypted(bs)) {
262 printf("Disk image '%s' is encrypted.\n", filename);
263 if (read_password(password, sizeof(password)) < 0) {
264 error_report("No password given");
265 goto fail;
266 }
267 if (bdrv_set_key(bs, password) < 0) {
268 error_report("invalid password");
269 goto fail;
270 }
271 }
272 return bs;
273 fail:
274 if (bs) {
275 bdrv_delete(bs);
276 }
277 return NULL;
278 }
279
280 static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
281 const char *base_filename,
282 const char *base_fmt)
283 {
284 if (base_filename) {
285 if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
286 error_report("Backing file not supported for file format '%s'",
287 fmt);
288 return -1;
289 }
290 }
291 if (base_fmt) {
292 if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
293 error_report("Backing file format not supported for file "
294 "format '%s'", fmt);
295 return -1;
296 }
297 }
298 return 0;
299 }
300
301 static int img_create(int argc, char **argv)
302 {
303 int c, ret = 0;
304 uint64_t img_size = -1;
305 const char *fmt = "raw";
306 const char *base_fmt = NULL;
307 const char *filename;
308 const char *base_filename = NULL;
309 char *options = NULL;
310
311 for(;;) {
312 c = getopt(argc, argv, "F:b:f:he6o:");
313 if (c == -1) {
314 break;
315 }
316 switch(c) {
317 case '?':
318 case 'h':
319 help();
320 break;
321 case 'F':
322 base_fmt = optarg;
323 break;
324 case 'b':
325 base_filename = optarg;
326 break;
327 case 'f':
328 fmt = optarg;
329 break;
330 case 'e':
331 error_report("option -e is deprecated, please use \'-o "
332 "encryption\' instead!");
333 return 1;
334 case '6':
335 error_report("option -6 is deprecated, please use \'-o "
336 "compat6\' instead!");
337 return 1;
338 case 'o':
339 options = optarg;
340 break;
341 }
342 }
343
344 /* Get the filename */
345 if (optind >= argc) {
346 help();
347 }
348 filename = argv[optind++];
349
350 /* Get image size, if specified */
351 if (optind < argc) {
352 int64_t sval;
353 sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
354 if (sval < 0) {
355 error_report("Invalid image size specified! You may use k, M, G or "
356 "T suffixes for ");
357 error_report("kilobytes, megabytes, gigabytes and terabytes.");
358 ret = -1;
359 goto out;
360 }
361 img_size = (uint64_t)sval;
362 }
363
364 if (options && !strcmp(options, "?")) {
365 ret = print_block_option_help(filename, fmt);
366 goto out;
367 }
368
369 ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
370 options, img_size, BDRV_O_FLAGS);
371 out:
372 if (ret) {
373 return 1;
374 }
375 return 0;
376 }
377
378 /*
379 * Checks an image for consistency. Exit codes:
380 *
381 * 0 - Check completed, image is good
382 * 1 - Check not completed because of internal errors
383 * 2 - Check completed, image is corrupted
384 * 3 - Check completed, image has leaked clusters, but is good otherwise
385 */
386 static int img_check(int argc, char **argv)
387 {
388 int c, ret;
389 const char *filename, *fmt;
390 BlockDriverState *bs;
391 BdrvCheckResult result;
392
393 fmt = NULL;
394 for(;;) {
395 c = getopt(argc, argv, "f:h");
396 if (c == -1) {
397 break;
398 }
399 switch(c) {
400 case '?':
401 case 'h':
402 help();
403 break;
404 case 'f':
405 fmt = optarg;
406 break;
407 }
408 }
409 if (optind >= argc) {
410 help();
411 }
412 filename = argv[optind++];
413
414 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
415 if (!bs) {
416 return 1;
417 }
418 ret = bdrv_check(bs, &result);
419
420 if (ret == -ENOTSUP) {
421 error_report("This image format does not support checks");
422 bdrv_delete(bs);
423 return 1;
424 }
425
426 if (!(result.corruptions || result.leaks || result.check_errors)) {
427 printf("No errors were found on the image.\n");
428 } else {
429 if (result.corruptions) {
430 printf("\n%d errors were found on the image.\n"
431 "Data may be corrupted, or further writes to the image "
432 "may corrupt it.\n",
433 result.corruptions);
434 }
435
436 if (result.leaks) {
437 printf("\n%d leaked clusters were found on the image.\n"
438 "This means waste of disk space, but no harm to data.\n",
439 result.leaks);
440 }
441
442 if (result.check_errors) {
443 printf("\n%d internal errors have occurred during the check.\n",
444 result.check_errors);
445 }
446 }
447
448 bdrv_delete(bs);
449
450 if (ret < 0 || result.check_errors) {
451 printf("\nAn error has occurred during the check: %s\n"
452 "The check is not complete and may have missed error.\n",
453 strerror(-ret));
454 return 1;
455 }
456
457 if (result.corruptions) {
458 return 2;
459 } else if (result.leaks) {
460 return 3;
461 } else {
462 return 0;
463 }
464 }
465
466 static int img_commit(int argc, char **argv)
467 {
468 int c, ret, flags;
469 const char *filename, *fmt, *cache;
470 BlockDriverState *bs;
471
472 fmt = NULL;
473 cache = BDRV_DEFAULT_CACHE;
474 for(;;) {
475 c = getopt(argc, argv, "f:ht:");
476 if (c == -1) {
477 break;
478 }
479 switch(c) {
480 case '?':
481 case 'h':
482 help();
483 break;
484 case 'f':
485 fmt = optarg;
486 break;
487 case 't':
488 cache = optarg;
489 break;
490 }
491 }
492 if (optind >= argc) {
493 help();
494 }
495 filename = argv[optind++];
496
497 flags = BDRV_O_RDWR;
498 ret = set_cache_flag(cache, &flags);
499 if (ret < 0) {
500 error_report("Invalid cache option: %s", cache);
501 return -1;
502 }
503
504 bs = bdrv_new_open(filename, fmt, flags);
505 if (!bs) {
506 return 1;
507 }
508 ret = bdrv_commit(bs);
509 switch(ret) {
510 case 0:
511 printf("Image committed.\n");
512 break;
513 case -ENOENT:
514 error_report("No disk inserted");
515 break;
516 case -EACCES:
517 error_report("Image is read-only");
518 break;
519 case -ENOTSUP:
520 error_report("Image is already committed");
521 break;
522 default:
523 error_report("Error while committing image");
524 break;
525 }
526
527 bdrv_delete(bs);
528 if (ret) {
529 return 1;
530 }
531 return 0;
532 }
533
534 /*
535 * Checks whether the sector is not a zero sector.
536 *
537 * Attention! The len must be a multiple of 4 * sizeof(long) due to
538 * restriction of optimizations in this function.
539 */
540 static int is_not_zero(const uint8_t *sector, int len)
541 {
542 /*
543 * Use long as the biggest available internal data type that fits into the
544 * CPU register and unroll the loop to smooth out the effect of memory
545 * latency.
546 */
547
548 int i;
549 long d0, d1, d2, d3;
550 const long * const data = (const long *) sector;
551
552 len /= sizeof(long);
553
554 for(i = 0; i < len; i += 4) {
555 d0 = data[i + 0];
556 d1 = data[i + 1];
557 d2 = data[i + 2];
558 d3 = data[i + 3];
559
560 if (d0 || d1 || d2 || d3) {
561 return 1;
562 }
563 }
564
565 return 0;
566 }
567
568 /*
569 * Returns true iff the first sector pointed to by 'buf' contains at least
570 * a non-NUL byte.
571 *
572 * 'pnum' is set to the number of sectors (including and immediately following
573 * the first one) that are known to be in the same allocated/unallocated state.
574 */
575 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
576 {
577 int v, i;
578
579 if (n <= 0) {
580 *pnum = 0;
581 return 0;
582 }
583 v = is_not_zero(buf, 512);
584 for(i = 1; i < n; i++) {
585 buf += 512;
586 if (v != is_not_zero(buf, 512))
587 break;
588 }
589 *pnum = i;
590 return v;
591 }
592
593 /*
594 * Compares two buffers sector by sector. Returns 0 if the first sector of both
595 * buffers matches, non-zero otherwise.
596 *
597 * pnum is set to the number of sectors (including and immediately following
598 * the first one) that are known to have the same comparison result
599 */
600 static int compare_sectors(const uint8_t *buf1, const uint8_t *buf2, int n,
601 int *pnum)
602 {
603 int res, i;
604
605 if (n <= 0) {
606 *pnum = 0;
607 return 0;
608 }
609
610 res = !!memcmp(buf1, buf2, 512);
611 for(i = 1; i < n; i++) {
612 buf1 += 512;
613 buf2 += 512;
614
615 if (!!memcmp(buf1, buf2, 512) != res) {
616 break;
617 }
618 }
619
620 *pnum = i;
621 return res;
622 }
623
624 #define IO_BUF_SIZE (2 * 1024 * 1024)
625
626 static int img_convert(int argc, char **argv)
627 {
628 int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
629 int progress = 0, flags;
630 const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
631 BlockDriver *drv, *proto_drv;
632 BlockDriverState **bs = NULL, *out_bs = NULL;
633 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
634 uint64_t bs_sectors;
635 uint8_t * buf = NULL;
636 const uint8_t *buf1;
637 BlockDriverInfo bdi;
638 QEMUOptionParameter *param = NULL, *create_options = NULL;
639 QEMUOptionParameter *out_baseimg_param;
640 char *options = NULL;
641 const char *snapshot_name = NULL;
642 float local_progress;
643
644 fmt = NULL;
645 out_fmt = "raw";
646 cache = "unsafe";
647 out_baseimg = NULL;
648 compress = 0;
649 for(;;) {
650 c = getopt(argc, argv, "f:O:B:s:hce6o:pt:");
651 if (c == -1) {
652 break;
653 }
654 switch(c) {
655 case '?':
656 case 'h':
657 help();
658 break;
659 case 'f':
660 fmt = optarg;
661 break;
662 case 'O':
663 out_fmt = optarg;
664 break;
665 case 'B':
666 out_baseimg = optarg;
667 break;
668 case 'c':
669 compress = 1;
670 break;
671 case 'e':
672 error_report("option -e is deprecated, please use \'-o "
673 "encryption\' instead!");
674 return 1;
675 case '6':
676 error_report("option -6 is deprecated, please use \'-o "
677 "compat6\' instead!");
678 return 1;
679 case 'o':
680 options = optarg;
681 break;
682 case 's':
683 snapshot_name = optarg;
684 break;
685 case 'p':
686 progress = 1;
687 break;
688 case 't':
689 cache = optarg;
690 break;
691 }
692 }
693
694 bs_n = argc - optind - 1;
695 if (bs_n < 1) {
696 help();
697 }
698
699 out_filename = argv[argc - 1];
700
701 if (options && !strcmp(options, "?")) {
702 ret = print_block_option_help(out_filename, out_fmt);
703 goto out;
704 }
705
706 if (bs_n > 1 && out_baseimg) {
707 error_report("-B makes no sense when concatenating multiple input "
708 "images");
709 ret = -1;
710 goto out;
711 }
712
713 qemu_progress_init(progress, 2.0);
714 qemu_progress_print(0, 100);
715
716 bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
717
718 total_sectors = 0;
719 for (bs_i = 0; bs_i < bs_n; bs_i++) {
720 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
721 if (!bs[bs_i]) {
722 error_report("Could not open '%s'", argv[optind + bs_i]);
723 ret = -1;
724 goto out;
725 }
726 bdrv_get_geometry(bs[bs_i], &bs_sectors);
727 total_sectors += bs_sectors;
728 }
729
730 if (snapshot_name != NULL) {
731 if (bs_n > 1) {
732 error_report("No support for concatenating multiple snapshot");
733 ret = -1;
734 goto out;
735 }
736 if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
737 error_report("Failed to load snapshot");
738 ret = -1;
739 goto out;
740 }
741 }
742
743 /* Find driver and parse its options */
744 drv = bdrv_find_format(out_fmt);
745 if (!drv) {
746 error_report("Unknown file format '%s'", out_fmt);
747 ret = -1;
748 goto out;
749 }
750
751 proto_drv = bdrv_find_protocol(out_filename);
752 if (!proto_drv) {
753 error_report("Unknown protocol '%s'", out_filename);
754 ret = -1;
755 goto out;
756 }
757
758 create_options = append_option_parameters(create_options,
759 drv->create_options);
760 create_options = append_option_parameters(create_options,
761 proto_drv->create_options);
762
763 if (options) {
764 param = parse_option_parameters(options, create_options, param);
765 if (param == NULL) {
766 error_report("Invalid options for file format '%s'.", out_fmt);
767 ret = -1;
768 goto out;
769 }
770 } else {
771 param = parse_option_parameters("", create_options, param);
772 }
773
774 set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
775 ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
776 if (ret < 0) {
777 goto out;
778 }
779
780 /* Get backing file name if -o backing_file was used */
781 out_baseimg_param = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
782 if (out_baseimg_param) {
783 out_baseimg = out_baseimg_param->value.s;
784 }
785
786 /* Check if compression is supported */
787 if (compress) {
788 QEMUOptionParameter *encryption =
789 get_option_parameter(param, BLOCK_OPT_ENCRYPT);
790
791 if (!drv->bdrv_write_compressed) {
792 error_report("Compression not supported for this file format");
793 ret = -1;
794 goto out;
795 }
796
797 if (encryption && encryption->value.n) {
798 error_report("Compression and encryption not supported at "
799 "the same time");
800 ret = -1;
801 goto out;
802 }
803 }
804
805 /* Create the new image */
806 ret = bdrv_create(drv, out_filename, param);
807 if (ret < 0) {
808 if (ret == -ENOTSUP) {
809 error_report("Formatting not supported for file format '%s'",
810 out_fmt);
811 } else if (ret == -EFBIG) {
812 error_report("The image size is too large for file format '%s'",
813 out_fmt);
814 } else {
815 error_report("%s: error while converting %s: %s",
816 out_filename, out_fmt, strerror(-ret));
817 }
818 goto out;
819 }
820
821 flags = BDRV_O_RDWR;
822 ret = set_cache_flag(cache, &flags);
823 if (ret < 0) {
824 error_report("Invalid cache option: %s", cache);
825 return -1;
826 }
827
828 out_bs = bdrv_new_open(out_filename, out_fmt, flags);
829 if (!out_bs) {
830 ret = -1;
831 goto out;
832 }
833
834 bs_i = 0;
835 bs_offset = 0;
836 bdrv_get_geometry(bs[0], &bs_sectors);
837 buf = qemu_malloc(IO_BUF_SIZE);
838
839 if (compress) {
840 ret = bdrv_get_info(out_bs, &bdi);
841 if (ret < 0) {
842 error_report("could not get block driver info");
843 goto out;
844 }
845 cluster_size = bdi.cluster_size;
846 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
847 error_report("invalid cluster size");
848 ret = -1;
849 goto out;
850 }
851 cluster_sectors = cluster_size >> 9;
852 sector_num = 0;
853
854 nb_sectors = total_sectors;
855 local_progress = (float)100 /
856 (nb_sectors / MIN(nb_sectors, cluster_sectors));
857
858 for(;;) {
859 int64_t bs_num;
860 int remainder;
861 uint8_t *buf2;
862
863 nb_sectors = total_sectors - sector_num;
864 if (nb_sectors <= 0)
865 break;
866 if (nb_sectors >= cluster_sectors)
867 n = cluster_sectors;
868 else
869 n = nb_sectors;
870
871 bs_num = sector_num - bs_offset;
872 assert (bs_num >= 0);
873 remainder = n;
874 buf2 = buf;
875 while (remainder > 0) {
876 int nlow;
877 while (bs_num == bs_sectors) {
878 bs_i++;
879 assert (bs_i < bs_n);
880 bs_offset += bs_sectors;
881 bdrv_get_geometry(bs[bs_i], &bs_sectors);
882 bs_num = 0;
883 /* printf("changing part: sector_num=%" PRId64 ", "
884 "bs_i=%d, bs_offset=%" PRId64 ", bs_sectors=%" PRId64
885 "\n", sector_num, bs_i, bs_offset, bs_sectors); */
886 }
887 assert (bs_num < bs_sectors);
888
889 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
890
891 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
892 if (ret < 0) {
893 error_report("error while reading");
894 goto out;
895 }
896
897 buf2 += nlow * 512;
898 bs_num += nlow;
899
900 remainder -= nlow;
901 }
902 assert (remainder == 0);
903
904 if (n < cluster_sectors) {
905 memset(buf + n * 512, 0, cluster_size - n * 512);
906 }
907 if (is_not_zero(buf, cluster_size)) {
908 ret = bdrv_write_compressed(out_bs, sector_num, buf,
909 cluster_sectors);
910 if (ret != 0) {
911 error_report("error while compressing sector %" PRId64,
912 sector_num);
913 goto out;
914 }
915 }
916 sector_num += n;
917 qemu_progress_print(local_progress, 100);
918 }
919 /* signal EOF to align */
920 bdrv_write_compressed(out_bs, 0, NULL, 0);
921 } else {
922 int has_zero_init = bdrv_has_zero_init(out_bs);
923
924 sector_num = 0; // total number of sectors converted so far
925 nb_sectors = total_sectors - sector_num;
926 local_progress = (float)100 /
927 (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
928
929 for(;;) {
930 nb_sectors = total_sectors - sector_num;
931 if (nb_sectors <= 0) {
932 break;
933 }
934 if (nb_sectors >= (IO_BUF_SIZE / 512)) {
935 n = (IO_BUF_SIZE / 512);
936 } else {
937 n = nb_sectors;
938 }
939
940 while (sector_num - bs_offset >= bs_sectors) {
941 bs_i ++;
942 assert (bs_i < bs_n);
943 bs_offset += bs_sectors;
944 bdrv_get_geometry(bs[bs_i], &bs_sectors);
945 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
946 "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
947 sector_num, bs_i, bs_offset, bs_sectors); */
948 }
949
950 if (n > bs_offset + bs_sectors - sector_num) {
951 n = bs_offset + bs_sectors - sector_num;
952 }
953
954 if (has_zero_init) {
955 /* If the output image is being created as a copy on write image,
956 assume that sectors which are unallocated in the input image
957 are present in both the output's and input's base images (no
958 need to copy them). */
959 if (out_baseimg) {
960 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
961 n, &n1)) {
962 sector_num += n1;
963 continue;
964 }
965 /* The next 'n1' sectors are allocated in the input image. Copy
966 only those as they may be followed by unallocated sectors. */
967 n = n1;
968 }
969 } else {
970 n1 = n;
971 }
972
973 ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
974 if (ret < 0) {
975 error_report("error while reading");
976 goto out;
977 }
978 /* NOTE: at the same time we convert, we do not write zero
979 sectors to have a chance to compress the image. Ideally, we
980 should add a specific call to have the info to go faster */
981 buf1 = buf;
982 while (n > 0) {
983 /* If the output image is being created as a copy on write image,
984 copy all sectors even the ones containing only NUL bytes,
985 because they may differ from the sectors in the base image.
986
987 If the output is to a host device, we also write out
988 sectors that are entirely 0, since whatever data was
989 already there is garbage, not 0s. */
990 if (!has_zero_init || out_baseimg ||
991 is_allocated_sectors(buf1, n, &n1)) {
992 ret = bdrv_write(out_bs, sector_num, buf1, n1);
993 if (ret < 0) {
994 error_report("error while writing");
995 goto out;
996 }
997 }
998 sector_num += n1;
999 n -= n1;
1000 buf1 += n1 * 512;
1001 }
1002 qemu_progress_print(local_progress, 100);
1003 }
1004 }
1005 out:
1006 qemu_progress_end();
1007 free_option_parameters(create_options);
1008 free_option_parameters(param);
1009 qemu_free(buf);
1010 if (out_bs) {
1011 bdrv_delete(out_bs);
1012 }
1013 if (bs) {
1014 for (bs_i = 0; bs_i < bs_n; bs_i++) {
1015 if (bs[bs_i]) {
1016 bdrv_delete(bs[bs_i]);
1017 }
1018 }
1019 qemu_free(bs);
1020 }
1021 if (ret) {
1022 return 1;
1023 }
1024 return 0;
1025 }
1026
1027
1028 static void dump_snapshots(BlockDriverState *bs)
1029 {
1030 QEMUSnapshotInfo *sn_tab, *sn;
1031 int nb_sns, i;
1032 char buf[256];
1033
1034 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
1035 if (nb_sns <= 0)
1036 return;
1037 printf("Snapshot list:\n");
1038 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
1039 for(i = 0; i < nb_sns; i++) {
1040 sn = &sn_tab[i];
1041 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
1042 }
1043 qemu_free(sn_tab);
1044 }
1045
1046 static int img_info(int argc, char **argv)
1047 {
1048 int c;
1049 const char *filename, *fmt;
1050 BlockDriverState *bs;
1051 char fmt_name[128], size_buf[128], dsize_buf[128];
1052 uint64_t total_sectors;
1053 int64_t allocated_size;
1054 char backing_filename[1024];
1055 char backing_filename2[1024];
1056 BlockDriverInfo bdi;
1057
1058 fmt = NULL;
1059 for(;;) {
1060 c = getopt(argc, argv, "f:h");
1061 if (c == -1) {
1062 break;
1063 }
1064 switch(c) {
1065 case '?':
1066 case 'h':
1067 help();
1068 break;
1069 case 'f':
1070 fmt = optarg;
1071 break;
1072 }
1073 }
1074 if (optind >= argc) {
1075 help();
1076 }
1077 filename = argv[optind++];
1078
1079 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1080 if (!bs) {
1081 return 1;
1082 }
1083 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
1084 bdrv_get_geometry(bs, &total_sectors);
1085 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
1086 allocated_size = bdrv_get_allocated_file_size(bs);
1087 if (allocated_size < 0) {
1088 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1089 } else {
1090 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1091 allocated_size);
1092 }
1093 printf("image: %s\n"
1094 "file format: %s\n"
1095 "virtual size: %s (%" PRId64 " bytes)\n"
1096 "disk size: %s\n",
1097 filename, fmt_name, size_buf,
1098 (total_sectors * 512),
1099 dsize_buf);
1100 if (bdrv_is_encrypted(bs)) {
1101 printf("encrypted: yes\n");
1102 }
1103 if (bdrv_get_info(bs, &bdi) >= 0) {
1104 if (bdi.cluster_size != 0) {
1105 printf("cluster_size: %d\n", bdi.cluster_size);
1106 }
1107 }
1108 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
1109 if (backing_filename[0] != '\0') {
1110 path_combine(backing_filename2, sizeof(backing_filename2),
1111 filename, backing_filename);
1112 printf("backing file: %s (actual path: %s)\n",
1113 backing_filename,
1114 backing_filename2);
1115 }
1116 dump_snapshots(bs);
1117 bdrv_delete(bs);
1118 return 0;
1119 }
1120
1121 #define SNAPSHOT_LIST 1
1122 #define SNAPSHOT_CREATE 2
1123 #define SNAPSHOT_APPLY 3
1124 #define SNAPSHOT_DELETE 4
1125
1126 static int img_snapshot(int argc, char **argv)
1127 {
1128 BlockDriverState *bs;
1129 QEMUSnapshotInfo sn;
1130 char *filename, *snapshot_name = NULL;
1131 int c, ret = 0, bdrv_oflags;
1132 int action = 0;
1133 qemu_timeval tv;
1134
1135 bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1136 /* Parse commandline parameters */
1137 for(;;) {
1138 c = getopt(argc, argv, "la:c:d:h");
1139 if (c == -1) {
1140 break;
1141 }
1142 switch(c) {
1143 case '?':
1144 case 'h':
1145 help();
1146 return 0;
1147 case 'l':
1148 if (action) {
1149 help();
1150 return 0;
1151 }
1152 action = SNAPSHOT_LIST;
1153 bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1154 break;
1155 case 'a':
1156 if (action) {
1157 help();
1158 return 0;
1159 }
1160 action = SNAPSHOT_APPLY;
1161 snapshot_name = optarg;
1162 break;
1163 case 'c':
1164 if (action) {
1165 help();
1166 return 0;
1167 }
1168 action = SNAPSHOT_CREATE;
1169 snapshot_name = optarg;
1170 break;
1171 case 'd':
1172 if (action) {
1173 help();
1174 return 0;
1175 }
1176 action = SNAPSHOT_DELETE;
1177 snapshot_name = optarg;
1178 break;
1179 }
1180 }
1181
1182 if (optind >= argc) {
1183 help();
1184 }
1185 filename = argv[optind++];
1186
1187 /* Open the image */
1188 bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1189 if (!bs) {
1190 return 1;
1191 }
1192
1193 /* Perform the requested action */
1194 switch(action) {
1195 case SNAPSHOT_LIST:
1196 dump_snapshots(bs);
1197 break;
1198
1199 case SNAPSHOT_CREATE:
1200 memset(&sn, 0, sizeof(sn));
1201 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
1202
1203 qemu_gettimeofday(&tv);
1204 sn.date_sec = tv.tv_sec;
1205 sn.date_nsec = tv.tv_usec * 1000;
1206
1207 ret = bdrv_snapshot_create(bs, &sn);
1208 if (ret) {
1209 error_report("Could not create snapshot '%s': %d (%s)",
1210 snapshot_name, ret, strerror(-ret));
1211 }
1212 break;
1213
1214 case SNAPSHOT_APPLY:
1215 ret = bdrv_snapshot_goto(bs, snapshot_name);
1216 if (ret) {
1217 error_report("Could not apply snapshot '%s': %d (%s)",
1218 snapshot_name, ret, strerror(-ret));
1219 }
1220 break;
1221
1222 case SNAPSHOT_DELETE:
1223 ret = bdrv_snapshot_delete(bs, snapshot_name);
1224 if (ret) {
1225 error_report("Could not delete snapshot '%s': %d (%s)",
1226 snapshot_name, ret, strerror(-ret));
1227 }
1228 break;
1229 }
1230
1231 /* Cleanup */
1232 bdrv_delete(bs);
1233 if (ret) {
1234 return 1;
1235 }
1236 return 0;
1237 }
1238
1239 static int img_rebase(int argc, char **argv)
1240 {
1241 BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
1242 BlockDriver *old_backing_drv, *new_backing_drv;
1243 char *filename;
1244 const char *fmt, *cache, *out_basefmt, *out_baseimg;
1245 int c, flags, ret;
1246 int unsafe = 0;
1247 int progress = 0;
1248
1249 /* Parse commandline parameters */
1250 fmt = NULL;
1251 cache = BDRV_DEFAULT_CACHE;
1252 out_baseimg = NULL;
1253 out_basefmt = NULL;
1254 for(;;) {
1255 c = getopt(argc, argv, "uhf:F:b:pt:");
1256 if (c == -1) {
1257 break;
1258 }
1259 switch(c) {
1260 case '?':
1261 case 'h':
1262 help();
1263 return 0;
1264 case 'f':
1265 fmt = optarg;
1266 break;
1267 case 'F':
1268 out_basefmt = optarg;
1269 break;
1270 case 'b':
1271 out_baseimg = optarg;
1272 break;
1273 case 'u':
1274 unsafe = 1;
1275 break;
1276 case 'p':
1277 progress = 1;
1278 break;
1279 case 't':
1280 cache = optarg;
1281 break;
1282 }
1283 }
1284
1285 if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1286 help();
1287 }
1288 filename = argv[optind++];
1289
1290 qemu_progress_init(progress, 2.0);
1291 qemu_progress_print(0, 100);
1292
1293 flags = BDRV_O_RDWR | (unsafe ? BDRV_O_NO_BACKING : 0);
1294 ret = set_cache_flag(cache, &flags);
1295 if (ret < 0) {
1296 error_report("Invalid cache option: %s", cache);
1297 return -1;
1298 }
1299
1300 /*
1301 * Open the images.
1302 *
1303 * Ignore the old backing file for unsafe rebase in case we want to correct
1304 * the reference to a renamed or moved backing file.
1305 */
1306 bs = bdrv_new_open(filename, fmt, flags);
1307 if (!bs) {
1308 return 1;
1309 }
1310
1311 /* Find the right drivers for the backing files */
1312 old_backing_drv = NULL;
1313 new_backing_drv = NULL;
1314
1315 if (!unsafe && bs->backing_format[0] != '\0') {
1316 old_backing_drv = bdrv_find_format(bs->backing_format);
1317 if (old_backing_drv == NULL) {
1318 error_report("Invalid format name: '%s'", bs->backing_format);
1319 ret = -1;
1320 goto out;
1321 }
1322 }
1323
1324 if (out_basefmt != NULL) {
1325 new_backing_drv = bdrv_find_format(out_basefmt);
1326 if (new_backing_drv == NULL) {
1327 error_report("Invalid format name: '%s'", out_basefmt);
1328 ret = -1;
1329 goto out;
1330 }
1331 }
1332
1333 /* For safe rebasing we need to compare old and new backing file */
1334 if (unsafe) {
1335 /* Make the compiler happy */
1336 bs_old_backing = NULL;
1337 bs_new_backing = NULL;
1338 } else {
1339 char backing_name[1024];
1340
1341 bs_old_backing = bdrv_new("old_backing");
1342 bdrv_get_backing_filename(bs, backing_name, sizeof(backing_name));
1343 ret = bdrv_open(bs_old_backing, backing_name, BDRV_O_FLAGS,
1344 old_backing_drv);
1345 if (ret) {
1346 error_report("Could not open old backing file '%s'", backing_name);
1347 goto out;
1348 }
1349
1350 bs_new_backing = bdrv_new("new_backing");
1351 ret = bdrv_open(bs_new_backing, out_baseimg, BDRV_O_FLAGS,
1352 new_backing_drv);
1353 if (ret) {
1354 error_report("Could not open new backing file '%s'", out_baseimg);
1355 goto out;
1356 }
1357 }
1358
1359 /*
1360 * Check each unallocated cluster in the COW file. If it is unallocated,
1361 * accesses go to the backing file. We must therefore compare this cluster
1362 * in the old and new backing file, and if they differ we need to copy it
1363 * from the old backing file into the COW file.
1364 *
1365 * If qemu-img crashes during this step, no harm is done. The content of
1366 * the image is the same as the original one at any time.
1367 */
1368 if (!unsafe) {
1369 uint64_t num_sectors;
1370 uint64_t sector;
1371 int n;
1372 uint8_t * buf_old;
1373 uint8_t * buf_new;
1374 float local_progress;
1375
1376 buf_old = qemu_malloc(IO_BUF_SIZE);
1377 buf_new = qemu_malloc(IO_BUF_SIZE);
1378
1379 bdrv_get_geometry(bs, &num_sectors);
1380
1381 local_progress = (float)100 /
1382 (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1383 for (sector = 0; sector < num_sectors; sector += n) {
1384
1385 /* How many sectors can we handle with the next read? */
1386 if (sector + (IO_BUF_SIZE / 512) <= num_sectors) {
1387 n = (IO_BUF_SIZE / 512);
1388 } else {
1389 n = num_sectors - sector;
1390 }
1391
1392 /* If the cluster is allocated, we don't need to take action */
1393 ret = bdrv_is_allocated(bs, sector, n, &n);
1394 if (ret) {
1395 continue;
1396 }
1397
1398 /* Read old and new backing file */
1399 ret = bdrv_read(bs_old_backing, sector, buf_old, n);
1400 if (ret < 0) {
1401 error_report("error while reading from old backing file");
1402 goto out;
1403 }
1404 ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1405 if (ret < 0) {
1406 error_report("error while reading from new backing file");
1407 goto out;
1408 }
1409
1410 /* If they differ, we need to write to the COW file */
1411 uint64_t written = 0;
1412
1413 while (written < n) {
1414 int pnum;
1415
1416 if (compare_sectors(buf_old + written * 512,
1417 buf_new + written * 512, n - written, &pnum))
1418 {
1419 ret = bdrv_write(bs, sector + written,
1420 buf_old + written * 512, pnum);
1421 if (ret < 0) {
1422 error_report("Error while writing to COW image: %s",
1423 strerror(-ret));
1424 goto out;
1425 }
1426 }
1427
1428 written += pnum;
1429 }
1430 qemu_progress_print(local_progress, 100);
1431 }
1432
1433 qemu_free(buf_old);
1434 qemu_free(buf_new);
1435 }
1436
1437 /*
1438 * Change the backing file. All clusters that are different from the old
1439 * backing file are overwritten in the COW file now, so the visible content
1440 * doesn't change when we switch the backing file.
1441 */
1442 ret = bdrv_change_backing_file(bs, out_baseimg, out_basefmt);
1443 if (ret == -ENOSPC) {
1444 error_report("Could not change the backing file to '%s': No "
1445 "space left in the file header", out_baseimg);
1446 } else if (ret < 0) {
1447 error_report("Could not change the backing file to '%s': %s",
1448 out_baseimg, strerror(-ret));
1449 }
1450
1451 qemu_progress_print(100, 0);
1452 /*
1453 * TODO At this point it is possible to check if any clusters that are
1454 * allocated in the COW file are the same in the backing file. If so, they
1455 * could be dropped from the COW file. Don't do this before switching the
1456 * backing file, in case of a crash this would lead to corruption.
1457 */
1458 out:
1459 qemu_progress_end();
1460 /* Cleanup */
1461 if (!unsafe) {
1462 if (bs_old_backing != NULL) {
1463 bdrv_delete(bs_old_backing);
1464 }
1465 if (bs_new_backing != NULL) {
1466 bdrv_delete(bs_new_backing);
1467 }
1468 }
1469
1470 bdrv_delete(bs);
1471 if (ret) {
1472 return 1;
1473 }
1474 return 0;
1475 }
1476
1477 static int img_resize(int argc, char **argv)
1478 {
1479 int c, ret, relative;
1480 const char *filename, *fmt, *size;
1481 int64_t n, total_size;
1482 BlockDriverState *bs = NULL;
1483 QEMUOptionParameter *param;
1484 QEMUOptionParameter resize_options[] = {
1485 {
1486 .name = BLOCK_OPT_SIZE,
1487 .type = OPT_SIZE,
1488 .help = "Virtual disk size"
1489 },
1490 { NULL }
1491 };
1492
1493 /* Remove size from argv manually so that negative numbers are not treated
1494 * as options by getopt. */
1495 if (argc < 3) {
1496 help();
1497 return 1;
1498 }
1499
1500 size = argv[--argc];
1501
1502 /* Parse getopt arguments */
1503 fmt = NULL;
1504 for(;;) {
1505 c = getopt(argc, argv, "f:h");
1506 if (c == -1) {
1507 break;
1508 }
1509 switch(c) {
1510 case '?':
1511 case 'h':
1512 help();
1513 break;
1514 case 'f':
1515 fmt = optarg;
1516 break;
1517 }
1518 }
1519 if (optind >= argc) {
1520 help();
1521 }
1522 filename = argv[optind++];
1523
1524 /* Choose grow, shrink, or absolute resize mode */
1525 switch (size[0]) {
1526 case '+':
1527 relative = 1;
1528 size++;
1529 break;
1530 case '-':
1531 relative = -1;
1532 size++;
1533 break;
1534 default:
1535 relative = 0;
1536 break;
1537 }
1538
1539 /* Parse size */
1540 param = parse_option_parameters("", resize_options, NULL);
1541 if (set_option_parameter(param, BLOCK_OPT_SIZE, size)) {
1542 /* Error message already printed when size parsing fails */
1543 ret = -1;
1544 goto out;
1545 }
1546 n = get_option_parameter(param, BLOCK_OPT_SIZE)->value.n;
1547 free_option_parameters(param);
1548
1549 bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
1550 if (!bs) {
1551 ret = -1;
1552 goto out;
1553 }
1554
1555 if (relative) {
1556 total_size = bdrv_getlength(bs) + n * relative;
1557 } else {
1558 total_size = n;
1559 }
1560 if (total_size <= 0) {
1561 error_report("New image size must be positive");
1562 ret = -1;
1563 goto out;
1564 }
1565
1566 ret = bdrv_truncate(bs, total_size);
1567 switch (ret) {
1568 case 0:
1569 printf("Image resized.\n");
1570 break;
1571 case -ENOTSUP:
1572 error_report("This image format does not support resize");
1573 break;
1574 case -EACCES:
1575 error_report("Image is read-only");
1576 break;
1577 default:
1578 error_report("Error resizing image (%d)", -ret);
1579 break;
1580 }
1581 out:
1582 if (bs) {
1583 bdrv_delete(bs);
1584 }
1585 if (ret) {
1586 return 1;
1587 }
1588 return 0;
1589 }
1590
1591 static const img_cmd_t img_cmds[] = {
1592 #define DEF(option, callback, arg_string) \
1593 { option, callback },
1594 #include "qemu-img-cmds.h"
1595 #undef DEF
1596 #undef GEN_DOCS
1597 { NULL, NULL, },
1598 };
1599
1600 int main(int argc, char **argv)
1601 {
1602 const img_cmd_t *cmd;
1603 const char *cmdname;
1604
1605 error_set_progname(argv[0]);
1606
1607 bdrv_init();
1608 if (argc < 2)
1609 help();
1610 cmdname = argv[1];
1611 argc--; argv++;
1612
1613 /* find the command */
1614 for(cmd = img_cmds; cmd->name != NULL; cmd++) {
1615 if (!strcmp(cmdname, cmd->name)) {
1616 return cmd->handler(argc, argv);
1617 }
1618 }
1619
1620 /* not found */
1621 help();
1622 return 0;
1623 }