]> git.proxmox.com Git - mirror_qemu.git/blob - qemu-img.c
913ad34bf8536c5c83d6d5c1165119b7247ced7e
[mirror_qemu.git] / qemu-img.c
1 /*
2 * QEMU disk image utility
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu-common.h"
25 #include "osdep.h"
26 #include "block_int.h"
27 #include <assert.h>
28 #include <stdio.h>
29
30 #ifdef _WIN32
31 #include <windows.h>
32 #endif
33
34 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
35 #define BRDV_O_FLAGS BDRV_O_CACHE_WB
36
37 static void QEMU_NORETURN error(const char *fmt, ...)
38 {
39 va_list ap;
40 va_start(ap, fmt);
41 fprintf(stderr, "qemu-img: ");
42 vfprintf(stderr, fmt, ap);
43 fprintf(stderr, "\n");
44 exit(1);
45 va_end(ap);
46 }
47
48 static void format_print(void *opaque, const char *name)
49 {
50 printf(" %s", name);
51 }
52
53 /* Please keep in synch with qemu-img.texi */
54 static void help(void)
55 {
56 printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
57 "usage: qemu-img command [command options]\n"
58 "QEMU disk image utility\n"
59 "\n"
60 "Command syntax:\n"
61 " create [-e] [-6] [-F fmt] [-b base_image] [-f fmt] filename [size]\n"
62 " commit [-f fmt] filename\n"
63 " convert [-c] [-e] [-6] [-f fmt] [-O output_fmt] [-B output_base_image] filename [filename2 [...]] output_filename\n"
64 " info [-f fmt] filename\n"
65 " snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\n"
66 "\n"
67 "Command parameters:\n"
68 " 'filename' is a disk image filename\n"
69 " 'base_image' is the read-only disk image which is used as base for a copy on\n"
70 " write image; the copy on write image only stores the modified data\n"
71 " 'output_base_image' forces the output image to be created as a copy on write\n"
72 " image of the specified base image; 'output_base_image' should have the same\n"
73 " content as the input's base image, however the path, image format, etc may\n"
74 " differ\n"
75 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
76 " 'size' is the disk image size in kilobytes. Optional suffixes\n"
77 " 'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\n"
78 " supported any 'k' or 'K' is ignored\n"
79 " 'output_filename' is the destination disk image filename\n"
80 " 'output_fmt' is the destination format\n"
81 " '-c' indicates that target image must be compressed (qcow format only)\n"
82 " '-e' indicates that the target image must be encrypted (qcow format only)\n"
83 " '-6' indicates that the target image must use compatibility level 6 (vmdk format only)\n"
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"
92 );
93 printf("\nSupported formats:");
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;
144
145 tcsetattr (0, TCSANOW, &tty);
146
147 atexit(term_exit);
148 }
149
150 static int read_password(char *buf, int buf_size)
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 }
204 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
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
217 static int img_create(int argc, char **argv)
218 {
219 int c, ret, flags;
220 const char *fmt = "raw";
221 const char *base_fmt = NULL;
222 const char *filename;
223 const char *base_filename = NULL;
224 uint64_t size;
225 double sizef;
226 const char *p;
227 BlockDriver *drv;
228
229 flags = 0;
230 for(;;) {
231 c = getopt(argc, argv, "F:b:f:he6");
232 if (c == -1)
233 break;
234 switch(c) {
235 case 'h':
236 help();
237 break;
238 case 'F':
239 base_fmt = optarg;
240 break;
241 case 'b':
242 base_filename = optarg;
243 break;
244 case 'f':
245 fmt = optarg;
246 break;
247 case 'e':
248 flags |= BLOCK_FLAG_ENCRYPT;
249 break;
250 case '6':
251 flags |= BLOCK_FLAG_COMPAT6;
252 break;
253 }
254 }
255 if (optind >= argc)
256 help();
257 filename = argv[optind++];
258 size = 0;
259 if (base_filename) {
260 BlockDriverState *bs;
261 BlockDriver *base_drv = NULL;
262
263 if (base_fmt) {
264 base_drv = bdrv_find_format(base_fmt);
265 if (base_drv == NULL)
266 error("Unknown basefile format '%s'", base_fmt);
267 }
268
269 bs = bdrv_new_open(base_filename, base_fmt);
270 bdrv_get_geometry(bs, &size);
271 size *= 512;
272 bdrv_delete(bs);
273 } else {
274 if (optind >= argc)
275 help();
276 p = argv[optind];
277 sizef = strtod(p, (char **)&p);
278 if (*p == 'M') {
279 size = (uint64_t)(sizef * 1024 * 1024);
280 } else if (*p == 'G') {
281 size = (uint64_t)(sizef * 1024 * 1024 * 1024);
282 } else if (*p == 'k' || *p == 'K' || *p == '\0') {
283 size = (uint64_t)(sizef * 1024);
284 } else {
285 help();
286 }
287 }
288 drv = bdrv_find_format(fmt);
289 if (!drv)
290 error("Unknown file format '%s'", fmt);
291 printf("Formatting '%s', fmt=%s",
292 filename, fmt);
293 if (flags & BLOCK_FLAG_ENCRYPT)
294 printf(", encrypted");
295 if (flags & BLOCK_FLAG_COMPAT6)
296 printf(", compatibility level=6");
297 if (base_filename) {
298 printf(", backing_file=%s",
299 base_filename);
300 if (base_fmt)
301 printf(", backing_fmt=%s",
302 base_fmt);
303 }
304 printf(", size=%" PRIu64 " kB\n", size / 1024);
305 ret = bdrv_create2(drv, filename, size / 512, base_filename, base_fmt, flags);
306 if (ret < 0) {
307 if (ret == -ENOTSUP) {
308 error("Formatting or formatting option not supported for file format '%s'", fmt);
309 } else {
310 error("Error while formatting");
311 }
312 }
313 return 0;
314 }
315
316 static int img_commit(int argc, char **argv)
317 {
318 int c, ret;
319 const char *filename, *fmt;
320 BlockDriver *drv;
321 BlockDriverState *bs;
322
323 fmt = NULL;
324 for(;;) {
325 c = getopt(argc, argv, "f:h");
326 if (c == -1)
327 break;
328 switch(c) {
329 case 'h':
330 help();
331 break;
332 case 'f':
333 fmt = optarg;
334 break;
335 }
336 }
337 if (optind >= argc)
338 help();
339 filename = argv[optind++];
340
341 bs = bdrv_new("");
342 if (!bs)
343 error("Not enough memory");
344 if (fmt) {
345 drv = bdrv_find_format(fmt);
346 if (!drv)
347 error("Unknown file format '%s'", fmt);
348 } else {
349 drv = NULL;
350 }
351 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
352 error("Could not open '%s'", filename);
353 }
354 ret = bdrv_commit(bs);
355 switch(ret) {
356 case 0:
357 printf("Image committed.\n");
358 break;
359 case -ENOENT:
360 error("No disk inserted");
361 break;
362 case -EACCES:
363 error("Image is read-only");
364 break;
365 case -ENOTSUP:
366 error("Image is already committed");
367 break;
368 default:
369 error("Error while committing image");
370 break;
371 }
372
373 bdrv_delete(bs);
374 return 0;
375 }
376
377 static int is_not_zero(const uint8_t *sector, int len)
378 {
379 int i;
380 len >>= 2;
381 for(i = 0;i < len; i++) {
382 if (((uint32_t *)sector)[i] != 0)
383 return 1;
384 }
385 return 0;
386 }
387
388 /*
389 * Returns true iff the first sector pointed to by 'buf' contains at least
390 * a non-NUL byte.
391 *
392 * 'pnum' is set to the number of sectors (including and immediately following
393 * the first one) that are known to be in the same allocated/unallocated state.
394 */
395 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
396 {
397 int v, i;
398
399 if (n <= 0) {
400 *pnum = 0;
401 return 0;
402 }
403 v = is_not_zero(buf, 512);
404 for(i = 1; i < n; i++) {
405 buf += 512;
406 if (v != is_not_zero(buf, 512))
407 break;
408 }
409 *pnum = i;
410 return v;
411 }
412
413 #define IO_BUF_SIZE 65536
414
415 static int img_convert(int argc, char **argv)
416 {
417 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
418 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
419 BlockDriver *drv;
420 BlockDriverState **bs, *out_bs;
421 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
422 uint64_t bs_sectors;
423 uint8_t buf[IO_BUF_SIZE];
424 const uint8_t *buf1;
425 BlockDriverInfo bdi;
426
427 fmt = NULL;
428 out_fmt = "raw";
429 out_baseimg = NULL;
430 flags = 0;
431 for(;;) {
432 c = getopt(argc, argv, "f:O:B:hce6");
433 if (c == -1)
434 break;
435 switch(c) {
436 case 'h':
437 help();
438 break;
439 case 'f':
440 fmt = optarg;
441 break;
442 case 'O':
443 out_fmt = optarg;
444 break;
445 case 'B':
446 out_baseimg = optarg;
447 break;
448 case 'c':
449 flags |= BLOCK_FLAG_COMPRESS;
450 break;
451 case 'e':
452 flags |= BLOCK_FLAG_ENCRYPT;
453 break;
454 case '6':
455 flags |= BLOCK_FLAG_COMPAT6;
456 break;
457 }
458 }
459
460 bs_n = argc - optind - 1;
461 if (bs_n < 1) help();
462
463 out_filename = argv[argc - 1];
464
465 if (bs_n > 1 && out_baseimg)
466 error("-B makes no sense when concatenating multiple input images");
467
468 bs = calloc(bs_n, sizeof(BlockDriverState *));
469 if (!bs)
470 error("Out of memory");
471
472 total_sectors = 0;
473 for (bs_i = 0; bs_i < bs_n; bs_i++) {
474 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
475 if (!bs[bs_i])
476 error("Could not open '%s'", argv[optind + bs_i]);
477 bdrv_get_geometry(bs[bs_i], &bs_sectors);
478 total_sectors += bs_sectors;
479 }
480
481 drv = bdrv_find_format(out_fmt);
482 if (!drv)
483 error("Unknown file format '%s'", out_fmt);
484 if (flags & BLOCK_FLAG_COMPRESS && drv != &bdrv_qcow && drv != &bdrv_qcow2)
485 error("Compression not supported for this file format");
486 if (flags & BLOCK_FLAG_ENCRYPT && drv != &bdrv_qcow && drv != &bdrv_qcow2)
487 error("Encryption not supported for this file format");
488 if (flags & BLOCK_FLAG_COMPAT6 && drv != &bdrv_vmdk)
489 error("Alternative compatibility level not supported for this file format");
490 if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS)
491 error("Compression and encryption not supported at the same time");
492
493 ret = bdrv_create(drv, out_filename, total_sectors, out_baseimg, flags);
494 if (ret < 0) {
495 if (ret == -ENOTSUP) {
496 error("Formatting not supported for file format '%s'", out_fmt);
497 } else {
498 error("Error while formatting '%s'", out_filename);
499 }
500 }
501
502 out_bs = bdrv_new_open(out_filename, out_fmt);
503
504 bs_i = 0;
505 bs_offset = 0;
506 bdrv_get_geometry(bs[0], &bs_sectors);
507
508 if (flags & BLOCK_FLAG_COMPRESS) {
509 if (bdrv_get_info(out_bs, &bdi) < 0)
510 error("could not get block driver info");
511 cluster_size = bdi.cluster_size;
512 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
513 error("invalid cluster size");
514 cluster_sectors = cluster_size >> 9;
515 sector_num = 0;
516 for(;;) {
517 int64_t bs_num;
518 int remainder;
519 uint8_t *buf2;
520
521 nb_sectors = total_sectors - sector_num;
522 if (nb_sectors <= 0)
523 break;
524 if (nb_sectors >= cluster_sectors)
525 n = cluster_sectors;
526 else
527 n = nb_sectors;
528
529 bs_num = sector_num - bs_offset;
530 assert (bs_num >= 0);
531 remainder = n;
532 buf2 = buf;
533 while (remainder > 0) {
534 int nlow;
535 while (bs_num == bs_sectors) {
536 bs_i++;
537 assert (bs_i < bs_n);
538 bs_offset += bs_sectors;
539 bdrv_get_geometry(bs[bs_i], &bs_sectors);
540 bs_num = 0;
541 /* printf("changing part: sector_num=%lld, "
542 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
543 sector_num, bs_i, bs_offset, bs_sectors); */
544 }
545 assert (bs_num < bs_sectors);
546
547 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
548
549 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
550 error("error while reading");
551
552 buf2 += nlow * 512;
553 bs_num += nlow;
554
555 remainder -= nlow;
556 }
557 assert (remainder == 0);
558
559 if (n < cluster_sectors)
560 memset(buf + n * 512, 0, cluster_size - n * 512);
561 if (is_not_zero(buf, cluster_size)) {
562 if (bdrv_write_compressed(out_bs, sector_num, buf,
563 cluster_sectors) != 0)
564 error("error while compressing sector %" PRId64,
565 sector_num);
566 }
567 sector_num += n;
568 }
569 /* signal EOF to align */
570 bdrv_write_compressed(out_bs, 0, NULL, 0);
571 } else {
572 sector_num = 0; // total number of sectors converted so far
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
582 while (sector_num - bs_offset >= bs_sectors) {
583 bs_i ++;
584 assert (bs_i < bs_n);
585 bs_offset += bs_sectors;
586 bdrv_get_geometry(bs[bs_i], &bs_sectors);
587 /* printf("changing part: sector_num=%lld, bs_i=%d, "
588 "bs_offset=%lld, bs_sectors=%lld\n",
589 sector_num, bs_i, bs_offset, bs_sectors); */
590 }
591
592 if (n > bs_offset + bs_sectors - sector_num)
593 n = bs_offset + bs_sectors - sector_num;
594
595 if (drv != &bdrv_host_device) {
596 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset,
597 n, &n1)) {
598 sector_num += n1;
599 continue;
600 }
601 /* The next 'n1' sectors are allocated in the input image. Copy
602 only those as they may be followed by unallocated sectors. */
603 n = n1;
604 } else {
605 n1 = n;
606 }
607
608 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
609 error("error while reading");
610 /* NOTE: at the same time we convert, we do not write zero
611 sectors to have a chance to compress the image. Ideally, we
612 should add a specific call to have the info to go faster */
613 buf1 = buf;
614 while (n > 0) {
615 /* If the output image is being created as a copy on write image,
616 copy all sectors even the ones containing only NUL bytes,
617 because they may differ from the sectors in the base image.
618
619 If the output is to a host device, we also write out
620 sectors that are entirely 0, since whatever data was
621 already there is garbage, not 0s. */
622 if (drv == &bdrv_host_device || out_baseimg ||
623 is_allocated_sectors(buf1, n, &n1)) {
624 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
625 error("error while writing");
626 }
627 sector_num += n1;
628 n -= n1;
629 buf1 += n1 * 512;
630 }
631 }
632 }
633 bdrv_delete(out_bs);
634 for (bs_i = 0; bs_i < bs_n; bs_i++)
635 bdrv_delete(bs[bs_i]);
636 free(bs);
637 return 0;
638 }
639
640 #ifdef _WIN32
641 static int64_t get_allocated_file_size(const char *filename)
642 {
643 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
644 get_compressed_t get_compressed;
645 struct _stati64 st;
646
647 /* WinNT support GetCompressedFileSize to determine allocate size */
648 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
649 if (get_compressed) {
650 DWORD high, low;
651 low = get_compressed(filename, &high);
652 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
653 return (((int64_t) high) << 32) + low;
654 }
655
656 if (_stati64(filename, &st) < 0)
657 return -1;
658 return st.st_size;
659 }
660 #else
661 static int64_t get_allocated_file_size(const char *filename)
662 {
663 struct stat st;
664 if (stat(filename, &st) < 0)
665 return -1;
666 return (int64_t)st.st_blocks * 512;
667 }
668 #endif
669
670 static void dump_snapshots(BlockDriverState *bs)
671 {
672 QEMUSnapshotInfo *sn_tab, *sn;
673 int nb_sns, i;
674 char buf[256];
675
676 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
677 if (nb_sns <= 0)
678 return;
679 printf("Snapshot list:\n");
680 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
681 for(i = 0; i < nb_sns; i++) {
682 sn = &sn_tab[i];
683 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
684 }
685 qemu_free(sn_tab);
686 }
687
688 static int img_info(int argc, char **argv)
689 {
690 int c;
691 const char *filename, *fmt;
692 BlockDriver *drv;
693 BlockDriverState *bs;
694 char fmt_name[128], size_buf[128], dsize_buf[128];
695 uint64_t total_sectors;
696 int64_t allocated_size;
697 char backing_filename[1024];
698 char backing_filename2[1024];
699 BlockDriverInfo bdi;
700
701 fmt = NULL;
702 for(;;) {
703 c = getopt(argc, argv, "f:h");
704 if (c == -1)
705 break;
706 switch(c) {
707 case 'h':
708 help();
709 break;
710 case 'f':
711 fmt = optarg;
712 break;
713 }
714 }
715 if (optind >= argc)
716 help();
717 filename = argv[optind++];
718
719 bs = bdrv_new("");
720 if (!bs)
721 error("Not enough memory");
722 if (fmt) {
723 drv = bdrv_find_format(fmt);
724 if (!drv)
725 error("Unknown file format '%s'", fmt);
726 } else {
727 drv = NULL;
728 }
729 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
730 error("Could not open '%s'", filename);
731 }
732 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
733 bdrv_get_geometry(bs, &total_sectors);
734 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
735 allocated_size = get_allocated_file_size(filename);
736 if (allocated_size < 0)
737 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
738 else
739 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
740 allocated_size);
741 printf("image: %s\n"
742 "file format: %s\n"
743 "virtual size: %s (%" PRId64 " bytes)\n"
744 "disk size: %s\n",
745 filename, fmt_name, size_buf,
746 (total_sectors * 512),
747 dsize_buf);
748 if (bdrv_is_encrypted(bs))
749 printf("encrypted: yes\n");
750 if (bdrv_get_info(bs, &bdi) >= 0) {
751 if (bdi.cluster_size != 0)
752 printf("cluster_size: %d\n", bdi.cluster_size);
753 }
754 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
755 if (backing_filename[0] != '\0') {
756 path_combine(backing_filename2, sizeof(backing_filename2),
757 filename, backing_filename);
758 printf("backing file: %s (actual path: %s)\n",
759 backing_filename,
760 backing_filename2);
761 }
762 dump_snapshots(bs);
763 bdrv_delete(bs);
764 return 0;
765 }
766
767 #define SNAPSHOT_LIST 1
768 #define SNAPSHOT_CREATE 2
769 #define SNAPSHOT_APPLY 3
770 #define SNAPSHOT_DELETE 4
771
772 static void img_snapshot(int argc, char **argv)
773 {
774 BlockDriverState *bs;
775 QEMUSnapshotInfo sn;
776 char *filename, *snapshot_name = NULL;
777 int c, ret;
778 int action = 0;
779 qemu_timeval tv;
780
781 /* Parse commandline parameters */
782 for(;;) {
783 c = getopt(argc, argv, "la:c:d:h");
784 if (c == -1)
785 break;
786 switch(c) {
787 case 'h':
788 help();
789 return;
790 case 'l':
791 if (action) {
792 help();
793 return;
794 }
795 action = SNAPSHOT_LIST;
796 break;
797 case 'a':
798 if (action) {
799 help();
800 return;
801 }
802 action = SNAPSHOT_APPLY;
803 snapshot_name = optarg;
804 break;
805 case 'c':
806 if (action) {
807 help();
808 return;
809 }
810 action = SNAPSHOT_CREATE;
811 snapshot_name = optarg;
812 break;
813 case 'd':
814 if (action) {
815 help();
816 return;
817 }
818 action = SNAPSHOT_DELETE;
819 snapshot_name = optarg;
820 break;
821 }
822 }
823
824 if (optind >= argc)
825 help();
826 filename = argv[optind++];
827
828 /* Open the image */
829 bs = bdrv_new("");
830 if (!bs)
831 error("Not enough memory");
832
833 if (bdrv_open2(bs, filename, 0, NULL) < 0) {
834 error("Could not open '%s'", filename);
835 }
836
837 /* Perform the requested action */
838 switch(action) {
839 case SNAPSHOT_LIST:
840 dump_snapshots(bs);
841 break;
842
843 case SNAPSHOT_CREATE:
844 memset(&sn, 0, sizeof(sn));
845 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
846
847 qemu_gettimeofday(&tv);
848 sn.date_sec = tv.tv_sec;
849 sn.date_nsec = tv.tv_usec * 1000;
850
851 ret = bdrv_snapshot_create(bs, &sn);
852 if (ret)
853 error("Could not create snapshot '%s': %d (%s)",
854 snapshot_name, ret, strerror(-ret));
855 break;
856
857 case SNAPSHOT_APPLY:
858 ret = bdrv_snapshot_goto(bs, snapshot_name);
859 if (ret)
860 error("Could not apply snapshot '%s': %d (%s)",
861 snapshot_name, ret, strerror(-ret));
862 break;
863
864 case SNAPSHOT_DELETE:
865 ret = bdrv_snapshot_delete(bs, snapshot_name);
866 if (ret)
867 error("Could not delete snapshot '%s': %d (%s)",
868 snapshot_name, ret, strerror(-ret));
869 break;
870 }
871
872 /* Cleanup */
873 bdrv_delete(bs);
874 }
875
876 int main(int argc, char **argv)
877 {
878 const char *cmd;
879
880 bdrv_init();
881 if (argc < 2)
882 help();
883 cmd = argv[1];
884 argc--; argv++;
885 if (!strcmp(cmd, "create")) {
886 img_create(argc, argv);
887 } else if (!strcmp(cmd, "commit")) {
888 img_commit(argc, argv);
889 } else if (!strcmp(cmd, "convert")) {
890 img_convert(argc, argv);
891 } else if (!strcmp(cmd, "info")) {
892 img_info(argc, argv);
893 } else if (!strcmp(cmd, "snapshot")) {
894 img_snapshot(argc, argv);
895 } else {
896 help();
897 }
898 return 0;
899 }