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