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