![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmdk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to vmdk.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 1: /*
2: * Block driver for the VMDK format
3: *
4: * Copyright (c) 2004 Fabrice Bellard
5: * Copyright (c) 2005 Filip Navara
6: *
7: * Permission is hereby granted, free of charge, to any person obtaining a copy
8: * of this software and associated documentation files (the "Software"), to deal
9: * in the Software without restriction, including without limitation the rights
10: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11: * copies of the Software, and to permit persons to whom the Software is
12: * furnished to do so, subject to the following conditions:
13: *
14: * The above copyright notice and this permission notice shall be included in
15: * all copies or substantial portions of the Software.
16: *
17: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23: * THE SOFTWARE.
24: */
25:
26: #include "qemu-common.h"
27: #include "block_int.h"
28: #include "module.h"
1.1.1.6 root 29: #include "migration.h"
30: #include <zlib.h>
1.1 root 31:
32: #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
33: #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
1.1.1.6 root 34: #define VMDK4_COMPRESSION_DEFLATE 1
35: #define VMDK4_FLAG_RGD (1 << 1)
36: #define VMDK4_FLAG_COMPRESS (1 << 16)
37: #define VMDK4_FLAG_MARKER (1 << 17)
1.1 root 38:
39: typedef struct {
40: uint32_t version;
41: uint32_t flags;
42: uint32_t disk_sectors;
43: uint32_t granularity;
44: uint32_t l1dir_offset;
45: uint32_t l1dir_size;
46: uint32_t file_sectors;
47: uint32_t cylinders;
48: uint32_t heads;
49: uint32_t sectors_per_track;
50: } VMDK3Header;
51:
52: typedef struct {
53: uint32_t version;
54: uint32_t flags;
55: int64_t capacity;
56: int64_t granularity;
57: int64_t desc_offset;
58: int64_t desc_size;
59: int32_t num_gtes_per_gte;
60: int64_t gd_offset;
1.1.1.6 root 61: int64_t rgd_offset;
1.1 root 62: int64_t grain_offset;
63: char filler[1];
64: char check_bytes[4];
1.1.1.6 root 65: uint16_t compressAlgorithm;
66: } QEMU_PACKED VMDK4Header;
1.1 root 67:
68: #define L2_CACHE_SIZE 16
69:
1.1.1.5 root 70: typedef struct VmdkExtent {
71: BlockDriverState *file;
72: bool flat;
1.1.1.6 root 73: bool compressed;
74: bool has_marker;
1.1.1.5 root 75: int64_t sectors;
76: int64_t end_sector;
77: int64_t flat_start_offset;
1.1 root 78: int64_t l1_table_offset;
79: int64_t l1_backup_table_offset;
80: uint32_t *l1_table;
81: uint32_t *l1_backup_table;
82: unsigned int l1_size;
83: uint32_t l1_entry_sectors;
84:
85: unsigned int l2_size;
86: uint32_t *l2_cache;
87: uint32_t l2_cache_offsets[L2_CACHE_SIZE];
88: uint32_t l2_cache_counts[L2_CACHE_SIZE];
89:
90: unsigned int cluster_sectors;
1.1.1.5 root 91: } VmdkExtent;
92:
93: typedef struct BDRVVmdkState {
1.1.1.6 root 94: CoMutex lock;
1.1.1.5 root 95: int desc_offset;
96: bool cid_updated;
1.1 root 97: uint32_t parent_cid;
1.1.1.5 root 98: int num_extents;
99: /* Extent array with num_extents entries, ascend ordered by address */
100: VmdkExtent *extents;
1.1.1.6 root 101: Error *migration_blocker;
1.1 root 102: } BDRVVmdkState;
103:
104: typedef struct VmdkMetaData {
105: uint32_t offset;
106: unsigned int l1_index;
107: unsigned int l2_index;
108: unsigned int l2_offset;
109: int valid;
110: } VmdkMetaData;
111:
1.1.1.6 root 112: typedef struct VmdkGrainMarker {
113: uint64_t lba;
114: uint32_t size;
115: uint8_t data[0];
116: } VmdkGrainMarker;
117:
1.1 root 118: static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename)
119: {
120: uint32_t magic;
121:
1.1.1.5 root 122: if (buf_size < 4) {
1.1 root 123: return 0;
1.1.1.5 root 124: }
1.1 root 125: magic = be32_to_cpu(*(uint32_t *)buf);
126: if (magic == VMDK3_MAGIC ||
1.1.1.5 root 127: magic == VMDK4_MAGIC) {
1.1 root 128: return 100;
1.1.1.5 root 129: } else {
130: const char *p = (const char *)buf;
131: const char *end = p + buf_size;
132: while (p < end) {
133: if (*p == '#') {
134: /* skip comment line */
135: while (p < end && *p != '\n') {
136: p++;
137: }
138: p++;
139: continue;
140: }
141: if (*p == ' ') {
142: while (p < end && *p == ' ') {
143: p++;
144: }
145: /* skip '\r' if windows line endings used. */
146: if (p < end && *p == '\r') {
147: p++;
148: }
149: /* only accept blank lines before 'version=' line */
150: if (p == end || *p != '\n') {
151: return 0;
152: }
153: p++;
154: continue;
155: }
156: if (end - p >= strlen("version=X\n")) {
157: if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 ||
158: strncmp("version=2\n", p, strlen("version=2\n")) == 0) {
159: return 100;
160: }
161: }
162: if (end - p >= strlen("version=X\r\n")) {
163: if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 ||
164: strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) {
165: return 100;
166: }
167: }
168: return 0;
169: }
1.1 root 170: return 0;
1.1.1.5 root 171: }
1.1 root 172: }
173:
174: #define CHECK_CID 1
175:
176: #define SECTOR_SIZE 512
1.1.1.5 root 177: #define DESC_SIZE (20 * SECTOR_SIZE) /* 20 sectors of 512 bytes each */
178: #define BUF_SIZE 4096
179: #define HEADER_SIZE 512 /* first sector of 512 bytes */
180:
181: static void vmdk_free_extents(BlockDriverState *bs)
182: {
183: int i;
184: BDRVVmdkState *s = bs->opaque;
1.1.1.6 root 185: VmdkExtent *e;
1.1.1.5 root 186:
187: for (i = 0; i < s->num_extents; i++) {
1.1.1.6 root 188: e = &s->extents[i];
189: g_free(e->l1_table);
190: g_free(e->l2_cache);
191: g_free(e->l1_backup_table);
192: if (e->file != bs->file) {
193: bdrv_delete(e->file);
194: }
1.1.1.5 root 195: }
1.1.1.6 root 196: g_free(s->extents);
197: }
198:
199: static void vmdk_free_last_extent(BlockDriverState *bs)
200: {
201: BDRVVmdkState *s = bs->opaque;
202:
203: if (s->num_extents == 0) {
204: return;
205: }
206: s->num_extents--;
207: s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent));
1.1.1.5 root 208: }
1.1 root 209:
210: static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent)
211: {
212: char desc[DESC_SIZE];
1.1.1.6 root 213: uint32_t cid = 0xffffffff;
1.1 root 214: const char *p_name, *cid_str;
215: size_t cid_str_size;
1.1.1.5 root 216: BDRVVmdkState *s = bs->opaque;
1.1.1.6 root 217: int ret;
1.1 root 218:
1.1.1.6 root 219: ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
220: if (ret < 0) {
1.1 root 221: return 0;
1.1.1.5 root 222: }
1.1 root 223:
224: if (parent) {
225: cid_str = "parentCID";
226: cid_str_size = sizeof("parentCID");
227: } else {
228: cid_str = "CID";
229: cid_str_size = sizeof("CID");
230: }
231:
1.1.1.6 root 232: desc[DESC_SIZE - 1] = '\0';
1.1.1.5 root 233: p_name = strstr(desc, cid_str);
234: if (p_name != NULL) {
1.1 root 235: p_name += cid_str_size;
1.1.1.5 root 236: sscanf(p_name, "%x", &cid);
1.1 root 237: }
238:
239: return cid;
240: }
241:
242: static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
243: {
244: char desc[DESC_SIZE], tmp_desc[DESC_SIZE];
245: char *p_name, *tmp_str;
1.1.1.5 root 246: BDRVVmdkState *s = bs->opaque;
1.1.1.6 root 247: int ret;
1.1 root 248:
1.1.1.6 root 249: ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
250: if (ret < 0) {
251: return ret;
1.1.1.5 root 252: }
1.1 root 253:
1.1.1.6 root 254: desc[DESC_SIZE - 1] = '\0';
1.1.1.5 root 255: tmp_str = strstr(desc, "parentCID");
1.1.1.6 root 256: if (tmp_str == NULL) {
257: return -EINVAL;
258: }
259:
1.1 root 260: pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);
1.1.1.5 root 261: p_name = strstr(desc, "CID");
262: if (p_name != NULL) {
1.1 root 263: p_name += sizeof("CID");
264: snprintf(p_name, sizeof(desc) - (p_name - desc), "%x\n", cid);
265: pstrcat(desc, sizeof(desc), tmp_desc);
266: }
267:
1.1.1.6 root 268: ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
269: if (ret < 0) {
270: return ret;
1.1.1.5 root 271: }
1.1.1.6 root 272:
1.1 root 273: return 0;
274: }
275:
276: static int vmdk_is_cid_valid(BlockDriverState *bs)
277: {
278: #ifdef CHECK_CID
279: BDRVVmdkState *s = bs->opaque;
280: BlockDriverState *p_bs = bs->backing_hd;
281: uint32_t cur_pcid;
282:
283: if (p_bs) {
1.1.1.5 root 284: cur_pcid = vmdk_read_cid(p_bs, 0);
285: if (s->parent_cid != cur_pcid) {
286: /* CID not valid */
1.1 root 287: return 0;
1.1.1.5 root 288: }
1.1 root 289: }
290: #endif
1.1.1.5 root 291: /* CID valid */
1.1 root 292: return 1;
293: }
294:
1.1.1.5 root 295: static int vmdk_parent_open(BlockDriverState *bs)
1.1 root 296: {
1.1.1.5 root 297: char *p_name;
298: char desc[DESC_SIZE + 1];
299: BDRVVmdkState *s = bs->opaque;
1.1.1.6 root 300: int ret;
1.1 root 301:
1.1.1.5 root 302: desc[DESC_SIZE] = '\0';
1.1.1.6 root 303: ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
304: if (ret < 0) {
305: return ret;
1.1 root 306: }
307:
1.1.1.5 root 308: p_name = strstr(desc, "parentFileNameHint");
309: if (p_name != NULL) {
310: char *end_name;
1.1 root 311:
1.1.1.5 root 312: p_name += sizeof("parentFileNameHint") + 1;
313: end_name = strchr(p_name, '\"');
314: if (end_name == NULL) {
1.1.1.6 root 315: return -EINVAL;
1.1.1.5 root 316: }
317: if ((end_name - p_name) > sizeof(bs->backing_file) - 1) {
1.1.1.6 root 318: return -EINVAL;
1.1.1.5 root 319: }
320:
321: pstrcpy(bs->backing_file, end_name - p_name + 1, p_name);
1.1.1.3 root 322: }
1.1 root 323:
1.1.1.5 root 324: return 0;
325: }
1.1 root 326:
1.1.1.5 root 327: /* Create and append extent to the extent array. Return the added VmdkExtent
328: * address. return NULL if allocation failed. */
329: static VmdkExtent *vmdk_add_extent(BlockDriverState *bs,
330: BlockDriverState *file, bool flat, int64_t sectors,
331: int64_t l1_offset, int64_t l1_backup_offset,
332: uint32_t l1_size,
333: int l2_size, unsigned int cluster_sectors)
334: {
335: VmdkExtent *extent;
336: BDRVVmdkState *s = bs->opaque;
337:
1.1.1.6 root 338: s->extents = g_realloc(s->extents,
1.1.1.5 root 339: (s->num_extents + 1) * sizeof(VmdkExtent));
340: extent = &s->extents[s->num_extents];
341: s->num_extents++;
342:
343: memset(extent, 0, sizeof(VmdkExtent));
344: extent->file = file;
345: extent->flat = flat;
346: extent->sectors = sectors;
347: extent->l1_table_offset = l1_offset;
348: extent->l1_backup_table_offset = l1_backup_offset;
349: extent->l1_size = l1_size;
350: extent->l1_entry_sectors = l2_size * cluster_sectors;
351: extent->l2_size = l2_size;
352: extent->cluster_sectors = cluster_sectors;
353:
354: if (s->num_extents > 1) {
355: extent->end_sector = (*(extent - 1)).end_sector + extent->sectors;
356: } else {
357: extent->end_sector = extent->sectors;
1.1.1.3 root 358: }
1.1.1.5 root 359: bs->total_sectors = extent->end_sector;
360: return extent;
361: }
362:
363: static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
364: {
365: int ret;
366: int l1_size, i;
367:
368: /* read the L1 table */
369: l1_size = extent->l1_size * sizeof(uint32_t);
1.1.1.6 root 370: extent->l1_table = g_malloc(l1_size);
1.1.1.5 root 371: ret = bdrv_pread(extent->file,
372: extent->l1_table_offset,
373: extent->l1_table,
374: l1_size);
375: if (ret < 0) {
376: goto fail_l1;
1.1.1.3 root 377: }
1.1.1.5 root 378: for (i = 0; i < extent->l1_size; i++) {
379: le32_to_cpus(&extent->l1_table[i]);
1.1.1.3 root 380: }
1.1 root 381:
1.1.1.5 root 382: if (extent->l1_backup_table_offset) {
1.1.1.6 root 383: extent->l1_backup_table = g_malloc(l1_size);
1.1.1.5 root 384: ret = bdrv_pread(extent->file,
385: extent->l1_backup_table_offset,
386: extent->l1_backup_table,
387: l1_size);
388: if (ret < 0) {
389: goto fail_l1b;
390: }
391: for (i = 0; i < extent->l1_size; i++) {
392: le32_to_cpus(&extent->l1_backup_table[i]);
393: }
1.1 root 394: }
395:
1.1.1.5 root 396: extent->l2_cache =
1.1.1.6 root 397: g_malloc(extent->l2_size * L2_CACHE_SIZE * sizeof(uint32_t));
1.1.1.5 root 398: return 0;
399: fail_l1b:
1.1.1.6 root 400: g_free(extent->l1_backup_table);
1.1.1.5 root 401: fail_l1:
1.1.1.6 root 402: g_free(extent->l1_table);
1.1.1.5 root 403: return ret;
404: }
1.1 root 405:
1.1.1.6 root 406: static int vmdk_open_vmdk3(BlockDriverState *bs,
407: BlockDriverState *file,
408: int flags)
1.1.1.5 root 409: {
410: int ret;
411: uint32_t magic;
412: VMDK3Header header;
413: VmdkExtent *extent;
1.1 root 414:
1.1.1.6 root 415: ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
1.1.1.5 root 416: if (ret < 0) {
1.1.1.6 root 417: return ret;
1.1.1.3 root 418: }
1.1.1.5 root 419: extent = vmdk_add_extent(bs,
420: bs->file, false,
421: le32_to_cpu(header.disk_sectors),
422: le32_to_cpu(header.l1dir_offset) << 9,
423: 0, 1 << 6, 1 << 9,
424: le32_to_cpu(header.granularity));
425: ret = vmdk_init_tables(bs, extent);
426: if (ret) {
1.1.1.6 root 427: /* free extent allocated by vmdk_add_extent */
428: vmdk_free_last_extent(bs);
1.1.1.3 root 429: }
1.1.1.5 root 430: return ret;
431: }
1.1 root 432:
1.1.1.6 root 433: static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
434: int64_t desc_offset);
435:
436: static int vmdk_open_vmdk4(BlockDriverState *bs,
437: BlockDriverState *file,
438: int flags)
1.1.1.5 root 439: {
440: int ret;
441: uint32_t magic;
442: uint32_t l1_size, l1_entry_sectors;
443: VMDK4Header header;
444: VmdkExtent *extent;
1.1.1.6 root 445: int64_t l1_backup_offset = 0;
1.1 root 446:
1.1.1.6 root 447: ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
1.1.1.5 root 448: if (ret < 0) {
1.1.1.6 root 449: return ret;
450: }
451: if (header.capacity == 0 && header.desc_offset) {
452: return vmdk_open_desc_file(bs, flags, header.desc_offset << 9);
1.1.1.3 root 453: }
1.1.1.5 root 454: l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gte)
455: * le64_to_cpu(header.granularity);
1.1.1.7 ! root 456: if (l1_entry_sectors == 0) {
1.1.1.6 root 457: return -EINVAL;
458: }
1.1.1.5 root 459: l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
460: / l1_entry_sectors;
1.1.1.6 root 461: if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
462: l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
463: }
464: extent = vmdk_add_extent(bs, file, false,
1.1.1.5 root 465: le64_to_cpu(header.capacity),
466: le64_to_cpu(header.gd_offset) << 9,
1.1.1.6 root 467: l1_backup_offset,
1.1.1.5 root 468: l1_size,
469: le32_to_cpu(header.num_gtes_per_gte),
470: le64_to_cpu(header.granularity));
1.1.1.6 root 471: extent->compressed =
472: le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
473: extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
1.1.1.5 root 474: ret = vmdk_init_tables(bs, extent);
475: if (ret) {
1.1.1.6 root 476: /* free extent allocated by vmdk_add_extent */
477: vmdk_free_last_extent(bs);
1.1.1.3 root 478: }
1.1.1.5 root 479: return ret;
480: }
1.1 root 481:
1.1.1.5 root 482: /* find an option value out of descriptor file */
483: static int vmdk_parse_description(const char *desc, const char *opt_name,
484: char *buf, int buf_size)
485: {
486: char *opt_pos, *opt_end;
487: const char *end = desc + strlen(desc);
488:
489: opt_pos = strstr(desc, opt_name);
490: if (!opt_pos) {
491: return -1;
1.1.1.3 root 492: }
1.1.1.5 root 493: /* Skip "=\"" following opt_name */
494: opt_pos += strlen(opt_name) + 2;
495: if (opt_pos >= end) {
496: return -1;
1.1.1.3 root 497: }
1.1.1.5 root 498: opt_end = opt_pos;
499: while (opt_end < end && *opt_end != '"') {
500: opt_end++;
1.1.1.3 root 501: }
1.1.1.5 root 502: if (opt_end == end || buf_size < opt_end - opt_pos + 1) {
503: return -1;
1.1.1.3 root 504: }
1.1.1.5 root 505: pstrcpy(buf, opt_end - opt_pos + 1, opt_pos);
506: return 0;
1.1 root 507: }
508:
1.1.1.6 root 509: /* Open an extent file and append to bs array */
510: static int vmdk_open_sparse(BlockDriverState *bs,
511: BlockDriverState *file,
512: int flags)
513: {
514: uint32_t magic;
515:
516: if (bdrv_pread(file, 0, &magic, sizeof(magic)) != sizeof(magic)) {
517: return -EIO;
518: }
519:
520: magic = be32_to_cpu(magic);
521: switch (magic) {
522: case VMDK3_MAGIC:
523: return vmdk_open_vmdk3(bs, file, flags);
524: break;
525: case VMDK4_MAGIC:
526: return vmdk_open_vmdk4(bs, file, flags);
527: break;
528: default:
529: return -EINVAL;
530: break;
531: }
532: }
533:
1.1.1.5 root 534: static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
535: const char *desc_file_path)
1.1 root 536: {
1.1.1.5 root 537: int ret;
538: char access[11];
539: char type[11];
540: char fname[512];
541: const char *p = desc;
542: int64_t sectors = 0;
543: int64_t flat_offset;
1.1.1.6 root 544: char extent_path[PATH_MAX];
545: BlockDriverState *extent_file;
1.1.1.5 root 546:
547: while (*p) {
548: /* parse extent line:
549: * RW [size in sectors] FLAT "file-name.vmdk" OFFSET
550: * or
551: * RW [size in sectors] SPARSE "file-name.vmdk"
552: */
553: flat_offset = -1;
554: ret = sscanf(p, "%10s %" SCNd64 " %10s %511s %" SCNd64,
555: access, §ors, type, fname, &flat_offset);
556: if (ret < 4 || strcmp(access, "RW")) {
557: goto next_line;
558: } else if (!strcmp(type, "FLAT")) {
559: if (ret != 5 || flat_offset < 0) {
560: return -EINVAL;
561: }
562: } else if (ret != 4) {
563: return -EINVAL;
564: }
1.1 root 565:
1.1.1.5 root 566: /* trim the quotation marks around */
567: if (fname[0] == '"') {
568: memmove(fname, fname + 1, strlen(fname));
569: if (strlen(fname) <= 1 || fname[strlen(fname) - 1] != '"') {
570: return -EINVAL;
571: }
572: fname[strlen(fname) - 1] = '\0';
573: }
574: if (sectors <= 0 ||
575: (strcmp(type, "FLAT") && strcmp(type, "SPARSE")) ||
576: (strcmp(access, "RW"))) {
577: goto next_line;
578: }
1.1 root 579:
1.1.1.6 root 580: path_combine(extent_path, sizeof(extent_path),
581: desc_file_path, fname);
582: ret = bdrv_file_open(&extent_file, extent_path, bs->open_flags);
583: if (ret) {
584: return ret;
585: }
586:
1.1.1.5 root 587: /* save to extents array */
588: if (!strcmp(type, "FLAT")) {
589: /* FLAT extent */
590: VmdkExtent *extent;
591:
1.1.1.6 root 592: extent = vmdk_add_extent(bs, extent_file, true, sectors,
593: 0, 0, 0, 0, sectors);
594: extent->flat_start_offset = flat_offset << 9;
595: } else if (!strcmp(type, "SPARSE")) {
596: /* SPARSE extent */
597: ret = vmdk_open_sparse(bs, extent_file, bs->open_flags);
1.1.1.5 root 598: if (ret) {
1.1.1.6 root 599: bdrv_delete(extent_file);
1.1.1.5 root 600: return ret;
601: }
602: } else {
603: fprintf(stderr,
604: "VMDK: Not supported extent type \"%s\""".\n", type);
605: return -ENOTSUP;
606: }
607: next_line:
608: /* move to next line */
609: while (*p && *p != '\n') {
610: p++;
611: }
612: p++;
613: }
614: return 0;
615: }
1.1 root 616:
1.1.1.6 root 617: static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
618: int64_t desc_offset)
1.1.1.5 root 619: {
620: int ret;
621: char buf[2048];
622: char ct[128];
623: BDRVVmdkState *s = bs->opaque;
1.1 root 624:
1.1.1.6 root 625: ret = bdrv_pread(bs->file, desc_offset, buf, sizeof(buf));
1.1.1.5 root 626: if (ret < 0) {
627: return ret;
628: }
629: buf[2047] = '\0';
630: if (vmdk_parse_description(buf, "createType", ct, sizeof(ct))) {
631: return -EINVAL;
632: }
1.1.1.6 root 633: if (strcmp(ct, "monolithicFlat") &&
634: strcmp(ct, "twoGbMaxExtentSparse") &&
635: strcmp(ct, "twoGbMaxExtentFlat")) {
1.1.1.5 root 636: fprintf(stderr,
637: "VMDK: Not supported image type \"%s\""".\n", ct);
638: return -ENOTSUP;
639: }
640: s->desc_offset = 0;
1.1.1.6 root 641: return vmdk_parse_extents(buf, bs, bs->file->filename);
1.1 root 642: }
643:
1.1.1.3 root 644: static int vmdk_open(BlockDriverState *bs, int flags)
1.1 root 645: {
1.1.1.6 root 646: int ret;
647: BDRVVmdkState *s = bs->opaque;
1.1 root 648:
1.1.1.6 root 649: if (vmdk_open_sparse(bs, bs->file, flags) == 0) {
650: s->desc_offset = 0x200;
1.1 root 651: } else {
1.1.1.6 root 652: ret = vmdk_open_desc_file(bs, flags, 0);
653: if (ret) {
654: goto fail;
655: }
1.1 root 656: }
1.1.1.6 root 657: /* try to open parent images, if exist */
658: ret = vmdk_parent_open(bs);
659: if (ret) {
660: goto fail;
661: }
662: s->parent_cid = vmdk_read_cid(bs, 1);
663: qemu_co_mutex_init(&s->lock);
664:
665: /* Disable migration when VMDK images are used */
666: error_set(&s->migration_blocker,
667: QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
668: "vmdk", bs->device_name, "live migration");
669: migrate_add_blocker(s->migration_blocker);
670:
671: return 0;
672:
673: fail:
674: vmdk_free_extents(bs);
675: return ret;
1.1 root 676: }
677:
1.1.1.5 root 678: static int get_whole_cluster(BlockDriverState *bs,
679: VmdkExtent *extent,
680: uint64_t cluster_offset,
681: uint64_t offset,
682: bool allocate)
1.1 root 683: {
1.1.1.5 root 684: /* 128 sectors * 512 bytes each = grain size 64KB */
685: uint8_t whole_grain[extent->cluster_sectors * 512];
1.1 root 686:
1.1.1.5 root 687: /* we will be here if it's first write on non-exist grain(cluster).
688: * try to read from parent image, if exist */
1.1 root 689: if (bs->backing_hd) {
1.1.1.2 root 690: int ret;
1.1 root 691:
1.1.1.5 root 692: if (!vmdk_is_cid_valid(bs)) {
1.1 root 693: return -1;
1.1.1.5 root 694: }
1.1 root 695:
1.1.1.5 root 696: /* floor offset to cluster */
697: offset -= offset % (extent->cluster_sectors * 512);
1.1.1.2 root 698: ret = bdrv_read(bs->backing_hd, offset >> 9, whole_grain,
1.1.1.5 root 699: extent->cluster_sectors);
1.1.1.2 root 700: if (ret < 0) {
701: return -1;
702: }
1.1 root 703:
1.1.1.5 root 704: /* Write grain only into the active image */
705: ret = bdrv_write(extent->file, cluster_offset, whole_grain,
706: extent->cluster_sectors);
1.1.1.2 root 707: if (ret < 0) {
708: return -1;
1.1 root 709: }
710: }
711: return 0;
712: }
713:
1.1.1.5 root 714: static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data)
1.1 root 715: {
716: /* update L2 table */
1.1.1.5 root 717: if (bdrv_pwrite_sync(
718: extent->file,
719: ((int64_t)m_data->l2_offset * 512)
720: + (m_data->l2_index * sizeof(m_data->offset)),
721: &(m_data->offset),
722: sizeof(m_data->offset)
723: ) < 0) {
1.1 root 724: return -1;
1.1.1.5 root 725: }
1.1 root 726: /* update backup L2 table */
1.1.1.5 root 727: if (extent->l1_backup_table_offset != 0) {
728: m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
729: if (bdrv_pwrite_sync(
730: extent->file,
731: ((int64_t)m_data->l2_offset * 512)
732: + (m_data->l2_index * sizeof(m_data->offset)),
733: &(m_data->offset), sizeof(m_data->offset)
734: ) < 0) {
1.1 root 735: return -1;
1.1.1.5 root 736: }
1.1 root 737: }
738:
739: return 0;
740: }
741:
1.1.1.5 root 742: static int get_cluster_offset(BlockDriverState *bs,
743: VmdkExtent *extent,
744: VmdkMetaData *m_data,
745: uint64_t offset,
746: int allocate,
747: uint64_t *cluster_offset)
1.1 root 748: {
749: unsigned int l1_index, l2_offset, l2_index;
750: int min_index, i, j;
751: uint32_t min_count, *l2_table, tmp = 0;
752:
1.1.1.5 root 753: if (m_data) {
1.1 root 754: m_data->valid = 0;
1.1.1.5 root 755: }
756: if (extent->flat) {
757: *cluster_offset = extent->flat_start_offset;
1.1 root 758: return 0;
1.1.1.5 root 759: }
760:
1.1.1.6 root 761: offset -= (extent->end_sector - extent->sectors) * SECTOR_SIZE;
1.1.1.5 root 762: l1_index = (offset >> 9) / extent->l1_entry_sectors;
763: if (l1_index >= extent->l1_size) {
764: return -1;
765: }
766: l2_offset = extent->l1_table[l1_index];
767: if (!l2_offset) {
768: return -1;
769: }
770: for (i = 0; i < L2_CACHE_SIZE; i++) {
771: if (l2_offset == extent->l2_cache_offsets[i]) {
1.1 root 772: /* increment the hit count */
1.1.1.5 root 773: if (++extent->l2_cache_counts[i] == 0xffffffff) {
774: for (j = 0; j < L2_CACHE_SIZE; j++) {
775: extent->l2_cache_counts[j] >>= 1;
1.1 root 776: }
777: }
1.1.1.5 root 778: l2_table = extent->l2_cache + (i * extent->l2_size);
1.1 root 779: goto found;
780: }
781: }
782: /* not found: load a new entry in the least used one */
783: min_index = 0;
784: min_count = 0xffffffff;
1.1.1.5 root 785: for (i = 0; i < L2_CACHE_SIZE; i++) {
786: if (extent->l2_cache_counts[i] < min_count) {
787: min_count = extent->l2_cache_counts[i];
1.1 root 788: min_index = i;
789: }
790: }
1.1.1.5 root 791: l2_table = extent->l2_cache + (min_index * extent->l2_size);
792: if (bdrv_pread(
793: extent->file,
794: (int64_t)l2_offset * 512,
795: l2_table,
796: extent->l2_size * sizeof(uint32_t)
797: ) != extent->l2_size * sizeof(uint32_t)) {
798: return -1;
799: }
1.1 root 800:
1.1.1.5 root 801: extent->l2_cache_offsets[min_index] = l2_offset;
802: extent->l2_cache_counts[min_index] = 1;
1.1 root 803: found:
1.1.1.5 root 804: l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
805: *cluster_offset = le32_to_cpu(l2_table[l2_index]);
1.1 root 806:
1.1.1.5 root 807: if (!*cluster_offset) {
808: if (!allocate) {
809: return -1;
810: }
1.1.1.3 root 811:
1.1.1.5 root 812: /* Avoid the L2 tables update for the images that have snapshots. */
813: *cluster_offset = bdrv_getlength(extent->file);
1.1.1.6 root 814: if (!extent->compressed) {
815: bdrv_truncate(
816: extent->file,
817: *cluster_offset + (extent->cluster_sectors << 9)
818: );
819: }
1.1.1.3 root 820:
1.1.1.5 root 821: *cluster_offset >>= 9;
822: tmp = cpu_to_le32(*cluster_offset);
1.1.1.3 root 823: l2_table[l2_index] = tmp;
824:
1.1 root 825: /* First of all we write grain itself, to avoid race condition
826: * that may to corrupt the image.
827: * This problem may occur because of insufficient space on host disk
828: * or inappropriate VM shutdown.
829: */
1.1.1.5 root 830: if (get_whole_cluster(
831: bs, extent, *cluster_offset, offset, allocate) == -1) {
832: return -1;
833: }
1.1 root 834:
835: if (m_data) {
836: m_data->offset = tmp;
837: m_data->l1_index = l1_index;
838: m_data->l2_index = l2_index;
839: m_data->l2_offset = l2_offset;
840: m_data->valid = 1;
841: }
842: }
1.1.1.5 root 843: *cluster_offset <<= 9;
844: return 0;
845: }
846:
847: static VmdkExtent *find_extent(BDRVVmdkState *s,
848: int64_t sector_num, VmdkExtent *start_hint)
849: {
850: VmdkExtent *extent = start_hint;
851:
852: if (!extent) {
853: extent = &s->extents[0];
854: }
855: while (extent < &s->extents[s->num_extents]) {
856: if (sector_num < extent->end_sector) {
857: return extent;
858: }
859: extent++;
860: }
861: return NULL;
1.1 root 862: }
863:
1.1.1.7 ! root 864: static int coroutine_fn vmdk_co_is_allocated(BlockDriverState *bs,
! 865: int64_t sector_num, int nb_sectors, int *pnum)
1.1 root 866: {
867: BDRVVmdkState *s = bs->opaque;
1.1.1.5 root 868: int64_t index_in_cluster, n, ret;
869: uint64_t offset;
870: VmdkExtent *extent;
1.1 root 871:
1.1.1.5 root 872: extent = find_extent(s, sector_num, NULL);
873: if (!extent) {
874: return 0;
875: }
1.1.1.7 ! root 876: qemu_co_mutex_lock(&s->lock);
1.1.1.5 root 877: ret = get_cluster_offset(bs, extent, NULL,
878: sector_num * 512, 0, &offset);
1.1.1.7 ! root 879: qemu_co_mutex_unlock(&s->lock);
1.1.1.5 root 880: /* get_cluster_offset returning 0 means success */
881: ret = !ret;
882:
883: index_in_cluster = sector_num % extent->cluster_sectors;
884: n = extent->cluster_sectors - index_in_cluster;
885: if (n > nb_sectors) {
1.1 root 886: n = nb_sectors;
1.1.1.5 root 887: }
1.1 root 888: *pnum = n;
1.1.1.5 root 889: return ret;
1.1 root 890: }
891:
1.1.1.6 root 892: static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
893: int64_t offset_in_cluster, const uint8_t *buf,
894: int nb_sectors, int64_t sector_num)
895: {
896: int ret;
897: VmdkGrainMarker *data = NULL;
898: uLongf buf_len;
899: const uint8_t *write_buf = buf;
900: int write_len = nb_sectors * 512;
901:
902: if (extent->compressed) {
903: if (!extent->has_marker) {
904: ret = -EINVAL;
905: goto out;
906: }
907: buf_len = (extent->cluster_sectors << 9) * 2;
908: data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
909: if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
910: buf_len == 0) {
911: ret = -EINVAL;
912: goto out;
913: }
914: data->lba = sector_num;
915: data->size = buf_len;
916: write_buf = (uint8_t *)data;
917: write_len = buf_len + sizeof(VmdkGrainMarker);
918: }
919: ret = bdrv_pwrite(extent->file,
920: cluster_offset + offset_in_cluster,
921: write_buf,
922: write_len);
923: if (ret != write_len) {
924: ret = ret < 0 ? ret : -EIO;
925: goto out;
926: }
927: ret = 0;
928: out:
929: g_free(data);
930: return ret;
931: }
932:
933: static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
934: int64_t offset_in_cluster, uint8_t *buf,
935: int nb_sectors)
936: {
937: int ret;
938: int cluster_bytes, buf_bytes;
939: uint8_t *cluster_buf, *compressed_data;
940: uint8_t *uncomp_buf;
941: uint32_t data_len;
942: VmdkGrainMarker *marker;
943: uLongf buf_len;
944:
945:
946: if (!extent->compressed) {
947: ret = bdrv_pread(extent->file,
948: cluster_offset + offset_in_cluster,
949: buf, nb_sectors * 512);
950: if (ret == nb_sectors * 512) {
951: return 0;
952: } else {
953: return -EIO;
954: }
955: }
956: cluster_bytes = extent->cluster_sectors * 512;
957: /* Read two clusters in case GrainMarker + compressed data > one cluster */
958: buf_bytes = cluster_bytes * 2;
959: cluster_buf = g_malloc(buf_bytes);
960: uncomp_buf = g_malloc(cluster_bytes);
961: ret = bdrv_pread(extent->file,
962: cluster_offset,
963: cluster_buf, buf_bytes);
964: if (ret < 0) {
965: goto out;
966: }
967: compressed_data = cluster_buf;
968: buf_len = cluster_bytes;
969: data_len = cluster_bytes;
970: if (extent->has_marker) {
971: marker = (VmdkGrainMarker *)cluster_buf;
972: compressed_data = marker->data;
973: data_len = le32_to_cpu(marker->size);
974: }
975: if (!data_len || data_len > buf_bytes) {
976: ret = -EINVAL;
977: goto out;
978: }
979: ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
980: if (ret != Z_OK) {
981: ret = -EINVAL;
982: goto out;
983:
984: }
985: if (offset_in_cluster < 0 ||
986: offset_in_cluster + nb_sectors * 512 > buf_len) {
987: ret = -EINVAL;
988: goto out;
989: }
990: memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
991: ret = 0;
992:
993: out:
994: g_free(uncomp_buf);
995: g_free(cluster_buf);
996: return ret;
997: }
998:
1.1 root 999: static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
1000: uint8_t *buf, int nb_sectors)
1001: {
1002: BDRVVmdkState *s = bs->opaque;
1.1.1.5 root 1003: int ret;
1004: uint64_t n, index_in_cluster;
1005: VmdkExtent *extent = NULL;
1.1 root 1006: uint64_t cluster_offset;
1007:
1008: while (nb_sectors > 0) {
1.1.1.5 root 1009: extent = find_extent(s, sector_num, extent);
1010: if (!extent) {
1011: return -EIO;
1012: }
1013: ret = get_cluster_offset(
1014: bs, extent, NULL,
1015: sector_num << 9, 0, &cluster_offset);
1016: index_in_cluster = sector_num % extent->cluster_sectors;
1017: n = extent->cluster_sectors - index_in_cluster;
1018: if (n > nb_sectors) {
1.1 root 1019: n = nb_sectors;
1.1.1.5 root 1020: }
1021: if (ret) {
1022: /* if not allocated, try to read from parent image, if exist */
1.1 root 1023: if (bs->backing_hd) {
1.1.1.5 root 1024: if (!vmdk_is_cid_valid(bs)) {
1025: return -EINVAL;
1026: }
1.1 root 1027: ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
1.1.1.5 root 1028: if (ret < 0) {
1029: return ret;
1030: }
1.1 root 1031: } else {
1032: memset(buf, 0, 512 * n);
1033: }
1034: } else {
1.1.1.6 root 1035: ret = vmdk_read_extent(extent,
1036: cluster_offset, index_in_cluster * 512,
1037: buf, n);
1038: if (ret) {
1.1.1.5 root 1039: return ret;
1040: }
1.1 root 1041: }
1042: nb_sectors -= n;
1043: sector_num += n;
1044: buf += n * 512;
1045: }
1046: return 0;
1047: }
1048:
1.1.1.6 root 1049: static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
1050: uint8_t *buf, int nb_sectors)
1051: {
1052: int ret;
1053: BDRVVmdkState *s = bs->opaque;
1054: qemu_co_mutex_lock(&s->lock);
1055: ret = vmdk_read(bs, sector_num, buf, nb_sectors);
1056: qemu_co_mutex_unlock(&s->lock);
1057: return ret;
1058: }
1059:
1.1 root 1060: static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
1061: const uint8_t *buf, int nb_sectors)
1062: {
1063: BDRVVmdkState *s = bs->opaque;
1.1.1.5 root 1064: VmdkExtent *extent = NULL;
1065: int n, ret;
1066: int64_t index_in_cluster;
1.1 root 1067: uint64_t cluster_offset;
1.1.1.5 root 1068: VmdkMetaData m_data;
1.1 root 1069:
1070: if (sector_num > bs->total_sectors) {
1071: fprintf(stderr,
1072: "(VMDK) Wrong offset: sector_num=0x%" PRIx64
1073: " total_sectors=0x%" PRIx64 "\n",
1074: sector_num, bs->total_sectors);
1.1.1.5 root 1075: return -EIO;
1.1 root 1076: }
1077:
1078: while (nb_sectors > 0) {
1.1.1.5 root 1079: extent = find_extent(s, sector_num, extent);
1080: if (!extent) {
1081: return -EIO;
1082: }
1083: ret = get_cluster_offset(
1084: bs,
1085: extent,
1086: &m_data,
1.1.1.6 root 1087: sector_num << 9, !extent->compressed,
1.1.1.5 root 1088: &cluster_offset);
1.1.1.6 root 1089: if (extent->compressed) {
1090: if (ret == 0) {
1091: /* Refuse write to allocated cluster for streamOptimized */
1092: fprintf(stderr,
1093: "VMDK: can't write to allocated cluster"
1094: " for streamOptimized\n");
1095: return -EIO;
1096: } else {
1097: /* allocate */
1098: ret = get_cluster_offset(
1099: bs,
1100: extent,
1101: &m_data,
1102: sector_num << 9, 1,
1103: &cluster_offset);
1104: }
1105: }
1.1.1.5 root 1106: if (ret) {
1107: return -EINVAL;
1108: }
1109: index_in_cluster = sector_num % extent->cluster_sectors;
1110: n = extent->cluster_sectors - index_in_cluster;
1111: if (n > nb_sectors) {
1.1 root 1112: n = nb_sectors;
1.1.1.5 root 1113: }
1.1 root 1114:
1.1.1.6 root 1115: ret = vmdk_write_extent(extent,
1116: cluster_offset, index_in_cluster * 512,
1117: buf, n, sector_num);
1118: if (ret) {
1.1.1.5 root 1119: return ret;
1120: }
1.1 root 1121: if (m_data.valid) {
1122: /* update L2 tables */
1.1.1.5 root 1123: if (vmdk_L2update(extent, &m_data) == -1) {
1124: return -EIO;
1125: }
1.1 root 1126: }
1127: nb_sectors -= n;
1128: sector_num += n;
1129: buf += n * 512;
1130:
1.1.1.5 root 1131: /* update CID on the first write every time the virtual disk is
1132: * opened */
1133: if (!s->cid_updated) {
1.1.1.6 root 1134: ret = vmdk_write_cid(bs, time(NULL));
1135: if (ret < 0) {
1136: return ret;
1137: }
1.1.1.5 root 1138: s->cid_updated = true;
1.1 root 1139: }
1140: }
1141: return 0;
1142: }
1143:
1.1.1.6 root 1144: static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
1145: const uint8_t *buf, int nb_sectors)
1146: {
1147: int ret;
1148: BDRVVmdkState *s = bs->opaque;
1149: qemu_co_mutex_lock(&s->lock);
1150: ret = vmdk_write(bs, sector_num, buf, nb_sectors);
1151: qemu_co_mutex_unlock(&s->lock);
1152: return ret;
1153: }
1154:
1.1.1.5 root 1155:
1.1.1.6 root 1156: static int vmdk_create_extent(const char *filename, int64_t filesize,
1157: bool flat, bool compress)
1.1 root 1158: {
1.1.1.5 root 1159: int ret, i;
1160: int fd = 0;
1.1 root 1161: VMDK4Header header;
1162: uint32_t tmp, magic, grains, gd_size, gt_size, gt_count;
1163:
1.1.1.5 root 1164: fd = open(
1165: filename,
1166: O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1167: 0644);
1168: if (fd < 0) {
1169: return -errno;
1.1 root 1170: }
1.1.1.5 root 1171: if (flat) {
1172: ret = ftruncate(fd, filesize);
1173: if (ret < 0) {
1174: ret = -errno;
1175: }
1176: goto exit;
1.1 root 1177: }
1178: magic = cpu_to_be32(VMDK4_MAGIC);
1179: memset(&header, 0, sizeof(header));
1.1.1.5 root 1180: header.version = 1;
1.1.1.6 root 1181: header.flags =
1182: 3 | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0);
1183: header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
1.1.1.5 root 1184: header.capacity = filesize / 512;
1185: header.granularity = 128;
1186: header.num_gtes_per_gte = 512;
1.1 root 1187:
1.1.1.5 root 1188: grains = (filesize / 512 + header.granularity - 1) / header.granularity;
1.1 root 1189: gt_size = ((header.num_gtes_per_gte * sizeof(uint32_t)) + 511) >> 9;
1.1.1.5 root 1190: gt_count =
1191: (grains + header.num_gtes_per_gte - 1) / header.num_gtes_per_gte;
1.1 root 1192: gd_size = (gt_count * sizeof(uint32_t) + 511) >> 9;
1193:
1194: header.desc_offset = 1;
1195: header.desc_size = 20;
1196: header.rgd_offset = header.desc_offset + header.desc_size;
1197: header.gd_offset = header.rgd_offset + gd_size + (gt_size * gt_count);
1198: header.grain_offset =
1199: ((header.gd_offset + gd_size + (gt_size * gt_count) +
1200: header.granularity - 1) / header.granularity) *
1201: header.granularity;
1.1.1.5 root 1202: /* swap endianness for all header fields */
1203: header.version = cpu_to_le32(header.version);
1204: header.flags = cpu_to_le32(header.flags);
1205: header.capacity = cpu_to_le64(header.capacity);
1206: header.granularity = cpu_to_le64(header.granularity);
1207: header.num_gtes_per_gte = cpu_to_le32(header.num_gtes_per_gte);
1.1 root 1208: header.desc_offset = cpu_to_le64(header.desc_offset);
1209: header.desc_size = cpu_to_le64(header.desc_size);
1210: header.rgd_offset = cpu_to_le64(header.rgd_offset);
1211: header.gd_offset = cpu_to_le64(header.gd_offset);
1212: header.grain_offset = cpu_to_le64(header.grain_offset);
1.1.1.6 root 1213: header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
1.1 root 1214:
1215: header.check_bytes[0] = 0xa;
1216: header.check_bytes[1] = 0x20;
1217: header.check_bytes[2] = 0xd;
1218: header.check_bytes[3] = 0xa;
1219:
1220: /* write all the data */
1.1.1.3 root 1221: ret = qemu_write_full(fd, &magic, sizeof(magic));
1222: if (ret != sizeof(magic)) {
1223: ret = -errno;
1224: goto exit;
1225: }
1226: ret = qemu_write_full(fd, &header, sizeof(header));
1227: if (ret != sizeof(header)) {
1228: ret = -errno;
1229: goto exit;
1230: }
1.1 root 1231:
1.1.1.5 root 1232: ret = ftruncate(fd, le64_to_cpu(header.grain_offset) << 9);
1.1.1.3 root 1233: if (ret < 0) {
1234: ret = -errno;
1235: goto exit;
1236: }
1.1 root 1237:
1238: /* write grain directory */
1239: lseek(fd, le64_to_cpu(header.rgd_offset) << 9, SEEK_SET);
1.1.1.5 root 1240: for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_size;
1.1.1.3 root 1241: i < gt_count; i++, tmp += gt_size) {
1242: ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1243: if (ret != sizeof(tmp)) {
1244: ret = -errno;
1245: goto exit;
1246: }
1247: }
1.1 root 1248:
1249: /* write backup grain directory */
1250: lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);
1.1.1.5 root 1251: for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_size;
1.1.1.3 root 1252: i < gt_count; i++, tmp += gt_size) {
1253: ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1254: if (ret != sizeof(tmp)) {
1255: ret = -errno;
1256: goto exit;
1257: }
1258: }
1.1 root 1259:
1.1.1.5 root 1260: ret = 0;
1261: exit:
1262: close(fd);
1263: return ret;
1264: }
1265:
1266: static int filename_decompose(const char *filename, char *path, char *prefix,
1267: char *postfix, size_t buf_len)
1268: {
1269: const char *p, *q;
1270:
1271: if (filename == NULL || !strlen(filename)) {
1272: fprintf(stderr, "Vmdk: no filename provided.\n");
1273: return -1;
1274: }
1275: p = strrchr(filename, '/');
1276: if (p == NULL) {
1277: p = strrchr(filename, '\\');
1278: }
1279: if (p == NULL) {
1280: p = strrchr(filename, ':');
1281: }
1282: if (p != NULL) {
1283: p++;
1284: if (p - filename >= buf_len) {
1285: return -1;
1286: }
1287: pstrcpy(path, p - filename + 1, filename);
1288: } else {
1289: p = filename;
1290: path[0] = '\0';
1291: }
1292: q = strrchr(p, '.');
1293: if (q == NULL) {
1294: pstrcpy(prefix, buf_len, p);
1295: postfix[0] = '\0';
1296: } else {
1297: if (q - p >= buf_len) {
1298: return -1;
1299: }
1300: pstrcpy(prefix, q - p + 1, p);
1301: pstrcpy(postfix, buf_len, q);
1302: }
1303: return 0;
1304: }
1305:
1306: static int relative_path(char *dest, int dest_size,
1307: const char *base, const char *target)
1308: {
1309: int i = 0;
1310: int n = 0;
1311: const char *p, *q;
1312: #ifdef _WIN32
1313: const char *sep = "\\";
1314: #else
1315: const char *sep = "/";
1316: #endif
1317:
1318: if (!(dest && base && target)) {
1319: return -1;
1320: }
1321: if (path_is_absolute(target)) {
1322: dest[dest_size - 1] = '\0';
1323: strncpy(dest, target, dest_size - 1);
1324: return 0;
1325: }
1326: while (base[i] == target[i]) {
1327: i++;
1328: }
1329: p = &base[i];
1330: q = &target[i];
1331: while (*p) {
1332: if (*p == *sep) {
1333: n++;
1334: }
1335: p++;
1336: }
1337: dest[0] = '\0';
1338: for (; n; n--) {
1339: pstrcat(dest, dest_size, "..");
1340: pstrcat(dest, dest_size, sep);
1341: }
1342: pstrcat(dest, dest_size, q);
1343: return 0;
1344: }
1345:
1346: static int vmdk_create(const char *filename, QEMUOptionParameter *options)
1347: {
1348: int fd, idx = 0;
1349: char desc[BUF_SIZE];
1350: int64_t total_size = 0, filesize;
1351: const char *backing_file = NULL;
1352: const char *fmt = NULL;
1353: int flags = 0;
1354: int ret = 0;
1.1.1.6 root 1355: bool flat, split, compress;
1.1.1.5 root 1356: char ext_desc_lines[BUF_SIZE] = "";
1357: char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];
1358: const int64_t split_size = 0x80000000; /* VMDK has constant split size */
1359: const char *desc_extent_line;
1360: char parent_desc_line[BUF_SIZE] = "";
1361: uint32_t parent_cid = 0xffffffff;
1362: const char desc_template[] =
1363: "# Disk DescriptorFile\n"
1364: "version=1\n"
1365: "CID=%x\n"
1366: "parentCID=%x\n"
1367: "createType=\"%s\"\n"
1368: "%s"
1369: "\n"
1370: "# Extent description\n"
1371: "%s"
1372: "\n"
1373: "# The Disk Data Base\n"
1374: "#DDB\n"
1375: "\n"
1376: "ddb.virtualHWVersion = \"%d\"\n"
1377: "ddb.geometry.cylinders = \"%" PRId64 "\"\n"
1378: "ddb.geometry.heads = \"16\"\n"
1379: "ddb.geometry.sectors = \"63\"\n"
1380: "ddb.adapterType = \"ide\"\n";
1.1 root 1381:
1.1.1.5 root 1382: if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
1383: return -EINVAL;
1384: }
1385: /* Read out options */
1386: while (options && options->name) {
1387: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1388: total_size = options->value.n;
1389: } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1390: backing_file = options->value.s;
1391: } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
1392: flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
1393: } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
1394: fmt = options->value.s;
1395: }
1396: options++;
1397: }
1398: if (!fmt) {
1399: /* Default format to monolithicSparse */
1400: fmt = "monolithicSparse";
1401: } else if (strcmp(fmt, "monolithicFlat") &&
1402: strcmp(fmt, "monolithicSparse") &&
1403: strcmp(fmt, "twoGbMaxExtentSparse") &&
1.1.1.6 root 1404: strcmp(fmt, "twoGbMaxExtentFlat") &&
1405: strcmp(fmt, "streamOptimized")) {
1.1.1.5 root 1406: fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt);
1407: return -EINVAL;
1408: }
1409: split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
1410: strcmp(fmt, "twoGbMaxExtentSparse"));
1411: flat = !(strcmp(fmt, "monolithicFlat") &&
1412: strcmp(fmt, "twoGbMaxExtentFlat"));
1.1.1.6 root 1413: compress = !strcmp(fmt, "streamOptimized");
1.1.1.5 root 1414: if (flat) {
1415: desc_extent_line = "RW %lld FLAT \"%s\" 0\n";
1416: } else {
1417: desc_extent_line = "RW %lld SPARSE \"%s\"\n";
1418: }
1419: if (flat && backing_file) {
1420: /* not supporting backing file for flat image */
1421: return -ENOTSUP;
1422: }
1423: if (backing_file) {
1424: char parent_filename[PATH_MAX];
1425: BlockDriverState *bs = bdrv_new("");
1426: ret = bdrv_open(bs, backing_file, 0, NULL);
1427: if (ret != 0) {
1428: bdrv_delete(bs);
1429: return ret;
1430: }
1431: if (strcmp(bs->drv->format_name, "vmdk")) {
1432: bdrv_delete(bs);
1433: return -EINVAL;
1434: }
1435: parent_cid = vmdk_read_cid(bs, 0);
1436: bdrv_delete(bs);
1437: relative_path(parent_filename, sizeof(parent_filename),
1438: filename, backing_file);
1439: snprintf(parent_desc_line, sizeof(parent_desc_line),
1440: "parentFileNameHint=\"%s\"", parent_filename);
1441: }
1442:
1443: /* Create extents */
1444: filesize = total_size;
1445: while (filesize > 0) {
1446: char desc_line[BUF_SIZE];
1447: char ext_filename[PATH_MAX];
1448: char desc_filename[PATH_MAX];
1449: int64_t size = filesize;
1450:
1451: if (split && size > split_size) {
1452: size = split_size;
1453: }
1454: if (split) {
1455: snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",
1456: prefix, flat ? 'f' : 's', ++idx, postfix);
1457: } else if (flat) {
1458: snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",
1459: prefix, postfix);
1460: } else {
1461: snprintf(desc_filename, sizeof(desc_filename), "%s%s",
1462: prefix, postfix);
1463: }
1464: snprintf(ext_filename, sizeof(ext_filename), "%s%s",
1465: path, desc_filename);
1466:
1.1.1.6 root 1467: if (vmdk_create_extent(ext_filename, size, flat, compress)) {
1.1.1.5 root 1468: return -EINVAL;
1469: }
1470: filesize -= size;
1471:
1472: /* Format description line */
1473: snprintf(desc_line, sizeof(desc_line),
1474: desc_extent_line, size / 512, desc_filename);
1475: pstrcat(ext_desc_lines, sizeof(ext_desc_lines), desc_line);
1476: }
1477: /* generate descriptor file */
1478: snprintf(desc, sizeof(desc), desc_template,
1479: (unsigned int)time(NULL),
1480: parent_cid,
1481: fmt,
1482: parent_desc_line,
1483: ext_desc_lines,
1484: (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
1485: total_size / (int64_t)(63 * 16 * 512));
1486: if (split || flat) {
1487: fd = open(
1488: filename,
1489: O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1490: 0644);
1491: } else {
1492: fd = open(
1493: filename,
1494: O_WRONLY | O_BINARY | O_LARGEFILE,
1495: 0644);
1496: }
1497: if (fd < 0) {
1498: return -errno;
1499: }
1500: /* the descriptor offset = 0x200 */
1501: if (!split && !flat && 0x200 != lseek(fd, 0x200, SEEK_SET)) {
1502: ret = -errno;
1503: goto exit;
1504: }
1.1.1.3 root 1505: ret = qemu_write_full(fd, desc, strlen(desc));
1506: if (ret != strlen(desc)) {
1507: ret = -errno;
1508: goto exit;
1509: }
1510: ret = 0;
1511: exit:
1.1 root 1512: close(fd);
1.1.1.3 root 1513: return ret;
1.1 root 1514: }
1515:
1516: static void vmdk_close(BlockDriverState *bs)
1517: {
1.1.1.6 root 1518: BDRVVmdkState *s = bs->opaque;
1519:
1.1.1.5 root 1520: vmdk_free_extents(bs);
1.1.1.6 root 1521:
1522: migrate_del_blocker(s->migration_blocker);
1523: error_free(s->migration_blocker);
1.1 root 1524: }
1525:
1.1.1.6 root 1526: static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
1.1 root 1527: {
1.1.1.5 root 1528: BDRVVmdkState *s = bs->opaque;
1.1.1.7 ! root 1529: int i, err;
! 1530: int ret = 0;
1.1.1.5 root 1531:
1532: for (i = 0; i < s->num_extents; i++) {
1.1.1.6 root 1533: err = bdrv_co_flush(s->extents[i].file);
1.1.1.5 root 1534: if (err < 0) {
1535: ret = err;
1536: }
1537: }
1538: return ret;
1.1 root 1539: }
1540:
1.1.1.5 root 1541: static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
1542: {
1543: int i;
1544: int64_t ret = 0;
1545: int64_t r;
1546: BDRVVmdkState *s = bs->opaque;
1547:
1548: ret = bdrv_get_allocated_file_size(bs->file);
1549: if (ret < 0) {
1550: return ret;
1551: }
1552: for (i = 0; i < s->num_extents; i++) {
1553: if (s->extents[i].file == bs->file) {
1554: continue;
1555: }
1556: r = bdrv_get_allocated_file_size(s->extents[i].file);
1557: if (r < 0) {
1558: return r;
1559: }
1560: ret += r;
1561: }
1562: return ret;
1563: }
1.1 root 1564:
1565: static QEMUOptionParameter vmdk_create_options[] = {
1566: {
1567: .name = BLOCK_OPT_SIZE,
1568: .type = OPT_SIZE,
1569: .help = "Virtual disk size"
1570: },
1571: {
1572: .name = BLOCK_OPT_BACKING_FILE,
1573: .type = OPT_STRING,
1574: .help = "File name of a base image"
1575: },
1576: {
1577: .name = BLOCK_OPT_COMPAT6,
1578: .type = OPT_FLAG,
1579: .help = "VMDK version 6 image"
1580: },
1.1.1.5 root 1581: {
1582: .name = BLOCK_OPT_SUBFMT,
1583: .type = OPT_STRING,
1584: .help =
1585: "VMDK flat extent format, can be one of "
1.1.1.6 root 1586: "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
1.1.1.5 root 1587: },
1.1 root 1588: { NULL }
1589: };
1590:
1591: static BlockDriver bdrv_vmdk = {
1.1.1.5 root 1592: .format_name = "vmdk",
1593: .instance_size = sizeof(BDRVVmdkState),
1594: .bdrv_probe = vmdk_probe,
1.1.1.3 root 1595: .bdrv_open = vmdk_open,
1.1.1.6 root 1596: .bdrv_read = vmdk_co_read,
1597: .bdrv_write = vmdk_co_write,
1.1.1.5 root 1598: .bdrv_close = vmdk_close,
1599: .bdrv_create = vmdk_create,
1.1.1.6 root 1600: .bdrv_co_flush_to_disk = vmdk_co_flush,
1.1.1.7 ! root 1601: .bdrv_co_is_allocated = vmdk_co_is_allocated,
1.1.1.5 root 1602: .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
1.1 root 1603:
1604: .create_options = vmdk_create_options,
1605: };
1606:
1607: static void bdrv_vmdk_init(void)
1608: {
1609: bdrv_register(&bdrv_vmdk);
1610: }
1611:
1612: block_init(bdrv_vmdk_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.