File:  [Qemu by Fabrice Bellard] / qemu / qemu-img.c
Revision 1.1.1.11 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:24:09 2018 UTC (20 months, 3 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0130, HEAD
qemu 0.13.0

    1: /*
    2:  * QEMU disk image utility
    3:  *
    4:  * Copyright (c) 2003-2008 Fabrice Bellard
    5:  *
    6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    7:  * of this software and associated documentation files (the "Software"), to deal
    8:  * in the Software without restriction, including without limitation the rights
    9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   10:  * copies of the Software, and to permit persons to whom the Software is
   11:  * furnished to do so, subject to the following conditions:
   12:  *
   13:  * The above copyright notice and this permission notice shall be included in
   14:  * all copies or substantial portions of the Software.
   15:  *
   16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   22:  * THE SOFTWARE.
   23:  */
   24: #include "qemu-common.h"
   25: #include "qemu-option.h"
   26: #include "osdep.h"
   27: #include "block_int.h"
   28: #include <stdio.h>
   29: 
   30: #ifdef _WIN32
   31: #include <windows.h>
   32: #endif
   33: 
   34: typedef struct img_cmd_t {
   35:     const char *name;
   36:     int (*handler)(int argc, char **argv);
   37: } img_cmd_t;
   38: 
   39: /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
   40: #define BDRV_O_FLAGS BDRV_O_CACHE_WB
   41: 
   42: static void error(const char *fmt, ...)
   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: 
   57: /* Please keep in synch with qemu-img.texi */
   58: static void help(void)
   59: {
   60:     const char *help_msg =
   61:            "qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
   62:            "usage: qemu-img command [command options]\n"
   63:            "QEMU disk image utility\n"
   64:            "\n"
   65:            "Command syntax:\n"
   66: #define DEF(option, callback, arg_string)        \
   67:            "  " arg_string "\n"
   68: #include "qemu-img-cmds.h"
   69: #undef DEF
   70: #undef GEN_DOCS
   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"
   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"
   78:            "  'output_filename' is the destination disk image filename\n"
   79:            "  'output_fmt' is the destination format\n"
   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"
   83:            "  '-c' indicates that target image must be compressed (qcow format only)\n"
   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"
   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"
   94:            "  '-l' lists all snapshots in the given image\n";
   95: 
   96:     printf("%s\nSupported formats:", help_msg);
   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;
  147: 
  148:     tcsetattr (0, TCSANOW, &tty);
  149: 
  150:     atexit(term_exit);
  151: }
  152: 
  153: static int read_password(char *buf, int buf_size)
  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,
  191:                                        const char *fmt,
  192:                                        int flags)
  193: {
  194:     BlockDriverState *bs;
  195:     BlockDriver *drv;
  196:     char password[256];
  197: 
  198:     bs = bdrv_new("");
  199:     if (!bs) {
  200:         error("Not enough memory");
  201:         goto fail;
  202:     }
  203:     if (fmt) {
  204:         drv = bdrv_find_format(fmt);
  205:         if (!drv) {
  206:             error("Unknown file format '%s'", fmt);
  207:             goto fail;
  208:         }
  209:     } else {
  210:         drv = NULL;
  211:     }
  212:     if (bdrv_open(bs, filename, flags, drv) < 0) {
  213:         error("Could not open '%s'", filename);
  214:         goto fail;
  215:     }
  216:     if (bdrv_is_encrypted(bs)) {
  217:         printf("Disk image '%s' is encrypted.\n", filename);
  218:         if (read_password(password, sizeof(password)) < 0) {
  219:             error("No password given");
  220:             goto fail;
  221:         }
  222:         if (bdrv_set_key(bs, password) < 0) {
  223:             error("invalid password");
  224:             goto fail;
  225:         }
  226:     }
  227:     return bs;
  228: fail:
  229:     if (bs) {
  230:         bdrv_delete(bs);
  231:     }
  232:     return NULL;
  233: }
  234: 
  235: static int add_old_style_options(const char *fmt, QEMUOptionParameter *list,
  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);
  241:             return -1;
  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);
  247:             return -1;
  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);
  254:             return -1;
  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);
  260:             return -1;
  261:         }
  262:     }
  263:     return 0;
  264: }
  265: 
  266: static int img_create(int argc, char **argv)
  267: {
  268:     int c, ret = 0, flags;
  269:     const char *fmt = "raw";
  270:     const char *base_fmt = NULL;
  271:     const char *filename;
  272:     const char *base_filename = NULL;
  273:     BlockDriver *drv, *proto_drv;
  274:     QEMUOptionParameter *param = NULL, *create_options = NULL;
  275:     char *options = NULL;
  276: 
  277:     flags = 0;
  278:     for(;;) {
  279:         c = getopt(argc, argv, "F:b:f:he6o:");
  280:         if (c == -1)
  281:             break;
  282:         switch(c) {
  283:         case 'h':
  284:             help();
  285:             break;
  286:         case 'F':
  287:             base_fmt = optarg;
  288:             break;
  289:         case 'b':
  290:             base_filename = optarg;
  291:             break;
  292:         case 'f':
  293:             fmt = optarg;
  294:             break;
  295:         case 'e':
  296:             flags |= BLOCK_FLAG_ENCRYPT;
  297:             break;
  298:         case '6':
  299:             flags |= BLOCK_FLAG_COMPAT6;
  300:             break;
  301:         case 'o':
  302:             options = optarg;
  303:             break;
  304:         }
  305:     }
  306: 
  307:     /* Get the filename */
  308:     if (optind >= argc)
  309:         help();
  310:     filename = argv[optind++];
  311: 
  312:     /* Find driver and parse its options */
  313:     drv = bdrv_find_format(fmt);
  314:     if (!drv) {
  315:         error("Unknown file format '%s'", fmt);
  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);
  329: 
  330:     if (options && !strcmp(options, "?")) {
  331:         print_option_help(create_options);
  332:         goto out;
  333:     }
  334: 
  335:     /* Create parameter list with default values */
  336:     param = parse_option_parameters("", create_options, param);
  337:     set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
  338: 
  339:     /* Parse -o options */
  340:     if (options) {
  341:         param = parse_option_parameters(options, create_options, param);
  342:         if (param == NULL) {
  343:             error("Invalid options for file format '%s'.", fmt);
  344:             ret = -1;
  345:             goto out;
  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 */
  355:     ret = add_old_style_options(fmt, param, flags, base_filename, base_fmt);
  356:     if (ret < 0) {
  357:         goto out;
  358:     }
  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
  362:     if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
  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);
  381:                      ret = -1;
  382:                      goto out;
  383:                 }
  384:             }
  385: 
  386:             bs = bdrv_new_open(backing_file->value.s, fmt, BDRV_O_FLAGS);
  387:             if (!bs) {
  388:                 ret = -1;
  389:                 goto out;
  390:             }
  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);
  397:         } else {
  398:             error("Image creation needs a size parameter");
  399:             ret = -1;
  400:             goto out;
  401:         }
  402:     }
  403: 
  404:     printf("Formatting '%s', fmt=%s ", filename, fmt);
  405:     print_option_parameters(param);
  406:     puts("");
  407: 
  408:     ret = bdrv_create(drv, filename, param);
  409:     free_option_parameters(create_options);
  410:     free_option_parameters(param);
  411: 
  412:     if (ret < 0) {
  413:         if (ret == -ENOTSUP) {
  414:             error("Formatting or formatting option not supported for file format '%s'", fmt);
  415:         } else if (ret == -EFBIG) {
  416:             error("The image size is too large for file format '%s'", fmt);
  417:         } else {
  418:             error("%s: error while creating %s: %s", filename, fmt, strerror(-ret));
  419:         }
  420:     }
  421: out:
  422:     if (ret) {
  423:         return 1;
  424:     }
  425:     return 0;
  426: }
  427: 
  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:  */
  436: static int img_check(int argc, char **argv)
  437: {
  438:     int c, ret;
  439:     const char *filename, *fmt;
  440:     BlockDriverState *bs;
  441:     BdrvCheckResult result;
  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: 
  461:     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
  462:     if (!bs) {
  463:         return 1;
  464:     }
  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;
  471:     }
  472: 
  473:     if (!(result.corruptions || result.leaks || result.check_errors)) {
  474:         printf("No errors were found on the image.\n");
  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);
  492:         }
  493:     }
  494: 
  495:     bdrv_delete(bs);
  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:     }
  511: }
  512: 
  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:     }
  533:     if (optind >= argc)
  534:         help();
  535:     filename = argv[optind++];
  536: 
  537:     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_RDWR);
  538:     if (!bs) {
  539:         return 1;
  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);
  561:     if (ret) {
  562:         return 1;
  563:     }
  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: 
  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:  */
  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: 
  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: 
  634: #define IO_BUF_SIZE (2 * 1024 * 1024)
  635: 
  636: static int img_convert(int argc, char **argv)
  637: {
  638:     int c, ret = 0, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
  639:     const char *fmt, *out_fmt, *out_baseimg, *out_filename;
  640:     BlockDriver *drv, *proto_drv;
  641:     BlockDriverState **bs = NULL, *out_bs = NULL;
  642:     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
  643:     uint64_t bs_sectors;
  644:     uint8_t * buf = NULL;
  645:     const uint8_t *buf1;
  646:     BlockDriverInfo bdi;
  647:     QEMUOptionParameter *param = NULL, *create_options = NULL;
  648:     char *options = NULL;
  649: 
  650:     fmt = NULL;
  651:     out_fmt = "raw";
  652:     out_baseimg = NULL;
  653:     flags = 0;
  654:     for(;;) {
  655:         c = getopt(argc, argv, "f:O:B:hce6o:");
  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;
  668:         case 'B':
  669:             out_baseimg = optarg;
  670:             break;
  671:         case 'c':
  672:             flags |= BLOCK_FLAG_COMPRESS;
  673:             break;
  674:         case 'e':
  675:             flags |= BLOCK_FLAG_ENCRYPT;
  676:             break;
  677:         case '6':
  678:             flags |= BLOCK_FLAG_COMPAT6;
  679:             break;
  680:         case 'o':
  681:             options = optarg;
  682:             break;
  683:         }
  684:     }
  685: 
  686:     bs_n = argc - optind - 1;
  687:     if (bs_n < 1) help();
  688: 
  689:     out_filename = argv[argc - 1];
  690: 
  691:     if (bs_n > 1 && out_baseimg) {
  692:         error("-B makes no sense when concatenating multiple input images");
  693:         return 1;
  694:     }
  695:         
  696:     bs = calloc(bs_n, sizeof(BlockDriverState *));
  697:     if (!bs) {
  698:         error("Out of memory");
  699:         return 1;
  700:     }
  701: 
  702:     total_sectors = 0;
  703:     for (bs_i = 0; bs_i < bs_n; bs_i++) {
  704:         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt, BDRV_O_FLAGS);
  705:         if (!bs[bs_i]) {
  706:             error("Could not open '%s'", argv[optind + bs_i]);
  707:             ret = -1;
  708:             goto out;
  709:         }
  710:         bdrv_get_geometry(bs[bs_i], &bs_sectors);
  711:         total_sectors += bs_sectors;
  712:     }
  713: 
  714:     /* Find driver and parse its options */
  715:     drv = bdrv_find_format(out_fmt);
  716:     if (!drv) {
  717:         error("Unknown file format '%s'", out_fmt);
  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:     }
  728: 
  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);
  733:     if (options && !strcmp(options, "?")) {
  734:         print_option_help(create_options);
  735:         goto out;
  736:     }
  737: 
  738:     if (options) {
  739:         param = parse_option_parameters(options, create_options, param);
  740:         if (param == NULL) {
  741:             error("Invalid options for file format '%s'.", out_fmt);
  742:             ret = -1;
  743:             goto out;
  744:         }
  745:     } else {
  746:         param = parse_option_parameters("", create_options, param);
  747:     }
  748: 
  749:     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
  750:     ret = add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
  751:     if (ret < 0) {
  752:         goto out;
  753:     }
  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");
  762:             ret = -1;
  763:             goto out;
  764:         }
  765: 
  766:         if (encryption && encryption->value.n) {
  767:             error("Compression and encryption not supported at the same time");
  768:             ret = -1;
  769:             goto out;
  770:         }
  771:     }
  772: 
  773:     /* Create the new image */
  774:     ret = bdrv_create(drv, out_filename, param);
  775:     if (ret < 0) {
  776:         if (ret == -ENOTSUP) {
  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);
  780:         } else {
  781:             error("%s: error while converting %s: %s", out_filename, out_fmt, strerror(-ret));
  782:         }
  783:         goto out;
  784:     }
  785: 
  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:     }
  792: 
  793:     bs_i = 0;
  794:     bs_offset = 0;
  795:     bdrv_get_geometry(bs[0], &bs_sectors);
  796:     buf = qemu_malloc(IO_BUF_SIZE);
  797: 
  798:     if (flags & BLOCK_FLAG_COMPRESS) {
  799:         ret = bdrv_get_info(out_bs, &bdi);
  800:         if (ret < 0) {
  801:             error("could not get block driver info");
  802:             goto out;
  803:         }
  804:         cluster_size = bdi.cluster_size;
  805:         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE) {
  806:             error("invalid cluster size");
  807:             ret = -1;
  808:             goto out;
  809:         }
  810:         cluster_sectors = cluster_size >> 9;
  811:         sector_num = 0;
  812:         for(;;) {
  813:             int64_t bs_num;
  814:             int remainder;
  815:             uint8_t *buf2;
  816: 
  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;
  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;
  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); */
  840:                 }
  841:                 assert (bs_num < bs_sectors);
  842: 
  843:                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
  844: 
  845:                 ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
  846:                 if (ret < 0) {
  847:                     error("error while reading");
  848:                     goto out;
  849:                 }
  850: 
  851:                 buf2 += nlow * 512;
  852:                 bs_num += nlow;
  853: 
  854:                 remainder -= nlow;
  855:             }
  856:             assert (remainder == 0);
  857: 
  858:             if (n < cluster_sectors)
  859:                 memset(buf + n * 512, 0, cluster_size - n * 512);
  860:             if (is_not_zero(buf, cluster_size)) {
  861:                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
  862:                                             cluster_sectors);
  863:                 if (ret != 0) {
  864:                     error("error while compressing sector %" PRId64,
  865:                           sector_num);
  866:                     goto out;
  867:                 }
  868:             }
  869:             sector_num += n;
  870:         }
  871:         /* signal EOF to align */
  872:         bdrv_write_compressed(out_bs, 0, NULL, 0);
  873:     } else {
  874:         int has_zero_init = bdrv_has_zero_init(out_bs);
  875: 
  876:         sector_num = 0; // total number of sectors converted so far
  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;
  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);
  891:                 /* printf("changing part: sector_num=%" PRId64 ", bs_i=%d, "
  892:                   "bs_offset=%" PRId64 ", bs_sectors=%" PRId64 "\n",
  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: 
  899:             if (has_zero_init) {
  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;
  916:             }
  917: 
  918:             ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
  919:             if (ret < 0) {
  920:                 error("error while reading");
  921:                 goto out;
  922:             }
  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) {
  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,
  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. */
  935:                 if (!has_zero_init || out_baseimg ||
  936:                     is_allocated_sectors(buf1, n, &n1)) {
  937:                     ret = bdrv_write(out_bs, sector_num, buf1, n1);
  938:                     if (ret < 0) {
  939:                         error("error while writing");
  940:                         goto out;
  941:                     }
  942:                 }
  943:                 sector_num += n1;
  944:                 n -= n1;
  945:                 buf1 += n1 * 512;
  946:             }
  947:         }
  948:     }
  949: out:
  950:     free_option_parameters(create_options);
  951:     free_option_parameters(param);
  952:     qemu_free(buf);
  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:     }
  961:     free(bs);
  962:     if (ret) {
  963:         return 1;
  964:     }
  965:     return 0;
  966: }
  967: 
  968: #ifdef _WIN32
  969: static int64_t get_allocated_file_size(const char *filename)
  970: {
  971:     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
  972:     get_compressed_t get_compressed;
  973:     struct _stati64 st;
  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: 
  984:     if (_stati64(filename, &st) < 0)
  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;
  992:     if (stat(filename, &st) < 0)
  993:         return -1;
  994:     return (int64_t)st.st_blocks * 512;
  995: }
  996: #endif
  997: 
  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: 
 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];
 1022:     uint64_t total_sectors;
 1023:     int64_t allocated_size;
 1024:     char backing_filename[1024];
 1025:     char backing_filename2[1024];
 1026:     BlockDriverInfo bdi;
 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:     }
 1042:     if (optind >= argc)
 1043:         help();
 1044:     filename = argv[optind++];
 1045: 
 1046:     bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS | BDRV_O_NO_BACKING);
 1047:     if (!bs) {
 1048:         return 1;
 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)
 1055:         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
 1056:     else
 1057:         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
 1058:                                 allocated_size);
 1059:     printf("image: %s\n"
 1060:            "file format: %s\n"
 1061:            "virtual size: %s (%" PRId64 " bytes)\n"
 1062:            "disk size: %s\n",
 1063:            filename, fmt_name, size_buf,
 1064:            (total_sectors * 512),
 1065:            dsize_buf);
 1066:     if (bdrv_is_encrypted(bs))
 1067:         printf("encrypted: yes\n");
 1068:     if (bdrv_get_info(bs, &bdi) >= 0) {
 1069:         if (bdi.cluster_size != 0)
 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);
 1076:         printf("backing file: %s (actual path: %s)\n",
 1077:                backing_filename,
 1078:                backing_filename2);
 1079:     }
 1080:     dump_snapshots(bs);
 1081:     bdrv_delete(bs);
 1082:     return 0;
 1083: }
 1084: 
 1085: #define SNAPSHOT_LIST   1
 1086: #define SNAPSHOT_CREATE 2
 1087: #define SNAPSHOT_APPLY  3
 1088: #define SNAPSHOT_DELETE 4
 1089: 
 1090: static int img_snapshot(int argc, char **argv)
 1091: {
 1092:     BlockDriverState *bs;
 1093:     QEMUSnapshotInfo sn;
 1094:     char *filename, *snapshot_name = NULL;
 1095:     int c, ret = 0, bdrv_oflags;
 1096:     int action = 0;
 1097:     qemu_timeval tv;
 1098: 
 1099:     bdrv_oflags = BDRV_O_RDWR;
 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();
 1108:             return 0;
 1109:         case 'l':
 1110:             if (action) {
 1111:                 help();
 1112:                 return 0;
 1113:             }
 1114:             action = SNAPSHOT_LIST;
 1115:             bdrv_oflags &= ~BDRV_O_RDWR; /* no need for RW */
 1116:             break;
 1117:         case 'a':
 1118:             if (action) {
 1119:                 help();
 1120:                 return 0;
 1121:             }
 1122:             action = SNAPSHOT_APPLY;
 1123:             snapshot_name = optarg;
 1124:             break;
 1125:         case 'c':
 1126:             if (action) {
 1127:                 help();
 1128:                 return 0;
 1129:             }
 1130:             action = SNAPSHOT_CREATE;
 1131:             snapshot_name = optarg;
 1132:             break;
 1133:         case 'd':
 1134:             if (action) {
 1135:                 help();
 1136:                 return 0;
 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 */
 1149:     bs = bdrv_new_open(filename, NULL, bdrv_oflags);
 1150:     if (!bs) {
 1151:         return 1;
 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);
 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:     }
 1471: 
 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:     }
 1503:     return 0;
 1504: }
 1505: 
 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: 
 1515: int main(int argc, char **argv)
 1516: {
 1517:     const img_cmd_t *cmd;
 1518:     const char *cmdname;
 1519: 
 1520:     bdrv_init();
 1521:     if (argc < 2)
 1522:         help();
 1523:     cmdname = argv[1];
 1524:     argc--; argv++;
 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:         }
 1531:     }
 1532: 
 1533:     /* not found */
 1534:     help();
 1535:     return 0;
 1536: }

unix.superglobalmegacorp.com