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