X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=block-qcow2.c;h=afbf7feb56b87686817975f4738f42a239bdeed0;hb=221f715d90ec5fec569a19119887445c037bca86;hp=a65a10d69b2c371fc2de3b852c3ff337f1d672df;hpb=643e5399bbb1dd6113e787c4d86c942a3a7c76ca;p=qemu diff --git a/block-qcow2.c b/block-qcow2.c index a65a10d..afbf7fe 100644 --- a/block-qcow2.c +++ b/block-qcow2.c @@ -189,6 +189,14 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags) int len, i, shift, ret; QCowHeader header; + /* Performance is terrible right now with cache=writethrough due mainly + * to reference count updates. If the user does not explicitly specify + * a caching type, force to writeback caching. + */ + if ((flags & BDRV_O_CACHE_DEF)) { + flags |= BDRV_O_CACHE_WB; + flags &= ~BDRV_O_CACHE_DEF; + } ret = bdrv_file_open(&s->hd, filename, flags); if (ret < 0) return ret; @@ -245,8 +253,6 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags) goto fail; s->l1_table_offset = header.l1_table_offset; s->l1_table = qemu_malloc(s->l1_size * sizeof(uint64_t)); - if (!s->l1_table) - goto fail; if (bdrv_pread(s->hd, s->l1_table_offset, s->l1_table, s->l1_size * sizeof(uint64_t)) != s->l1_size * sizeof(uint64_t)) goto fail; @@ -255,16 +261,10 @@ static int qcow_open(BlockDriverState *bs, const char *filename, int flags) } /* alloc L2 cache */ s->l2_cache = qemu_malloc(s->l2_size * L2_CACHE_SIZE * sizeof(uint64_t)); - if (!s->l2_cache) - goto fail; s->cluster_cache = qemu_malloc(s->cluster_size); - if (!s->cluster_cache) - goto fail; /* one more sector for decompressed data alignment */ s->cluster_data = qemu_malloc(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size + 512); - if (!s->cluster_data) - goto fail; s->cluster_cache_offset = -1; if (refcount_init(bs) < 0) @@ -443,8 +443,6 @@ static int grow_l1_table(BlockDriverState *bs, int min_size) new_l1_size2 = sizeof(uint64_t) * new_l1_size; new_l1_table = qemu_mallocz(new_l1_size2); - if (!new_l1_table) - return -ENOMEM; memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t)); /* write new table (align to cluster) */ @@ -601,6 +599,37 @@ static uint64_t *l2_allocate(BlockDriverState *bs, int l1_index) return l2_table; } +static int size_to_clusters(BDRVQcowState *s, int64_t size) +{ + return (size + (s->cluster_size - 1)) >> s->cluster_bits; +} + +static int count_contiguous_clusters(uint64_t nb_clusters, int cluster_size, + uint64_t *l2_table, uint64_t start, uint64_t mask) +{ + int i; + uint64_t offset = be64_to_cpu(l2_table[0]) & ~mask; + + if (!offset) + return 0; + + for (i = start; i < start + nb_clusters; i++) + if (offset + i * cluster_size != (be64_to_cpu(l2_table[i]) & ~mask)) + break; + + return (i - start); +} + +static int count_contiguous_free_clusters(uint64_t nb_clusters, uint64_t *l2_table) +{ + int i = 0; + + while(nb_clusters-- && l2_table[i] == 0) + i++; + + return i; +} + /* * get_cluster_offset * @@ -622,9 +651,9 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, { BDRVQcowState *s = bs->opaque; int l1_index, l2_index; - uint64_t l2_offset, *l2_table, cluster_offset, next; - int l1_bits; - int index_in_cluster, nb_available, nb_needed; + uint64_t l2_offset, *l2_table, cluster_offset; + int l1_bits, c; + int index_in_cluster, nb_available, nb_needed, nb_clusters; index_in_cluster = (offset >> 9) & (s->cluster_sectors - 1); nb_needed = *num + index_in_cluster; @@ -632,7 +661,7 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, l1_bits = s->l2_bits + s->cluster_bits; /* compute how many bytes there are between the offset and - * and the end of the l1 entry + * the end of the l1 entry */ nb_available = (1 << l1_bits) - (offset & ((1 << l1_bits) - 1)); @@ -667,38 +696,25 @@ static uint64_t get_cluster_offset(BlockDriverState *bs, l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1); cluster_offset = be64_to_cpu(l2_table[l2_index]); - nb_available = s->cluster_sectors; - l2_index++; + nb_clusters = size_to_clusters(s, nb_needed << 9); if (!cluster_offset) { - - /* how many empty clusters ? */ - - while (nb_available < nb_needed && !l2_table[l2_index]) { - l2_index++; - nb_available += s->cluster_sectors; - } + /* how many empty clusters ? */ + c = count_contiguous_free_clusters(nb_clusters, &l2_table[l2_index]); } else { + /* how many allocated clusters ? */ + c = count_contiguous_clusters(nb_clusters, s->cluster_size, + &l2_table[l2_index], 0, QCOW_OFLAG_COPIED); + } - /* how many allocated clusters ? */ - - cluster_offset &= ~QCOW_OFLAG_COPIED; - while (nb_available < nb_needed) { - next = be64_to_cpu(l2_table[l2_index]) & ~QCOW_OFLAG_COPIED; - if (next != cluster_offset + (nb_available << 9)) - break; - l2_index++; - nb_available += s->cluster_sectors; - } - } - + nb_available = (c * s->cluster_sectors); out: if (nb_available > nb_needed) nb_available = nb_needed; *num = nb_available - index_in_cluster; - return cluster_offset; + return cluster_offset & ~QCOW_OFLAG_COPIED; } /* @@ -841,6 +857,69 @@ static uint64_t alloc_compressed_cluster_offset(BlockDriverState *bs, return cluster_offset; } +typedef struct QCowL2Meta +{ + uint64_t offset; + int n_start; + int nb_available; + int nb_clusters; +} QCowL2Meta; + +static int alloc_cluster_link_l2(BlockDriverState *bs, uint64_t cluster_offset, + QCowL2Meta *m) +{ + BDRVQcowState *s = bs->opaque; + int i, j = 0, l2_index, ret; + uint64_t *old_cluster, start_sect, l2_offset, *l2_table; + + if (m->nb_clusters == 0) + return 0; + + old_cluster = qemu_malloc(m->nb_clusters * sizeof(uint64_t)); + + /* copy content of unmodified sectors */ + start_sect = (m->offset & ~(s->cluster_size - 1)) >> 9; + if (m->n_start) { + ret = copy_sectors(bs, start_sect, cluster_offset, 0, m->n_start); + if (ret < 0) + goto err; + } + + if (m->nb_available & (s->cluster_sectors - 1)) { + uint64_t end = m->nb_available & ~(uint64_t)(s->cluster_sectors - 1); + ret = copy_sectors(bs, start_sect + end, cluster_offset + (end << 9), + m->nb_available - end, s->cluster_sectors); + if (ret < 0) + goto err; + } + + ret = -EIO; + /* update L2 table */ + if (!get_cluster_table(bs, m->offset, &l2_table, &l2_offset, &l2_index)) + goto err; + + for (i = 0; i < m->nb_clusters; i++) { + if(l2_table[l2_index + i] != 0) + old_cluster[j++] = l2_table[l2_index + i]; + + l2_table[l2_index + i] = cpu_to_be64((cluster_offset + + (i << s->cluster_bits)) | QCOW_OFLAG_COPIED); + } + + if (bdrv_pwrite(s->hd, l2_offset + l2_index * sizeof(uint64_t), + l2_table + l2_index, m->nb_clusters * sizeof(uint64_t)) != + m->nb_clusters * sizeof(uint64_t)) + goto err; + + for (i = 0; i < j; i++) + free_any_clusters(bs, old_cluster[i], 1); + + ret = 0; +err: + qemu_free(old_cluster); + return ret; + } + /* * alloc_cluster_offset * @@ -857,41 +936,31 @@ static uint64_t alloc_compressed_cluster_offset(BlockDriverState *bs, static uint64_t alloc_cluster_offset(BlockDriverState *bs, uint64_t offset, int n_start, int n_end, - int *num) + int *num, QCowL2Meta *m) { BDRVQcowState *s = bs->opaque; int l2_index, ret; uint64_t l2_offset, *l2_table, cluster_offset; - int nb_available, nb_clusters, i, j; - uint64_t start_sect, current; + int nb_clusters, i = 0; ret = get_cluster_table(bs, offset, &l2_table, &l2_offset, &l2_index); if (ret == 0) return 0; - nb_clusters = ((n_end << 9) + s->cluster_size - 1) >> - s->cluster_bits; - if (nb_clusters > s->l2_size - l2_index) - nb_clusters = s->l2_size - l2_index; + nb_clusters = size_to_clusters(s, n_end << 9); + + nb_clusters = MIN(nb_clusters, s->l2_size - l2_index); cluster_offset = be64_to_cpu(l2_table[l2_index]); /* We keep all QCOW_OFLAG_COPIED clusters */ if (cluster_offset & QCOW_OFLAG_COPIED) { - - for (i = 1; i < nb_clusters; i++) { - current = be64_to_cpu(l2_table[l2_index + i]); - if (cluster_offset + (i << s->cluster_bits) != current) - break; - } - nb_clusters = i; - - nb_available = nb_clusters << (s->cluster_bits - 9); - if (nb_available > n_end) - nb_available = n_end; + nb_clusters = count_contiguous_clusters(nb_clusters, s->cluster_size, + &l2_table[l2_index], 0, 0); cluster_offset &= ~QCOW_OFLAG_COPIED; + m->nb_clusters = 0; goto out; } @@ -903,46 +972,21 @@ static uint64_t alloc_cluster_offset(BlockDriverState *bs, /* how many available clusters ? */ - i = 0; while (i < nb_clusters) { + i += count_contiguous_clusters(nb_clusters - i, s->cluster_size, + &l2_table[l2_index], i, 0); - i++; - - if (!cluster_offset) { + if(be64_to_cpu(l2_table[l2_index + i])) + break; - /* how many free clusters ? */ + i += count_contiguous_free_clusters(nb_clusters - i, + &l2_table[l2_index + i]); - while (i < nb_clusters) { - cluster_offset = be64_to_cpu(l2_table[l2_index + i]); - if (cluster_offset != 0) - break; - i++; - } + cluster_offset = be64_to_cpu(l2_table[l2_index + i]); - if ((cluster_offset & QCOW_OFLAG_COPIED) || + if ((cluster_offset & QCOW_OFLAG_COPIED) || (cluster_offset & QCOW_OFLAG_COMPRESSED)) - break; - - } else { - - /* how many contiguous clusters ? */ - - j = 1; - current = 0; - while (i < nb_clusters) { - current = be64_to_cpu(l2_table[l2_index + i]); - if (cluster_offset + (j << s->cluster_bits) != current) - break; - - i++; - j++; - } - - free_any_clusters(bs, cluster_offset, j); - if (current) - break; - cluster_offset = current; - } + break; } nb_clusters = i; @@ -950,48 +994,15 @@ static uint64_t alloc_cluster_offset(BlockDriverState *bs, cluster_offset = alloc_clusters(bs, nb_clusters * s->cluster_size); - /* we must initialize the cluster content which won't be - written */ - - nb_available = nb_clusters << (s->cluster_bits - 9); - if (nb_available > n_end) - nb_available = n_end; - - /* copy content of unmodified sectors */ - - start_sect = (offset & ~(s->cluster_size - 1)) >> 9; - if (n_start) { - ret = copy_sectors(bs, start_sect, cluster_offset, 0, n_start); - if (ret < 0) - return 0; - } - - if (nb_available & (s->cluster_sectors - 1)) { - uint64_t end = nb_available & ~(uint64_t)(s->cluster_sectors - 1); - ret = copy_sectors(bs, start_sect + end, - cluster_offset + (end << 9), - nb_available - end, - s->cluster_sectors); - if (ret < 0) - return 0; - } - - /* update L2 table */ - - for (i = 0; i < nb_clusters; i++) - l2_table[l2_index + i] = cpu_to_be64((cluster_offset + - (i << s->cluster_bits)) | - QCOW_OFLAG_COPIED); - - if (bdrv_pwrite(s->hd, - l2_offset + l2_index * sizeof(uint64_t), - l2_table + l2_index, - nb_clusters * sizeof(uint64_t)) != - nb_clusters * sizeof(uint64_t)) - return 0; + /* save info needed for meta data update */ + m->offset = offset; + m->n_start = n_start; + m->nb_clusters = nb_clusters; out: - *num = nb_available - n_start; + m->nb_available = MIN(nb_clusters << (s->cluster_bits - 9), n_end); + + *num = m->nb_available - n_start; return cluster_offset; } @@ -1122,6 +1133,7 @@ static int qcow_write(BlockDriverState *bs, int64_t sector_num, int ret, index_in_cluster, n; uint64_t cluster_offset; int n_end; + QCowL2Meta l2meta; while (nb_sectors > 0) { index_in_cluster = sector_num & (s->cluster_sectors - 1); @@ -1131,7 +1143,7 @@ static int qcow_write(BlockDriverState *bs, int64_t sector_num, n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; cluster_offset = alloc_cluster_offset(bs, sector_num << 9, index_in_cluster, - n_end, &n); + n_end, &n, &l2meta); if (!cluster_offset) return -1; if (s->crypt_method) { @@ -1142,8 +1154,10 @@ static int qcow_write(BlockDriverState *bs, int64_t sector_num, } else { ret = bdrv_pwrite(s->hd, cluster_offset + index_in_cluster * 512, buf, n * 512); } - if (ret != n * 512) + if (ret != n * 512 || alloc_cluster_link_l2(bs, cluster_offset, &l2meta) < 0) { + free_any_clusters(bs, cluster_offset, l2meta.nb_clusters); return -1; + } nb_sectors -= n; sector_num += n; buf += n * 512; @@ -1162,6 +1176,7 @@ typedef struct QCowAIOCB { uint8_t *cluster_data; BlockDriverAIOCB *hd_aiocb; QEMUBH *bh; + QCowL2Meta l2meta; } QCowAIOCB; static void qcow_aio_read_cb(void *opaque, int ret); @@ -1290,6 +1305,7 @@ static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs, acb->nb_sectors = nb_sectors; acb->n = 0; acb->cluster_offset = 0; + acb->l2meta.nb_clusters = 0; return acb; } @@ -1313,7 +1329,6 @@ static void qcow_aio_write_cb(void *opaque, int ret) BlockDriverState *bs = acb->common.bs; BDRVQcowState *s = bs->opaque; int index_in_cluster; - uint64_t cluster_offset; const uint8_t *src_buf; int n_end; @@ -1326,6 +1341,11 @@ static void qcow_aio_write_cb(void *opaque, int ret) return; } + if (alloc_cluster_link_l2(bs, acb->cluster_offset, &acb->l2meta) < 0) { + free_any_clusters(bs, acb->cluster_offset, acb->l2meta.nb_clusters); + goto fail; + } + acb->nb_sectors -= acb->n; acb->sector_num += acb->n; acb->buf += acb->n * 512; @@ -1343,10 +1363,10 @@ static void qcow_aio_write_cb(void *opaque, int ret) n_end > QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors) n_end = QCOW_MAX_CRYPT_CLUSTERS * s->cluster_sectors; - cluster_offset = alloc_cluster_offset(bs, acb->sector_num << 9, + acb->cluster_offset = alloc_cluster_offset(bs, acb->sector_num << 9, index_in_cluster, - n_end, &acb->n); - if (!cluster_offset || (cluster_offset & 511) != 0) { + n_end, &acb->n, &acb->l2meta); + if (!acb->cluster_offset || (acb->cluster_offset & 511) != 0) { ret = -EIO; goto fail; } @@ -1354,10 +1374,6 @@ static void qcow_aio_write_cb(void *opaque, int ret) if (!acb->cluster_data) { acb->cluster_data = qemu_mallocz(QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size); - if (!acb->cluster_data) { - ret = -ENOMEM; - goto fail; - } } encrypt_sectors(s, acb->sector_num, acb->cluster_data, acb->buf, acb->n, 1, &s->aes_encrypt_key); @@ -1366,7 +1382,7 @@ static void qcow_aio_write_cb(void *opaque, int ret) src_buf = acb->buf; } acb->hd_aiocb = bdrv_aio_write(s->hd, - (cluster_offset >> 9) + index_in_cluster, + (acb->cluster_offset >> 9) + index_in_cluster, src_buf, acb->n, qcow_aio_write_cb, acb); if (acb->hd_aiocb == NULL) @@ -1482,11 +1498,7 @@ static int qcow_create(const char *filename, int64_t total_size, offset += align_offset(l1_size * sizeof(uint64_t), s->cluster_size); s->refcount_table = qemu_mallocz(s->cluster_size); - if (!s->refcount_table) - goto fail; s->refcount_block = qemu_mallocz(s->cluster_size); - if (!s->refcount_block) - goto fail; s->refcount_table_offset = offset; header.refcount_table_offset = cpu_to_be64(offset); @@ -1523,11 +1535,6 @@ static int qcow_create(const char *filename, int64_t total_size, qemu_free(s->refcount_block); close(fd); return 0; - fail: - qemu_free(s->refcount_table); - qemu_free(s->refcount_block); - close(fd); - return -ENOMEM; } static int qcow_make_empty(BlockDriverState *bs) @@ -1574,8 +1581,6 @@ static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num, return -EINVAL; out_buf = qemu_malloc(s->cluster_size + (s->cluster_size / 1000) + 128); - if (!out_buf) - return -ENOMEM; /* best compression, small window, no zlib header */ memset(&strm, 0, sizeof(strm)); @@ -1658,8 +1663,6 @@ static int update_snapshot_refcount(BlockDriverState *bs, l1_allocated = 0; if (l1_table_offset != s->l1_table_offset) { l1_table = qemu_malloc(l1_size2); - if (!l1_table) - goto fail; l1_allocated = 1; if (bdrv_pread(s->hd, l1_table_offset, l1_table, l1_size2) != l1_size2) @@ -1674,8 +1677,6 @@ static int update_snapshot_refcount(BlockDriverState *bs, l2_size = s->l2_size * sizeof(uint64_t); l2_table = qemu_malloc(l2_size); - if (!l2_table) - goto fail; l1_modified = 0; for(i = 0; i < l1_size; i++) { l2_offset = l1_table[i]; @@ -1778,10 +1779,14 @@ static int qcow_read_snapshots(BlockDriverState *bs) int64_t offset; uint32_t extra_data_size; + if (!s->nb_snapshots) { + s->snapshots = NULL; + s->snapshots_size = 0; + return 0; + } + offset = s->snapshots_offset; s->snapshots = qemu_mallocz(s->nb_snapshots * sizeof(QCowSnapshot)); - if (!s->snapshots) - goto fail; for(i = 0; i < s->nb_snapshots; i++) { offset = align_offset(offset, 8); if (bdrv_pread(s->hd, offset, &h, sizeof(h)) != sizeof(h)) @@ -1802,16 +1807,12 @@ static int qcow_read_snapshots(BlockDriverState *bs) offset += extra_data_size; sn->id_str = qemu_malloc(id_str_size + 1); - if (!sn->id_str) - goto fail; if (bdrv_pread(s->hd, offset, sn->id_str, id_str_size) != id_str_size) goto fail; offset += id_str_size; sn->id_str[id_str_size] = '\0'; sn->name = qemu_malloc(name_size + 1); - if (!sn->name) - goto fail; if (bdrv_pread(s->hd, offset, sn->name, name_size) != name_size) goto fail; offset += name_size; @@ -1977,8 +1978,6 @@ static int qcow_snapshot_create(BlockDriverState *bs, sn->l1_size = s->l1_size; l1_table = qemu_malloc(s->l1_size * sizeof(uint64_t)); - if (!l1_table) - goto fail; for(i = 0; i < s->l1_size; i++) { l1_table[i] = cpu_to_be64(s->l1_table[i]); } @@ -1990,9 +1989,10 @@ static int qcow_snapshot_create(BlockDriverState *bs, l1_table = NULL; snapshots1 = qemu_malloc((s->nb_snapshots + 1) * sizeof(QCowSnapshot)); - if (!snapshots1) - goto fail; - memcpy(snapshots1, s->snapshots, s->nb_snapshots * sizeof(QCowSnapshot)); + if (s->snapshots) { + memcpy(snapshots1, s->snapshots, s->nb_snapshots * sizeof(QCowSnapshot)); + qemu_free(s->snapshots); + } s->snapshots = snapshots1; s->snapshots[s->nb_snapshots++] = *sn; @@ -2095,8 +2095,6 @@ static int qcow_snapshot_list(BlockDriverState *bs, int i; sn_tab = qemu_mallocz(s->nb_snapshots * sizeof(QEMUSnapshotInfo)); - if (!sn_tab) - goto fail; for(i = 0; i < s->nb_snapshots; i++) { sn_info = sn_tab + i; sn = s->snapshots + i; @@ -2111,10 +2109,6 @@ static int qcow_snapshot_list(BlockDriverState *bs, } *psn_tab = sn_tab; return s->nb_snapshots; - fail: - qemu_free(sn_tab); - *psn_tab = NULL; - return -ENOMEM; } /*********************************************************/ @@ -2126,12 +2120,8 @@ static int refcount_init(BlockDriverState *bs) int ret, refcount_table_size2, i; s->refcount_block_cache = qemu_malloc(s->cluster_size); - if (!s->refcount_block_cache) - goto fail; refcount_table_size2 = s->refcount_table_size * sizeof(uint64_t); s->refcount_table = qemu_malloc(refcount_table_size2); - if (!s->refcount_table) - goto fail; if (s->refcount_table_size > 0) { ret = bdrv_pread(s->hd, s->refcount_table_offset, s->refcount_table, refcount_table_size2); @@ -2194,26 +2184,19 @@ static int64_t alloc_clusters_noref(BlockDriverState *bs, int64_t size) BDRVQcowState *s = bs->opaque; int i, nb_clusters; - nb_clusters = (size + s->cluster_size - 1) >> s->cluster_bits; - for(;;) { - if (get_refcount(bs, s->free_cluster_index) == 0) { - s->free_cluster_index++; - for(i = 1; i < nb_clusters; i++) { - if (get_refcount(bs, s->free_cluster_index) != 0) - goto not_found; - s->free_cluster_index++; - } + nb_clusters = size_to_clusters(s, size); +retry: + for(i = 0; i < nb_clusters; i++) { + int64_t i = s->free_cluster_index++; + if (get_refcount(bs, i) != 0) + goto retry; + } #ifdef DEBUG_ALLOC2 - printf("alloc_clusters: size=%lld -> %lld\n", - size, - (s->free_cluster_index - nb_clusters) << s->cluster_bits); + printf("alloc_clusters: size=%lld -> %lld\n", + size, + (s->free_cluster_index - nb_clusters) << s->cluster_bits); #endif - return (s->free_cluster_index - nb_clusters) << s->cluster_bits; - } else { - not_found: - s->free_cluster_index++; - } - } + return (s->free_cluster_index - nb_clusters) << s->cluster_bits; } static int64_t alloc_clusters(BlockDriverState *bs, int64_t size) @@ -2302,8 +2285,6 @@ static int grow_refcount_table(BlockDriverState *bs, int min_size) #endif new_table_size2 = new_table_size * sizeof(uint64_t); new_table = qemu_mallocz(new_table_size2); - if (!new_table) - return -ENOMEM; memcpy(new_table, s->refcount_table, s->refcount_table_size * sizeof(uint64_t)); for(i = 0; i < s->refcount_table_size; i++) @@ -2468,8 +2449,6 @@ static int check_refcounts_l1(BlockDriverState *bs, l1_table_offset, l1_size2); l1_table = qemu_malloc(l1_size2); - if (!l1_table) - goto fail; if (bdrv_pread(s->hd, l1_table_offset, l1_table, l1_size2) != l1_size2) goto fail; @@ -2478,8 +2457,6 @@ static int check_refcounts_l1(BlockDriverState *bs, l2_size = s->l2_size * sizeof(uint64_t); l2_table = qemu_malloc(l2_size); - if (!l2_table) - goto fail; for(i = 0; i < l1_size; i++) { l2_offset = l1_table[i]; if (l2_offset) { @@ -2548,7 +2525,7 @@ static void check_refcounts(BlockDriverState *bs) uint16_t *refcount_table; size = bdrv_getlength(s->hd); - nb_clusters = (size + s->cluster_size - 1) >> s->cluster_bits; + nb_clusters = size_to_clusters(s, size); refcount_table = qemu_mallocz(nb_clusters * sizeof(uint16_t)); /* header */ @@ -2600,7 +2577,7 @@ static void dump_refcounts(BlockDriverState *bs) int refcount; size = bdrv_getlength(s->hd); - nb_clusters = (size + s->cluster_size - 1) >> s->cluster_bits; + nb_clusters = size_to_clusters(s, size); for(k = 0; k < nb_clusters;) { k1 = k; refcount = get_refcount(bs, k); @@ -2614,28 +2591,26 @@ static void dump_refcounts(BlockDriverState *bs) #endif BlockDriver bdrv_qcow2 = { - "qcow2", - sizeof(BDRVQcowState), - qcow_probe, - qcow_open, - NULL, - NULL, - qcow_close, - qcow_create, - qcow_flush, - qcow_is_allocated, - qcow_set_key, - qcow_make_empty, - - .bdrv_aio_read = qcow_aio_read, - .bdrv_aio_write = qcow_aio_write, - .bdrv_aio_cancel = qcow_aio_cancel, - .aiocb_size = sizeof(QCowAIOCB), + .format_name = "qcow2", + .instance_size = sizeof(BDRVQcowState), + .bdrv_probe = qcow_probe, + .bdrv_open = qcow_open, + .bdrv_close = qcow_close, + .bdrv_create = qcow_create, + .bdrv_flush = qcow_flush, + .bdrv_is_allocated = qcow_is_allocated, + .bdrv_set_key = qcow_set_key, + .bdrv_make_empty = qcow_make_empty, + + .bdrv_aio_read = qcow_aio_read, + .bdrv_aio_write = qcow_aio_write, + .bdrv_aio_cancel = qcow_aio_cancel, + .aiocb_size = sizeof(QCowAIOCB), .bdrv_write_compressed = qcow_write_compressed, .bdrv_snapshot_create = qcow_snapshot_create, - .bdrv_snapshot_goto = qcow_snapshot_goto, + .bdrv_snapshot_goto = qcow_snapshot_goto, .bdrv_snapshot_delete = qcow_snapshot_delete, - .bdrv_snapshot_list = qcow_snapshot_list, - .bdrv_get_info = qcow_get_info, + .bdrv_snapshot_list = qcow_snapshot_list, + .bdrv_get_info = qcow_get_info, };