![[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.6 ! root 456: if (l1_entry_sectors <= 0) {
! 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:
864: static int vmdk_is_allocated(BlockDriverState *bs, int64_t sector_num,
865: int nb_sectors, int *pnum)
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: }
876: ret = get_cluster_offset(bs, extent, NULL,
877: sector_num * 512, 0, &offset);
878: /* get_cluster_offset returning 0 means success */
879: ret = !ret;
880:
881: index_in_cluster = sector_num % extent->cluster_sectors;
882: n = extent->cluster_sectors - index_in_cluster;
883: if (n > nb_sectors) {
1.1 root 884: n = nb_sectors;
1.1.1.5 root 885: }
1.1 root 886: *pnum = n;
1.1.1.5 root 887: return ret;
1.1 root 888: }
889:
1.1.1.6 ! root 890: static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
! 891: int64_t offset_in_cluster, const uint8_t *buf,
! 892: int nb_sectors, int64_t sector_num)
! 893: {
! 894: int ret;
! 895: VmdkGrainMarker *data = NULL;
! 896: uLongf buf_len;
! 897: const uint8_t *write_buf = buf;
! 898: int write_len = nb_sectors * 512;
! 899:
! 900: if (extent->compressed) {
! 901: if (!extent->has_marker) {
! 902: ret = -EINVAL;
! 903: goto out;
! 904: }
! 905: buf_len = (extent->cluster_sectors << 9) * 2;
! 906: data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
! 907: if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
! 908: buf_len == 0) {
! 909: ret = -EINVAL;
! 910: goto out;
! 911: }
! 912: data->lba = sector_num;
! 913: data->size = buf_len;
! 914: write_buf = (uint8_t *)data;
! 915: write_len = buf_len + sizeof(VmdkGrainMarker);
! 916: }
! 917: ret = bdrv_pwrite(extent->file,
! 918: cluster_offset + offset_in_cluster,
! 919: write_buf,
! 920: write_len);
! 921: if (ret != write_len) {
! 922: ret = ret < 0 ? ret : -EIO;
! 923: goto out;
! 924: }
! 925: ret = 0;
! 926: out:
! 927: g_free(data);
! 928: return ret;
! 929: }
! 930:
! 931: static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
! 932: int64_t offset_in_cluster, uint8_t *buf,
! 933: int nb_sectors)
! 934: {
! 935: int ret;
! 936: int cluster_bytes, buf_bytes;
! 937: uint8_t *cluster_buf, *compressed_data;
! 938: uint8_t *uncomp_buf;
! 939: uint32_t data_len;
! 940: VmdkGrainMarker *marker;
! 941: uLongf buf_len;
! 942:
! 943:
! 944: if (!extent->compressed) {
! 945: ret = bdrv_pread(extent->file,
! 946: cluster_offset + offset_in_cluster,
! 947: buf, nb_sectors * 512);
! 948: if (ret == nb_sectors * 512) {
! 949: return 0;
! 950: } else {
! 951: return -EIO;
! 952: }
! 953: }
! 954: cluster_bytes = extent->cluster_sectors * 512;
! 955: /* Read two clusters in case GrainMarker + compressed data > one cluster */
! 956: buf_bytes = cluster_bytes * 2;
! 957: cluster_buf = g_malloc(buf_bytes);
! 958: uncomp_buf = g_malloc(cluster_bytes);
! 959: ret = bdrv_pread(extent->file,
! 960: cluster_offset,
! 961: cluster_buf, buf_bytes);
! 962: if (ret < 0) {
! 963: goto out;
! 964: }
! 965: compressed_data = cluster_buf;
! 966: buf_len = cluster_bytes;
! 967: data_len = cluster_bytes;
! 968: if (extent->has_marker) {
! 969: marker = (VmdkGrainMarker *)cluster_buf;
! 970: compressed_data = marker->data;
! 971: data_len = le32_to_cpu(marker->size);
! 972: }
! 973: if (!data_len || data_len > buf_bytes) {
! 974: ret = -EINVAL;
! 975: goto out;
! 976: }
! 977: ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
! 978: if (ret != Z_OK) {
! 979: ret = -EINVAL;
! 980: goto out;
! 981:
! 982: }
! 983: if (offset_in_cluster < 0 ||
! 984: offset_in_cluster + nb_sectors * 512 > buf_len) {
! 985: ret = -EINVAL;
! 986: goto out;
! 987: }
! 988: memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
! 989: ret = 0;
! 990:
! 991: out:
! 992: g_free(uncomp_buf);
! 993: g_free(cluster_buf);
! 994: return ret;
! 995: }
! 996:
1.1 root 997: static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
998: uint8_t *buf, int nb_sectors)
999: {
1000: BDRVVmdkState *s = bs->opaque;
1.1.1.5 root 1001: int ret;
1002: uint64_t n, index_in_cluster;
1003: VmdkExtent *extent = NULL;
1.1 root 1004: uint64_t cluster_offset;
1005:
1006: while (nb_sectors > 0) {
1.1.1.5 root 1007: extent = find_extent(s, sector_num, extent);
1008: if (!extent) {
1009: return -EIO;
1010: }
1011: ret = get_cluster_offset(
1012: bs, extent, NULL,
1013: sector_num << 9, 0, &cluster_offset);
1014: index_in_cluster = sector_num % extent->cluster_sectors;
1015: n = extent->cluster_sectors - index_in_cluster;
1016: if (n > nb_sectors) {
1.1 root 1017: n = nb_sectors;
1.1.1.5 root 1018: }
1019: if (ret) {
1020: /* if not allocated, try to read from parent image, if exist */
1.1 root 1021: if (bs->backing_hd) {
1.1.1.5 root 1022: if (!vmdk_is_cid_valid(bs)) {
1023: return -EINVAL;
1024: }
1.1 root 1025: ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
1.1.1.5 root 1026: if (ret < 0) {
1027: return ret;
1028: }
1.1 root 1029: } else {
1030: memset(buf, 0, 512 * n);
1031: }
1032: } else {
1.1.1.6 ! root 1033: ret = vmdk_read_extent(extent,
! 1034: cluster_offset, index_in_cluster * 512,
! 1035: buf, n);
! 1036: if (ret) {
1.1.1.5 root 1037: return ret;
1038: }
1.1 root 1039: }
1040: nb_sectors -= n;
1041: sector_num += n;
1042: buf += n * 512;
1043: }
1044: return 0;
1045: }
1046:
1.1.1.6 ! root 1047: static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
! 1048: uint8_t *buf, int nb_sectors)
! 1049: {
! 1050: int ret;
! 1051: BDRVVmdkState *s = bs->opaque;
! 1052: qemu_co_mutex_lock(&s->lock);
! 1053: ret = vmdk_read(bs, sector_num, buf, nb_sectors);
! 1054: qemu_co_mutex_unlock(&s->lock);
! 1055: return ret;
! 1056: }
! 1057:
1.1 root 1058: static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
1059: const uint8_t *buf, int nb_sectors)
1060: {
1061: BDRVVmdkState *s = bs->opaque;
1.1.1.5 root 1062: VmdkExtent *extent = NULL;
1063: int n, ret;
1064: int64_t index_in_cluster;
1.1 root 1065: uint64_t cluster_offset;
1.1.1.5 root 1066: VmdkMetaData m_data;
1.1 root 1067:
1068: if (sector_num > bs->total_sectors) {
1069: fprintf(stderr,
1070: "(VMDK) Wrong offset: sector_num=0x%" PRIx64
1071: " total_sectors=0x%" PRIx64 "\n",
1072: sector_num, bs->total_sectors);
1.1.1.5 root 1073: return -EIO;
1.1 root 1074: }
1075:
1076: while (nb_sectors > 0) {
1.1.1.5 root 1077: extent = find_extent(s, sector_num, extent);
1078: if (!extent) {
1079: return -EIO;
1080: }
1081: ret = get_cluster_offset(
1082: bs,
1083: extent,
1084: &m_data,
1.1.1.6 ! root 1085: sector_num << 9, !extent->compressed,
1.1.1.5 root 1086: &cluster_offset);
1.1.1.6 ! root 1087: if (extent->compressed) {
! 1088: if (ret == 0) {
! 1089: /* Refuse write to allocated cluster for streamOptimized */
! 1090: fprintf(stderr,
! 1091: "VMDK: can't write to allocated cluster"
! 1092: " for streamOptimized\n");
! 1093: return -EIO;
! 1094: } else {
! 1095: /* allocate */
! 1096: ret = get_cluster_offset(
! 1097: bs,
! 1098: extent,
! 1099: &m_data,
! 1100: sector_num << 9, 1,
! 1101: &cluster_offset);
! 1102: }
! 1103: }
1.1.1.5 root 1104: if (ret) {
1105: return -EINVAL;
1106: }
1107: index_in_cluster = sector_num % extent->cluster_sectors;
1108: n = extent->cluster_sectors - index_in_cluster;
1109: if (n > nb_sectors) {
1.1 root 1110: n = nb_sectors;
1.1.1.5 root 1111: }
1.1 root 1112:
1.1.1.6 ! root 1113: ret = vmdk_write_extent(extent,
! 1114: cluster_offset, index_in_cluster * 512,
! 1115: buf, n, sector_num);
! 1116: if (ret) {
1.1.1.5 root 1117: return ret;
1118: }
1.1 root 1119: if (m_data.valid) {
1120: /* update L2 tables */
1.1.1.5 root 1121: if (vmdk_L2update(extent, &m_data) == -1) {
1122: return -EIO;
1123: }
1.1 root 1124: }
1125: nb_sectors -= n;
1126: sector_num += n;
1127: buf += n * 512;
1128:
1.1.1.5 root 1129: /* update CID on the first write every time the virtual disk is
1130: * opened */
1131: if (!s->cid_updated) {
1.1.1.6 ! root 1132: ret = vmdk_write_cid(bs, time(NULL));
! 1133: if (ret < 0) {
! 1134: return ret;
! 1135: }
1.1.1.5 root 1136: s->cid_updated = true;
1.1 root 1137: }
1138: }
1139: return 0;
1140: }
1141:
1.1.1.6 ! root 1142: static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
! 1143: const uint8_t *buf, int nb_sectors)
! 1144: {
! 1145: int ret;
! 1146: BDRVVmdkState *s = bs->opaque;
! 1147: qemu_co_mutex_lock(&s->lock);
! 1148: ret = vmdk_write(bs, sector_num, buf, nb_sectors);
! 1149: qemu_co_mutex_unlock(&s->lock);
! 1150: return ret;
! 1151: }
! 1152:
1.1.1.5 root 1153:
1.1.1.6 ! root 1154: static int vmdk_create_extent(const char *filename, int64_t filesize,
! 1155: bool flat, bool compress)
1.1 root 1156: {
1.1.1.5 root 1157: int ret, i;
1158: int fd = 0;
1.1 root 1159: VMDK4Header header;
1160: uint32_t tmp, magic, grains, gd_size, gt_size, gt_count;
1161:
1.1.1.5 root 1162: fd = open(
1163: filename,
1164: O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1165: 0644);
1166: if (fd < 0) {
1167: return -errno;
1.1 root 1168: }
1.1.1.5 root 1169: if (flat) {
1170: ret = ftruncate(fd, filesize);
1171: if (ret < 0) {
1172: ret = -errno;
1173: }
1174: goto exit;
1.1 root 1175: }
1176: magic = cpu_to_be32(VMDK4_MAGIC);
1177: memset(&header, 0, sizeof(header));
1.1.1.5 root 1178: header.version = 1;
1.1.1.6 ! root 1179: header.flags =
! 1180: 3 | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0);
! 1181: header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
1.1.1.5 root 1182: header.capacity = filesize / 512;
1183: header.granularity = 128;
1184: header.num_gtes_per_gte = 512;
1.1 root 1185:
1.1.1.5 root 1186: grains = (filesize / 512 + header.granularity - 1) / header.granularity;
1.1 root 1187: gt_size = ((header.num_gtes_per_gte * sizeof(uint32_t)) + 511) >> 9;
1.1.1.5 root 1188: gt_count =
1189: (grains + header.num_gtes_per_gte - 1) / header.num_gtes_per_gte;
1.1 root 1190: gd_size = (gt_count * sizeof(uint32_t) + 511) >> 9;
1191:
1192: header.desc_offset = 1;
1193: header.desc_size = 20;
1194: header.rgd_offset = header.desc_offset + header.desc_size;
1195: header.gd_offset = header.rgd_offset + gd_size + (gt_size * gt_count);
1196: header.grain_offset =
1197: ((header.gd_offset + gd_size + (gt_size * gt_count) +
1198: header.granularity - 1) / header.granularity) *
1199: header.granularity;
1.1.1.5 root 1200: /* swap endianness for all header fields */
1201: header.version = cpu_to_le32(header.version);
1202: header.flags = cpu_to_le32(header.flags);
1203: header.capacity = cpu_to_le64(header.capacity);
1204: header.granularity = cpu_to_le64(header.granularity);
1205: header.num_gtes_per_gte = cpu_to_le32(header.num_gtes_per_gte);
1.1 root 1206: header.desc_offset = cpu_to_le64(header.desc_offset);
1207: header.desc_size = cpu_to_le64(header.desc_size);
1208: header.rgd_offset = cpu_to_le64(header.rgd_offset);
1209: header.gd_offset = cpu_to_le64(header.gd_offset);
1210: header.grain_offset = cpu_to_le64(header.grain_offset);
1.1.1.6 ! root 1211: header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
1.1 root 1212:
1213: header.check_bytes[0] = 0xa;
1214: header.check_bytes[1] = 0x20;
1215: header.check_bytes[2] = 0xd;
1216: header.check_bytes[3] = 0xa;
1217:
1218: /* write all the data */
1.1.1.3 root 1219: ret = qemu_write_full(fd, &magic, sizeof(magic));
1220: if (ret != sizeof(magic)) {
1221: ret = -errno;
1222: goto exit;
1223: }
1224: ret = qemu_write_full(fd, &header, sizeof(header));
1225: if (ret != sizeof(header)) {
1226: ret = -errno;
1227: goto exit;
1228: }
1.1 root 1229:
1.1.1.5 root 1230: ret = ftruncate(fd, le64_to_cpu(header.grain_offset) << 9);
1.1.1.3 root 1231: if (ret < 0) {
1232: ret = -errno;
1233: goto exit;
1234: }
1.1 root 1235:
1236: /* write grain directory */
1237: lseek(fd, le64_to_cpu(header.rgd_offset) << 9, SEEK_SET);
1.1.1.5 root 1238: for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_size;
1.1.1.3 root 1239: i < gt_count; i++, tmp += gt_size) {
1240: ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1241: if (ret != sizeof(tmp)) {
1242: ret = -errno;
1243: goto exit;
1244: }
1245: }
1.1 root 1246:
1247: /* write backup grain directory */
1248: lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);
1.1.1.5 root 1249: for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_size;
1.1.1.3 root 1250: i < gt_count; i++, tmp += gt_size) {
1251: ret = qemu_write_full(fd, &tmp, sizeof(tmp));
1252: if (ret != sizeof(tmp)) {
1253: ret = -errno;
1254: goto exit;
1255: }
1256: }
1.1 root 1257:
1.1.1.5 root 1258: ret = 0;
1259: exit:
1260: close(fd);
1261: return ret;
1262: }
1263:
1264: static int filename_decompose(const char *filename, char *path, char *prefix,
1265: char *postfix, size_t buf_len)
1266: {
1267: const char *p, *q;
1268:
1269: if (filename == NULL || !strlen(filename)) {
1270: fprintf(stderr, "Vmdk: no filename provided.\n");
1271: return -1;
1272: }
1273: p = strrchr(filename, '/');
1274: if (p == NULL) {
1275: p = strrchr(filename, '\\');
1276: }
1277: if (p == NULL) {
1278: p = strrchr(filename, ':');
1279: }
1280: if (p != NULL) {
1281: p++;
1282: if (p - filename >= buf_len) {
1283: return -1;
1284: }
1285: pstrcpy(path, p - filename + 1, filename);
1286: } else {
1287: p = filename;
1288: path[0] = '\0';
1289: }
1290: q = strrchr(p, '.');
1291: if (q == NULL) {
1292: pstrcpy(prefix, buf_len, p);
1293: postfix[0] = '\0';
1294: } else {
1295: if (q - p >= buf_len) {
1296: return -1;
1297: }
1298: pstrcpy(prefix, q - p + 1, p);
1299: pstrcpy(postfix, buf_len, q);
1300: }
1301: return 0;
1302: }
1303:
1304: static int relative_path(char *dest, int dest_size,
1305: const char *base, const char *target)
1306: {
1307: int i = 0;
1308: int n = 0;
1309: const char *p, *q;
1310: #ifdef _WIN32
1311: const char *sep = "\\";
1312: #else
1313: const char *sep = "/";
1314: #endif
1315:
1316: if (!(dest && base && target)) {
1317: return -1;
1318: }
1319: if (path_is_absolute(target)) {
1320: dest[dest_size - 1] = '\0';
1321: strncpy(dest, target, dest_size - 1);
1322: return 0;
1323: }
1324: while (base[i] == target[i]) {
1325: i++;
1326: }
1327: p = &base[i];
1328: q = &target[i];
1329: while (*p) {
1330: if (*p == *sep) {
1331: n++;
1332: }
1333: p++;
1334: }
1335: dest[0] = '\0';
1336: for (; n; n--) {
1337: pstrcat(dest, dest_size, "..");
1338: pstrcat(dest, dest_size, sep);
1339: }
1340: pstrcat(dest, dest_size, q);
1341: return 0;
1342: }
1343:
1344: static int vmdk_create(const char *filename, QEMUOptionParameter *options)
1345: {
1346: int fd, idx = 0;
1347: char desc[BUF_SIZE];
1348: int64_t total_size = 0, filesize;
1349: const char *backing_file = NULL;
1350: const char *fmt = NULL;
1351: int flags = 0;
1352: int ret = 0;
1.1.1.6 ! root 1353: bool flat, split, compress;
1.1.1.5 root 1354: char ext_desc_lines[BUF_SIZE] = "";
1355: char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];
1356: const int64_t split_size = 0x80000000; /* VMDK has constant split size */
1357: const char *desc_extent_line;
1358: char parent_desc_line[BUF_SIZE] = "";
1359: uint32_t parent_cid = 0xffffffff;
1360: const char desc_template[] =
1361: "# Disk DescriptorFile\n"
1362: "version=1\n"
1363: "CID=%x\n"
1364: "parentCID=%x\n"
1365: "createType=\"%s\"\n"
1366: "%s"
1367: "\n"
1368: "# Extent description\n"
1369: "%s"
1370: "\n"
1371: "# The Disk Data Base\n"
1372: "#DDB\n"
1373: "\n"
1374: "ddb.virtualHWVersion = \"%d\"\n"
1375: "ddb.geometry.cylinders = \"%" PRId64 "\"\n"
1376: "ddb.geometry.heads = \"16\"\n"
1377: "ddb.geometry.sectors = \"63\"\n"
1378: "ddb.adapterType = \"ide\"\n";
1.1 root 1379:
1.1.1.5 root 1380: if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
1381: return -EINVAL;
1382: }
1383: /* Read out options */
1384: while (options && options->name) {
1385: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1386: total_size = options->value.n;
1387: } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
1388: backing_file = options->value.s;
1389: } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
1390: flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
1391: } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
1392: fmt = options->value.s;
1393: }
1394: options++;
1395: }
1396: if (!fmt) {
1397: /* Default format to monolithicSparse */
1398: fmt = "monolithicSparse";
1399: } else if (strcmp(fmt, "monolithicFlat") &&
1400: strcmp(fmt, "monolithicSparse") &&
1401: strcmp(fmt, "twoGbMaxExtentSparse") &&
1.1.1.6 ! root 1402: strcmp(fmt, "twoGbMaxExtentFlat") &&
! 1403: strcmp(fmt, "streamOptimized")) {
1.1.1.5 root 1404: fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt);
1405: return -EINVAL;
1406: }
1407: split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
1408: strcmp(fmt, "twoGbMaxExtentSparse"));
1409: flat = !(strcmp(fmt, "monolithicFlat") &&
1410: strcmp(fmt, "twoGbMaxExtentFlat"));
1.1.1.6 ! root 1411: compress = !strcmp(fmt, "streamOptimized");
1.1.1.5 root 1412: if (flat) {
1413: desc_extent_line = "RW %lld FLAT \"%s\" 0\n";
1414: } else {
1415: desc_extent_line = "RW %lld SPARSE \"%s\"\n";
1416: }
1417: if (flat && backing_file) {
1418: /* not supporting backing file for flat image */
1419: return -ENOTSUP;
1420: }
1421: if (backing_file) {
1422: char parent_filename[PATH_MAX];
1423: BlockDriverState *bs = bdrv_new("");
1424: ret = bdrv_open(bs, backing_file, 0, NULL);
1425: if (ret != 0) {
1426: bdrv_delete(bs);
1427: return ret;
1428: }
1429: if (strcmp(bs->drv->format_name, "vmdk")) {
1430: bdrv_delete(bs);
1431: return -EINVAL;
1432: }
1433: parent_cid = vmdk_read_cid(bs, 0);
1434: bdrv_delete(bs);
1435: relative_path(parent_filename, sizeof(parent_filename),
1436: filename, backing_file);
1437: snprintf(parent_desc_line, sizeof(parent_desc_line),
1438: "parentFileNameHint=\"%s\"", parent_filename);
1439: }
1440:
1441: /* Create extents */
1442: filesize = total_size;
1443: while (filesize > 0) {
1444: char desc_line[BUF_SIZE];
1445: char ext_filename[PATH_MAX];
1446: char desc_filename[PATH_MAX];
1447: int64_t size = filesize;
1448:
1449: if (split && size > split_size) {
1450: size = split_size;
1451: }
1452: if (split) {
1453: snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",
1454: prefix, flat ? 'f' : 's', ++idx, postfix);
1455: } else if (flat) {
1456: snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",
1457: prefix, postfix);
1458: } else {
1459: snprintf(desc_filename, sizeof(desc_filename), "%s%s",
1460: prefix, postfix);
1461: }
1462: snprintf(ext_filename, sizeof(ext_filename), "%s%s",
1463: path, desc_filename);
1464:
1.1.1.6 ! root 1465: if (vmdk_create_extent(ext_filename, size, flat, compress)) {
1.1.1.5 root 1466: return -EINVAL;
1467: }
1468: filesize -= size;
1469:
1470: /* Format description line */
1471: snprintf(desc_line, sizeof(desc_line),
1472: desc_extent_line, size / 512, desc_filename);
1473: pstrcat(ext_desc_lines, sizeof(ext_desc_lines), desc_line);
1474: }
1475: /* generate descriptor file */
1476: snprintf(desc, sizeof(desc), desc_template,
1477: (unsigned int)time(NULL),
1478: parent_cid,
1479: fmt,
1480: parent_desc_line,
1481: ext_desc_lines,
1482: (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
1483: total_size / (int64_t)(63 * 16 * 512));
1484: if (split || flat) {
1485: fd = open(
1486: filename,
1487: O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
1488: 0644);
1489: } else {
1490: fd = open(
1491: filename,
1492: O_WRONLY | O_BINARY | O_LARGEFILE,
1493: 0644);
1494: }
1495: if (fd < 0) {
1496: return -errno;
1497: }
1498: /* the descriptor offset = 0x200 */
1499: if (!split && !flat && 0x200 != lseek(fd, 0x200, SEEK_SET)) {
1500: ret = -errno;
1501: goto exit;
1502: }
1.1.1.3 root 1503: ret = qemu_write_full(fd, desc, strlen(desc));
1504: if (ret != strlen(desc)) {
1505: ret = -errno;
1506: goto exit;
1507: }
1508: ret = 0;
1509: exit:
1.1 root 1510: close(fd);
1.1.1.3 root 1511: return ret;
1.1 root 1512: }
1513:
1514: static void vmdk_close(BlockDriverState *bs)
1515: {
1.1.1.6 ! root 1516: BDRVVmdkState *s = bs->opaque;
! 1517:
1.1.1.5 root 1518: vmdk_free_extents(bs);
1.1.1.6 ! root 1519:
! 1520: migrate_del_blocker(s->migration_blocker);
! 1521: error_free(s->migration_blocker);
1.1 root 1522: }
1523:
1.1.1.6 ! root 1524: static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
1.1 root 1525: {
1.1.1.5 root 1526: int i, ret, err;
1527: BDRVVmdkState *s = bs->opaque;
1528:
1.1.1.6 ! root 1529: ret = bdrv_co_flush(bs->file);
1.1.1.5 root 1530: for (i = 0; i < s->num_extents; i++) {
1.1.1.6 ! root 1531: err = bdrv_co_flush(s->extents[i].file);
1.1.1.5 root 1532: if (err < 0) {
1533: ret = err;
1534: }
1535: }
1536: return ret;
1.1 root 1537: }
1538:
1.1.1.5 root 1539: static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
1540: {
1541: int i;
1542: int64_t ret = 0;
1543: int64_t r;
1544: BDRVVmdkState *s = bs->opaque;
1545:
1546: ret = bdrv_get_allocated_file_size(bs->file);
1547: if (ret < 0) {
1548: return ret;
1549: }
1550: for (i = 0; i < s->num_extents; i++) {
1551: if (s->extents[i].file == bs->file) {
1552: continue;
1553: }
1554: r = bdrv_get_allocated_file_size(s->extents[i].file);
1555: if (r < 0) {
1556: return r;
1557: }
1558: ret += r;
1559: }
1560: return ret;
1561: }
1.1 root 1562:
1563: static QEMUOptionParameter vmdk_create_options[] = {
1564: {
1565: .name = BLOCK_OPT_SIZE,
1566: .type = OPT_SIZE,
1567: .help = "Virtual disk size"
1568: },
1569: {
1570: .name = BLOCK_OPT_BACKING_FILE,
1571: .type = OPT_STRING,
1572: .help = "File name of a base image"
1573: },
1574: {
1575: .name = BLOCK_OPT_COMPAT6,
1576: .type = OPT_FLAG,
1577: .help = "VMDK version 6 image"
1578: },
1.1.1.5 root 1579: {
1580: .name = BLOCK_OPT_SUBFMT,
1581: .type = OPT_STRING,
1582: .help =
1583: "VMDK flat extent format, can be one of "
1.1.1.6 ! root 1584: "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
1.1.1.5 root 1585: },
1.1 root 1586: { NULL }
1587: };
1588:
1589: static BlockDriver bdrv_vmdk = {
1.1.1.5 root 1590: .format_name = "vmdk",
1591: .instance_size = sizeof(BDRVVmdkState),
1592: .bdrv_probe = vmdk_probe,
1.1.1.3 root 1593: .bdrv_open = vmdk_open,
1.1.1.6 ! root 1594: .bdrv_read = vmdk_co_read,
! 1595: .bdrv_write = vmdk_co_write,
1.1.1.5 root 1596: .bdrv_close = vmdk_close,
1597: .bdrv_create = vmdk_create,
1.1.1.6 ! root 1598: .bdrv_co_flush_to_disk = vmdk_co_flush,
! 1599: .bdrv_is_allocated = vmdk_is_allocated,
1.1.1.5 root 1600: .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
1.1 root 1601:
1602: .create_options = vmdk_create_options,
1603: };
1604:
1605: static void bdrv_vmdk_init(void)
1606: {
1607: bdrv_register(&bdrv_vmdk);
1608: }
1609:
1610: block_init(bdrv_vmdk_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.