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

1.1       root        1: /*
                      2:  * create a COW disk image
                      3:  * 
                      4:  * Copyright (c) 2003 Fabrice Bellard
                      5:  * 
                      6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
                      7:  * of this software and associated documentation files (the "Software"), to deal
                      8:  * in the Software without restriction, including without limitation the rights
                      9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                     10:  * copies of the Software, and to permit persons to whom the Software is
                     11:  * furnished to do so, subject to the following conditions:
                     12:  *
                     13:  * The above copyright notice and this permission notice shall be included in
                     14:  * all copies or substantial portions of the Software.
                     15:  *
                     16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                     17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                     18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
                     19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                     20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                     21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
                     22:  * THE SOFTWARE.
                     23:  */
                     24: #include "vl.h"
                     25: 
1.1.1.2 ! root       26: #ifdef _WIN32
        !            27: #include <windows.h>
        !            28: #endif
        !            29: 
1.1       root       30: void *get_mmap_addr(unsigned long size)
                     31: {
                     32:     return NULL;
                     33: }
                     34: 
                     35: void qemu_free(void *ptr)
                     36: {
                     37:     free(ptr);
                     38: }
                     39: 
                     40: void *qemu_malloc(size_t size)
                     41: {
                     42:     return malloc(size);
                     43: }
                     44: 
                     45: void *qemu_mallocz(size_t size)
                     46: {
                     47:     void *ptr;
                     48:     ptr = qemu_malloc(size);
                     49:     if (!ptr)
                     50:         return NULL;
                     51:     memset(ptr, 0, size);
                     52:     return ptr;
                     53: }
                     54: 
                     55: char *qemu_strdup(const char *str)
                     56: {
                     57:     char *ptr;
                     58:     ptr = qemu_malloc(strlen(str) + 1);
                     59:     if (!ptr)
                     60:         return NULL;
                     61:     strcpy(ptr, str);
                     62:     return ptr;
                     63: }
                     64: 
                     65: void pstrcpy(char *buf, int buf_size, const char *str)
                     66: {
                     67:     int c;
                     68:     char *q = buf;
                     69: 
                     70:     if (buf_size <= 0)
                     71:         return;
                     72: 
                     73:     for(;;) {
                     74:         c = *str++;
                     75:         if (c == 0 || q >= buf + buf_size - 1)
                     76:             break;
                     77:         *q++ = c;
                     78:     }
                     79:     *q = '\0';
                     80: }
                     81: 
                     82: /* strcat and truncate. */
                     83: char *pstrcat(char *buf, int buf_size, const char *s)
                     84: {
                     85:     int len;
                     86:     len = strlen(buf);
                     87:     if (len < buf_size) 
                     88:         pstrcpy(buf + len, buf_size - len, s);
                     89:     return buf;
                     90: }
                     91: 
                     92: int strstart(const char *str, const char *val, const char **ptr)
                     93: {
                     94:     const char *p, *q;
                     95:     p = str;
                     96:     q = val;
                     97:     while (*q != '\0') {
                     98:         if (*p != *q)
                     99:             return 0;
                    100:         p++;
                    101:         q++;
                    102:     }
                    103:     if (ptr)
                    104:         *ptr = p;
                    105:     return 1;
                    106: }
                    107: 
                    108: void term_printf(const char *fmt, ...)
                    109: {
                    110:     va_list ap;
                    111:     va_start(ap, fmt);
                    112:     vprintf(fmt, ap);
                    113:     va_end(ap);
                    114: }
                    115: 
                    116: void __attribute__((noreturn)) error(const char *fmt, ...) 
                    117: {
                    118:     va_list ap;
                    119:     va_start(ap, fmt);
                    120:     fprintf(stderr, "qemu-img: ");
                    121:     vfprintf(stderr, fmt, ap);
                    122:     fprintf(stderr, "\n");
                    123:     exit(1);
                    124:     va_end(ap);
                    125: }
                    126: 
                    127: static void format_print(void *opaque, const char *name)
                    128: {
                    129:     printf(" %s", name);
                    130: }
                    131: 
                    132: void help(void)
                    133: {
                    134:     printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2005 Fabrice Bellard\n"
                    135:            "usage: qemu-img command [command options]\n"
                    136:            "QEMU disk image utility\n"
                    137:            "\n"
                    138:            "Command syntax:\n"
                    139:            "  create [-e] [-b base_image] [-f fmt] filename [size]\n"
                    140:            "  commit [-f fmt] filename\n"
                    141:            "  convert [-c] [-e] [-f fmt] filename [-O output_fmt] output_filename\n"
                    142:            "  info [-f fmt] filename\n"
                    143:            "\n"
                    144:            "Command parameters:\n"
                    145:            "  'filename' is a disk image filename\n"
                    146:            "  'base_image' is the read-only disk image which is used as base for a copy on\n"
                    147:            "    write image; the copy on write image only stores the modified data\n"
                    148:            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
                    149:            "  'size' is the disk image size in kilobytes. Optional suffixes 'M' (megabyte)\n"
                    150:            "    and 'G' (gigabyte) are supported\n"
                    151:            "  'output_filename' is the destination disk image filename\n"
                    152:            "  'output_fmt' is the destination format\n"
                    153:            "  '-c' indicates that target image must be compressed (qcow format only)\n"
                    154:            "  '-e' indicates that the target image must be encrypted (qcow format only)\n"
                    155:            );
                    156:     printf("\nSupported format:");
                    157:     bdrv_iterate_format(format_print, NULL);
                    158:     printf("\n");
                    159:     exit(1);
                    160: }
                    161: 
                    162: 
                    163: #define NB_SUFFIXES 4
                    164: 
                    165: static void get_human_readable_size(char *buf, int buf_size, int64_t size)
                    166: {
1.1.1.2 ! root      167:     static const char suffixes[NB_SUFFIXES] = "KMGT";
1.1       root      168:     int64_t base;
                    169:     int i;
                    170: 
                    171:     if (size <= 999) {
1.1.1.2 ! root      172:         snprintf(buf, buf_size, "%" PRId64, size);
1.1       root      173:     } else {
                    174:         base = 1024;
                    175:         for(i = 0; i < NB_SUFFIXES; i++) {
                    176:             if (size < (10 * base)) {
                    177:                 snprintf(buf, buf_size, "%0.1f%c", 
                    178:                          (double)size / base,
                    179:                          suffixes[i]);
                    180:                 break;
                    181:             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
1.1.1.2 ! root      182:                 snprintf(buf, buf_size, "%" PRId64 "%c", 
        !           183:                          ((size + (base >> 1)) / base),
1.1       root      184:                          suffixes[i]);
                    185:                 break;
                    186:             }
                    187:             base = base * 1024;
                    188:         }
                    189:     }
                    190: }
                    191: 
                    192: #if defined(WIN32)
                    193: /* XXX: put correct support for win32 */
                    194: static int read_password(char *buf, int buf_size)
                    195: {
                    196:     int c, i;
                    197:     printf("Password: ");
                    198:     fflush(stdout);
                    199:     i = 0;
                    200:     for(;;) {
                    201:         c = getchar();
                    202:         if (c == '\n')
                    203:             break;
                    204:         if (i < (buf_size - 1))
                    205:             buf[i++] = c;
                    206:     }
                    207:     buf[i] = '\0';
                    208:     return 0;
                    209: }
                    210: 
                    211: #else
                    212: 
                    213: #include <termios.h>
                    214: 
                    215: static struct termios oldtty;
                    216: 
                    217: static void term_exit(void)
                    218: {
                    219:     tcsetattr (0, TCSANOW, &oldtty);
                    220: }
                    221: 
                    222: static void term_init(void)
                    223: {
                    224:     struct termios tty;
                    225: 
                    226:     tcgetattr (0, &tty);
                    227:     oldtty = tty;
                    228: 
                    229:     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                    230:                           |INLCR|IGNCR|ICRNL|IXON);
                    231:     tty.c_oflag |= OPOST;
                    232:     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
                    233:     tty.c_cflag &= ~(CSIZE|PARENB);
                    234:     tty.c_cflag |= CS8;
                    235:     tty.c_cc[VMIN] = 1;
                    236:     tty.c_cc[VTIME] = 0;
                    237:     
                    238:     tcsetattr (0, TCSANOW, &tty);
                    239: 
                    240:     atexit(term_exit);
                    241: }
                    242: 
                    243: int read_password(char *buf, int buf_size)
                    244: {
                    245:     uint8_t ch;
                    246:     int i, ret;
                    247: 
                    248:     printf("password: ");
                    249:     fflush(stdout);
                    250:     term_init();
                    251:     i = 0;
                    252:     for(;;) {
                    253:         ret = read(0, &ch, 1);
                    254:         if (ret == -1) {
                    255:             if (errno == EAGAIN || errno == EINTR) {
                    256:                 continue;
                    257:             } else {
                    258:                 ret = -1;
                    259:                 break;
                    260:             }
                    261:         } else if (ret == 0) {
                    262:             ret = -1;
                    263:             break;
                    264:         } else {
                    265:             if (ch == '\r') {
                    266:                 ret = 0;
                    267:                 break;
                    268:             }
                    269:             if (i < (buf_size - 1))
                    270:                 buf[i++] = ch;
                    271:         }
                    272:     }
                    273:     term_exit();
                    274:     buf[i] = '\0';
                    275:     printf("\n");
                    276:     return ret;
                    277: }
                    278: #endif
                    279: 
                    280: static BlockDriverState *bdrv_new_open(const char *filename,
                    281:                                        const char *fmt)
                    282: {
                    283:     BlockDriverState *bs;
                    284:     BlockDriver *drv;
                    285:     char password[256];
                    286: 
                    287:     bs = bdrv_new("");
                    288:     if (!bs)
                    289:         error("Not enough memory");
                    290:     if (fmt) {
                    291:         drv = bdrv_find_format(fmt);
                    292:         if (!drv)
                    293:             error("Unknown file format '%s'", fmt);
                    294:     } else {
                    295:         drv = NULL;
                    296:     }
                    297:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
                    298:         error("Could not open '%s'", filename);
                    299:     }
                    300:     if (bdrv_is_encrypted(bs)) {
                    301:         printf("Disk image '%s' is encrypted.\n", filename);
                    302:         if (read_password(password, sizeof(password)) < 0)
                    303:             error("No password given");
                    304:         if (bdrv_set_key(bs, password) < 0)
                    305:             error("invalid password");
                    306:     }
                    307:     return bs;
                    308: }
                    309: 
                    310: static int img_create(int argc, char **argv)
                    311: {
                    312:     int c, ret, encrypted;
                    313:     const char *fmt = "raw";
                    314:     const char *filename;
                    315:     const char *base_filename = NULL;
                    316:     int64_t size;
                    317:     const char *p;
                    318:     BlockDriver *drv;
                    319:     
                    320:     encrypted = 0;
                    321:     for(;;) {
                    322:         c = getopt(argc, argv, "b:f:he");
                    323:         if (c == -1)
                    324:             break;
                    325:         switch(c) {
                    326:         case 'h':
                    327:             help();
                    328:             break;
                    329:         case 'b':
                    330:             base_filename = optarg;
                    331:             break;
                    332:         case 'f':
                    333:             fmt = optarg;
                    334:             break;
                    335:         case 'e':
                    336:             encrypted = 1;
                    337:             break;
                    338:         }
                    339:     }
                    340:     if (optind >= argc) 
                    341:         help();
                    342:     filename = argv[optind++];
                    343:     size = 0;
                    344:     if (base_filename) {
                    345:         BlockDriverState *bs;
                    346:         bs = bdrv_new_open(base_filename, NULL);
                    347:         bdrv_get_geometry(bs, &size);
                    348:         size *= 512;
                    349:         bdrv_delete(bs);
                    350:     } else {
                    351:         if (optind >= argc)
                    352:             help();
                    353:         p = argv[optind];
                    354:         size = strtoul(p, (char **)&p, 0);
                    355:         if (*p == 'M') {
                    356:             size *= 1024 * 1024;
                    357:         } else if (*p == 'G') {
                    358:             size *= 1024 * 1024 * 1024;
                    359:         } else if (*p == 'k' || *p == 'K' || *p == '\0') {
                    360:             size *= 1024;
                    361:         } else {
                    362:             help();
                    363:         }
                    364:     }
                    365:     drv = bdrv_find_format(fmt);
                    366:     if (!drv)
                    367:         error("Unknown file format '%s'", fmt);
                    368:     printf("Formating '%s', fmt=%s",
                    369:            filename, fmt);
                    370:     if (encrypted)
                    371:         printf(", encrypted");
                    372:     if (base_filename) {
                    373:         printf(", backing_file=%s",
                    374:                base_filename);
                    375:     }
1.1.1.2 ! root      376:     printf(", size=%" PRId64 " kB\n", (int64_t) (size / 1024));
1.1       root      377:     ret = bdrv_create(drv, filename, size / 512, base_filename, encrypted);
                    378:     if (ret < 0) {
                    379:         if (ret == -ENOTSUP) {
                    380:             error("Formatting or formatting option not supported for file format '%s'", fmt);
                    381:         } else {
                    382:             error("Error while formatting");
                    383:         }
                    384:     }
                    385:     return 0;
                    386: }
                    387: 
                    388: static int img_commit(int argc, char **argv)
                    389: {
                    390:     int c, ret;
                    391:     const char *filename, *fmt;
                    392:     BlockDriver *drv;
                    393:     BlockDriverState *bs;
                    394: 
                    395:     fmt = NULL;
                    396:     for(;;) {
                    397:         c = getopt(argc, argv, "f:h");
                    398:         if (c == -1)
                    399:             break;
                    400:         switch(c) {
                    401:         case 'h':
                    402:             help();
                    403:             break;
                    404:         case 'f':
                    405:             fmt = optarg;
                    406:             break;
                    407:         }
                    408:     }
                    409:     if (optind >= argc) 
                    410:         help();
                    411:     filename = argv[optind++];
                    412: 
                    413:     bs = bdrv_new("");
                    414:     if (!bs)
                    415:         error("Not enough memory");
                    416:     if (fmt) {
                    417:         drv = bdrv_find_format(fmt);
                    418:         if (!drv)
                    419:             error("Unknown file format '%s'", fmt);
                    420:     } else {
                    421:         drv = NULL;
                    422:     }
                    423:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
                    424:         error("Could not open '%s'", filename);
                    425:     }
                    426:     ret = bdrv_commit(bs);
                    427:     switch(ret) {
                    428:     case 0:
                    429:         printf("Image committed.\n");
                    430:         break;
                    431:     case -ENOENT:
                    432:         error("No disk inserted");
                    433:         break;
                    434:     case -EACCES:
                    435:         error("Image is read-only");
                    436:         break;
                    437:     case -ENOTSUP:
                    438:         error("Image is already committed");
                    439:         break;
                    440:     default:
                    441:         error("Error while committing image");
                    442:         break;
                    443:     }
                    444: 
                    445:     bdrv_delete(bs);
                    446:     return 0;
                    447: }
                    448: 
                    449: static int is_not_zero(const uint8_t *sector, int len)
                    450: {
                    451:     int i;
                    452:     len >>= 2;
                    453:     for(i = 0;i < len; i++) {
                    454:         if (((uint32_t *)sector)[i] != 0)
                    455:             return 1;
                    456:     }
                    457:     return 0;
                    458: }
                    459: 
                    460: static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
                    461: {
                    462:     int v, i;
                    463: 
                    464:     if (n <= 0) {
                    465:         *pnum = 0;
                    466:         return 0;
                    467:     }
                    468:     v = is_not_zero(buf, 512);
                    469:     for(i = 1; i < n; i++) {
                    470:         buf += 512;
                    471:         if (v != is_not_zero(buf, 512))
                    472:             break;
                    473:     }
                    474:     *pnum = i;
                    475:     return v;
                    476: }
                    477: 
                    478: #define IO_BUF_SIZE 65536
                    479: 
                    480: static int img_convert(int argc, char **argv)
                    481: {
                    482:     int c, ret, n, n1, compress, cluster_size, cluster_sectors, encrypt;
                    483:     const char *filename, *fmt, *out_fmt, *out_filename;
                    484:     BlockDriver *drv;
                    485:     BlockDriverState *bs, *out_bs;
                    486:     int64_t total_sectors, nb_sectors, sector_num;
                    487:     uint8_t buf[IO_BUF_SIZE];
                    488:     const uint8_t *buf1;
                    489: 
                    490:     fmt = NULL;
                    491:     out_fmt = "raw";
                    492:     compress = 0;
                    493:     encrypt = 0;
                    494:     for(;;) {
                    495:         c = getopt(argc, argv, "f:O:hce");
                    496:         if (c == -1)
                    497:             break;
                    498:         switch(c) {
                    499:         case 'h':
                    500:             help();
                    501:             break;
                    502:         case 'f':
                    503:             fmt = optarg;
                    504:             break;
                    505:         case 'O':
                    506:             out_fmt = optarg;
                    507:             break;
                    508:         case 'c':
                    509:             compress = 1;
                    510:             break;
                    511:         case 'e':
                    512:             encrypt = 1;
                    513:             break;
                    514:         }
                    515:     }
                    516:     if (optind >= argc) 
                    517:         help();
                    518:     filename = argv[optind++];
                    519:     if (optind >= argc) 
                    520:         help();
                    521:     out_filename = argv[optind++];
                    522:     
                    523:     bs = bdrv_new_open(filename, fmt);
                    524: 
                    525:     drv = bdrv_find_format(out_fmt);
                    526:     if (!drv)
                    527:         error("Unknown file format '%s'", fmt);
                    528:     if (compress && drv != &bdrv_qcow)
                    529:         error("Compression not supported for this file format");
                    530:     if (encrypt && drv != &bdrv_qcow)
                    531:         error("Encryption not supported for this file format");
                    532:     if (compress && encrypt)
                    533:         error("Compression and encryption not supported at the same time");
                    534:     bdrv_get_geometry(bs, &total_sectors);
                    535:     ret = bdrv_create(drv, out_filename, total_sectors, NULL, encrypt);
                    536:     if (ret < 0) {
                    537:         if (ret == -ENOTSUP) {
                    538:             error("Formatting not supported for file format '%s'", fmt);
                    539:         } else {
                    540:             error("Error while formatting '%s'", out_filename);
                    541:         }
                    542:     }
                    543:     
                    544:     out_bs = bdrv_new_open(out_filename, out_fmt);
                    545: 
                    546:     if (compress) {
                    547:         cluster_size = qcow_get_cluster_size(out_bs);
                    548:         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
                    549:             error("invalid cluster size");
                    550:         cluster_sectors = cluster_size >> 9;
                    551:         sector_num = 0;
                    552:         for(;;) {
                    553:             nb_sectors = total_sectors - sector_num;
                    554:             if (nb_sectors <= 0)
                    555:                 break;
                    556:             if (nb_sectors >= cluster_sectors)
                    557:                 n = cluster_sectors;
                    558:             else
                    559:                 n = nb_sectors;
                    560:             if (bdrv_read(bs, sector_num, buf, n) < 0) 
                    561:                 error("error while reading");
                    562:             if (n < cluster_sectors)
                    563:                 memset(buf + n * 512, 0, cluster_size - n * 512);
                    564:             if (is_not_zero(buf, cluster_size)) {
                    565:                 if (qcow_compress_cluster(out_bs, sector_num, buf) != 0)
1.1.1.2 ! root      566:                     error("error while compressing sector %" PRId64,
        !           567:                           sector_num);
1.1       root      568:             }
                    569:             sector_num += n;
                    570:         }
                    571:     } else {
                    572:         sector_num = 0;
                    573:         for(;;) {
                    574:             nb_sectors = total_sectors - sector_num;
                    575:             if (nb_sectors <= 0)
                    576:                 break;
                    577:             if (nb_sectors >= (IO_BUF_SIZE / 512))
                    578:                 n = (IO_BUF_SIZE / 512);
                    579:             else
                    580:                 n = nb_sectors;
                    581:             if (bdrv_read(bs, sector_num, buf, n) < 0) 
                    582:                 error("error while reading");
                    583:             /* NOTE: at the same time we convert, we do not write zero
                    584:                sectors to have a chance to compress the image. Ideally, we
                    585:                should add a specific call to have the info to go faster */
                    586:             buf1 = buf;
                    587:             while (n > 0) {
                    588:                 if (is_allocated_sectors(buf1, n, &n1)) {
                    589:                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0) 
                    590:                         error("error while writing");
                    591:                 }
                    592:                 sector_num += n1;
                    593:                 n -= n1;
                    594:                 buf1 += n1 * 512;
                    595:             }
                    596:         }
                    597:     }
                    598:     bdrv_delete(out_bs);
                    599:     bdrv_delete(bs);
                    600:     return 0;
                    601: }
                    602: 
                    603: #ifdef _WIN32
                    604: static int64_t get_allocated_file_size(const char *filename)
                    605: {
1.1.1.2 ! root      606:     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
        !           607:     get_compressed_t get_compressed;
1.1       root      608:     struct _stati64 st;
1.1.1.2 ! root      609: 
        !           610:     /* WinNT support GetCompressedFileSize to determine allocate size */
        !           611:     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
        !           612:     if (get_compressed) {
        !           613:        DWORD high, low;
        !           614:        low = get_compressed(filename, &high);
        !           615:        if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
        !           616:            return (((int64_t) high) << 32) + low;
        !           617:     }
        !           618: 
1.1       root      619:     if (_stati64(filename, &st) < 0) 
                    620:         return -1;
                    621:     return st.st_size;
                    622: }
                    623: #else
                    624: static int64_t get_allocated_file_size(const char *filename)
                    625: {
                    626:     struct stat st;
                    627:     if (stat(filename, &st) < 0) 
                    628:         return -1;
                    629:     return (int64_t)st.st_blocks * 512;
                    630: }
                    631: #endif
                    632: 
                    633: static int img_info(int argc, char **argv)
                    634: {
                    635:     int c;
                    636:     const char *filename, *fmt;
                    637:     BlockDriver *drv;
                    638:     BlockDriverState *bs;
                    639:     char fmt_name[128], size_buf[128], dsize_buf[128];
                    640:     int64_t total_sectors, allocated_size;
                    641: 
                    642:     fmt = NULL;
                    643:     for(;;) {
                    644:         c = getopt(argc, argv, "f:h");
                    645:         if (c == -1)
                    646:             break;
                    647:         switch(c) {
                    648:         case 'h':
                    649:             help();
                    650:             break;
                    651:         case 'f':
                    652:             fmt = optarg;
                    653:             break;
                    654:         }
                    655:     }
                    656:     if (optind >= argc) 
                    657:         help();
                    658:     filename = argv[optind++];
                    659: 
                    660:     bs = bdrv_new("");
                    661:     if (!bs)
                    662:         error("Not enough memory");
                    663:     if (fmt) {
                    664:         drv = bdrv_find_format(fmt);
                    665:         if (!drv)
                    666:             error("Unknown file format '%s'", fmt);
                    667:     } else {
                    668:         drv = NULL;
                    669:     }
                    670:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
                    671:         error("Could not open '%s'", filename);
                    672:     }
                    673:     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
                    674:     bdrv_get_geometry(bs, &total_sectors);
                    675:     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
                    676:     allocated_size = get_allocated_file_size(filename);
                    677:     if (allocated_size < 0)
                    678:        sprintf(dsize_buf, "unavailable");
                    679:     else
                    680:         get_human_readable_size(dsize_buf, sizeof(dsize_buf), 
                    681:                                 allocated_size);
                    682:     printf("image: %s\n"
                    683:            "file format: %s\n"
1.1.1.2 ! root      684:            "virtual size: %s (%" PRId64 " bytes)\n"
1.1       root      685:            "disk size: %s\n",
                    686:            filename, fmt_name, size_buf, 
1.1.1.2 ! root      687:            (total_sectors * 512),
1.1       root      688:            dsize_buf);
                    689:     if (bdrv_is_encrypted(bs))
                    690:         printf("encrypted: yes\n");
                    691:     bdrv_delete(bs);
                    692:     return 0;
                    693: }
                    694: 
                    695: int main(int argc, char **argv)
                    696: {
                    697:     const char *cmd;
                    698: 
                    699:     bdrv_init();
                    700:     if (argc < 2)
                    701:         help();
                    702:     cmd = argv[1];
                    703:     optind++;
                    704:     if (!strcmp(cmd, "create")) {
                    705:         img_create(argc, argv);
                    706:     } else if (!strcmp(cmd, "commit")) {
                    707:         img_commit(argc, argv);
                    708:     } else if (!strcmp(cmd, "convert")) {
                    709:         img_convert(argc, argv);
                    710:     } else if (!strcmp(cmd, "info")) {
                    711:         img_info(argc, argv);
                    712:     } else {
                    713:         help();
                    714:     }
                    715:     return 0;
                    716: }

unix.superglobalmegacorp.com