Commit 9e029689 authored by Alberto Garcia's avatar Alberto Garcia Committed by Max Reitz
Browse files

qcow2: Replace align_offset() with ROUND_UP() 



The align_offset() function is equivalent to the ROUND_UP() macro so
there's no need to use the former. The ROUND_UP() name is also a bit
more explicit.

This patch uses ROUND_UP() instead of the slower QEMU_ALIGN_UP()
because align_offset() already requires that the second parameter is a
power of two.

Signed-off-by: default avatarAlberto Garcia <berto@igalia.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Reviewed-by: default avatarPhilippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180215131008.5153-1-berto@igalia.com
Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
parent 624f3006

block/qcow2-bitmap.c

+2 −2
Original line number Diff line number Diff line
@@ -413,8 +413,8 @@ static inline void bitmap_dir_entry_to_be(Qcow2BitmapDirEntry *entry) 


static inline int calc_dir_entry_size(size_t name_size, size_t extra_data_size)

{

    return align_offset(sizeof(Qcow2BitmapDirEntry) +

                        name_size + extra_data_size, 8);

    int size = sizeof(Qcow2BitmapDirEntry) + name_size + extra_data_size;

    return ROUND_UP(size, 8);

}



static inline int dir_entry_size(Qcow2BitmapDirEntry *entry)

block/qcow2-cluster.c

+2 −2
Original line number Diff line number Diff line
@@ -126,11 +126,11 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, 


    new_l1_size2 = sizeof(uint64_t) * new_l1_size;

    new_l1_table = qemu_try_blockalign(bs->file->bs,

                                       align_offset(new_l1_size2, 512));

                                       ROUND_UP(new_l1_size2, 512));

    if (new_l1_table == NULL) {

        return -ENOMEM;

    }

    memset(new_l1_table, 0, align_offset(new_l1_size2, 512));

    memset(new_l1_table, 0, ROUND_UP(new_l1_size2, 512));



    if (s->l1_size) {

        memcpy(new_l1_table, s->l1_table, s->l1_size * sizeof(uint64_t));

block/qcow2-refcount.c

+2 −2
Original line number Diff line number Diff line
@@ -1204,7 +1204,7 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs, 
     * l1_table_offset when it is the current s->l1_table_offset! Be careful

     * when changing this! */

    if (l1_table_offset != s->l1_table_offset) {

        l1_table = g_try_malloc0(align_offset(l1_size2, 512));

        l1_table = g_try_malloc0(ROUND_UP(l1_size2, 512));

        if (l1_size2 && l1_table == NULL) {

            ret = -ENOMEM;

            goto fail;
@@ -2553,7 +2553,7 @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset, 
    }



    /* align range to test to cluster boundaries */

    size = align_offset(offset_into_cluster(s, offset) + size, s->cluster_size);

    size = ROUND_UP(offset_into_cluster(s, offset) + size, s->cluster_size);

    offset = start_of_cluster(s, offset);



    if ((chk & QCOW2_OL_ACTIVE_L1) && s->l1_size) {

block/qcow2-snapshot.c

+5 −5
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ int qcow2_read_snapshots(BlockDriverState *bs) 


    for(i = 0; i < s->nb_snapshots; i++) {

        /* Read statically sized part of the snapshot header */

        offset = align_offset(offset, 8);

        offset = ROUND_UP(offset, 8);

        ret = bdrv_pread(bs->file, offset, &h, sizeof(h));

        if (ret < 0) {

            goto fail;
@@ -155,7 +155,7 @@ static int qcow2_write_snapshots(BlockDriverState *bs) 
    offset = 0;

    for(i = 0; i < s->nb_snapshots; i++) {

        sn = s->snapshots + i;

        offset = align_offset(offset, 8);

        offset = ROUND_UP(offset, 8);

        offset += sizeof(h);

        offset += sizeof(extra);

        offset += strlen(sn->id_str);
@@ -215,7 +215,7 @@ static int qcow2_write_snapshots(BlockDriverState *bs) 
        assert(id_str_size <= UINT16_MAX && name_size <= UINT16_MAX);

        h.id_str_size = cpu_to_be16(id_str_size);

        h.name_size = cpu_to_be16(name_size);

        offset = align_offset(offset, 8);

        offset = ROUND_UP(offset, 8);



        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h));

        if (ret < 0) {
@@ -441,7 +441,7 @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) 
    /* The VM state isn't needed any more in the active L1 table; in fact, it

     * hurts by causing expensive COW for the next snapshot. */

    qcow2_cluster_discard(bs, qcow2_vm_state_offset(s),

                          align_offset(sn->vm_state_size, s->cluster_size),

                          ROUND_UP(sn->vm_state_size, s->cluster_size),

                          QCOW2_DISCARD_NEVER, false);



#ifdef DEBUG_ALLOC
@@ -710,7 +710,7 @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs, 
    }

    new_l1_bytes = sn->l1_size * sizeof(uint64_t);

    new_l1_table = qemu_try_blockalign(bs->file->bs,

                                       align_offset(new_l1_bytes, 512));

                                       ROUND_UP(new_l1_bytes, 512));

    if (new_l1_table == NULL) {

        return -ENOMEM;

    }

block/qcow2.c

+7 −7
Original line number Diff line number Diff line
@@ -1379,7 +1379,7 @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags, 


    if (s->l1_size > 0) {

        s->l1_table = qemu_try_blockalign(bs->file->bs,

            align_offset(s->l1_size * sizeof(uint64_t), 512));

            ROUND_UP(s->l1_size * sizeof(uint64_t), 512));

        if (s->l1_table == NULL) {

            error_setg(errp, "Could not allocate L1 table");

            ret = -ENOMEM;
@@ -2642,19 +2642,19 @@ static int64_t qcow2_calc_prealloc_size(int64_t total_size, 
{

    int64_t meta_size = 0;

    uint64_t nl1e, nl2e;

    int64_t aligned_total_size = align_offset(total_size, cluster_size);

    int64_t aligned_total_size = ROUND_UP(total_size, cluster_size);



    /* header: 1 cluster */

    meta_size += cluster_size;



    /* total size of L2 tables */

    nl2e = aligned_total_size / cluster_size;

    nl2e = align_offset(nl2e, cluster_size / sizeof(uint64_t));

    nl2e = ROUND_UP(nl2e, cluster_size / sizeof(uint64_t));

    meta_size += nl2e * sizeof(uint64_t);



    /* total size of L1 tables */

    nl1e = nl2e * sizeof(uint64_t) / cluster_size;

    nl1e = align_offset(nl1e, cluster_size / sizeof(uint64_t));

    nl1e = ROUND_UP(nl1e, cluster_size / sizeof(uint64_t));

    meta_size += nl1e * sizeof(uint64_t);



    /* total size of refcount table and blocks */
@@ -3710,8 +3710,8 @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, 
    has_backing_file = !!optstr;

    g_free(optstr);



    virtual_size = align_offset(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

                                cluster_size);

    virtual_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);

    virtual_size = ROUND_UP(virtual_size, cluster_size);



    /* Check that virtual disk size is valid */

    l2_tables = DIV_ROUND_UP(virtual_size / cluster_size,
@@ -3731,7 +3731,7 @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs, 
            goto err;

        }



        virtual_size = align_offset(ssize, cluster_size);

        virtual_size = ROUND_UP(ssize, cluster_size);



        if (has_backing_file) {

            /* We don't how much of the backing chain is shared by the input