?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vnc: throttle screen updates. (Gerd Hoffmann)
[sniper_test.git] / qemu-img.c
blob66ec91cc11f4cefdc904f8060b876ab2560e7adb
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
29 #ifdef _WIN32
30 #include <windows.h>
31 #endif
32
33 /* Default to cache=writeback as data integrity is not important for qemu-tcg. */
34 #define BRDV_O_FLAGS BDRV_O_CACHE_WB
35
36 static void QEMU_NORETURN error(const char *fmt, ...)
37 {
38 va_list ap;
39 va_start(ap, fmt);
40 fprintf(stderr, "qemu-img: ");
41 vfprintf(stderr, fmt, ap);
42 fprintf(stderr, "\n");
43 exit(1);
44 va_end(ap);
45 }
46
47 static void format_print(void *opaque, const char *name)
48 {
49 printf(" %s", name);
50 }
51
52 /* Please keep in synch with qemu-img.texi */
53 static void help(void)
54 {
55 printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2008 Fabrice Bellard\n"
56 "usage: qemu-img command [command options]\n"
57 "QEMU disk image utility\n"
58 "\n"
59 "Command syntax:\n"
60 " create [-e] [-6] [-b base_image] [-f fmt] filename [size]\n"
61 " commit [-f fmt] filename\n"
62 " convert [-c] [-e] [-6] [-f fmt] [-O output_fmt] [-B output_base_image] filename [filename2 [...]] output_filename\n"
63 " info [-f fmt] filename\n"
64 " snapshot [-l | -a snapshot | -c snapshot | -d snapshot] filename\n"
65 "\n"
66 "Command parameters:\n"
67 " 'filename' is a disk image filename\n"
68 " 'base_image' is the read-only disk image which is used as base for a copy on\n"
69 " write image; the copy on write image only stores the modified data\n"
70 " 'output_base_image' forces the output image to be created as a copy on write\n"
71 " image of the specified base image; 'output_base_image' should have the same\n"
72 " content as the input's base image, however the path, image format, etc may\n"
73 " differ\n"
74 " 'fmt' is the disk image format. It is guessed automatically in most cases\n"
75 " 'size' is the disk image size in kilobytes. Optional suffixes\n"
76 " 'M' (megabyte, 1024 * 1024) and 'G' (gigabyte, 1024 * 1024 * 1024) are\n"
77 " supported any 'k' or 'K' is ignored\n"
78 " 'output_filename' is the destination disk image filename\n"
79 " 'output_fmt' is the destination format\n"
80 " '-c' indicates that target image must be compressed (qcow format only)\n"
81 " '-e' indicates that the target image must be encrypted (qcow format only)\n"
82 " '-6' indicates that the target image must use compatibility level 6 (vmdk format only)\n"
83 " '-h' with or without a command shows this help and lists the supported formats\n"
84 "\n"
85 "Parameters to snapshot subcommand:\n"
86 " 'snapshot' is the name of the snapshot to create, apply or delete\n"
87 " '-a' applies a snapshot (revert disk to saved state)\n"
88 " '-c' creates a snapshot\n"
89 " '-d' deletes a snapshot\n"
90 " '-l' lists all snapshots in the given image\n"
91 );
92 printf("\nSupported formats:");
93 bdrv_iterate_format(format_print, NULL);
94 printf("\n");
95 exit(1);
96 }
97
98 #if defined(WIN32)
99 /* XXX: put correct support for win32 */
100 static int read_password(char *buf, int buf_size)
101 {
102 int c, i;
103 printf("Password: ");
104 fflush(stdout);
105 i = 0;
106 for(;;) {
107 c = getchar();
108 if (c == '\n')
109 break;
110 if (i < (buf_size - 1))
111 buf[i++] = c;
112 }
113 buf[i] = '\0';
114 return 0;
115 }
116
117 #else
118
119 #include <termios.h>
120
121 static struct termios oldtty;
122
123 static void term_exit(void)
124 {
125 tcsetattr (0, TCSANOW, &oldtty);
126 }
127
128 static void term_init(void)
129 {
130 struct termios tty;
131
132 tcgetattr (0, &tty);
133 oldtty = tty;
134
135 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
136 |INLCR|IGNCR|ICRNL|IXON);
137 tty.c_oflag |= OPOST;
138 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
139 tty.c_cflag &= ~(CSIZE|PARENB);
140 tty.c_cflag |= CS8;
141 tty.c_cc[VMIN] = 1;
142 tty.c_cc[VTIME] = 0;
143
144 tcsetattr (0, TCSANOW, &tty);
145
146 atexit(term_exit);
147 }
148
149 static int read_password(char *buf, int buf_size)
150 {
151 uint8_t ch;
152 int i, ret;
153
154 printf("password: ");
155 fflush(stdout);
156 term_init();
157 i = 0;
158 for(;;) {
159 ret = read(0, &ch, 1);
160 if (ret == -1) {
161 if (errno == EAGAIN || errno == EINTR) {
162 continue;
163 } else {
164 ret = -1;
165 break;
166 }
167 } else if (ret == 0) {
168 ret = -1;
169 break;
170 } else {
171 if (ch == '\r') {
172 ret = 0;
173 break;
174 }
175 if (i < (buf_size - 1))
176 buf[i++] = ch;
177 }
178 }
179 term_exit();
180 buf[i] = '\0';
181 printf("\n");
182 return ret;
183 }
184 #endif
185
186 static BlockDriverState *bdrv_new_open(const char *filename,
187 const char *fmt)
188 {
189 BlockDriverState *bs;
190 BlockDriver *drv;
191 char password[256];
192
193 bs = bdrv_new("");
194 if (!bs)
195 error("Not enough memory");
196 if (fmt) {
197 drv = bdrv_find_format(fmt);
198 if (!drv)
199 error("Unknown file format '%s'", fmt);
200 } else {
201 drv = NULL;
202 }
203 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
204 error("Could not open '%s'", filename);
205 }
206 if (bdrv_is_encrypted(bs)) {
207 printf("Disk image '%s' is encrypted.\n", filename);
208 if (read_password(password, sizeof(password)) < 0)
209 error("No password given");
210 if (bdrv_set_key(bs, password) < 0)
211 error("invalid password");
212 }
213 return bs;
214 }
215
216 static int img_create(int argc, char **argv)
217 {
218 int c, ret, flags;
219 const char *fmt = "raw";
220 const char *filename;
221 const char *base_filename = NULL;
222 uint64_t size;
223 double sizef;
224 const char *p;
225 BlockDriver *drv;
226
227 flags = 0;
228 for(;;) {
229 c = getopt(argc, argv, "b:f:he6");
230 if (c == -1)
231 break;
232 switch(c) {
233 case 'h':
234 help();
235 break;
236 case 'b':
237 base_filename = optarg;
238 break;
239 case 'f':
240 fmt = optarg;
241 break;
242 case 'e':
243 flags |= BLOCK_FLAG_ENCRYPT;
244 break;
245 case '6':
246 flags |= BLOCK_FLAG_COMPAT6;
247 break;
248 }
249 }
250 if (optind >= argc)
251 help();
252 filename = argv[optind++];
253 size = 0;
254 if (base_filename) {
255 BlockDriverState *bs;
256 bs = bdrv_new_open(base_filename, NULL);
257 bdrv_get_geometry(bs, &size);
258 size *= 512;
259 bdrv_delete(bs);
260 } else {
261 if (optind >= argc)
262 help();
263 p = argv[optind];
264 sizef = strtod(p, (char **)&p);
265 if (*p == 'M') {
266 size = (uint64_t)(sizef * 1024 * 1024);
267 } else if (*p == 'G') {
268 size = (uint64_t)(sizef * 1024 * 1024 * 1024);
269 } else if (*p == 'k' || *p == 'K' || *p == '\0') {
270 size = (uint64_t)(sizef * 1024);
271 } else {
272 help();
273 }
274 }
275 drv = bdrv_find_format(fmt);
276 if (!drv)
277 error("Unknown file format '%s'", fmt);
278 printf("Formatting '%s', fmt=%s",
279 filename, fmt);
280 if (flags & BLOCK_FLAG_ENCRYPT)
281 printf(", encrypted");
282 if (flags & BLOCK_FLAG_COMPAT6)
283 printf(", compatibility level=6");
284 if (base_filename) {
285 printf(", backing_file=%s",
286 base_filename);
287 }
288 printf(", size=%" PRIu64 " kB\n", size / 1024);
289 ret = bdrv_create(drv, filename, size / 512, base_filename, flags);
290 if (ret < 0) {
291 if (ret == -ENOTSUP) {
292 error("Formatting or formatting option not supported for file format '%s'", fmt);
293 } else {
294 error("Error while formatting");
295 }
296 }
297 return 0;
298 }
299
300 static int img_commit(int argc, char **argv)
301 {
302 int c, ret;
303 const char *filename, *fmt;
304 BlockDriver *drv;
305 BlockDriverState *bs;
306
307 fmt = NULL;
308 for(;;) {
309 c = getopt(argc, argv, "f:h");
310 if (c == -1)
311 break;
312 switch(c) {
313 case 'h':
314 help();
315 break;
316 case 'f':
317 fmt = optarg;
318 break;
319 }
320 }
321 if (optind >= argc)
322 help();
323 filename = argv[optind++];
324
325 bs = bdrv_new("");
326 if (!bs)
327 error("Not enough memory");
328 if (fmt) {
329 drv = bdrv_find_format(fmt);
330 if (!drv)
331 error("Unknown file format '%s'", fmt);
332 } else {
333 drv = NULL;
334 }
335 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
336 error("Could not open '%s'", filename);
337 }
338 ret = bdrv_commit(bs);
339 switch(ret) {
340 case 0:
341 printf("Image committed.\n");
342 break;
343 case -ENOENT:
344 error("No disk inserted");
345 break;
346 case -EACCES:
347 error("Image is read-only");
348 break;
349 case -ENOTSUP:
350 error("Image is already committed");
351 break;
352 default:
353 error("Error while committing image");
354 break;
355 }
356
357 bdrv_delete(bs);
358 return 0;
359 }
360
361 static int is_not_zero(const uint8_t *sector, int len)
362 {
363 int i;
364 len >>= 2;
365 for(i = 0;i < len; i++) {
366 if (((uint32_t *)sector)[i] != 0)
367 return 1;
368 }
369 return 0;
370 }
371
372 /*
373 * Returns true iff the first sector pointed to by 'buf' contains at least
374 * a non-NUL byte.
375 *
376 * 'pnum' is set to the number of sectors (including and immediately following
377 * the first one) that are known to be in the same allocated/unallocated state.
378 */
379 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
380 {
381 int v, i;
382
383 if (n <= 0) {
384 *pnum = 0;
385 return 0;
386 }
387 v = is_not_zero(buf, 512);
388 for(i = 1; i < n; i++) {
389 buf += 512;
390 if (v != is_not_zero(buf, 512))
391 break;
392 }
393 *pnum = i;
394 return v;
395 }
396
397 #define IO_BUF_SIZE 65536
398
399 static int img_convert(int argc, char **argv)
400 {
401 int c, ret, n, n1, bs_n, bs_i, flags, cluster_size, cluster_sectors;
402 const char *fmt, *out_fmt, *out_baseimg, *out_filename;
403 BlockDriver *drv;
404 BlockDriverState **bs, *out_bs;
405 int64_t total_sectors, nb_sectors, sector_num, bs_offset;
406 uint64_t bs_sectors;
407 uint8_t buf[IO_BUF_SIZE];
408 const uint8_t *buf1;
409 BlockDriverInfo bdi;
410
411 fmt = NULL;
412 out_fmt = "raw";
413 out_baseimg = NULL;
414 flags = 0;
415 for(;;) {
416 c = getopt(argc, argv, "f:O:B:hce6");
417 if (c == -1)
418 break;
419 switch(c) {
420 case 'h':
421 help();
422 break;
423 case 'f':
424 fmt = optarg;
425 break;
426 case 'O':
427 out_fmt = optarg;
428 break;
429 case 'B':
430 out_baseimg = optarg;
431 break;
432 case 'c':
433 flags |= BLOCK_FLAG_COMPRESS;
434 break;
435 case 'e':
436 flags |= BLOCK_FLAG_ENCRYPT;
437 break;
438 case '6':
439 flags |= BLOCK_FLAG_COMPAT6;
440 break;
441 }
442 }
443
444 bs_n = argc - optind - 1;
445 if (bs_n < 1) help();
446
447 out_filename = argv[argc - 1];
448
449 if (bs_n > 1 && out_baseimg)
450 error("-B makes no sense when concatenating multiple input images");
451
452 bs = calloc(bs_n, sizeof(BlockDriverState *));
453 if (!bs)
454 error("Out of memory");
455
456 total_sectors = 0;
457 for (bs_i = 0; bs_i < bs_n; bs_i++) {
458 bs[bs_i] = bdrv_new_open(argv[optind + bs_i], fmt);
459 if (!bs[bs_i])
460 error("Could not open '%s'", argv[optind + bs_i]);
461 bdrv_get_geometry(bs[bs_i], &bs_sectors);
462 total_sectors += bs_sectors;
463 }
464
465 drv = bdrv_find_format(out_fmt);
466 if (!drv)
467 error("Unknown file format '%s'", out_fmt);
468 if (flags & BLOCK_FLAG_COMPRESS && drv != &bdrv_qcow && drv != &bdrv_qcow2)
469 error("Compression not supported for this file format");
470 if (flags & BLOCK_FLAG_ENCRYPT && drv != &bdrv_qcow && drv != &bdrv_qcow2)
471 error("Encryption not supported for this file format");
472 if (flags & BLOCK_FLAG_COMPAT6 && drv != &bdrv_vmdk)
473 error("Alternative compatibility level not supported for this file format");
474 if (flags & BLOCK_FLAG_ENCRYPT && flags & BLOCK_FLAG_COMPRESS)
475 error("Compression and encryption not supported at the same time");
476
477 ret = bdrv_create(drv, out_filename, total_sectors, out_baseimg, flags);
478 if (ret < 0) {
479 if (ret == -ENOTSUP) {
480 error("Formatting not supported for file format '%s'", fmt);
481 } else {
482 error("Error while formatting '%s'", out_filename);
483 }
484 }
485
486 out_bs = bdrv_new_open(out_filename, out_fmt);
487
488 bs_i = 0;
489 bs_offset = 0;
490 bdrv_get_geometry(bs[0], &bs_sectors);
491
492 if (flags & BLOCK_FLAG_COMPRESS) {
493 if (bdrv_get_info(out_bs, &bdi) < 0)
494 error("could not get block driver info");
495 cluster_size = bdi.cluster_size;
496 if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
497 error("invalid cluster size");
498 cluster_sectors = cluster_size >> 9;
499 sector_num = 0;
500 for(;;) {
501 int64_t bs_num;
502 int remainder;
503 uint8_t *buf2;
504
505 nb_sectors = total_sectors - sector_num;
506 if (nb_sectors <= 0)
507 break;
508 if (nb_sectors >= cluster_sectors)
509 n = cluster_sectors;
510 else
511 n = nb_sectors;
512
513 bs_num = sector_num - bs_offset;
514 assert (bs_num >= 0);
515 remainder = n;
516 buf2 = buf;
517 while (remainder > 0) {
518 int nlow;
519 while (bs_num == bs_sectors) {
520 bs_i++;
521 assert (bs_i < bs_n);
522 bs_offset += bs_sectors;
523 bdrv_get_geometry(bs[bs_i], &bs_sectors);
524 bs_num = 0;
525 /* printf("changing part: sector_num=%lld, "
526 "bs_i=%d, bs_offset=%lld, bs_sectors=%lld\n",
527 sector_num, bs_i, bs_offset, bs_sectors); */
528 }
529 assert (bs_num < bs_sectors);
530
531 nlow = (remainder > bs_sectors - bs_num) ? bs_sectors - bs_num : remainder;
532
533 if (bdrv_read(bs[bs_i], bs_num, buf2, nlow) < 0)
534 error("error while reading");
535
536 buf2 += nlow * 512;
537 bs_num += nlow;
538
539 remainder -= nlow;
540 }
541 assert (remainder == 0);
542
543 if (n < cluster_sectors)
544 memset(buf + n * 512, 0, cluster_size - n * 512);
545 if (is_not_zero(buf, cluster_size)) {
546 if (bdrv_write_compressed(out_bs, sector_num, buf,
547 cluster_sectors) != 0)
548 error("error while compressing sector %" PRId64,
549 sector_num);
550 }
551 sector_num += n;
552 }
553 /* signal EOF to align */
554 bdrv_write_compressed(out_bs, 0, NULL, 0);
555 } else {
556 sector_num = 0; // total number of sectors converted so far
557 for(;;) {
558 nb_sectors = total_sectors - sector_num;
559 if (nb_sectors <= 0)
560 break;
561 if (nb_sectors >= (IO_BUF_SIZE / 512))
562 n = (IO_BUF_SIZE / 512);
563 else
564 n = nb_sectors;
565
566 while (sector_num - bs_offset >= bs_sectors) {
567 bs_i ++;
568 assert (bs_i < bs_n);
569 bs_offset += bs_sectors;
570 bdrv_get_geometry(bs[bs_i], &bs_sectors);
571 /* printf("changing part: sector_num=%lld, bs_i=%d, "
572 "bs_offset=%lld, bs_sectors=%lld\n",
573 sector_num, bs_i, bs_offset, bs_sectors); */
574 }
575
576 if (n > bs_offset + bs_sectors - sector_num)
577 n = bs_offset + bs_sectors - sector_num;
578
579 /* If the output image is being created as a copy on write image,
580 assume that sectors which are unallocated in the input image
581 are present in both the output's and input's base images (no
582 need to copy them). */
583 if (out_baseimg) {
584 if (!bdrv_is_allocated(bs[bs_i], sector_num - bs_offset, n, &n1)) {
585 sector_num += n1;
586 continue;
587 }
588 /* The next 'n1' sectors are allocated in the input image. Copy
589 only those as they may be followed by unallocated sectors. */
590 n = n1;
591 }
592
593 if (bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n) < 0)
594 error("error while reading");
595 /* NOTE: at the same time we convert, we do not write zero
596 sectors to have a chance to compress the image. Ideally, we
597 should add a specific call to have the info to go faster */
598 buf1 = buf;
599 while (n > 0) {
600 /* If the output image is being created as a copy on write image,
601 copy all sectors even the ones containing only NUL bytes,
602 because they may differ from the sectors in the base image. */
603 if (out_baseimg || is_allocated_sectors(buf1, n, &n1)) {
604 if (bdrv_write(out_bs, sector_num, buf1, n1) < 0)
605 error("error while writing");
606 }
607 sector_num += n1;
608 n -= n1;
609 buf1 += n1 * 512;
610 }
611 }
612 }
613 bdrv_delete(out_bs);
614 for (bs_i = 0; bs_i < bs_n; bs_i++)
615 bdrv_delete(bs[bs_i]);
616 free(bs);
617 return 0;
618 }
619
620 #ifdef _WIN32
621 static int64_t get_allocated_file_size(const char *filename)
622 {
623 typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
624 get_compressed_t get_compressed;
625 struct _stati64 st;
626
627 /* WinNT support GetCompressedFileSize to determine allocate size */
628 get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
629 if (get_compressed) {
630 DWORD high, low;
631 low = get_compressed(filename, &high);
632 if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
633 return (((int64_t) high) << 32) + low;
634 }
635
636 if (_stati64(filename, &st) < 0)
637 return -1;
638 return st.st_size;
639 }
640 #else
641 static int64_t get_allocated_file_size(const char *filename)
642 {
643 struct stat st;
644 if (stat(filename, &st) < 0)
645 return -1;
646 return (int64_t)st.st_blocks * 512;
647 }
648 #endif
649
650 static void dump_snapshots(BlockDriverState *bs)
651 {
652 QEMUSnapshotInfo *sn_tab, *sn;
653 int nb_sns, i;
654 char buf[256];
655
656 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
657 if (nb_sns <= 0)
658 return;
659 printf("Snapshot list:\n");
660 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
661 for(i = 0; i < nb_sns; i++) {
662 sn = &sn_tab[i];
663 printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
664 }
665 qemu_free(sn_tab);
666 }
667
668 static int img_info(int argc, char **argv)
669 {
670 int c;
671 const char *filename, *fmt;
672 BlockDriver *drv;
673 BlockDriverState *bs;
674 char fmt_name[128], size_buf[128], dsize_buf[128];
675 uint64_t total_sectors;
676 int64_t allocated_size;
677 char backing_filename[1024];
678 char backing_filename2[1024];
679 BlockDriverInfo bdi;
680
681 fmt = NULL;
682 for(;;) {
683 c = getopt(argc, argv, "f:h");
684 if (c == -1)
685 break;
686 switch(c) {
687 case 'h':
688 help();
689 break;
690 case 'f':
691 fmt = optarg;
692 break;
693 }
694 }
695 if (optind >= argc)
696 help();
697 filename = argv[optind++];
698
699 bs = bdrv_new("");
700 if (!bs)
701 error("Not enough memory");
702 if (fmt) {
703 drv = bdrv_find_format(fmt);
704 if (!drv)
705 error("Unknown file format '%s'", fmt);
706 } else {
707 drv = NULL;
708 }
709 if (bdrv_open2(bs, filename, BRDV_O_FLAGS, drv) < 0) {
710 error("Could not open '%s'", filename);
711 }
712 bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
713 bdrv_get_geometry(bs, &total_sectors);
714 get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
715 allocated_size = get_allocated_file_size(filename);
716 if (allocated_size < 0)
717 snprintf(dsize_buf, sizeof(dsize_buf), "unavailable");
718 else
719 get_human_readable_size(dsize_buf, sizeof(dsize_buf),
720 allocated_size);
721 printf("image: %s\n"
722 "file format: %s\n"
723 "virtual size: %s (%" PRId64 " bytes)\n"
724 "disk size: %s\n",
725 filename, fmt_name, size_buf,
726 (total_sectors * 512),
727 dsize_buf);
728 if (bdrv_is_encrypted(bs))
729 printf("encrypted: yes\n");
730 if (bdrv_get_info(bs, &bdi) >= 0) {
731 if (bdi.cluster_size != 0)
732 printf("cluster_size: %d\n", bdi.cluster_size);
733 }
734 bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
735 if (backing_filename[0] != '\0') {
736 path_combine(backing_filename2, sizeof(backing_filename2),
737 filename, backing_filename);
738 printf("backing file: %s (actual path: %s)\n",
739 backing_filename,
740 backing_filename2);
741 }
742 dump_snapshots(bs);
743 bdrv_delete(bs);
744 return 0;
745 }
746
747 #define SNAPSHOT_LIST 1
748 #define SNAPSHOT_CREATE 2
749 #define SNAPSHOT_APPLY 3
750 #define SNAPSHOT_DELETE 4
751
752 static void img_snapshot(int argc, char **argv)
753 {
754 BlockDriverState *bs;
755 QEMUSnapshotInfo sn;
756 char *filename, *snapshot_name = NULL;
757 int c, ret;
758 int action = 0;
759 qemu_timeval tv;
760
761 /* Parse commandline parameters */
762 for(;;) {
763 c = getopt(argc, argv, "la:c:d:h");
764 if (c == -1)
765 break;
766 switch(c) {
767 case 'h':
768 help();
769 return;
770 case 'l':
771 if (action) {
772 help();
773 return;
774 }
775 action = SNAPSHOT_LIST;
776 break;
777 case 'a':
778 if (action) {
779 help();
780 return;
781 }
782 action = SNAPSHOT_APPLY;
783 snapshot_name = optarg;
784 break;
785 case 'c':
786 if (action) {
787 help();
788 return;
789 }
790 action = SNAPSHOT_CREATE;
791 snapshot_name = optarg;
792 break;
793 case 'd':
794 if (action) {
795 help();
796 return;
797 }
798 action = SNAPSHOT_DELETE;
799 snapshot_name = optarg;
800 break;
801 }
802 }
803
804 if (optind >= argc)
805 help();
806 filename = argv[optind++];
807
808 /* Open the image */
809 bs = bdrv_new("");
810 if (!bs)
811 error("Not enough memory");
812
813 if (bdrv_open2(bs, filename, 0, NULL) < 0) {
814 error("Could not open '%s'", filename);
815 }
816
817 /* Perform the requested action */
818 switch(action) {
819 case SNAPSHOT_LIST:
820 dump_snapshots(bs);
821 break;
822
823 case SNAPSHOT_CREATE:
824 memset(&sn, 0, sizeof(sn));
825 pstrcpy(sn.name, sizeof(sn.name), snapshot_name);
826
827 qemu_gettimeofday(&tv);
828 sn.date_sec = tv.tv_sec;
829 sn.date_nsec = tv.tv_usec * 1000;
830
831 ret = bdrv_snapshot_create(bs, &sn);
832 if (ret)
833 error("Could not create snapshot '%s': %d (%s)",
834 snapshot_name, ret, strerror(-ret));
835 break;
836
837 case SNAPSHOT_APPLY:
838 ret = bdrv_snapshot_goto(bs, snapshot_name);
839 if (ret)
840 error("Could not apply snapshot '%s': %d (%s)",
841 snapshot_name, ret, strerror(-ret));
842 break;
843
844 case SNAPSHOT_DELETE:
845 ret = bdrv_snapshot_delete(bs, snapshot_name);
846 if (ret)
847 error("Could not delete snapshot '%s': %d (%s)",
848 snapshot_name, ret, strerror(-ret));
849 break;
850 }
851
852 /* Cleanup */
853 bdrv_delete(bs);
854 }
855
856 int main(int argc, char **argv)
857 {
858 const char *cmd;
859
860 bdrv_init();
861 if (argc < 2)
862 help();
863 cmd = argv[1];
864 argc--; argv++;
865 if (!strcmp(cmd, "create")) {
866 img_create(argc, argv);
867 } else if (!strcmp(cmd, "commit")) {
868 img_commit(argc, argv);
869 } else if (!strcmp(cmd, "convert")) {
870 img_convert(argc, argv);
871 } else if (!strcmp(cmd, "info")) {
872 img_info(argc, argv);
873 } else if (!strcmp(cmd, "snapshot")) {
874 img_snapshot(argc, argv);
875 } else {
876 help();
877 }
878 return 0;
879 }