![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qemu-img.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu|
Return to qemu-img.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu |
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: }