Commit ae2f14af authored by Anthony Liguori's avatar Anthony Liguori
Browse files

qcow2: Refcount checking code cleanup (Kevin Wolf) 



This is purely cosmetical changes to make the code easier to read. Move L2
table processing from a deeply nested block to its own function, add some
comments.

Patch v2: Fix misplaced bracket causing false positives

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@7216 c046a42c-6fe2-441c-8c8c-71466251a162
parent 1585969c

block-qcow2.c

+105 −44
Original line number Diff line number Diff line
@@ -2603,50 +2603,36 @@ static int inc_refcounts(BlockDriverState *bs, 
    return errors;

}



static int check_refcounts_l1(BlockDriverState *bs,

                              uint16_t *refcount_table,

                              int refcount_table_size,

                              int64_t l1_table_offset, int l1_size,

/*

 * Increases the refcount in the given refcount table for the all clusters

 * referenced in the L2 table. While doing so, performs some checks on L2

 * entries.

 *

 * Returns the number of errors found by the checks or -errno if an internal

 * error occurred.

 */

static int check_refcounts_l2(BlockDriverState *bs,

    uint16_t *refcount_table, int refcount_table_size, int64_t l2_offset,

    int check_copied)

{

    BDRVQcowState *s = bs->opaque;

    uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2;

    int l2_size, i, j, nb_csectors, refcount;

    uint64_t *l2_table, offset;

    int i, l2_size, nb_csectors, refcount;

    int errors = 0;



    l2_table = NULL;

    l1_size2 = l1_size * sizeof(uint64_t);



    errors += inc_refcounts(bs, refcount_table, refcount_table_size,

                  l1_table_offset, l1_size2);



    l1_table = qemu_malloc(l1_size2);

    if (bdrv_pread(s->hd, l1_table_offset,

                   l1_table, l1_size2) != l1_size2)

        goto fail;

    for(i = 0;i < l1_size; i++)

        be64_to_cpus(&l1_table[i]);



    /* Read L2 table from disk */

    l2_size = s->l2_size * sizeof(uint64_t);

    l2_table = qemu_malloc(l2_size);

    for(i = 0; i < l1_size; i++) {

        l2_offset = l1_table[i];

        if (l2_offset) {

            if (check_copied) {

                refcount = get_refcount(bs, (l2_offset & ~QCOW_OFLAG_COPIED) >> s->cluster_bits);

                if ((refcount == 1) != ((l2_offset & QCOW_OFLAG_COPIED) != 0)) {

                    fprintf(stderr, "ERROR OFLAG_COPIED: l2_offset=%" PRIx64

                        " refcount=%d\n", l2_offset, refcount);

                    errors++;

                }

            }

            l2_offset &= ~QCOW_OFLAG_COPIED;



    if (bdrv_pread(s->hd, l2_offset, l2_table, l2_size) != l2_size)

        goto fail;

            for(j = 0; j < s->l2_size; j++) {

                offset = be64_to_cpu(l2_table[j]);



    /* Do the actual checks */

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

        offset = be64_to_cpu(l2_table[i]);

        if (offset != 0) {

            if (offset & QCOW_OFLAG_COMPRESSED) {

                /* Compressed clusters don't have QCOW_OFLAG_COPIED */

                if (offset & QCOW_OFLAG_COPIED) {

                    fprintf(stderr, "ERROR: cluster %" PRId64 ": "

                        "copied flag must never be set for compressed "
@@ -2654,6 +2640,8 @@ static int check_refcounts_l1(BlockDriverState *bs, 
                    offset &= ~QCOW_OFLAG_COPIED;

                    errors++;

                }



                /* Mark cluster as used */

                nb_csectors = ((offset >> s->csize_shift) &

                               s->csize_mask) + 1;

                offset &= s->cluster_offset_mask;
@@ -2661,14 +2649,19 @@ static int check_refcounts_l1(BlockDriverState *bs, 
                              refcount_table_size,

                              offset & ~511, nb_csectors * 512);

            } else {

                /* QCOW_OFLAG_COPIED must be set iff refcount == 1 */

                if (check_copied) {

                            refcount = get_refcount(bs, (offset & ~QCOW_OFLAG_COPIED) >> s->cluster_bits);

                            if ((refcount == 1) != ((offset & QCOW_OFLAG_COPIED) != 0)) {

                    uint64_t entry = offset;

                    offset &= ~QCOW_OFLAG_COPIED;

                    refcount = get_refcount(bs, offset >> s->cluster_bits);

                    if ((refcount == 1) != ((entry & QCOW_OFLAG_COPIED) != 0)) {

                        fprintf(stderr, "ERROR OFLAG_COPIED: offset=%"

                                    PRIx64 " refcount=%d\n", offset, refcount);

                            PRIx64 " refcount=%d\n", entry, refcount);

                        errors++;

                    }

                }



                /* Mark cluster as used */

                offset &= ~QCOW_OFLAG_COPIED;

                errors += inc_refcounts(bs, refcount_table,

                              refcount_table_size,
@@ -2676,19 +2669,86 @@ static int check_refcounts_l1(BlockDriverState *bs, 
            }

        }

    }



    qemu_free(l2_table);

    return errors;



fail:

    fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");

    qemu_free(l2_table);

    return -EIO;

}



/*

 * Increases the refcount for the L1 table, its L2 tables and all referenced

 * clusters in the given refcount table. While doing so, performs some checks

 * on L1 and L2 entries.

 *

 * Returns the number of errors found by the checks or -errno if an internal

 * error occurred.

 */

static int check_refcounts_l1(BlockDriverState *bs,

                              uint16_t *refcount_table,

                              int refcount_table_size,

                              int64_t l1_table_offset, int l1_size,

                              int check_copied)

{

    BDRVQcowState *s = bs->opaque;

    uint64_t *l1_table, l2_offset, l1_size2;

    int i, refcount, ret;

    int errors = 0;



    l1_size2 = l1_size * sizeof(uint64_t);



    /* Mark L1 table as used */

    errors += inc_refcounts(bs, refcount_table, refcount_table_size,

                  l1_table_offset, l1_size2);



    /* Read L1 table entries from disk */

    l1_table = qemu_malloc(l1_size2);

    if (bdrv_pread(s->hd, l1_table_offset,

                   l1_table, l1_size2) != l1_size2)

        goto fail;

    for(i = 0;i < l1_size; i++)

        be64_to_cpus(&l1_table[i]);



    /* Do the actual checks */

    for(i = 0; i < l1_size; i++) {

        l2_offset = l1_table[i];

        if (l2_offset) {

            /* QCOW_OFLAG_COPIED must be set iff refcount == 1 */

            if (check_copied) {

                refcount = get_refcount(bs, (l2_offset & ~QCOW_OFLAG_COPIED)

                    >> s->cluster_bits);

                if ((refcount == 1) != ((l2_offset & QCOW_OFLAG_COPIED) != 0)) {

                    fprintf(stderr, "ERROR OFLAG_COPIED: l2_offset=%" PRIx64

                        " refcount=%d\n", l2_offset, refcount);

                    errors++;

                }

            }



            /* Mark L2 table as used */

            l2_offset &= ~QCOW_OFLAG_COPIED;

            errors += inc_refcounts(bs, refcount_table,

                          refcount_table_size,

                          l2_offset,

                          s->cluster_size);



            /* Process and check L2 entries */

            ret = check_refcounts_l2(bs, refcount_table, refcount_table_size,

                l2_offset, check_copied);

            if (ret < 0) {

                goto fail;

            }

            errors += ret;

        }

    }

    qemu_free(l1_table);

    qemu_free(l2_table);

    return errors;



fail:

    fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");

    qemu_free(l1_table);

    qemu_free(l2_table);

    return -EIO;

}
@@ -2715,6 +2775,7 @@ static int check_refcounts(BlockDriverState *bs) 
    errors += inc_refcounts(bs, refcount_table, nb_clusters,

                  0, s->cluster_size);



    /* current L1 table */

    ret = check_refcounts_l1(bs, refcount_table, nb_clusters,

                       s->l1_table_offset, s->l1_size, 1);

    if (ret < 0) {