[PATCH] kvm tool: QCOW version 1 write support.

[PATCH] kvm tool: QCOW version 1 write support.

[Prasad Joshi]

The code is based on the following QCOW 1 image format specification:

http://people.gnome.org/~markmc/qcow-image-format-version-1.html

Signed-off-by: Prasad Joshi <prasadjoshi124@gmail.com>
---
 tools/kvm/qcow.c |  148 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 147 insertions(+), 1 deletions(-)

diff --git a/tools/kvm/qcow.c b/tools/kvm/qcow.c
index e6d5897..ff73c55 100644
--- a/tools/kvm/qcow.c
+++ b/tools/kvm/qcow.c
@@ -134,8 +134,154 @@ error:
 	return -1;
 }
 
-static int qcow1_write_sector(struct disk_image *self, uint64_t sector, void *src, uint32_t src_len)
+static inline u64 get_file_length(int fd)
 {
+	struct stat st;
+
+	if (fstat(fd, &st) < 0)
+		return 0;
+	return st.st_size;
+}
+
+static inline u64 align(u64 address, uint32_t size)
+{
+	return (address + size) & (~(size - 1));
+}
+
+static int qcow_pwrite_with_sync(int fd, void *buf, size_t count, off_t offset)
+{
+	if (pwrite_in_full(fd, buf, count, offset) < 0)
+		return -1;
+
+	if (fsync(fd) < 0)
+		return -1;
+
+	return 0;
+}
+
+static uint32_t qcow1_write_cluster(struct qcow *q, uint64_t offset, void *buf,
+		uint32_t src_len)
+{
+	struct qcow1_header *header = q->header;
+	struct qcow_table *table    = &q->table;
+	uint32_t length;
+
+	uint32_t l2_table_size;
+	u64 l2_table_offset;
+	u64 *l2_table;
+	u64 l2_idx;
+
+	uint32_t clust_size;
+	u64 clust_offset;
+	u64 clust_start;
+
+	u64 l1_idx;
+	u64 tmp;
+
+	l2_table_size = 1 << header->l2_bits;
+	clust_size    = 1 << header->cluster_bits;
+
+	l1_idx = get_l1_index(q, offset);
+	if (l1_idx >= table->table_size)
+		goto error;
+
+	l2_idx = get_l2_index(q, offset);
+	if (l2_idx >= l2_table_size)
+		goto error;
+
+	clust_offset = get_cluster_offset(q, offset);
+	if (clust_offset >= clust_size)
+		goto error;
+
+	length = clust_size - clust_offset;
+	if (length > src_len)
+		length = src_len;
+
+	l2_table = calloc(l2_table_size, sizeof(u64));
+	if (!l2_table)
+		goto error;
+
+	l2_table_offset = table->l1_table[l1_idx];
+	if (l2_table_offset) {
+		if (pread_in_full(q->fd, l2_table, l2_table_size * sizeof(u64),
+					l2_table_offset) < 0)
+			goto free_l2;
+	} else {
+		/*
+		 * 1. write a level 2 table of zeros at the end of the file
+		 * 2. update the level1 table
+		 */
+		l2_table_offset = align(get_file_length(q->fd), clust_size);
+		table->l1_table[l1_idx] = l2_table_offset;
+
+		if (qcow_pwrite_with_sync(q->fd, l2_table,
+					l2_table_size * sizeof(u64),
+					l2_table_offset) < 0)
+			goto free_l2;
+
+		tmp = cpu_to_be64(l2_table_offset);
+		if (qcow_pwrite_with_sync(q->fd, &tmp, sizeof(tmp),
+					header->l1_table_offset +
+					(l1_idx * sizeof(u64))) < 0)
+			goto free_l2;
+	}
+
+	clust_start = be64_to_cpu(l2_table[l2_idx]);
+	free(l2_table);
+	if (clust_start) {
+		if (qcow_pwrite_with_sync(q->fd, buf, length,
+					clust_start + clust_offset) < 0)
+			goto error;
+	} else {
+		/*
+		 * Follow the write order to avoid metadata loss
+		 * 1. write the data at the end of the file
+		 * 2. update the l2_table with new
+		 */
+		clust_start = align(get_file_length(q->fd), clust_size);
+		if (qcow_pwrite_with_sync(q->fd, buf, length,
+					clust_start + clust_offset) < 0)
+			goto error;
+
+		tmp = cpu_to_be64(clust_start);
+		if (qcow_pwrite_with_sync(q->fd, &tmp, sizeof(tmp),
+					l2_table_offset +
+					(l2_idx * sizeof(u64))) < 0)
+			goto error;
+	}
+	return length;
+free_l2:
+	free(l2_table);
+error:
+	return 0;
+}
+
+static int qcow1_write_sector(struct disk_image *self, uint64_t sector,
+		void *src, uint32_t src_len)
+{
+	struct qcow *q = self->priv;
+	struct qcow1_header *header = q->header;
+	uint32_t length = 0;
+	char *buf = src;
+	uint64_t offset;
+	uint32_t nr;
+
+	while (length < src_len) {
+		offset = sector << SECTOR_SHIFT;
+		if (offset >= header->size)
+			goto error;
+
+		nr = qcow1_write_cluster(q, offset, buf, src_len - length);
+		if (!nr)
+			goto error;
+
+		length += nr;
+		buf    += nr;
+		sector += (nr >> SECTOR_SHIFT);
+	}
+
+	return 0;
+error:
 	return -1;
 }
 
-- 
1.7.1

Re: [PATCH] kvm tool: QCOW version 1 write support.

[Pekka Enberg]

On Fri, 15 Apr 2011, Prasad Joshi wrote:
> -static int qcow1_write_sector(struct disk_image *self, uint64_t sector, void *src, uint32_t src_len)
> +static inline u64 get_file_length(int fd)
> {
> +	struct stat st;
> +
> +	if (fstat(fd, &st) < 0)
> +		return 0;
> +	return st.st_size;
> +}

Wouldn't it be better to put this in 'struct disk_image'? We do fstat() 
upon startup anyway.

> +
> +static inline u64 align(u64 address, uint32_t size)
> +{
> +	return (address + size) & (~(size - 1));
> +}

There's ALIGN macro somewhere in include/linux. Use that.

> +static uint32_t qcow1_write_cluster(struct qcow *q, uint64_t offset, void *buf,
> +		uint32_t src_len)
> +{
> +	struct qcow1_header *header = q->header;
> +	struct qcow_table *table    = &q->table;
> +	uint32_t length;

Please use u32, u64, and friends.

> +
> +	uint32_t l2_table_size;
> +	u64 l2_table_offset;
> +	u64 *l2_table;
> +	u64 l2_idx;
> +
> +	uint32_t clust_size;
> +	u64 clust_offset;
> +	u64 clust_start;
> +
> +	u64 l1_idx;
> +	u64 tmp;
> +
> +	l2_table_size = 1 << header->l2_bits;
> +	clust_size    = 1 << header->cluster_bits;
> +
> +	l1_idx = get_l1_index(q, offset);
> +	if (l1_idx >= table->table_size)
> +		goto error;
> +
> +	l2_idx = get_l2_index(q, offset);
> +	if (l2_idx >= l2_table_size)
> +		goto error;
> +
> +	clust_offset = get_cluster_offset(q, offset);
> +	if (clust_offset >= clust_size)
> +		goto error;
> +
> +	length = clust_size - clust_offset;
> +	if (length > src_len)
> +		length = src_len;
> +
> +	l2_table = calloc(l2_table_size, sizeof(u64));
> +	if (!l2_table)
> +		goto error;
> +
> +	l2_table_offset = table->l1_table[l1_idx];
> +	if (l2_table_offset) {
> +		if (pread_in_full(q->fd, l2_table, l2_table_size * sizeof(u64),
> +					l2_table_offset) < 0)
> +			goto free_l2;
> +	} else {
> +		/*
> +		 * 1. write a level 2 table of zeros at the end of the file
> +		 * 2. update the level1 table
> +		 */
> +		l2_table_offset = align(get_file_length(q->fd), clust_size);
> +		table->l1_table[l1_idx] = l2_table_offset;
> +
> +		if (qcow_pwrite_with_sync(q->fd, l2_table,
> +					l2_table_size * sizeof(u64),
> +					l2_table_offset) < 0)
> +			goto free_l2;
> +
> +		tmp = cpu_to_be64(l2_table_offset);
> +		if (qcow_pwrite_with_sync(q->fd, &tmp, sizeof(tmp),
> +					header->l1_table_offset +
> +					(l1_idx * sizeof(u64))) < 0)
> +			goto free_l2;
> +	}

Maybe it's best to split this in a separate function? 
qcow_write_l2_table() or something?

It would also nice to have some comments explaining what exactly you're 
trying to do with fsync() calls there.

> +
> +	clust_start = be64_to_cpu(l2_table[l2_idx]);
> +	free(l2_table);
> +	if (clust_start) {
> +		if (qcow_pwrite_with_sync(q->fd, buf, length,
> +					clust_start + clust_offset) < 0)
> +			goto error;
> +	} else {
> +		/*
> +		 * Follow the write order to avoid metadata loss
> +		 * 1. write the data at the end of the file
> +		 * 2. update the l2_table with new
> +		 */
> +		clust_start = align(get_file_length(q->fd), clust_size);
> +		if (qcow_pwrite_with_sync(q->fd, buf, length,
> +					clust_start + clust_offset) < 0)
> +			goto error;
> +
> +		tmp = cpu_to_be64(clust_start);
> +		if (qcow_pwrite_with_sync(q->fd, &tmp, sizeof(tmp),
> +					l2_table_offset +
> +					(l2_idx * sizeof(u64))) < 0)
> +			goto error;
> +	}
> +	return length;

You can get rid of some duplication with:

 	clust_start = be64_to_cpu(l2_table[l2_idx]);
 	if (!clust_start) {
 		clust_start	= ALIGN(...);
 		update_metadata = true;
 	}

 	if (qcow_pwrite_with_sync(....) < 0)
 		goto error;

 	if (update_metadata) {
 		// ...
 	}

 			Pekka