Annotation of qemu/qemu-img.c, revision 1.1.1.13
1.1 root 1: /*
1.1.1.3 root 2: * QEMU disk image utility
1.1.1.4 root 3: *
4: * Copyright (c) 2003-2008 Fabrice Bellard
5: *
1.1 root 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: */
1.1.1.4 root 24: #include "qemu-common.h"
1.1.1.8 root 25: #include "qemu-option.h"
1.1.1.12 root 26: #include "qemu-error.h"
1.1.1.5 root 27: #include "osdep.h"
1.1.1.12 root 28: #include "sysemu.h"
1.1.1.4 root 29: #include "block_int.h"
1.1.1.8 root 30: #include <stdio.h>
1.1 root 31:
1.1.1.2 root 32: #ifdef _WIN32
33: #include <windows.h>
34: #endif
35:
1.1.1.8 root 36: typedef struct img_cmd_t {
37: const char *name;
38: int (*handler)(int argc, char **argv);
39: } img_cmd_t;
40:
1.1.1.5 root 41: /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
1.1.1.11 root 42: #define BDRV_O_FLAGS BDRV_O_CACHE_WB
1.1.1.13! root 43: #define BDRV_DEFAULT_CACHE "writeback"
1.1 root 44:
45: static void format_print(void *opaque, const char *name)
46: {
47: printf(" %s", name);
48: }
49:
1.1.1.5 root 50: /* Please keep in synch with qemu-img.texi */
1.1.1.4 root 51: static void help(void)
1.1 root 52: {
1.1.1.11 root 53: const char *help_msg =
54: "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
1.1 root 55: "usage: qemu-img command [command options]\n"
56: "QEMU disk image utility\n"
57: "\n"
58: "Command syntax:\n"
1.1.1.8 root 59: #define DEF(option, callback, arg_string) \
60: " " arg_string "\n"
61: #include "qemu-img-cmds.h"
62: #undef DEF
63: #undef GEN_DOCS
1.1 root 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"
1.1.1.13! root 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"
1.1.1.9 root 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"
1.1 root 73: " 'output_filename' is the destination disk image filename\n"
74: " 'output_fmt' is the destination format\n"
1.1.1.8 root 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"
1.1 root 78: " '-c' indicates that target image must be compressed (qcow format only)\n"
1.1.1.11 root 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"
1.1.1.5 root 82: " '-h' with or without a command shows this help and lists the supported formats\n"
1.1.1.13! root 83: " '-p' show progress of command (only certain commands)\n"
1.1.1.5 root 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"
1.1.1.11 root 90: " '-l' lists all snapshots in the given image\n";
91:
92: printf("%s\nSupported formats:", help_msg);
1.1 root 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;
1.1.1.4 root 143:
1.1 root 144: tcsetattr (0, TCSANOW, &tty);
145:
146: atexit(term_exit);
147: }
148:
1.1.1.4 root 149: static int read_password(char *buf, int buf_size)
1.1 root 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:
1.1.1.13! root 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:
1.1.1.12 root 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:
1.1 root 234: static BlockDriverState *bdrv_new_open(const char *filename,
1.1.1.11 root 235: const char *fmt,
236: int flags)
1.1 root 237: {
238: BlockDriverState *bs;
239: BlockDriver *drv;
240: char password[256];
1.1.1.12 root 241: int ret;
242:
243: bs = bdrv_new("image");
1.1 root 244:
245: if (fmt) {
246: drv = bdrv_find_format(fmt);
1.1.1.11 root 247: if (!drv) {
1.1.1.12 root 248: error_report("Unknown file format '%s'", fmt);
1.1.1.11 root 249: goto fail;
250: }
1.1 root 251: } else {
252: drv = NULL;
253: }
1.1.1.12 root 254:
255: ret = bdrv_open(bs, filename, flags, drv);
256: if (ret < 0) {
257: error_report("Could not open '%s': %s", filename, strerror(-ret));
1.1.1.11 root 258: goto fail;
1.1 root 259: }
1.1.1.12 root 260:
1.1 root 261: if (bdrv_is_encrypted(bs)) {
262: printf("Disk image '%s' is encrypted.\n", filename);
1.1.1.11 root 263: if (read_password(password, sizeof(password)) < 0) {
1.1.1.12 root 264: error_report("No password given");
1.1.1.11 root 265: goto fail;
266: }
267: if (bdrv_set_key(bs, password) < 0) {
1.1.1.12 root 268: error_report("invalid password");
1.1.1.11 root 269: goto fail;
270: }
1.1 root 271: }
272: return bs;
1.1.1.11 root 273: fail:
274: if (bs) {
275: bdrv_delete(bs);
276: }
277: return NULL;
1.1 root 278: }
279:
1.1.1.11 root 280: static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
1.1.1.12 root 281: const char *base_filename,
282: const char *base_fmt)
1.1.1.8 root 283: {
284: if (base_filename) {
285: if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
1.1.1.12 root 286: error_report("Backing file not supported for file format '%s'",
287: fmt);
1.1.1.11 root 288: return -1;
1.1.1.8 root 289: }
290: }
291: if (base_fmt) {
292: if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
1.1.1.12 root 293: error_report("Backing file format not supported for file "
294: "format '%s'", fmt);
1.1.1.11 root 295: return -1;
1.1.1.8 root 296: }
297: }
1.1.1.11 root 298: return 0;
1.1.1.8 root 299: }
300:
1.1 root 301: static int img_create(int argc, char **argv)
302: {
1.1.1.12 root 303: int c, ret = 0;
304: uint64_t img_size = -1;
1.1 root 305: const char *fmt = "raw";
1.1.1.8 root 306: const char *base_fmt = NULL;
1.1 root 307: const char *filename;
308: const char *base_filename = NULL;
1.1.1.8 root 309: char *options = NULL;
1.1.1.4 root 310:
1.1 root 311: for(;;) {
1.1.1.8 root 312: c = getopt(argc, argv, "F:b:f:he6o:");
1.1.1.12 root 313: if (c == -1) {
1.1 root 314: break;
1.1.1.12 root 315: }
1.1 root 316: switch(c) {
1.1.1.12 root 317: case '?':
1.1 root 318: case 'h':
319: help();
320: break;
1.1.1.8 root 321: case 'F':
322: base_fmt = optarg;
323: break;
1.1 root 324: case 'b':
325: base_filename = optarg;
326: break;
327: case 'f':
328: fmt = optarg;
329: break;
330: case 'e':
1.1.1.13! root 331: error_report("option -e is deprecated, please use \'-o "
1.1.1.12 root 332: "encryption\' instead!");
333: return 1;
1.1.1.4 root 334: case '6':
1.1.1.13! root 335: error_report("option -6 is deprecated, please use \'-o "
1.1.1.12 root 336: "compat6\' instead!");
337: return 1;
1.1.1.8 root 338: case 'o':
339: options = optarg;
340: break;
1.1 root 341: }
342: }
1.1.1.8 root 343:
1.1.1.11 root 344: /* Get the filename */
1.1.1.12 root 345: if (optind >= argc) {
1.1.1.11 root 346: help();
347: }
1.1.1.12 root 348: filename = argv[optind++];
1.1.1.11 root 349:
1.1.1.12 root 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.");
1.1.1.11 root 358: ret = -1;
359: goto out;
1.1.1.8 root 360: }
1.1.1.12 root 361: img_size = (uint64_t)sval;
1.1.1.8 root 362: }
363:
1.1.1.12 root 364: if (options && !strcmp(options, "?")) {
365: ret = print_block_option_help(filename, fmt);
1.1.1.11 root 366: goto out;
367: }
1.1.1.8 root 368:
1.1.1.12 root 369: ret = bdrv_img_create(filename, fmt, base_filename, base_fmt,
370: options, img_size, BDRV_O_FLAGS);
1.1.1.11 root 371: out:
372: if (ret) {
373: return 1;
374: }
1.1 root 375: return 0;
376: }
377:
1.1.1.11 root 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: */
1.1.1.8 root 386: static int img_check(int argc, char **argv)
387: {
388: int c, ret;
389: const char *filename, *fmt;
390: BlockDriverState *bs;
1.1.1.11 root 391: BdrvCheckResult result;
1.1.1.8 root 392:
393: fmt = NULL;
394: for(;;) {
395: c = getopt(argc, argv, "f:h");
1.1.1.12 root 396: if (c == -1) {
1.1.1.8 root 397: break;
1.1.1.12 root 398: }
1.1.1.8 root 399: switch(c) {
1.1.1.12 root 400: case '?':
1.1.1.8 root 401: case 'h':
402: help();
403: break;
404: case 'f':
405: fmt = optarg;
406: break;
407: }
408: }
1.1.1.12 root 409: if (optind >= argc) {
1.1.1.8 root 410: help();
1.1.1.12 root 411: }
1.1.1.8 root 412: filename = argv[optind++];
413:
1.1.1.11 root 414: bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
415: if (!bs) {
416: return 1;
1.1.1.8 root 417: }
1.1.1.11 root 418: ret = bdrv_check(bs, &result);
419:
420: if (ret == -ENOTSUP) {
1.1.1.12 root 421: error_report("This image format does not support checks");
1.1.1.11 root 422: bdrv_delete(bs);
423: return 1;
1.1.1.8 root 424: }
1.1.1.11 root 425:
426: if (!(result.corruptions || result.leaks || result.check_errors)) {
1.1.1.8 root 427: printf("No errors were found on the image.\n");
1.1.1.11 root 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);
1.1.1.8 root 445: }
446: }
447:
448: bdrv_delete(bs);
1.1.1.11 root 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: }
1.1.1.8 root 464: }
465:
1.1 root 466: static int img_commit(int argc, char **argv)
467: {
1.1.1.13! root 468: int c, ret, flags;
! 469: const char *filename, *fmt, *cache;
1.1 root 470: BlockDriverState *bs;
471:
472: fmt = NULL;
1.1.1.13! root 473: cache = BDRV_DEFAULT_CACHE;
1.1 root 474: for(;;) {
1.1.1.13! root 475: c = getopt(argc, argv, "f:ht:");
1.1.1.12 root 476: if (c == -1) {
1.1 root 477: break;
1.1.1.12 root 478: }
1.1 root 479: switch(c) {
1.1.1.12 root 480: case '?':
1.1 root 481: case 'h':
482: help();
483: break;
484: case 'f':
485: fmt = optarg;
486: break;
1.1.1.13! root 487: case 't':
! 488: cache = optarg;
! 489: break;
1.1 root 490: }
491: }
1.1.1.12 root 492: if (optind >= argc) {
1.1 root 493: help();
1.1.1.12 root 494: }
1.1 root 495: filename = argv[optind++];
496:
1.1.1.13! root 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);
1.1.1.11 root 505: if (!bs) {
506: return 1;
1.1 root 507: }
508: ret = bdrv_commit(bs);
509: switch(ret) {
510: case 0:
511: printf("Image committed.\n");
512: break;
513: case -ENOENT:
1.1.1.12 root 514: error_report("No disk inserted");
1.1 root 515: break;
516: case -EACCES:
1.1.1.12 root 517: error_report("Image is read-only");
1.1 root 518: break;
519: case -ENOTSUP:
1.1.1.12 root 520: error_report("Image is already committed");
1.1 root 521: break;
522: default:
1.1.1.12 root 523: error_report("Error while committing image");
1.1 root 524: break;
525: }
526:
527: bdrv_delete(bs);
1.1.1.11 root 528: if (ret) {
529: return 1;
530: }
1.1 root 531: return 0;
532: }
533:
1.1.1.13! root 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: */
1.1 root 540: static int is_not_zero(const uint8_t *sector, int len)
541: {
1.1.1.13! root 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:
1.1 root 548: int i;
1.1.1.13! root 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) {
1.1 root 561: return 1;
1.1.1.13! root 562: }
1.1 root 563: }
1.1.1.13! root 564:
1.1 root 565: return 0;
566: }
567:
1.1.1.5 root 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: */
1.1 root 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:
1.1.1.11 root 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:
1.1.1.9 root 624: #define IO_BUF_SIZE (2 * 1024 * 1024)
1.1 root 625:
626: static int img_convert(int argc, char **argv)
627: {
1.1.1.12 root 628: int c, ret = 0, n, n1, bs_n, bs_i, compress, cluster_size, cluster_sectors;
1.1.1.13! root 629: int progress = 0, flags;
! 630: const char *fmt, *out_fmt, *cache, *out_baseimg, *out_filename;
1.1.1.11 root 631: BlockDriver *drv, *proto_drv;
632: BlockDriverState **bs = NULL, *out_bs = NULL;
1.1.1.4 root 633: int64_t total_sectors, nb_sectors, sector_num, bs_offset;
634: uint64_t bs_sectors;
1.1.1.11 root 635: uint8_t * buf = NULL;
1.1 root 636: const uint8_t *buf1;
1.1.1.3 root 637: BlockDriverInfo bdi;
1.1.1.11 root 638: QEMUOptionParameter *param = NULL, *create_options = NULL;
1.1.1.12 root 639: QEMUOptionParameter *out_baseimg_param;
1.1.1.8 root 640: char *options = NULL;
1.1.1.12 root 641: const char *snapshot_name = NULL;
1.1.1.13! root 642: float local_progress;
1.1 root 643:
644: fmt = NULL;
645: out_fmt = "raw";
1.1.1.13! root 646: cache = "unsafe";
1.1.1.5 root 647: out_baseimg = NULL;
1.1.1.12 root 648: compress = 0;
1.1 root 649: for(;;) {
1.1.1.13! root 650: c = getopt(argc, argv, "f:O:B:s:hce6o:pt:");
1.1.1.12 root 651: if (c == -1) {
1.1 root 652: break;
1.1.1.12 root 653: }
1.1 root 654: switch(c) {
1.1.1.12 root 655: case '?':
1.1 root 656: case 'h':
657: help();
658: break;
659: case 'f':
660: fmt = optarg;
661: break;
662: case 'O':
663: out_fmt = optarg;
664: break;
1.1.1.5 root 665: case 'B':
666: out_baseimg = optarg;
667: break;
1.1 root 668: case 'c':
1.1.1.12 root 669: compress = 1;
1.1 root 670: break;
671: case 'e':
1.1.1.13! root 672: error_report("option -e is deprecated, please use \'-o "
1.1.1.12 root 673: "encryption\' instead!");
674: return 1;
1.1.1.4 root 675: case '6':
1.1.1.13! root 676: error_report("option -6 is deprecated, please use \'-o "
1.1.1.12 root 677: "compat6\' instead!");
678: return 1;
1.1.1.8 root 679: case 'o':
680: options = optarg;
681: break;
1.1.1.12 root 682: case 's':
683: snapshot_name = optarg;
684: break;
1.1.1.13! root 685: case 'p':
! 686: progress = 1;
! 687: break;
! 688: case 't':
! 689: cache = optarg;
! 690: break;
1.1 root 691: }
692: }
1.1.1.4 root 693:
694: bs_n = argc - optind - 1;
1.1.1.12 root 695: if (bs_n < 1) {
696: help();
697: }
1.1.1.4 root 698:
699: out_filename = argv[argc - 1];
1.1.1.5 root 700:
1.1.1.12 root 701: if (options && !strcmp(options, "?")) {
702: ret = print_block_option_help(out_filename, out_fmt);
703: goto out;
704: }
705:
1.1.1.11 root 706: if (bs_n > 1 && out_baseimg) {
1.1.1.12 root 707: error_report("-B makes no sense when concatenating multiple input "
708: "images");
709: ret = -1;
710: goto out;
1.1.1.11 root 711: }
1.1.1.4 root 712:
1.1.1.13! root 713: qemu_progress_init(progress, 2.0);
! 714: qemu_progress_print(0, 100);
! 715:
1.1.1.12 root 716: bs = qemu_mallocz(bs_n * sizeof(BlockDriverState *));
1.1.1.4 root 717:
718: total_sectors = 0;
719: for (bs_i = 0; bs_i < bs_n; bs_i++) {
1.1.1.11 root 720: bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
721: if (!bs[bs_i]) {
1.1.1.12 root 722: error_report("Could not open '%s'", argv[optind + bs_i]);
1.1.1.11 root 723: ret = -1;
724: goto out;
725: }
1.1.1.4 root 726: bdrv_get_geometry(bs[bs_i], &bs_sectors);
727: total_sectors += bs_sectors;
728: }
1.1 root 729:
1.1.1.12 root 730: if (snapshot_name != NULL) {
731: if (bs_n > 1) {
1.1.1.13! root 732: error_report("No support for concatenating multiple snapshot");
1.1.1.12 root 733: ret = -1;
734: goto out;
735: }
736: if (bdrv_snapshot_load_tmp(bs[0], snapshot_name) < 0) {
1.1.1.13! root 737: error_report("Failed to load snapshot");
1.1.1.12 root 738: ret = -1;
739: goto out;
740: }
741: }
742:
1.1.1.8 root 743: /* Find driver and parse its options */
1.1 root 744: drv = bdrv_find_format(out_fmt);
1.1.1.11 root 745: if (!drv) {
1.1.1.12 root 746: error_report("Unknown file format '%s'", out_fmt);
1.1.1.11 root 747: ret = -1;
748: goto out;
749: }
750:
751: proto_drv = bdrv_find_protocol(out_filename);
752: if (!proto_drv) {
1.1.1.12 root 753: error_report("Unknown protocol '%s'", out_filename);
1.1.1.11 root 754: ret = -1;
755: goto out;
756: }
1.1.1.4 root 757:
1.1.1.11 root 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);
1.1.1.8 root 762:
763: if (options) {
1.1.1.11 root 764: param = parse_option_parameters(options, create_options, param);
1.1.1.8 root 765: if (param == NULL) {
1.1.1.12 root 766: error_report("Invalid options for file format '%s'.", out_fmt);
1.1.1.11 root 767: ret = -1;
768: goto out;
1.1.1.8 root 769: }
770: } else {
1.1.1.11 root 771: param = parse_option_parameters("", create_options, param);
1.1.1.8 root 772: }
773:
774: set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
1.1.1.12 root 775: ret = add_old_style_options(out_fmt, param, out_baseimg, NULL);
1.1.1.11 root 776: if (ret < 0) {
777: goto out;
778: }
1.1.1.8 root 779:
1.1.1.12 root 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:
1.1.1.8 root 786: /* Check if compression is supported */
1.1.1.12 root 787: if (compress) {
1.1.1.8 root 788: QEMUOptionParameter *encryption =
789: get_option_parameter(param, BLOCK_OPT_ENCRYPT);
790:
791: if (!drv->bdrv_write_compressed) {
1.1.1.12 root 792: error_report("Compression not supported for this file format");
1.1.1.11 root 793: ret = -1;
794: goto out;
1.1.1.8 root 795: }
796:
797: if (encryption && encryption->value.n) {
1.1.1.12 root 798: error_report("Compression and encryption not supported at "
799: "the same time");
1.1.1.11 root 800: ret = -1;
801: goto out;
1.1.1.8 root 802: }
803: }
804:
805: /* Create the new image */
806: ret = bdrv_create(drv, out_filename, param);
1.1 root 807: if (ret < 0) {
808: if (ret == -ENOTSUP) {
1.1.1.12 root 809: error_report("Formatting not supported for file format '%s'",
810: out_fmt);
1.1.1.7 root 811: } else if (ret == -EFBIG) {
1.1.1.12 root 812: error_report("The image size is too large for file format '%s'",
813: out_fmt);
1.1 root 814: } else {
1.1.1.12 root 815: error_report("%s: error while converting %s: %s",
816: out_filename, out_fmt, strerror(-ret));
1.1 root 817: }
1.1.1.11 root 818: goto out;
1.1 root 819: }
1.1.1.4 root 820:
1.1.1.13! root 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);
1.1.1.11 root 829: if (!out_bs) {
830: ret = -1;
831: goto out;
832: }
1.1 root 833:
1.1.1.4 root 834: bs_i = 0;
835: bs_offset = 0;
836: bdrv_get_geometry(bs[0], &bs_sectors);
1.1.1.10 root 837: buf = qemu_malloc(IO_BUF_SIZE);
1.1.1.4 root 838:
1.1.1.12 root 839: if (compress) {
1.1.1.11 root 840: ret = bdrv_get_info(out_bs, &bdi);
841: if (ret < 0) {
1.1.1.12 root 842: error_report("could not get block driver info");
1.1.1.11 root 843: goto out;
844: }
1.1.1.3 root 845: cluster_size = bdi.cluster_size;
1.1.1.11 root 846: if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
1.1.1.12 root 847: error_report("invalid cluster size");
1.1.1.11 root 848: ret = -1;
849: goto out;
850: }
1.1 root 851: cluster_sectors = cluster_size >> 9;
852: sector_num = 0;
1.1.1.13! root 853:
! 854: nb_sectors = total_sectors;
! 855: local_progress = (float)100 /
! 856: (nb_sectors / MIN(nb_sectors, cluster_sectors));
! 857:
1.1 root 858: for(;;) {
1.1.1.4 root 859: int64_t bs_num;
860: int remainder;
861: uint8_t *buf2;
862:
1.1 root 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;
1.1.1.4 root 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;
1.1.1.11 root 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); */
1.1.1.4 root 886: }
887: assert (bs_num < bs_sectors);
888:
889: nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
890:
1.1.1.11 root 891: ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
892: if (ret < 0) {
1.1.1.12 root 893: error_report("error while reading");
1.1.1.11 root 894: goto out;
895: }
1.1.1.4 root 896:
897: buf2 += nlow * 512;
898: bs_num += nlow;
899:
900: remainder -= nlow;
901: }
902: assert (remainder == 0);
903:
1.1.1.12 root 904: if (n < cluster_sectors) {
1.1 root 905: memset(buf + n * 512, 0, cluster_size - n * 512);
1.1.1.12 root 906: }
1.1 root 907: if (is_not_zero(buf, cluster_size)) {
1.1.1.11 root 908: ret = bdrv_write_compressed(out_bs, sector_num, buf,
909: cluster_sectors);
910: if (ret != 0) {
1.1.1.12 root 911: error_report("error while compressing sector %" PRId64,
1.1.1.2 root 912: sector_num);
1.1.1.11 root 913: goto out;
914: }
1.1 root 915: }
916: sector_num += n;
1.1.1.13! root 917: qemu_progress_print(local_progress, 100);
1.1 root 918: }
1.1.1.3 root 919: /* signal EOF to align */
920: bdrv_write_compressed(out_bs, 0, NULL, 0);
1.1 root 921: } else {
1.1.1.11 root 922: int has_zero_init = bdrv_has_zero_init(out_bs);
923:
1.1.1.5 root 924: sector_num = 0; // total number of sectors converted so far
1.1.1.13! root 925: nb_sectors = total_sectors - sector_num;
! 926: local_progress = (float)100 /
! 927: (nb_sectors / MIN(nb_sectors, IO_BUF_SIZE / 512));
! 928:
1.1 root 929: for(;;) {
930: nb_sectors = total_sectors - sector_num;
1.1.1.12 root 931: if (nb_sectors <= 0) {
1.1 root 932: break;
1.1.1.12 root 933: }
934: if (nb_sectors >= (IO_BUF_SIZE / 512)) {
1.1 root 935: n = (IO_BUF_SIZE / 512);
1.1.1.12 root 936: } else {
1.1 root 937: n = nb_sectors;
1.1.1.12 root 938: }
1.1.1.4 root 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);
1.1.1.11 root 945: /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
946: "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
1.1.1.4 root 947: sector_num, bs_i, bs_offset, bs_sectors); */
948: }
949:
1.1.1.12 root 950: if (n > bs_offset + bs_sectors - sector_num) {
1.1.1.4 root 951: n = bs_offset + bs_sectors - sector_num;
1.1.1.12 root 952: }
1.1.1.4 root 953:
1.1.1.11 root 954: if (has_zero_init) {
1.1.1.8 root 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;
1.1.1.5 root 971: }
972:
1.1.1.11 root 973: ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
974: if (ret < 0) {
1.1.1.12 root 975: error_report("error while reading");
1.1.1.11 root 976: goto out;
977: }
1.1 root 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) {
1.1.1.5 root 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,
1.1.1.8 root 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. */
1.1.1.11 root 990: if (!has_zero_init || out_baseimg ||
1.1.1.8 root 991: is_allocated_sectors(buf1, n, &n1)) {
1.1.1.11 root 992: ret = bdrv_write(out_bs, sector_num, buf1, n1);
993: if (ret < 0) {
1.1.1.12 root 994: error_report("error while writing");
1.1.1.11 root 995: goto out;
996: }
1.1 root 997: }
998: sector_num += n1;
999: n -= n1;
1000: buf1 += n1 * 512;
1001: }
1.1.1.13! root 1002: qemu_progress_print(local_progress, 100);
1.1 root 1003: }
1004: }
1.1.1.11 root 1005: out:
1.1.1.13! root 1006: qemu_progress_end();
1.1.1.11 root 1007: free_option_parameters(create_options);
1008: free_option_parameters(param);
1.1.1.10 root 1009: qemu_free(buf);
1.1.1.11 root 1010: if (out_bs) {
1011: bdrv_delete(out_bs);
1012: }
1.1.1.12 root 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: }
1.1.1.11 root 1018: }
1.1.1.12 root 1019: qemu_free(bs);
1.1.1.11 root 1020: }
1021: if (ret) {
1022: return 1;
1023: }
1.1 root 1024: return 0;
1025: }
1026:
1027:
1.1.1.3 root 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:
1.1 root 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];
1.1.1.4 root 1052: uint64_t total_sectors;
1053: int64_t allocated_size;
1.1.1.3 root 1054: char backing_filename[1024];
1055: char backing_filename2[1024];
1056: BlockDriverInfo bdi;
1.1 root 1057:
1058: fmt = NULL;
1059: for(;;) {
1060: c = getopt(argc, argv, "f:h");
1.1.1.12 root 1061: if (c == -1) {
1.1 root 1062: break;
1.1.1.12 root 1063: }
1.1 root 1064: switch(c) {
1.1.1.12 root 1065: case '?':
1.1 root 1066: case 'h':
1067: help();
1068: break;
1069: case 'f':
1070: fmt = optarg;
1071: break;
1072: }
1073: }
1.1.1.12 root 1074: if (optind >= argc) {
1.1 root 1075: help();
1.1.1.12 root 1076: }
1.1 root 1077: filename = argv[optind++];
1078:
1.1.1.11 root 1079: bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
1080: if (!bs) {
1081: return 1;
1.1 root 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);
1.1.1.13! root 1086: allocated_size = bdrv_get_allocated_file_size(bs);
1.1.1.12 root 1087: if (allocated_size < 0) {
1.1.1.5 root 1088: snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1.1.1.12 root 1089: } else {
1.1.1.4 root 1090: get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1.1 root 1091: allocated_size);
1.1.1.12 root 1092: }
1.1 root 1093: printf("image: %s\n"
1094: "file format: %s\n"
1.1.1.2 root 1095: "virtual size: %s (%" PRId64 " bytes)\n"
1.1 root 1096: "disk size: %s\n",
1.1.1.4 root 1097: filename, fmt_name, size_buf,
1.1.1.2 root 1098: (total_sectors * 512),
1.1 root 1099: dsize_buf);
1.1.1.12 root 1100: if (bdrv_is_encrypted(bs)) {
1.1 root 1101: printf("encrypted: yes\n");
1.1.1.12 root 1102: }
1.1.1.3 root 1103: if (bdrv_get_info(bs, &bdi) >= 0) {
1.1.1.12 root 1104: if (bdi.cluster_size != 0) {
1.1.1.3 root 1105: printf("cluster_size: %d\n", bdi.cluster_size);
1.1.1.12 root 1106: }
1.1.1.3 root 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);
1.1.1.4 root 1112: printf("backing file: %s (actual path: %s)\n",
1.1.1.3 root 1113: backing_filename,
1114: backing_filename2);
1115: }
1116: dump_snapshots(bs);
1.1 root 1117: bdrv_delete(bs);
1118: return 0;
1119: }
1120:
1.1.1.5 root 1121: #define SNAPSHOT_LIST 1
1122: #define SNAPSHOT_CREATE 2
1123: #define SNAPSHOT_APPLY 3
1124: #define SNAPSHOT_DELETE 4
1125:
1.1.1.8 root 1126: static int img_snapshot(int argc, char **argv)
1.1.1.5 root 1127: {
1128: BlockDriverState *bs;
1129: QEMUSnapshotInfo sn;
1130: char *filename, *snapshot_name = NULL;
1.1.1.11 root 1131: int c, ret = 0, bdrv_oflags;
1.1.1.5 root 1132: int action = 0;
1133: qemu_timeval tv;
1134:
1.1.1.12 root 1135: bdrv_oflags = BDRV_O_FLAGS | BDRV_O_RDWR;
1.1.1.5 root 1136: /* Parse commandline parameters */
1137: for(;;) {
1138: c = getopt(argc, argv, "la:c:d:h");
1.1.1.12 root 1139: if (c == -1) {
1.1.1.5 root 1140: break;
1.1.1.12 root 1141: }
1.1.1.5 root 1142: switch(c) {
1.1.1.12 root 1143: case '?':
1.1.1.5 root 1144: case 'h':
1145: help();
1.1.1.8 root 1146: return 0;
1.1.1.5 root 1147: case 'l':
1148: if (action) {
1149: help();
1.1.1.8 root 1150: return 0;
1.1.1.5 root 1151: }
1152: action = SNAPSHOT_LIST;
1.1.1.11 root 1153: bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
1.1.1.5 root 1154: break;
1155: case 'a':
1156: if (action) {
1157: help();
1.1.1.8 root 1158: return 0;
1.1.1.5 root 1159: }
1160: action = SNAPSHOT_APPLY;
1161: snapshot_name = optarg;
1162: break;
1163: case 'c':
1164: if (action) {
1165: help();
1.1.1.8 root 1166: return 0;
1.1.1.5 root 1167: }
1168: action = SNAPSHOT_CREATE;
1169: snapshot_name = optarg;
1170: break;
1171: case 'd':
1172: if (action) {
1173: help();
1.1.1.8 root 1174: return 0;
1.1.1.5 root 1175: }
1176: action = SNAPSHOT_DELETE;
1177: snapshot_name = optarg;
1178: break;
1179: }
1180: }
1181:
1.1.1.12 root 1182: if (optind >= argc) {
1.1.1.5 root 1183: help();
1.1.1.12 root 1184: }
1.1.1.5 root 1185: filename = argv[optind++];
1186:
1187: /* Open the image */
1.1.1.11 root 1188: bs = bdrv_new_open(filename, NULL, bdrv_oflags);
1189: if (!bs) {
1190: return 1;
1.1.1.5 root 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);
1.1.1.12 root 1208: if (ret) {
1209: error_report("Could not create snapshot '%s': %d (%s)",
1.1.1.5 root 1210: snapshot_name, ret, strerror(-ret));
1.1.1.12 root 1211: }
1.1.1.5 root 1212: break;
1213:
1214: case SNAPSHOT_APPLY:
1215: ret = bdrv_snapshot_goto(bs, snapshot_name);
1.1.1.12 root 1216: if (ret) {
1217: error_report("Could not apply snapshot '%s': %d (%s)",
1.1.1.5 root 1218: snapshot_name, ret, strerror(-ret));
1.1.1.12 root 1219: }
1.1.1.5 root 1220: break;
1221:
1222: case SNAPSHOT_DELETE:
1223: ret = bdrv_snapshot_delete(bs, snapshot_name);
1.1.1.12 root 1224: if (ret) {
1225: error_report("Could not delete snapshot '%s': %d (%s)",
1.1.1.5 root 1226: snapshot_name, ret, strerror(-ret));
1.1.1.12 root 1227: }
1.1.1.5 root 1228: break;
1229: }
1230:
1231: /* Cleanup */
1232: bdrv_delete(bs);
1.1.1.11 root 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;
1.1.1.13! root 1244: const char *fmt, *cache, *out_basefmt, *out_baseimg;
1.1.1.11 root 1245: int c, flags, ret;
1246: int unsafe = 0;
1.1.1.13! root 1247: int progress = 0;
1.1.1.11 root 1248:
1249: /* Parse commandline parameters */
1250: fmt = NULL;
1.1.1.13! root 1251: cache = BDRV_DEFAULT_CACHE;
1.1.1.11 root 1252: out_baseimg = NULL;
1253: out_basefmt = NULL;
1254: for(;;) {
1.1.1.13! root 1255: c = getopt(argc, argv, "uhf:F:b:pt:");
1.1.1.12 root 1256: if (c == -1) {
1.1.1.11 root 1257: break;
1.1.1.12 root 1258: }
1.1.1.11 root 1259: switch(c) {
1.1.1.12 root 1260: case '?':
1.1.1.11 root 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;
1.1.1.13! root 1276: case 'p':
! 1277: progress = 1;
! 1278: break;
! 1279: case 't':
! 1280: cache = optarg;
! 1281: break;
1.1.1.11 root 1282: }
1283: }
1284:
1.1.1.13! root 1285: if ((optind >= argc) || (!unsafe && !out_baseimg)) {
1.1.1.11 root 1286: help();
1.1.1.12 root 1287: }
1.1.1.11 root 1288: filename = argv[optind++];
1289:
1.1.1.13! root 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:
1.1.1.11 root 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) {
1.1.1.12 root 1318: error_report("Invalid format name: '%s'", bs->backing_format);
1.1.1.11 root 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) {
1.1.1.12 root 1327: error_report("Invalid format name: '%s'", out_basefmt);
1.1.1.11 root 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) {
1.1.1.12 root 1346: error_report("Could not open old backing file '%s'", backing_name);
1.1.1.11 root 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) {
1.1.1.12 root 1354: error_report("Could not open new backing file '%s'", out_baseimg);
1.1.1.11 root 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;
1.1.1.13! root 1374: float local_progress;
1.1.1.11 root 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:
1.1.1.13! root 1381: local_progress = (float)100 /
! 1382: (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
1.1.1.11 root 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) {
1.1.1.12 root 1401: error_report("error while reading from old backing file");
1.1.1.11 root 1402: goto out;
1403: }
1404: ret = bdrv_read(bs_new_backing, sector, buf_new, n);
1405: if (ret < 0) {
1.1.1.12 root 1406: error_report("error while reading from new backing file");
1.1.1.11 root 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) {
1.1.1.12 root 1422: error_report("Error while writing to COW image: %s",
1.1.1.11 root 1423: strerror(-ret));
1424: goto out;
1425: }
1426: }
1427:
1428: written += pnum;
1429: }
1.1.1.13! root 1430: qemu_progress_print(local_progress, 100);
1.1.1.11 root 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) {
1.1.1.12 root 1444: error_report("Could not change the backing file to '%s': No "
1445: "space left in the file header", out_baseimg);
1.1.1.11 root 1446: } else if (ret < 0) {
1.1.1.12 root 1447: error_report("Could not change the backing file to '%s': %s",
1.1.1.11 root 1448: out_baseimg, strerror(-ret));
1449: }
1450:
1.1.1.13! root 1451: qemu_progress_print(100, 0);
1.1.1.11 root 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:
1.1.1.13! root 1459: qemu_progress_end();
1.1.1.11 root 1460: /* Cleanup */
1461: if (!unsafe) {
1.1.1.13! root 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: }
1.1.1.11 root 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;
1.1.1.12 root 1482: BlockDriverState *bs = NULL;
1.1.1.11 root 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:
1.1.1.13! root 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 */
1.1.1.11 root 1503: fmt = NULL;
1504: for(;;) {
1505: c = getopt(argc, argv, "f:h");
1506: if (c == -1) {
1507: break;
1508: }
1509: switch(c) {
1.1.1.12 root 1510: case '?':
1.1.1.11 root 1511: case 'h':
1512: help();
1513: break;
1514: case 'f':
1515: fmt = optarg;
1516: break;
1517: }
1518: }
1.1.1.13! root 1519: if (optind >= argc) {
1.1.1.11 root 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 */
1.1.1.12 root 1543: ret = -1;
1544: goto out;
1.1.1.11 root 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) {
1.1.1.12 root 1551: ret = -1;
1552: goto out;
1.1.1.11 root 1553: }
1.1.1.8 root 1554:
1.1.1.11 root 1555: if (relative) {
1556: total_size = bdrv_getlength(bs) + n * relative;
1557: } else {
1558: total_size = n;
1559: }
1560: if (total_size <= 0) {
1.1.1.12 root 1561: error_report("New image size must be positive");
1.1.1.11 root 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:
1.1.1.12 root 1572: error_report("This image format does not support resize");
1.1.1.11 root 1573: break;
1574: case -EACCES:
1.1.1.12 root 1575: error_report("Image is read-only");
1.1.1.11 root 1576: break;
1577: default:
1.1.1.12 root 1578: error_report("Error resizing image (%d)", -ret);
1.1.1.11 root 1579: break;
1580: }
1581: out:
1.1.1.12 root 1582: if (bs) {
1583: bdrv_delete(bs);
1584: }
1.1.1.11 root 1585: if (ret) {
1586: return 1;
1587: }
1.1.1.8 root 1588: return 0;
1.1.1.5 root 1589: }
1590:
1.1.1.8 root 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:
1.1 root 1600: int main(int argc, char **argv)
1601: {
1.1.1.8 root 1602: const img_cmd_t *cmd;
1603: const char *cmdname;
1.1 root 1604:
1.1.1.12 root 1605: error_set_progname(argv[0]);
1606:
1.1 root 1607: bdrv_init();
1608: if (argc < 2)
1609: help();
1.1.1.8 root 1610: cmdname = argv[1];
1.1.1.5 root 1611: argc--; argv++;
1.1.1.8 root 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: }
1.1 root 1618: }
1.1.1.8 root 1619:
1620: /* not found */
1621: help();
1.1 root 1622: return 0;
1623: }
unix.superglobalmegacorp.com
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qemu-img.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu