Annotation of qemu/qemu-img.c, revision 1.1.1.8

1.1       root        1: /*
1.1.1.3   root        2:  * QEMU disk image utility
1.1.1.4   root        3:  *
                      4:  * Copyright (c) 2003-2008 Fabrice Bellard
                      5:  *
1.1       root        6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
                      7:  * of this software and associated documentation files (the "Software"), to deal
                      8:  * in the Software without restriction, including without limitation the rights
                      9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                     10:  * copies of the Software, and to permit persons to whom the Software is
                     11:  * furnished to do so, subject to the following conditions:
                     12:  *
                     13:  * The above copyright notice and this permission notice shall be included in
                     14:  * all copies or substantial portions of the Software.
                     15:  *
                     16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                     17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                     18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
                     19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                     20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                     21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
                     22:  * THE SOFTWARE.
                     23:  */
1.1.1.4   root       24: #include "qemu-common.h"
1.1.1.8 ! root       25: #include "qemu-option.h"
1.1.1.5   root       26: #include "osdep.h"
1.1.1.4   root       27: #include "block_int.h"
1.1.1.8 ! root       28: #include <stdio.h>
1.1       root       29: 
1.1.1.2   root       30: #ifdef _WIN32
                     31: #include <windows.h>
                     32: #endif
                     33: 
1.1.1.8 ! root       34: typedef struct img_cmd_t {
        !            35:     const char *name;
        !            36:     int (*handler)(int argc, char **argv);
        !            37: } img_cmd_t;
        !            38: 
1.1.1.5   root       39: /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
                     40: #define BRDV_O_FLAGS BDRV_O_CACHE_WB
1.1       root       41: 
1.1.1.5   root       42: static void QEMU_NORETURN error(const char *fmt, ...)
1.1       root       43: {
                     44:     va_list ap;
                     45:     va_start(ap, fmt);
                     46:     fprintf(stderr, "qemu-img: ");
                     47:     vfprintf(stderr, fmt, ap);
                     48:     fprintf(stderr, "\n");
                     49:     exit(1);
                     50:     va_end(ap);
                     51: }
                     52: 
                     53: static void format_print(void *opaque, const char *name)
                     54: {
                     55:     printf(" %s", name);
                     56: }
                     57: 
1.1.1.5   root       58: /* Please keep in synch with qemu-img.texi */
1.1.1.4   root       59: static void help(void)
1.1       root       60: {
1.1.1.4   root       61:     printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
1.1       root       62:            "usage: qemu-img command [command options]\n"
                     63:            "QEMU disk image utility\n"
                     64:            "\n"
                     65:            "Command syntax:\n"
1.1.1.8 ! root       66: #define DEF(option, callback, arg_string)        \
        !            67:            "  " arg_string "\n"
        !            68: #include "qemu-img-cmds.h"
        !            69: #undef DEF
        !            70: #undef GEN_DOCS
1.1       root       71:            "\n"
                     72:            "Command parameters:\n"
                     73:            "  'filename' is a disk image filename\n"
                     74:            "  'base_image' is the read-only disk image which is used as base for a copy on\n"
                     75:            "    write image; the copy on write image only stores the modified data\n"
1.1.1.5   root       76:            "  'output_base_image' forces the output image to be created as a copy on write\n"
                     77:            "    image of the specified base image; 'output_base_image' should have the same\n"
                     78:            "    content as the input's base image, however the path, image format, etc may\n"
                     79:            "    differ\n"
1.1       root       80:            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
1.1.1.5   root       81:            "  'size' is the disk image size in kilobytes. Optional suffixes\n"
1.1.1.6   root       82:            "    'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\n"
                     83:            "    supported any 'k' or 'K' is ignored\n"
1.1       root       84:            "  'output_filename' is the destination disk image filename\n"
                     85:            "  'output_fmt' is the destination format\n"
1.1.1.8 ! root       86:            "  'options' is a comma separated list of format specific options in a\n"
        !            87:            "    name=value format. Use -o ? for an overview of the options supported by the\n"
        !            88:            "    used format\n"
1.1       root       89:            "  '-c' indicates that target image must be compressed (qcow format only)\n"
1.1.1.5   root       90:            "  '-h' with or without a command shows this help and lists the supported formats\n"
                     91:            "\n"
                     92:            "Parameters to snapshot subcommand:\n"
                     93:            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
                     94:            "  '-a' applies a snapshot (revert disk to saved state)\n"
                     95:            "  '-c' creates a snapshot\n"
                     96:            "  '-d' deletes a snapshot\n"
                     97:            "  '-l' lists all snapshots in the given image\n"
1.1       root       98:            );
1.1.1.5   root       99:     printf("\nSupported formats:");
1.1       root      100:     bdrv_iterate_format(format_print, NULL);
                    101:     printf("\n");
                    102:     exit(1);
                    103: }
                    104: 
                    105: #if defined(WIN32)
                    106: /* XXX: put correct support for win32 */
                    107: static int read_password(char *buf, int buf_size)
                    108: {
                    109:     int c, i;
                    110:     printf("Password: ");
                    111:     fflush(stdout);
                    112:     i = 0;
                    113:     for(;;) {
                    114:         c = getchar();
                    115:         if (c == '\n')
                    116:             break;
                    117:         if (i < (buf_size - 1))
                    118:             buf[i++] = c;
                    119:     }
                    120:     buf[i] = '\0';
                    121:     return 0;
                    122: }
                    123: 
                    124: #else
                    125: 
                    126: #include <termios.h>
                    127: 
                    128: static struct termios oldtty;
                    129: 
                    130: static void term_exit(void)
                    131: {
                    132:     tcsetattr (0, TCSANOW, &oldtty);
                    133: }
                    134: 
                    135: static void term_init(void)
                    136: {
                    137:     struct termios tty;
                    138: 
                    139:     tcgetattr (0, &tty);
                    140:     oldtty = tty;
                    141: 
                    142:     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                    143:                           |INLCR|IGNCR|ICRNL|IXON);
                    144:     tty.c_oflag |= OPOST;
                    145:     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
                    146:     tty.c_cflag &= ~(CSIZE|PARENB);
                    147:     tty.c_cflag |= CS8;
                    148:     tty.c_cc[VMIN] = 1;
                    149:     tty.c_cc[VTIME] = 0;
1.1.1.4   root      150: 
1.1       root      151:     tcsetattr (0, TCSANOW, &tty);
                    152: 
                    153:     atexit(term_exit);
                    154: }
                    155: 
1.1.1.4   root      156: static int read_password(char *buf, int buf_size)
1.1       root      157: {
                    158:     uint8_t ch;
                    159:     int i, ret;
                    160: 
                    161:     printf("password: ");
                    162:     fflush(stdout);
                    163:     term_init();
                    164:     i = 0;
                    165:     for(;;) {
                    166:         ret = read(0, &ch, 1);
                    167:         if (ret == -1) {
                    168:             if (errno == EAGAIN || errno == EINTR) {
                    169:                 continue;
                    170:             } else {
                    171:                 ret = -1;
                    172:                 break;
                    173:             }
                    174:         } else if (ret == 0) {
                    175:             ret = -1;
                    176:             break;
                    177:         } else {
                    178:             if (ch == '\r') {
                    179:                 ret = 0;
                    180:                 break;
                    181:             }
                    182:             if (i < (buf_size - 1))
                    183:                 buf[i++] = ch;
                    184:         }
                    185:     }
                    186:     term_exit();
                    187:     buf[i] = '\0';
                    188:     printf("\n");
                    189:     return ret;
                    190: }
                    191: #endif
                    192: 
                    193: static BlockDriverState *bdrv_new_open(const char *filename,
                    194:                                        const char *fmt)
                    195: {
                    196:     BlockDriverState *bs;
                    197:     BlockDriver *drv;
                    198:     char password[256];
                    199: 
                    200:     bs = bdrv_new("");
                    201:     if (!bs)
                    202:         error("Not enough memory");
                    203:     if (fmt) {
                    204:         drv = bdrv_find_format(fmt);
                    205:         if (!drv)
                    206:             error("Unknown file format '%s'", fmt);
                    207:     } else {
                    208:         drv = NULL;
                    209:     }
1.1.1.5   root      210:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
1.1       root      211:         error("Could not open '%s'", filename);
                    212:     }
                    213:     if (bdrv_is_encrypted(bs)) {
                    214:         printf("Disk image '%s' is encrypted.\n", filename);
                    215:         if (read_password(password, sizeof(password)) < 0)
                    216:             error("No password given");
                    217:         if (bdrv_set_key(bs, password) < 0)
                    218:             error("invalid password");
                    219:     }
                    220:     return bs;
                    221: }
                    222: 
1.1.1.8 ! root      223: static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
        !           224:     int flags, const char *base_filename, const char *base_fmt)
        !           225: {
        !           226:     if (flags & BLOCK_FLAG_ENCRYPT) {
        !           227:         if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
        !           228:             error("Encryption not supported for file format '%s'", fmt);
        !           229:         }
        !           230:     }
        !           231:     if (flags & BLOCK_FLAG_COMPAT6) {
        !           232:         if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
        !           233:             error("VMDK version 6 not supported for file format '%s'", fmt);
        !           234:         }
        !           235:     }
        !           236: 
        !           237:     if (base_filename) {
        !           238:         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
        !           239:             error("Backing file not supported for file format '%s'", fmt);
        !           240:         }
        !           241:     }
        !           242:     if (base_fmt) {
        !           243:         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
        !           244:             error("Backing file format not supported for file format '%s'", fmt);
        !           245:         }
        !           246:     }
        !           247: }
        !           248: 
1.1       root      249: static int img_create(int argc, char **argv)
                    250: {
1.1.1.4   root      251:     int c, ret, flags;
1.1       root      252:     const char *fmt = "raw";
1.1.1.8 ! root      253:     const char *base_fmt = NULL;
1.1       root      254:     const char *filename;
                    255:     const char *base_filename = NULL;
                    256:     BlockDriver *drv;
1.1.1.8 ! root      257:     QEMUOptionParameter *param = NULL;
        !           258:     char *options = NULL;
1.1.1.4   root      259: 
                    260:     flags = 0;
1.1       root      261:     for(;;) {
1.1.1.8 ! root      262:         c = getopt(argc, argv, "F:b:f:he6o:");
1.1       root      263:         if (c == -1)
                    264:             break;
                    265:         switch(c) {
                    266:         case 'h':
                    267:             help();
                    268:             break;
1.1.1.8 ! root      269:         case 'F':
        !           270:             base_fmt = optarg;
        !           271:             break;
1.1       root      272:         case 'b':
                    273:             base_filename = optarg;
                    274:             break;
                    275:         case 'f':
                    276:             fmt = optarg;
                    277:             break;
                    278:         case 'e':
1.1.1.4   root      279:             flags |= BLOCK_FLAG_ENCRYPT;
                    280:             break;
                    281:         case '6':
                    282:             flags |= BLOCK_FLAG_COMPAT6;
1.1       root      283:             break;
1.1.1.8 ! root      284:         case 'o':
        !           285:             options = optarg;
        !           286:             break;
1.1       root      287:         }
                    288:     }
1.1.1.8 ! root      289: 
        !           290:     /* Find driver and parse its options */
        !           291:     drv = bdrv_find_format(fmt);
        !           292:     if (!drv)
        !           293:         error("Unknown file format '%s'", fmt);
        !           294: 
        !           295:     if (options && !strcmp(options, "?")) {
        !           296:         print_option_help(drv->create_options);
        !           297:         return 0;
        !           298:     }
        !           299: 
        !           300:     if (options) {
        !           301:         param = parse_option_parameters(options, drv->create_options, param);
        !           302:         if (param == NULL) {
        !           303:             error("Invalid options for file format '%s'.", fmt);
        !           304:         }
        !           305:     } else {
        !           306:         param = parse_option_parameters("", drv->create_options, param);
        !           307:     }
        !           308: 
        !           309:     /* Get the filename */
1.1.1.4   root      310:     if (optind >= argc)
1.1       root      311:         help();
                    312:     filename = argv[optind++];
1.1.1.8 ! root      313: 
        !           314:     /* Add size to parameters */
        !           315:     if (optind < argc) {
        !           316:         set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
        !           317:     }
        !           318: 
        !           319:     /* Add old-style options to parameters */
        !           320:     add_old_style_options(fmt, param, flags, base_filename, base_fmt);
        !           321: 
        !           322:     // The size for the image must always be specified, with one exception:
        !           323:     // If we are using a backing file, we can obtain the size from there
        !           324:     if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {
        !           325: 
        !           326:         QEMUOptionParameter *backing_file =
        !           327:             get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
        !           328:         QEMUOptionParameter *backing_fmt =
        !           329:             get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
        !           330: 
        !           331:         if (backing_file && backing_file->value.s) {
        !           332:             BlockDriverState *bs;
        !           333:             uint64_t size;
        !           334:             const char *fmt = NULL;
        !           335:             char buf[32];
        !           336: 
        !           337:             if (backing_fmt && backing_fmt->value.s) {
        !           338:                  if (bdrv_find_format(backing_fmt->value.s)) {
        !           339:                      fmt = backing_fmt->value.s;
        !           340:                 } else {
        !           341:                      error("Unknown backing file format '%s'",
        !           342:                         backing_fmt->value.s);
        !           343:                 }
        !           344:             }
        !           345: 
        !           346:             bs = bdrv_new_open(backing_file->value.s, fmt);
        !           347:             bdrv_get_geometry(bs, &size);
        !           348:             size *= 512;
        !           349:             bdrv_delete(bs);
        !           350: 
        !           351:             snprintf(buf, sizeof(buf), "%" PRId64, size);
        !           352:             set_option_parameter(param, BLOCK_OPT_SIZE, buf);
1.1       root      353:         } else {
1.1.1.8 ! root      354:             error("Image creation needs a size parameter");
1.1       root      355:         }
                    356:     }
1.1.1.8 ! root      357: 
        !           358:     printf("Formatting '%s', fmt=%s ", filename, fmt);
        !           359:     print_option_parameters(param);
        !           360:     puts("");
        !           361: 
        !           362:     ret = bdrv_create(drv, filename, param);
        !           363:     free_option_parameters(param);
        !           364: 
1.1       root      365:     if (ret < 0) {
                    366:         if (ret == -ENOTSUP) {
                    367:             error("Formatting or formatting option not supported for file format '%s'", fmt);
1.1.1.7   root      368:         } else if (ret == -EFBIG) {
                    369:             error("The image size is too large for file format '%s'", fmt);
1.1       root      370:         } else {
                    371:             error("Error while formatting");
                    372:         }
                    373:     }
                    374:     return 0;
                    375: }
                    376: 
1.1.1.8 ! root      377: static int img_check(int argc, char **argv)
        !           378: {
        !           379:     int c, ret;
        !           380:     const char *filename, *fmt;
        !           381:     BlockDriver *drv;
        !           382:     BlockDriverState *bs;
        !           383: 
        !           384:     fmt = NULL;
        !           385:     for(;;) {
        !           386:         c = getopt(argc, argv, "f:h");
        !           387:         if (c == -1)
        !           388:             break;
        !           389:         switch(c) {
        !           390:         case 'h':
        !           391:             help();
        !           392:             break;
        !           393:         case 'f':
        !           394:             fmt = optarg;
        !           395:             break;
        !           396:         }
        !           397:     }
        !           398:     if (optind >= argc)
        !           399:         help();
        !           400:     filename = argv[optind++];
        !           401: 
        !           402:     bs = bdrv_new("");
        !           403:     if (!bs)
        !           404:         error("Not enough memory");
        !           405:     if (fmt) {
        !           406:         drv = bdrv_find_format(fmt);
        !           407:         if (!drv)
        !           408:             error("Unknown file format '%s'", fmt);
        !           409:     } else {
        !           410:         drv = NULL;
        !           411:     }
        !           412:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
        !           413:         error("Could not open '%s'", filename);
        !           414:     }
        !           415:     ret = bdrv_check(bs);
        !           416:     switch(ret) {
        !           417:     case 0:
        !           418:         printf("No errors were found on the image.\n");
        !           419:         break;
        !           420:     case -ENOTSUP:
        !           421:         error("This image format does not support checks");
        !           422:         break;
        !           423:     default:
        !           424:         if (ret < 0) {
        !           425:             error("An error occurred during the check");
        !           426:         } else {
        !           427:             printf("%d errors were found on the image.\n", ret);
        !           428:         }
        !           429:         break;
        !           430:     }
        !           431: 
        !           432:     bdrv_delete(bs);
        !           433:     return 0;
        !           434: }
        !           435: 
1.1       root      436: static int img_commit(int argc, char **argv)
                    437: {
                    438:     int c, ret;
                    439:     const char *filename, *fmt;
                    440:     BlockDriver *drv;
                    441:     BlockDriverState *bs;
                    442: 
                    443:     fmt = NULL;
                    444:     for(;;) {
                    445:         c = getopt(argc, argv, "f:h");
                    446:         if (c == -1)
                    447:             break;
                    448:         switch(c) {
                    449:         case 'h':
                    450:             help();
                    451:             break;
                    452:         case 'f':
                    453:             fmt = optarg;
                    454:             break;
                    455:         }
                    456:     }
1.1.1.4   root      457:     if (optind >= argc)
1.1       root      458:         help();
                    459:     filename = argv[optind++];
                    460: 
                    461:     bs = bdrv_new("");
                    462:     if (!bs)
                    463:         error("Not enough memory");
                    464:     if (fmt) {
                    465:         drv = bdrv_find_format(fmt);
                    466:         if (!drv)
                    467:             error("Unknown file format '%s'", fmt);
                    468:     } else {
                    469:         drv = NULL;
                    470:     }
1.1.1.5   root      471:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
1.1       root      472:         error("Could not open '%s'", filename);
                    473:     }
                    474:     ret = bdrv_commit(bs);
                    475:     switch(ret) {
                    476:     case 0:
                    477:         printf("Image committed.\n");
                    478:         break;
                    479:     case -ENOENT:
                    480:         error("No disk inserted");
                    481:         break;
                    482:     case -EACCES:
                    483:         error("Image is read-only");
                    484:         break;
                    485:     case -ENOTSUP:
                    486:         error("Image is already committed");
                    487:         break;
                    488:     default:
                    489:         error("Error while committing image");
                    490:         break;
                    491:     }
                    492: 
                    493:     bdrv_delete(bs);
                    494:     return 0;
                    495: }
                    496: 
                    497: static int is_not_zero(const uint8_t *sector, int len)
                    498: {
                    499:     int i;
                    500:     len >>= 2;
                    501:     for(i = 0;i < len; i++) {
                    502:         if (((uint32_t *)sector)[i] != 0)
                    503:             return 1;
                    504:     }
                    505:     return 0;
                    506: }
                    507: 
1.1.1.5   root      508: /*
                    509:  * Returns true iff the first sector pointed to by 'buf' contains at least
                    510:  * a non-NUL byte.
                    511:  *
                    512:  * 'pnum' is set to the number of sectors (including and immediately following
                    513:  * the first one) that are known to be in the same allocated/unallocated state.
                    514:  */
1.1       root      515: static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
                    516: {
                    517:     int v, i;
                    518: 
                    519:     if (n <= 0) {
                    520:         *pnum = 0;
                    521:         return 0;
                    522:     }
                    523:     v = is_not_zero(buf, 512);
                    524:     for(i = 1; i < n; i++) {
                    525:         buf += 512;
                    526:         if (v != is_not_zero(buf, 512))
                    527:             break;
                    528:     }
                    529:     *pnum = i;
                    530:     return v;
                    531: }
                    532: 
                    533: #define IO_BUF_SIZE 65536
                    534: 
                    535: static int img_convert(int argc, char **argv)
                    536: {
1.1.1.4   root      537:     int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
1.1.1.5   root      538:     const char *fmt, *out_fmt, *out_baseimg, *out_filename;
1.1       root      539:     BlockDriver *drv;
1.1.1.4   root      540:     BlockDriverState **bs, *out_bs;
                    541:     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
                    542:     uint64_t bs_sectors;
1.1       root      543:     uint8_t buf[IO_BUF_SIZE];
                    544:     const uint8_t *buf1;
1.1.1.3   root      545:     BlockDriverInfo bdi;
1.1.1.8 ! root      546:     QEMUOptionParameter *param = NULL;
        !           547:     char *options = NULL;
1.1       root      548: 
                    549:     fmt = NULL;
                    550:     out_fmt = "raw";
1.1.1.5   root      551:     out_baseimg = NULL;
1.1.1.4   root      552:     flags = 0;
1.1       root      553:     for(;;) {
1.1.1.8 ! root      554:         c = getopt(argc, argv, "f:O:B:hce6o:");
1.1       root      555:         if (c == -1)
                    556:             break;
                    557:         switch(c) {
                    558:         case 'h':
                    559:             help();
                    560:             break;
                    561:         case 'f':
                    562:             fmt = optarg;
                    563:             break;
                    564:         case 'O':
                    565:             out_fmt = optarg;
                    566:             break;
1.1.1.5   root      567:         case 'B':
                    568:             out_baseimg = optarg;
                    569:             break;
1.1       root      570:         case 'c':
1.1.1.4   root      571:             flags |= BLOCK_FLAG_COMPRESS;
1.1       root      572:             break;
                    573:         case 'e':
1.1.1.4   root      574:             flags |= BLOCK_FLAG_ENCRYPT;
                    575:             break;
                    576:         case '6':
                    577:             flags |= BLOCK_FLAG_COMPAT6;
1.1       root      578:             break;
1.1.1.8 ! root      579:         case 'o':
        !           580:             options = optarg;
        !           581:             break;
1.1       root      582:         }
                    583:     }
1.1.1.4   root      584: 
                    585:     bs_n = argc - optind - 1;
                    586:     if (bs_n < 1) help();
                    587: 
                    588:     out_filename = argv[argc - 1];
1.1.1.5   root      589: 
                    590:     if (bs_n > 1 && out_baseimg)
                    591:         error("-B makes no sense when concatenating multiple input images");
1.1.1.4   root      592:         
                    593:     bs = calloc(bs_n, sizeof(BlockDriverState *));
                    594:     if (!bs)
                    595:         error("Out of memory");
                    596: 
                    597:     total_sectors = 0;
                    598:     for (bs_i = 0; bs_i < bs_n; bs_i++) {
                    599:         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
                    600:         if (!bs[bs_i])
                    601:             error("Could not open '%s'", argv[optind + bs_i]);
                    602:         bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    603:         total_sectors += bs_sectors;
                    604:     }
1.1       root      605: 
1.1.1.8 ! root      606:     /* Find driver and parse its options */
1.1       root      607:     drv = bdrv_find_format(out_fmt);
                    608:     if (!drv)
1.1.1.4   root      609:         error("Unknown file format '%s'", out_fmt);
                    610: 
1.1.1.8 ! root      611:     if (options && !strcmp(options, "?")) {
        !           612:         print_option_help(drv->create_options);
        !           613:         return 0;
        !           614:     }
        !           615: 
        !           616:     if (options) {
        !           617:         param = parse_option_parameters(options, drv->create_options, param);
        !           618:         if (param == NULL) {
        !           619:             error("Invalid options for file format '%s'.", out_fmt);
        !           620:         }
        !           621:     } else {
        !           622:         param = parse_option_parameters("", drv->create_options, param);
        !           623:     }
        !           624: 
        !           625:     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
        !           626:     add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
        !           627: 
        !           628:     /* Check if compression is supported */
        !           629:     if (flags & BLOCK_FLAG_COMPRESS) {
        !           630:         QEMUOptionParameter *encryption =
        !           631:             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
        !           632: 
        !           633:         if (!drv->bdrv_write_compressed) {
        !           634:             error("Compression not supported for this file format");
        !           635:         }
        !           636: 
        !           637:         if (encryption && encryption->value.n) {
        !           638:             error("Compression and encryption not supported at the same time");
        !           639:         }
        !           640:     }
        !           641: 
        !           642:     /* Create the new image */
        !           643:     ret = bdrv_create(drv, out_filename, param);
        !           644:     free_option_parameters(param);
        !           645: 
1.1       root      646:     if (ret < 0) {
                    647:         if (ret == -ENOTSUP) {
1.1.1.7   root      648:             error("Formatting not supported for file format '%s'", out_fmt);
                    649:         } else if (ret == -EFBIG) {
                    650:             error("The image size is too large for file format '%s'", out_fmt);
1.1       root      651:         } else {
                    652:             error("Error while formatting '%s'", out_filename);
                    653:         }
                    654:     }
1.1.1.4   root      655: 
1.1       root      656:     out_bs = bdrv_new_open(out_filename, out_fmt);
                    657: 
1.1.1.4   root      658:     bs_i = 0;
                    659:     bs_offset = 0;
                    660:     bdrv_get_geometry(bs[0], &bs_sectors);
                    661: 
                    662:     if (flags & BLOCK_FLAG_COMPRESS) {
1.1.1.3   root      663:         if (bdrv_get_info(out_bs, &bdi) < 0)
                    664:             error("could not get block driver info");
                    665:         cluster_size = bdi.cluster_size;
1.1       root      666:         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
                    667:             error("invalid cluster size");
                    668:         cluster_sectors = cluster_size >> 9;
                    669:         sector_num = 0;
                    670:         for(;;) {
1.1.1.4   root      671:             int64_t bs_num;
                    672:             int remainder;
                    673:             uint8_t *buf2;
                    674: 
1.1       root      675:             nb_sectors = total_sectors - sector_num;
                    676:             if (nb_sectors <= 0)
                    677:                 break;
                    678:             if (nb_sectors >= cluster_sectors)
                    679:                 n = cluster_sectors;
                    680:             else
                    681:                 n = nb_sectors;
1.1.1.4   root      682: 
                    683:             bs_num = sector_num - bs_offset;
                    684:             assert (bs_num >= 0);
                    685:             remainder = n;
                    686:             buf2 = buf;
                    687:             while (remainder > 0) {
                    688:                 int nlow;
                    689:                 while (bs_num == bs_sectors) {
                    690:                     bs_i++;
                    691:                     assert (bs_i < bs_n);
                    692:                     bs_offset += bs_sectors;
                    693:                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    694:                     bs_num = 0;
                    695:                     /* printf("changing part: sector_num=%lld, "
                    696:                        "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
                    697:                        sector_num, bs_i, bs_offset, bs_sectors); */
                    698:                 }
                    699:                 assert (bs_num < bs_sectors);
                    700: 
                    701:                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
                    702: 
                    703:                 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 
                    704:                     error("error while reading");
                    705: 
                    706:                 buf2 += nlow * 512;
                    707:                 bs_num += nlow;
                    708: 
                    709:                 remainder -= nlow;
                    710:             }
                    711:             assert (remainder == 0);
                    712: 
1.1       root      713:             if (n < cluster_sectors)
                    714:                 memset(buf + n * 512, 0, cluster_size - n * 512);
                    715:             if (is_not_zero(buf, cluster_size)) {
1.1.1.4   root      716:                 if (bdrv_write_compressed(out_bs, sector_num, buf,
1.1.1.3   root      717:                                           cluster_sectors) != 0)
1.1.1.2   root      718:                     error("error while compressing sector %" PRId64,
                    719:                           sector_num);
1.1       root      720:             }
                    721:             sector_num += n;
                    722:         }
1.1.1.3   root      723:         /* signal EOF to align */
                    724:         bdrv_write_compressed(out_bs, 0, NULL, 0);
1.1       root      725:     } else {
1.1.1.5   root      726:         sector_num = 0; // total number of sectors converted so far
1.1       root      727:         for(;;) {
                    728:             nb_sectors = total_sectors - sector_num;
                    729:             if (nb_sectors <= 0)
                    730:                 break;
                    731:             if (nb_sectors >= (IO_BUF_SIZE / 512))
                    732:                 n = (IO_BUF_SIZE / 512);
                    733:             else
                    734:                 n = nb_sectors;
1.1.1.4   root      735: 
                    736:             while (sector_num - bs_offset >= bs_sectors) {
                    737:                 bs_i ++;
                    738:                 assert (bs_i < bs_n);
                    739:                 bs_offset += bs_sectors;
                    740:                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    741:                 /* printf("changing part: sector_num=%lld, bs_i=%d, "
                    742:                   "bs_offset=%lld, bs_sectors=%lld\n",
                    743:                    sector_num, bs_i, bs_offset, bs_sectors); */
                    744:             }
                    745: 
                    746:             if (n > bs_offset + bs_sectors - sector_num)
                    747:                 n = bs_offset + bs_sectors - sector_num;
                    748: 
1.1.1.8 ! root      749:             if (strcmp(drv->format_name, "host_device")) {
        !           750:                 /* If the output image is being created as a copy on write image,
        !           751:                    assume that sectors which are unallocated in the input image
        !           752:                    are present in both the output's and input's base images (no
        !           753:                    need to copy them). */
        !           754:                 if (out_baseimg) {
        !           755:                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
        !           756:                                            n, &n1)) {
        !           757:                         sector_num += n1;
        !           758:                         continue;
        !           759:                     }
        !           760:                     /* The next 'n1' sectors are allocated in the input image. Copy
        !           761:                        only those as they may be followed by unallocated sectors. */
        !           762:                     n = n1;
        !           763:                 }
        !           764:             } else {
        !           765:                 n1 = n;
1.1.1.5   root      766:             }
                    767: 
1.1.1.4   root      768:             if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 
1.1       root      769:                 error("error while reading");
                    770:             /* NOTE: at the same time we convert, we do not write zero
                    771:                sectors to have a chance to compress the image. Ideally, we
                    772:                should add a specific call to have the info to go faster */
                    773:             buf1 = buf;
                    774:             while (n > 0) {
1.1.1.5   root      775:                 /* If the output image is being created as a copy on write image,
                    776:                    copy all sectors even the ones containing only NUL bytes,
1.1.1.8 ! root      777:                    because they may differ from the sectors in the base image.
        !           778: 
        !           779:                    If the output is to a host device, we also write out
        !           780:                    sectors that are entirely 0, since whatever data was
        !           781:                    already there is garbage, not 0s. */
        !           782:                 if (strcmp(drv->format_name, "host_device") == 0 || out_baseimg ||
        !           783:                     is_allocated_sectors(buf1, n, &n1)) {
1.1.1.4   root      784:                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
1.1       root      785:                         error("error while writing");
                    786:                 }
                    787:                 sector_num += n1;
                    788:                 n -= n1;
                    789:                 buf1 += n1 * 512;
                    790:             }
                    791:         }
                    792:     }
                    793:     bdrv_delete(out_bs);
1.1.1.4   root      794:     for (bs_i = 0; bs_i < bs_n; bs_i++)
                    795:         bdrv_delete(bs[bs_i]);
                    796:     free(bs);
1.1       root      797:     return 0;
                    798: }
                    799: 
                    800: #ifdef _WIN32
                    801: static int64_t get_allocated_file_size(const char *filename)
                    802: {
1.1.1.2   root      803:     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
                    804:     get_compressed_t get_compressed;
1.1       root      805:     struct _stati64 st;
1.1.1.2   root      806: 
                    807:     /* WinNT support GetCompressedFileSize to determine allocate size */
                    808:     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
                    809:     if (get_compressed) {
                    810:        DWORD high, low;
                    811:        low = get_compressed(filename, &high);
                    812:        if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
                    813:            return (((int64_t) high) << 32) + low;
                    814:     }
                    815: 
1.1.1.4   root      816:     if (_stati64(filename, &st) < 0)
1.1       root      817:         return -1;
                    818:     return st.st_size;
                    819: }
                    820: #else
                    821: static int64_t get_allocated_file_size(const char *filename)
                    822: {
                    823:     struct stat st;
1.1.1.4   root      824:     if (stat(filename, &st) < 0)
1.1       root      825:         return -1;
                    826:     return (int64_t)st.st_blocks * 512;
                    827: }
                    828: #endif
                    829: 
1.1.1.3   root      830: static void dump_snapshots(BlockDriverState *bs)
                    831: {
                    832:     QEMUSnapshotInfo *sn_tab, *sn;
                    833:     int nb_sns, i;
                    834:     char buf[256];
                    835: 
                    836:     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
                    837:     if (nb_sns <= 0)
                    838:         return;
                    839:     printf("Snapshot list:\n");
                    840:     printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
                    841:     for(i = 0; i < nb_sns; i++) {
                    842:         sn = &sn_tab[i];
                    843:         printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
                    844:     }
                    845:     qemu_free(sn_tab);
                    846: }
                    847: 
1.1       root      848: static int img_info(int argc, char **argv)
                    849: {
                    850:     int c;
                    851:     const char *filename, *fmt;
                    852:     BlockDriver *drv;
                    853:     BlockDriverState *bs;
                    854:     char fmt_name[128], size_buf[128], dsize_buf[128];
1.1.1.4   root      855:     uint64_t total_sectors;
                    856:     int64_t allocated_size;
1.1.1.3   root      857:     char backing_filename[1024];
                    858:     char backing_filename2[1024];
                    859:     BlockDriverInfo bdi;
1.1       root      860: 
                    861:     fmt = NULL;
                    862:     for(;;) {
                    863:         c = getopt(argc, argv, "f:h");
                    864:         if (c == -1)
                    865:             break;
                    866:         switch(c) {
                    867:         case 'h':
                    868:             help();
                    869:             break;
                    870:         case 'f':
                    871:             fmt = optarg;
                    872:             break;
                    873:         }
                    874:     }
1.1.1.4   root      875:     if (optind >= argc)
1.1       root      876:         help();
                    877:     filename = argv[optind++];
                    878: 
                    879:     bs = bdrv_new("");
                    880:     if (!bs)
                    881:         error("Not enough memory");
                    882:     if (fmt) {
                    883:         drv = bdrv_find_format(fmt);
                    884:         if (!drv)
                    885:             error("Unknown file format '%s'", fmt);
                    886:     } else {
                    887:         drv = NULL;
                    888:     }
1.1.1.5   root      889:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
1.1       root      890:         error("Could not open '%s'", filename);
                    891:     }
                    892:     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
                    893:     bdrv_get_geometry(bs, &total_sectors);
                    894:     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
                    895:     allocated_size = get_allocated_file_size(filename);
                    896:     if (allocated_size < 0)
1.1.1.5   root      897:         snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
1.1       root      898:     else
1.1.1.4   root      899:         get_human_readable_size(dsize_buf, sizeof(dsize_buf),
1.1       root      900:                                 allocated_size);
                    901:     printf("image: %s\n"
                    902:            "file format: %s\n"
1.1.1.2   root      903:            "virtual size: %s (%" PRId64 " bytes)\n"
1.1       root      904:            "disk size: %s\n",
1.1.1.4   root      905:            filename, fmt_name, size_buf,
1.1.1.2   root      906:            (total_sectors * 512),
1.1       root      907:            dsize_buf);
                    908:     if (bdrv_is_encrypted(bs))
                    909:         printf("encrypted: yes\n");
1.1.1.3   root      910:     if (bdrv_get_info(bs, &bdi) >= 0) {
1.1.1.4   root      911:         if (bdi.cluster_size != 0)
1.1.1.3   root      912:             printf("cluster_size: %d\n", bdi.cluster_size);
                    913:     }
                    914:     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
                    915:     if (backing_filename[0] != '\0') {
                    916:         path_combine(backing_filename2, sizeof(backing_filename2),
                    917:                      filename, backing_filename);
1.1.1.4   root      918:         printf("backing file: %s (actual path: %s)\n",
1.1.1.3   root      919:                backing_filename,
                    920:                backing_filename2);
                    921:     }
                    922:     dump_snapshots(bs);
1.1       root      923:     bdrv_delete(bs);
                    924:     return 0;
                    925: }
                    926: 
1.1.1.5   root      927: #define SNAPSHOT_LIST   1
                    928: #define SNAPSHOT_CREATE 2
                    929: #define SNAPSHOT_APPLY  3
                    930: #define SNAPSHOT_DELETE 4
                    931: 
1.1.1.8 ! root      932: static int img_snapshot(int argc, char **argv)
1.1.1.5   root      933: {
                    934:     BlockDriverState *bs;
                    935:     QEMUSnapshotInfo sn;
                    936:     char *filename, *snapshot_name = NULL;
                    937:     int c, ret;
                    938:     int action = 0;
                    939:     qemu_timeval tv;
                    940: 
                    941:     /* Parse commandline parameters */
                    942:     for(;;) {
                    943:         c = getopt(argc, argv, "la:c:d:h");
                    944:         if (c == -1)
                    945:             break;
                    946:         switch(c) {
                    947:         case 'h':
                    948:             help();
1.1.1.8 ! root      949:             return 0;
1.1.1.5   root      950:         case 'l':
                    951:             if (action) {
                    952:                 help();
1.1.1.8 ! root      953:                 return 0;
1.1.1.5   root      954:             }
                    955:             action = SNAPSHOT_LIST;
                    956:             break;
                    957:         case 'a':
                    958:             if (action) {
                    959:                 help();
1.1.1.8 ! root      960:                 return 0;
1.1.1.5   root      961:             }
                    962:             action = SNAPSHOT_APPLY;
                    963:             snapshot_name = optarg;
                    964:             break;
                    965:         case 'c':
                    966:             if (action) {
                    967:                 help();
1.1.1.8 ! root      968:                 return 0;
1.1.1.5   root      969:             }
                    970:             action = SNAPSHOT_CREATE;
                    971:             snapshot_name = optarg;
                    972:             break;
                    973:         case 'd':
                    974:             if (action) {
                    975:                 help();
1.1.1.8 ! root      976:                 return 0;
1.1.1.5   root      977:             }
                    978:             action = SNAPSHOT_DELETE;
                    979:             snapshot_name = optarg;
                    980:             break;
                    981:         }
                    982:     }
                    983: 
                    984:     if (optind >= argc)
                    985:         help();
                    986:     filename = argv[optind++];
                    987: 
                    988:     /* Open the image */
                    989:     bs = bdrv_new("");
                    990:     if (!bs)
                    991:         error("Not enough memory");
                    992: 
                    993:     if (bdrv_open2(bs, filename, 0, NULL) < 0) {
                    994:         error("Could not open '%s'", filename);
                    995:     }
                    996: 
                    997:     /* Perform the requested action */
                    998:     switch(action) {
                    999:     case SNAPSHOT_LIST:
                   1000:         dump_snapshots(bs);
                   1001:         break;
                   1002: 
                   1003:     case SNAPSHOT_CREATE:
                   1004:         memset(&sn, 0, sizeof(sn));
                   1005:         pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
                   1006: 
                   1007:         qemu_gettimeofday(&tv);
                   1008:         sn.date_sec = tv.tv_sec;
                   1009:         sn.date_nsec = tv.tv_usec * 1000;
                   1010: 
                   1011:         ret = bdrv_snapshot_create(bs, &sn);
                   1012:         if (ret)
                   1013:             error("Could not create snapshot '%s': %d (%s)",
                   1014:                 snapshot_name, ret, strerror(-ret));
                   1015:         break;
                   1016: 
                   1017:     case SNAPSHOT_APPLY:
                   1018:         ret = bdrv_snapshot_goto(bs, snapshot_name);
                   1019:         if (ret)
                   1020:             error("Could not apply snapshot '%s': %d (%s)",
                   1021:                 snapshot_name, ret, strerror(-ret));
                   1022:         break;
                   1023: 
                   1024:     case SNAPSHOT_DELETE:
                   1025:         ret = bdrv_snapshot_delete(bs, snapshot_name);
                   1026:         if (ret)
                   1027:             error("Could not delete snapshot '%s': %d (%s)",
                   1028:                 snapshot_name, ret, strerror(-ret));
                   1029:         break;
                   1030:     }
                   1031: 
                   1032:     /* Cleanup */
                   1033:     bdrv_delete(bs);
1.1.1.8 ! root     1034: 
        !          1035:     return 0;
1.1.1.5   root     1036: }
                   1037: 
1.1.1.8 ! root     1038: static const img_cmd_t img_cmds[] = {
        !          1039: #define DEF(option, callback, arg_string)        \
        !          1040:     { option, callback },
        !          1041: #include "qemu-img-cmds.h"
        !          1042: #undef DEF
        !          1043: #undef GEN_DOCS
        !          1044:     { NULL, NULL, },
        !          1045: };
        !          1046: 
1.1       root     1047: int main(int argc, char **argv)
                   1048: {
1.1.1.8 ! root     1049:     const img_cmd_t *cmd;
        !          1050:     const char *cmdname;
1.1       root     1051: 
                   1052:     bdrv_init();
                   1053:     if (argc < 2)
                   1054:         help();
1.1.1.8 ! root     1055:     cmdname = argv[1];
1.1.1.5   root     1056:     argc--; argv++;
1.1.1.8 ! root     1057: 
        !          1058:     /* find the command */
        !          1059:     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
        !          1060:         if (!strcmp(cmdname, cmd->name)) {
        !          1061:             return cmd->handler(argc, argv);
        !          1062:         }
1.1       root     1063:     }
1.1.1.8 ! root     1064: 
        !          1065:     /* not found */
        !          1066:     help();
1.1       root     1067:     return 0;
                   1068: }

unix.superglobalmegacorp.com