?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdbstub: Fix qOffsets packet detection
[qemu/qmp-unstable.git] / block / vmdk.c
blobb66745dfdd9594ce91d835b7180dedc68470ce8f
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/block_int.h"
28 #include "qemu/module.h"
29 #include "migration/migration.h"
30 #include <zlib.h>
31 #include <glib.h>
32
33 #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
34 #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
35 #define VMDK4_COMPRESSION_DEFLATE 1
36 #define VMDK4_FLAG_NL_DETECT (1 << 0)
37 #define VMDK4_FLAG_RGD (1 << 1)
38 /* Zeroed-grain enable bit */
39 #define VMDK4_FLAG_ZERO_GRAIN (1 << 2)
40 #define VMDK4_FLAG_COMPRESS (1 << 16)
41 #define VMDK4_FLAG_MARKER (1 << 17)
42 #define VMDK4_GD_AT_END 0xffffffffffffffffULL
43
44 #define VMDK_GTE_ZEROED 0x1
45
46 /* VMDK internal error codes */
47 #define VMDK_OK 0
48 #define VMDK_ERROR (-1)
49 /* Cluster not allocated */
50 #define VMDK_UNALLOC (-2)
51 #define VMDK_ZEROED (-3)
52
53 #define BLOCK_OPT_ZEROED_GRAIN "zeroed_grain"
54
55 typedef struct {
56 uint32_t version;
57 uint32_t flags;
58 uint32_t disk_sectors;
59 uint32_t granularity;
60 uint32_t l1dir_offset;
61 uint32_t l1dir_size;
62 uint32_t file_sectors;
63 uint32_t cylinders;
64 uint32_t heads;
65 uint32_t sectors_per_track;
66 } QEMU_PACKED VMDK3Header;
67
68 typedef struct {
69 uint32_t version;
70 uint32_t flags;
71 uint64_t capacity;
72 uint64_t granularity;
73 uint64_t desc_offset;
74 uint64_t desc_size;
75 /* Number of GrainTableEntries per GrainTable */
76 uint32_t num_gtes_per_gt;
77 uint64_t rgd_offset;
78 uint64_t gd_offset;
79 uint64_t grain_offset;
80 char filler[1];
81 char check_bytes[4];
82 uint16_t compressAlgorithm;
83 } QEMU_PACKED VMDK4Header;
84
85 #define L2_CACHE_SIZE 16
86
87 typedef struct VmdkExtent {
88 BlockDriverState *file;
89 bool flat;
90 bool compressed;
91 bool has_marker;
92 bool has_zero_grain;
93 int version;
94 int64_t sectors;
95 int64_t end_sector;
96 int64_t flat_start_offset;
97 int64_t l1_table_offset;
98 int64_t l1_backup_table_offset;
99 uint32_t *l1_table;
100 uint32_t *l1_backup_table;
101 unsigned int l1_size;
102 uint32_t l1_entry_sectors;
103
104 unsigned int l2_size;
105 uint32_t *l2_cache;
106 uint32_t l2_cache_offsets[L2_CACHE_SIZE];
107 uint32_t l2_cache_counts[L2_CACHE_SIZE];
108
109 int64_t cluster_sectors;
110 int64_t next_cluster_sector;
111 char *type;
112 } VmdkExtent;
113
114 typedef struct BDRVVmdkState {
115 CoMutex lock;
116 uint64_t desc_offset;
117 bool cid_updated;
118 bool cid_checked;
119 uint32_t cid;
120 uint32_t parent_cid;
121 int num_extents;
122 /* Extent array with num_extents entries, ascend ordered by address */
123 VmdkExtent *extents;
124 Error *migration_blocker;
125 char *create_type;
126 } BDRVVmdkState;
127
128 typedef struct VmdkMetaData {
129 unsigned int l1_index;
130 unsigned int l2_index;
131 unsigned int l2_offset;
132 int valid;
133 uint32_t *l2_cache_entry;
134 } VmdkMetaData;
135
136 typedef struct VmdkGrainMarker {
137 uint64_t lba;
138 uint32_t size;
139 uint8_t data[0];
140 } QEMU_PACKED VmdkGrainMarker;
141
142 enum {
143 MARKER_END_OF_STREAM = 0,
144 MARKER_GRAIN_TABLE = 1,
145 MARKER_GRAIN_DIRECTORY = 2,
146 MARKER_FOOTER = 3,
147 };
148
149 static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename)
150 {
151 uint32_t magic;
152
153 if (buf_size < 4) {
154 return 0;
155 }
156 magic = be32_to_cpu(*(uint32_t *)buf);
157 if (magic == VMDK3_MAGIC ||
158 magic == VMDK4_MAGIC) {
159 return 100;
160 } else {
161 const char *p = (const char *)buf;
162 const char *end = p + buf_size;
163 while (p < end) {
164 if (*p == '#') {
165 /* skip comment line */
166 while (p < end && *p != '\n') {
167 p++;
168 }
169 p++;
170 continue;
171 }
172 if (*p == ' ') {
173 while (p < end && *p == ' ') {
174 p++;
175 }
176 /* skip '\r' if windows line endings used. */
177 if (p < end && *p == '\r') {
178 p++;
179 }
180 /* only accept blank lines before 'version=' line */
181 if (p == end || *p != '\n') {
182 return 0;
183 }
184 p++;
185 continue;
186 }
187 if (end - p >= strlen("version=X\n")) {
188 if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 ||
189 strncmp("version=2\n", p, strlen("version=2\n")) == 0) {
190 return 100;
191 }
192 }
193 if (end - p >= strlen("version=X\r\n")) {
194 if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 ||
195 strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) {
196 return 100;
197 }
198 }
199 return 0;
200 }
201 return 0;
202 }
203 }
204
205 #define SECTOR_SIZE 512
206 #define DESC_SIZE (20 * SECTOR_SIZE) /* 20 sectors of 512 bytes each */
207 #define BUF_SIZE 4096
208 #define HEADER_SIZE 512 /* first sector of 512 bytes */
209
210 static void vmdk_free_extents(BlockDriverState *bs)
211 {
212 int i;
213 BDRVVmdkState *s = bs->opaque;
214 VmdkExtent *e;
215
216 for (i = 0; i < s->num_extents; i++) {
217 e = &s->extents[i];
218 g_free(e->l1_table);
219 g_free(e->l2_cache);
220 g_free(e->l1_backup_table);
221 g_free(e->type);
222 if (e->file != bs->file) {
223 bdrv_unref(e->file);
224 }
225 }
226 g_free(s->extents);
227 }
228
229 static void vmdk_free_last_extent(BlockDriverState *bs)
230 {
231 BDRVVmdkState *s = bs->opaque;
232
233 if (s->num_extents == 0) {
234 return;
235 }
236 s->num_extents--;
237 s->extents = g_renew(VmdkExtent, s->extents, s->num_extents);
238 }
239
240 static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent)
241 {
242 char desc[DESC_SIZE];
243 uint32_t cid = 0xffffffff;
244 const char *p_name, *cid_str;
245 size_t cid_str_size;
246 BDRVVmdkState *s = bs->opaque;
247 int ret;
248
249 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
250 if (ret < 0) {
251 return 0;
252 }
253
254 if (parent) {
255 cid_str = "parentCID";
256 cid_str_size = sizeof("parentCID");
257 } else {
258 cid_str = "CID";
259 cid_str_size = sizeof("CID");
260 }
261
262 desc[DESC_SIZE - 1] = '\0';
263 p_name = strstr(desc, cid_str);
264 if (p_name != NULL) {
265 p_name += cid_str_size;
266 sscanf(p_name, "%" SCNx32, &cid);
267 }
268
269 return cid;
270 }
271
272 static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
273 {
274 char desc[DESC_SIZE], tmp_desc[DESC_SIZE];
275 char *p_name, *tmp_str;
276 BDRVVmdkState *s = bs->opaque;
277 int ret;
278
279 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
280 if (ret < 0) {
281 return ret;
282 }
283
284 desc[DESC_SIZE - 1] = '\0';
285 tmp_str = strstr(desc, "parentCID");
286 if (tmp_str == NULL) {
287 return -EINVAL;
288 }
289
290 pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);
291 p_name = strstr(desc, "CID");
292 if (p_name != NULL) {
293 p_name += sizeof("CID");
294 snprintf(p_name, sizeof(desc) - (p_name - desc), "%" PRIx32 "\n", cid);
295 pstrcat(desc, sizeof(desc), tmp_desc);
296 }
297
298 ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
299 if (ret < 0) {
300 return ret;
301 }
302
303 return 0;
304 }
305
306 static int vmdk_is_cid_valid(BlockDriverState *bs)
307 {
308 BDRVVmdkState *s = bs->opaque;
309 BlockDriverState *p_bs = bs->backing_hd;
310 uint32_t cur_pcid;
311
312 if (!s->cid_checked && p_bs) {
313 cur_pcid = vmdk_read_cid(p_bs, 0);
314 if (s->parent_cid != cur_pcid) {
315 /* CID not valid */
316 return 0;
317 }
318 }
319 s->cid_checked = true;
320 /* CID valid */
321 return 1;
322 }
323
324 /* Queue extents, if any, for reopen() */
325 static int vmdk_reopen_prepare(BDRVReopenState *state,
326 BlockReopenQueue *queue, Error **errp)
327 {
328 BDRVVmdkState *s;
329 int ret = -1;
330 int i;
331 VmdkExtent *e;
332
333 assert(state != NULL);
334 assert(state->bs != NULL);
335
336 if (queue == NULL) {
337 error_setg(errp, "No reopen queue for VMDK extents");
338 goto exit;
339 }
340
341 s = state->bs->opaque;
342
343 assert(s != NULL);
344
345 for (i = 0; i < s->num_extents; i++) {
346 e = &s->extents[i];
347 if (e->file != state->bs->file) {
348 bdrv_reopen_queue(queue, e->file, state->flags);
349 }
350 }
351 ret = 0;
352
353 exit:
354 return ret;
355 }
356
357 static int vmdk_parent_open(BlockDriverState *bs)
358 {
359 char *p_name;
360 char desc[DESC_SIZE + 1];
361 BDRVVmdkState *s = bs->opaque;
362 int ret;
363
364 desc[DESC_SIZE] = '\0';
365 ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
366 if (ret < 0) {
367 return ret;
368 }
369
370 p_name = strstr(desc, "parentFileNameHint");
371 if (p_name != NULL) {
372 char *end_name;
373
374 p_name += sizeof("parentFileNameHint") + 1;
375 end_name = strchr(p_name, '\"');
376 if (end_name == NULL) {
377 return -EINVAL;
378 }
379 if ((end_name - p_name) > sizeof(bs->backing_file) - 1) {
380 return -EINVAL;
381 }
382
383 pstrcpy(bs->backing_file, end_name - p_name + 1, p_name);
384 }
385
386 return 0;
387 }
388
389 /* Create and append extent to the extent array. Return the added VmdkExtent
390 * address. return NULL if allocation failed. */
391 static int vmdk_add_extent(BlockDriverState *bs,
392 BlockDriverState *file, bool flat, int64_t sectors,
393 int64_t l1_offset, int64_t l1_backup_offset,
394 uint32_t l1_size,
395 int l2_size, uint64_t cluster_sectors,
396 VmdkExtent **new_extent,
397 Error **errp)
398 {
399 VmdkExtent *extent;
400 BDRVVmdkState *s = bs->opaque;
401 int64_t nb_sectors;
402
403 if (cluster_sectors > 0x200000) {
404 /* 0x200000 * 512Bytes = 1GB for one cluster is unrealistic */
405 error_setg(errp, "Invalid granularity, image may be corrupt");
406 return -EFBIG;
407 }
408 if (l1_size > 512 * 1024 * 1024) {
409 /* Although with big capacity and small l1_entry_sectors, we can get a
410 * big l1_size, we don't want unbounded value to allocate the table.
411 * Limit it to 512M, which is 16PB for default cluster and L2 table
412 * size */
413 error_setg(errp, "L1 size too big");
414 return -EFBIG;
415 }
416
417 nb_sectors = bdrv_nb_sectors(file);
418 if (nb_sectors < 0) {
419 return nb_sectors;
420 }
421
422 s->extents = g_renew(VmdkExtent, s->extents, s->num_extents + 1);
423 extent = &s->extents[s->num_extents];
424 s->num_extents++;
425
426 memset(extent, 0, sizeof(VmdkExtent));
427 extent->file = file;
428 extent->flat = flat;
429 extent->sectors = sectors;
430 extent->l1_table_offset = l1_offset;
431 extent->l1_backup_table_offset = l1_backup_offset;
432 extent->l1_size = l1_size;
433 extent->l1_entry_sectors = l2_size * cluster_sectors;
434 extent->l2_size = l2_size;
435 extent->cluster_sectors = flat ? sectors : cluster_sectors;
436 extent->next_cluster_sector = ROUND_UP(nb_sectors, cluster_sectors);
437
438 if (s->num_extents > 1) {
439 extent->end_sector = (*(extent - 1)).end_sector + extent->sectors;
440 } else {
441 extent->end_sector = extent->sectors;
442 }
443 bs->total_sectors = extent->end_sector;
444 if (new_extent) {
445 *new_extent = extent;
446 }
447 return 0;
448 }
449
450 static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
451 Error **errp)
452 {
453 int ret;
454 size_t l1_size;
455 int i;
456
457 /* read the L1 table */
458 l1_size = extent->l1_size * sizeof(uint32_t);
459 extent->l1_table = g_try_malloc(l1_size);
460 if (l1_size && extent->l1_table == NULL) {
461 return -ENOMEM;
462 }
463
464 ret = bdrv_pread(extent->file,
465 extent->l1_table_offset,
466 extent->l1_table,
467 l1_size);
468 if (ret < 0) {
469 error_setg_errno(errp, -ret,
470 "Could not read l1 table from extent '%s'",
471 extent->file->filename);
472 goto fail_l1;
473 }
474 for (i = 0; i < extent->l1_size; i++) {
475 le32_to_cpus(&extent->l1_table[i]);
476 }
477
478 if (extent->l1_backup_table_offset) {
479 extent->l1_backup_table = g_try_malloc(l1_size);
480 if (l1_size && extent->l1_backup_table == NULL) {
481 ret = -ENOMEM;
482 goto fail_l1;
483 }
484 ret = bdrv_pread(extent->file,
485 extent->l1_backup_table_offset,
486 extent->l1_backup_table,
487 l1_size);
488 if (ret < 0) {
489 error_setg_errno(errp, -ret,
490 "Could not read l1 backup table from extent '%s'",
491 extent->file->filename);
492 goto fail_l1b;
493 }
494 for (i = 0; i < extent->l1_size; i++) {
495 le32_to_cpus(&extent->l1_backup_table[i]);
496 }
497 }
498
499 extent->l2_cache =
500 g_new(uint32_t, extent->l2_size * L2_CACHE_SIZE);
501 return 0;
502 fail_l1b:
503 g_free(extent->l1_backup_table);
504 fail_l1:
505 g_free(extent->l1_table);
506 return ret;
507 }
508
509 static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
510 BlockDriverState *file,
511 int flags, Error **errp)
512 {
513 int ret;
514 uint32_t magic;
515 VMDK3Header header;
516 VmdkExtent *extent;
517
518 ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
519 if (ret < 0) {
520 error_setg_errno(errp, -ret,
521 "Could not read header from file '%s'",
522 file->filename);
523 return ret;
524 }
525 ret = vmdk_add_extent(bs, file, false,
526 le32_to_cpu(header.disk_sectors),
527 (int64_t)le32_to_cpu(header.l1dir_offset) << 9,
528 0,
529 le32_to_cpu(header.l1dir_size),
530 4096,
531 le32_to_cpu(header.granularity),
532 &extent,
533 errp);
534 if (ret < 0) {
535 return ret;
536 }
537 ret = vmdk_init_tables(bs, extent, errp);
538 if (ret) {
539 /* free extent allocated by vmdk_add_extent */
540 vmdk_free_last_extent(bs);
541 }
542 return ret;
543 }
544
545 static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
546 Error **errp);
547
548 static char *vmdk_read_desc(BlockDriverState *file, uint64_t desc_offset,
549 Error **errp)
550 {
551 int64_t size;
552 char *buf;
553 int ret;
554
555 size = bdrv_getlength(file);
556 if (size < 0) {
557 error_setg_errno(errp, -size, "Could not access file");
558 return NULL;
559 }
560
561 if (size < 4) {
562 /* Both descriptor file and sparse image must be much larger than 4
563 * bytes, also callers of vmdk_read_desc want to compare the first 4
564 * bytes with VMDK4_MAGIC, let's error out if less is read. */
565 error_setg(errp, "File is too small, not a valid image");
566 return NULL;
567 }
568
569 size = MIN(size, (1 << 20) - 1); /* avoid unbounded allocation */
570 buf = g_malloc(size + 1);
571
572 ret = bdrv_pread(file, desc_offset, buf, size);
573 if (ret < 0) {
574 error_setg_errno(errp, -ret, "Could not read from file");
575 g_free(buf);
576 return NULL;
577 }
578 buf[ret] = 0;
579
580 return buf;
581 }
582
583 static int vmdk_open_vmdk4(BlockDriverState *bs,
584 BlockDriverState *file,
585 int flags, Error **errp)
586 {
587 int ret;
588 uint32_t magic;
589 uint32_t l1_size, l1_entry_sectors;
590 VMDK4Header header;
591 VmdkExtent *extent;
592 BDRVVmdkState *s = bs->opaque;
593 int64_t l1_backup_offset = 0;
594
595 ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
596 if (ret < 0) {
597 error_setg_errno(errp, -ret,
598 "Could not read header from file '%s'",
599 file->filename);
600 return -EINVAL;
601 }
602 if (header.capacity == 0) {
603 uint64_t desc_offset = le64_to_cpu(header.desc_offset);
604 if (desc_offset) {
605 char *buf = vmdk_read_desc(file, desc_offset << 9, errp);
606 if (!buf) {
607 return -EINVAL;
608 }
609 ret = vmdk_open_desc_file(bs, flags, buf, errp);
610 g_free(buf);
611 return ret;
612 }
613 }
614
615 if (!s->create_type) {
616 s->create_type = g_strdup("monolithicSparse");
617 }
618
619 if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {
620 /*
621 * The footer takes precedence over the header, so read it in. The
622 * footer starts at offset -1024 from the end: One sector for the
623 * footer, and another one for the end-of-stream marker.
624 */
625 struct {
626 struct {
627 uint64_t val;
628 uint32_t size;
629 uint32_t type;
630 uint8_t pad[512 - 16];
631 } QEMU_PACKED footer_marker;
632
633 uint32_t magic;
634 VMDK4Header header;
635 uint8_t pad[512 - 4 - sizeof(VMDK4Header)];
636
637 struct {
638 uint64_t val;
639 uint32_t size;
640 uint32_t type;
641 uint8_t pad[512 - 16];
642 } QEMU_PACKED eos_marker;
643 } QEMU_PACKED footer;
644
645 ret = bdrv_pread(file,
646 bs->file->total_sectors * 512 - 1536,
647 &footer, sizeof(footer));
648 if (ret < 0) {
649 error_setg_errno(errp, -ret, "Failed to read footer");
650 return ret;
651 }
652
653 /* Some sanity checks for the footer */
654 if (be32_to_cpu(footer.magic) != VMDK4_MAGIC ||
655 le32_to_cpu(footer.footer_marker.size) != 0 ||
656 le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER ||
657 le64_to_cpu(footer.eos_marker.val) != 0 ||
658 le32_to_cpu(footer.eos_marker.size) != 0 ||
659 le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM)
660 {
661 error_setg(errp, "Invalid footer");
662 return -EINVAL;
663 }
664
665 header = footer.header;
666 }
667
668 if (le32_to_cpu(header.version) > 3) {
669 char buf[64];
670 snprintf(buf, sizeof(buf), "VMDK version %" PRId32,
671 le32_to_cpu(header.version));
672 error_set(errp, QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
673 bdrv_get_device_or_node_name(bs), "vmdk", buf);
674 return -ENOTSUP;
675 } else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) {
676 /* VMware KB 2064959 explains that version 3 added support for
677 * persistent changed block tracking (CBT), and backup software can
678 * read it as version=1 if it doesn't care about the changed area
679 * information. So we are safe to enable read only. */
680 error_setg(errp, "VMDK version 3 must be read only");
681 return -EINVAL;
682 }
683
684 if (le32_to_cpu(header.num_gtes_per_gt) > 512) {
685 error_setg(errp, "L2 table size too big");
686 return -EINVAL;
687 }
688
689 l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)
690 * le64_to_cpu(header.granularity);
691 if (l1_entry_sectors == 0) {
692 error_setg(errp, "L1 entry size is invalid");
693 return -EINVAL;
694 }
695 l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
696 / l1_entry_sectors;
697 if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
698 l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
699 }
700 if (bdrv_nb_sectors(file) < le64_to_cpu(header.grain_offset)) {
701 error_setg(errp, "File truncated, expecting at least %" PRId64 " bytes",
702 (int64_t)(le64_to_cpu(header.grain_offset)
703 * BDRV_SECTOR_SIZE));
704 return -EINVAL;
705 }
706
707 ret = vmdk_add_extent(bs, file, false,
708 le64_to_cpu(header.capacity),
709 le64_to_cpu(header.gd_offset) << 9,
710 l1_backup_offset,
711 l1_size,
712 le32_to_cpu(header.num_gtes_per_gt),
713 le64_to_cpu(header.granularity),
714 &extent,
715 errp);
716 if (ret < 0) {
717 return ret;
718 }
719 extent->compressed =
720 le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
721 if (extent->compressed) {
722 g_free(s->create_type);
723 s->create_type = g_strdup("streamOptimized");
724 }
725 extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
726 extent->version = le32_to_cpu(header.version);
727 extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN;
728 ret = vmdk_init_tables(bs, extent, errp);
729 if (ret) {
730 /* free extent allocated by vmdk_add_extent */
731 vmdk_free_last_extent(bs);
732 }
733 return ret;
734 }
735
736 /* find an option value out of descriptor file */
737 static int vmdk_parse_description(const char *desc, const char *opt_name,
738 char *buf, int buf_size)
739 {
740 char *opt_pos, *opt_end;
741 const char *end = desc + strlen(desc);
742
743 opt_pos = strstr(desc, opt_name);
744 if (!opt_pos) {
745 return VMDK_ERROR;
746 }
747 /* Skip "=\"" following opt_name */
748 opt_pos += strlen(opt_name) + 2;
749 if (opt_pos >= end) {
750 return VMDK_ERROR;
751 }
752 opt_end = opt_pos;
753 while (opt_end < end && *opt_end != '"') {
754 opt_end++;
755 }
756 if (opt_end == end || buf_size < opt_end - opt_pos + 1) {
757 return VMDK_ERROR;
758 }
759 pstrcpy(buf, opt_end - opt_pos + 1, opt_pos);
760 return VMDK_OK;
761 }
762
763 /* Open an extent file and append to bs array */
764 static int vmdk_open_sparse(BlockDriverState *bs,
765 BlockDriverState *file, int flags,
766 char *buf, Error **errp)
767 {
768 uint32_t magic;
769
770 magic = ldl_be_p(buf);
771 switch (magic) {
772 case VMDK3_MAGIC:
773 return vmdk_open_vmfs_sparse(bs, file, flags, errp);
774 break;
775 case VMDK4_MAGIC:
776 return vmdk_open_vmdk4(bs, file, flags, errp);
777 break;
778 default:
779 error_setg(errp, "Image not in VMDK format");
780 return -EINVAL;
781 break;
782 }
783 }
784
785 static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
786 const char *desc_file_path, Error **errp)
787 {
788 int ret;
789 int matches;
790 char access[11];
791 char type[11];
792 char fname[512];
793 const char *p = desc;
794 int64_t sectors = 0;
795 int64_t flat_offset;
796 char *extent_path;
797 BlockDriverState *extent_file;
798 BDRVVmdkState *s = bs->opaque;
799 VmdkExtent *extent;
800
801 while (*p) {
802 /* parse extent line in one of below formats:
803 *
804 * RW [size in sectors] FLAT "file-name.vmdk" OFFSET
805 * RW [size in sectors] SPARSE "file-name.vmdk"
806 * RW [size in sectors] VMFS "file-name.vmdk"
807 * RW [size in sectors] VMFSSPARSE "file-name.vmdk"
808 */
809 flat_offset = -1;
810 matches = sscanf(p, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64,
811 access, &sectors, type, fname, &flat_offset);
812 if (matches < 4 || strcmp(access, "RW")) {
813 goto next_line;
814 } else if (!strcmp(type, "FLAT")) {
815 if (matches != 5 || flat_offset < 0) {
816 error_setg(errp, "Invalid extent lines: \n%s", p);
817 return -EINVAL;
818 }
819 } else if (!strcmp(type, "VMFS")) {
820 if (matches == 4) {
821 flat_offset = 0;
822 } else {
823 error_setg(errp, "Invalid extent lines:\n%s", p);
824 return -EINVAL;
825 }
826 } else if (matches != 4) {
827 error_setg(errp, "Invalid extent lines:\n%s", p);
828 return -EINVAL;
829 }
830
831 if (sectors <= 0 ||
832 (strcmp(type, "FLAT") && strcmp(type, "SPARSE") &&
833 strcmp(type, "VMFS") && strcmp(type, "VMFSSPARSE")) ||
834 (strcmp(access, "RW"))) {
835 goto next_line;
836 }
837
838 if (!path_is_absolute(fname) && !path_has_protocol(fname) &&
839 !desc_file_path[0])
840 {
841 error_setg(errp, "Cannot use relative extent paths with VMDK "
842 "descriptor file '%s'", bs->file->filename);
843 return -EINVAL;
844 }
845
846 extent_path = g_malloc0(PATH_MAX);
847 path_combine(extent_path, PATH_MAX, desc_file_path, fname);
848 extent_file = NULL;
849 ret = bdrv_open(&extent_file, extent_path, NULL, NULL,
850 bs->open_flags | BDRV_O_PROTOCOL, NULL, errp);
851 g_free(extent_path);
852 if (ret) {
853 return ret;
854 }
855
856 /* save to extents array */
857 if (!strcmp(type, "FLAT") || !strcmp(type, "VMFS")) {
858 /* FLAT extent */
859
860 ret = vmdk_add_extent(bs, extent_file, true, sectors,
861 0, 0, 0, 0, 0, &extent, errp);
862 if (ret < 0) {
863 bdrv_unref(extent_file);
864 return ret;
865 }
866 extent->flat_start_offset = flat_offset << 9;
867 } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
868 /* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/
869 char *buf = vmdk_read_desc(extent_file, 0, errp);
870 if (!buf) {
871 ret = -EINVAL;
872 } else {
873 ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, buf, errp);
874 }
875 g_free(buf);
876 if (ret) {
877 bdrv_unref(extent_file);
878 return ret;
879 }
880 extent = &s->extents[s->num_extents - 1];
881 } else {
882 error_setg(errp, "Unsupported extent type '%s'", type);
883 bdrv_unref(extent_file);
884 return -ENOTSUP;
885 }
886 extent->type = g_strdup(type);
887 next_line:
888 /* move to next line */
889 while (*p) {
890 if (*p == '\n') {
891 p++;
892 break;
893 }
894 p++;
895 }
896 }
897 return 0;
898 }
899
900 static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
901 Error **errp)
902 {
903 int ret;
904 char ct[128];
905 BDRVVmdkState *s = bs->opaque;
906
907 if (vmdk_parse_description(buf, "createType", ct, sizeof(ct))) {
908 error_setg(errp, "invalid VMDK image descriptor");
909 ret = -EINVAL;
910 goto exit;
911 }
912 if (strcmp(ct, "monolithicFlat") &&
913 strcmp(ct, "vmfs") &&
914 strcmp(ct, "vmfsSparse") &&
915 strcmp(ct, "twoGbMaxExtentSparse") &&
916 strcmp(ct, "twoGbMaxExtentFlat")) {
917 error_setg(errp, "Unsupported image type '%s'", ct);
918 ret = -ENOTSUP;
919 goto exit;
920 }
921 s->create_type = g_strdup(ct);
922 s->desc_offset = 0;
923 ret = vmdk_parse_extents(buf, bs, bs->file->exact_filename, errp);
924 exit:
925 return ret;
926 }
927
928 static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
929 Error **errp)
930 {
931 char *buf;
932 int ret;
933 BDRVVmdkState *s = bs->opaque;
934 uint32_t magic;
935
936 buf = vmdk_read_desc(bs->file, 0, errp);
937 if (!buf) {
938 return -EINVAL;
939 }
940
941 magic = ldl_be_p(buf);
942 switch (magic) {
943 case VMDK3_MAGIC:
944 case VMDK4_MAGIC:
945 ret = vmdk_open_sparse(bs, bs->file, flags, buf, errp);
946 s->desc_offset = 0x200;
947 break;
948 default:
949 ret = vmdk_open_desc_file(bs, flags, buf, errp);
950 break;
951 }
952 if (ret) {
953 goto fail;
954 }
955
956 /* try to open parent images, if exist */
957 ret = vmdk_parent_open(bs);
958 if (ret) {
959 goto fail;
960 }
961 s->cid = vmdk_read_cid(bs, 0);
962 s->parent_cid = vmdk_read_cid(bs, 1);
963 qemu_co_mutex_init(&s->lock);
964
965 /* Disable migration when VMDK images are used */
966 error_setg(&s->migration_blocker, "The vmdk format used by node '%s' "
967 "does not support live migration",
968 bdrv_get_device_or_node_name(bs));
969 migrate_add_blocker(s->migration_blocker);
970 g_free(buf);
971 return 0;
972
973 fail:
974 g_free(buf);
975 g_free(s->create_type);
976 s->create_type = NULL;
977 vmdk_free_extents(bs);
978 return ret;
979 }
980
981
982 static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp)
983 {
984 BDRVVmdkState *s = bs->opaque;
985 int i;
986
987 for (i = 0; i < s->num_extents; i++) {
988 if (!s->extents[i].flat) {
989 bs->bl.write_zeroes_alignment =
990 MAX(bs->bl.write_zeroes_alignment,
991 s->extents[i].cluster_sectors);
992 }
993 }
994 }
995
996 /**
997 * get_whole_cluster
998 *
999 * Copy backing file's cluster that covers @sector_num, otherwise write zero,
1000 * to the cluster at @cluster_sector_num.
1001 *
1002 * If @skip_start_sector < @skip_end_sector, the relative range
1003 * [@skip_start_sector, @skip_end_sector) is not copied or written, and leave
1004 * it for call to write user data in the request.
1005 */
1006 static int get_whole_cluster(BlockDriverState *bs,
1007 VmdkExtent *extent,
1008 uint64_t cluster_sector_num,
1009 uint64_t sector_num,
1010 uint64_t skip_start_sector,
1011 uint64_t skip_end_sector)
1012 {
1013 int ret = VMDK_OK;
1014 int64_t cluster_bytes;
1015 uint8_t *whole_grain;
1016
1017 /* For COW, align request sector_num to cluster start */
1018 sector_num = QEMU_ALIGN_DOWN(sector_num, extent->cluster_sectors);
1019 cluster_bytes = extent->cluster_sectors << BDRV_SECTOR_BITS;
1020 whole_grain = qemu_blockalign(bs, cluster_bytes);
1021
1022 if (!bs->backing_hd) {
1023 memset(whole_grain, 0, skip_start_sector << BDRV_SECTOR_BITS);
1024 memset(whole_grain + (skip_end_sector << BDRV_SECTOR_BITS), 0,
1025 cluster_bytes - (skip_end_sector << BDRV_SECTOR_BITS));
1026 }
1027
1028 assert(skip_end_sector <= extent->cluster_sectors);
1029 /* we will be here if it's first write on non-exist grain(cluster).
1030 * try to read from parent image, if exist */
1031 if (bs->backing_hd && !vmdk_is_cid_valid(bs)) {
1032 ret = VMDK_ERROR;
1033 goto exit;
1034 }
1035
1036 /* Read backing data before skip range */
1037 if (skip_start_sector > 0) {
1038 if (bs->backing_hd) {
1039 ret = bdrv_read(bs->backing_hd, sector_num,
1040 whole_grain, skip_start_sector);
1041 if (ret < 0) {
1042 ret = VMDK_ERROR;
1043 goto exit;
1044 }
1045 }
1046 ret = bdrv_write(extent->file, cluster_sector_num, whole_grain,
1047 skip_start_sector);
1048 if (ret < 0) {
1049 ret = VMDK_ERROR;
1050 goto exit;
1051 }
1052 }
1053 /* Read backing data after skip range */
1054 if (skip_end_sector < extent->cluster_sectors) {
1055 if (bs->backing_hd) {
1056 ret = bdrv_read(bs->backing_hd, sector_num + skip_end_sector,
1057 whole_grain + (skip_end_sector << BDRV_SECTOR_BITS),
1058 extent->cluster_sectors - skip_end_sector);
1059 if (ret < 0) {
1060 ret = VMDK_ERROR;
1061 goto exit;
1062 }
1063 }
1064 ret = bdrv_write(extent->file, cluster_sector_num + skip_end_sector,
1065 whole_grain + (skip_end_sector << BDRV_SECTOR_BITS),
1066 extent->cluster_sectors - skip_end_sector);
1067 if (ret < 0) {
1068 ret = VMDK_ERROR;
1069 goto exit;
1070 }
1071 }
1072
1073 exit:
1074 qemu_vfree(whole_grain);
1075 return ret;
1076 }
1077
1078 static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
1079 uint32_t offset)
1080 {
1081 offset = cpu_to_le32(offset);
1082 /* update L2 table */
1083 if (bdrv_pwrite_sync(
1084 extent->file,
1085 ((int64_t)m_data->l2_offset * 512)
1086 + (m_data->l2_index * sizeof(offset)),
1087 &offset, sizeof(offset)) < 0) {
1088 return VMDK_ERROR;
1089 }
1090 /* update backup L2 table */
1091 if (extent->l1_backup_table_offset != 0) {
1092 m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
1093 if (bdrv_pwrite_sync(
1094 extent->file,
1095 ((int64_t)m_data->l2_offset * 512)
1096 + (m_data->l2_index * sizeof(offset)),
1097 &offset, sizeof(offset)) < 0) {
1098 return VMDK_ERROR;
1099 }
1100 }
1101 if (m_data->l2_cache_entry) {
1102 *m_data->l2_cache_entry = offset;
1103 }
1104
1105 return VMDK_OK;
1106 }
1107
1108 /**
1109 * get_cluster_offset
1110 *
1111 * Look up cluster offset in extent file by sector number, and store in
1112 * @cluster_offset.
1113 *
1114 * For flat extents, the start offset as parsed from the description file is
1115 * returned.
1116 *
1117 * For sparse extents, look up in L1, L2 table. If allocate is true, return an
1118 * offset for a new cluster and update L2 cache. If there is a backing file,
1119 * COW is done before returning; otherwise, zeroes are written to the allocated
1120 * cluster. Both COW and zero writing skips the sector range
1121 * [@skip_start_sector, @skip_end_sector) passed in by caller, because caller
1122 * has new data to write there.
1123 *
1124 * Returns: VMDK_OK if cluster exists and mapped in the image.
1125 * VMDK_UNALLOC if cluster is not mapped and @allocate is false.
1126 * VMDK_ERROR if failed.
1127 */
1128 static int get_cluster_offset(BlockDriverState *bs,
1129 VmdkExtent *extent,
1130 VmdkMetaData *m_data,
1131 uint64_t offset,
1132 bool allocate,
1133 uint64_t *cluster_offset,
1134 uint64_t skip_start_sector,
1135 uint64_t skip_end_sector)
1136 {
1137 unsigned int l1_index, l2_offset, l2_index;
1138 int min_index, i, j;
1139 uint32_t min_count, *l2_table;
1140 bool zeroed = false;
1141 int64_t ret;
1142 int64_t cluster_sector;
1143
1144 if (m_data) {
1145 m_data->valid = 0;
1146 }
1147 if (extent->flat) {
1148 *cluster_offset = extent->flat_start_offset;
1149 return VMDK_OK;
1150 }
1151
1152 offset -= (extent->end_sector - extent->sectors) * SECTOR_SIZE;
1153 l1_index = (offset >> 9) / extent->l1_entry_sectors;
1154 if (l1_index >= extent->l1_size) {
1155 return VMDK_ERROR;
1156 }
1157 l2_offset = extent->l1_table[l1_index];
1158 if (!l2_offset) {
1159 return VMDK_UNALLOC;
1160 }
1161 for (i = 0; i < L2_CACHE_SIZE; i++) {
1162 if (l2_offset == extent->l2_cache_offsets[i]) {
1163 /* increment the hit count */
1164 if (++extent->l2_cache_counts[i] == 0xffffffff) {
1165 for (j = 0; j < L2_CACHE_SIZE; j++) {
1166 extent->l2_cache_counts[j] >>= 1;
1167 }
1168 }
1169 l2_table = extent->l2_cache + (i * extent->l2_size);
1170 goto found;
1171 }
1172 }
1173 /* not found: load a new entry in the least used one */
1174 min_index = 0;
1175 min_count = 0xffffffff;
1176 for (i = 0; i < L2_CACHE_SIZE; i++) {
1177 if (extent->l2_cache_counts[i] < min_count) {
1178 min_count = extent->l2_cache_counts[i];
1179 min_index = i;
1180 }
1181 }
1182 l2_table = extent->l2_cache + (min_index * extent->l2_size);
1183 if (bdrv_pread(
1184 extent->file,
1185 (int64_t)l2_offset * 512,
1186 l2_table,
1187 extent->l2_size * sizeof(uint32_t)
1188 ) != extent->l2_size * sizeof(uint32_t)) {
1189 return VMDK_ERROR;
1190 }
1191
1192 extent->l2_cache_offsets[min_index] = l2_offset;
1193 extent->l2_cache_counts[min_index] = 1;
1194 found:
1195 l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
1196 cluster_sector = le32_to_cpu(l2_table[l2_index]);
1197
1198 if (m_data) {
1199 m_data->valid = 1;
1200 m_data->l1_index = l1_index;
1201 m_data->l2_index = l2_index;
1202 m_data->l2_offset = l2_offset;
1203 m_data->l2_cache_entry = &l2_table[l2_index];
1204 }
1205 if (extent->has_zero_grain && cluster_sector == VMDK_GTE_ZEROED) {
1206 zeroed = true;
1207 }
1208
1209 if (!cluster_sector || zeroed) {
1210 if (!allocate) {
1211 return zeroed ? VMDK_ZEROED : VMDK_UNALLOC;
1212 }
1213
1214 cluster_sector = extent->next_cluster_sector;
1215 extent->next_cluster_sector += extent->cluster_sectors;
1216
1217 /* First of all we write grain itself, to avoid race condition
1218 * that may to corrupt the image.
1219 * This problem may occur because of insufficient space on host disk
1220 * or inappropriate VM shutdown.
1221 */
1222 ret = get_whole_cluster(bs, extent,
1223 cluster_sector,
1224 offset >> BDRV_SECTOR_BITS,
1225 skip_start_sector, skip_end_sector);
1226 if (ret) {
1227 return ret;
1228 }
1229 }
1230 *cluster_offset = cluster_sector << BDRV_SECTOR_BITS;
1231 return VMDK_OK;
1232 }
1233
1234 static VmdkExtent *find_extent(BDRVVmdkState *s,
1235 int64_t sector_num, VmdkExtent *start_hint)
1236 {
1237 VmdkExtent *extent = start_hint;
1238
1239 if (!extent) {
1240 extent = &s->extents[0];
1241 }
1242 while (extent < &s->extents[s->num_extents]) {
1243 if (sector_num < extent->end_sector) {
1244 return extent;
1245 }
1246 extent++;
1247 }
1248 return NULL;
1249 }
1250
1251 static int64_t coroutine_fn vmdk_co_get_block_status(BlockDriverState *bs,
1252 int64_t sector_num, int nb_sectors, int *pnum)
1253 {
1254 BDRVVmdkState *s = bs->opaque;
1255 int64_t index_in_cluster, n, ret;
1256 uint64_t offset;
1257 VmdkExtent *extent;
1258
1259 extent = find_extent(s, sector_num, NULL);
1260 if (!extent) {
1261 return 0;
1262 }
1263 qemu_co_mutex_lock(&s->lock);
1264 ret = get_cluster_offset(bs, extent, NULL,
1265 sector_num * 512, false, &offset,
1266 0, 0);
1267 qemu_co_mutex_unlock(&s->lock);
1268
1269 switch (ret) {
1270 case VMDK_ERROR:
1271 ret = -EIO;
1272 break;
1273 case VMDK_UNALLOC:
1274 ret = 0;
1275 break;
1276 case VMDK_ZEROED:
1277 ret = BDRV_BLOCK_ZERO;
1278 break;
1279 case VMDK_OK:
1280 ret = BDRV_BLOCK_DATA;
1281 if (extent->file == bs->file && !extent->compressed) {
1282 ret |= BDRV_BLOCK_OFFSET_VALID | offset;
1283 }
1284
1285 break;
1286 }
1287
1288 index_in_cluster = sector_num % extent->cluster_sectors;
1289 n = extent->cluster_sectors - index_in_cluster;
1290 if (n > nb_sectors) {
1291 n = nb_sectors;
1292 }
1293 *pnum = n;
1294 return ret;
1295 }
1296
1297 static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
1298 int64_t offset_in_cluster, const uint8_t *buf,
1299 int nb_sectors, int64_t sector_num)
1300 {
1301 int ret;
1302 VmdkGrainMarker *data = NULL;
1303 uLongf buf_len;
1304 const uint8_t *write_buf = buf;
1305 int write_len = nb_sectors * 512;
1306 int64_t write_offset;
1307 int64_t write_end_sector;
1308
1309 if (extent->compressed) {
1310 if (!extent->has_marker) {
1311 ret = -EINVAL;
1312 goto out;
1313 }
1314 buf_len = (extent->cluster_sectors << 9) * 2;
1315 data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
1316 if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
1317 buf_len == 0) {
1318 ret = -EINVAL;
1319 goto out;
1320 }
1321 data->lba = sector_num;
1322 data->size = buf_len;
1323 write_buf = (uint8_t *)data;
1324 write_len = buf_len + sizeof(VmdkGrainMarker);
1325 }
1326 write_offset = cluster_offset + offset_in_cluster,
1327 ret = bdrv_pwrite(extent->file, write_offset, write_buf, write_len);
1328
1329 write_end_sector = DIV_ROUND_UP(write_offset + write_len, BDRV_SECTOR_SIZE);
1330
1331 extent->next_cluster_sector = MAX(extent->next_cluster_sector,
1332 write_end_sector);
1333
1334 if (ret != write_len) {
1335 ret = ret < 0 ? ret : -EIO;
1336 goto out;
1337 }
1338 ret = 0;
1339 out:
1340 g_free(data);
1341 return ret;
1342 }
1343
1344 static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
1345 int64_t offset_in_cluster, uint8_t *buf,
1346 int nb_sectors)
1347 {
1348 int ret;
1349 int cluster_bytes, buf_bytes;
1350 uint8_t *cluster_buf, *compressed_data;
1351 uint8_t *uncomp_buf;
1352 uint32_t data_len;
1353 VmdkGrainMarker *marker;
1354 uLongf buf_len;
1355
1356
1357 if (!extent->compressed) {
1358 ret = bdrv_pread(extent->file,
1359 cluster_offset + offset_in_cluster,
1360 buf, nb_sectors * 512);
1361 if (ret == nb_sectors * 512) {
1362 return 0;
1363 } else {
1364 return -EIO;
1365 }
1366 }
1367 cluster_bytes = extent->cluster_sectors * 512;
1368 /* Read two clusters in case GrainMarker + compressed data > one cluster */
1369 buf_bytes = cluster_bytes * 2;
1370 cluster_buf = g_malloc(buf_bytes);
1371 uncomp_buf = g_malloc(cluster_bytes);
1372 ret = bdrv_pread(extent->file,
1373 cluster_offset,
1374 cluster_buf, buf_bytes);
1375 if (ret < 0) {
1376 goto out;
1377 }
1378 compressed_data = cluster_buf;
1379 buf_len = cluster_bytes;
1380 data_len = cluster_bytes;
1381 if (extent->has_marker) {
1382 marker = (VmdkGrainMarker *)cluster_buf;
1383 compressed_data = marker->data;
1384 data_len = le32_to_cpu(marker->size);
1385 }
1386 if (!data_len || data_len > buf_bytes) {
1387 ret = -EINVAL;
1388 goto out;
1389 }
1390 ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
1391 if (ret != Z_OK) {
1392 ret = -EINVAL;
1393 goto out;
1394
1395 }
1396 if (offset_in_cluster < 0 ||
1397 offset_in_cluster + nb_sectors * 512 > buf_len) {
1398 ret = -EINVAL;
1399 goto out;
1400 }
1401 memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
1402 ret = 0;
1403
1404 out:
1405 g_free(uncomp_buf);
1406 g_free(cluster_buf);
1407 return ret;
1408 }
1409
1410 static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
1411 uint8_t *buf, int nb_sectors)
1412 {
1413 BDRVVmdkState *s = bs->opaque;
1414 int ret;
1415 uint64_t n, index_in_cluster;
1416 uint64_t extent_begin_sector, extent_relative_sector_num;
1417 VmdkExtent *extent = NULL;
1418 uint64_t cluster_offset;
1419
1420 while (nb_sectors > 0) {
1421 extent = find_extent(s, sector_num, extent);
1422 if (!extent) {
1423 return -EIO;
1424 }
1425 ret = get_cluster_offset(bs, extent, NULL,
1426 sector_num << 9, false, &cluster_offset,
1427 0, 0);
1428 extent_begin_sector = extent->end_sector - extent->sectors;
1429 extent_relative_sector_num = sector_num - extent_begin_sector;
1430 index_in_cluster = extent_relative_sector_num % extent->cluster_sectors;
1431 n = extent->cluster_sectors - index_in_cluster;
1432 if (n > nb_sectors) {
1433 n = nb_sectors;
1434 }
1435 if (ret != VMDK_OK) {
1436 /* if not allocated, try to read from parent image, if exist */
1437 if (bs->backing_hd && ret != VMDK_ZEROED) {
1438 if (!vmdk_is_cid_valid(bs)) {
1439 return -EINVAL;
1440 }
1441 ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
1442 if (ret < 0) {
1443 return ret;
1444 }
1445 } else {
1446 memset(buf, 0, 512 * n);
1447 }
1448 } else {
1449 ret = vmdk_read_extent(extent,
1450 cluster_offset, index_in_cluster * 512,
1451 buf, n);
1452 if (ret) {
1453 return ret;
1454 }
1455 }
1456 nb_sectors -= n;
1457 sector_num += n;
1458 buf += n * 512;
1459 }
1460 return 0;
1461 }
1462
1463 static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
1464 uint8_t *buf, int nb_sectors)
1465 {
1466 int ret;
1467 BDRVVmdkState *s = bs->opaque;
1468 qemu_co_mutex_lock(&s->lock);
1469 ret = vmdk_read(bs, sector_num, buf, nb_sectors);
1470 qemu_co_mutex_unlock(&s->lock);
1471 return ret;
1472 }
1473
1474 /**
1475 * vmdk_write:
1476 * @zeroed: buf is ignored (data is zero), use zeroed_grain GTE feature
1477 * if possible, otherwise return -ENOTSUP.
1478 * @zero_dry_run: used for zeroed == true only, don't update L2 table, just try
1479 * with each cluster. By dry run we can find if the zero write
1480 * is possible without modifying image data.
1481 *
1482 * Returns: error code with 0 for success.
1483 */
1484 static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
1485 const uint8_t *buf, int nb_sectors,
1486 bool zeroed, bool zero_dry_run)
1487 {
1488 BDRVVmdkState *s = bs->opaque;
1489 VmdkExtent *extent = NULL;
1490 int ret;
1491 int64_t index_in_cluster, n;
1492 uint64_t extent_begin_sector, extent_relative_sector_num;
1493 uint64_t cluster_offset;
1494 VmdkMetaData m_data;
1495
1496 if (sector_num > bs->total_sectors) {
1497 error_report("Wrong offset: sector_num=0x%" PRIx64
1498 " total_sectors=0x%" PRIx64 "\n",
1499 sector_num, bs->total_sectors);
1500 return -EIO;
1501 }
1502
1503 while (nb_sectors > 0) {
1504 extent = find_extent(s, sector_num, extent);
1505 if (!extent) {
1506 return -EIO;
1507 }
1508 extent_begin_sector = extent->end_sector - extent->sectors;
1509 extent_relative_sector_num = sector_num - extent_begin_sector;
1510 index_in_cluster = extent_relative_sector_num % extent->cluster_sectors;
1511 n = extent->cluster_sectors - index_in_cluster;
1512 if (n > nb_sectors) {
1513 n = nb_sectors;
1514 }
1515 ret = get_cluster_offset(bs, extent, &m_data, sector_num << 9,
1516 !(extent->compressed || zeroed),
1517 &cluster_offset,
1518 index_in_cluster, index_in_cluster + n);
1519 if (extent->compressed) {
1520 if (ret == VMDK_OK) {
1521 /* Refuse write to allocated cluster for streamOptimized */
1522 error_report("Could not write to allocated cluster"
1523 " for streamOptimized");
1524 return -EIO;
1525 } else {
1526 /* allocate */
1527 ret = get_cluster_offset(bs, extent, &m_data, sector_num << 9,
1528 true, &cluster_offset, 0, 0);
1529 }
1530 }
1531 if (ret == VMDK_ERROR) {
1532 return -EINVAL;
1533 }
1534 if (zeroed) {
1535 /* Do zeroed write, buf is ignored */
1536 if (extent->has_zero_grain &&
1537 index_in_cluster == 0 &&
1538 n >= extent->cluster_sectors) {
1539 n = extent->cluster_sectors;
1540 if (!zero_dry_run) {
1541 /* update L2 tables */
1542 if (vmdk_L2update(extent, &m_data, VMDK_GTE_ZEROED)
1543 != VMDK_OK) {
1544 return -EIO;
1545 }
1546 }
1547 } else {
1548 return -ENOTSUP;
1549 }
1550 } else {
1551 ret = vmdk_write_extent(extent,
1552 cluster_offset, index_in_cluster * 512,
1553 buf, n, sector_num);
1554 if (ret) {
1555 return ret;
1556 }
1557 if (m_data.valid) {
1558 /* update L2 tables */
1559 if (vmdk_L2update(extent, &m_data,
1560 cluster_offset >> BDRV_SECTOR_BITS)
1561 != VMDK_OK) {
1562 return -EIO;
1563 }
1564 }
1565 }
1566 nb_sectors -= n;
1567 sector_num += n;
1568 buf += n * 512;
1569
1570 /* update CID on the first write every time the virtual disk is
1571 * opened */
1572 if (!s->cid_updated) {
1573 ret = vmdk_write_cid(bs, g_random_int());
1574 if (ret < 0) {
1575 return ret;
1576 }
1577 s->cid_updated = true;
1578 }
1579 }
1580 return 0;
1581 }
1582
1583 static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
1584 const uint8_t *buf, int nb_sectors)
1585 {
1586 int ret;
1587 BDRVVmdkState *s = bs->opaque;
1588 qemu_co_mutex_lock(&s->lock);
1589 ret = vmdk_write(bs, sector_num, buf, nb_sectors, false, false);
1590 qemu_co_mutex_unlock(&s->lock);
1591 return ret;
1592 }
1593
1594 static int vmdk_write_compressed(BlockDriverState *bs,
1595 int64_t sector_num,
1596 const uint8_t *buf,
1597 int nb_sectors)
1598 {
1599 BDRVVmdkState *s = bs->opaque;
1600 if (s->num_extents == 1 && s->extents[0].compressed) {
1601 return vmdk_write(bs, sector_num, buf, nb_sectors, false, false);
1602 } else {
1603 return -ENOTSUP;
1604 }
1605 }
1606
1607 static int coroutine_fn vmdk_co_write_zeroes(BlockDriverState *bs,
1608 int64_t sector_num,
1609 int nb_sectors,
1610 BdrvRequestFlags flags)
1611 {
1612 int ret;
1613 BDRVVmdkState *s = bs->opaque;
1614 qemu_co_mutex_lock(&s->lock);
1615 /* write zeroes could fail if sectors not aligned to cluster, test it with
1616 * dry_run == true before really updating image */
1617 ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, true);
1618 if (!ret) {
1619 ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, false);
1620 }
1621 qemu_co_mutex_unlock(&s->lock);
1622 return ret;
1623 }
1624
1625 static int vmdk_create_extent(const char *filename, int64_t filesize,
1626 bool flat, bool compress, bool zeroed_grain,
1627 QemuOpts *opts, Error **errp)
1628 {
1629 int ret, i;
1630 BlockDriverState *bs = NULL;
1631 VMDK4Header header;
1632 Error *local_err = NULL;
1633 uint32_t tmp, magic, grains, gd_sectors, gt_size, gt_count;
1634 uint32_t *gd_buf = NULL;
1635 int gd_buf_size;
1636
1637 ret = bdrv_create_file(filename, opts, &local_err);
1638 if (ret < 0) {
1639 error_propagate(errp, local_err);
1640 goto exit;
1641 }
1642
1643 assert(bs == NULL);
1644 ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL,
1645 NULL, &local_err);
1646 if (ret < 0) {
1647 error_propagate(errp, local_err);
1648 goto exit;
1649 }
1650
1651 if (flat) {
1652 ret = bdrv_truncate(bs, filesize);
1653 if (ret < 0) {
1654 error_setg_errno(errp, -ret, "Could not truncate file");
1655 }
1656 goto exit;
1657 }
1658 magic = cpu_to_be32(VMDK4_MAGIC);
1659 memset(&header, 0, sizeof(header));
1660 header.version = zeroed_grain ? 2 : 1;
1661 header.flags = VMDK4_FLAG_RGD | VMDK4_FLAG_NL_DETECT
1662 | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0)
1663 | (zeroed_grain ? VMDK4_FLAG_ZERO_GRAIN : 0);
1664 header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
1665 header.capacity = filesize / BDRV_SECTOR_SIZE;
1666 header.granularity = 128;
1667 header.num_gtes_per_gt = BDRV_SECTOR_SIZE;
1668
1669 grains = DIV_ROUND_UP(filesize / BDRV_SECTOR_SIZE, header.granularity);
1670 gt_size = DIV_ROUND_UP(header.num_gtes_per_gt * sizeof(uint32_t),
1671 BDRV_SECTOR_SIZE);
1672 gt_count = DIV_ROUND_UP(grains, header.num_gtes_per_gt);
1673 gd_sectors = DIV_ROUND_UP(gt_count * sizeof(uint32_t), BDRV_SECTOR_SIZE);
1674
1675 header.desc_offset = 1;
1676 header.desc_size = 20;
1677 header.rgd_offset = header.desc_offset + header.desc_size;
1678 header.gd_offset = header.rgd_offset + gd_sectors + (gt_size * gt_count);
1679 header.grain_offset =
1680 ROUND_UP(header.gd_offset + gd_sectors + (gt_size * gt_count),
1681 header.granularity);
1682 /* swap endianness for all header fields */
1683 header.version = cpu_to_le32(header.version);
1684 header.flags = cpu_to_le32(header.flags);
1685 header.capacity = cpu_to_le64(header.capacity);
1686 header.granularity = cpu_to_le64(header.granularity);
1687 header.num_gtes_per_gt = cpu_to_le32(header.num_gtes_per_gt);
1688 header.desc_offset = cpu_to_le64(header.desc_offset);
1689 header.desc_size = cpu_to_le64(header.desc_size);
1690 header.rgd_offset = cpu_to_le64(header.rgd_offset);
1691 header.gd_offset = cpu_to_le64(header.gd_offset);
1692 header.grain_offset = cpu_to_le64(header.grain_offset);
1693 header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
1694
1695 header.check_bytes[0] = 0xa;
1696 header.check_bytes[1] = 0x20;
1697 header.check_bytes[2] = 0xd;
1698 header.check_bytes[3] = 0xa;
1699
1700 /* write all the data */
1701 ret = bdrv_pwrite(bs, 0, &magic, sizeof(magic));
1702 if (ret < 0) {
1703 error_set(errp, QERR_IO_ERROR);
1704 goto exit;
1705 }
1706 ret = bdrv_pwrite(bs, sizeof(magic), &header, sizeof(header));
1707 if (ret < 0) {
1708 error_set(errp, QERR_IO_ERROR);
1709 goto exit;
1710 }
1711
1712 ret = bdrv_truncate(bs, le64_to_cpu(header.grain_offset) << 9);
1713 if (ret < 0) {
1714 error_setg_errno(errp, -ret, "Could not truncate file");
1715 goto exit;
1716 }
1717
1718 /* write grain directory */
1719 gd_buf_size = gd_sectors * BDRV_SECTOR_SIZE;
1720 gd_buf = g_malloc0(gd_buf_size);
1721 for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_sectors;
1722 i < gt_count; i++, tmp += gt_size) {
1723 gd_buf[i] = cpu_to_le32(tmp);
1724 }
1725 ret = bdrv_pwrite(bs, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
1726 gd_buf, gd_buf_size);
1727 if (ret < 0) {
1728 error_set(errp, QERR_IO_ERROR);
1729 goto exit;
1730 }
1731
1732 /* write backup grain directory */
1733 for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_sectors;
1734 i < gt_count; i++, tmp += gt_size) {
1735 gd_buf[i] = cpu_to_le32(tmp);
1736 }
1737 ret = bdrv_pwrite(bs, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
1738 gd_buf, gd_buf_size);
1739 if (ret < 0) {
1740 error_set(errp, QERR_IO_ERROR);
1741 goto exit;
1742 }
1743
1744 ret = 0;
1745 exit:
1746 if (bs) {
1747 bdrv_unref(bs);
1748 }
1749 g_free(gd_buf);
1750 return ret;
1751 }
1752
1753 static int filename_decompose(const char *filename, char *path, char *prefix,
1754 char *postfix, size_t buf_len, Error **errp)
1755 {
1756 const char *p, *q;
1757
1758 if (filename == NULL || !strlen(filename)) {
1759 error_setg(errp, "No filename provided");
1760 return VMDK_ERROR;
1761 }
1762 p = strrchr(filename, '/');
1763 if (p == NULL) {
1764 p = strrchr(filename, '\\');
1765 }
1766 if (p == NULL) {
1767 p = strrchr(filename, ':');
1768 }
1769 if (p != NULL) {
1770 p++;
1771 if (p - filename >= buf_len) {
1772 return VMDK_ERROR;
1773 }
1774 pstrcpy(path, p - filename + 1, filename);
1775 } else {
1776 p = filename;
1777 path[0] = '\0';
1778 }
1779 q = strrchr(p, '.');
1780 if (q == NULL) {
1781 pstrcpy(prefix, buf_len, p);
1782 postfix[0] = '\0';
1783 } else {
1784 if (q - p >= buf_len) {
1785 return VMDK_ERROR;
1786 }
1787 pstrcpy(prefix, q - p + 1, p);
1788 pstrcpy(postfix, buf_len, q);
1789 }
1790 return VMDK_OK;
1791 }
1792
1793 static int vmdk_create(const char *filename, QemuOpts *opts, Error **errp)
1794 {
1795 int idx = 0;
1796 BlockDriverState *new_bs = NULL;
1797 Error *local_err = NULL;
1798 char *desc = NULL;
1799 int64_t total_size = 0, filesize;
1800 char *adapter_type = NULL;
1801 char *backing_file = NULL;
1802 char *fmt = NULL;
1803 int flags = 0;
1804 int ret = 0;
1805 bool flat, split, compress;
1806 GString *ext_desc_lines;
1807 char *path = g_malloc0(PATH_MAX);
1808 char *prefix = g_malloc0(PATH_MAX);
1809 char *postfix = g_malloc0(PATH_MAX);
1810 char *desc_line = g_malloc0(BUF_SIZE);
1811 char *ext_filename = g_malloc0(PATH_MAX);
1812 char *desc_filename = g_malloc0(PATH_MAX);
1813 const int64_t split_size = 0x80000000; /* VMDK has constant split size */
1814 const char *desc_extent_line;
1815 char *parent_desc_line = g_malloc0(BUF_SIZE);
1816 uint32_t parent_cid = 0xffffffff;
1817 uint32_t number_heads = 16;
1818 bool zeroed_grain = false;
1819 uint32_t desc_offset = 0, desc_len;
1820 const char desc_template[] =
1821 "# Disk DescriptorFile\n"
1822 "version=1\n"
1823 "CID=%" PRIx32 "\n"
1824 "parentCID=%" PRIx32 "\n"
1825 "createType=\"%s\"\n"
1826 "%s"
1827 "\n"
1828 "# Extent description\n"
1829 "%s"
1830 "\n"
1831 "# The Disk Data Base\n"
1832 "#DDB\n"
1833 "\n"
1834 "ddb.virtualHWVersion = \"%d\"\n"
1835 "ddb.geometry.cylinders = \"%" PRId64 "\"\n"
1836 "ddb.geometry.heads = \"%" PRIu32 "\"\n"
1837 "ddb.geometry.sectors = \"63\"\n"
1838 "ddb.adapterType = \"%s\"\n";
1839
1840 ext_desc_lines = g_string_new(NULL);
1841
1842 if (filename_decompose(filename, path, prefix, postfix, PATH_MAX, errp)) {
1843 ret = -EINVAL;
1844 goto exit;
1845 }
1846 /* Read out options */
1847 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1848 BDRV_SECTOR_SIZE);
1849 adapter_type = qemu_opt_get_del(opts, BLOCK_OPT_ADAPTER_TYPE);
1850 backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);
1851 if (qemu_opt_get_bool_del(opts, BLOCK_OPT_COMPAT6, false)) {
1852 flags |= BLOCK_FLAG_COMPAT6;
1853 }
1854 fmt = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);
1855 if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ZEROED_GRAIN, false)) {
1856 zeroed_grain = true;
1857 }
1858
1859 if (!adapter_type) {
1860 adapter_type = g_strdup("ide");
1861 } else if (strcmp(adapter_type, "ide") &&
1862 strcmp(adapter_type, "buslogic") &&
1863 strcmp(adapter_type, "lsilogic") &&
1864 strcmp(adapter_type, "legacyESX")) {
1865 error_setg(errp, "Unknown adapter type: '%s'", adapter_type);
1866 ret = -EINVAL;
1867 goto exit;
1868 }
1869 if (strcmp(adapter_type, "ide") != 0) {
1870 /* that's the number of heads with which vmware operates when
1871 creating, exporting, etc. vmdk files with a non-ide adapter type */
1872 number_heads = 255;
1873 }
1874 if (!fmt) {
1875 /* Default format to monolithicSparse */
1876 fmt = g_strdup("monolithicSparse");
1877 } else if (strcmp(fmt, "monolithicFlat") &&
1878 strcmp(fmt, "monolithicSparse") &&
1879 strcmp(fmt, "twoGbMaxExtentSparse") &&
1880 strcmp(fmt, "twoGbMaxExtentFlat") &&
1881 strcmp(fmt, "streamOptimized")) {
1882 error_setg(errp, "Unknown subformat: '%s'", fmt);
1883 ret = -EINVAL;
1884 goto exit;
1885 }
1886 split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
1887 strcmp(fmt, "twoGbMaxExtentSparse"));
1888 flat = !(strcmp(fmt, "monolithicFlat") &&
1889 strcmp(fmt, "twoGbMaxExtentFlat"));
1890 compress = !strcmp(fmt, "streamOptimized");
1891 if (flat) {
1892 desc_extent_line = "RW %" PRId64 " FLAT \"%s\" 0\n";
1893 } else {
1894 desc_extent_line = "RW %" PRId64 " SPARSE \"%s\"\n";
1895 }
1896 if (flat && backing_file) {
1897 error_setg(errp, "Flat image can't have backing file");
1898 ret = -ENOTSUP;
1899 goto exit;
1900 }
1901 if (flat && zeroed_grain) {
1902 error_setg(errp, "Flat image can't enable zeroed grain");
1903 ret = -ENOTSUP;
1904 goto exit;
1905 }
1906 if (backing_file) {
1907 BlockDriverState *bs = NULL;
1908 char *full_backing = g_new0(char, PATH_MAX);
1909 bdrv_get_full_backing_filename_from_filename(filename, backing_file,
1910 full_backing, PATH_MAX,
1911 &local_err);
1912 if (local_err) {
1913 g_free(full_backing);
1914 error_propagate(errp, local_err);
1915 ret = -ENOENT;
1916 goto exit;
1917 }
1918 ret = bdrv_open(&bs, full_backing, NULL, NULL, BDRV_O_NO_BACKING, NULL,
1919 errp);
1920 g_free(full_backing);
1921 if (ret != 0) {
1922 goto exit;
1923 }
1924 if (strcmp(bs->drv->format_name, "vmdk")) {
1925 bdrv_unref(bs);
1926 ret = -EINVAL;
1927 goto exit;
1928 }
1929 parent_cid = vmdk_read_cid(bs, 0);
1930 bdrv_unref(bs);
1931 snprintf(parent_desc_line, BUF_SIZE,
1932 "parentFileNameHint=\"%s\"", backing_file);
1933 }
1934
1935 /* Create extents */
1936 filesize = total_size;
1937 while (filesize > 0) {
1938 int64_t size = filesize;
1939
1940 if (split && size > split_size) {
1941 size = split_size;
1942 }
1943 if (split) {
1944 snprintf(desc_filename, PATH_MAX, "%s-%c%03d%s",
1945 prefix, flat ? 'f' : 's', ++idx, postfix);
1946 } else if (flat) {
1947 snprintf(desc_filename, PATH_MAX, "%s-flat%s", prefix, postfix);
1948 } else {
1949 snprintf(desc_filename, PATH_MAX, "%s%s", prefix, postfix);
1950 }
1951 snprintf(ext_filename, PATH_MAX, "%s%s", path, desc_filename);
1952
1953 if (vmdk_create_extent(ext_filename, size,
1954 flat, compress, zeroed_grain, opts, errp)) {
1955 ret = -EINVAL;
1956 goto exit;
1957 }
1958 filesize -= size;
1959
1960 /* Format description line */
1961 snprintf(desc_line, BUF_SIZE,
1962 desc_extent_line, size / BDRV_SECTOR_SIZE, desc_filename);
1963 g_string_append(ext_desc_lines, desc_line);
1964 }
1965 /* generate descriptor file */
1966 desc = g_strdup_printf(desc_template,
1967 g_random_int(),
1968 parent_cid,
1969 fmt,
1970 parent_desc_line,
1971 ext_desc_lines->str,
1972 (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
1973 total_size /
1974 (int64_t)(63 * number_heads * BDRV_SECTOR_SIZE),
1975 number_heads,
1976 adapter_type);
1977 desc_len = strlen(desc);
1978 /* the descriptor offset = 0x200 */
1979 if (!split && !flat) {
1980 desc_offset = 0x200;
1981 } else {
1982 ret = bdrv_create_file(filename, opts, &local_err);
1983 if (ret < 0) {
1984 error_propagate(errp, local_err);
1985 goto exit;
1986 }
1987 }
1988 assert(new_bs == NULL);
1989 ret = bdrv_open(&new_bs, filename, NULL, NULL,
1990 BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);
1991 if (ret < 0) {
1992 error_propagate(errp, local_err);
1993 goto exit;
1994 }
1995 ret = bdrv_pwrite(new_bs, desc_offset, desc, desc_len);
1996 if (ret < 0) {
1997 error_setg_errno(errp, -ret, "Could not write description");
1998 goto exit;
1999 }
2000 /* bdrv_pwrite write padding zeros to align to sector, we don't need that
2001 * for description file */
2002 if (desc_offset == 0) {
2003 ret = bdrv_truncate(new_bs, desc_len);
2004 if (ret < 0) {
2005 error_setg_errno(errp, -ret, "Could not truncate file");
2006 }
2007 }
2008 exit:
2009 if (new_bs) {
2010 bdrv_unref(new_bs);
2011 }
2012 g_free(adapter_type);
2013 g_free(backing_file);
2014 g_free(fmt);
2015 g_free(desc);
2016 g_free(path);
2017 g_free(prefix);
2018 g_free(postfix);
2019 g_free(desc_line);
2020 g_free(ext_filename);
2021 g_free(desc_filename);
2022 g_free(parent_desc_line);
2023 g_string_free(ext_desc_lines, true);
2024 return ret;
2025 }
2026
2027 static void vmdk_close(BlockDriverState *bs)
2028 {
2029 BDRVVmdkState *s = bs->opaque;
2030
2031 vmdk_free_extents(bs);
2032 g_free(s->create_type);
2033
2034 migrate_del_blocker(s->migration_blocker);
2035 error_free(s->migration_blocker);
2036 }
2037
2038 static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
2039 {
2040 BDRVVmdkState *s = bs->opaque;
2041 int i, err;
2042 int ret = 0;
2043
2044 for (i = 0; i < s->num_extents; i++) {
2045 err = bdrv_co_flush(s->extents[i].file);
2046 if (err < 0) {
2047 ret = err;
2048 }
2049 }
2050 return ret;
2051 }
2052
2053 static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
2054 {
2055 int i;
2056 int64_t ret = 0;
2057 int64_t r;
2058 BDRVVmdkState *s = bs->opaque;
2059
2060 ret = bdrv_get_allocated_file_size(bs->file);
2061 if (ret < 0) {
2062 return ret;
2063 }
2064 for (i = 0; i < s->num_extents; i++) {
2065 if (s->extents[i].file == bs->file) {
2066 continue;
2067 }
2068 r = bdrv_get_allocated_file_size(s->extents[i].file);
2069 if (r < 0) {
2070 return r;
2071 }
2072 ret += r;
2073 }
2074 return ret;
2075 }
2076
2077 static int vmdk_has_zero_init(BlockDriverState *bs)
2078 {
2079 int i;
2080 BDRVVmdkState *s = bs->opaque;
2081
2082 /* If has a flat extent and its underlying storage doesn't have zero init,
2083 * return 0. */
2084 for (i = 0; i < s->num_extents; i++) {
2085 if (s->extents[i].flat) {
2086 if (!bdrv_has_zero_init(s->extents[i].file)) {
2087 return 0;
2088 }
2089 }
2090 }
2091 return 1;
2092 }
2093
2094 static ImageInfo *vmdk_get_extent_info(VmdkExtent *extent)
2095 {
2096 ImageInfo *info = g_new0(ImageInfo, 1);
2097
2098 *info = (ImageInfo){
2099 .filename = g_strdup(extent->file->filename),
2100 .format = g_strdup(extent->type),
2101 .virtual_size = extent->sectors * BDRV_SECTOR_SIZE,
2102 .compressed = extent->compressed,
2103 .has_compressed = extent->compressed,
2104 .cluster_size = extent->cluster_sectors * BDRV_SECTOR_SIZE,
2105 .has_cluster_size = !extent->flat,
2106 };
2107
2108 return info;
2109 }
2110
2111 static int vmdk_check(BlockDriverState *bs, BdrvCheckResult *result,
2112 BdrvCheckMode fix)
2113 {
2114 BDRVVmdkState *s = bs->opaque;
2115 VmdkExtent *extent = NULL;
2116 int64_t sector_num = 0;
2117 int64_t total_sectors = bdrv_nb_sectors(bs);
2118 int ret;
2119 uint64_t cluster_offset;
2120
2121 if (fix) {
2122 return -ENOTSUP;
2123 }
2124
2125 for (;;) {
2126 if (sector_num >= total_sectors) {
2127 return 0;
2128 }
2129 extent = find_extent(s, sector_num, extent);
2130 if (!extent) {
2131 fprintf(stderr,
2132 "ERROR: could not find extent for sector %" PRId64 "\n",
2133 sector_num);
2134 break;
2135 }
2136 ret = get_cluster_offset(bs, extent, NULL,
2137 sector_num << BDRV_SECTOR_BITS,
2138 false, &cluster_offset, 0, 0);
2139 if (ret == VMDK_ERROR) {
2140 fprintf(stderr,
2141 "ERROR: could not get cluster_offset for sector %"
2142 PRId64 "\n", sector_num);
2143 break;
2144 }
2145 if (ret == VMDK_OK && cluster_offset >= bdrv_getlength(extent->file)) {
2146 fprintf(stderr,
2147 "ERROR: cluster offset for sector %"
2148 PRId64 " points after EOF\n", sector_num);
2149 break;
2150 }
2151 sector_num += extent->cluster_sectors;
2152 }
2153
2154 result->corruptions++;
2155 return 0;
2156 }
2157
2158 static ImageInfoSpecific *vmdk_get_specific_info(BlockDriverState *bs)
2159 {
2160 int i;
2161 BDRVVmdkState *s = bs->opaque;
2162 ImageInfoSpecific *spec_info = g_new0(ImageInfoSpecific, 1);
2163 ImageInfoList **next;
2164
2165 *spec_info = (ImageInfoSpecific){
2166 .kind = IMAGE_INFO_SPECIFIC_KIND_VMDK,
2167 {
2168 .vmdk = g_new0(ImageInfoSpecificVmdk, 1),
2169 },
2170 };
2171
2172 *spec_info->vmdk = (ImageInfoSpecificVmdk) {
2173 .create_type = g_strdup(s->create_type),
2174 .cid = s->cid,
2175 .parent_cid = s->parent_cid,
2176 };
2177
2178 next = &spec_info->vmdk->extents;
2179 for (i = 0; i < s->num_extents; i++) {
2180 *next = g_new0(ImageInfoList, 1);
2181 (*next)->value = vmdk_get_extent_info(&s->extents[i]);
2182 (*next)->next = NULL;
2183 next = &(*next)->next;
2184 }
2185
2186 return spec_info;
2187 }
2188
2189 static bool vmdk_extents_type_eq(const VmdkExtent *a, const VmdkExtent *b)
2190 {
2191 return a->flat == b->flat &&
2192 a->compressed == b->compressed &&
2193 (a->flat || a->cluster_sectors == b->cluster_sectors);
2194 }
2195
2196 static int vmdk_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2197 {
2198 int i;
2199 BDRVVmdkState *s = bs->opaque;
2200 assert(s->num_extents);
2201
2202 /* See if we have multiple extents but they have different cases */
2203 for (i = 1; i < s->num_extents; i++) {
2204 if (!vmdk_extents_type_eq(&s->extents[0], &s->extents[i])) {
2205 return -ENOTSUP;
2206 }
2207 }
2208 bdi->needs_compressed_writes = s->extents[0].compressed;
2209 if (!s->extents[0].flat) {
2210 bdi->cluster_size = s->extents[0].cluster_sectors << BDRV_SECTOR_BITS;
2211 }
2212 return 0;
2213 }
2214
2215 static void vmdk_detach_aio_context(BlockDriverState *bs)
2216 {
2217 BDRVVmdkState *s = bs->opaque;
2218 int i;
2219
2220 for (i = 0; i < s->num_extents; i++) {
2221 bdrv_detach_aio_context(s->extents[i].file);
2222 }
2223 }
2224
2225 static void vmdk_attach_aio_context(BlockDriverState *bs,
2226 AioContext *new_context)
2227 {
2228 BDRVVmdkState *s = bs->opaque;
2229 int i;
2230
2231 for (i = 0; i < s->num_extents; i++) {
2232 bdrv_attach_aio_context(s->extents[i].file, new_context);
2233 }
2234 }
2235
2236 static QemuOptsList vmdk_create_opts = {
2237 .name = "vmdk-create-opts",
2238 .head = QTAILQ_HEAD_INITIALIZER(vmdk_create_opts.head),
2239 .desc = {
2240 {
2241 .name = BLOCK_OPT_SIZE,
2242 .type = QEMU_OPT_SIZE,
2243 .help = "Virtual disk size"
2244 },
2245 {
2246 .name = BLOCK_OPT_ADAPTER_TYPE,
2247 .type = QEMU_OPT_STRING,
2248 .help = "Virtual adapter type, can be one of "
2249 "ide (default), lsilogic, buslogic or legacyESX"
2250 },
2251 {
2252 .name = BLOCK_OPT_BACKING_FILE,
2253 .type = QEMU_OPT_STRING,
2254 .help = "File name of a base image"
2255 },
2256 {
2257 .name = BLOCK_OPT_COMPAT6,
2258 .type = QEMU_OPT_BOOL,
2259 .help = "VMDK version 6 image",
2260 .def_value_str = "off"
2261 },
2262 {
2263 .name = BLOCK_OPT_SUBFMT,
2264 .type = QEMU_OPT_STRING,
2265 .help =
2266 "VMDK flat extent format, can be one of "
2267 "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
2268 },
2269 {
2270 .name = BLOCK_OPT_ZEROED_GRAIN,
2271 .type = QEMU_OPT_BOOL,
2272 .help = "Enable efficient zero writes "
2273 "using the zeroed-grain GTE feature"
2274 },
2275 { /* end of list */ }
2276 }
2277 };
2278
2279 static BlockDriver bdrv_vmdk = {
2280 .format_name = "vmdk",
2281 .instance_size = sizeof(BDRVVmdkState),
2282 .bdrv_probe = vmdk_probe,
2283 .bdrv_open = vmdk_open,
2284 .bdrv_check = vmdk_check,
2285 .bdrv_reopen_prepare = vmdk_reopen_prepare,
2286 .bdrv_read = vmdk_co_read,
2287 .bdrv_write = vmdk_co_write,
2288 .bdrv_write_compressed = vmdk_write_compressed,
2289 .bdrv_co_write_zeroes = vmdk_co_write_zeroes,
2290 .bdrv_close = vmdk_close,
2291 .bdrv_create = vmdk_create,
2292 .bdrv_co_flush_to_disk = vmdk_co_flush,
2293 .bdrv_co_get_block_status = vmdk_co_get_block_status,
2294 .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
2295 .bdrv_has_zero_init = vmdk_has_zero_init,
2296 .bdrv_get_specific_info = vmdk_get_specific_info,
2297 .bdrv_refresh_limits = vmdk_refresh_limits,
2298 .bdrv_get_info = vmdk_get_info,
2299 .bdrv_detach_aio_context = vmdk_detach_aio_context,
2300 .bdrv_attach_aio_context = vmdk_attach_aio_context,
2301
2302 .supports_backing = true,
2303 .create_opts = &vmdk_create_opts,
2304 };
2305
2306 static void bdrv_vmdk_init(void)
2307 {
2308 bdrv_register(&bdrv_vmdk);
2309 }
2310
2311 block_init(bdrv_vmdk_init);
QEMU Monitor Protocol