[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [patch 2/5][v2] Divide get_cluster_offset()
From: |
Laurent Vivier |
Subject: |
[Qemu-devel] [patch 2/5][v2] Divide get_cluster_offset() |
Date: |
Tue, 29 Jul 2008 16:13:54 +0200 |
User-agent: |
quilt/0.45-1 |
Divide get_cluster_offset() into get_cluster_offset() and
alloc_cluster_offset().
Signed-off-by: Laurent Vivier <address@hidden>
---
block-qcow2.c | 161 +++++++++++++++++++++++++++++++++-------------------------
1 file changed, 94 insertions(+), 67 deletions(-)
Index: qemu/block-qcow2.c
===================================================================
--- qemu.orig/block-qcow2.c 2008-07-11 10:07:10.000000000 +0200
+++ qemu/block-qcow2.c 2008-07-11 11:04:14.000000000 +0200
@@ -575,51 +575,65 @@ static int l2_allocate(BlockDriverState
return 1;
}
-static uint64_t get_cluster_offset(BlockDriverState *bs,
- uint64_t offset, int allocate,
- int compressed_size,
- int n_start, int n_end)
+static uint64_t get_cluster_offset(BlockDriverState *bs, uint64_t offset)
{
BDRVQcowState *s = bs->opaque;
int l1_index, l2_index, ret;
- uint64_t l2_offset, *l2_table, cluster_offset, tmp;
+ uint64_t l2_offset, *l2_table, cluster_offset;
+
+ l1_index = offset >> (s->l2_bits + s->cluster_bits);
+ if (l1_index >= s->l1_size)
+ return 0;
+
+ if (!s->l1_table[l1_index])
+ return 0;
+
+ ret = l2_load(bs, l1_index, &l2_table, &l2_offset);
+ if (ret == 0)
+ return 0;
+
+ l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
+ cluster_offset = be64_to_cpu(l2_table[l2_index]);
+
+ return cluster_offset & ~QCOW_OFLAG_COPIED;
+}
+
+static uint64_t alloc_cluster_offset(BlockDriverState *bs,
+ uint64_t offset,
+ int compressed_size,
+ int n_start, int n_end)
+{
+ BDRVQcowState *s = bs->opaque;
+ int l1_index, l2_index, ret;
+ uint64_t l2_offset, *l2_table, cluster_offset;
l1_index = offset >> (s->l2_bits + s->cluster_bits);
if (l1_index >= s->l1_size) {
- /* outside l1 table is allowed: we grow the table if needed */
- if (!allocate)
- return 0;
ret = grow_l1_table(bs, l1_index + 1);
if (ret < 0)
return 0;
}
+
l2_offset = s->l1_table[l1_index];
- if (!l2_offset) {
- if (!allocate)
- return 0;
- ret = l2_allocate(bs, l1_index, &l2_table, &l2_offset);
+ if (l2_offset & QCOW_OFLAG_COPIED) {
+ ret = l2_load(bs, l1_index, &l2_table, &l2_offset);
if (ret == 0)
return 0;
} else {
- if (!(l2_offset & QCOW_OFLAG_COPIED) && allocate) {
+ if (l2_offset)
free_clusters(bs, l2_offset, s->l2_size * sizeof(uint64_t));
- ret = l2_allocate(bs, l1_index, &l2_table, &l2_offset);
- if (ret == 0)
- return 0;
- } else {
- ret = l2_load(bs, l1_index, &l2_table, &l2_offset);
- if (ret == 0)
- return 0;
- }
+ ret = l2_allocate(bs, l1_index, &l2_table, &l2_offset);
+ if (ret == 0)
+ return 0;
}
+
l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);
cluster_offset = be64_to_cpu(l2_table[l2_index]);
- if (!cluster_offset) {
- if (!allocate)
- return cluster_offset;
- } else if (!(cluster_offset & QCOW_OFLAG_COPIED)) {
- if (!allocate)
- return cluster_offset;
+
+ if (cluster_offset & QCOW_OFLAG_COPIED)
+ return cluster_offset & ~QCOW_OFLAG_COPIED;
+
+ if (cluster_offset) {
/* free the cluster */
if (cluster_offset & QCOW_OFLAG_COMPRESSED) {
int nb_csectors;
@@ -630,45 +644,59 @@ static uint64_t get_cluster_offset(Block
} else {
free_clusters(bs, cluster_offset, s->cluster_size);
}
- } else {
- cluster_offset &= ~QCOW_OFLAG_COPIED;
- return cluster_offset;
}
- if (allocate == 1) {
- /* allocate a new cluster */
- cluster_offset = alloc_clusters(bs, s->cluster_size);
-
- /* we must initialize the cluster content which won't be
- written */
- if ((n_end - n_start) < s->cluster_sectors) {
- uint64_t start_sect;
-
- start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
- ret = copy_sectors(bs, start_sect,
- cluster_offset, 0, n_start);
- if (ret < 0)
- return 0;
- ret = copy_sectors(bs, start_sect,
- cluster_offset, n_end, s->cluster_sectors);
- if (ret < 0)
- return 0;
- }
- tmp = cpu_to_be64(cluster_offset | QCOW_OFLAG_COPIED);
- } else {
+
+ if (compressed_size) {
int nb_csectors;
cluster_offset = alloc_bytes(bs, compressed_size);
nb_csectors = ((cluster_offset + compressed_size - 1) >> 9) -
(cluster_offset >> 9);
cluster_offset |= QCOW_OFLAG_COMPRESSED |
((uint64_t)nb_csectors << s->csize_shift);
- /* compressed clusters never have the copied flag */
- tmp = cpu_to_be64(cluster_offset);
+
+ /* update L2 table
+ * compressed clusters never have the copied flag
+ */
+
+ l2_table[l2_index] = cpu_to_be64(cluster_offset);
+ if (bdrv_pwrite(s->hd,
+ l2_offset + l2_index * sizeof(uint64_t),
+ l2_table + l2_index,
+ sizeof(uint64_t)) != sizeof(uint64_t))
+ return 0;
+
+ return cluster_offset;
}
+
+ /* allocate a new cluster */
+
+ cluster_offset = alloc_clusters(bs, s->cluster_size);
+
+ /* we must initialize the cluster content which won't be
+ written */
+
+ if ((n_end - n_start) < s->cluster_sectors) {
+ uint64_t start_sect;
+
+ start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
+ ret = copy_sectors(bs, start_sect, cluster_offset, 0, n_start);
+ if (ret < 0)
+ return 0;
+ ret = copy_sectors(bs, start_sect,
+ cluster_offset, n_end, s->cluster_sectors);
+ if (ret < 0)
+ return 0;
+ }
+
/* update L2 table */
- l2_table[l2_index] = tmp;
+
+ l2_table[l2_index] = cpu_to_be64(cluster_offset | QCOW_OFLAG_COPIED);
if (bdrv_pwrite(s->hd,
- l2_offset + l2_index * sizeof(tmp), &tmp, sizeof(tmp)) !=
sizeof(tmp))
+ l2_offset + l2_index * sizeof(uint64_t),
+ l2_table + l2_index,
+ sizeof(uint64_t)) != sizeof(uint64_t))
return 0;
+
return cluster_offset;
}
@@ -679,7 +707,7 @@ static int qcow_is_allocated(BlockDriver
int index_in_cluster, n;
uint64_t cluster_offset;
- cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);
+ cluster_offset = get_cluster_offset(bs, sector_num << 9);
index_in_cluster = sector_num & (s->cluster_sectors - 1);
n = s->cluster_sectors - index_in_cluster;
if (n > nb_sectors)
@@ -761,7 +789,7 @@ static int qcow_read(BlockDriverState *b
uint64_t cluster_offset;
while (nb_sectors > 0) {
- cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);
+ cluster_offset = get_cluster_offset(bs, sector_num << 9);
index_in_cluster = sector_num & (s->cluster_sectors - 1);
n = s->cluster_sectors - index_in_cluster;
if (n > nb_sectors)
@@ -810,9 +838,9 @@ static int qcow_write(BlockDriverState *
n = s->cluster_sectors - index_in_cluster;
if (n > nb_sectors)
n = nb_sectors;
- cluster_offset = get_cluster_offset(bs, sector_num << 9, 1, 0,
- index_in_cluster,
- index_in_cluster + n);
+ cluster_offset = alloc_cluster_offset(bs, sector_num << 9, 0,
+ index_in_cluster,
+ index_in_cluster + n);
if (!cluster_offset)
return -1;
if (s->crypt_method) {
@@ -885,8 +913,7 @@ static void qcow_aio_read_cb(void *opaqu
}
/* prepare next AIO request */
- acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9,
- 0, 0, 0, 0);
+ acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9);
index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);
acb->n = s->cluster_sectors - index_in_cluster;
if (acb->n > acb->nb_sectors)
@@ -995,9 +1022,9 @@ static void qcow_aio_write_cb(void *opaq
acb->n = s->cluster_sectors - index_in_cluster;
if (acb->n > acb->nb_sectors)
acb->n = acb->nb_sectors;
- cluster_offset = get_cluster_offset(bs, acb->sector_num << 9, 1, 0,
- index_in_cluster,
- index_in_cluster + acb->n);
+ cluster_offset = alloc_cluster_offset(bs, acb->sector_num << 9, 0,
+ index_in_cluster,
+ index_in_cluster + acb->n);
if (!cluster_offset || (cluster_offset & 511) != 0) {
ret = -EIO;
goto fail;
@@ -1257,8 +1284,8 @@ static int qcow_write_compressed(BlockDr
/* could not compress: write normal cluster */
qcow_write(bs, sector_num, buf, s->cluster_sectors);
} else {
- cluster_offset = get_cluster_offset(bs, sector_num << 9, 2,
- out_len, 0, 0);
+ cluster_offset = alloc_cluster_offset(bs, sector_num << 9,
+ out_len, 0, 0);
cluster_offset &= s->cluster_offset_mask;
if (bdrv_pwrite(s->hd, cluster_offset, out_buf, out_len) != out_len) {
qemu_free(out_buf);
--
- [Qemu-devel] [patch 0/5][v2] qcow2: improve I/O performance with cache=off, Laurent Vivier, 2008/07/29
- [Qemu-devel] [patch 1/5][v2] Extract code from get_cluster_offset(), Laurent Vivier, 2008/07/29
- [Qemu-devel] [patch 4/5][v2] Aggregate same type clusters., Laurent Vivier, 2008/07/29
- [Qemu-devel] [patch 3/5][v2] Extract compressing part from alloc_cluster_offset(), Laurent Vivier, 2008/07/29
- [Qemu-devel] [patch 2/5][v2] Divide get_cluster_offset(),
Laurent Vivier <=
- [Qemu-devel] [patch 5/5][v2] Try to aggregate free clusters and freed clusters, Laurent Vivier, 2008/07/29
- Re: [Qemu-devel] [patch 0/5][v2] qcow2: improve I/O performance with cache=off, Anthony Liguori, 2008/07/29