1019d6b8fSAnthony Liguori /* 2019d6b8fSAnthony Liguori * Block driver for the VMDK format 3019d6b8fSAnthony Liguori * 4019d6b8fSAnthony Liguori * Copyright (c) 2004 Fabrice Bellard 5019d6b8fSAnthony Liguori * Copyright (c) 2005 Filip Navara 6019d6b8fSAnthony Liguori * 7019d6b8fSAnthony Liguori * Permission is hereby granted, free of charge, to any person obtaining a copy 8019d6b8fSAnthony Liguori * of this software and associated documentation files (the "Software"), to deal 9019d6b8fSAnthony Liguori * in the Software without restriction, including without limitation the rights 10019d6b8fSAnthony Liguori * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11019d6b8fSAnthony Liguori * copies of the Software, and to permit persons to whom the Software is 12019d6b8fSAnthony Liguori * furnished to do so, subject to the following conditions: 13019d6b8fSAnthony Liguori * 14019d6b8fSAnthony Liguori * The above copyright notice and this permission notice shall be included in 15019d6b8fSAnthony Liguori * all copies or substantial portions of the Software. 16019d6b8fSAnthony Liguori * 17019d6b8fSAnthony Liguori * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18019d6b8fSAnthony Liguori * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19019d6b8fSAnthony Liguori * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20019d6b8fSAnthony Liguori * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21019d6b8fSAnthony Liguori * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22019d6b8fSAnthony Liguori * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23019d6b8fSAnthony Liguori * THE SOFTWARE. 24019d6b8fSAnthony Liguori */ 25019d6b8fSAnthony Liguori 26019d6b8fSAnthony Liguori #include "qemu-common.h" 27737e150eSPaolo Bonzini #include "block/block_int.h" 281de7afc9SPaolo Bonzini #include "qemu/module.h" 29caf71f86SPaolo Bonzini #include "migration/migration.h" 302923d34fSStefan Weil #include <zlib.h> 31019d6b8fSAnthony Liguori 32019d6b8fSAnthony Liguori #define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D') 33019d6b8fSAnthony Liguori #define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V') 34432bb170SFam Zheng #define VMDK4_COMPRESSION_DEFLATE 1 3595b0aa42SFam Zheng #define VMDK4_FLAG_NL_DETECT (1 << 0) 36bb45ded9SFam Zheng #define VMDK4_FLAG_RGD (1 << 1) 3714ead646SFam Zheng /* Zeroed-grain enable bit */ 3814ead646SFam Zheng #define VMDK4_FLAG_ZERO_GRAIN (1 << 2) 39432bb170SFam Zheng #define VMDK4_FLAG_COMPRESS (1 << 16) 40432bb170SFam Zheng #define VMDK4_FLAG_MARKER (1 << 17) 4165bd155cSKevin Wolf #define VMDK4_GD_AT_END 0xffffffffffffffffULL 42019d6b8fSAnthony Liguori 4314ead646SFam Zheng #define VMDK_GTE_ZEROED 0x1 4465f74725SFam Zheng 4565f74725SFam Zheng /* VMDK internal error codes */ 4665f74725SFam Zheng #define VMDK_OK 0 4765f74725SFam Zheng #define VMDK_ERROR (-1) 4865f74725SFam Zheng /* Cluster not allocated */ 4965f74725SFam Zheng #define VMDK_UNALLOC (-2) 5065f74725SFam Zheng #define VMDK_ZEROED (-3) 5165f74725SFam Zheng 5269e0b6dfSFam Zheng #define BLOCK_OPT_ZEROED_GRAIN "zeroed_grain" 5369e0b6dfSFam Zheng 54019d6b8fSAnthony Liguori typedef struct { 55019d6b8fSAnthony Liguori uint32_t version; 56019d6b8fSAnthony Liguori uint32_t flags; 57019d6b8fSAnthony Liguori uint32_t disk_sectors; 58019d6b8fSAnthony Liguori uint32_t granularity; 59019d6b8fSAnthony Liguori uint32_t l1dir_offset; 60019d6b8fSAnthony Liguori uint32_t l1dir_size; 61019d6b8fSAnthony Liguori uint32_t file_sectors; 62019d6b8fSAnthony Liguori uint32_t cylinders; 63019d6b8fSAnthony Liguori uint32_t heads; 64019d6b8fSAnthony Liguori uint32_t sectors_per_track; 655d8caa54SFam Zheng } QEMU_PACKED VMDK3Header; 66019d6b8fSAnthony Liguori 67019d6b8fSAnthony Liguori typedef struct { 68019d6b8fSAnthony Liguori uint32_t version; 69019d6b8fSAnthony Liguori uint32_t flags; 70e98768d4SFam Zheng uint64_t capacity; 71e98768d4SFam Zheng uint64_t granularity; 72e98768d4SFam Zheng uint64_t desc_offset; 73e98768d4SFam Zheng uint64_t desc_size; 74ca8804ceSFam Zheng /* Number of GrainTableEntries per GrainTable */ 75ca8804ceSFam Zheng uint32_t num_gtes_per_gt; 76e98768d4SFam Zheng uint64_t rgd_offset; 77e98768d4SFam Zheng uint64_t gd_offset; 78e98768d4SFam Zheng uint64_t grain_offset; 79019d6b8fSAnthony Liguori char filler[1]; 80019d6b8fSAnthony Liguori char check_bytes[4]; 81432bb170SFam Zheng uint16_t compressAlgorithm; 82541dc0d4SStefan Weil } QEMU_PACKED VMDK4Header; 83019d6b8fSAnthony Liguori 84019d6b8fSAnthony Liguori #define L2_CACHE_SIZE 16 85019d6b8fSAnthony Liguori 86b3976d3cSFam Zheng typedef struct VmdkExtent { 87b3976d3cSFam Zheng BlockDriverState *file; 88b3976d3cSFam Zheng bool flat; 89432bb170SFam Zheng bool compressed; 90432bb170SFam Zheng bool has_marker; 9114ead646SFam Zheng bool has_zero_grain; 9214ead646SFam Zheng int version; 93b3976d3cSFam Zheng int64_t sectors; 94b3976d3cSFam Zheng int64_t end_sector; 957fa60fa3SFam Zheng int64_t flat_start_offset; 96019d6b8fSAnthony Liguori int64_t l1_table_offset; 97019d6b8fSAnthony Liguori int64_t l1_backup_table_offset; 98019d6b8fSAnthony Liguori uint32_t *l1_table; 99019d6b8fSAnthony Liguori uint32_t *l1_backup_table; 100019d6b8fSAnthony Liguori unsigned int l1_size; 101019d6b8fSAnthony Liguori uint32_t l1_entry_sectors; 102019d6b8fSAnthony Liguori 103019d6b8fSAnthony Liguori unsigned int l2_size; 104019d6b8fSAnthony Liguori uint32_t *l2_cache; 105019d6b8fSAnthony Liguori uint32_t l2_cache_offsets[L2_CACHE_SIZE]; 106019d6b8fSAnthony Liguori uint32_t l2_cache_counts[L2_CACHE_SIZE]; 107019d6b8fSAnthony Liguori 108301c7d38SFam Zheng int64_t cluster_sectors; 109f4c129a3SFam Zheng char *type; 110b3976d3cSFam Zheng } VmdkExtent; 111b3976d3cSFam Zheng 112b3976d3cSFam Zheng typedef struct BDRVVmdkState { 113848c66e8SPaolo Bonzini CoMutex lock; 114e98768d4SFam Zheng uint64_t desc_offset; 11569b4d86dSFam Zheng bool cid_updated; 116c338b6adSFam Zheng bool cid_checked; 117f4c129a3SFam Zheng uint32_t cid; 118019d6b8fSAnthony Liguori uint32_t parent_cid; 119b3976d3cSFam Zheng int num_extents; 120b3976d3cSFam Zheng /* Extent array with num_extents entries, ascend ordered by address */ 121b3976d3cSFam Zheng VmdkExtent *extents; 1222bc3166cSKevin Wolf Error *migration_blocker; 123f4c129a3SFam Zheng char *create_type; 124019d6b8fSAnthony Liguori } BDRVVmdkState; 125019d6b8fSAnthony Liguori 126019d6b8fSAnthony Liguori typedef struct VmdkMetaData { 127019d6b8fSAnthony Liguori uint32_t offset; 128019d6b8fSAnthony Liguori unsigned int l1_index; 129019d6b8fSAnthony Liguori unsigned int l2_index; 130019d6b8fSAnthony Liguori unsigned int l2_offset; 131019d6b8fSAnthony Liguori int valid; 132cdeaf1f1SFam Zheng uint32_t *l2_cache_entry; 133019d6b8fSAnthony Liguori } VmdkMetaData; 134019d6b8fSAnthony Liguori 135432bb170SFam Zheng typedef struct VmdkGrainMarker { 136432bb170SFam Zheng uint64_t lba; 137432bb170SFam Zheng uint32_t size; 138432bb170SFam Zheng uint8_t data[0]; 1395d8caa54SFam Zheng } QEMU_PACKED VmdkGrainMarker; 140432bb170SFam Zheng 14165bd155cSKevin Wolf enum { 14265bd155cSKevin Wolf MARKER_END_OF_STREAM = 0, 14365bd155cSKevin Wolf MARKER_GRAIN_TABLE = 1, 14465bd155cSKevin Wolf MARKER_GRAIN_DIRECTORY = 2, 14565bd155cSKevin Wolf MARKER_FOOTER = 3, 14665bd155cSKevin Wolf }; 14765bd155cSKevin Wolf 148019d6b8fSAnthony Liguori static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename) 149019d6b8fSAnthony Liguori { 150019d6b8fSAnthony Liguori uint32_t magic; 151019d6b8fSAnthony Liguori 152ae261c86SFam Zheng if (buf_size < 4) { 153019d6b8fSAnthony Liguori return 0; 154ae261c86SFam Zheng } 155019d6b8fSAnthony Liguori magic = be32_to_cpu(*(uint32_t *)buf); 156019d6b8fSAnthony Liguori if (magic == VMDK3_MAGIC || 15701fc99d6SFam Zheng magic == VMDK4_MAGIC) { 158019d6b8fSAnthony Liguori return 100; 15901fc99d6SFam Zheng } else { 16001fc99d6SFam Zheng const char *p = (const char *)buf; 16101fc99d6SFam Zheng const char *end = p + buf_size; 16201fc99d6SFam Zheng while (p < end) { 16301fc99d6SFam Zheng if (*p == '#') { 16401fc99d6SFam Zheng /* skip comment line */ 16501fc99d6SFam Zheng while (p < end && *p != '\n') { 16601fc99d6SFam Zheng p++; 16701fc99d6SFam Zheng } 16801fc99d6SFam Zheng p++; 16901fc99d6SFam Zheng continue; 17001fc99d6SFam Zheng } 17101fc99d6SFam Zheng if (*p == ' ') { 17201fc99d6SFam Zheng while (p < end && *p == ' ') { 17301fc99d6SFam Zheng p++; 17401fc99d6SFam Zheng } 17501fc99d6SFam Zheng /* skip '\r' if windows line endings used. */ 17601fc99d6SFam Zheng if (p < end && *p == '\r') { 17701fc99d6SFam Zheng p++; 17801fc99d6SFam Zheng } 17901fc99d6SFam Zheng /* only accept blank lines before 'version=' line */ 18001fc99d6SFam Zheng if (p == end || *p != '\n') { 181019d6b8fSAnthony Liguori return 0; 182019d6b8fSAnthony Liguori } 18301fc99d6SFam Zheng p++; 18401fc99d6SFam Zheng continue; 18501fc99d6SFam Zheng } 18601fc99d6SFam Zheng if (end - p >= strlen("version=X\n")) { 18701fc99d6SFam Zheng if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 || 18801fc99d6SFam Zheng strncmp("version=2\n", p, strlen("version=2\n")) == 0) { 18901fc99d6SFam Zheng return 100; 19001fc99d6SFam Zheng } 19101fc99d6SFam Zheng } 19201fc99d6SFam Zheng if (end - p >= strlen("version=X\r\n")) { 19301fc99d6SFam Zheng if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 || 19401fc99d6SFam Zheng strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) { 19501fc99d6SFam Zheng return 100; 19601fc99d6SFam Zheng } 19701fc99d6SFam Zheng } 19801fc99d6SFam Zheng return 0; 19901fc99d6SFam Zheng } 20001fc99d6SFam Zheng return 0; 20101fc99d6SFam Zheng } 20201fc99d6SFam Zheng } 203019d6b8fSAnthony Liguori 204019d6b8fSAnthony Liguori #define SECTOR_SIZE 512 205f66fd6c3SFam Zheng #define DESC_SIZE (20 * SECTOR_SIZE) /* 20 sectors of 512 bytes each */ 206f66fd6c3SFam Zheng #define BUF_SIZE 4096 207f66fd6c3SFam Zheng #define HEADER_SIZE 512 /* first sector of 512 bytes */ 208019d6b8fSAnthony Liguori 209b3976d3cSFam Zheng static void vmdk_free_extents(BlockDriverState *bs) 210b3976d3cSFam Zheng { 211b3976d3cSFam Zheng int i; 212b3976d3cSFam Zheng BDRVVmdkState *s = bs->opaque; 213b3c0bfb6SFam Zheng VmdkExtent *e; 214b3976d3cSFam Zheng 215b3976d3cSFam Zheng for (i = 0; i < s->num_extents; i++) { 216b3c0bfb6SFam Zheng e = &s->extents[i]; 217b3c0bfb6SFam Zheng g_free(e->l1_table); 218b3c0bfb6SFam Zheng g_free(e->l2_cache); 219b3c0bfb6SFam Zheng g_free(e->l1_backup_table); 220f4c129a3SFam Zheng g_free(e->type); 221b3c0bfb6SFam Zheng if (e->file != bs->file) { 2224f6fd349SFam Zheng bdrv_unref(e->file); 223b3c0bfb6SFam Zheng } 224b3976d3cSFam Zheng } 2257267c094SAnthony Liguori g_free(s->extents); 226b3976d3cSFam Zheng } 227b3976d3cSFam Zheng 22886c6b429SFam Zheng static void vmdk_free_last_extent(BlockDriverState *bs) 22986c6b429SFam Zheng { 23086c6b429SFam Zheng BDRVVmdkState *s = bs->opaque; 23186c6b429SFam Zheng 23286c6b429SFam Zheng if (s->num_extents == 0) { 23386c6b429SFam Zheng return; 23486c6b429SFam Zheng } 23586c6b429SFam Zheng s->num_extents--; 23686c6b429SFam Zheng s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent)); 23786c6b429SFam Zheng } 23886c6b429SFam Zheng 239019d6b8fSAnthony Liguori static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent) 240019d6b8fSAnthony Liguori { 241019d6b8fSAnthony Liguori char desc[DESC_SIZE]; 2428379e46dSPavel Borzenkov uint32_t cid = 0xffffffff; 243019d6b8fSAnthony Liguori const char *p_name, *cid_str; 244019d6b8fSAnthony Liguori size_t cid_str_size; 245e1da9b24SFam Zheng BDRVVmdkState *s = bs->opaque; 24699f1835dSKevin Wolf int ret; 247019d6b8fSAnthony Liguori 24899f1835dSKevin Wolf ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE); 24999f1835dSKevin Wolf if (ret < 0) { 250019d6b8fSAnthony Liguori return 0; 251e1da9b24SFam Zheng } 252019d6b8fSAnthony Liguori 253019d6b8fSAnthony Liguori if (parent) { 254019d6b8fSAnthony Liguori cid_str = "parentCID"; 255019d6b8fSAnthony Liguori cid_str_size = sizeof("parentCID"); 256019d6b8fSAnthony Liguori } else { 257019d6b8fSAnthony Liguori cid_str = "CID"; 258019d6b8fSAnthony Liguori cid_str_size = sizeof("CID"); 259019d6b8fSAnthony Liguori } 260019d6b8fSAnthony Liguori 26193897b9fSKevin Wolf desc[DESC_SIZE - 1] = '\0'; 262ae261c86SFam Zheng p_name = strstr(desc, cid_str); 263ae261c86SFam Zheng if (p_name != NULL) { 264019d6b8fSAnthony Liguori p_name += cid_str_size; 265019d6b8fSAnthony Liguori sscanf(p_name, "%x", &cid); 266019d6b8fSAnthony Liguori } 267019d6b8fSAnthony Liguori 268019d6b8fSAnthony Liguori return cid; 269019d6b8fSAnthony Liguori } 270019d6b8fSAnthony Liguori 271019d6b8fSAnthony Liguori static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid) 272019d6b8fSAnthony Liguori { 273019d6b8fSAnthony Liguori char desc[DESC_SIZE], tmp_desc[DESC_SIZE]; 274019d6b8fSAnthony Liguori char *p_name, *tmp_str; 275e1da9b24SFam Zheng BDRVVmdkState *s = bs->opaque; 27699f1835dSKevin Wolf int ret; 277019d6b8fSAnthony Liguori 27899f1835dSKevin Wolf ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE); 27999f1835dSKevin Wolf if (ret < 0) { 28099f1835dSKevin Wolf return ret; 281e1da9b24SFam Zheng } 282019d6b8fSAnthony Liguori 28393897b9fSKevin Wolf desc[DESC_SIZE - 1] = '\0'; 284019d6b8fSAnthony Liguori tmp_str = strstr(desc, "parentCID"); 28593897b9fSKevin Wolf if (tmp_str == NULL) { 28693897b9fSKevin Wolf return -EINVAL; 28793897b9fSKevin Wolf } 28893897b9fSKevin Wolf 289019d6b8fSAnthony Liguori pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str); 290ae261c86SFam Zheng p_name = strstr(desc, "CID"); 291ae261c86SFam Zheng if (p_name != NULL) { 292019d6b8fSAnthony Liguori p_name += sizeof("CID"); 293019d6b8fSAnthony Liguori snprintf(p_name, sizeof(desc) - (p_name - desc), "%x\n", cid); 294019d6b8fSAnthony Liguori pstrcat(desc, sizeof(desc), tmp_desc); 295019d6b8fSAnthony Liguori } 296019d6b8fSAnthony Liguori 29799f1835dSKevin Wolf ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE); 29899f1835dSKevin Wolf if (ret < 0) { 29999f1835dSKevin Wolf return ret; 300e1da9b24SFam Zheng } 30199f1835dSKevin Wolf 302019d6b8fSAnthony Liguori return 0; 303019d6b8fSAnthony Liguori } 304019d6b8fSAnthony Liguori 305019d6b8fSAnthony Liguori static int vmdk_is_cid_valid(BlockDriverState *bs) 306019d6b8fSAnthony Liguori { 307019d6b8fSAnthony Liguori BDRVVmdkState *s = bs->opaque; 308b171271aSKevin Wolf BlockDriverState *p_bs = bs->backing_hd; 309019d6b8fSAnthony Liguori uint32_t cur_pcid; 310019d6b8fSAnthony Liguori 311c338b6adSFam Zheng if (!s->cid_checked && p_bs) { 312019d6b8fSAnthony Liguori cur_pcid = vmdk_read_cid(p_bs, 0); 313ae261c86SFam Zheng if (s->parent_cid != cur_pcid) { 314ae261c86SFam Zheng /* CID not valid */ 315019d6b8fSAnthony Liguori return 0; 316019d6b8fSAnthony Liguori } 317ae261c86SFam Zheng } 318c338b6adSFam Zheng s->cid_checked = true; 319ae261c86SFam Zheng /* CID valid */ 320019d6b8fSAnthony Liguori return 1; 321019d6b8fSAnthony Liguori } 322019d6b8fSAnthony Liguori 3233897575fSJeff Cody /* Queue extents, if any, for reopen() */ 3243897575fSJeff Cody static int vmdk_reopen_prepare(BDRVReopenState *state, 3253897575fSJeff Cody BlockReopenQueue *queue, Error **errp) 3263897575fSJeff Cody { 3273897575fSJeff Cody BDRVVmdkState *s; 3283897575fSJeff Cody int ret = -1; 3293897575fSJeff Cody int i; 3303897575fSJeff Cody VmdkExtent *e; 3313897575fSJeff Cody 3323897575fSJeff Cody assert(state != NULL); 3333897575fSJeff Cody assert(state->bs != NULL); 3343897575fSJeff Cody 3353897575fSJeff Cody if (queue == NULL) { 3364823970bSFam Zheng error_setg(errp, "No reopen queue for VMDK extents"); 3373897575fSJeff Cody goto exit; 3383897575fSJeff Cody } 3393897575fSJeff Cody 3403897575fSJeff Cody s = state->bs->opaque; 3413897575fSJeff Cody 3423897575fSJeff Cody assert(s != NULL); 3433897575fSJeff Cody 3443897575fSJeff Cody for (i = 0; i < s->num_extents; i++) { 3453897575fSJeff Cody e = &s->extents[i]; 3463897575fSJeff Cody if (e->file != state->bs->file) { 3473897575fSJeff Cody bdrv_reopen_queue(queue, e->file, state->flags); 3483897575fSJeff Cody } 3493897575fSJeff Cody } 3503897575fSJeff Cody ret = 0; 3513897575fSJeff Cody 3523897575fSJeff Cody exit: 3533897575fSJeff Cody return ret; 3543897575fSJeff Cody } 3553897575fSJeff Cody 3569949f97eSKevin Wolf static int vmdk_parent_open(BlockDriverState *bs) 357019d6b8fSAnthony Liguori { 358019d6b8fSAnthony Liguori char *p_name; 3597fa60fa3SFam Zheng char desc[DESC_SIZE + 1]; 360e1da9b24SFam Zheng BDRVVmdkState *s = bs->opaque; 361588b65a3SPaolo Bonzini int ret; 362019d6b8fSAnthony Liguori 3637fa60fa3SFam Zheng desc[DESC_SIZE] = '\0'; 364588b65a3SPaolo Bonzini ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE); 365588b65a3SPaolo Bonzini if (ret < 0) { 366588b65a3SPaolo Bonzini return ret; 367e1da9b24SFam Zheng } 368019d6b8fSAnthony Liguori 369ae261c86SFam Zheng p_name = strstr(desc, "parentFileNameHint"); 370ae261c86SFam Zheng if (p_name != NULL) { 371019d6b8fSAnthony Liguori char *end_name; 372019d6b8fSAnthony Liguori 373019d6b8fSAnthony Liguori p_name += sizeof("parentFileNameHint") + 1; 374ae261c86SFam Zheng end_name = strchr(p_name, '\"'); 375ae261c86SFam Zheng if (end_name == NULL) { 376588b65a3SPaolo Bonzini return -EINVAL; 377ae261c86SFam Zheng } 378ae261c86SFam Zheng if ((end_name - p_name) > sizeof(bs->backing_file) - 1) { 379588b65a3SPaolo Bonzini return -EINVAL; 380ae261c86SFam Zheng } 381019d6b8fSAnthony Liguori 382b171271aSKevin Wolf pstrcpy(bs->backing_file, end_name - p_name + 1, p_name); 383019d6b8fSAnthony Liguori } 384019d6b8fSAnthony Liguori 385019d6b8fSAnthony Liguori return 0; 386019d6b8fSAnthony Liguori } 387019d6b8fSAnthony Liguori 388b3976d3cSFam Zheng /* Create and append extent to the extent array. Return the added VmdkExtent 389b3976d3cSFam Zheng * address. return NULL if allocation failed. */ 3908aa1331cSFam Zheng static int vmdk_add_extent(BlockDriverState *bs, 391b3976d3cSFam Zheng BlockDriverState *file, bool flat, int64_t sectors, 392b3976d3cSFam Zheng int64_t l1_offset, int64_t l1_backup_offset, 393b3976d3cSFam Zheng uint32_t l1_size, 3948aa1331cSFam Zheng int l2_size, uint64_t cluster_sectors, 3954823970bSFam Zheng VmdkExtent **new_extent, 3964823970bSFam Zheng Error **errp) 397b3976d3cSFam Zheng { 398b3976d3cSFam Zheng VmdkExtent *extent; 399b3976d3cSFam Zheng BDRVVmdkState *s = bs->opaque; 400b3976d3cSFam Zheng 4018aa1331cSFam Zheng if (cluster_sectors > 0x200000) { 4028aa1331cSFam Zheng /* 0x200000 * 512Bytes = 1GB for one cluster is unrealistic */ 4034823970bSFam Zheng error_setg(errp, "Invalid granularity, image may be corrupt"); 4044823970bSFam Zheng return -EFBIG; 4058aa1331cSFam Zheng } 406b0651b8cSFam Zheng if (l1_size > 512 * 1024 * 1024) { 407b0651b8cSFam Zheng /* Although with big capacity and small l1_entry_sectors, we can get a 408b0651b8cSFam Zheng * big l1_size, we don't want unbounded value to allocate the table. 409b0651b8cSFam Zheng * Limit it to 512M, which is 16PB for default cluster and L2 table 410b0651b8cSFam Zheng * size */ 4114823970bSFam Zheng error_setg(errp, "L1 size too big"); 412b0651b8cSFam Zheng return -EFBIG; 413b0651b8cSFam Zheng } 4148aa1331cSFam Zheng 4157267c094SAnthony Liguori s->extents = g_realloc(s->extents, 416b3976d3cSFam Zheng (s->num_extents + 1) * sizeof(VmdkExtent)); 417b3976d3cSFam Zheng extent = &s->extents[s->num_extents]; 418b3976d3cSFam Zheng s->num_extents++; 419b3976d3cSFam Zheng 420b3976d3cSFam Zheng memset(extent, 0, sizeof(VmdkExtent)); 421b3976d3cSFam Zheng extent->file = file; 422b3976d3cSFam Zheng extent->flat = flat; 423b3976d3cSFam Zheng extent->sectors = sectors; 424b3976d3cSFam Zheng extent->l1_table_offset = l1_offset; 425b3976d3cSFam Zheng extent->l1_backup_table_offset = l1_backup_offset; 426b3976d3cSFam Zheng extent->l1_size = l1_size; 427b3976d3cSFam Zheng extent->l1_entry_sectors = l2_size * cluster_sectors; 428b3976d3cSFam Zheng extent->l2_size = l2_size; 429301c7d38SFam Zheng extent->cluster_sectors = flat ? sectors : cluster_sectors; 430b3976d3cSFam Zheng 431b3976d3cSFam Zheng if (s->num_extents > 1) { 432b3976d3cSFam Zheng extent->end_sector = (*(extent - 1)).end_sector + extent->sectors; 433b3976d3cSFam Zheng } else { 434b3976d3cSFam Zheng extent->end_sector = extent->sectors; 435b3976d3cSFam Zheng } 436b3976d3cSFam Zheng bs->total_sectors = extent->end_sector; 4378aa1331cSFam Zheng if (new_extent) { 4388aa1331cSFam Zheng *new_extent = extent; 4398aa1331cSFam Zheng } 4408aa1331cSFam Zheng return 0; 441b3976d3cSFam Zheng } 442b3976d3cSFam Zheng 4434823970bSFam Zheng static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent, 4444823970bSFam Zheng Error **errp) 445019d6b8fSAnthony Liguori { 446b4b3ab14SFam Zheng int ret; 447b4b3ab14SFam Zheng int l1_size, i; 448b4b3ab14SFam Zheng 449b4b3ab14SFam Zheng /* read the L1 table */ 450b4b3ab14SFam Zheng l1_size = extent->l1_size * sizeof(uint32_t); 4517267c094SAnthony Liguori extent->l1_table = g_malloc(l1_size); 452b4b3ab14SFam Zheng ret = bdrv_pread(extent->file, 453b4b3ab14SFam Zheng extent->l1_table_offset, 454b4b3ab14SFam Zheng extent->l1_table, 455b4b3ab14SFam Zheng l1_size); 456b4b3ab14SFam Zheng if (ret < 0) { 4574823970bSFam Zheng error_setg_errno(errp, -ret, 4584823970bSFam Zheng "Could not read l1 table from extent '%s'", 4594823970bSFam Zheng extent->file->filename); 460b4b3ab14SFam Zheng goto fail_l1; 461b4b3ab14SFam Zheng } 462b4b3ab14SFam Zheng for (i = 0; i < extent->l1_size; i++) { 463b4b3ab14SFam Zheng le32_to_cpus(&extent->l1_table[i]); 464b4b3ab14SFam Zheng } 465b4b3ab14SFam Zheng 466b4b3ab14SFam Zheng if (extent->l1_backup_table_offset) { 4677267c094SAnthony Liguori extent->l1_backup_table = g_malloc(l1_size); 468b4b3ab14SFam Zheng ret = bdrv_pread(extent->file, 469b4b3ab14SFam Zheng extent->l1_backup_table_offset, 470b4b3ab14SFam Zheng extent->l1_backup_table, 471b4b3ab14SFam Zheng l1_size); 472b4b3ab14SFam Zheng if (ret < 0) { 4734823970bSFam Zheng error_setg_errno(errp, -ret, 4744823970bSFam Zheng "Could not read l1 backup table from extent '%s'", 4754823970bSFam Zheng extent->file->filename); 476b4b3ab14SFam Zheng goto fail_l1b; 477b4b3ab14SFam Zheng } 478b4b3ab14SFam Zheng for (i = 0; i < extent->l1_size; i++) { 479b4b3ab14SFam Zheng le32_to_cpus(&extent->l1_backup_table[i]); 480b4b3ab14SFam Zheng } 481b4b3ab14SFam Zheng } 482b4b3ab14SFam Zheng 483b4b3ab14SFam Zheng extent->l2_cache = 4847267c094SAnthony Liguori g_malloc(extent->l2_size * L2_CACHE_SIZE * sizeof(uint32_t)); 485b4b3ab14SFam Zheng return 0; 486b4b3ab14SFam Zheng fail_l1b: 4877267c094SAnthony Liguori g_free(extent->l1_backup_table); 488b4b3ab14SFam Zheng fail_l1: 4897267c094SAnthony Liguori g_free(extent->l1_table); 490b4b3ab14SFam Zheng return ret; 491b4b3ab14SFam Zheng } 492b4b3ab14SFam Zheng 493daac8fdcSFam Zheng static int vmdk_open_vmfs_sparse(BlockDriverState *bs, 49486c6b429SFam Zheng BlockDriverState *file, 4954823970bSFam Zheng int flags, Error **errp) 496b4b3ab14SFam Zheng { 497b4b3ab14SFam Zheng int ret; 498019d6b8fSAnthony Liguori uint32_t magic; 499019d6b8fSAnthony Liguori VMDK3Header header; 500b4b3ab14SFam Zheng VmdkExtent *extent; 501b4b3ab14SFam Zheng 50286c6b429SFam Zheng ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header)); 503b4b3ab14SFam Zheng if (ret < 0) { 5044823970bSFam Zheng error_setg_errno(errp, -ret, 5054823970bSFam Zheng "Could not read header from file '%s'", 5064823970bSFam Zheng file->filename); 50786c6b429SFam Zheng return ret; 508b3976d3cSFam Zheng } 509f6b61e54SFam Zheng ret = vmdk_add_extent(bs, file, false, 510b3976d3cSFam Zheng le32_to_cpu(header.disk_sectors), 511b4b3ab14SFam Zheng le32_to_cpu(header.l1dir_offset) << 9, 512f6b61e54SFam Zheng 0, 513f6b61e54SFam Zheng le32_to_cpu(header.l1dir_size), 514f6b61e54SFam Zheng 4096, 5158aa1331cSFam Zheng le32_to_cpu(header.granularity), 5164823970bSFam Zheng &extent, 5174823970bSFam Zheng errp); 5188aa1331cSFam Zheng if (ret < 0) { 5198aa1331cSFam Zheng return ret; 5208aa1331cSFam Zheng } 5214823970bSFam Zheng ret = vmdk_init_tables(bs, extent, errp); 522b4b3ab14SFam Zheng if (ret) { 52386c6b429SFam Zheng /* free extent allocated by vmdk_add_extent */ 52486c6b429SFam Zheng vmdk_free_last_extent(bs); 525b4b3ab14SFam Zheng } 526b4b3ab14SFam Zheng return ret; 527b4b3ab14SFam Zheng } 528b4b3ab14SFam Zheng 529f16f509dSFam Zheng static int vmdk_open_desc_file(BlockDriverState *bs, int flags, 5304823970bSFam Zheng uint64_t desc_offset, Error **errp); 531f16f509dSFam Zheng 532*a8842e6dSPaolo Bonzini static char *vmdk_read_desc(BlockDriverState *file, uint64_t desc_offset, 533*a8842e6dSPaolo Bonzini Error **errp) 534*a8842e6dSPaolo Bonzini { 535*a8842e6dSPaolo Bonzini int64_t size; 536*a8842e6dSPaolo Bonzini char *buf; 537*a8842e6dSPaolo Bonzini int ret; 538*a8842e6dSPaolo Bonzini 539*a8842e6dSPaolo Bonzini size = bdrv_getlength(file); 540*a8842e6dSPaolo Bonzini if (size < 0) { 541*a8842e6dSPaolo Bonzini error_setg_errno(errp, -size, "Could not access file"); 542*a8842e6dSPaolo Bonzini return NULL; 543*a8842e6dSPaolo Bonzini } 544*a8842e6dSPaolo Bonzini 545*a8842e6dSPaolo Bonzini size = MIN(size, 1 << 20); /* avoid unbounded allocation */ 546*a8842e6dSPaolo Bonzini buf = g_malloc0(size + 1); 547*a8842e6dSPaolo Bonzini 548*a8842e6dSPaolo Bonzini ret = bdrv_pread(file, desc_offset, buf, size); 549*a8842e6dSPaolo Bonzini if (ret < 0) { 550*a8842e6dSPaolo Bonzini error_setg_errno(errp, -ret, "Could not read from file"); 551*a8842e6dSPaolo Bonzini g_free(buf); 552*a8842e6dSPaolo Bonzini return NULL; 553*a8842e6dSPaolo Bonzini } 554*a8842e6dSPaolo Bonzini 555*a8842e6dSPaolo Bonzini return buf; 556*a8842e6dSPaolo Bonzini } 557*a8842e6dSPaolo Bonzini 55886c6b429SFam Zheng static int vmdk_open_vmdk4(BlockDriverState *bs, 55986c6b429SFam Zheng BlockDriverState *file, 5604823970bSFam Zheng int flags, Error **errp) 561b4b3ab14SFam Zheng { 562b4b3ab14SFam Zheng int ret; 563b4b3ab14SFam Zheng uint32_t magic; 564b4b3ab14SFam Zheng uint32_t l1_size, l1_entry_sectors; 565019d6b8fSAnthony Liguori VMDK4Header header; 566b4b3ab14SFam Zheng VmdkExtent *extent; 567f4c129a3SFam Zheng BDRVVmdkState *s = bs->opaque; 568bb45ded9SFam Zheng int64_t l1_backup_offset = 0; 569b4b3ab14SFam Zheng 57086c6b429SFam Zheng ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header)); 571b4b3ab14SFam Zheng if (ret < 0) { 5724823970bSFam Zheng error_setg_errno(errp, -ret, 5734823970bSFam Zheng "Could not read header from file '%s'", 5744823970bSFam Zheng file->filename); 575b3976d3cSFam Zheng } 5765a394b9eSStefan Hajnoczi if (header.capacity == 0) { 577e98768d4SFam Zheng uint64_t desc_offset = le64_to_cpu(header.desc_offset); 5785a394b9eSStefan Hajnoczi if (desc_offset) { 5794823970bSFam Zheng return vmdk_open_desc_file(bs, flags, desc_offset << 9, errp); 5805a394b9eSStefan Hajnoczi } 581f16f509dSFam Zheng } 58265bd155cSKevin Wolf 583f4c129a3SFam Zheng if (!s->create_type) { 584f4c129a3SFam Zheng s->create_type = g_strdup("monolithicSparse"); 585f4c129a3SFam Zheng } 586f4c129a3SFam Zheng 58765bd155cSKevin Wolf if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) { 58865bd155cSKevin Wolf /* 58965bd155cSKevin Wolf * The footer takes precedence over the header, so read it in. The 59065bd155cSKevin Wolf * footer starts at offset -1024 from the end: One sector for the 59165bd155cSKevin Wolf * footer, and another one for the end-of-stream marker. 59265bd155cSKevin Wolf */ 59365bd155cSKevin Wolf struct { 59465bd155cSKevin Wolf struct { 59565bd155cSKevin Wolf uint64_t val; 59665bd155cSKevin Wolf uint32_t size; 59765bd155cSKevin Wolf uint32_t type; 59865bd155cSKevin Wolf uint8_t pad[512 - 16]; 59965bd155cSKevin Wolf } QEMU_PACKED footer_marker; 60065bd155cSKevin Wolf 60165bd155cSKevin Wolf uint32_t magic; 60265bd155cSKevin Wolf VMDK4Header header; 60365bd155cSKevin Wolf uint8_t pad[512 - 4 - sizeof(VMDK4Header)]; 60465bd155cSKevin Wolf 60565bd155cSKevin Wolf struct { 60665bd155cSKevin Wolf uint64_t val; 60765bd155cSKevin Wolf uint32_t size; 60865bd155cSKevin Wolf uint32_t type; 60965bd155cSKevin Wolf uint8_t pad[512 - 16]; 61065bd155cSKevin Wolf } QEMU_PACKED eos_marker; 61165bd155cSKevin Wolf } QEMU_PACKED footer; 61265bd155cSKevin Wolf 61365bd155cSKevin Wolf ret = bdrv_pread(file, 61465bd155cSKevin Wolf bs->file->total_sectors * 512 - 1536, 61565bd155cSKevin Wolf &footer, sizeof(footer)); 61665bd155cSKevin Wolf if (ret < 0) { 61765bd155cSKevin Wolf return ret; 61865bd155cSKevin Wolf } 61965bd155cSKevin Wolf 62065bd155cSKevin Wolf /* Some sanity checks for the footer */ 62165bd155cSKevin Wolf if (be32_to_cpu(footer.magic) != VMDK4_MAGIC || 62265bd155cSKevin Wolf le32_to_cpu(footer.footer_marker.size) != 0 || 62365bd155cSKevin Wolf le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER || 62465bd155cSKevin Wolf le64_to_cpu(footer.eos_marker.val) != 0 || 62565bd155cSKevin Wolf le32_to_cpu(footer.eos_marker.size) != 0 || 62665bd155cSKevin Wolf le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM) 62765bd155cSKevin Wolf { 62865bd155cSKevin Wolf return -EINVAL; 62965bd155cSKevin Wolf } 63065bd155cSKevin Wolf 63165bd155cSKevin Wolf header = footer.header; 63265bd155cSKevin Wolf } 63365bd155cSKevin Wolf 634509d39aaSFam Zheng if (le32_to_cpu(header.version) > 3) { 63596c51eb5SFam Zheng char buf[64]; 63696c51eb5SFam Zheng snprintf(buf, sizeof(buf), "VMDK version %d", 63796c51eb5SFam Zheng le32_to_cpu(header.version)); 63896c51eb5SFam Zheng qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE, 63996c51eb5SFam Zheng bs->device_name, "vmdk", buf); 64096c51eb5SFam Zheng return -ENOTSUP; 641509d39aaSFam Zheng } else if (le32_to_cpu(header.version) == 3 && (flags & BDRV_O_RDWR)) { 642509d39aaSFam Zheng /* VMware KB 2064959 explains that version 3 added support for 643509d39aaSFam Zheng * persistent changed block tracking (CBT), and backup software can 644509d39aaSFam Zheng * read it as version=1 if it doesn't care about the changed area 645509d39aaSFam Zheng * information. So we are safe to enable read only. */ 646509d39aaSFam Zheng error_setg(errp, "VMDK version 3 must be read only"); 647509d39aaSFam Zheng return -EINVAL; 64896c51eb5SFam Zheng } 64996c51eb5SFam Zheng 650ca8804ceSFam Zheng if (le32_to_cpu(header.num_gtes_per_gt) > 512) { 651f8ce0403SFam Zheng error_report("L2 table size too big"); 652f8ce0403SFam Zheng return -EINVAL; 653f8ce0403SFam Zheng } 654f8ce0403SFam Zheng 655ca8804ceSFam Zheng l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt) 656b3976d3cSFam Zheng * le64_to_cpu(header.granularity); 65775d12341SStefan Weil if (l1_entry_sectors == 0) { 65886c6b429SFam Zheng return -EINVAL; 65986c6b429SFam Zheng } 660b3976d3cSFam Zheng l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1) 661b3976d3cSFam Zheng / l1_entry_sectors; 662bb45ded9SFam Zheng if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) { 663bb45ded9SFam Zheng l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9; 664bb45ded9SFam Zheng } 66534ceed81SFam Zheng if (bdrv_getlength(file) < 66634ceed81SFam Zheng le64_to_cpu(header.grain_offset) * BDRV_SECTOR_SIZE) { 66734ceed81SFam Zheng error_report("File truncated, expecting at least %lld bytes", 66834ceed81SFam Zheng le64_to_cpu(header.grain_offset) * BDRV_SECTOR_SIZE); 66934ceed81SFam Zheng return -EINVAL; 67034ceed81SFam Zheng } 67134ceed81SFam Zheng 6728aa1331cSFam Zheng ret = vmdk_add_extent(bs, file, false, 673b3976d3cSFam Zheng le64_to_cpu(header.capacity), 674b3976d3cSFam Zheng le64_to_cpu(header.gd_offset) << 9, 675bb45ded9SFam Zheng l1_backup_offset, 676b3976d3cSFam Zheng l1_size, 677ca8804ceSFam Zheng le32_to_cpu(header.num_gtes_per_gt), 6788aa1331cSFam Zheng le64_to_cpu(header.granularity), 6794823970bSFam Zheng &extent, 6804823970bSFam Zheng errp); 6818aa1331cSFam Zheng if (ret < 0) { 6828aa1331cSFam Zheng return ret; 6838aa1331cSFam Zheng } 684432bb170SFam Zheng extent->compressed = 685432bb170SFam Zheng le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE; 686d8a7b061SFam Zheng if (extent->compressed) { 687d8a7b061SFam Zheng g_free(s->create_type); 688d8a7b061SFam Zheng s->create_type = g_strdup("streamOptimized"); 689d8a7b061SFam Zheng } 690432bb170SFam Zheng extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER; 69114ead646SFam Zheng extent->version = le32_to_cpu(header.version); 69214ead646SFam Zheng extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN; 6934823970bSFam Zheng ret = vmdk_init_tables(bs, extent, errp); 694b4b3ab14SFam Zheng if (ret) { 69586c6b429SFam Zheng /* free extent allocated by vmdk_add_extent */ 69686c6b429SFam Zheng vmdk_free_last_extent(bs); 697019d6b8fSAnthony Liguori } 698b4b3ab14SFam Zheng return ret; 699b4b3ab14SFam Zheng } 700b4b3ab14SFam Zheng 7017fa60fa3SFam Zheng /* find an option value out of descriptor file */ 7027fa60fa3SFam Zheng static int vmdk_parse_description(const char *desc, const char *opt_name, 7037fa60fa3SFam Zheng char *buf, int buf_size) 7047fa60fa3SFam Zheng { 7057fa60fa3SFam Zheng char *opt_pos, *opt_end; 7067fa60fa3SFam Zheng const char *end = desc + strlen(desc); 7077fa60fa3SFam Zheng 7087fa60fa3SFam Zheng opt_pos = strstr(desc, opt_name); 7097fa60fa3SFam Zheng if (!opt_pos) { 71065f74725SFam Zheng return VMDK_ERROR; 7117fa60fa3SFam Zheng } 7127fa60fa3SFam Zheng /* Skip "=\"" following opt_name */ 7137fa60fa3SFam Zheng opt_pos += strlen(opt_name) + 2; 7147fa60fa3SFam Zheng if (opt_pos >= end) { 71565f74725SFam Zheng return VMDK_ERROR; 7167fa60fa3SFam Zheng } 7177fa60fa3SFam Zheng opt_end = opt_pos; 7187fa60fa3SFam Zheng while (opt_end < end && *opt_end != '"') { 7197fa60fa3SFam Zheng opt_end++; 7207fa60fa3SFam Zheng } 7217fa60fa3SFam Zheng if (opt_end == end || buf_size < opt_end - opt_pos + 1) { 72265f74725SFam Zheng return VMDK_ERROR; 7237fa60fa3SFam Zheng } 7247fa60fa3SFam Zheng pstrcpy(buf, opt_end - opt_pos + 1, opt_pos); 72565f74725SFam Zheng return VMDK_OK; 7267fa60fa3SFam Zheng } 7277fa60fa3SFam Zheng 72886c6b429SFam Zheng /* Open an extent file and append to bs array */ 72986c6b429SFam Zheng static int vmdk_open_sparse(BlockDriverState *bs, 73086c6b429SFam Zheng BlockDriverState *file, 7314823970bSFam Zheng int flags, Error **errp) 73286c6b429SFam Zheng { 73386c6b429SFam Zheng uint32_t magic; 73486c6b429SFam Zheng 73586c6b429SFam Zheng if (bdrv_pread(file, 0, &magic, sizeof(magic)) != sizeof(magic)) { 73686c6b429SFam Zheng return -EIO; 73786c6b429SFam Zheng } 73886c6b429SFam Zheng 73986c6b429SFam Zheng magic = be32_to_cpu(magic); 74086c6b429SFam Zheng switch (magic) { 74186c6b429SFam Zheng case VMDK3_MAGIC: 7424823970bSFam Zheng return vmdk_open_vmfs_sparse(bs, file, flags, errp); 74386c6b429SFam Zheng break; 74486c6b429SFam Zheng case VMDK4_MAGIC: 7454823970bSFam Zheng return vmdk_open_vmdk4(bs, file, flags, errp); 74686c6b429SFam Zheng break; 74786c6b429SFam Zheng default: 74815bac0d5SStefan Weil return -EMEDIUMTYPE; 74986c6b429SFam Zheng break; 75086c6b429SFam Zheng } 75186c6b429SFam Zheng } 75286c6b429SFam Zheng 7537fa60fa3SFam Zheng static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, 7544823970bSFam Zheng const char *desc_file_path, Error **errp) 7557fa60fa3SFam Zheng { 7567fa60fa3SFam Zheng int ret; 7577fa60fa3SFam Zheng char access[11]; 7587fa60fa3SFam Zheng char type[11]; 7597fa60fa3SFam Zheng char fname[512]; 7607fa60fa3SFam Zheng const char *p = desc; 7617fa60fa3SFam Zheng int64_t sectors = 0; 7627fa60fa3SFam Zheng int64_t flat_offset; 76386c6b429SFam Zheng char extent_path[PATH_MAX]; 76486c6b429SFam Zheng BlockDriverState *extent_file; 765f4c129a3SFam Zheng BDRVVmdkState *s = bs->opaque; 766f4c129a3SFam Zheng VmdkExtent *extent; 7677fa60fa3SFam Zheng 7687fa60fa3SFam Zheng while (*p) { 7697fa60fa3SFam Zheng /* parse extent line: 7707fa60fa3SFam Zheng * RW [size in sectors] FLAT "file-name.vmdk" OFFSET 7717fa60fa3SFam Zheng * or 7727fa60fa3SFam Zheng * RW [size in sectors] SPARSE "file-name.vmdk" 7737fa60fa3SFam Zheng */ 7747fa60fa3SFam Zheng flat_offset = -1; 775cd923475SPhilipp Hahn ret = sscanf(p, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64, 7767fa60fa3SFam Zheng access, §ors, type, fname, &flat_offset); 7777fa60fa3SFam Zheng if (ret < 4 || strcmp(access, "RW")) { 7787fa60fa3SFam Zheng goto next_line; 7797fa60fa3SFam Zheng } else if (!strcmp(type, "FLAT")) { 7807fa60fa3SFam Zheng if (ret != 5 || flat_offset < 0) { 7814823970bSFam Zheng error_setg(errp, "Invalid extent lines: \n%s", p); 7827fa60fa3SFam Zheng return -EINVAL; 7837fa60fa3SFam Zheng } 784dbbcaa8dSFam Zheng } else if (!strcmp(type, "VMFS")) { 785b47053bdSFam Zheng if (ret == 4) { 786dbbcaa8dSFam Zheng flat_offset = 0; 787b47053bdSFam Zheng } else { 788b47053bdSFam Zheng error_setg(errp, "Invalid extent lines:\n%s", p); 789b47053bdSFam Zheng return -EINVAL; 790b47053bdSFam Zheng } 7917fa60fa3SFam Zheng } else if (ret != 4) { 7924823970bSFam Zheng error_setg(errp, "Invalid extent lines:\n%s", p); 7937fa60fa3SFam Zheng return -EINVAL; 7947fa60fa3SFam Zheng } 7957fa60fa3SFam Zheng 7967fa60fa3SFam Zheng if (sectors <= 0 || 797daac8fdcSFam Zheng (strcmp(type, "FLAT") && strcmp(type, "SPARSE") && 79804d542c8SPaolo Bonzini strcmp(type, "VMFS") && strcmp(type, "VMFSSPARSE")) || 7997fa60fa3SFam Zheng (strcmp(access, "RW"))) { 8007fa60fa3SFam Zheng goto next_line; 8017fa60fa3SFam Zheng } 8027fa60fa3SFam Zheng 8037fa60fa3SFam Zheng path_combine(extent_path, sizeof(extent_path), 8047fa60fa3SFam Zheng desc_file_path, fname); 8052e40134bSMax Reitz extent_file = NULL; 8062e40134bSMax Reitz ret = bdrv_open(&extent_file, extent_path, NULL, NULL, 8072e40134bSMax Reitz bs->open_flags | BDRV_O_PROTOCOL, NULL, errp); 8087fa60fa3SFam Zheng if (ret) { 8097fa60fa3SFam Zheng return ret; 8107fa60fa3SFam Zheng } 81186c6b429SFam Zheng 81286c6b429SFam Zheng /* save to extents array */ 81304d542c8SPaolo Bonzini if (!strcmp(type, "FLAT") || !strcmp(type, "VMFS")) { 81486c6b429SFam Zheng /* FLAT extent */ 81586c6b429SFam Zheng 8168aa1331cSFam Zheng ret = vmdk_add_extent(bs, extent_file, true, sectors, 8174823970bSFam Zheng 0, 0, 0, 0, 0, &extent, errp); 8188aa1331cSFam Zheng if (ret < 0) { 8198aa1331cSFam Zheng return ret; 8208aa1331cSFam Zheng } 821f16f509dSFam Zheng extent->flat_start_offset = flat_offset << 9; 822daac8fdcSFam Zheng } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) { 823daac8fdcSFam Zheng /* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/ 8244823970bSFam Zheng ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, errp); 82586c6b429SFam Zheng if (ret) { 8264f6fd349SFam Zheng bdrv_unref(extent_file); 82786c6b429SFam Zheng return ret; 82886c6b429SFam Zheng } 829f4c129a3SFam Zheng extent = &s->extents[s->num_extents - 1]; 8307fa60fa3SFam Zheng } else { 8314823970bSFam Zheng error_setg(errp, "Unsupported extent type '%s'", type); 8327fa60fa3SFam Zheng return -ENOTSUP; 8337fa60fa3SFam Zheng } 834f4c129a3SFam Zheng extent->type = g_strdup(type); 8357fa60fa3SFam Zheng next_line: 8367fa60fa3SFam Zheng /* move to next line */ 837899f1ae2SFam Zheng while (*p) { 838899f1ae2SFam Zheng if (*p == '\n') { 8397fa60fa3SFam Zheng p++; 840899f1ae2SFam Zheng break; 8417fa60fa3SFam Zheng } 8427fa60fa3SFam Zheng p++; 8437fa60fa3SFam Zheng } 844899f1ae2SFam Zheng } 8457fa60fa3SFam Zheng return 0; 8467fa60fa3SFam Zheng } 8477fa60fa3SFam Zheng 848f16f509dSFam Zheng static int vmdk_open_desc_file(BlockDriverState *bs, int flags, 8494823970bSFam Zheng uint64_t desc_offset, Error **errp) 8507fa60fa3SFam Zheng { 8517fa60fa3SFam Zheng int ret; 852*a8842e6dSPaolo Bonzini char *buf; 8537fa60fa3SFam Zheng char ct[128]; 8547fa60fa3SFam Zheng BDRVVmdkState *s = bs->opaque; 8557fa60fa3SFam Zheng 856*a8842e6dSPaolo Bonzini buf = vmdk_read_desc(bs->file, desc_offset, errp); 857*a8842e6dSPaolo Bonzini if (!buf) { 8580bed087dSEvgeny Budilovsky return -EINVAL; 8590bed087dSEvgeny Budilovsky goto exit; 8600bed087dSEvgeny Budilovsky } 861*a8842e6dSPaolo Bonzini 8627fa60fa3SFam Zheng if (vmdk_parse_description(buf, "createType", ct, sizeof(ct))) { 8630bed087dSEvgeny Budilovsky ret = -EMEDIUMTYPE; 8640bed087dSEvgeny Budilovsky goto exit; 8657fa60fa3SFam Zheng } 8666398de51SFam Zheng if (strcmp(ct, "monolithicFlat") && 86704d542c8SPaolo Bonzini strcmp(ct, "vmfs") && 868daac8fdcSFam Zheng strcmp(ct, "vmfsSparse") && 86986c6b429SFam Zheng strcmp(ct, "twoGbMaxExtentSparse") && 8706398de51SFam Zheng strcmp(ct, "twoGbMaxExtentFlat")) { 8714823970bSFam Zheng error_setg(errp, "Unsupported image type '%s'", ct); 8720bed087dSEvgeny Budilovsky ret = -ENOTSUP; 8730bed087dSEvgeny Budilovsky goto exit; 8747fa60fa3SFam Zheng } 875f4c129a3SFam Zheng s->create_type = g_strdup(ct); 8767fa60fa3SFam Zheng s->desc_offset = 0; 8774823970bSFam Zheng ret = vmdk_parse_extents(buf, bs, bs->file->filename, errp); 8780bed087dSEvgeny Budilovsky exit: 8790bed087dSEvgeny Budilovsky g_free(buf); 8800bed087dSEvgeny Budilovsky return ret; 8817fa60fa3SFam Zheng } 8827fa60fa3SFam Zheng 883015a1036SMax Reitz static int vmdk_open(BlockDriverState *bs, QDict *options, int flags, 884015a1036SMax Reitz Error **errp) 885b4b3ab14SFam Zheng { 88686c6b429SFam Zheng int ret; 88786c6b429SFam Zheng BDRVVmdkState *s = bs->opaque; 888b4b3ab14SFam Zheng 8894823970bSFam Zheng if (vmdk_open_sparse(bs, bs->file, flags, errp) == 0) { 89086c6b429SFam Zheng s->desc_offset = 0x200; 891bae0a0ccSPaolo Bonzini } else { 8924823970bSFam Zheng ret = vmdk_open_desc_file(bs, flags, 0, errp); 893bae0a0ccSPaolo Bonzini if (ret) { 894bae0a0ccSPaolo Bonzini goto fail; 895bae0a0ccSPaolo Bonzini } 896bae0a0ccSPaolo Bonzini } 89786c6b429SFam Zheng /* try to open parent images, if exist */ 89886c6b429SFam Zheng ret = vmdk_parent_open(bs); 89986c6b429SFam Zheng if (ret) { 900bae0a0ccSPaolo Bonzini goto fail; 901b4b3ab14SFam Zheng } 902f4c129a3SFam Zheng s->cid = vmdk_read_cid(bs, 0); 90386c6b429SFam Zheng s->parent_cid = vmdk_read_cid(bs, 1); 904848c66e8SPaolo Bonzini qemu_co_mutex_init(&s->lock); 9052bc3166cSKevin Wolf 9062bc3166cSKevin Wolf /* Disable migration when VMDK images are used */ 9072bc3166cSKevin Wolf error_set(&s->migration_blocker, 9082bc3166cSKevin Wolf QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, 9092bc3166cSKevin Wolf "vmdk", bs->device_name, "live migration"); 9102bc3166cSKevin Wolf migrate_add_blocker(s->migration_blocker); 9112bc3166cSKevin Wolf 9122bc3166cSKevin Wolf return 0; 913bae0a0ccSPaolo Bonzini 914bae0a0ccSPaolo Bonzini fail: 915f4c129a3SFam Zheng g_free(s->create_type); 916f4c129a3SFam Zheng s->create_type = NULL; 917bae0a0ccSPaolo Bonzini vmdk_free_extents(bs); 918bae0a0ccSPaolo Bonzini return ret; 919019d6b8fSAnthony Liguori } 920019d6b8fSAnthony Liguori 921d34682cdSKevin Wolf 922d34682cdSKevin Wolf static int vmdk_refresh_limits(BlockDriverState *bs) 923d34682cdSKevin Wolf { 924d34682cdSKevin Wolf BDRVVmdkState *s = bs->opaque; 925d34682cdSKevin Wolf int i; 926d34682cdSKevin Wolf 927d34682cdSKevin Wolf for (i = 0; i < s->num_extents; i++) { 928d34682cdSKevin Wolf if (!s->extents[i].flat) { 929d34682cdSKevin Wolf bs->bl.write_zeroes_alignment = 930d34682cdSKevin Wolf MAX(bs->bl.write_zeroes_alignment, 931d34682cdSKevin Wolf s->extents[i].cluster_sectors); 932d34682cdSKevin Wolf } 933d34682cdSKevin Wolf } 934d34682cdSKevin Wolf 935d34682cdSKevin Wolf return 0; 936d34682cdSKevin Wolf } 937d34682cdSKevin Wolf 938b3976d3cSFam Zheng static int get_whole_cluster(BlockDriverState *bs, 939b3976d3cSFam Zheng VmdkExtent *extent, 940b3976d3cSFam Zheng uint64_t cluster_offset, 941b3976d3cSFam Zheng uint64_t offset, 942b3976d3cSFam Zheng bool allocate) 943019d6b8fSAnthony Liguori { 944bf81507dSFam Zheng int ret = VMDK_OK; 945bf81507dSFam Zheng uint8_t *whole_grain = NULL; 946019d6b8fSAnthony Liguori 9470e69c543SFam Zheng /* we will be here if it's first write on non-exist grain(cluster). 9480e69c543SFam Zheng * try to read from parent image, if exist */ 949b171271aSKevin Wolf if (bs->backing_hd) { 950bf81507dSFam Zheng whole_grain = 951bf81507dSFam Zheng qemu_blockalign(bs, extent->cluster_sectors << BDRV_SECTOR_BITS); 952ae261c86SFam Zheng if (!vmdk_is_cid_valid(bs)) { 953bf81507dSFam Zheng ret = VMDK_ERROR; 954bf81507dSFam Zheng goto exit; 955ae261c86SFam Zheng } 956019d6b8fSAnthony Liguori 9570e69c543SFam Zheng /* floor offset to cluster */ 9580e69c543SFam Zheng offset -= offset % (extent->cluster_sectors * 512); 959c336500dSKevin Wolf ret = bdrv_read(bs->backing_hd, offset >> 9, whole_grain, 960b3976d3cSFam Zheng extent->cluster_sectors); 961c336500dSKevin Wolf if (ret < 0) { 962bf81507dSFam Zheng ret = VMDK_ERROR; 963bf81507dSFam Zheng goto exit; 964c336500dSKevin Wolf } 965019d6b8fSAnthony Liguori 9660e69c543SFam Zheng /* Write grain only into the active image */ 967b3976d3cSFam Zheng ret = bdrv_write(extent->file, cluster_offset, whole_grain, 968b3976d3cSFam Zheng extent->cluster_sectors); 969c336500dSKevin Wolf if (ret < 0) { 970bf81507dSFam Zheng ret = VMDK_ERROR; 971bf81507dSFam Zheng goto exit; 972019d6b8fSAnthony Liguori } 973019d6b8fSAnthony Liguori } 974bf81507dSFam Zheng exit: 975bf81507dSFam Zheng qemu_vfree(whole_grain); 976bf81507dSFam Zheng return ret; 977019d6b8fSAnthony Liguori } 978019d6b8fSAnthony Liguori 979b3976d3cSFam Zheng static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data) 980019d6b8fSAnthony Liguori { 981e304e8e5SFam Zheng uint32_t offset; 982e304e8e5SFam Zheng QEMU_BUILD_BUG_ON(sizeof(offset) != sizeof(m_data->offset)); 983e304e8e5SFam Zheng offset = cpu_to_le32(m_data->offset); 984019d6b8fSAnthony Liguori /* update L2 table */ 985b3976d3cSFam Zheng if (bdrv_pwrite_sync( 986b3976d3cSFam Zheng extent->file, 987b3976d3cSFam Zheng ((int64_t)m_data->l2_offset * 512) 988b3976d3cSFam Zheng + (m_data->l2_index * sizeof(m_data->offset)), 989e304e8e5SFam Zheng &offset, sizeof(offset)) < 0) { 99065f74725SFam Zheng return VMDK_ERROR; 991b3976d3cSFam Zheng } 992019d6b8fSAnthony Liguori /* update backup L2 table */ 993b3976d3cSFam Zheng if (extent->l1_backup_table_offset != 0) { 994b3976d3cSFam Zheng m_data->l2_offset = extent->l1_backup_table[m_data->l1_index]; 995b3976d3cSFam Zheng if (bdrv_pwrite_sync( 996b3976d3cSFam Zheng extent->file, 997b3976d3cSFam Zheng ((int64_t)m_data->l2_offset * 512) 998b3976d3cSFam Zheng + (m_data->l2_index * sizeof(m_data->offset)), 999e304e8e5SFam Zheng &offset, sizeof(offset)) < 0) { 100065f74725SFam Zheng return VMDK_ERROR; 1001019d6b8fSAnthony Liguori } 1002b3976d3cSFam Zheng } 1003cdeaf1f1SFam Zheng if (m_data->l2_cache_entry) { 1004cdeaf1f1SFam Zheng *m_data->l2_cache_entry = offset; 1005cdeaf1f1SFam Zheng } 1006019d6b8fSAnthony Liguori 100765f74725SFam Zheng return VMDK_OK; 1008019d6b8fSAnthony Liguori } 1009019d6b8fSAnthony Liguori 101091b85bd3SFam Zheng static int get_cluster_offset(BlockDriverState *bs, 1011b3976d3cSFam Zheng VmdkExtent *extent, 1012b3976d3cSFam Zheng VmdkMetaData *m_data, 101391b85bd3SFam Zheng uint64_t offset, 101491b85bd3SFam Zheng int allocate, 101591b85bd3SFam Zheng uint64_t *cluster_offset) 1016019d6b8fSAnthony Liguori { 1017019d6b8fSAnthony Liguori unsigned int l1_index, l2_offset, l2_index; 1018019d6b8fSAnthony Liguori int min_index, i, j; 1019e304e8e5SFam Zheng uint32_t min_count, *l2_table; 102014ead646SFam Zheng bool zeroed = false; 1021019d6b8fSAnthony Liguori 1022ae261c86SFam Zheng if (m_data) { 1023019d6b8fSAnthony Liguori m_data->valid = 0; 1024ae261c86SFam Zheng } 102591b85bd3SFam Zheng if (extent->flat) { 10267fa60fa3SFam Zheng *cluster_offset = extent->flat_start_offset; 102765f74725SFam Zheng return VMDK_OK; 102891b85bd3SFam Zheng } 1029019d6b8fSAnthony Liguori 10306398de51SFam Zheng offset -= (extent->end_sector - extent->sectors) * SECTOR_SIZE; 1031b3976d3cSFam Zheng l1_index = (offset >> 9) / extent->l1_entry_sectors; 1032b3976d3cSFam Zheng if (l1_index >= extent->l1_size) { 103365f74725SFam Zheng return VMDK_ERROR; 1034b3976d3cSFam Zheng } 1035b3976d3cSFam Zheng l2_offset = extent->l1_table[l1_index]; 1036b3976d3cSFam Zheng if (!l2_offset) { 103765f74725SFam Zheng return VMDK_UNALLOC; 1038b3976d3cSFam Zheng } 1039019d6b8fSAnthony Liguori for (i = 0; i < L2_CACHE_SIZE; i++) { 1040b3976d3cSFam Zheng if (l2_offset == extent->l2_cache_offsets[i]) { 1041019d6b8fSAnthony Liguori /* increment the hit count */ 1042b3976d3cSFam Zheng if (++extent->l2_cache_counts[i] == 0xffffffff) { 1043019d6b8fSAnthony Liguori for (j = 0; j < L2_CACHE_SIZE; j++) { 1044b3976d3cSFam Zheng extent->l2_cache_counts[j] >>= 1; 1045019d6b8fSAnthony Liguori } 1046019d6b8fSAnthony Liguori } 1047b3976d3cSFam Zheng l2_table = extent->l2_cache + (i * extent->l2_size); 1048019d6b8fSAnthony Liguori goto found; 1049019d6b8fSAnthony Liguori } 1050019d6b8fSAnthony Liguori } 1051019d6b8fSAnthony Liguori /* not found: load a new entry in the least used one */ 1052019d6b8fSAnthony Liguori min_index = 0; 1053019d6b8fSAnthony Liguori min_count = 0xffffffff; 1054019d6b8fSAnthony Liguori for (i = 0; i < L2_CACHE_SIZE; i++) { 1055b3976d3cSFam Zheng if (extent->l2_cache_counts[i] < min_count) { 1056b3976d3cSFam Zheng min_count = extent->l2_cache_counts[i]; 1057019d6b8fSAnthony Liguori min_index = i; 1058019d6b8fSAnthony Liguori } 1059019d6b8fSAnthony Liguori } 1060b3976d3cSFam Zheng l2_table = extent->l2_cache + (min_index * extent->l2_size); 1061b3976d3cSFam Zheng if (bdrv_pread( 1062b3976d3cSFam Zheng extent->file, 1063b3976d3cSFam Zheng (int64_t)l2_offset * 512, 1064b3976d3cSFam Zheng l2_table, 1065b3976d3cSFam Zheng extent->l2_size * sizeof(uint32_t) 1066b3976d3cSFam Zheng ) != extent->l2_size * sizeof(uint32_t)) { 106765f74725SFam Zheng return VMDK_ERROR; 1068b3976d3cSFam Zheng } 1069019d6b8fSAnthony Liguori 1070b3976d3cSFam Zheng extent->l2_cache_offsets[min_index] = l2_offset; 1071b3976d3cSFam Zheng extent->l2_cache_counts[min_index] = 1; 1072019d6b8fSAnthony Liguori found: 1073b3976d3cSFam Zheng l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size; 107491b85bd3SFam Zheng *cluster_offset = le32_to_cpu(l2_table[l2_index]); 1075019d6b8fSAnthony Liguori 1076cdeaf1f1SFam Zheng if (m_data) { 1077cdeaf1f1SFam Zheng m_data->valid = 1; 1078cdeaf1f1SFam Zheng m_data->l1_index = l1_index; 1079cdeaf1f1SFam Zheng m_data->l2_index = l2_index; 1080cdeaf1f1SFam Zheng m_data->offset = *cluster_offset; 1081cdeaf1f1SFam Zheng m_data->l2_offset = l2_offset; 1082cdeaf1f1SFam Zheng m_data->l2_cache_entry = &l2_table[l2_index]; 1083cdeaf1f1SFam Zheng } 108414ead646SFam Zheng if (extent->has_zero_grain && *cluster_offset == VMDK_GTE_ZEROED) { 108514ead646SFam Zheng zeroed = true; 108614ead646SFam Zheng } 108714ead646SFam Zheng 108814ead646SFam Zheng if (!*cluster_offset || zeroed) { 108991b85bd3SFam Zheng if (!allocate) { 109014ead646SFam Zheng return zeroed ? VMDK_ZEROED : VMDK_UNALLOC; 109191b85bd3SFam Zheng } 10929949f97eSKevin Wolf 1093ae261c86SFam Zheng /* Avoid the L2 tables update for the images that have snapshots. */ 109491b85bd3SFam Zheng *cluster_offset = bdrv_getlength(extent->file); 10952b2c8c5dSFam Zheng if (!extent->compressed) { 1096b3976d3cSFam Zheng bdrv_truncate( 1097b3976d3cSFam Zheng extent->file, 109891b85bd3SFam Zheng *cluster_offset + (extent->cluster_sectors << 9) 1099b3976d3cSFam Zheng ); 11002b2c8c5dSFam Zheng } 1101019d6b8fSAnthony Liguori 110291b85bd3SFam Zheng *cluster_offset >>= 9; 1103e304e8e5SFam Zheng l2_table[l2_index] = cpu_to_le32(*cluster_offset); 11049949f97eSKevin Wolf 1105019d6b8fSAnthony Liguori /* First of all we write grain itself, to avoid race condition 1106019d6b8fSAnthony Liguori * that may to corrupt the image. 1107019d6b8fSAnthony Liguori * This problem may occur because of insufficient space on host disk 1108019d6b8fSAnthony Liguori * or inappropriate VM shutdown. 1109019d6b8fSAnthony Liguori */ 1110b3976d3cSFam Zheng if (get_whole_cluster( 1111ae261c86SFam Zheng bs, extent, *cluster_offset, offset, allocate) == -1) { 111265f74725SFam Zheng return VMDK_ERROR; 1113ae261c86SFam Zheng } 1114019d6b8fSAnthony Liguori 1115019d6b8fSAnthony Liguori if (m_data) { 1116e304e8e5SFam Zheng m_data->offset = *cluster_offset; 1117019d6b8fSAnthony Liguori } 1118019d6b8fSAnthony Liguori } 111991b85bd3SFam Zheng *cluster_offset <<= 9; 112065f74725SFam Zheng return VMDK_OK; 1121019d6b8fSAnthony Liguori } 1122019d6b8fSAnthony Liguori 1123b3976d3cSFam Zheng static VmdkExtent *find_extent(BDRVVmdkState *s, 1124b3976d3cSFam Zheng int64_t sector_num, VmdkExtent *start_hint) 1125b3976d3cSFam Zheng { 1126b3976d3cSFam Zheng VmdkExtent *extent = start_hint; 1127b3976d3cSFam Zheng 1128b3976d3cSFam Zheng if (!extent) { 1129b3976d3cSFam Zheng extent = &s->extents[0]; 1130b3976d3cSFam Zheng } 1131b3976d3cSFam Zheng while (extent < &s->extents[s->num_extents]) { 1132b3976d3cSFam Zheng if (sector_num < extent->end_sector) { 1133b3976d3cSFam Zheng return extent; 1134b3976d3cSFam Zheng } 1135b3976d3cSFam Zheng extent++; 1136b3976d3cSFam Zheng } 1137b3976d3cSFam Zheng return NULL; 1138b3976d3cSFam Zheng } 1139b3976d3cSFam Zheng 1140b6b8a333SPaolo Bonzini static int64_t coroutine_fn vmdk_co_get_block_status(BlockDriverState *bs, 1141f8a2e5e3SStefan Hajnoczi int64_t sector_num, int nb_sectors, int *pnum) 1142019d6b8fSAnthony Liguori { 1143019d6b8fSAnthony Liguori BDRVVmdkState *s = bs->opaque; 1144b3976d3cSFam Zheng int64_t index_in_cluster, n, ret; 1145b3976d3cSFam Zheng uint64_t offset; 1146b3976d3cSFam Zheng VmdkExtent *extent; 1147b3976d3cSFam Zheng 1148b3976d3cSFam Zheng extent = find_extent(s, sector_num, NULL); 1149b3976d3cSFam Zheng if (!extent) { 1150b3976d3cSFam Zheng return 0; 1151b3976d3cSFam Zheng } 1152f8a2e5e3SStefan Hajnoczi qemu_co_mutex_lock(&s->lock); 115391b85bd3SFam Zheng ret = get_cluster_offset(bs, extent, NULL, 115491b85bd3SFam Zheng sector_num * 512, 0, &offset); 1155f8a2e5e3SStefan Hajnoczi qemu_co_mutex_unlock(&s->lock); 115614ead646SFam Zheng 11574bc74be9SPaolo Bonzini switch (ret) { 11584bc74be9SPaolo Bonzini case VMDK_ERROR: 11594bc74be9SPaolo Bonzini ret = -EIO; 11604bc74be9SPaolo Bonzini break; 11614bc74be9SPaolo Bonzini case VMDK_UNALLOC: 11624bc74be9SPaolo Bonzini ret = 0; 11634bc74be9SPaolo Bonzini break; 11644bc74be9SPaolo Bonzini case VMDK_ZEROED: 11654bc74be9SPaolo Bonzini ret = BDRV_BLOCK_ZERO; 11664bc74be9SPaolo Bonzini break; 11674bc74be9SPaolo Bonzini case VMDK_OK: 11684bc74be9SPaolo Bonzini ret = BDRV_BLOCK_DATA; 11694bc74be9SPaolo Bonzini if (extent->file == bs->file) { 11704bc74be9SPaolo Bonzini ret |= BDRV_BLOCK_OFFSET_VALID | offset; 11714bc74be9SPaolo Bonzini } 11724bc74be9SPaolo Bonzini 11734bc74be9SPaolo Bonzini break; 11744bc74be9SPaolo Bonzini } 117591b85bd3SFam Zheng 1176b3976d3cSFam Zheng index_in_cluster = sector_num % extent->cluster_sectors; 1177b3976d3cSFam Zheng n = extent->cluster_sectors - index_in_cluster; 1178ae261c86SFam Zheng if (n > nb_sectors) { 1179019d6b8fSAnthony Liguori n = nb_sectors; 1180ae261c86SFam Zheng } 1181019d6b8fSAnthony Liguori *pnum = n; 1182b3976d3cSFam Zheng return ret; 1183019d6b8fSAnthony Liguori } 1184019d6b8fSAnthony Liguori 1185dd3f6ee2SFam Zheng static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset, 1186dd3f6ee2SFam Zheng int64_t offset_in_cluster, const uint8_t *buf, 1187dd3f6ee2SFam Zheng int nb_sectors, int64_t sector_num) 1188dd3f6ee2SFam Zheng { 1189dd3f6ee2SFam Zheng int ret; 11902b2c8c5dSFam Zheng VmdkGrainMarker *data = NULL; 11912b2c8c5dSFam Zheng uLongf buf_len; 1192dd3f6ee2SFam Zheng const uint8_t *write_buf = buf; 1193dd3f6ee2SFam Zheng int write_len = nb_sectors * 512; 1194dd3f6ee2SFam Zheng 11952b2c8c5dSFam Zheng if (extent->compressed) { 11962b2c8c5dSFam Zheng if (!extent->has_marker) { 11972b2c8c5dSFam Zheng ret = -EINVAL; 11982b2c8c5dSFam Zheng goto out; 11992b2c8c5dSFam Zheng } 12002b2c8c5dSFam Zheng buf_len = (extent->cluster_sectors << 9) * 2; 12012b2c8c5dSFam Zheng data = g_malloc(buf_len + sizeof(VmdkGrainMarker)); 12022b2c8c5dSFam Zheng if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK || 12032b2c8c5dSFam Zheng buf_len == 0) { 12042b2c8c5dSFam Zheng ret = -EINVAL; 12052b2c8c5dSFam Zheng goto out; 12062b2c8c5dSFam Zheng } 12072b2c8c5dSFam Zheng data->lba = sector_num; 12082b2c8c5dSFam Zheng data->size = buf_len; 12092b2c8c5dSFam Zheng write_buf = (uint8_t *)data; 12102b2c8c5dSFam Zheng write_len = buf_len + sizeof(VmdkGrainMarker); 12112b2c8c5dSFam Zheng } 1212dd3f6ee2SFam Zheng ret = bdrv_pwrite(extent->file, 1213dd3f6ee2SFam Zheng cluster_offset + offset_in_cluster, 1214dd3f6ee2SFam Zheng write_buf, 1215dd3f6ee2SFam Zheng write_len); 1216dd3f6ee2SFam Zheng if (ret != write_len) { 1217dd3f6ee2SFam Zheng ret = ret < 0 ? ret : -EIO; 1218dd3f6ee2SFam Zheng goto out; 1219dd3f6ee2SFam Zheng } 1220dd3f6ee2SFam Zheng ret = 0; 1221dd3f6ee2SFam Zheng out: 12222b2c8c5dSFam Zheng g_free(data); 1223dd3f6ee2SFam Zheng return ret; 1224dd3f6ee2SFam Zheng } 1225dd3f6ee2SFam Zheng 1226dd3f6ee2SFam Zheng static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset, 1227dd3f6ee2SFam Zheng int64_t offset_in_cluster, uint8_t *buf, 1228dd3f6ee2SFam Zheng int nb_sectors) 1229dd3f6ee2SFam Zheng { 1230dd3f6ee2SFam Zheng int ret; 12312b2c8c5dSFam Zheng int cluster_bytes, buf_bytes; 12322b2c8c5dSFam Zheng uint8_t *cluster_buf, *compressed_data; 12332b2c8c5dSFam Zheng uint8_t *uncomp_buf; 12342b2c8c5dSFam Zheng uint32_t data_len; 12352b2c8c5dSFam Zheng VmdkGrainMarker *marker; 12362b2c8c5dSFam Zheng uLongf buf_len; 1237dd3f6ee2SFam Zheng 12382b2c8c5dSFam Zheng 12392b2c8c5dSFam Zheng if (!extent->compressed) { 1240dd3f6ee2SFam Zheng ret = bdrv_pread(extent->file, 1241dd3f6ee2SFam Zheng cluster_offset + offset_in_cluster, 1242dd3f6ee2SFam Zheng buf, nb_sectors * 512); 1243dd3f6ee2SFam Zheng if (ret == nb_sectors * 512) { 1244dd3f6ee2SFam Zheng return 0; 1245dd3f6ee2SFam Zheng } else { 1246dd3f6ee2SFam Zheng return -EIO; 1247dd3f6ee2SFam Zheng } 1248dd3f6ee2SFam Zheng } 12492b2c8c5dSFam Zheng cluster_bytes = extent->cluster_sectors * 512; 12502b2c8c5dSFam Zheng /* Read two clusters in case GrainMarker + compressed data > one cluster */ 12512b2c8c5dSFam Zheng buf_bytes = cluster_bytes * 2; 12522b2c8c5dSFam Zheng cluster_buf = g_malloc(buf_bytes); 12532b2c8c5dSFam Zheng uncomp_buf = g_malloc(cluster_bytes); 12542b2c8c5dSFam Zheng ret = bdrv_pread(extent->file, 12552b2c8c5dSFam Zheng cluster_offset, 12562b2c8c5dSFam Zheng cluster_buf, buf_bytes); 12572b2c8c5dSFam Zheng if (ret < 0) { 12582b2c8c5dSFam Zheng goto out; 12592b2c8c5dSFam Zheng } 12602b2c8c5dSFam Zheng compressed_data = cluster_buf; 12612b2c8c5dSFam Zheng buf_len = cluster_bytes; 12622b2c8c5dSFam Zheng data_len = cluster_bytes; 12632b2c8c5dSFam Zheng if (extent->has_marker) { 12642b2c8c5dSFam Zheng marker = (VmdkGrainMarker *)cluster_buf; 12652b2c8c5dSFam Zheng compressed_data = marker->data; 12662b2c8c5dSFam Zheng data_len = le32_to_cpu(marker->size); 12672b2c8c5dSFam Zheng } 12682b2c8c5dSFam Zheng if (!data_len || data_len > buf_bytes) { 12692b2c8c5dSFam Zheng ret = -EINVAL; 12702b2c8c5dSFam Zheng goto out; 12712b2c8c5dSFam Zheng } 12722b2c8c5dSFam Zheng ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len); 12732b2c8c5dSFam Zheng if (ret != Z_OK) { 12742b2c8c5dSFam Zheng ret = -EINVAL; 12752b2c8c5dSFam Zheng goto out; 12762b2c8c5dSFam Zheng 12772b2c8c5dSFam Zheng } 12782b2c8c5dSFam Zheng if (offset_in_cluster < 0 || 12792b2c8c5dSFam Zheng offset_in_cluster + nb_sectors * 512 > buf_len) { 12802b2c8c5dSFam Zheng ret = -EINVAL; 12812b2c8c5dSFam Zheng goto out; 12822b2c8c5dSFam Zheng } 12832b2c8c5dSFam Zheng memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512); 12842b2c8c5dSFam Zheng ret = 0; 12852b2c8c5dSFam Zheng 12862b2c8c5dSFam Zheng out: 12872b2c8c5dSFam Zheng g_free(uncomp_buf); 12882b2c8c5dSFam Zheng g_free(cluster_buf); 12892b2c8c5dSFam Zheng return ret; 12902b2c8c5dSFam Zheng } 1291dd3f6ee2SFam Zheng 1292019d6b8fSAnthony Liguori static int vmdk_read(BlockDriverState *bs, int64_t sector_num, 1293019d6b8fSAnthony Liguori uint8_t *buf, int nb_sectors) 1294019d6b8fSAnthony Liguori { 1295019d6b8fSAnthony Liguori BDRVVmdkState *s = bs->opaque; 1296b3976d3cSFam Zheng int ret; 1297b3976d3cSFam Zheng uint64_t n, index_in_cluster; 1298b1649faeSGerhard Wiesinger uint64_t extent_begin_sector, extent_relative_sector_num; 1299b3976d3cSFam Zheng VmdkExtent *extent = NULL; 1300019d6b8fSAnthony Liguori uint64_t cluster_offset; 1301019d6b8fSAnthony Liguori 1302019d6b8fSAnthony Liguori while (nb_sectors > 0) { 1303b3976d3cSFam Zheng extent = find_extent(s, sector_num, extent); 1304b3976d3cSFam Zheng if (!extent) { 1305b3976d3cSFam Zheng return -EIO; 1306b3976d3cSFam Zheng } 130791b85bd3SFam Zheng ret = get_cluster_offset( 130891b85bd3SFam Zheng bs, extent, NULL, 130991b85bd3SFam Zheng sector_num << 9, 0, &cluster_offset); 1310b1649faeSGerhard Wiesinger extent_begin_sector = extent->end_sector - extent->sectors; 1311b1649faeSGerhard Wiesinger extent_relative_sector_num = sector_num - extent_begin_sector; 1312b1649faeSGerhard Wiesinger index_in_cluster = extent_relative_sector_num % extent->cluster_sectors; 1313b3976d3cSFam Zheng n = extent->cluster_sectors - index_in_cluster; 1314ae261c86SFam Zheng if (n > nb_sectors) { 1315019d6b8fSAnthony Liguori n = nb_sectors; 1316ae261c86SFam Zheng } 131714ead646SFam Zheng if (ret != VMDK_OK) { 131891b85bd3SFam Zheng /* if not allocated, try to read from parent image, if exist */ 131914ead646SFam Zheng if (bs->backing_hd && ret != VMDK_ZEROED) { 1320ae261c86SFam Zheng if (!vmdk_is_cid_valid(bs)) { 13217fa60fa3SFam Zheng return -EINVAL; 1322ae261c86SFam Zheng } 1323b171271aSKevin Wolf ret = bdrv_read(bs->backing_hd, sector_num, buf, n); 1324ae261c86SFam Zheng if (ret < 0) { 13257fa60fa3SFam Zheng return ret; 1326ae261c86SFam Zheng } 1327019d6b8fSAnthony Liguori } else { 1328019d6b8fSAnthony Liguori memset(buf, 0, 512 * n); 1329019d6b8fSAnthony Liguori } 1330019d6b8fSAnthony Liguori } else { 1331dd3f6ee2SFam Zheng ret = vmdk_read_extent(extent, 1332dd3f6ee2SFam Zheng cluster_offset, index_in_cluster * 512, 1333dd3f6ee2SFam Zheng buf, n); 1334dd3f6ee2SFam Zheng if (ret) { 13357fa60fa3SFam Zheng return ret; 13367fa60fa3SFam Zheng } 1337019d6b8fSAnthony Liguori } 1338019d6b8fSAnthony Liguori nb_sectors -= n; 1339019d6b8fSAnthony Liguori sector_num += n; 1340019d6b8fSAnthony Liguori buf += n * 512; 1341019d6b8fSAnthony Liguori } 1342019d6b8fSAnthony Liguori return 0; 1343019d6b8fSAnthony Liguori } 1344019d6b8fSAnthony Liguori 13452914caa0SPaolo Bonzini static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num, 13462914caa0SPaolo Bonzini uint8_t *buf, int nb_sectors) 13472914caa0SPaolo Bonzini { 13482914caa0SPaolo Bonzini int ret; 13492914caa0SPaolo Bonzini BDRVVmdkState *s = bs->opaque; 13502914caa0SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 13512914caa0SPaolo Bonzini ret = vmdk_read(bs, sector_num, buf, nb_sectors); 13522914caa0SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 13532914caa0SPaolo Bonzini return ret; 13542914caa0SPaolo Bonzini } 13552914caa0SPaolo Bonzini 1356cdeaf1f1SFam Zheng /** 1357cdeaf1f1SFam Zheng * vmdk_write: 1358cdeaf1f1SFam Zheng * @zeroed: buf is ignored (data is zero), use zeroed_grain GTE feature 1359cdeaf1f1SFam Zheng * if possible, otherwise return -ENOTSUP. 13608e507243SFam Zheng * @zero_dry_run: used for zeroed == true only, don't update L2 table, just try 13618e507243SFam Zheng * with each cluster. By dry run we can find if the zero write 13628e507243SFam Zheng * is possible without modifying image data. 1363cdeaf1f1SFam Zheng * 1364cdeaf1f1SFam Zheng * Returns: error code with 0 for success. 1365cdeaf1f1SFam Zheng */ 1366019d6b8fSAnthony Liguori static int vmdk_write(BlockDriverState *bs, int64_t sector_num, 1367cdeaf1f1SFam Zheng const uint8_t *buf, int nb_sectors, 1368cdeaf1f1SFam Zheng bool zeroed, bool zero_dry_run) 1369019d6b8fSAnthony Liguori { 1370019d6b8fSAnthony Liguori BDRVVmdkState *s = bs->opaque; 1371b3976d3cSFam Zheng VmdkExtent *extent = NULL; 1372585ea0c8SFam Zheng int ret; 1373585ea0c8SFam Zheng int64_t index_in_cluster, n; 1374b1649faeSGerhard Wiesinger uint64_t extent_begin_sector, extent_relative_sector_num; 1375019d6b8fSAnthony Liguori uint64_t cluster_offset; 1376b3976d3cSFam Zheng VmdkMetaData m_data; 1377019d6b8fSAnthony Liguori 1378019d6b8fSAnthony Liguori if (sector_num > bs->total_sectors) { 13794823970bSFam Zheng error_report("Wrong offset: sector_num=0x%" PRIx64 1380019d6b8fSAnthony Liguori " total_sectors=0x%" PRIx64 "\n", 1381019d6b8fSAnthony Liguori sector_num, bs->total_sectors); 13827fa60fa3SFam Zheng return -EIO; 1383019d6b8fSAnthony Liguori } 1384019d6b8fSAnthony Liguori 1385019d6b8fSAnthony Liguori while (nb_sectors > 0) { 1386b3976d3cSFam Zheng extent = find_extent(s, sector_num, extent); 1387b3976d3cSFam Zheng if (!extent) { 1388b3976d3cSFam Zheng return -EIO; 1389b3976d3cSFam Zheng } 139091b85bd3SFam Zheng ret = get_cluster_offset( 1391b3976d3cSFam Zheng bs, 1392b3976d3cSFam Zheng extent, 1393b3976d3cSFam Zheng &m_data, 13942b2c8c5dSFam Zheng sector_num << 9, !extent->compressed, 13952b2c8c5dSFam Zheng &cluster_offset); 13962b2c8c5dSFam Zheng if (extent->compressed) { 139765f74725SFam Zheng if (ret == VMDK_OK) { 13982b2c8c5dSFam Zheng /* Refuse write to allocated cluster for streamOptimized */ 13994823970bSFam Zheng error_report("Could not write to allocated cluster" 14004823970bSFam Zheng " for streamOptimized"); 14012b2c8c5dSFam Zheng return -EIO; 14022b2c8c5dSFam Zheng } else { 14032b2c8c5dSFam Zheng /* allocate */ 14042b2c8c5dSFam Zheng ret = get_cluster_offset( 14052b2c8c5dSFam Zheng bs, 14062b2c8c5dSFam Zheng extent, 14072b2c8c5dSFam Zheng &m_data, 140891b85bd3SFam Zheng sector_num << 9, 1, 140991b85bd3SFam Zheng &cluster_offset); 14102b2c8c5dSFam Zheng } 14112b2c8c5dSFam Zheng } 1412cdeaf1f1SFam Zheng if (ret == VMDK_ERROR) { 141391b85bd3SFam Zheng return -EINVAL; 1414b3976d3cSFam Zheng } 1415b1649faeSGerhard Wiesinger extent_begin_sector = extent->end_sector - extent->sectors; 1416b1649faeSGerhard Wiesinger extent_relative_sector_num = sector_num - extent_begin_sector; 1417b1649faeSGerhard Wiesinger index_in_cluster = extent_relative_sector_num % extent->cluster_sectors; 1418b3976d3cSFam Zheng n = extent->cluster_sectors - index_in_cluster; 1419b3976d3cSFam Zheng if (n > nb_sectors) { 1420019d6b8fSAnthony Liguori n = nb_sectors; 1421b3976d3cSFam Zheng } 1422cdeaf1f1SFam Zheng if (zeroed) { 1423cdeaf1f1SFam Zheng /* Do zeroed write, buf is ignored */ 1424cdeaf1f1SFam Zheng if (extent->has_zero_grain && 1425cdeaf1f1SFam Zheng index_in_cluster == 0 && 1426cdeaf1f1SFam Zheng n >= extent->cluster_sectors) { 1427cdeaf1f1SFam Zheng n = extent->cluster_sectors; 1428cdeaf1f1SFam Zheng if (!zero_dry_run) { 1429cdeaf1f1SFam Zheng m_data.offset = VMDK_GTE_ZEROED; 1430cdeaf1f1SFam Zheng /* update L2 tables */ 1431cdeaf1f1SFam Zheng if (vmdk_L2update(extent, &m_data) != VMDK_OK) { 1432cdeaf1f1SFam Zheng return -EIO; 1433cdeaf1f1SFam Zheng } 1434cdeaf1f1SFam Zheng } 1435cdeaf1f1SFam Zheng } else { 1436cdeaf1f1SFam Zheng return -ENOTSUP; 1437cdeaf1f1SFam Zheng } 1438cdeaf1f1SFam Zheng } else { 1439dd3f6ee2SFam Zheng ret = vmdk_write_extent(extent, 1440dd3f6ee2SFam Zheng cluster_offset, index_in_cluster * 512, 1441dd3f6ee2SFam Zheng buf, n, sector_num); 1442dd3f6ee2SFam Zheng if (ret) { 14437fa60fa3SFam Zheng return ret; 1444b3976d3cSFam Zheng } 1445019d6b8fSAnthony Liguori if (m_data.valid) { 1446019d6b8fSAnthony Liguori /* update L2 tables */ 1447cdeaf1f1SFam Zheng if (vmdk_L2update(extent, &m_data) != VMDK_OK) { 14487fa60fa3SFam Zheng return -EIO; 1449019d6b8fSAnthony Liguori } 1450b3976d3cSFam Zheng } 1451cdeaf1f1SFam Zheng } 1452019d6b8fSAnthony Liguori nb_sectors -= n; 1453019d6b8fSAnthony Liguori sector_num += n; 1454019d6b8fSAnthony Liguori buf += n * 512; 1455019d6b8fSAnthony Liguori 1456ae261c86SFam Zheng /* update CID on the first write every time the virtual disk is 1457ae261c86SFam Zheng * opened */ 145869b4d86dSFam Zheng if (!s->cid_updated) { 145999f1835dSKevin Wolf ret = vmdk_write_cid(bs, time(NULL)); 146099f1835dSKevin Wolf if (ret < 0) { 146199f1835dSKevin Wolf return ret; 146299f1835dSKevin Wolf } 146369b4d86dSFam Zheng s->cid_updated = true; 1464019d6b8fSAnthony Liguori } 1465019d6b8fSAnthony Liguori } 1466019d6b8fSAnthony Liguori return 0; 1467019d6b8fSAnthony Liguori } 1468019d6b8fSAnthony Liguori 1469e183ef75SPaolo Bonzini static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num, 1470e183ef75SPaolo Bonzini const uint8_t *buf, int nb_sectors) 1471e183ef75SPaolo Bonzini { 1472e183ef75SPaolo Bonzini int ret; 1473e183ef75SPaolo Bonzini BDRVVmdkState *s = bs->opaque; 1474e183ef75SPaolo Bonzini qemu_co_mutex_lock(&s->lock); 1475cdeaf1f1SFam Zheng ret = vmdk_write(bs, sector_num, buf, nb_sectors, false, false); 1476cdeaf1f1SFam Zheng qemu_co_mutex_unlock(&s->lock); 1477cdeaf1f1SFam Zheng return ret; 1478cdeaf1f1SFam Zheng } 1479cdeaf1f1SFam Zheng 1480cdeaf1f1SFam Zheng static int coroutine_fn vmdk_co_write_zeroes(BlockDriverState *bs, 1481cdeaf1f1SFam Zheng int64_t sector_num, 1482aa7bfbffSPeter Lieven int nb_sectors, 1483aa7bfbffSPeter Lieven BdrvRequestFlags flags) 1484cdeaf1f1SFam Zheng { 1485cdeaf1f1SFam Zheng int ret; 1486cdeaf1f1SFam Zheng BDRVVmdkState *s = bs->opaque; 1487cdeaf1f1SFam Zheng qemu_co_mutex_lock(&s->lock); 14888e507243SFam Zheng /* write zeroes could fail if sectors not aligned to cluster, test it with 14898e507243SFam Zheng * dry_run == true before really updating image */ 1490cdeaf1f1SFam Zheng ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, true); 1491cdeaf1f1SFam Zheng if (!ret) { 1492cdeaf1f1SFam Zheng ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, false); 1493cdeaf1f1SFam Zheng } 1494e183ef75SPaolo Bonzini qemu_co_mutex_unlock(&s->lock); 1495e183ef75SPaolo Bonzini return ret; 1496e183ef75SPaolo Bonzini } 1497e183ef75SPaolo Bonzini 14986c031aacSFam Zheng static int vmdk_create_extent(const char *filename, int64_t filesize, 1499917703c1SFam Zheng bool flat, bool compress, bool zeroed_grain, 1500917703c1SFam Zheng Error **errp) 1501019d6b8fSAnthony Liguori { 1502f66fd6c3SFam Zheng int ret, i; 1503917703c1SFam Zheng BlockDriverState *bs = NULL; 1504019d6b8fSAnthony Liguori VMDK4Header header; 1505917703c1SFam Zheng Error *local_err; 1506917703c1SFam Zheng uint32_t tmp, magic, grains, gd_sectors, gt_size, gt_count; 1507917703c1SFam Zheng uint32_t *gd_buf = NULL; 1508917703c1SFam Zheng int gd_buf_size; 15090e7e1989SKevin Wolf 1510917703c1SFam Zheng ret = bdrv_create_file(filename, NULL, &local_err); 1511f66fd6c3SFam Zheng if (ret < 0) { 1512917703c1SFam Zheng error_propagate(errp, local_err); 1513917703c1SFam Zheng goto exit; 1514917703c1SFam Zheng } 1515917703c1SFam Zheng 15162e40134bSMax Reitz assert(bs == NULL); 15172e40134bSMax Reitz ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL, 15182e40134bSMax Reitz NULL, &local_err); 1519917703c1SFam Zheng if (ret < 0) { 1520917703c1SFam Zheng error_propagate(errp, local_err); 1521917703c1SFam Zheng goto exit; 1522917703c1SFam Zheng } 1523917703c1SFam Zheng 1524917703c1SFam Zheng if (flat) { 1525917703c1SFam Zheng ret = bdrv_truncate(bs, filesize); 1526917703c1SFam Zheng if (ret < 0) { 152739a611a3SJeff Cody error_setg_errno(errp, -ret, "Could not truncate file"); 1528f66fd6c3SFam Zheng } 1529f66fd6c3SFam Zheng goto exit; 1530f66fd6c3SFam Zheng } 1531019d6b8fSAnthony Liguori magic = cpu_to_be32(VMDK4_MAGIC); 1532019d6b8fSAnthony Liguori memset(&header, 0, sizeof(header)); 153369e0b6dfSFam Zheng header.version = zeroed_grain ? 2 : 1; 153495b0aa42SFam Zheng header.flags = VMDK4_FLAG_RGD | VMDK4_FLAG_NL_DETECT 153569e0b6dfSFam Zheng | (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0) 153669e0b6dfSFam Zheng | (zeroed_grain ? VMDK4_FLAG_ZERO_GRAIN : 0); 15376c031aacSFam Zheng header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0; 1538917703c1SFam Zheng header.capacity = filesize / BDRV_SECTOR_SIZE; 153916372ff0SAlexander Graf header.granularity = 128; 1540917703c1SFam Zheng header.num_gtes_per_gt = BDRV_SECTOR_SIZE; 1541019d6b8fSAnthony Liguori 1542917703c1SFam Zheng grains = DIV_ROUND_UP(filesize / BDRV_SECTOR_SIZE, header.granularity); 1543917703c1SFam Zheng gt_size = DIV_ROUND_UP(header.num_gtes_per_gt * sizeof(uint32_t), 1544917703c1SFam Zheng BDRV_SECTOR_SIZE); 1545917703c1SFam Zheng gt_count = DIV_ROUND_UP(grains, header.num_gtes_per_gt); 1546917703c1SFam Zheng gd_sectors = DIV_ROUND_UP(gt_count * sizeof(uint32_t), BDRV_SECTOR_SIZE); 1547019d6b8fSAnthony Liguori 1548019d6b8fSAnthony Liguori header.desc_offset = 1; 1549019d6b8fSAnthony Liguori header.desc_size = 20; 1550019d6b8fSAnthony Liguori header.rgd_offset = header.desc_offset + header.desc_size; 1551917703c1SFam Zheng header.gd_offset = header.rgd_offset + gd_sectors + (gt_size * gt_count); 1552019d6b8fSAnthony Liguori header.grain_offset = 1553917703c1SFam Zheng ROUND_UP(header.gd_offset + gd_sectors + (gt_size * gt_count), 1554917703c1SFam Zheng header.granularity); 155516372ff0SAlexander Graf /* swap endianness for all header fields */ 155616372ff0SAlexander Graf header.version = cpu_to_le32(header.version); 155716372ff0SAlexander Graf header.flags = cpu_to_le32(header.flags); 155816372ff0SAlexander Graf header.capacity = cpu_to_le64(header.capacity); 155916372ff0SAlexander Graf header.granularity = cpu_to_le64(header.granularity); 1560ca8804ceSFam Zheng header.num_gtes_per_gt = cpu_to_le32(header.num_gtes_per_gt); 1561019d6b8fSAnthony Liguori header.desc_offset = cpu_to_le64(header.desc_offset); 1562019d6b8fSAnthony Liguori header.desc_size = cpu_to_le64(header.desc_size); 1563019d6b8fSAnthony Liguori header.rgd_offset = cpu_to_le64(header.rgd_offset); 1564019d6b8fSAnthony Liguori header.gd_offset = cpu_to_le64(header.gd_offset); 1565019d6b8fSAnthony Liguori header.grain_offset = cpu_to_le64(header.grain_offset); 15666c031aacSFam Zheng header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm); 1567019d6b8fSAnthony Liguori 1568019d6b8fSAnthony Liguori header.check_bytes[0] = 0xa; 1569019d6b8fSAnthony Liguori header.check_bytes[1] = 0x20; 1570019d6b8fSAnthony Liguori header.check_bytes[2] = 0xd; 1571019d6b8fSAnthony Liguori header.check_bytes[3] = 0xa; 1572019d6b8fSAnthony Liguori 1573019d6b8fSAnthony Liguori /* write all the data */ 1574917703c1SFam Zheng ret = bdrv_pwrite(bs, 0, &magic, sizeof(magic)); 1575917703c1SFam Zheng if (ret < 0) { 1576917703c1SFam Zheng error_set(errp, QERR_IO_ERROR); 15771640366cSKirill A. Shutemov goto exit; 15781640366cSKirill A. Shutemov } 1579917703c1SFam Zheng ret = bdrv_pwrite(bs, sizeof(magic), &header, sizeof(header)); 1580917703c1SFam Zheng if (ret < 0) { 1581917703c1SFam Zheng error_set(errp, QERR_IO_ERROR); 15821640366cSKirill A. Shutemov goto exit; 15831640366cSKirill A. Shutemov } 1584019d6b8fSAnthony Liguori 1585917703c1SFam Zheng ret = bdrv_truncate(bs, le64_to_cpu(header.grain_offset) << 9); 15861640366cSKirill A. Shutemov if (ret < 0) { 158739a611a3SJeff Cody error_setg_errno(errp, -ret, "Could not truncate file"); 15881640366cSKirill A. Shutemov goto exit; 15891640366cSKirill A. Shutemov } 1590019d6b8fSAnthony Liguori 1591019d6b8fSAnthony Liguori /* write grain directory */ 1592917703c1SFam Zheng gd_buf_size = gd_sectors * BDRV_SECTOR_SIZE; 1593917703c1SFam Zheng gd_buf = g_malloc0(gd_buf_size); 1594917703c1SFam Zheng for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_sectors; 15951640366cSKirill A. Shutemov i < gt_count; i++, tmp += gt_size) { 1596917703c1SFam Zheng gd_buf[i] = cpu_to_le32(tmp); 15971640366cSKirill A. Shutemov } 1598917703c1SFam Zheng ret = bdrv_pwrite(bs, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE, 1599917703c1SFam Zheng gd_buf, gd_buf_size); 1600917703c1SFam Zheng if (ret < 0) { 1601917703c1SFam Zheng error_set(errp, QERR_IO_ERROR); 1602917703c1SFam Zheng goto exit; 16031640366cSKirill A. Shutemov } 1604019d6b8fSAnthony Liguori 1605019d6b8fSAnthony Liguori /* write backup grain directory */ 1606917703c1SFam Zheng for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_sectors; 16071640366cSKirill A. Shutemov i < gt_count; i++, tmp += gt_size) { 1608917703c1SFam Zheng gd_buf[i] = cpu_to_le32(tmp); 16091640366cSKirill A. Shutemov } 1610917703c1SFam Zheng ret = bdrv_pwrite(bs, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE, 1611917703c1SFam Zheng gd_buf, gd_buf_size); 1612917703c1SFam Zheng if (ret < 0) { 1613917703c1SFam Zheng error_set(errp, QERR_IO_ERROR); 1614917703c1SFam Zheng goto exit; 16151640366cSKirill A. Shutemov } 1616019d6b8fSAnthony Liguori 1617f66fd6c3SFam Zheng ret = 0; 1618f66fd6c3SFam Zheng exit: 1619917703c1SFam Zheng if (bs) { 1620917703c1SFam Zheng bdrv_unref(bs); 1621917703c1SFam Zheng } 1622917703c1SFam Zheng g_free(gd_buf); 1623f66fd6c3SFam Zheng return ret; 1624f66fd6c3SFam Zheng } 1625019d6b8fSAnthony Liguori 1626f66fd6c3SFam Zheng static int filename_decompose(const char *filename, char *path, char *prefix, 16274823970bSFam Zheng char *postfix, size_t buf_len, Error **errp) 1628f66fd6c3SFam Zheng { 1629f66fd6c3SFam Zheng const char *p, *q; 1630f66fd6c3SFam Zheng 1631f66fd6c3SFam Zheng if (filename == NULL || !strlen(filename)) { 16324823970bSFam Zheng error_setg(errp, "No filename provided"); 163365f74725SFam Zheng return VMDK_ERROR; 1634f66fd6c3SFam Zheng } 1635f66fd6c3SFam Zheng p = strrchr(filename, '/'); 1636f66fd6c3SFam Zheng if (p == NULL) { 1637f66fd6c3SFam Zheng p = strrchr(filename, '\\'); 1638f66fd6c3SFam Zheng } 1639f66fd6c3SFam Zheng if (p == NULL) { 1640f66fd6c3SFam Zheng p = strrchr(filename, ':'); 1641f66fd6c3SFam Zheng } 1642f66fd6c3SFam Zheng if (p != NULL) { 1643f66fd6c3SFam Zheng p++; 1644f66fd6c3SFam Zheng if (p - filename >= buf_len) { 164565f74725SFam Zheng return VMDK_ERROR; 1646f66fd6c3SFam Zheng } 1647f66fd6c3SFam Zheng pstrcpy(path, p - filename + 1, filename); 1648f66fd6c3SFam Zheng } else { 1649f66fd6c3SFam Zheng p = filename; 1650f66fd6c3SFam Zheng path[0] = '\0'; 1651f66fd6c3SFam Zheng } 1652f66fd6c3SFam Zheng q = strrchr(p, '.'); 1653f66fd6c3SFam Zheng if (q == NULL) { 1654f66fd6c3SFam Zheng pstrcpy(prefix, buf_len, p); 1655f66fd6c3SFam Zheng postfix[0] = '\0'; 1656f66fd6c3SFam Zheng } else { 1657f66fd6c3SFam Zheng if (q - p >= buf_len) { 165865f74725SFam Zheng return VMDK_ERROR; 1659f66fd6c3SFam Zheng } 1660f66fd6c3SFam Zheng pstrcpy(prefix, q - p + 1, p); 1661f66fd6c3SFam Zheng pstrcpy(postfix, buf_len, q); 1662f66fd6c3SFam Zheng } 166365f74725SFam Zheng return VMDK_OK; 1664f66fd6c3SFam Zheng } 1665f66fd6c3SFam Zheng 1666d5124c00SMax Reitz static int vmdk_create(const char *filename, QEMUOptionParameter *options, 1667d5124c00SMax Reitz Error **errp) 1668f66fd6c3SFam Zheng { 1669917703c1SFam Zheng int idx = 0; 1670917703c1SFam Zheng BlockDriverState *new_bs = NULL; 1671917703c1SFam Zheng Error *local_err; 1672af057fe7SFam Zheng char *desc = NULL; 1673f66fd6c3SFam Zheng int64_t total_size = 0, filesize; 16747f2039f6SOthmar Pasteka const char *adapter_type = NULL; 1675f66fd6c3SFam Zheng const char *backing_file = NULL; 1676f66fd6c3SFam Zheng const char *fmt = NULL; 1677f66fd6c3SFam Zheng int flags = 0; 1678f66fd6c3SFam Zheng int ret = 0; 16796c031aacSFam Zheng bool flat, split, compress; 1680af057fe7SFam Zheng GString *ext_desc_lines; 1681f66fd6c3SFam Zheng char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX]; 1682f66fd6c3SFam Zheng const int64_t split_size = 0x80000000; /* VMDK has constant split size */ 1683f66fd6c3SFam Zheng const char *desc_extent_line; 1684f66fd6c3SFam Zheng char parent_desc_line[BUF_SIZE] = ""; 1685f66fd6c3SFam Zheng uint32_t parent_cid = 0xffffffff; 16867f2039f6SOthmar Pasteka uint32_t number_heads = 16; 168769e0b6dfSFam Zheng bool zeroed_grain = false; 1688917703c1SFam Zheng uint32_t desc_offset = 0, desc_len; 1689f66fd6c3SFam Zheng const char desc_template[] = 1690f66fd6c3SFam Zheng "# Disk DescriptorFile\n" 1691f66fd6c3SFam Zheng "version=1\n" 1692f66fd6c3SFam Zheng "CID=%x\n" 1693f66fd6c3SFam Zheng "parentCID=%x\n" 1694f66fd6c3SFam Zheng "createType=\"%s\"\n" 1695f66fd6c3SFam Zheng "%s" 1696f66fd6c3SFam Zheng "\n" 1697f66fd6c3SFam Zheng "# Extent description\n" 1698f66fd6c3SFam Zheng "%s" 1699f66fd6c3SFam Zheng "\n" 1700f66fd6c3SFam Zheng "# The Disk Data Base\n" 1701f66fd6c3SFam Zheng "#DDB\n" 1702f66fd6c3SFam Zheng "\n" 1703f66fd6c3SFam Zheng "ddb.virtualHWVersion = \"%d\"\n" 1704f66fd6c3SFam Zheng "ddb.geometry.cylinders = \"%" PRId64 "\"\n" 17057f2039f6SOthmar Pasteka "ddb.geometry.heads = \"%d\"\n" 1706f66fd6c3SFam Zheng "ddb.geometry.sectors = \"63\"\n" 17077f2039f6SOthmar Pasteka "ddb.adapterType = \"%s\"\n"; 1708f66fd6c3SFam Zheng 1709af057fe7SFam Zheng ext_desc_lines = g_string_new(NULL); 1710af057fe7SFam Zheng 17114823970bSFam Zheng if (filename_decompose(filename, path, prefix, postfix, PATH_MAX, errp)) { 1712af057fe7SFam Zheng ret = -EINVAL; 1713af057fe7SFam Zheng goto exit; 1714f66fd6c3SFam Zheng } 1715f66fd6c3SFam Zheng /* Read out options */ 1716f66fd6c3SFam Zheng while (options && options->name) { 1717f66fd6c3SFam Zheng if (!strcmp(options->name, BLOCK_OPT_SIZE)) { 1718f66fd6c3SFam Zheng total_size = options->value.n; 17197f2039f6SOthmar Pasteka } else if (!strcmp(options->name, BLOCK_OPT_ADAPTER_TYPE)) { 17207f2039f6SOthmar Pasteka adapter_type = options->value.s; 1721f66fd6c3SFam Zheng } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) { 1722f66fd6c3SFam Zheng backing_file = options->value.s; 1723f66fd6c3SFam Zheng } else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) { 1724f66fd6c3SFam Zheng flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0; 1725f66fd6c3SFam Zheng } else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) { 1726f66fd6c3SFam Zheng fmt = options->value.s; 172769e0b6dfSFam Zheng } else if (!strcmp(options->name, BLOCK_OPT_ZEROED_GRAIN)) { 172869e0b6dfSFam Zheng zeroed_grain |= options->value.n; 1729f66fd6c3SFam Zheng } 1730f66fd6c3SFam Zheng options++; 1731f66fd6c3SFam Zheng } 17327f2039f6SOthmar Pasteka if (!adapter_type) { 17337f2039f6SOthmar Pasteka adapter_type = "ide"; 17347f2039f6SOthmar Pasteka } else if (strcmp(adapter_type, "ide") && 17357f2039f6SOthmar Pasteka strcmp(adapter_type, "buslogic") && 17367f2039f6SOthmar Pasteka strcmp(adapter_type, "lsilogic") && 17377f2039f6SOthmar Pasteka strcmp(adapter_type, "legacyESX")) { 17384823970bSFam Zheng error_setg(errp, "Unknown adapter type: '%s'", adapter_type); 1739af057fe7SFam Zheng ret = -EINVAL; 1740af057fe7SFam Zheng goto exit; 17417f2039f6SOthmar Pasteka } 17427f2039f6SOthmar Pasteka if (strcmp(adapter_type, "ide") != 0) { 17437f2039f6SOthmar Pasteka /* that's the number of heads with which vmware operates when 17447f2039f6SOthmar Pasteka creating, exporting, etc. vmdk files with a non-ide adapter type */ 17457f2039f6SOthmar Pasteka number_heads = 255; 17467f2039f6SOthmar Pasteka } 1747f66fd6c3SFam Zheng if (!fmt) { 1748f66fd6c3SFam Zheng /* Default format to monolithicSparse */ 1749f66fd6c3SFam Zheng fmt = "monolithicSparse"; 1750f66fd6c3SFam Zheng } else if (strcmp(fmt, "monolithicFlat") && 1751f66fd6c3SFam Zheng strcmp(fmt, "monolithicSparse") && 1752f66fd6c3SFam Zheng strcmp(fmt, "twoGbMaxExtentSparse") && 17536c031aacSFam Zheng strcmp(fmt, "twoGbMaxExtentFlat") && 17546c031aacSFam Zheng strcmp(fmt, "streamOptimized")) { 17554823970bSFam Zheng error_setg(errp, "Unknown subformat: '%s'", fmt); 1756af057fe7SFam Zheng ret = -EINVAL; 1757af057fe7SFam Zheng goto exit; 1758f66fd6c3SFam Zheng } 1759f66fd6c3SFam Zheng split = !(strcmp(fmt, "twoGbMaxExtentFlat") && 1760f66fd6c3SFam Zheng strcmp(fmt, "twoGbMaxExtentSparse")); 1761f66fd6c3SFam Zheng flat = !(strcmp(fmt, "monolithicFlat") && 1762f66fd6c3SFam Zheng strcmp(fmt, "twoGbMaxExtentFlat")); 17636c031aacSFam Zheng compress = !strcmp(fmt, "streamOptimized"); 1764f66fd6c3SFam Zheng if (flat) { 1765f66fd6c3SFam Zheng desc_extent_line = "RW %lld FLAT \"%s\" 0\n"; 1766f66fd6c3SFam Zheng } else { 1767f66fd6c3SFam Zheng desc_extent_line = "RW %lld SPARSE \"%s\"\n"; 1768f66fd6c3SFam Zheng } 1769f66fd6c3SFam Zheng if (flat && backing_file) { 17704823970bSFam Zheng error_setg(errp, "Flat image can't have backing file"); 1771af057fe7SFam Zheng ret = -ENOTSUP; 1772af057fe7SFam Zheng goto exit; 1773f66fd6c3SFam Zheng } 177452c8d629SFam Zheng if (flat && zeroed_grain) { 177552c8d629SFam Zheng error_setg(errp, "Flat image can't enable zeroed grain"); 1776af057fe7SFam Zheng ret = -ENOTSUP; 1777af057fe7SFam Zheng goto exit; 177852c8d629SFam Zheng } 1779f66fd6c3SFam Zheng if (backing_file) { 1780f67503e5SMax Reitz BlockDriverState *bs = NULL; 1781ddf5636dSMax Reitz ret = bdrv_open(&bs, backing_file, NULL, NULL, BDRV_O_NO_BACKING, NULL, 1782ddf5636dSMax Reitz errp); 1783f66fd6c3SFam Zheng if (ret != 0) { 1784af057fe7SFam Zheng goto exit; 1785f66fd6c3SFam Zheng } 1786f66fd6c3SFam Zheng if (strcmp(bs->drv->format_name, "vmdk")) { 17874f6fd349SFam Zheng bdrv_unref(bs); 1788af057fe7SFam Zheng ret = -EINVAL; 1789af057fe7SFam Zheng goto exit; 1790f66fd6c3SFam Zheng } 1791f66fd6c3SFam Zheng parent_cid = vmdk_read_cid(bs, 0); 17924f6fd349SFam Zheng bdrv_unref(bs); 1793f66fd6c3SFam Zheng snprintf(parent_desc_line, sizeof(parent_desc_line), 17948ed610a1SFam Zheng "parentFileNameHint=\"%s\"", backing_file); 1795f66fd6c3SFam Zheng } 1796f66fd6c3SFam Zheng 1797f66fd6c3SFam Zheng /* Create extents */ 1798f66fd6c3SFam Zheng filesize = total_size; 1799f66fd6c3SFam Zheng while (filesize > 0) { 1800f66fd6c3SFam Zheng char desc_line[BUF_SIZE]; 1801f66fd6c3SFam Zheng char ext_filename[PATH_MAX]; 1802f66fd6c3SFam Zheng char desc_filename[PATH_MAX]; 1803f66fd6c3SFam Zheng int64_t size = filesize; 1804f66fd6c3SFam Zheng 1805f66fd6c3SFam Zheng if (split && size > split_size) { 1806f66fd6c3SFam Zheng size = split_size; 1807f66fd6c3SFam Zheng } 1808f66fd6c3SFam Zheng if (split) { 1809f66fd6c3SFam Zheng snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s", 1810f66fd6c3SFam Zheng prefix, flat ? 'f' : 's', ++idx, postfix); 1811f66fd6c3SFam Zheng } else if (flat) { 1812f66fd6c3SFam Zheng snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s", 1813f66fd6c3SFam Zheng prefix, postfix); 1814f66fd6c3SFam Zheng } else { 1815f66fd6c3SFam Zheng snprintf(desc_filename, sizeof(desc_filename), "%s%s", 1816f66fd6c3SFam Zheng prefix, postfix); 1817f66fd6c3SFam Zheng } 1818f66fd6c3SFam Zheng snprintf(ext_filename, sizeof(ext_filename), "%s%s", 1819f66fd6c3SFam Zheng path, desc_filename); 1820f66fd6c3SFam Zheng 182169e0b6dfSFam Zheng if (vmdk_create_extent(ext_filename, size, 1822917703c1SFam Zheng flat, compress, zeroed_grain, errp)) { 1823af057fe7SFam Zheng ret = -EINVAL; 1824af057fe7SFam Zheng goto exit; 1825f66fd6c3SFam Zheng } 1826f66fd6c3SFam Zheng filesize -= size; 1827f66fd6c3SFam Zheng 1828f66fd6c3SFam Zheng /* Format description line */ 1829f66fd6c3SFam Zheng snprintf(desc_line, sizeof(desc_line), 1830917703c1SFam Zheng desc_extent_line, size / BDRV_SECTOR_SIZE, desc_filename); 1831af057fe7SFam Zheng g_string_append(ext_desc_lines, desc_line); 1832f66fd6c3SFam Zheng } 1833f66fd6c3SFam Zheng /* generate descriptor file */ 1834af057fe7SFam Zheng desc = g_strdup_printf(desc_template, 1835f66fd6c3SFam Zheng (unsigned int)time(NULL), 1836f66fd6c3SFam Zheng parent_cid, 1837f66fd6c3SFam Zheng fmt, 1838f66fd6c3SFam Zheng parent_desc_line, 1839af057fe7SFam Zheng ext_desc_lines->str, 1840f66fd6c3SFam Zheng (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4), 1841917703c1SFam Zheng total_size / 1842917703c1SFam Zheng (int64_t)(63 * number_heads * BDRV_SECTOR_SIZE), 1843af057fe7SFam Zheng number_heads, 18447f2039f6SOthmar Pasteka adapter_type); 1845917703c1SFam Zheng desc_len = strlen(desc); 1846917703c1SFam Zheng /* the descriptor offset = 0x200 */ 1847917703c1SFam Zheng if (!split && !flat) { 1848917703c1SFam Zheng desc_offset = 0x200; 1849f66fd6c3SFam Zheng } else { 1850917703c1SFam Zheng ret = bdrv_create_file(filename, options, &local_err); 1851917703c1SFam Zheng if (ret < 0) { 1852917703c1SFam Zheng error_setg_errno(errp, -ret, "Could not create image file"); 1853af057fe7SFam Zheng goto exit; 1854f66fd6c3SFam Zheng } 1855f66fd6c3SFam Zheng } 18562e40134bSMax Reitz assert(new_bs == NULL); 18572e40134bSMax Reitz ret = bdrv_open(&new_bs, filename, NULL, NULL, 18582e40134bSMax Reitz BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err); 1859917703c1SFam Zheng if (ret < 0) { 1860917703c1SFam Zheng error_setg_errno(errp, -ret, "Could not write description"); 1861917703c1SFam Zheng goto exit; 18621640366cSKirill A. Shutemov } 1863917703c1SFam Zheng ret = bdrv_pwrite(new_bs, desc_offset, desc, desc_len); 1864917703c1SFam Zheng if (ret < 0) { 1865917703c1SFam Zheng error_setg_errno(errp, -ret, "Could not write description"); 1866917703c1SFam Zheng goto exit; 1867917703c1SFam Zheng } 1868917703c1SFam Zheng /* bdrv_pwrite write padding zeros to align to sector, we don't need that 1869917703c1SFam Zheng * for description file */ 1870917703c1SFam Zheng if (desc_offset == 0) { 1871917703c1SFam Zheng ret = bdrv_truncate(new_bs, desc_len); 1872917703c1SFam Zheng if (ret < 0) { 187339a611a3SJeff Cody error_setg_errno(errp, -ret, "Could not truncate file"); 1874917703c1SFam Zheng } 1875917703c1SFam Zheng } 1876af057fe7SFam Zheng exit: 1877917703c1SFam Zheng if (new_bs) { 1878917703c1SFam Zheng bdrv_unref(new_bs); 1879917703c1SFam Zheng } 1880af057fe7SFam Zheng g_free(desc); 1881af057fe7SFam Zheng g_string_free(ext_desc_lines, true); 18821640366cSKirill A. Shutemov return ret; 1883019d6b8fSAnthony Liguori } 1884019d6b8fSAnthony Liguori 1885019d6b8fSAnthony Liguori static void vmdk_close(BlockDriverState *bs) 1886019d6b8fSAnthony Liguori { 18872bc3166cSKevin Wolf BDRVVmdkState *s = bs->opaque; 18882bc3166cSKevin Wolf 1889b3976d3cSFam Zheng vmdk_free_extents(bs); 1890f4c129a3SFam Zheng g_free(s->create_type); 18912bc3166cSKevin Wolf 18922bc3166cSKevin Wolf migrate_del_blocker(s->migration_blocker); 18932bc3166cSKevin Wolf error_free(s->migration_blocker); 1894019d6b8fSAnthony Liguori } 1895019d6b8fSAnthony Liguori 18968b94ff85SPaolo Bonzini static coroutine_fn int vmdk_co_flush(BlockDriverState *bs) 1897019d6b8fSAnthony Liguori { 1898333c574dSFam Zheng BDRVVmdkState *s = bs->opaque; 189929cdb251SPaolo Bonzini int i, err; 190029cdb251SPaolo Bonzini int ret = 0; 1901333c574dSFam Zheng 1902333c574dSFam Zheng for (i = 0; i < s->num_extents; i++) { 19038b94ff85SPaolo Bonzini err = bdrv_co_flush(s->extents[i].file); 1904333c574dSFam Zheng if (err < 0) { 1905333c574dSFam Zheng ret = err; 1906333c574dSFam Zheng } 1907333c574dSFam Zheng } 1908333c574dSFam Zheng return ret; 1909019d6b8fSAnthony Liguori } 1910019d6b8fSAnthony Liguori 19114a1d5e1fSFam Zheng static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs) 19124a1d5e1fSFam Zheng { 19134a1d5e1fSFam Zheng int i; 19144a1d5e1fSFam Zheng int64_t ret = 0; 19154a1d5e1fSFam Zheng int64_t r; 19164a1d5e1fSFam Zheng BDRVVmdkState *s = bs->opaque; 19174a1d5e1fSFam Zheng 19184a1d5e1fSFam Zheng ret = bdrv_get_allocated_file_size(bs->file); 19194a1d5e1fSFam Zheng if (ret < 0) { 19204a1d5e1fSFam Zheng return ret; 19214a1d5e1fSFam Zheng } 19224a1d5e1fSFam Zheng for (i = 0; i < s->num_extents; i++) { 19234a1d5e1fSFam Zheng if (s->extents[i].file == bs->file) { 19244a1d5e1fSFam Zheng continue; 19254a1d5e1fSFam Zheng } 19264a1d5e1fSFam Zheng r = bdrv_get_allocated_file_size(s->extents[i].file); 19274a1d5e1fSFam Zheng if (r < 0) { 19284a1d5e1fSFam Zheng return r; 19294a1d5e1fSFam Zheng } 19304a1d5e1fSFam Zheng ret += r; 19314a1d5e1fSFam Zheng } 19324a1d5e1fSFam Zheng return ret; 19334a1d5e1fSFam Zheng } 19340e7e1989SKevin Wolf 1935da7a50f9SFam Zheng static int vmdk_has_zero_init(BlockDriverState *bs) 1936da7a50f9SFam Zheng { 1937da7a50f9SFam Zheng int i; 1938da7a50f9SFam Zheng BDRVVmdkState *s = bs->opaque; 1939da7a50f9SFam Zheng 1940da7a50f9SFam Zheng /* If has a flat extent and its underlying storage doesn't have zero init, 1941da7a50f9SFam Zheng * return 0. */ 1942da7a50f9SFam Zheng for (i = 0; i < s->num_extents; i++) { 1943da7a50f9SFam Zheng if (s->extents[i].flat) { 1944da7a50f9SFam Zheng if (!bdrv_has_zero_init(s->extents[i].file)) { 1945da7a50f9SFam Zheng return 0; 1946da7a50f9SFam Zheng } 1947da7a50f9SFam Zheng } 1948da7a50f9SFam Zheng } 1949da7a50f9SFam Zheng return 1; 1950da7a50f9SFam Zheng } 1951da7a50f9SFam Zheng 1952f4c129a3SFam Zheng static ImageInfo *vmdk_get_extent_info(VmdkExtent *extent) 1953f4c129a3SFam Zheng { 1954f4c129a3SFam Zheng ImageInfo *info = g_new0(ImageInfo, 1); 1955f4c129a3SFam Zheng 1956f4c129a3SFam Zheng *info = (ImageInfo){ 1957f4c129a3SFam Zheng .filename = g_strdup(extent->file->filename), 1958f4c129a3SFam Zheng .format = g_strdup(extent->type), 1959f4c129a3SFam Zheng .virtual_size = extent->sectors * BDRV_SECTOR_SIZE, 1960f4c129a3SFam Zheng .compressed = extent->compressed, 1961f4c129a3SFam Zheng .has_compressed = extent->compressed, 1962f4c129a3SFam Zheng .cluster_size = extent->cluster_sectors * BDRV_SECTOR_SIZE, 1963f4c129a3SFam Zheng .has_cluster_size = !extent->flat, 1964f4c129a3SFam Zheng }; 1965f4c129a3SFam Zheng 1966f4c129a3SFam Zheng return info; 1967f4c129a3SFam Zheng } 1968f4c129a3SFam Zheng 1969f43aa8e1SPeter Lieven static int vmdk_check(BlockDriverState *bs, BdrvCheckResult *result, 1970f43aa8e1SPeter Lieven BdrvCheckMode fix) 1971f43aa8e1SPeter Lieven { 1972f43aa8e1SPeter Lieven BDRVVmdkState *s = bs->opaque; 1973f43aa8e1SPeter Lieven VmdkExtent *extent = NULL; 1974f43aa8e1SPeter Lieven int64_t sector_num = 0; 1975f43aa8e1SPeter Lieven int64_t total_sectors = bdrv_getlength(bs) / BDRV_SECTOR_SIZE; 1976f43aa8e1SPeter Lieven int ret; 1977f43aa8e1SPeter Lieven uint64_t cluster_offset; 1978f43aa8e1SPeter Lieven 1979f43aa8e1SPeter Lieven if (fix) { 1980f43aa8e1SPeter Lieven return -ENOTSUP; 1981f43aa8e1SPeter Lieven } 1982f43aa8e1SPeter Lieven 1983f43aa8e1SPeter Lieven for (;;) { 1984f43aa8e1SPeter Lieven if (sector_num >= total_sectors) { 1985f43aa8e1SPeter Lieven return 0; 1986f43aa8e1SPeter Lieven } 1987f43aa8e1SPeter Lieven extent = find_extent(s, sector_num, extent); 1988f43aa8e1SPeter Lieven if (!extent) { 1989f43aa8e1SPeter Lieven fprintf(stderr, 1990f43aa8e1SPeter Lieven "ERROR: could not find extent for sector %" PRId64 "\n", 1991f43aa8e1SPeter Lieven sector_num); 1992f43aa8e1SPeter Lieven break; 1993f43aa8e1SPeter Lieven } 1994f43aa8e1SPeter Lieven ret = get_cluster_offset(bs, extent, NULL, 1995f43aa8e1SPeter Lieven sector_num << BDRV_SECTOR_BITS, 1996f43aa8e1SPeter Lieven 0, &cluster_offset); 1997f43aa8e1SPeter Lieven if (ret == VMDK_ERROR) { 1998f43aa8e1SPeter Lieven fprintf(stderr, 1999f43aa8e1SPeter Lieven "ERROR: could not get cluster_offset for sector %" 2000f43aa8e1SPeter Lieven PRId64 "\n", sector_num); 2001f43aa8e1SPeter Lieven break; 2002f43aa8e1SPeter Lieven } 2003f43aa8e1SPeter Lieven if (ret == VMDK_OK && cluster_offset >= bdrv_getlength(extent->file)) { 2004f43aa8e1SPeter Lieven fprintf(stderr, 2005f43aa8e1SPeter Lieven "ERROR: cluster offset for sector %" 2006f43aa8e1SPeter Lieven PRId64 " points after EOF\n", sector_num); 2007f43aa8e1SPeter Lieven break; 2008f43aa8e1SPeter Lieven } 2009f43aa8e1SPeter Lieven sector_num += extent->cluster_sectors; 2010f43aa8e1SPeter Lieven } 2011f43aa8e1SPeter Lieven 2012f43aa8e1SPeter Lieven result->corruptions++; 2013f43aa8e1SPeter Lieven return 0; 2014f43aa8e1SPeter Lieven } 2015f43aa8e1SPeter Lieven 2016f4c129a3SFam Zheng static ImageInfoSpecific *vmdk_get_specific_info(BlockDriverState *bs) 2017f4c129a3SFam Zheng { 2018f4c129a3SFam Zheng int i; 2019f4c129a3SFam Zheng BDRVVmdkState *s = bs->opaque; 2020f4c129a3SFam Zheng ImageInfoSpecific *spec_info = g_new0(ImageInfoSpecific, 1); 2021f4c129a3SFam Zheng ImageInfoList **next; 2022f4c129a3SFam Zheng 2023f4c129a3SFam Zheng *spec_info = (ImageInfoSpecific){ 2024f4c129a3SFam Zheng .kind = IMAGE_INFO_SPECIFIC_KIND_VMDK, 2025f4c129a3SFam Zheng { 2026f4c129a3SFam Zheng .vmdk = g_new0(ImageInfoSpecificVmdk, 1), 2027f4c129a3SFam Zheng }, 2028f4c129a3SFam Zheng }; 2029f4c129a3SFam Zheng 2030f4c129a3SFam Zheng *spec_info->vmdk = (ImageInfoSpecificVmdk) { 2031f4c129a3SFam Zheng .create_type = g_strdup(s->create_type), 2032f4c129a3SFam Zheng .cid = s->cid, 2033f4c129a3SFam Zheng .parent_cid = s->parent_cid, 2034f4c129a3SFam Zheng }; 2035f4c129a3SFam Zheng 2036f4c129a3SFam Zheng next = &spec_info->vmdk->extents; 2037f4c129a3SFam Zheng for (i = 0; i < s->num_extents; i++) { 2038f4c129a3SFam Zheng *next = g_new0(ImageInfoList, 1); 2039f4c129a3SFam Zheng (*next)->value = vmdk_get_extent_info(&s->extents[i]); 2040f4c129a3SFam Zheng (*next)->next = NULL; 2041f4c129a3SFam Zheng next = &(*next)->next; 2042f4c129a3SFam Zheng } 2043f4c129a3SFam Zheng 2044f4c129a3SFam Zheng return spec_info; 2045f4c129a3SFam Zheng } 2046f4c129a3SFam Zheng 20470e7e1989SKevin Wolf static QEMUOptionParameter vmdk_create_options[] = { 2048db08adf5SKevin Wolf { 2049db08adf5SKevin Wolf .name = BLOCK_OPT_SIZE, 2050db08adf5SKevin Wolf .type = OPT_SIZE, 2051db08adf5SKevin Wolf .help = "Virtual disk size" 2052db08adf5SKevin Wolf }, 2053db08adf5SKevin Wolf { 20547f2039f6SOthmar Pasteka .name = BLOCK_OPT_ADAPTER_TYPE, 20557f2039f6SOthmar Pasteka .type = OPT_STRING, 20567f2039f6SOthmar Pasteka .help = "Virtual adapter type, can be one of " 20577f2039f6SOthmar Pasteka "ide (default), lsilogic, buslogic or legacyESX" 20587f2039f6SOthmar Pasteka }, 20597f2039f6SOthmar Pasteka { 2060db08adf5SKevin Wolf .name = BLOCK_OPT_BACKING_FILE, 2061db08adf5SKevin Wolf .type = OPT_STRING, 2062db08adf5SKevin Wolf .help = "File name of a base image" 2063db08adf5SKevin Wolf }, 2064db08adf5SKevin Wolf { 2065db08adf5SKevin Wolf .name = BLOCK_OPT_COMPAT6, 2066db08adf5SKevin Wolf .type = OPT_FLAG, 2067db08adf5SKevin Wolf .help = "VMDK version 6 image" 2068db08adf5SKevin Wolf }, 2069f66fd6c3SFam Zheng { 2070f66fd6c3SFam Zheng .name = BLOCK_OPT_SUBFMT, 2071f66fd6c3SFam Zheng .type = OPT_STRING, 2072f66fd6c3SFam Zheng .help = 2073f66fd6c3SFam Zheng "VMDK flat extent format, can be one of " 20746c031aacSFam Zheng "{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} " 2075f66fd6c3SFam Zheng }, 207669e0b6dfSFam Zheng { 207769e0b6dfSFam Zheng .name = BLOCK_OPT_ZEROED_GRAIN, 207869e0b6dfSFam Zheng .type = OPT_FLAG, 207969e0b6dfSFam Zheng .help = "Enable efficient zero writes using the zeroed-grain GTE feature" 208069e0b6dfSFam Zheng }, 20810e7e1989SKevin Wolf { NULL } 20820e7e1989SKevin Wolf }; 20830e7e1989SKevin Wolf 2084019d6b8fSAnthony Liguori static BlockDriver bdrv_vmdk = { 2085019d6b8fSAnthony Liguori .format_name = "vmdk", 2086019d6b8fSAnthony Liguori .instance_size = sizeof(BDRVVmdkState), 2087019d6b8fSAnthony Liguori .bdrv_probe = vmdk_probe, 20886511ef77SKevin Wolf .bdrv_open = vmdk_open, 2089f43aa8e1SPeter Lieven .bdrv_check = vmdk_check, 20903897575fSJeff Cody .bdrv_reopen_prepare = vmdk_reopen_prepare, 20912914caa0SPaolo Bonzini .bdrv_read = vmdk_co_read, 2092e183ef75SPaolo Bonzini .bdrv_write = vmdk_co_write, 2093cdeaf1f1SFam Zheng .bdrv_co_write_zeroes = vmdk_co_write_zeroes, 2094019d6b8fSAnthony Liguori .bdrv_close = vmdk_close, 2095019d6b8fSAnthony Liguori .bdrv_create = vmdk_create, 2096c68b89acSKevin Wolf .bdrv_co_flush_to_disk = vmdk_co_flush, 2097b6b8a333SPaolo Bonzini .bdrv_co_get_block_status = vmdk_co_get_block_status, 20984a1d5e1fSFam Zheng .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size, 2099da7a50f9SFam Zheng .bdrv_has_zero_init = vmdk_has_zero_init, 2100f4c129a3SFam Zheng .bdrv_get_specific_info = vmdk_get_specific_info, 2101d34682cdSKevin Wolf .bdrv_refresh_limits = vmdk_refresh_limits, 21020e7e1989SKevin Wolf 21030e7e1989SKevin Wolf .create_options = vmdk_create_options, 2104019d6b8fSAnthony Liguori }; 2105019d6b8fSAnthony Liguori 2106019d6b8fSAnthony Liguori static void bdrv_vmdk_init(void) 2107019d6b8fSAnthony Liguori { 2108019d6b8fSAnthony Liguori bdrv_register(&bdrv_vmdk); 2109019d6b8fSAnthony Liguori } 2110019d6b8fSAnthony Liguori 2111019d6b8fSAnthony Liguori block_init(bdrv_vmdk_init); 2112