File:  [Qemu by Fabrice Bellard] / qemu / qemu-img.c
Revision 1.1.1.13 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:56:18 2018 UTC (3 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

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

unix.superglobalmegacorp.com