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