block/vmdk.c

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