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

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:            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
1.1.1.9   root       75:            "  'size' is the disk image size in bytes. Optional suffixes\n"
                     76:            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
                     77:            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
1.1       root       78:            "  'output_filename' is the destination disk image filename\n"
                     79:            "  'output_fmt' is the destination format\n"
1.1.1.8   root       80:            "  'options' is a comma separated list of format specific options in a\n"
                     81:            "    name=value format. Use -o ? for an overview of the options supported by the\n"
                     82:            "    used format\n"
1.1       root       83:            "  '-c' indicates that target image must be compressed (qcow format only)\n"
1.1.1.5   root       84:            "  '-h' with or without a command shows this help and lists the supported formats\n"
                     85:            "\n"
                     86:            "Parameters to snapshot subcommand:\n"
                     87:            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
                     88:            "  '-a' applies a snapshot (revert disk to saved state)\n"
                     89:            "  '-c' creates a snapshot\n"
                     90:            "  '-d' deletes a snapshot\n"
                     91:            "  '-l' lists all snapshots in the given image\n"
1.1       root       92:            );
1.1.1.5   root       93:     printf("\nSupported formats:");
1.1       root       94:     bdrv_iterate_format(format_print, NULL);
                     95:     printf("\n");
                     96:     exit(1);
                     97: }
                     98: 
                     99: #if defined(WIN32)
                    100: /* XXX: put correct support for win32 */
                    101: static int read_password(char *buf, int buf_size)
                    102: {
                    103:     int c, i;
                    104:     printf("Password: ");
                    105:     fflush(stdout);
                    106:     i = 0;
                    107:     for(;;) {
                    108:         c = getchar();
                    109:         if (c == '\n')
                    110:             break;
                    111:         if (i < (buf_size - 1))
                    112:             buf[i++] = c;
                    113:     }
                    114:     buf[i] = '\0';
                    115:     return 0;
                    116: }
                    117: 
                    118: #else
                    119: 
                    120: #include <termios.h>
                    121: 
                    122: static struct termios oldtty;
                    123: 
                    124: static void term_exit(void)
                    125: {
                    126:     tcsetattr (0, TCSANOW, &oldtty);
                    127: }
                    128: 
                    129: static void term_init(void)
                    130: {
                    131:     struct termios tty;
                    132: 
                    133:     tcgetattr (0, &tty);
                    134:     oldtty = tty;
                    135: 
                    136:     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                    137:                           |INLCR|IGNCR|ICRNL|IXON);
                    138:     tty.c_oflag |= OPOST;
                    139:     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
                    140:     tty.c_cflag &= ~(CSIZE|PARENB);
                    141:     tty.c_cflag |= CS8;
                    142:     tty.c_cc[VMIN] = 1;
                    143:     tty.c_cc[VTIME] = 0;
1.1.1.4   root      144: 
1.1       root      145:     tcsetattr (0, TCSANOW, &tty);
                    146: 
                    147:     atexit(term_exit);
                    148: }
                    149: 
1.1.1.4   root      150: static int read_password(char *buf, int buf_size)
1.1       root      151: {
                    152:     uint8_t ch;
                    153:     int i, ret;
                    154: 
                    155:     printf("password: ");
                    156:     fflush(stdout);
                    157:     term_init();
                    158:     i = 0;
                    159:     for(;;) {
                    160:         ret = read(0, &ch, 1);
                    161:         if (ret == -1) {
                    162:             if (errno == EAGAIN || errno == EINTR) {
                    163:                 continue;
                    164:             } else {
                    165:                 ret = -1;
                    166:                 break;
                    167:             }
                    168:         } else if (ret == 0) {
                    169:             ret = -1;
                    170:             break;
                    171:         } else {
                    172:             if (ch == '\r') {
                    173:                 ret = 0;
                    174:                 break;
                    175:             }
                    176:             if (i < (buf_size - 1))
                    177:                 buf[i++] = ch;
                    178:         }
                    179:     }
                    180:     term_exit();
                    181:     buf[i] = '\0';
                    182:     printf("\n");
                    183:     return ret;
                    184: }
                    185: #endif
                    186: 
                    187: static BlockDriverState *bdrv_new_open(const char *filename,
                    188:                                        const char *fmt)
                    189: {
                    190:     BlockDriverState *bs;
                    191:     BlockDriver *drv;
                    192:     char password[256];
                    193: 
                    194:     bs = bdrv_new("");
                    195:     if (!bs)
                    196:         error("Not enough memory");
                    197:     if (fmt) {
                    198:         drv = bdrv_find_format(fmt);
                    199:         if (!drv)
                    200:             error("Unknown file format '%s'", fmt);
                    201:     } else {
                    202:         drv = NULL;
                    203:     }
1.1.1.5   root      204:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
1.1       root      205:         error("Could not open '%s'", filename);
                    206:     }
                    207:     if (bdrv_is_encrypted(bs)) {
                    208:         printf("Disk image '%s' is encrypted.\n", filename);
                    209:         if (read_password(password, sizeof(password)) < 0)
                    210:             error("No password given");
                    211:         if (bdrv_set_key(bs, password) < 0)
                    212:             error("invalid password");
                    213:     }
                    214:     return bs;
                    215: }
                    216: 
1.1.1.8   root      217: static void add_old_style_options(const char *fmt, QEMUOptionParameter *list,
                    218:     int flags, const char *base_filename, const char *base_fmt)
                    219: {
                    220:     if (flags & BLOCK_FLAG_ENCRYPT) {
                    221:         if (set_option_parameter(list, BLOCK_OPT_ENCRYPT, "on")) {
                    222:             error("Encryption not supported for file format '%s'", fmt);
                    223:         }
                    224:     }
                    225:     if (flags & BLOCK_FLAG_COMPAT6) {
                    226:         if (set_option_parameter(list, BLOCK_OPT_COMPAT6, "on")) {
                    227:             error("VMDK version 6 not supported for file format '%s'", fmt);
                    228:         }
                    229:     }
                    230: 
                    231:     if (base_filename) {
                    232:         if (set_option_parameter(list, BLOCK_OPT_BACKING_FILE, base_filename)) {
                    233:             error("Backing file not supported for file format '%s'", fmt);
                    234:         }
                    235:     }
                    236:     if (base_fmt) {
                    237:         if (set_option_parameter(list, BLOCK_OPT_BACKING_FMT, base_fmt)) {
                    238:             error("Backing file format not supported for file format '%s'", fmt);
                    239:         }
                    240:     }
                    241: }
                    242: 
1.1       root      243: static int img_create(int argc, char **argv)
                    244: {
1.1.1.4   root      245:     int c, ret, flags;
1.1       root      246:     const char *fmt = "raw";
1.1.1.8   root      247:     const char *base_fmt = NULL;
1.1       root      248:     const char *filename;
                    249:     const char *base_filename = NULL;
                    250:     BlockDriver *drv;
1.1.1.8   root      251:     QEMUOptionParameter *param = NULL;
                    252:     char *options = NULL;
1.1.1.4   root      253: 
                    254:     flags = 0;
1.1       root      255:     for(;;) {
1.1.1.8   root      256:         c = getopt(argc, argv, "F:b:f:he6o:");
1.1       root      257:         if (c == -1)
                    258:             break;
                    259:         switch(c) {
                    260:         case 'h':
                    261:             help();
                    262:             break;
1.1.1.8   root      263:         case 'F':
                    264:             base_fmt = optarg;
                    265:             break;
1.1       root      266:         case 'b':
                    267:             base_filename = optarg;
                    268:             break;
                    269:         case 'f':
                    270:             fmt = optarg;
                    271:             break;
                    272:         case 'e':
1.1.1.4   root      273:             flags |= BLOCK_FLAG_ENCRYPT;
                    274:             break;
                    275:         case '6':
                    276:             flags |= BLOCK_FLAG_COMPAT6;
1.1       root      277:             break;
1.1.1.8   root      278:         case 'o':
                    279:             options = optarg;
                    280:             break;
1.1       root      281:         }
                    282:     }
1.1.1.8   root      283: 
                    284:     /* Find driver and parse its options */
                    285:     drv = bdrv_find_format(fmt);
                    286:     if (!drv)
                    287:         error("Unknown file format '%s'", fmt);
                    288: 
                    289:     if (options && !strcmp(options, "?")) {
                    290:         print_option_help(drv->create_options);
                    291:         return 0;
                    292:     }
                    293: 
1.1.1.9   root      294:     /* Create parameter list with default values */
                    295:     param = parse_option_parameters("", drv->create_options, param);
                    296:     set_option_parameter_int(param, BLOCK_OPT_SIZE, -1);
                    297: 
                    298:     /* Parse -o options */
1.1.1.8   root      299:     if (options) {
                    300:         param = parse_option_parameters(options, drv->create_options, param);
                    301:         if (param == NULL) {
                    302:             error("Invalid options for file format '%s'.", fmt);
                    303:         }
                    304:     }
                    305: 
                    306:     /* Get the filename */
1.1.1.4   root      307:     if (optind >= argc)
1.1       root      308:         help();
                    309:     filename = argv[optind++];
1.1.1.8   root      310: 
                    311:     /* Add size to parameters */
                    312:     if (optind < argc) {
                    313:         set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
                    314:     }
                    315: 
                    316:     /* Add old-style options to parameters */
                    317:     add_old_style_options(fmt, param, flags, base_filename, base_fmt);
                    318: 
                    319:     // The size for the image must always be specified, with one exception:
                    320:     // If we are using a backing file, we can obtain the size from there
1.1.1.9   root      321:     if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) {
1.1.1.8   root      322: 
                    323:         QEMUOptionParameter *backing_file =
                    324:             get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
                    325:         QEMUOptionParameter *backing_fmt =
                    326:             get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
                    327: 
                    328:         if (backing_file && backing_file->value.s) {
                    329:             BlockDriverState *bs;
                    330:             uint64_t size;
                    331:             const char *fmt = NULL;
                    332:             char buf[32];
                    333: 
                    334:             if (backing_fmt && backing_fmt->value.s) {
                    335:                  if (bdrv_find_format(backing_fmt->value.s)) {
                    336:                      fmt = backing_fmt->value.s;
                    337:                 } else {
                    338:                      error("Unknown backing file format '%s'",
                    339:                         backing_fmt->value.s);
                    340:                 }
                    341:             }
                    342: 
                    343:             bs = bdrv_new_open(backing_file->value.s, fmt);
                    344:             bdrv_get_geometry(bs, &size);
                    345:             size *= 512;
                    346:             bdrv_delete(bs);
                    347: 
                    348:             snprintf(buf, sizeof(buf), "%" PRId64, size);
                    349:             set_option_parameter(param, BLOCK_OPT_SIZE, buf);
1.1       root      350:         } else {
1.1.1.8   root      351:             error("Image creation needs a size parameter");
1.1       root      352:         }
                    353:     }
1.1.1.8   root      354: 
                    355:     printf("Formatting '%s', fmt=%s ", filename, fmt);
                    356:     print_option_parameters(param);
                    357:     puts("");
                    358: 
                    359:     ret = bdrv_create(drv, filename, param);
                    360:     free_option_parameters(param);
                    361: 
1.1       root      362:     if (ret < 0) {
                    363:         if (ret == -ENOTSUP) {
                    364:             error("Formatting or formatting option not supported for file format '%s'", fmt);
1.1.1.7   root      365:         } else if (ret == -EFBIG) {
                    366:             error("The image size is too large for file format '%s'", fmt);
1.1       root      367:         } else {
                    368:             error("Error while formatting");
                    369:         }
                    370:     }
                    371:     return 0;
                    372: }
                    373: 
1.1.1.8   root      374: static int img_check(int argc, char **argv)
                    375: {
                    376:     int c, ret;
                    377:     const char *filename, *fmt;
                    378:     BlockDriver *drv;
                    379:     BlockDriverState *bs;
                    380: 
                    381:     fmt = NULL;
                    382:     for(;;) {
                    383:         c = getopt(argc, argv, "f:h");
                    384:         if (c == -1)
                    385:             break;
                    386:         switch(c) {
                    387:         case 'h':
                    388:             help();
                    389:             break;
                    390:         case 'f':
                    391:             fmt = optarg;
                    392:             break;
                    393:         }
                    394:     }
                    395:     if (optind >= argc)
                    396:         help();
                    397:     filename = argv[optind++];
                    398: 
                    399:     bs = bdrv_new("");
                    400:     if (!bs)
                    401:         error("Not enough memory");
                    402:     if (fmt) {
                    403:         drv = bdrv_find_format(fmt);
                    404:         if (!drv)
                    405:             error("Unknown file format '%s'", fmt);
                    406:     } else {
                    407:         drv = NULL;
                    408:     }
                    409:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
                    410:         error("Could not open '%s'", filename);
                    411:     }
                    412:     ret = bdrv_check(bs);
                    413:     switch(ret) {
                    414:     case 0:
                    415:         printf("No errors were found on the image.\n");
                    416:         break;
                    417:     case -ENOTSUP:
                    418:         error("This image format does not support checks");
                    419:         break;
                    420:     default:
                    421:         if (ret < 0) {
                    422:             error("An error occurred during the check");
                    423:         } else {
                    424:             printf("%d errors were found on the image.\n", ret);
                    425:         }
                    426:         break;
                    427:     }
                    428: 
                    429:     bdrv_delete(bs);
                    430:     return 0;
                    431: }
                    432: 
1.1       root      433: static int img_commit(int argc, char **argv)
                    434: {
                    435:     int c, ret;
                    436:     const char *filename, *fmt;
                    437:     BlockDriver *drv;
                    438:     BlockDriverState *bs;
                    439: 
                    440:     fmt = NULL;
                    441:     for(;;) {
                    442:         c = getopt(argc, argv, "f:h");
                    443:         if (c == -1)
                    444:             break;
                    445:         switch(c) {
                    446:         case 'h':
                    447:             help();
                    448:             break;
                    449:         case 'f':
                    450:             fmt = optarg;
                    451:             break;
                    452:         }
                    453:     }
1.1.1.4   root      454:     if (optind >= argc)
1.1       root      455:         help();
                    456:     filename = argv[optind++];
                    457: 
                    458:     bs = bdrv_new("");
                    459:     if (!bs)
                    460:         error("Not enough memory");
                    461:     if (fmt) {
                    462:         drv = bdrv_find_format(fmt);
                    463:         if (!drv)
                    464:             error("Unknown file format '%s'", fmt);
                    465:     } else {
                    466:         drv = NULL;
                    467:     }
1.1.1.5   root      468:     if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
1.1       root      469:         error("Could not open '%s'", filename);
                    470:     }
                    471:     ret = bdrv_commit(bs);
                    472:     switch(ret) {
                    473:     case 0:
                    474:         printf("Image committed.\n");
                    475:         break;
                    476:     case -ENOENT:
                    477:         error("No disk inserted");
                    478:         break;
                    479:     case -EACCES:
                    480:         error("Image is read-only");
                    481:         break;
                    482:     case -ENOTSUP:
                    483:         error("Image is already committed");
                    484:         break;
                    485:     default:
                    486:         error("Error while committing image");
                    487:         break;
                    488:     }
                    489: 
                    490:     bdrv_delete(bs);
                    491:     return 0;
                    492: }
                    493: 
                    494: static int is_not_zero(const uint8_t *sector, int len)
                    495: {
                    496:     int i;
                    497:     len >>= 2;
                    498:     for(i = 0;i < len; i++) {
                    499:         if (((uint32_t *)sector)[i] != 0)
                    500:             return 1;
                    501:     }
                    502:     return 0;
                    503: }
                    504: 
1.1.1.5   root      505: /*
                    506:  * Returns true iff the first sector pointed to by 'buf' contains at least
                    507:  * a non-NUL byte.
                    508:  *
                    509:  * 'pnum' is set to the number of sectors (including and immediately following
                    510:  * the first one) that are known to be in the same allocated/unallocated state.
                    511:  */
1.1       root      512: static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
                    513: {
                    514:     int v, i;
                    515: 
                    516:     if (n <= 0) {
                    517:         *pnum = 0;
                    518:         return 0;
                    519:     }
                    520:     v = is_not_zero(buf, 512);
                    521:     for(i = 1; i < n; i++) {
                    522:         buf += 512;
                    523:         if (v != is_not_zero(buf, 512))
                    524:             break;
                    525:     }
                    526:     *pnum = i;
                    527:     return v;
                    528: }
                    529: 
1.1.1.9   root      530: #define IO_BUF_SIZE (2 * 1024 * 1024)
1.1       root      531: 
                    532: static int img_convert(int argc, char **argv)
                    533: {
1.1.1.4   root      534:     int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
1.1.1.5   root      535:     const char *fmt, *out_fmt, *out_baseimg, *out_filename;
1.1       root      536:     BlockDriver *drv;
1.1.1.4   root      537:     BlockDriverState **bs, *out_bs;
                    538:     int64_t total_sectors, nb_sectors, sector_num, bs_offset;
                    539:     uint64_t bs_sectors;
1.1.1.10! root      540:     uint8_t * buf;
1.1       root      541:     const uint8_t *buf1;
1.1.1.3   root      542:     BlockDriverInfo bdi;
1.1.1.8   root      543:     QEMUOptionParameter *param = NULL;
                    544:     char *options = NULL;
1.1       root      545: 
                    546:     fmt = NULL;
                    547:     out_fmt = "raw";
1.1.1.5   root      548:     out_baseimg = NULL;
1.1.1.4   root      549:     flags = 0;
1.1       root      550:     for(;;) {
1.1.1.8   root      551:         c = getopt(argc, argv, "f:O:B:hce6o:");
1.1       root      552:         if (c == -1)
                    553:             break;
                    554:         switch(c) {
                    555:         case 'h':
                    556:             help();
                    557:             break;
                    558:         case 'f':
                    559:             fmt = optarg;
                    560:             break;
                    561:         case 'O':
                    562:             out_fmt = optarg;
                    563:             break;
1.1.1.5   root      564:         case 'B':
                    565:             out_baseimg = optarg;
                    566:             break;
1.1       root      567:         case 'c':
1.1.1.4   root      568:             flags |= BLOCK_FLAG_COMPRESS;
1.1       root      569:             break;
                    570:         case 'e':
1.1.1.4   root      571:             flags |= BLOCK_FLAG_ENCRYPT;
                    572:             break;
                    573:         case '6':
                    574:             flags |= BLOCK_FLAG_COMPAT6;
1.1       root      575:             break;
1.1.1.8   root      576:         case 'o':
                    577:             options = optarg;
                    578:             break;
1.1       root      579:         }
                    580:     }
1.1.1.4   root      581: 
                    582:     bs_n = argc - optind - 1;
                    583:     if (bs_n < 1) help();
                    584: 
                    585:     out_filename = argv[argc - 1];
1.1.1.5   root      586: 
                    587:     if (bs_n > 1 && out_baseimg)
                    588:         error("-B makes no sense when concatenating multiple input images");
1.1.1.4   root      589:         
                    590:     bs = calloc(bs_n, sizeof(BlockDriverState *));
                    591:     if (!bs)
                    592:         error("Out of memory");
                    593: 
                    594:     total_sectors = 0;
                    595:     for (bs_i = 0; bs_i < bs_n; bs_i++) {
                    596:         bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
                    597:         if (!bs[bs_i])
                    598:             error("Could not open '%s'", argv[optind + bs_i]);
                    599:         bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    600:         total_sectors += bs_sectors;
                    601:     }
1.1       root      602: 
1.1.1.8   root      603:     /* Find driver and parse its options */
1.1       root      604:     drv = bdrv_find_format(out_fmt);
                    605:     if (!drv)
1.1.1.4   root      606:         error("Unknown file format '%s'", out_fmt);
                    607: 
1.1.1.8   root      608:     if (options && !strcmp(options, "?")) {
                    609:         print_option_help(drv->create_options);
1.1.1.9   root      610:         free(bs);
1.1.1.8   root      611:         return 0;
                    612:     }
                    613: 
                    614:     if (options) {
                    615:         param = parse_option_parameters(options, drv->create_options, param);
                    616:         if (param == NULL) {
                    617:             error("Invalid options for file format '%s'.", out_fmt);
                    618:         }
                    619:     } else {
                    620:         param = parse_option_parameters("", drv->create_options, param);
                    621:     }
                    622: 
                    623:     set_option_parameter_int(param, BLOCK_OPT_SIZE, total_sectors * 512);
                    624:     add_old_style_options(out_fmt, param, flags, out_baseimg, NULL);
                    625: 
                    626:     /* Check if compression is supported */
                    627:     if (flags & BLOCK_FLAG_COMPRESS) {
                    628:         QEMUOptionParameter *encryption =
                    629:             get_option_parameter(param, BLOCK_OPT_ENCRYPT);
                    630: 
                    631:         if (!drv->bdrv_write_compressed) {
                    632:             error("Compression not supported for this file format");
                    633:         }
                    634: 
                    635:         if (encryption && encryption->value.n) {
                    636:             error("Compression and encryption not supported at the same time");
                    637:         }
                    638:     }
                    639: 
                    640:     /* Create the new image */
                    641:     ret = bdrv_create(drv, out_filename, param);
                    642:     free_option_parameters(param);
                    643: 
1.1       root      644:     if (ret < 0) {
                    645:         if (ret == -ENOTSUP) {
1.1.1.7   root      646:             error("Formatting not supported for file format '%s'", out_fmt);
                    647:         } else if (ret == -EFBIG) {
                    648:             error("The image size is too large for file format '%s'", out_fmt);
1.1       root      649:         } else {
                    650:             error("Error while formatting '%s'", out_filename);
                    651:         }
                    652:     }
1.1.1.4   root      653: 
1.1       root      654:     out_bs = bdrv_new_open(out_filename, out_fmt);
                    655: 
1.1.1.4   root      656:     bs_i = 0;
                    657:     bs_offset = 0;
                    658:     bdrv_get_geometry(bs[0], &bs_sectors);
1.1.1.10! root      659:     buf = qemu_malloc(IO_BUF_SIZE);
1.1.1.4   root      660: 
                    661:     if (flags & BLOCK_FLAG_COMPRESS) {
1.1.1.3   root      662:         if (bdrv_get_info(out_bs, &bdi) < 0)
                    663:             error("could not get block driver info");
                    664:         cluster_size = bdi.cluster_size;
1.1       root      665:         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
                    666:             error("invalid cluster size");
                    667:         cluster_sectors = cluster_size >> 9;
                    668:         sector_num = 0;
                    669:         for(;;) {
1.1.1.4   root      670:             int64_t bs_num;
                    671:             int remainder;
                    672:             uint8_t *buf2;
                    673: 
1.1       root      674:             nb_sectors = total_sectors - sector_num;
                    675:             if (nb_sectors <= 0)
                    676:                 break;
                    677:             if (nb_sectors >= cluster_sectors)
                    678:                 n = cluster_sectors;
                    679:             else
                    680:                 n = nb_sectors;
1.1.1.4   root      681: 
                    682:             bs_num = sector_num - bs_offset;
                    683:             assert (bs_num >= 0);
                    684:             remainder = n;
                    685:             buf2 = buf;
                    686:             while (remainder > 0) {
                    687:                 int nlow;
                    688:                 while (bs_num == bs_sectors) {
                    689:                     bs_i++;
                    690:                     assert (bs_i < bs_n);
                    691:                     bs_offset += bs_sectors;
                    692:                     bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    693:                     bs_num = 0;
                    694:                     /* printf("changing part: sector_num=%lld, "
                    695:                        "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
                    696:                        sector_num, bs_i, bs_offset, bs_sectors); */
                    697:                 }
                    698:                 assert (bs_num < bs_sectors);
                    699: 
                    700:                 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
                    701: 
                    702:                 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0) 
                    703:                     error("error while reading");
                    704: 
                    705:                 buf2 += nlow * 512;
                    706:                 bs_num += nlow;
                    707: 
                    708:                 remainder -= nlow;
                    709:             }
                    710:             assert (remainder == 0);
                    711: 
1.1       root      712:             if (n < cluster_sectors)
                    713:                 memset(buf + n * 512, 0, cluster_size - n * 512);
                    714:             if (is_not_zero(buf, cluster_size)) {
1.1.1.4   root      715:                 if (bdrv_write_compressed(out_bs, sector_num, buf,
1.1.1.3   root      716:                                           cluster_sectors) != 0)
1.1.1.2   root      717:                     error("error while compressing sector %" PRId64,
                    718:                           sector_num);
1.1       root      719:             }
                    720:             sector_num += n;
                    721:         }
1.1.1.3   root      722:         /* signal EOF to align */
                    723:         bdrv_write_compressed(out_bs, 0, NULL, 0);
1.1       root      724:     } else {
1.1.1.5   root      725:         sector_num = 0; // total number of sectors converted so far
1.1       root      726:         for(;;) {
                    727:             nb_sectors = total_sectors - sector_num;
                    728:             if (nb_sectors <= 0)
                    729:                 break;
                    730:             if (nb_sectors >= (IO_BUF_SIZE / 512))
                    731:                 n = (IO_BUF_SIZE / 512);
                    732:             else
                    733:                 n = nb_sectors;
1.1.1.4   root      734: 
                    735:             while (sector_num - bs_offset >= bs_sectors) {
                    736:                 bs_i ++;
                    737:                 assert (bs_i < bs_n);
                    738:                 bs_offset += bs_sectors;
                    739:                 bdrv_get_geometry(bs[bs_i], &bs_sectors);
                    740:                 /* printf("changing part: sector_num=%lld, bs_i=%d, "
                    741:                   "bs_offset=%lld, bs_sectors=%lld\n",
                    742:                    sector_num, bs_i, bs_offset, bs_sectors); */
                    743:             }
                    744: 
                    745:             if (n > bs_offset + bs_sectors - sector_num)
                    746:                 n = bs_offset + bs_sectors - sector_num;
                    747: 
1.1.1.9   root      748:             if (!drv->no_zero_init) {
1.1.1.8   root      749:                 /* If the output image is being created as a copy on write image,
                    750:                    assume that sectors which are unallocated in the input image
                    751:                    are present in both the output's and input's base images (no
                    752:                    need to copy them). */
                    753:                 if (out_baseimg) {
                    754:                     if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
                    755:                                            n, &n1)) {
                    756:                         sector_num += n1;
                    757:                         continue;
                    758:                     }
                    759:                     /* The next 'n1' sectors are allocated in the input image. Copy
                    760:                        only those as they may be followed by unallocated sectors. */
                    761:                     n = n1;
                    762:                 }
                    763:             } else {
                    764:                 n1 = n;
1.1.1.5   root      765:             }
                    766: 
1.1.1.4   root      767:             if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0) 
1.1       root      768:                 error("error while reading");
                    769:             /* NOTE: at the same time we convert, we do not write zero
                    770:                sectors to have a chance to compress the image. Ideally, we
                    771:                should add a specific call to have the info to go faster */
                    772:             buf1 = buf;
                    773:             while (n > 0) {
1.1.1.5   root      774:                 /* If the output image is being created as a copy on write image,
                    775:                    copy all sectors even the ones containing only NUL bytes,
1.1.1.8   root      776:                    because they may differ from the sectors in the base image.
                    777: 
                    778:                    If the output is to a host device, we also write out
                    779:                    sectors that are entirely 0, since whatever data was
                    780:                    already there is garbage, not 0s. */
1.1.1.9   root      781:                 if (drv->no_zero_init || out_baseimg ||
1.1.1.8   root      782:                     is_allocated_sectors(buf1, n, &n1)) {
1.1.1.4   root      783:                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
1.1       root      784:                         error("error while writing");
                    785:                 }
                    786:                 sector_num += n1;
                    787:                 n -= n1;
                    788:                 buf1 += n1 * 512;
                    789:             }
                    790:         }
                    791:     }
1.1.1.10! root      792:     qemu_free(buf);
1.1       root      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