2004-08-02 05:59:26 +08:00
|
|
|
/*
|
|
|
|
* Block driver for the VMDK format
|
2007-09-17 05:08:06 +08:00
|
|
|
*
|
2004-08-02 05:59:26 +08:00
|
|
|
* Copyright (c) 2004 Fabrice Bellard
|
2005-04-27 05:08:00 +08:00
|
|
|
* Copyright (c) 2005 Filip Navara
|
2007-09-17 05:08:06 +08:00
|
|
|
*
|
2004-08-02 05:59:26 +08:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2007-11-11 10:51:17 +08:00
|
|
|
#include "qemu-common.h"
|
2012-12-18 01:19:44 +08:00
|
|
|
#include "block/block_int.h"
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/module.h"
|
2012-12-18 01:19:50 +08:00
|
|
|
#include "migration/migration.h"
|
2011-11-20 19:34:30 +08:00
|
|
|
#include <zlib.h>
|
2004-08-02 05:59:26 +08:00
|
|
|
|
|
|
|
#define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
|
|
|
|
#define VMDK4_MAGIC (('K' << 24) | ('D' << 16) | ('M' << 8) | 'V')
|
2011-08-12 23:19:30 +08:00
|
|
|
#define VMDK4_COMPRESSION_DEFLATE 1
|
2013-05-02 10:25:25 +08:00
|
|
|
#define VMDK4_FLAG_NL_DETECT (1 << 0)
|
2011-08-12 23:19:34 +08:00
|
|
|
#define VMDK4_FLAG_RGD (1 << 1)
|
2013-05-02 10:25:23 +08:00
|
|
|
/* Zeroed-grain enable bit */
|
|
|
|
#define VMDK4_FLAG_ZERO_GRAIN (1 << 2)
|
2011-08-12 23:19:30 +08:00
|
|
|
#define VMDK4_FLAG_COMPRESS (1 << 16)
|
|
|
|
#define VMDK4_FLAG_MARKER (1 << 17)
|
2012-08-16 16:39:33 +08:00
|
|
|
#define VMDK4_GD_AT_END 0xffffffffffffffffULL
|
2004-08-02 05:59:26 +08:00
|
|
|
|
2013-05-02 10:25:23 +08:00
|
|
|
#define VMDK_GTE_ZEROED 0x1
|
2013-05-02 10:25:22 +08:00
|
|
|
|
|
|
|
/* VMDK internal error codes */
|
|
|
|
#define VMDK_OK 0
|
|
|
|
#define VMDK_ERROR (-1)
|
|
|
|
/* Cluster not allocated */
|
|
|
|
#define VMDK_UNALLOC (-2)
|
|
|
|
#define VMDK_ZEROED (-3)
|
|
|
|
|
2013-05-02 10:25:24 +08:00
|
|
|
#define BLOCK_OPT_ZEROED_GRAIN "zeroed_grain"
|
|
|
|
|
2004-08-02 05:59:26 +08:00
|
|
|
typedef struct {
|
|
|
|
uint32_t version;
|
|
|
|
uint32_t flags;
|
|
|
|
uint32_t disk_sectors;
|
|
|
|
uint32_t granularity;
|
|
|
|
uint32_t l1dir_offset;
|
|
|
|
uint32_t l1dir_size;
|
|
|
|
uint32_t file_sectors;
|
|
|
|
uint32_t cylinders;
|
|
|
|
uint32_t heads;
|
|
|
|
uint32_t sectors_per_track;
|
2013-08-06 15:44:47 +08:00
|
|
|
} QEMU_PACKED VMDK3Header;
|
2004-08-02 05:59:26 +08:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint32_t version;
|
|
|
|
uint32_t flags;
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t capacity;
|
|
|
|
uint64_t granularity;
|
|
|
|
uint64_t desc_offset;
|
|
|
|
uint64_t desc_size;
|
2013-08-06 15:44:55 +08:00
|
|
|
/* Number of GrainTableEntries per GrainTable */
|
|
|
|
uint32_t num_gtes_per_gt;
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t rgd_offset;
|
|
|
|
uint64_t gd_offset;
|
|
|
|
uint64_t grain_offset;
|
2004-08-02 05:59:26 +08:00
|
|
|
char filler[1];
|
|
|
|
char check_bytes[4];
|
2011-08-12 23:19:30 +08:00
|
|
|
uint16_t compressAlgorithm;
|
2011-08-31 18:38:01 +08:00
|
|
|
} QEMU_PACKED VMDK4Header;
|
2004-08-02 05:59:26 +08:00
|
|
|
|
|
|
|
#define L2_CACHE_SIZE 16
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
typedef struct VmdkExtent {
|
|
|
|
BlockDriverState *file;
|
|
|
|
bool flat;
|
2011-08-12 23:19:30 +08:00
|
|
|
bool compressed;
|
|
|
|
bool has_marker;
|
2013-05-02 10:25:23 +08:00
|
|
|
bool has_zero_grain;
|
|
|
|
int version;
|
2011-07-12 19:56:28 +08:00
|
|
|
int64_t sectors;
|
|
|
|
int64_t end_sector;
|
2011-07-19 08:38:22 +08:00
|
|
|
int64_t flat_start_offset;
|
2004-08-02 05:59:26 +08:00
|
|
|
int64_t l1_table_offset;
|
2005-04-27 05:08:00 +08:00
|
|
|
int64_t l1_backup_table_offset;
|
2004-08-02 05:59:26 +08:00
|
|
|
uint32_t *l1_table;
|
2005-04-27 05:08:00 +08:00
|
|
|
uint32_t *l1_backup_table;
|
2004-08-02 05:59:26 +08:00
|
|
|
unsigned int l1_size;
|
|
|
|
uint32_t l1_entry_sectors;
|
|
|
|
|
|
|
|
unsigned int l2_size;
|
|
|
|
uint32_t *l2_cache;
|
|
|
|
uint32_t l2_cache_offsets[L2_CACHE_SIZE];
|
|
|
|
uint32_t l2_cache_counts[L2_CACHE_SIZE];
|
|
|
|
|
|
|
|
unsigned int cluster_sectors;
|
2011-07-12 19:56:28 +08:00
|
|
|
} VmdkExtent;
|
|
|
|
|
|
|
|
typedef struct BDRVVmdkState {
|
2011-10-20 19:16:21 +08:00
|
|
|
CoMutex lock;
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t desc_offset;
|
2011-07-12 19:56:34 +08:00
|
|
|
bool cid_updated;
|
2007-01-25 05:05:24 +08:00
|
|
|
uint32_t parent_cid;
|
2011-07-12 19:56:28 +08:00
|
|
|
int num_extents;
|
|
|
|
/* Extent array with num_extents entries, ascend ordered by address */
|
|
|
|
VmdkExtent *extents;
|
2011-11-22 23:50:27 +08:00
|
|
|
Error *migration_blocker;
|
2004-08-02 05:59:26 +08:00
|
|
|
} BDRVVmdkState;
|
|
|
|
|
2007-06-18 23:01:30 +08:00
|
|
|
typedef struct VmdkMetaData {
|
|
|
|
uint32_t offset;
|
|
|
|
unsigned int l1_index;
|
|
|
|
unsigned int l2_index;
|
|
|
|
unsigned int l2_offset;
|
|
|
|
int valid;
|
2013-05-02 10:25:27 +08:00
|
|
|
uint32_t *l2_cache_entry;
|
2007-06-18 23:01:30 +08:00
|
|
|
} VmdkMetaData;
|
|
|
|
|
2011-08-12 23:19:30 +08:00
|
|
|
typedef struct VmdkGrainMarker {
|
|
|
|
uint64_t lba;
|
|
|
|
uint32_t size;
|
|
|
|
uint8_t data[0];
|
2013-08-06 15:44:47 +08:00
|
|
|
} QEMU_PACKED VmdkGrainMarker;
|
2011-08-12 23:19:30 +08:00
|
|
|
|
2012-08-16 16:39:33 +08:00
|
|
|
enum {
|
|
|
|
MARKER_END_OF_STREAM = 0,
|
|
|
|
MARKER_GRAIN_TABLE = 1,
|
|
|
|
MARKER_GRAIN_DIRECTORY = 2,
|
|
|
|
MARKER_FOOTER = 3,
|
|
|
|
};
|
|
|
|
|
2004-08-02 05:59:26 +08:00
|
|
|
static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename)
|
|
|
|
{
|
|
|
|
uint32_t magic;
|
|
|
|
|
2011-07-12 19:56:38 +08:00
|
|
|
if (buf_size < 4) {
|
2004-08-02 05:59:26 +08:00
|
|
|
return 0;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
magic = be32_to_cpu(*(uint32_t *)buf);
|
|
|
|
if (magic == VMDK3_MAGIC ||
|
2011-07-12 19:56:30 +08:00
|
|
|
magic == VMDK4_MAGIC) {
|
2004-08-02 05:59:26 +08:00
|
|
|
return 100;
|
2011-07-12 19:56:30 +08:00
|
|
|
} else {
|
|
|
|
const char *p = (const char *)buf;
|
|
|
|
const char *end = p + buf_size;
|
|
|
|
while (p < end) {
|
|
|
|
if (*p == '#') {
|
|
|
|
/* skip comment line */
|
|
|
|
while (p < end && *p != '\n') {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (*p == ' ') {
|
|
|
|
while (p < end && *p == ' ') {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
/* skip '\r' if windows line endings used. */
|
|
|
|
if (p < end && *p == '\r') {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
/* only accept blank lines before 'version=' line */
|
|
|
|
if (p == end || *p != '\n') {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (end - p >= strlen("version=X\n")) {
|
|
|
|
if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 ||
|
|
|
|
strncmp("version=2\n", p, strlen("version=2\n")) == 0) {
|
|
|
|
return 100;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (end - p >= strlen("version=X\r\n")) {
|
|
|
|
if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 ||
|
|
|
|
strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) {
|
|
|
|
return 100;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
return 0;
|
2011-07-12 19:56:30 +08:00
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2007-01-25 05:05:24 +08:00
|
|
|
#define CHECK_CID 1
|
|
|
|
|
2007-09-17 16:09:54 +08:00
|
|
|
#define SECTOR_SIZE 512
|
2011-07-19 08:45:23 +08:00
|
|
|
#define DESC_SIZE (20 * SECTOR_SIZE) /* 20 sectors of 512 bytes each */
|
|
|
|
#define BUF_SIZE 4096
|
|
|
|
#define HEADER_SIZE 512 /* first sector of 512 bytes */
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
static void vmdk_free_extents(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-09-19 10:26:42 +08:00
|
|
|
VmdkExtent *e;
|
2011-07-12 19:56:28 +08:00
|
|
|
|
|
|
|
for (i = 0; i < s->num_extents; i++) {
|
2011-09-19 10:26:42 +08:00
|
|
|
e = &s->extents[i];
|
|
|
|
g_free(e->l1_table);
|
|
|
|
g_free(e->l2_cache);
|
|
|
|
g_free(e->l1_backup_table);
|
|
|
|
if (e->file != bs->file) {
|
|
|
|
bdrv_delete(e->file);
|
|
|
|
}
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2011-08-21 11:09:37 +08:00
|
|
|
g_free(s->extents);
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
static void vmdk_free_last_extent(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
|
|
|
|
if (s->num_extents == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
s->num_extents--;
|
|
|
|
s->extents = g_realloc(s->extents, s->num_extents * sizeof(VmdkExtent));
|
|
|
|
}
|
|
|
|
|
2007-01-25 05:05:24 +08:00
|
|
|
static uint32_t vmdk_read_cid(BlockDriverState *bs, int parent)
|
2004-08-02 05:59:26 +08:00
|
|
|
{
|
2007-01-25 05:05:24 +08:00
|
|
|
char desc[DESC_SIZE];
|
2011-10-19 01:19:03 +08:00
|
|
|
uint32_t cid = 0xffffffff;
|
2008-09-14 14:45:34 +08:00
|
|
|
const char *p_name, *cid_str;
|
2007-01-25 05:05:24 +08:00
|
|
|
size_t cid_str_size;
|
2011-07-12 19:56:32 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-10-26 18:25:25 +08:00
|
|
|
int ret;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-10-26 18:25:25 +08:00
|
|
|
ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
|
|
|
|
if (ret < 0) {
|
2007-01-25 05:05:24 +08:00
|
|
|
return 0;
|
2011-07-12 19:56:32 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
|
|
|
if (parent) {
|
|
|
|
cid_str = "parentCID";
|
|
|
|
cid_str_size = sizeof("parentCID");
|
|
|
|
} else {
|
|
|
|
cid_str = "CID";
|
|
|
|
cid_str_size = sizeof("CID");
|
|
|
|
}
|
|
|
|
|
2011-10-26 18:25:52 +08:00
|
|
|
desc[DESC_SIZE - 1] = '\0';
|
2011-07-12 19:56:38 +08:00
|
|
|
p_name = strstr(desc, cid_str);
|
|
|
|
if (p_name != NULL) {
|
2007-01-25 05:05:24 +08:00
|
|
|
p_name += cid_str_size;
|
2011-07-12 19:56:38 +08:00
|
|
|
sscanf(p_name, "%x", &cid);
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return cid;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
|
|
|
|
{
|
|
|
|
char desc[DESC_SIZE], tmp_desc[DESC_SIZE];
|
|
|
|
char *p_name, *tmp_str;
|
2011-07-12 19:56:32 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-10-26 18:25:25 +08:00
|
|
|
int ret;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-10-26 18:25:25 +08:00
|
|
|
ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2011-07-12 19:56:32 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-10-26 18:25:52 +08:00
|
|
|
desc[DESC_SIZE - 1] = '\0';
|
2011-07-12 19:56:38 +08:00
|
|
|
tmp_str = strstr(desc, "parentCID");
|
2011-10-26 18:25:52 +08:00
|
|
|
if (tmp_str == NULL) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-08-22 01:58:08 +08:00
|
|
|
pstrcpy(tmp_desc, sizeof(tmp_desc), tmp_str);
|
2011-07-12 19:56:38 +08:00
|
|
|
p_name = strstr(desc, "CID");
|
|
|
|
if (p_name != NULL) {
|
2007-01-25 05:05:24 +08:00
|
|
|
p_name += sizeof("CID");
|
2008-08-22 01:58:08 +08:00
|
|
|
snprintf(p_name, sizeof(desc) - (p_name - desc), "%x\n", cid);
|
|
|
|
pstrcat(desc, sizeof(desc), tmp_desc);
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
|
|
|
|
2011-10-26 18:25:25 +08:00
|
|
|
ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2011-07-12 19:56:32 +08:00
|
|
|
}
|
2011-10-26 18:25:25 +08:00
|
|
|
|
2007-01-25 05:05:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmdk_is_cid_valid(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
#ifdef CHECK_CID
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2009-07-17 14:20:41 +08:00
|
|
|
BlockDriverState *p_bs = bs->backing_hd;
|
2007-01-25 05:05:24 +08:00
|
|
|
uint32_t cur_pcid;
|
|
|
|
|
|
|
|
if (p_bs) {
|
2011-07-12 19:56:38 +08:00
|
|
|
cur_pcid = vmdk_read_cid(p_bs, 0);
|
|
|
|
if (s->parent_cid != cur_pcid) {
|
|
|
|
/* CID not valid */
|
2007-01-25 05:05:24 +08:00
|
|
|
return 0;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
|
|
|
#endif
|
2011-07-12 19:56:38 +08:00
|
|
|
/* CID valid */
|
2007-01-25 05:05:24 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-09-21 03:13:30 +08:00
|
|
|
/* Queue extents, if any, for reopen() */
|
|
|
|
static int vmdk_reopen_prepare(BDRVReopenState *state,
|
|
|
|
BlockReopenQueue *queue, Error **errp)
|
|
|
|
{
|
|
|
|
BDRVVmdkState *s;
|
|
|
|
int ret = -1;
|
|
|
|
int i;
|
|
|
|
VmdkExtent *e;
|
|
|
|
|
|
|
|
assert(state != NULL);
|
|
|
|
assert(state->bs != NULL);
|
|
|
|
|
|
|
|
if (queue == NULL) {
|
|
|
|
error_set(errp, ERROR_CLASS_GENERIC_ERROR,
|
|
|
|
"No reopen queue for VMDK extents");
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = state->bs->opaque;
|
|
|
|
|
|
|
|
assert(s != NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < s->num_extents; i++) {
|
|
|
|
e = &s->extents[i];
|
|
|
|
if (e->file != state->bs->file) {
|
|
|
|
bdrv_reopen_queue(queue, e->file, state->flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
exit:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-04-17 03:07:19 +08:00
|
|
|
static int vmdk_parent_open(BlockDriverState *bs)
|
2007-01-25 05:05:24 +08:00
|
|
|
{
|
2007-09-17 05:08:06 +08:00
|
|
|
char *p_name;
|
2011-07-19 08:38:22 +08:00
|
|
|
char desc[DESC_SIZE + 1];
|
2011-07-12 19:56:32 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-10-20 19:16:19 +08:00
|
|
|
int ret;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-19 08:38:22 +08:00
|
|
|
desc[DESC_SIZE] = '\0';
|
2011-10-20 19:16:19 +08:00
|
|
|
ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
2011-07-12 19:56:32 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:38 +08:00
|
|
|
p_name = strstr(desc, "parentFileNameHint");
|
|
|
|
if (p_name != NULL) {
|
2007-01-25 05:05:24 +08:00
|
|
|
char *end_name;
|
|
|
|
|
|
|
|
p_name += sizeof("parentFileNameHint") + 1;
|
2011-07-12 19:56:38 +08:00
|
|
|
end_name = strchr(p_name, '\"');
|
|
|
|
if (end_name == NULL) {
|
2011-10-20 19:16:19 +08:00
|
|
|
return -EINVAL;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
|
|
|
if ((end_name - p_name) > sizeof(bs->backing_file) - 1) {
|
2011-10-20 19:16:19 +08:00
|
|
|
return -EINVAL;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2007-09-17 16:09:54 +08:00
|
|
|
|
2009-07-17 14:20:41 +08:00
|
|
|
pstrcpy(bs->backing_file, end_name - p_name + 1, p_name);
|
2005-04-27 05:08:00 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
/* Create and append extent to the extent array. Return the added VmdkExtent
|
|
|
|
* address. return NULL if allocation failed. */
|
2013-08-06 15:44:51 +08:00
|
|
|
static int vmdk_add_extent(BlockDriverState *bs,
|
2011-07-12 19:56:28 +08:00
|
|
|
BlockDriverState *file, bool flat, int64_t sectors,
|
|
|
|
int64_t l1_offset, int64_t l1_backup_offset,
|
|
|
|
uint32_t l1_size,
|
2013-08-06 15:44:51 +08:00
|
|
|
int l2_size, uint64_t cluster_sectors,
|
|
|
|
VmdkExtent **new_extent)
|
2011-07-12 19:56:28 +08:00
|
|
|
{
|
|
|
|
VmdkExtent *extent;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
|
2013-08-06 15:44:51 +08:00
|
|
|
if (cluster_sectors > 0x200000) {
|
|
|
|
/* 0x200000 * 512Bytes = 1GB for one cluster is unrealistic */
|
|
|
|
error_report("invalid granularity, image may be corrupt");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-08-19 18:54:25 +08:00
|
|
|
if (l1_size > 512 * 1024 * 1024) {
|
|
|
|
/* Although with big capacity and small l1_entry_sectors, we can get a
|
|
|
|
* big l1_size, we don't want unbounded value to allocate the table.
|
|
|
|
* Limit it to 512M, which is 16PB for default cluster and L2 table
|
|
|
|
* size */
|
|
|
|
error_report("L1 size too big");
|
|
|
|
return -EFBIG;
|
|
|
|
}
|
2013-08-06 15:44:51 +08:00
|
|
|
|
2011-08-21 11:09:37 +08:00
|
|
|
s->extents = g_realloc(s->extents,
|
2011-07-12 19:56:28 +08:00
|
|
|
(s->num_extents + 1) * sizeof(VmdkExtent));
|
|
|
|
extent = &s->extents[s->num_extents];
|
|
|
|
s->num_extents++;
|
|
|
|
|
|
|
|
memset(extent, 0, sizeof(VmdkExtent));
|
|
|
|
extent->file = file;
|
|
|
|
extent->flat = flat;
|
|
|
|
extent->sectors = sectors;
|
|
|
|
extent->l1_table_offset = l1_offset;
|
|
|
|
extent->l1_backup_table_offset = l1_backup_offset;
|
|
|
|
extent->l1_size = l1_size;
|
|
|
|
extent->l1_entry_sectors = l2_size * cluster_sectors;
|
|
|
|
extent->l2_size = l2_size;
|
|
|
|
extent->cluster_sectors = cluster_sectors;
|
|
|
|
|
|
|
|
if (s->num_extents > 1) {
|
|
|
|
extent->end_sector = (*(extent - 1)).end_sector + extent->sectors;
|
|
|
|
} else {
|
|
|
|
extent->end_sector = extent->sectors;
|
|
|
|
}
|
|
|
|
bs->total_sectors = extent->end_sector;
|
2013-08-06 15:44:51 +08:00
|
|
|
if (new_extent) {
|
|
|
|
*new_extent = extent;
|
|
|
|
}
|
|
|
|
return 0;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:31 +08:00
|
|
|
static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent)
|
2007-01-25 05:05:24 +08:00
|
|
|
{
|
2011-07-12 19:56:31 +08:00
|
|
|
int ret;
|
|
|
|
int l1_size, i;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2004-08-02 05:59:26 +08:00
|
|
|
/* read the L1 table */
|
2011-07-12 19:56:28 +08:00
|
|
|
l1_size = extent->l1_size * sizeof(uint32_t);
|
2011-08-21 11:09:37 +08:00
|
|
|
extent->l1_table = g_malloc(l1_size);
|
2011-07-12 19:56:31 +08:00
|
|
|
ret = bdrv_pread(extent->file,
|
|
|
|
extent->l1_table_offset,
|
|
|
|
extent->l1_table,
|
|
|
|
l1_size);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail_l1;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
|
|
|
for (i = 0; i < extent->l1_size; i++) {
|
|
|
|
le32_to_cpus(&extent->l1_table[i]);
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
if (extent->l1_backup_table_offset) {
|
2011-08-21 11:09:37 +08:00
|
|
|
extent->l1_backup_table = g_malloc(l1_size);
|
2011-07-12 19:56:31 +08:00
|
|
|
ret = bdrv_pread(extent->file,
|
|
|
|
extent->l1_backup_table_offset,
|
|
|
|
extent->l1_backup_table,
|
|
|
|
l1_size);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto fail_l1b;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
|
|
|
for (i = 0; i < extent->l1_size; i++) {
|
|
|
|
le32_to_cpus(&extent->l1_backup_table[i]);
|
2005-04-27 05:08:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
extent->l2_cache =
|
2011-08-21 11:09:37 +08:00
|
|
|
g_malloc(extent->l2_size * L2_CACHE_SIZE * sizeof(uint32_t));
|
2004-08-02 05:59:26 +08:00
|
|
|
return 0;
|
2011-07-12 19:56:31 +08:00
|
|
|
fail_l1b:
|
2011-08-21 11:09:37 +08:00
|
|
|
g_free(extent->l1_backup_table);
|
2011-07-12 19:56:31 +08:00
|
|
|
fail_l1:
|
2011-08-21 11:09:37 +08:00
|
|
|
g_free(extent->l1_table);
|
2011-07-12 19:56:31 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-19 18:54:27 +08:00
|
|
|
static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
|
|
|
|
BlockDriverState *file,
|
|
|
|
int flags)
|
2011-07-12 19:56:31 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
uint32_t magic;
|
|
|
|
VMDK3Header header;
|
|
|
|
VmdkExtent *extent;
|
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
|
2011-07-12 19:56:31 +08:00
|
|
|
if (ret < 0) {
|
2011-08-12 23:19:28 +08:00
|
|
|
return ret;
|
2011-07-12 19:56:31 +08:00
|
|
|
}
|
2013-08-19 18:54:26 +08:00
|
|
|
ret = vmdk_add_extent(bs, file, false,
|
|
|
|
le32_to_cpu(header.disk_sectors),
|
|
|
|
le32_to_cpu(header.l1dir_offset) << 9,
|
|
|
|
0,
|
|
|
|
le32_to_cpu(header.l1dir_size),
|
|
|
|
4096,
|
|
|
|
le32_to_cpu(header.granularity),
|
|
|
|
&extent);
|
2013-08-06 15:44:51 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2011-07-12 19:56:31 +08:00
|
|
|
ret = vmdk_init_tables(bs, extent);
|
|
|
|
if (ret) {
|
2011-08-12 23:19:28 +08:00
|
|
|
/* free extent allocated by vmdk_add_extent */
|
|
|
|
vmdk_free_last_extent(bs);
|
2011-07-12 19:56:31 +08:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:33 +08:00
|
|
|
static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t desc_offset);
|
2011-08-12 23:19:33 +08:00
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
static int vmdk_open_vmdk4(BlockDriverState *bs,
|
|
|
|
BlockDriverState *file,
|
|
|
|
int flags)
|
2011-07-12 19:56:31 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
uint32_t magic;
|
|
|
|
uint32_t l1_size, l1_entry_sectors;
|
|
|
|
VMDK4Header header;
|
|
|
|
VmdkExtent *extent;
|
2011-08-12 23:19:34 +08:00
|
|
|
int64_t l1_backup_offset = 0;
|
2011-07-12 19:56:31 +08:00
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
|
2011-07-12 19:56:31 +08:00
|
|
|
if (ret < 0) {
|
2011-08-12 23:19:28 +08:00
|
|
|
return ret;
|
2011-07-12 19:56:31 +08:00
|
|
|
}
|
2013-06-10 17:07:33 +08:00
|
|
|
if (header.capacity == 0) {
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t desc_offset = le64_to_cpu(header.desc_offset);
|
2013-06-10 17:07:33 +08:00
|
|
|
if (desc_offset) {
|
|
|
|
return vmdk_open_desc_file(bs, flags, desc_offset << 9);
|
|
|
|
}
|
2011-08-12 23:19:33 +08:00
|
|
|
}
|
2012-08-16 16:39:33 +08:00
|
|
|
|
|
|
|
if (le64_to_cpu(header.gd_offset) == VMDK4_GD_AT_END) {
|
|
|
|
/*
|
|
|
|
* The footer takes precedence over the header, so read it in. The
|
|
|
|
* footer starts at offset -1024 from the end: One sector for the
|
|
|
|
* footer, and another one for the end-of-stream marker.
|
|
|
|
*/
|
|
|
|
struct {
|
|
|
|
struct {
|
|
|
|
uint64_t val;
|
|
|
|
uint32_t size;
|
|
|
|
uint32_t type;
|
|
|
|
uint8_t pad[512 - 16];
|
|
|
|
} QEMU_PACKED footer_marker;
|
|
|
|
|
|
|
|
uint32_t magic;
|
|
|
|
VMDK4Header header;
|
|
|
|
uint8_t pad[512 - 4 - sizeof(VMDK4Header)];
|
|
|
|
|
|
|
|
struct {
|
|
|
|
uint64_t val;
|
|
|
|
uint32_t size;
|
|
|
|
uint32_t type;
|
|
|
|
uint8_t pad[512 - 16];
|
|
|
|
} QEMU_PACKED eos_marker;
|
|
|
|
} QEMU_PACKED footer;
|
|
|
|
|
|
|
|
ret = bdrv_pread(file,
|
|
|
|
bs->file->total_sectors * 512 - 1536,
|
|
|
|
&footer, sizeof(footer));
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some sanity checks for the footer */
|
|
|
|
if (be32_to_cpu(footer.magic) != VMDK4_MAGIC ||
|
|
|
|
le32_to_cpu(footer.footer_marker.size) != 0 ||
|
|
|
|
le32_to_cpu(footer.footer_marker.type) != MARKER_FOOTER ||
|
|
|
|
le64_to_cpu(footer.eos_marker.val) != 0 ||
|
|
|
|
le32_to_cpu(footer.eos_marker.size) != 0 ||
|
|
|
|
le32_to_cpu(footer.eos_marker.type) != MARKER_END_OF_STREAM)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
header = footer.header;
|
|
|
|
}
|
|
|
|
|
2013-06-13 11:21:29 +08:00
|
|
|
if (le32_to_cpu(header.version) >= 3) {
|
|
|
|
char buf[64];
|
|
|
|
snprintf(buf, sizeof(buf), "VMDK version %d",
|
|
|
|
le32_to_cpu(header.version));
|
|
|
|
qerror_report(QERR_UNKNOWN_BLOCK_FORMAT_FEATURE,
|
|
|
|
bs->device_name, "vmdk", buf);
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
|
2013-08-06 15:44:55 +08:00
|
|
|
if (le32_to_cpu(header.num_gtes_per_gt) > 512) {
|
2013-08-06 15:44:52 +08:00
|
|
|
error_report("L2 table size too big");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-08-06 15:44:55 +08:00
|
|
|
l1_entry_sectors = le32_to_cpu(header.num_gtes_per_gt)
|
2011-07-12 19:56:31 +08:00
|
|
|
* le64_to_cpu(header.granularity);
|
2012-02-25 21:01:42 +08:00
|
|
|
if (l1_entry_sectors == 0) {
|
2011-08-12 23:19:28 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2011-07-12 19:56:31 +08:00
|
|
|
l1_size = (le64_to_cpu(header.capacity) + l1_entry_sectors - 1)
|
|
|
|
/ l1_entry_sectors;
|
2011-08-12 23:19:34 +08:00
|
|
|
if (le32_to_cpu(header.flags) & VMDK4_FLAG_RGD) {
|
|
|
|
l1_backup_offset = le64_to_cpu(header.rgd_offset) << 9;
|
|
|
|
}
|
2013-08-06 15:44:51 +08:00
|
|
|
ret = vmdk_add_extent(bs, file, false,
|
2011-07-12 19:56:31 +08:00
|
|
|
le64_to_cpu(header.capacity),
|
|
|
|
le64_to_cpu(header.gd_offset) << 9,
|
2011-08-12 23:19:34 +08:00
|
|
|
l1_backup_offset,
|
2011-07-12 19:56:31 +08:00
|
|
|
l1_size,
|
2013-08-06 15:44:55 +08:00
|
|
|
le32_to_cpu(header.num_gtes_per_gt),
|
2013-08-06 15:44:51 +08:00
|
|
|
le64_to_cpu(header.granularity),
|
|
|
|
&extent);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2011-08-12 23:19:30 +08:00
|
|
|
extent->compressed =
|
|
|
|
le16_to_cpu(header.compressAlgorithm) == VMDK4_COMPRESSION_DEFLATE;
|
|
|
|
extent->has_marker = le32_to_cpu(header.flags) & VMDK4_FLAG_MARKER;
|
2013-05-02 10:25:23 +08:00
|
|
|
extent->version = le32_to_cpu(header.version);
|
|
|
|
extent->has_zero_grain = le32_to_cpu(header.flags) & VMDK4_FLAG_ZERO_GRAIN;
|
2011-07-12 19:56:31 +08:00
|
|
|
ret = vmdk_init_tables(bs, extent);
|
|
|
|
if (ret) {
|
2011-08-12 23:19:28 +08:00
|
|
|
/* free extent allocated by vmdk_add_extent */
|
|
|
|
vmdk_free_last_extent(bs);
|
2011-07-12 19:56:31 +08:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-07-19 08:38:22 +08:00
|
|
|
/* find an option value out of descriptor file */
|
|
|
|
static int vmdk_parse_description(const char *desc, const char *opt_name,
|
|
|
|
char *buf, int buf_size)
|
|
|
|
{
|
|
|
|
char *opt_pos, *opt_end;
|
|
|
|
const char *end = desc + strlen(desc);
|
|
|
|
|
|
|
|
opt_pos = strstr(desc, opt_name);
|
|
|
|
if (!opt_pos) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
/* Skip "=\"" following opt_name */
|
|
|
|
opt_pos += strlen(opt_name) + 2;
|
|
|
|
if (opt_pos >= end) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
opt_end = opt_pos;
|
|
|
|
while (opt_end < end && *opt_end != '"') {
|
|
|
|
opt_end++;
|
|
|
|
}
|
|
|
|
if (opt_end == end || buf_size < opt_end - opt_pos + 1) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
pstrcpy(buf, opt_end - opt_pos + 1, opt_pos);
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_OK;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
/* Open an extent file and append to bs array */
|
|
|
|
static int vmdk_open_sparse(BlockDriverState *bs,
|
|
|
|
BlockDriverState *file,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
uint32_t magic;
|
|
|
|
|
|
|
|
if (bdrv_pread(file, 0, &magic, sizeof(magic)) != sizeof(magic)) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
magic = be32_to_cpu(magic);
|
|
|
|
switch (magic) {
|
|
|
|
case VMDK3_MAGIC:
|
2013-08-19 18:54:27 +08:00
|
|
|
return vmdk_open_vmfs_sparse(bs, file, flags);
|
2011-08-12 23:19:28 +08:00
|
|
|
break;
|
|
|
|
case VMDK4_MAGIC:
|
|
|
|
return vmdk_open_vmdk4(bs, file, flags);
|
|
|
|
break;
|
|
|
|
default:
|
2013-01-18 04:45:25 +08:00
|
|
|
return -EMEDIUMTYPE;
|
2011-08-12 23:19:28 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-19 08:38:22 +08:00
|
|
|
static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
|
|
|
|
const char *desc_file_path)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char access[11];
|
|
|
|
char type[11];
|
|
|
|
char fname[512];
|
|
|
|
const char *p = desc;
|
|
|
|
int64_t sectors = 0;
|
|
|
|
int64_t flat_offset;
|
2011-08-12 23:19:28 +08:00
|
|
|
char extent_path[PATH_MAX];
|
|
|
|
BlockDriverState *extent_file;
|
2011-07-19 08:38:22 +08:00
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
/* parse extent line:
|
|
|
|
* RW [size in sectors] FLAT "file-name.vmdk" OFFSET
|
|
|
|
* or
|
|
|
|
* RW [size in sectors] SPARSE "file-name.vmdk"
|
|
|
|
*/
|
|
|
|
flat_offset = -1;
|
2013-01-30 05:50:31 +08:00
|
|
|
ret = sscanf(p, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64,
|
2011-07-19 08:38:22 +08:00
|
|
|
access, §ors, type, fname, &flat_offset);
|
|
|
|
if (ret < 4 || strcmp(access, "RW")) {
|
|
|
|
goto next_line;
|
|
|
|
} else if (!strcmp(type, "FLAT")) {
|
|
|
|
if (ret != 5 || flat_offset < 0) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
} else if (ret != 4) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sectors <= 0 ||
|
2013-08-19 18:54:27 +08:00
|
|
|
(strcmp(type, "FLAT") && strcmp(type, "SPARSE") &&
|
2013-08-19 18:54:28 +08:00
|
|
|
strcmp(type, "VMFS") && strcmp(type, "VMFSSPARSE")) ||
|
2011-07-19 08:38:22 +08:00
|
|
|
(strcmp(access, "RW"))) {
|
|
|
|
goto next_line;
|
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
path_combine(extent_path, sizeof(extent_path),
|
|
|
|
desc_file_path, fname);
|
2013-03-06 18:52:48 +08:00
|
|
|
ret = bdrv_file_open(&extent_file, extent_path, NULL, bs->open_flags);
|
2011-08-12 23:19:28 +08:00
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-07-19 08:38:22 +08:00
|
|
|
/* save to extents array */
|
2013-08-19 18:54:28 +08:00
|
|
|
if (!strcmp(type, "FLAT") || !strcmp(type, "VMFS")) {
|
2011-07-19 08:38:22 +08:00
|
|
|
/* FLAT extent */
|
|
|
|
VmdkExtent *extent;
|
|
|
|
|
2013-08-06 15:44:51 +08:00
|
|
|
ret = vmdk_add_extent(bs, extent_file, true, sectors,
|
|
|
|
0, 0, 0, 0, sectors, &extent);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2011-08-12 23:19:33 +08:00
|
|
|
extent->flat_start_offset = flat_offset << 9;
|
2013-08-19 18:54:27 +08:00
|
|
|
} else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
|
|
|
|
/* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/
|
2011-08-12 23:19:28 +08:00
|
|
|
ret = vmdk_open_sparse(bs, extent_file, bs->open_flags);
|
|
|
|
if (ret) {
|
|
|
|
bdrv_delete(extent_file);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-07-19 08:38:22 +08:00
|
|
|
} else {
|
|
|
|
fprintf(stderr,
|
|
|
|
"VMDK: Not supported extent type \"%s\""".\n", type);
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
next_line:
|
|
|
|
/* move to next line */
|
|
|
|
while (*p && *p != '\n') {
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:33 +08:00
|
|
|
static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
|
2013-08-06 15:44:48 +08:00
|
|
|
uint64_t desc_offset)
|
2011-07-19 08:38:22 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2013-06-12 19:06:30 +08:00
|
|
|
char *buf = NULL;
|
2011-07-19 08:38:22 +08:00
|
|
|
char ct[128];
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2013-06-12 19:06:30 +08:00
|
|
|
int64_t size;
|
2011-07-19 08:38:22 +08:00
|
|
|
|
2013-06-12 19:06:30 +08:00
|
|
|
size = bdrv_getlength(bs->file);
|
|
|
|
if (size < 0) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = MIN(size, 1 << 20); /* avoid unbounded allocation */
|
|
|
|
buf = g_malloc0(size + 1);
|
|
|
|
|
|
|
|
ret = bdrv_pread(bs->file, desc_offset, buf, size);
|
2011-07-19 08:38:22 +08:00
|
|
|
if (ret < 0) {
|
2013-06-12 19:06:30 +08:00
|
|
|
goto exit;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
if (vmdk_parse_description(buf, "createType", ct, sizeof(ct))) {
|
2013-06-12 19:06:30 +08:00
|
|
|
ret = -EMEDIUMTYPE;
|
|
|
|
goto exit;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
2011-08-12 23:19:27 +08:00
|
|
|
if (strcmp(ct, "monolithicFlat") &&
|
2013-08-19 18:54:28 +08:00
|
|
|
strcmp(ct, "vmfs") &&
|
2013-08-19 18:54:27 +08:00
|
|
|
strcmp(ct, "vmfsSparse") &&
|
2011-08-12 23:19:28 +08:00
|
|
|
strcmp(ct, "twoGbMaxExtentSparse") &&
|
2011-08-12 23:19:27 +08:00
|
|
|
strcmp(ct, "twoGbMaxExtentFlat")) {
|
2011-07-19 08:38:22 +08:00
|
|
|
fprintf(stderr,
|
|
|
|
"VMDK: Not supported image type \"%s\""".\n", ct);
|
2013-06-12 19:06:30 +08:00
|
|
|
ret = -ENOTSUP;
|
|
|
|
goto exit;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
s->desc_offset = 0;
|
2013-06-12 19:06:30 +08:00
|
|
|
ret = vmdk_parse_extents(buf, bs, bs->file->filename);
|
|
|
|
exit:
|
|
|
|
g_free(buf);
|
|
|
|
return ret;
|
2011-07-19 08:38:22 +08:00
|
|
|
}
|
|
|
|
|
2013-03-15 17:35:01 +08:00
|
|
|
static int vmdk_open(BlockDriverState *bs, QDict *options, int flags)
|
2011-07-12 19:56:31 +08:00
|
|
|
{
|
2011-08-12 23:19:28 +08:00
|
|
|
int ret;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-07-12 19:56:31 +08:00
|
|
|
|
2011-08-12 23:19:28 +08:00
|
|
|
if (vmdk_open_sparse(bs, bs->file, flags) == 0) {
|
|
|
|
s->desc_offset = 0x200;
|
vmdk: clean up open
Move vmdk_parent_open to vmdk_open. There's another path how
vmdk_parent_open can be reached:
vmdk_parse_extents() -> vmdk_open_sparse() -> vmdk_open_vmdk4() ->
vmdk_open_desc_file().
If that can happen, however, the code is bogus. vmdk_parent_open
reads from bs->file:
if (bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE) != DESC_SIZE) {
but it is always called with s->desc_offset == 0 and with the same
bs->file. So the data that vmdk_parent_open reads comes always from the
same place, and anyway there is only one place where it can write it,
namely bs->backing_file.
So, if it cannot happen, the patched code is okay.
It is also possible that the recursive call can happen, but only once. In
that case there would still be a bug in vmdk_open_desc_file setting
s->desc_offset = 0, but the patched code is okay.
Finally, in the case where multiple recursive calls can happen the code
would need to be rewritten anyway. It is likely that this would anyway
involve adding several parameters to vmdk_parent_open, and calling it from
vmdk_open_vmdk4.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-10-20 19:16:20 +08:00
|
|
|
} else {
|
|
|
|
ret = vmdk_open_desc_file(bs, flags, 0);
|
2011-08-12 23:19:28 +08:00
|
|
|
if (ret) {
|
vmdk: clean up open
Move vmdk_parent_open to vmdk_open. There's another path how
vmdk_parent_open can be reached:
vmdk_parse_extents() -> vmdk_open_sparse() -> vmdk_open_vmdk4() ->
vmdk_open_desc_file().
If that can happen, however, the code is bogus. vmdk_parent_open
reads from bs->file:
if (bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE) != DESC_SIZE) {
but it is always called with s->desc_offset == 0 and with the same
bs->file. So the data that vmdk_parent_open reads comes always from the
same place, and anyway there is only one place where it can write it,
namely bs->backing_file.
So, if it cannot happen, the patched code is okay.
It is also possible that the recursive call can happen, but only once. In
that case there would still be a bug in vmdk_open_desc_file setting
s->desc_offset = 0, but the patched code is okay.
Finally, in the case where multiple recursive calls can happen the code
would need to be rewritten anyway. It is likely that this would anyway
involve adding several parameters to vmdk_parent_open, and calling it from
vmdk_open_vmdk4.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-10-20 19:16:20 +08:00
|
|
|
goto fail;
|
2011-08-12 23:19:28 +08:00
|
|
|
}
|
2011-07-12 19:56:31 +08:00
|
|
|
}
|
vmdk: clean up open
Move vmdk_parent_open to vmdk_open. There's another path how
vmdk_parent_open can be reached:
vmdk_parse_extents() -> vmdk_open_sparse() -> vmdk_open_vmdk4() ->
vmdk_open_desc_file().
If that can happen, however, the code is bogus. vmdk_parent_open
reads from bs->file:
if (bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE) != DESC_SIZE) {
but it is always called with s->desc_offset == 0 and with the same
bs->file. So the data that vmdk_parent_open reads comes always from the
same place, and anyway there is only one place where it can write it,
namely bs->backing_file.
So, if it cannot happen, the patched code is okay.
It is also possible that the recursive call can happen, but only once. In
that case there would still be a bug in vmdk_open_desc_file setting
s->desc_offset = 0, but the patched code is okay.
Finally, in the case where multiple recursive calls can happen the code
would need to be rewritten anyway. It is likely that this would anyway
involve adding several parameters to vmdk_parent_open, and calling it from
vmdk_open_vmdk4.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-10-20 19:16:20 +08:00
|
|
|
/* try to open parent images, if exist */
|
|
|
|
ret = vmdk_parent_open(bs);
|
|
|
|
if (ret) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
s->parent_cid = vmdk_read_cid(bs, 1);
|
2011-10-20 19:16:21 +08:00
|
|
|
qemu_co_mutex_init(&s->lock);
|
2011-11-22 23:50:27 +08:00
|
|
|
|
|
|
|
/* Disable migration when VMDK images are used */
|
|
|
|
error_set(&s->migration_blocker,
|
|
|
|
QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED,
|
|
|
|
"vmdk", bs->device_name, "live migration");
|
|
|
|
migrate_add_blocker(s->migration_blocker);
|
|
|
|
|
|
|
|
return 0;
|
vmdk: clean up open
Move vmdk_parent_open to vmdk_open. There's another path how
vmdk_parent_open can be reached:
vmdk_parse_extents() -> vmdk_open_sparse() -> vmdk_open_vmdk4() ->
vmdk_open_desc_file().
If that can happen, however, the code is bogus. vmdk_parent_open
reads from bs->file:
if (bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE) != DESC_SIZE) {
but it is always called with s->desc_offset == 0 and with the same
bs->file. So the data that vmdk_parent_open reads comes always from the
same place, and anyway there is only one place where it can write it,
namely bs->backing_file.
So, if it cannot happen, the patched code is okay.
It is also possible that the recursive call can happen, but only once. In
that case there would still be a bug in vmdk_open_desc_file setting
s->desc_offset = 0, but the patched code is okay.
Finally, in the case where multiple recursive calls can happen the code
would need to be rewritten anyway. It is likely that this would anyway
involve adding several parameters to vmdk_parent_open, and calling it from
vmdk_open_vmdk4.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2011-10-20 19:16:20 +08:00
|
|
|
|
|
|
|
fail:
|
|
|
|
vmdk_free_extents(bs);
|
|
|
|
return ret;
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
static int get_whole_cluster(BlockDriverState *bs,
|
|
|
|
VmdkExtent *extent,
|
|
|
|
uint64_t cluster_offset,
|
|
|
|
uint64_t offset,
|
|
|
|
bool allocate)
|
2007-01-25 05:05:24 +08:00
|
|
|
{
|
2013-08-06 15:44:54 +08:00
|
|
|
int ret = VMDK_OK;
|
|
|
|
uint8_t *whole_grain = NULL;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:29 +08:00
|
|
|
/* we will be here if it's first write on non-exist grain(cluster).
|
|
|
|
* try to read from parent image, if exist */
|
2009-07-17 14:20:41 +08:00
|
|
|
if (bs->backing_hd) {
|
2013-08-06 15:44:54 +08:00
|
|
|
whole_grain =
|
|
|
|
qemu_blockalign(bs, extent->cluster_sectors << BDRV_SECTOR_BITS);
|
2011-07-12 19:56:38 +08:00
|
|
|
if (!vmdk_is_cid_valid(bs)) {
|
2013-08-06 15:44:54 +08:00
|
|
|
ret = VMDK_ERROR;
|
|
|
|
goto exit;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:29 +08:00
|
|
|
/* floor offset to cluster */
|
|
|
|
offset -= offset % (extent->cluster_sectors * 512);
|
2010-04-17 01:28:14 +08:00
|
|
|
ret = bdrv_read(bs->backing_hd, offset >> 9, whole_grain,
|
2011-07-12 19:56:28 +08:00
|
|
|
extent->cluster_sectors);
|
2010-04-17 01:28:14 +08:00
|
|
|
if (ret < 0) {
|
2013-08-06 15:44:54 +08:00
|
|
|
ret = VMDK_ERROR;
|
|
|
|
goto exit;
|
2010-04-17 01:28:14 +08:00
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
|
2011-07-12 19:56:29 +08:00
|
|
|
/* Write grain only into the active image */
|
2011-07-12 19:56:28 +08:00
|
|
|
ret = bdrv_write(extent->file, cluster_offset, whole_grain,
|
|
|
|
extent->cluster_sectors);
|
2010-04-17 01:28:14 +08:00
|
|
|
if (ret < 0) {
|
2013-08-06 15:44:54 +08:00
|
|
|
ret = VMDK_ERROR;
|
|
|
|
goto exit;
|
2007-06-18 23:01:30 +08:00
|
|
|
}
|
|
|
|
}
|
2013-08-06 15:44:54 +08:00
|
|
|
exit:
|
|
|
|
qemu_vfree(whole_grain);
|
|
|
|
return ret;
|
2007-06-18 23:01:30 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data)
|
2007-06-18 23:01:30 +08:00
|
|
|
{
|
2013-05-02 10:25:26 +08:00
|
|
|
uint32_t offset;
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(offset) != sizeof(m_data->offset));
|
|
|
|
offset = cpu_to_le32(m_data->offset);
|
2007-06-18 23:01:30 +08:00
|
|
|
/* update L2 table */
|
2011-07-12 19:56:28 +08:00
|
|
|
if (bdrv_pwrite_sync(
|
|
|
|
extent->file,
|
|
|
|
((int64_t)m_data->l2_offset * 512)
|
|
|
|
+ (m_data->l2_index * sizeof(m_data->offset)),
|
2013-05-02 10:25:26 +08:00
|
|
|
&offset, sizeof(offset)) < 0) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
/* update backup L2 table */
|
2011-07-12 19:56:28 +08:00
|
|
|
if (extent->l1_backup_table_offset != 0) {
|
|
|
|
m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
|
|
|
|
if (bdrv_pwrite_sync(
|
|
|
|
extent->file,
|
|
|
|
((int64_t)m_data->l2_offset * 512)
|
|
|
|
+ (m_data->l2_index * sizeof(m_data->offset)),
|
2013-05-02 10:25:26 +08:00
|
|
|
&offset, sizeof(offset)) < 0) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
2013-05-02 10:25:27 +08:00
|
|
|
if (m_data->l2_cache_entry) {
|
|
|
|
*m_data->l2_cache_entry = offset;
|
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_OK;
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:35 +08:00
|
|
|
static int get_cluster_offset(BlockDriverState *bs,
|
2011-07-12 19:56:28 +08:00
|
|
|
VmdkExtent *extent,
|
|
|
|
VmdkMetaData *m_data,
|
2011-07-12 19:56:35 +08:00
|
|
|
uint64_t offset,
|
|
|
|
int allocate,
|
|
|
|
uint64_t *cluster_offset)
|
2004-08-02 05:59:26 +08:00
|
|
|
{
|
|
|
|
unsigned int l1_index, l2_offset, l2_index;
|
|
|
|
int min_index, i, j;
|
2013-05-02 10:25:26 +08:00
|
|
|
uint32_t min_count, *l2_table;
|
2013-05-02 10:25:23 +08:00
|
|
|
bool zeroed = false;
|
2007-06-18 23:01:30 +08:00
|
|
|
|
2011-07-12 19:56:38 +08:00
|
|
|
if (m_data) {
|
2007-06-18 23:01:30 +08:00
|
|
|
m_data->valid = 0;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2011-07-12 19:56:35 +08:00
|
|
|
if (extent->flat) {
|
2011-07-19 08:38:22 +08:00
|
|
|
*cluster_offset = extent->flat_start_offset;
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_OK;
|
2011-07-12 19:56:35 +08:00
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
|
2011-08-12 23:19:27 +08:00
|
|
|
offset -= (extent->end_sector - extent->sectors) * SECTOR_SIZE;
|
2011-07-12 19:56:28 +08:00
|
|
|
l1_index = (offset >> 9) / extent->l1_entry_sectors;
|
|
|
|
if (l1_index >= extent->l1_size) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
|
|
|
l2_offset = extent->l1_table[l1_index];
|
|
|
|
if (!l2_offset) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_UNALLOC;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2011-07-12 19:56:31 +08:00
|
|
|
for (i = 0; i < L2_CACHE_SIZE; i++) {
|
2011-07-12 19:56:28 +08:00
|
|
|
if (l2_offset == extent->l2_cache_offsets[i]) {
|
2004-08-02 05:59:26 +08:00
|
|
|
/* increment the hit count */
|
2011-07-12 19:56:28 +08:00
|
|
|
if (++extent->l2_cache_counts[i] == 0xffffffff) {
|
2011-07-12 19:56:31 +08:00
|
|
|
for (j = 0; j < L2_CACHE_SIZE; j++) {
|
2011-07-12 19:56:28 +08:00
|
|
|
extent->l2_cache_counts[j] >>= 1;
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
}
|
2011-07-12 19:56:28 +08:00
|
|
|
l2_table = extent->l2_cache + (i * extent->l2_size);
|
2004-08-02 05:59:26 +08:00
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* not found: load a new entry in the least used one */
|
|
|
|
min_index = 0;
|
|
|
|
min_count = 0xffffffff;
|
2011-07-12 19:56:31 +08:00
|
|
|
for (i = 0; i < L2_CACHE_SIZE; i++) {
|
2011-07-12 19:56:28 +08:00
|
|
|
if (extent->l2_cache_counts[i] < min_count) {
|
|
|
|
min_count = extent->l2_cache_counts[i];
|
2004-08-02 05:59:26 +08:00
|
|
|
min_index = i;
|
|
|
|
}
|
|
|
|
}
|
2011-07-12 19:56:28 +08:00
|
|
|
l2_table = extent->l2_cache + (min_index * extent->l2_size);
|
|
|
|
if (bdrv_pread(
|
|
|
|
extent->file,
|
|
|
|
(int64_t)l2_offset * 512,
|
|
|
|
l2_table,
|
|
|
|
extent->l2_size * sizeof(uint32_t)
|
|
|
|
) != extent->l2_size * sizeof(uint32_t)) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
extent->l2_cache_offsets[min_index] = l2_offset;
|
|
|
|
extent->l2_cache_counts[min_index] = 1;
|
2004-08-02 05:59:26 +08:00
|
|
|
found:
|
2011-07-12 19:56:28 +08:00
|
|
|
l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
|
2011-07-12 19:56:35 +08:00
|
|
|
*cluster_offset = le32_to_cpu(l2_table[l2_index]);
|
2007-06-18 23:01:30 +08:00
|
|
|
|
2013-05-02 10:25:27 +08:00
|
|
|
if (m_data) {
|
|
|
|
m_data->valid = 1;
|
|
|
|
m_data->l1_index = l1_index;
|
|
|
|
m_data->l2_index = l2_index;
|
|
|
|
m_data->offset = *cluster_offset;
|
|
|
|
m_data->l2_offset = l2_offset;
|
|
|
|
m_data->l2_cache_entry = &l2_table[l2_index];
|
|
|
|
}
|
2013-05-02 10:25:23 +08:00
|
|
|
if (extent->has_zero_grain && *cluster_offset == VMDK_GTE_ZEROED) {
|
|
|
|
zeroed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*cluster_offset || zeroed) {
|
2011-07-12 19:56:35 +08:00
|
|
|
if (!allocate) {
|
2013-05-02 10:25:23 +08:00
|
|
|
return zeroed ? VMDK_ZEROED : VMDK_UNALLOC;
|
2011-07-12 19:56:35 +08:00
|
|
|
}
|
2010-04-17 03:07:19 +08:00
|
|
|
|
2011-07-12 19:56:38 +08:00
|
|
|
/* Avoid the L2 tables update for the images that have snapshots. */
|
2011-07-12 19:56:35 +08:00
|
|
|
*cluster_offset = bdrv_getlength(extent->file);
|
2011-08-12 23:19:31 +08:00
|
|
|
if (!extent->compressed) {
|
|
|
|
bdrv_truncate(
|
|
|
|
extent->file,
|
|
|
|
*cluster_offset + (extent->cluster_sectors << 9)
|
|
|
|
);
|
|
|
|
}
|
2010-04-17 03:07:19 +08:00
|
|
|
|
2011-07-12 19:56:35 +08:00
|
|
|
*cluster_offset >>= 9;
|
2013-05-02 10:25:26 +08:00
|
|
|
l2_table[l2_index] = cpu_to_le32(*cluster_offset);
|
2007-06-18 23:01:30 +08:00
|
|
|
|
|
|
|
/* First of all we write grain itself, to avoid race condition
|
|
|
|
* that may to corrupt the image.
|
|
|
|
* This problem may occur because of insufficient space on host disk
|
|
|
|
* or inappropriate VM shutdown.
|
|
|
|
*/
|
2011-07-12 19:56:28 +08:00
|
|
|
if (get_whole_cluster(
|
2011-07-12 19:56:38 +08:00
|
|
|
bs, extent, *cluster_offset, offset, allocate) == -1) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
|
|
|
|
if (m_data) {
|
2013-05-02 10:25:26 +08:00
|
|
|
m_data->offset = *cluster_offset;
|
2007-06-18 23:01:30 +08:00
|
|
|
}
|
2005-04-27 05:08:00 +08:00
|
|
|
}
|
2011-07-12 19:56:35 +08:00
|
|
|
*cluster_offset <<= 9;
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_OK;
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
static VmdkExtent *find_extent(BDRVVmdkState *s,
|
|
|
|
int64_t sector_num, VmdkExtent *start_hint)
|
|
|
|
{
|
|
|
|
VmdkExtent *extent = start_hint;
|
|
|
|
|
|
|
|
if (!extent) {
|
|
|
|
extent = &s->extents[0];
|
|
|
|
}
|
|
|
|
while (extent < &s->extents[s->num_extents]) {
|
|
|
|
if (sector_num < extent->end_sector) {
|
|
|
|
return extent;
|
|
|
|
}
|
|
|
|
extent++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-11-14 20:44:21 +08:00
|
|
|
static int coroutine_fn vmdk_co_is_allocated(BlockDriverState *bs,
|
|
|
|
int64_t sector_num, int nb_sectors, int *pnum)
|
2004-08-02 05:59:26 +08:00
|
|
|
{
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-07-12 19:56:28 +08:00
|
|
|
int64_t index_in_cluster, n, ret;
|
|
|
|
uint64_t offset;
|
|
|
|
VmdkExtent *extent;
|
|
|
|
|
|
|
|
extent = find_extent(s, sector_num, NULL);
|
|
|
|
if (!extent) {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-11-14 20:44:21 +08:00
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2011-07-12 19:56:35 +08:00
|
|
|
ret = get_cluster_offset(bs, extent, NULL,
|
|
|
|
sector_num * 512, 0, &offset);
|
2011-11-14 20:44:21 +08:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
2013-05-02 10:25:23 +08:00
|
|
|
|
|
|
|
ret = (ret == VMDK_OK || ret == VMDK_ZEROED);
|
2011-07-12 19:56:35 +08:00
|
|
|
|
|
|
|
index_in_cluster = sector_num % extent->cluster_sectors;
|
|
|
|
n = extent->cluster_sectors - index_in_cluster;
|
2011-07-12 19:56:38 +08:00
|
|
|
if (n > nb_sectors) {
|
2004-08-02 05:59:26 +08:00
|
|
|
n = nb_sectors;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
*pnum = n;
|
2011-07-12 19:56:28 +08:00
|
|
|
return ret;
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:29 +08:00
|
|
|
static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
|
|
|
|
int64_t offset_in_cluster, const uint8_t *buf,
|
|
|
|
int nb_sectors, int64_t sector_num)
|
|
|
|
{
|
|
|
|
int ret;
|
2011-08-12 23:19:31 +08:00
|
|
|
VmdkGrainMarker *data = NULL;
|
|
|
|
uLongf buf_len;
|
2011-08-12 23:19:29 +08:00
|
|
|
const uint8_t *write_buf = buf;
|
|
|
|
int write_len = nb_sectors * 512;
|
|
|
|
|
2011-08-12 23:19:31 +08:00
|
|
|
if (extent->compressed) {
|
|
|
|
if (!extent->has_marker) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
buf_len = (extent->cluster_sectors << 9) * 2;
|
|
|
|
data = g_malloc(buf_len + sizeof(VmdkGrainMarker));
|
|
|
|
if (compress(data->data, &buf_len, buf, nb_sectors << 9) != Z_OK ||
|
|
|
|
buf_len == 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
data->lba = sector_num;
|
|
|
|
data->size = buf_len;
|
|
|
|
write_buf = (uint8_t *)data;
|
|
|
|
write_len = buf_len + sizeof(VmdkGrainMarker);
|
|
|
|
}
|
2011-08-12 23:19:29 +08:00
|
|
|
ret = bdrv_pwrite(extent->file,
|
|
|
|
cluster_offset + offset_in_cluster,
|
|
|
|
write_buf,
|
|
|
|
write_len);
|
|
|
|
if (ret != write_len) {
|
|
|
|
ret = ret < 0 ? ret : -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2011-08-12 23:19:31 +08:00
|
|
|
g_free(data);
|
2011-08-12 23:19:29 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
|
|
|
|
int64_t offset_in_cluster, uint8_t *buf,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
|
|
|
int ret;
|
2011-08-12 23:19:31 +08:00
|
|
|
int cluster_bytes, buf_bytes;
|
|
|
|
uint8_t *cluster_buf, *compressed_data;
|
|
|
|
uint8_t *uncomp_buf;
|
|
|
|
uint32_t data_len;
|
|
|
|
VmdkGrainMarker *marker;
|
|
|
|
uLongf buf_len;
|
|
|
|
|
2011-08-12 23:19:29 +08:00
|
|
|
|
2011-08-12 23:19:31 +08:00
|
|
|
if (!extent->compressed) {
|
|
|
|
ret = bdrv_pread(extent->file,
|
|
|
|
cluster_offset + offset_in_cluster,
|
|
|
|
buf, nb_sectors * 512);
|
|
|
|
if (ret == nb_sectors * 512) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cluster_bytes = extent->cluster_sectors * 512;
|
|
|
|
/* Read two clusters in case GrainMarker + compressed data > one cluster */
|
|
|
|
buf_bytes = cluster_bytes * 2;
|
|
|
|
cluster_buf = g_malloc(buf_bytes);
|
|
|
|
uncomp_buf = g_malloc(cluster_bytes);
|
2011-08-12 23:19:29 +08:00
|
|
|
ret = bdrv_pread(extent->file,
|
2011-08-12 23:19:31 +08:00
|
|
|
cluster_offset,
|
|
|
|
cluster_buf, buf_bytes);
|
|
|
|
if (ret < 0) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
compressed_data = cluster_buf;
|
|
|
|
buf_len = cluster_bytes;
|
|
|
|
data_len = cluster_bytes;
|
|
|
|
if (extent->has_marker) {
|
|
|
|
marker = (VmdkGrainMarker *)cluster_buf;
|
|
|
|
compressed_data = marker->data;
|
|
|
|
data_len = le32_to_cpu(marker->size);
|
|
|
|
}
|
|
|
|
if (!data_len || data_len > buf_bytes) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = uncompress(uncomp_buf, &buf_len, compressed_data, data_len);
|
|
|
|
if (ret != Z_OK) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
}
|
|
|
|
if (offset_in_cluster < 0 ||
|
|
|
|
offset_in_cluster + nb_sectors * 512 > buf_len) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2011-08-12 23:19:29 +08:00
|
|
|
}
|
2011-08-12 23:19:31 +08:00
|
|
|
memcpy(buf, uncomp_buf + offset_in_cluster, nb_sectors * 512);
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
g_free(uncomp_buf);
|
|
|
|
g_free(cluster_buf);
|
|
|
|
return ret;
|
2011-08-12 23:19:29 +08:00
|
|
|
}
|
|
|
|
|
2007-09-17 05:08:06 +08:00
|
|
|
static int vmdk_read(BlockDriverState *bs, int64_t sector_num,
|
2004-08-02 05:59:26 +08:00
|
|
|
uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-07-12 19:56:28 +08:00
|
|
|
int ret;
|
|
|
|
uint64_t n, index_in_cluster;
|
2012-11-10 16:22:18 +08:00
|
|
|
uint64_t extent_begin_sector, extent_relative_sector_num;
|
2011-07-12 19:56:28 +08:00
|
|
|
VmdkExtent *extent = NULL;
|
2004-08-02 05:59:26 +08:00
|
|
|
uint64_t cluster_offset;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2004-08-02 05:59:26 +08:00
|
|
|
while (nb_sectors > 0) {
|
2011-07-12 19:56:28 +08:00
|
|
|
extent = find_extent(s, sector_num, extent);
|
|
|
|
if (!extent) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
2011-07-12 19:56:35 +08:00
|
|
|
ret = get_cluster_offset(
|
|
|
|
bs, extent, NULL,
|
|
|
|
sector_num << 9, 0, &cluster_offset);
|
2012-11-10 16:22:18 +08:00
|
|
|
extent_begin_sector = extent->end_sector - extent->sectors;
|
|
|
|
extent_relative_sector_num = sector_num - extent_begin_sector;
|
|
|
|
index_in_cluster = extent_relative_sector_num % extent->cluster_sectors;
|
2011-07-12 19:56:28 +08:00
|
|
|
n = extent->cluster_sectors - index_in_cluster;
|
2011-07-12 19:56:38 +08:00
|
|
|
if (n > nb_sectors) {
|
2004-08-02 05:59:26 +08:00
|
|
|
n = nb_sectors;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2013-05-02 10:25:23 +08:00
|
|
|
if (ret != VMDK_OK) {
|
2011-07-12 19:56:35 +08:00
|
|
|
/* if not allocated, try to read from parent image, if exist */
|
2013-05-02 10:25:23 +08:00
|
|
|
if (bs->backing_hd && ret != VMDK_ZEROED) {
|
2011-07-12 19:56:38 +08:00
|
|
|
if (!vmdk_is_cid_valid(bs)) {
|
2011-07-19 08:38:22 +08:00
|
|
|
return -EINVAL;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2009-07-17 14:20:41 +08:00
|
|
|
ret = bdrv_read(bs->backing_hd, sector_num, buf, n);
|
2011-07-12 19:56:38 +08:00
|
|
|
if (ret < 0) {
|
2011-07-19 08:38:22 +08:00
|
|
|
return ret;
|
2011-07-12 19:56:38 +08:00
|
|
|
}
|
2007-01-25 05:05:24 +08:00
|
|
|
} else {
|
|
|
|
memset(buf, 0, 512 * n);
|
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
} else {
|
2011-08-12 23:19:29 +08:00
|
|
|
ret = vmdk_read_extent(extent,
|
|
|
|
cluster_offset, index_in_cluster * 512,
|
|
|
|
buf, n);
|
|
|
|
if (ret) {
|
2011-07-19 08:38:22 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
nb_sectors -= n;
|
|
|
|
sector_num += n;
|
|
|
|
buf += n * 512;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-20 19:16:22 +08:00
|
|
|
static coroutine_fn int vmdk_co_read(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
|
|
|
ret = vmdk_read(bs, sector_num, buf, nb_sectors);
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-05-02 10:25:27 +08:00
|
|
|
/**
|
|
|
|
* vmdk_write:
|
|
|
|
* @zeroed: buf is ignored (data is zero), use zeroed_grain GTE feature
|
2013-08-01 18:12:17 +08:00
|
|
|
* if possible, otherwise return -ENOTSUP.
|
|
|
|
* @zero_dry_run: used for zeroed == true only, don't update L2 table, just try
|
|
|
|
* with each cluster. By dry run we can find if the zero write
|
|
|
|
* is possible without modifying image data.
|
2013-05-02 10:25:27 +08:00
|
|
|
*
|
|
|
|
* Returns: error code with 0 for success.
|
|
|
|
*/
|
2007-09-17 05:08:06 +08:00
|
|
|
static int vmdk_write(BlockDriverState *bs, int64_t sector_num,
|
2013-05-02 10:25:27 +08:00
|
|
|
const uint8_t *buf, int nb_sectors,
|
|
|
|
bool zeroed, bool zero_dry_run)
|
2004-08-02 05:59:26 +08:00
|
|
|
{
|
2005-04-27 05:08:00 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2011-07-12 19:56:28 +08:00
|
|
|
VmdkExtent *extent = NULL;
|
2011-07-12 19:56:35 +08:00
|
|
|
int n, ret;
|
2011-07-12 19:56:28 +08:00
|
|
|
int64_t index_in_cluster;
|
2012-11-10 16:22:18 +08:00
|
|
|
uint64_t extent_begin_sector, extent_relative_sector_num;
|
2005-04-27 05:08:00 +08:00
|
|
|
uint64_t cluster_offset;
|
2011-07-12 19:56:28 +08:00
|
|
|
VmdkMetaData m_data;
|
2005-04-27 05:08:00 +08:00
|
|
|
|
2007-06-18 23:01:30 +08:00
|
|
|
if (sector_num > bs->total_sectors) {
|
|
|
|
fprintf(stderr,
|
2007-09-21 14:09:39 +08:00
|
|
|
"(VMDK) Wrong offset: sector_num=0x%" PRIx64
|
|
|
|
" total_sectors=0x%" PRIx64 "\n",
|
2007-06-18 23:01:30 +08:00
|
|
|
sector_num, bs->total_sectors);
|
2011-07-19 08:38:22 +08:00
|
|
|
return -EIO;
|
2007-06-18 23:01:30 +08:00
|
|
|
}
|
|
|
|
|
2005-04-27 05:08:00 +08:00
|
|
|
while (nb_sectors > 0) {
|
2011-07-12 19:56:28 +08:00
|
|
|
extent = find_extent(s, sector_num, extent);
|
|
|
|
if (!extent) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
2011-07-12 19:56:35 +08:00
|
|
|
ret = get_cluster_offset(
|
2011-07-12 19:56:28 +08:00
|
|
|
bs,
|
|
|
|
extent,
|
|
|
|
&m_data,
|
2011-08-12 23:19:31 +08:00
|
|
|
sector_num << 9, !extent->compressed,
|
2011-07-12 19:56:35 +08:00
|
|
|
&cluster_offset);
|
2011-08-12 23:19:31 +08:00
|
|
|
if (extent->compressed) {
|
2013-05-02 10:25:22 +08:00
|
|
|
if (ret == VMDK_OK) {
|
2011-08-12 23:19:31 +08:00
|
|
|
/* Refuse write to allocated cluster for streamOptimized */
|
|
|
|
fprintf(stderr,
|
|
|
|
"VMDK: can't write to allocated cluster"
|
|
|
|
" for streamOptimized\n");
|
|
|
|
return -EIO;
|
|
|
|
} else {
|
|
|
|
/* allocate */
|
|
|
|
ret = get_cluster_offset(
|
|
|
|
bs,
|
|
|
|
extent,
|
|
|
|
&m_data,
|
|
|
|
sector_num << 9, 1,
|
|
|
|
&cluster_offset);
|
|
|
|
}
|
|
|
|
}
|
2013-05-02 10:25:27 +08:00
|
|
|
if (ret == VMDK_ERROR) {
|
2011-07-12 19:56:35 +08:00
|
|
|
return -EINVAL;
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2012-11-10 16:22:18 +08:00
|
|
|
extent_begin_sector = extent->end_sector - extent->sectors;
|
|
|
|
extent_relative_sector_num = sector_num - extent_begin_sector;
|
|
|
|
index_in_cluster = extent_relative_sector_num % extent->cluster_sectors;
|
2011-07-12 19:56:28 +08:00
|
|
|
n = extent->cluster_sectors - index_in_cluster;
|
|
|
|
if (n > nb_sectors) {
|
|
|
|
n = nb_sectors;
|
|
|
|
}
|
2013-05-02 10:25:27 +08:00
|
|
|
if (zeroed) {
|
|
|
|
/* Do zeroed write, buf is ignored */
|
|
|
|
if (extent->has_zero_grain &&
|
|
|
|
index_in_cluster == 0 &&
|
|
|
|
n >= extent->cluster_sectors) {
|
|
|
|
n = extent->cluster_sectors;
|
|
|
|
if (!zero_dry_run) {
|
|
|
|
m_data.offset = VMDK_GTE_ZEROED;
|
|
|
|
/* update L2 tables */
|
|
|
|
if (vmdk_L2update(extent, &m_data) != VMDK_OK) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret = vmdk_write_extent(extent,
|
|
|
|
cluster_offset, index_in_cluster * 512,
|
|
|
|
buf, n, sector_num);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (m_data.valid) {
|
|
|
|
/* update L2 tables */
|
|
|
|
if (vmdk_L2update(extent, &m_data) != VMDK_OK) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
2011-07-12 19:56:28 +08:00
|
|
|
}
|
2007-06-18 23:01:30 +08:00
|
|
|
}
|
2005-04-27 05:08:00 +08:00
|
|
|
nb_sectors -= n;
|
|
|
|
sector_num += n;
|
|
|
|
buf += n * 512;
|
2007-01-25 05:05:24 +08:00
|
|
|
|
2011-07-12 19:56:38 +08:00
|
|
|
/* update CID on the first write every time the virtual disk is
|
|
|
|
* opened */
|
2011-07-12 19:56:34 +08:00
|
|
|
if (!s->cid_updated) {
|
2011-10-26 18:25:25 +08:00
|
|
|
ret = vmdk_write_cid(bs, time(NULL));
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
2011-07-12 19:56:34 +08:00
|
|
|
s->cid_updated = true;
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
2005-04-27 05:08:00 +08:00
|
|
|
}
|
|
|
|
return 0;
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-10-20 19:16:23 +08:00
|
|
|
static coroutine_fn int vmdk_co_write(BlockDriverState *bs, int64_t sector_num,
|
|
|
|
const uint8_t *buf, int nb_sectors)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2013-05-02 10:25:27 +08:00
|
|
|
ret = vmdk_write(bs, sector_num, buf, nb_sectors, false, false);
|
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int coroutine_fn vmdk_co_write_zeroes(BlockDriverState *bs,
|
|
|
|
int64_t sector_num,
|
|
|
|
int nb_sectors)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
qemu_co_mutex_lock(&s->lock);
|
2013-08-01 18:12:17 +08:00
|
|
|
/* write zeroes could fail if sectors not aligned to cluster, test it with
|
|
|
|
* dry_run == true before really updating image */
|
2013-05-02 10:25:27 +08:00
|
|
|
ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, true);
|
|
|
|
if (!ret) {
|
|
|
|
ret = vmdk_write(bs, sector_num, NULL, nb_sectors, true, false);
|
|
|
|
}
|
2011-10-20 19:16:23 +08:00
|
|
|
qemu_co_mutex_unlock(&s->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-08-12 23:19:32 +08:00
|
|
|
static int vmdk_create_extent(const char *filename, int64_t filesize,
|
2013-05-02 10:25:24 +08:00
|
|
|
bool flat, bool compress, bool zeroed_grain)
|
2005-07-02 22:02:54 +08:00
|
|
|
{
|
2011-07-19 08:45:23 +08:00
|
|
|
int ret, i;
|
|
|
|
int fd = 0;
|
2005-07-02 22:02:54 +08:00
|
|
|
VMDK4Header header;
|
|
|
|
uint32_t tmp, magic, grains, gd_size, gt_size, gt_count;
|
2009-05-18 22:42:10 +08:00
|
|
|
|
2012-08-15 04:43:45 +08:00
|
|
|
fd = qemu_open(filename,
|
|
|
|
O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
|
|
|
|
0644);
|
2011-07-19 08:45:23 +08:00
|
|
|
if (fd < 0) {
|
|
|
|
return -errno;
|
2009-05-18 22:42:10 +08:00
|
|
|
}
|
2011-07-19 08:45:23 +08:00
|
|
|
if (flat) {
|
|
|
|
ret = ftruncate(fd, filesize);
|
|
|
|
if (ret < 0) {
|
|
|
|
ret = -errno;
|
|
|
|
}
|
|
|
|
goto exit;
|
2007-01-25 05:05:24 +08:00
|
|
|
}
|
2005-07-02 22:02:54 +08:00
|
|
|
magic = cpu_to_be32(VMDK4_MAGIC);
|
|
|
|
memset(&header, 0, sizeof(header));
|
2013-05-02 10:25:24 +08:00
|
|
|
header.version = zeroed_grain ? 2 : 1;
|
2013-05-02 10:25:25 +08:00
|
|
|
header.flags = VMDK4_FLAG_RGD | VMDK4_FLAG_NL_DETECT
|
2013-05-02 10:25:24 +08:00
|
|
|
| (compress ? VMDK4_FLAG_COMPRESS | VMDK4_FLAG_MARKER : 0)
|
|
|
|
| (zeroed_grain ? VMDK4_FLAG_ZERO_GRAIN : 0);
|
2011-08-12 23:19:32 +08:00
|
|
|
header.compressAlgorithm = compress ? VMDK4_COMPRESSION_DEFLATE : 0;
|
2011-07-19 08:45:23 +08:00
|
|
|
header.capacity = filesize / 512;
|
2011-05-25 06:46:55 +08:00
|
|
|
header.granularity = 128;
|
2013-08-06 15:44:55 +08:00
|
|
|
header.num_gtes_per_gt = 512;
|
2005-07-02 22:02:54 +08:00
|
|
|
|
2011-07-19 08:45:23 +08:00
|
|
|
grains = (filesize / 512 + header.granularity - 1) / header.granularity;
|
2013-08-06 15:44:55 +08:00
|
|
|
gt_size = ((header.num_gtes_per_gt * sizeof(uint32_t)) + 511) >> 9;
|
2011-07-19 08:45:23 +08:00
|
|
|
gt_count =
|
2013-08-06 15:44:55 +08:00
|
|
|
(grains + header.num_gtes_per_gt - 1) / header.num_gtes_per_gt;
|
2005-07-02 22:02:54 +08:00
|
|
|
gd_size = (gt_count * sizeof(uint32_t) + 511) >> 9;
|
|
|
|
|
|
|
|
header.desc_offset = 1;
|
|
|
|
header.desc_size = 20;
|
|
|
|
header.rgd_offset = header.desc_offset + header.desc_size;
|
|
|
|
header.gd_offset = header.rgd_offset + gd_size + (gt_size * gt_count);
|
|
|
|
header.grain_offset =
|
|
|
|
((header.gd_offset + gd_size + (gt_size * gt_count) +
|
|
|
|
header.granularity - 1) / header.granularity) *
|
|
|
|
header.granularity;
|
2011-05-25 06:46:55 +08:00
|
|
|
/* swap endianness for all header fields */
|
|
|
|
header.version = cpu_to_le32(header.version);
|
|
|
|
header.flags = cpu_to_le32(header.flags);
|
|
|
|
header.capacity = cpu_to_le64(header.capacity);
|
|
|
|
header.granularity = cpu_to_le64(header.granularity);
|
2013-08-06 15:44:55 +08:00
|
|
|
header.num_gtes_per_gt = cpu_to_le32(header.num_gtes_per_gt);
|
2005-07-02 22:02:54 +08:00
|
|
|
header.desc_offset = cpu_to_le64(header.desc_offset);
|
|
|
|
header.desc_size = cpu_to_le64(header.desc_size);
|
|
|
|
header.rgd_offset = cpu_to_le64(header.rgd_offset);
|
|
|
|
header.gd_offset = cpu_to_le64(header.gd_offset);
|
|
|
|
header.grain_offset = cpu_to_le64(header.grain_offset);
|
2011-08-12 23:19:32 +08:00
|
|
|
header.compressAlgorithm = cpu_to_le16(header.compressAlgorithm);
|
2005-07-02 22:02:54 +08:00
|
|
|
|
|
|
|
header.check_bytes[0] = 0xa;
|
|
|
|
header.check_bytes[1] = 0x20;
|
|
|
|
header.check_bytes[2] = 0xd;
|
|
|
|
header.check_bytes[3] = 0xa;
|
2007-09-17 16:09:54 +08:00
|
|
|
|
|
|
|
/* write all the data */
|
2010-01-20 07:56:13 +08:00
|
|
|
ret = qemu_write_full(fd, &magic, sizeof(magic));
|
|
|
|
if (ret != sizeof(magic)) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
ret = qemu_write_full(fd, &header, sizeof(header));
|
|
|
|
if (ret != sizeof(header)) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
2005-07-02 22:02:54 +08:00
|
|
|
|
2011-05-25 06:46:55 +08:00
|
|
|
ret = ftruncate(fd, le64_to_cpu(header.grain_offset) << 9);
|
2010-01-20 07:56:13 +08:00
|
|
|
if (ret < 0) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
2005-07-02 22:02:54 +08:00
|
|
|
|
|
|
|
/* write grain directory */
|
|
|
|
lseek(fd, le64_to_cpu(header.rgd_offset) << 9, SEEK_SET);
|
2011-05-25 06:46:55 +08:00
|
|
|
for (i = 0, tmp = le64_to_cpu(header.rgd_offset) + gd_size;
|
2010-01-20 07:56:13 +08:00
|
|
|
i < gt_count; i++, tmp += gt_size) {
|
|
|
|
ret = qemu_write_full(fd, &tmp, sizeof(tmp));
|
|
|
|
if (ret != sizeof(tmp)) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
2007-09-17 16:09:54 +08:00
|
|
|
|
2005-07-02 22:02:54 +08:00
|
|
|
/* write backup grain directory */
|
|
|
|
lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);
|
2011-05-25 06:46:55 +08:00
|
|
|
for (i = 0, tmp = le64_to_cpu(header.gd_offset) + gd_size;
|
2010-01-20 07:56:13 +08:00
|
|
|
i < gt_count; i++, tmp += gt_size) {
|
|
|
|
ret = qemu_write_full(fd, &tmp, sizeof(tmp));
|
|
|
|
if (ret != sizeof(tmp)) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
2005-07-02 22:02:54 +08:00
|
|
|
|
2011-07-19 08:45:23 +08:00
|
|
|
ret = 0;
|
|
|
|
exit:
|
2012-08-15 04:43:46 +08:00
|
|
|
qemu_close(fd);
|
2011-07-19 08:45:23 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int filename_decompose(const char *filename, char *path, char *prefix,
|
|
|
|
char *postfix, size_t buf_len)
|
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
|
|
|
|
if (filename == NULL || !strlen(filename)) {
|
|
|
|
fprintf(stderr, "Vmdk: no filename provided.\n");
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
p = strrchr(filename, '/');
|
|
|
|
if (p == NULL) {
|
|
|
|
p = strrchr(filename, '\\');
|
|
|
|
}
|
|
|
|
if (p == NULL) {
|
|
|
|
p = strrchr(filename, ':');
|
|
|
|
}
|
|
|
|
if (p != NULL) {
|
|
|
|
p++;
|
|
|
|
if (p - filename >= buf_len) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
pstrcpy(path, p - filename + 1, filename);
|
|
|
|
} else {
|
|
|
|
p = filename;
|
|
|
|
path[0] = '\0';
|
|
|
|
}
|
|
|
|
q = strrchr(p, '.');
|
|
|
|
if (q == NULL) {
|
|
|
|
pstrcpy(prefix, buf_len, p);
|
|
|
|
postfix[0] = '\0';
|
|
|
|
} else {
|
|
|
|
if (q - p >= buf_len) {
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_ERROR;
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
pstrcpy(prefix, q - p + 1, p);
|
|
|
|
pstrcpy(postfix, buf_len, q);
|
|
|
|
}
|
2013-05-02 10:25:22 +08:00
|
|
|
return VMDK_OK;
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int vmdk_create(const char *filename, QEMUOptionParameter *options)
|
|
|
|
{
|
|
|
|
int fd, idx = 0;
|
|
|
|
char desc[BUF_SIZE];
|
|
|
|
int64_t total_size = 0, filesize;
|
2013-01-30 07:26:52 +08:00
|
|
|
const char *adapter_type = NULL;
|
2011-07-19 08:45:23 +08:00
|
|
|
const char *backing_file = NULL;
|
|
|
|
const char *fmt = NULL;
|
|
|
|
int flags = 0;
|
|
|
|
int ret = 0;
|
2011-08-12 23:19:32 +08:00
|
|
|
bool flat, split, compress;
|
2011-07-19 08:45:23 +08:00
|
|
|
char ext_desc_lines[BUF_SIZE] = "";
|
|
|
|
char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];
|
|
|
|
const int64_t split_size = 0x80000000; /* VMDK has constant split size */
|
|
|
|
const char *desc_extent_line;
|
|
|
|
char parent_desc_line[BUF_SIZE] = "";
|
|
|
|
uint32_t parent_cid = 0xffffffff;
|
2013-01-30 07:26:52 +08:00
|
|
|
uint32_t number_heads = 16;
|
2013-05-02 10:25:24 +08:00
|
|
|
bool zeroed_grain = false;
|
2011-07-19 08:45:23 +08:00
|
|
|
const char desc_template[] =
|
|
|
|
"# Disk DescriptorFile\n"
|
|
|
|
"version=1\n"
|
|
|
|
"CID=%x\n"
|
|
|
|
"parentCID=%x\n"
|
|
|
|
"createType=\"%s\"\n"
|
|
|
|
"%s"
|
|
|
|
"\n"
|
|
|
|
"# Extent description\n"
|
|
|
|
"%s"
|
|
|
|
"\n"
|
|
|
|
"# The Disk Data Base\n"
|
|
|
|
"#DDB\n"
|
|
|
|
"\n"
|
|
|
|
"ddb.virtualHWVersion = \"%d\"\n"
|
|
|
|
"ddb.geometry.cylinders = \"%" PRId64 "\"\n"
|
2013-01-30 07:26:52 +08:00
|
|
|
"ddb.geometry.heads = \"%d\"\n"
|
2011-07-19 08:45:23 +08:00
|
|
|
"ddb.geometry.sectors = \"63\"\n"
|
2013-01-30 07:26:52 +08:00
|
|
|
"ddb.adapterType = \"%s\"\n";
|
2011-07-19 08:45:23 +08:00
|
|
|
|
|
|
|
if (filename_decompose(filename, path, prefix, postfix, PATH_MAX)) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/* Read out options */
|
|
|
|
while (options && options->name) {
|
|
|
|
if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
|
|
|
|
total_size = options->value.n;
|
2013-01-30 07:26:52 +08:00
|
|
|
} else if (!strcmp(options->name, BLOCK_OPT_ADAPTER_TYPE)) {
|
|
|
|
adapter_type = options->value.s;
|
2011-07-19 08:45:23 +08:00
|
|
|
} else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {
|
|
|
|
backing_file = options->value.s;
|
|
|
|
} else if (!strcmp(options->name, BLOCK_OPT_COMPAT6)) {
|
|
|
|
flags |= options->value.n ? BLOCK_FLAG_COMPAT6 : 0;
|
|
|
|
} else if (!strcmp(options->name, BLOCK_OPT_SUBFMT)) {
|
|
|
|
fmt = options->value.s;
|
2013-05-02 10:25:24 +08:00
|
|
|
} else if (!strcmp(options->name, BLOCK_OPT_ZEROED_GRAIN)) {
|
|
|
|
zeroed_grain |= options->value.n;
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
options++;
|
|
|
|
}
|
2013-01-30 07:26:52 +08:00
|
|
|
if (!adapter_type) {
|
|
|
|
adapter_type = "ide";
|
|
|
|
} else if (strcmp(adapter_type, "ide") &&
|
|
|
|
strcmp(adapter_type, "buslogic") &&
|
|
|
|
strcmp(adapter_type, "lsilogic") &&
|
|
|
|
strcmp(adapter_type, "legacyESX")) {
|
|
|
|
fprintf(stderr, "VMDK: Unknown adapter type: '%s'.\n", adapter_type);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (strcmp(adapter_type, "ide") != 0) {
|
|
|
|
/* that's the number of heads with which vmware operates when
|
|
|
|
creating, exporting, etc. vmdk files with a non-ide adapter type */
|
|
|
|
number_heads = 255;
|
|
|
|
}
|
2011-07-19 08:45:23 +08:00
|
|
|
if (!fmt) {
|
|
|
|
/* Default format to monolithicSparse */
|
|
|
|
fmt = "monolithicSparse";
|
|
|
|
} else if (strcmp(fmt, "monolithicFlat") &&
|
|
|
|
strcmp(fmt, "monolithicSparse") &&
|
|
|
|
strcmp(fmt, "twoGbMaxExtentSparse") &&
|
2011-08-12 23:19:32 +08:00
|
|
|
strcmp(fmt, "twoGbMaxExtentFlat") &&
|
|
|
|
strcmp(fmt, "streamOptimized")) {
|
2011-07-19 08:45:23 +08:00
|
|
|
fprintf(stderr, "VMDK: Unknown subformat: %s\n", fmt);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&
|
|
|
|
strcmp(fmt, "twoGbMaxExtentSparse"));
|
|
|
|
flat = !(strcmp(fmt, "monolithicFlat") &&
|
|
|
|
strcmp(fmt, "twoGbMaxExtentFlat"));
|
2011-08-12 23:19:32 +08:00
|
|
|
compress = !strcmp(fmt, "streamOptimized");
|
2011-07-19 08:45:23 +08:00
|
|
|
if (flat) {
|
|
|
|
desc_extent_line = "RW %lld FLAT \"%s\" 0\n";
|
|
|
|
} else {
|
|
|
|
desc_extent_line = "RW %lld SPARSE \"%s\"\n";
|
|
|
|
}
|
|
|
|
if (flat && backing_file) {
|
|
|
|
/* not supporting backing file for flat image */
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
if (backing_file) {
|
|
|
|
BlockDriverState *bs = bdrv_new("");
|
2013-03-15 17:35:02 +08:00
|
|
|
ret = bdrv_open(bs, backing_file, NULL, 0, NULL);
|
2011-07-19 08:45:23 +08:00
|
|
|
if (ret != 0) {
|
|
|
|
bdrv_delete(bs);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (strcmp(bs->drv->format_name, "vmdk")) {
|
|
|
|
bdrv_delete(bs);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
parent_cid = vmdk_read_cid(bs, 0);
|
|
|
|
bdrv_delete(bs);
|
|
|
|
snprintf(parent_desc_line, sizeof(parent_desc_line),
|
2013-06-26 17:24:32 +08:00
|
|
|
"parentFileNameHint=\"%s\"", backing_file);
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Create extents */
|
|
|
|
filesize = total_size;
|
|
|
|
while (filesize > 0) {
|
|
|
|
char desc_line[BUF_SIZE];
|
|
|
|
char ext_filename[PATH_MAX];
|
|
|
|
char desc_filename[PATH_MAX];
|
|
|
|
int64_t size = filesize;
|
|
|
|
|
|
|
|
if (split && size > split_size) {
|
|
|
|
size = split_size;
|
|
|
|
}
|
|
|
|
if (split) {
|
|
|
|
snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",
|
|
|
|
prefix, flat ? 'f' : 's', ++idx, postfix);
|
|
|
|
} else if (flat) {
|
|
|
|
snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",
|
|
|
|
prefix, postfix);
|
|
|
|
} else {
|
|
|
|
snprintf(desc_filename, sizeof(desc_filename), "%s%s",
|
|
|
|
prefix, postfix);
|
|
|
|
}
|
|
|
|
snprintf(ext_filename, sizeof(ext_filename), "%s%s",
|
|
|
|
path, desc_filename);
|
|
|
|
|
2013-05-02 10:25:24 +08:00
|
|
|
if (vmdk_create_extent(ext_filename, size,
|
|
|
|
flat, compress, zeroed_grain)) {
|
2011-07-19 08:45:23 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
filesize -= size;
|
|
|
|
|
|
|
|
/* Format description line */
|
|
|
|
snprintf(desc_line, sizeof(desc_line),
|
|
|
|
desc_extent_line, size / 512, desc_filename);
|
|
|
|
pstrcat(ext_desc_lines, sizeof(ext_desc_lines), desc_line);
|
|
|
|
}
|
|
|
|
/* generate descriptor file */
|
|
|
|
snprintf(desc, sizeof(desc), desc_template,
|
|
|
|
(unsigned int)time(NULL),
|
|
|
|
parent_cid,
|
|
|
|
fmt,
|
|
|
|
parent_desc_line,
|
|
|
|
ext_desc_lines,
|
|
|
|
(flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),
|
2013-01-30 07:26:52 +08:00
|
|
|
total_size / (int64_t)(63 * number_heads * 512), number_heads,
|
|
|
|
adapter_type);
|
2011-07-19 08:45:23 +08:00
|
|
|
if (split || flat) {
|
2012-08-15 04:43:45 +08:00
|
|
|
fd = qemu_open(filename,
|
|
|
|
O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE,
|
|
|
|
0644);
|
2011-07-19 08:45:23 +08:00
|
|
|
} else {
|
2012-08-15 04:43:45 +08:00
|
|
|
fd = qemu_open(filename,
|
|
|
|
O_WRONLY | O_BINARY | O_LARGEFILE,
|
|
|
|
0644);
|
2011-07-19 08:45:23 +08:00
|
|
|
}
|
|
|
|
if (fd < 0) {
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
/* the descriptor offset = 0x200 */
|
|
|
|
if (!split && !flat && 0x200 != lseek(fd, 0x200, SEEK_SET)) {
|
|
|
|
ret = -errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
2010-01-20 07:56:13 +08:00
|
|
|
ret = qemu_write_full(fd, desc, strlen(desc));
|
|
|
|
if (ret != strlen(desc)) {
|
2010-03-04 17:00:34 +08:00
|
|
|
ret = -errno;
|
2010-01-20 07:56:13 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
exit:
|
2012-08-15 04:43:46 +08:00
|
|
|
qemu_close(fd);
|
2010-01-20 07:56:13 +08:00
|
|
|
return ret;
|
2005-07-02 22:02:54 +08:00
|
|
|
}
|
|
|
|
|
2004-09-19 03:32:11 +08:00
|
|
|
static void vmdk_close(BlockDriverState *bs)
|
2004-08-02 05:59:26 +08:00
|
|
|
{
|
2011-11-22 23:50:27 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
|
2011-07-12 19:56:28 +08:00
|
|
|
vmdk_free_extents(bs);
|
2011-11-22 23:50:27 +08:00
|
|
|
|
|
|
|
migrate_del_blocker(s->migration_blocker);
|
|
|
|
error_free(s->migration_blocker);
|
2004-08-02 05:59:26 +08:00
|
|
|
}
|
|
|
|
|
2011-10-20 19:16:24 +08:00
|
|
|
static coroutine_fn int vmdk_co_flush(BlockDriverState *bs)
|
2006-06-04 19:39:07 +08:00
|
|
|
{
|
2011-07-12 19:56:33 +08:00
|
|
|
BDRVVmdkState *s = bs->opaque;
|
2012-03-13 01:26:01 +08:00
|
|
|
int i, err;
|
|
|
|
int ret = 0;
|
2011-07-12 19:56:33 +08:00
|
|
|
|
|
|
|
for (i = 0; i < s->num_extents; i++) {
|
2011-10-20 19:16:24 +08:00
|
|
|
err = bdrv_co_flush(s->extents[i].file);
|
2011-07-12 19:56:33 +08:00
|
|
|
if (err < 0) {
|
|
|
|
ret = err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
2006-06-04 19:39:07 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 19:56:39 +08:00
|
|
|
static int64_t vmdk_get_allocated_file_size(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int64_t ret = 0;
|
|
|
|
int64_t r;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
|
|
|
|
ret = bdrv_get_allocated_file_size(bs->file);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
for (i = 0; i < s->num_extents; i++) {
|
|
|
|
if (s->extents[i].file == bs->file) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
r = bdrv_get_allocated_file_size(s->extents[i].file);
|
|
|
|
if (r < 0) {
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
ret += r;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2009-05-18 22:42:10 +08:00
|
|
|
|
2013-07-01 11:33:17 +08:00
|
|
|
static int vmdk_has_zero_init(BlockDriverState *bs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
BDRVVmdkState *s = bs->opaque;
|
|
|
|
|
|
|
|
/* If has a flat extent and its underlying storage doesn't have zero init,
|
|
|
|
* return 0. */
|
|
|
|
for (i = 0; i < s->num_extents; i++) {
|
|
|
|
if (s->extents[i].flat) {
|
|
|
|
if (!bdrv_has_zero_init(s->extents[i].file)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-05-18 22:42:10 +08:00
|
|
|
static QEMUOptionParameter vmdk_create_options[] = {
|
2009-06-04 21:39:38 +08:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_SIZE,
|
|
|
|
.type = OPT_SIZE,
|
|
|
|
.help = "Virtual disk size"
|
|
|
|
},
|
2013-01-30 07:26:52 +08:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_ADAPTER_TYPE,
|
|
|
|
.type = OPT_STRING,
|
|
|
|
.help = "Virtual adapter type, can be one of "
|
|
|
|
"ide (default), lsilogic, buslogic or legacyESX"
|
|
|
|
},
|
2009-06-04 21:39:38 +08:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_BACKING_FILE,
|
|
|
|
.type = OPT_STRING,
|
|
|
|
.help = "File name of a base image"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_COMPAT6,
|
|
|
|
.type = OPT_FLAG,
|
|
|
|
.help = "VMDK version 6 image"
|
|
|
|
},
|
2011-07-19 08:45:23 +08:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_SUBFMT,
|
|
|
|
.type = OPT_STRING,
|
|
|
|
.help =
|
|
|
|
"VMDK flat extent format, can be one of "
|
2011-08-12 23:19:32 +08:00
|
|
|
"{monolithicSparse (default) | monolithicFlat | twoGbMaxExtentSparse | twoGbMaxExtentFlat | streamOptimized} "
|
2011-07-19 08:45:23 +08:00
|
|
|
},
|
2013-05-02 10:25:24 +08:00
|
|
|
{
|
|
|
|
.name = BLOCK_OPT_ZEROED_GRAIN,
|
|
|
|
.type = OPT_FLAG,
|
|
|
|
.help = "Enable efficient zero writes using the zeroed-grain GTE feature"
|
|
|
|
},
|
2009-05-18 22:42:10 +08:00
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
2009-05-10 06:03:42 +08:00
|
|
|
static BlockDriver bdrv_vmdk = {
|
2013-07-01 11:33:17 +08:00
|
|
|
.format_name = "vmdk",
|
|
|
|
.instance_size = sizeof(BDRVVmdkState),
|
|
|
|
.bdrv_probe = vmdk_probe,
|
|
|
|
.bdrv_open = vmdk_open,
|
|
|
|
.bdrv_reopen_prepare = vmdk_reopen_prepare,
|
|
|
|
.bdrv_read = vmdk_co_read,
|
|
|
|
.bdrv_write = vmdk_co_write,
|
|
|
|
.bdrv_co_write_zeroes = vmdk_co_write_zeroes,
|
|
|
|
.bdrv_close = vmdk_close,
|
|
|
|
.bdrv_create = vmdk_create,
|
|
|
|
.bdrv_co_flush_to_disk = vmdk_co_flush,
|
|
|
|
.bdrv_co_is_allocated = vmdk_co_is_allocated,
|
|
|
|
.bdrv_get_allocated_file_size = vmdk_get_allocated_file_size,
|
|
|
|
.bdrv_has_zero_init = vmdk_has_zero_init,
|
|
|
|
|
|
|
|
.create_options = vmdk_create_options,
|
2004-08-02 05:59:26 +08:00
|
|
|
};
|
2009-05-10 06:03:42 +08:00
|
|
|
|
|
|
|
static void bdrv_vmdk_init(void)
|
|
|
|
{
|
|
|
|
bdrv_register(&bdrv_vmdk);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_init(bdrv_vmdk_init);
|