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

unix.superglobalmegacorp.com