Commit 543d7a42 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

Merge remote-tracking branch 'mreitz/tags/pull-block-for-kevin-2016-07-13' into queue-block 



Block patches (v2) for the block queue.

# gpg: Signature made Wed Jul 13 13:41:53 2016 CEST
# gpg:                using RSA key 0x3BB14202E838ACAD
# gpg: Good signature from "Max Reitz <mreitz@redhat.com>"
# Primary key fingerprint: 91BE B60A 30DB 3E88 57D1  1829 F407 DB00 61D5 CF40
#      Subkey fingerprint: 58B3 81CE 2DC8 9CF9 9730  EE64 3BB1 4202 E838 ACAD

* mreitz/tags/pull-block-for-kevin-2016-07-13:
  iotests: Make 157 actually format-agnostic
  vvfat: Fix qcow write target driver specification
  hmp: show all of snapshot info on every block dev in output of 'info snapshots'
  hmp: use snapshot name to determine whether a snapshot is 'fully available'
  qemu-iotests: Test naming of throttling groups
  blockdev: Fix regression with the default naming of throttling groups
  vmdk: fix metadata write regression
  Improve block job rate limiting for small bandwidth values
  qcow2: Fix qcow2_get_cluster_offset()
  qemu-io: Use correct range limitations
  qcow2: Avoid making the L1 table too big
  qemu-img: Use strerror() for generic resize error

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parents 35fedb7b 42190dcc

block/commit.c

+5 −8
Original line number Diff line number Diff line
@@ -113,6 +113,7 @@ static void coroutine_fn commit_run(void *opaque) 
    CommitBlockJob *s = opaque;

    CommitCompleteData *data;

    int64_t sector_num, end;

    uint64_t delay_ns = 0;

    int ret = 0;

    int n = 0;

    void *buf = NULL;
@@ -142,10 +143,8 @@ static void coroutine_fn commit_run(void *opaque) 
    buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);



    for (sector_num = 0; sector_num < end; sector_num += n) {

        uint64_t delay_ns = 0;

        bool copy;



wait:

        /* Note that even when no rate limit is applied we need to yield

         * with no pending I/O here so that bdrv_drain_all() returns.

         */
@@ -161,12 +160,6 @@ wait: 
        copy = (ret == 1);

        trace_commit_one_iteration(s, sector_num, n, ret);

        if (copy) {

            if (s->common.speed) {

                delay_ns = ratelimit_calculate_delay(&s->limit, n);

                if (delay_ns > 0) {

                    goto wait;

                }

            }

            ret = commit_populate(s->top, s->base, sector_num, n, buf);

            bytes_written += n * BDRV_SECTOR_SIZE;

        }
@@ -182,6 +175,10 @@ wait: 
        }

        /* Publish progress */

        s->common.offset += n * BDRV_SECTOR_SIZE;



        if (copy && s->common.speed) {

            delay_ns = ratelimit_calculate_delay(&s->limit, n);

        }

    }



    ret = 0;

block/mirror.c

+3 −1
Original line number Diff line number Diff line
@@ -422,7 +422,9 @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s) 
        assert(io_sectors);

        sector_num += io_sectors;

        nb_chunks -= DIV_ROUND_UP(io_sectors, sectors_per_chunk);

        delay_ns += ratelimit_calculate_delay(&s->limit, io_sectors);

        if (s->common.speed) {

            delay_ns = ratelimit_calculate_delay(&s->limit, io_sectors);

        }

    }

    return delay_ns;

}

block/qcow2-cluster.c

+13 −6
Original line number Diff line number Diff line
@@ -65,7 +65,8 @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size, 
        }

    }



    if (new_l1_size > INT_MAX / sizeof(uint64_t)) {

    QEMU_BUILD_BUG_ON(QCOW_MAX_L1_SIZE > INT_MAX);

    if (new_l1_size > QCOW_MAX_L1_SIZE / sizeof(uint64_t)) {

        return -EFBIG;

    }
@@ -482,8 +483,8 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, 
    unsigned int l2_index;

    uint64_t l1_index, l2_offset, *l2_table;

    int l1_bits, c;

    unsigned int offset_in_cluster, nb_clusters;

    uint64_t bytes_available, bytes_needed;

    unsigned int offset_in_cluster;

    uint64_t bytes_available, bytes_needed, nb_clusters;

    int ret;



    offset_in_cluster = offset_into_cluster(s, offset);
@@ -499,7 +500,6 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, 
    if (bytes_needed > bytes_available) {

        bytes_needed = bytes_available;

    }

    assert(bytes_needed <= INT_MAX);



    *cluster_offset = 0;
@@ -536,8 +536,11 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, 
    l2_index = (offset >> s->cluster_bits) & (s->l2_size - 1);

    *cluster_offset = be64_to_cpu(l2_table[l2_index]);



    /* nb_needed <= INT_MAX, thus nb_clusters <= INT_MAX, too */

    nb_clusters = size_to_clusters(s, bytes_needed);

    /* bytes_needed <= *bytes + offset_in_cluster, both of which are unsigned

     * integers; the minimum cluster size is 512, so this assertion is always

     * true */

    assert(nb_clusters <= INT_MAX);



    ret = qcow2_get_cluster_type(*cluster_offset);

    switch (ret) {
@@ -584,13 +587,17 @@ int qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset, 


    qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);



    bytes_available = (c * s->cluster_size);

    bytes_available = (int64_t)c * s->cluster_size;



out:

    if (bytes_available > bytes_needed) {

        bytes_available = bytes_needed;

    }



    /* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;

     * subtracting offset_in_cluster will therefore definitely yield something

     * not exceeding UINT_MAX */

    assert(bytes_available - offset_in_cluster <= UINT_MAX);

    *bytes = bytes_available - offset_in_cluster;



    return ret;

block/stream.c

+4 −8
Original line number Diff line number Diff line
@@ -95,6 +95,7 @@ static void coroutine_fn stream_run(void *opaque) 
    BlockDriverState *base = s->base;

    int64_t sector_num = 0;

    int64_t end = -1;

    uint64_t delay_ns = 0;

    int error = 0;

    int ret = 0;

    int n = 0;
@@ -123,10 +124,8 @@ static void coroutine_fn stream_run(void *opaque) 
    }



    for (sector_num = 0; sector_num < end; sector_num += n) {

        uint64_t delay_ns = 0;

        bool copy;



wait:

        /* Note that even when no rate limit is applied we need to yield

         * with no pending I/O here so that bdrv_drain_all() returns.

         */
@@ -156,12 +155,6 @@ wait: 
        }

        trace_stream_one_iteration(s, sector_num, n, ret);

        if (copy) {

            if (s->common.speed) {

                delay_ns = ratelimit_calculate_delay(&s->limit, n);

                if (delay_ns > 0) {

                    goto wait;

                }

            }

            ret = stream_populate(blk, sector_num, n, buf);

        }

        if (ret < 0) {
@@ -182,6 +175,9 @@ wait: 


        /* Publish progress */

        s->common.offset += n * BDRV_SECTOR_SIZE;

        if (copy && s->common.speed) {

            delay_ns = ratelimit_calculate_delay(&s->limit, n);

        }

    }



    if (!base) {

block/vmdk.c

+7 −7
Original line number Diff line number Diff line
@@ -1202,13 +1202,6 @@ static int get_cluster_offset(BlockDriverState *bs, 
    l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;

    cluster_sector = le32_to_cpu(l2_table[l2_index]);



    if (m_data) {

        m_data->valid = 1;

        m_data->l1_index = l1_index;

        m_data->l2_index = l2_index;

        m_data->l2_offset = l2_offset;

        m_data->l2_cache_entry = &l2_table[l2_index];

    }

    if (extent->has_zero_grain && cluster_sector == VMDK_GTE_ZEROED) {

        zeroed = true;

    }
@@ -1231,6 +1224,13 @@ static int get_cluster_offset(BlockDriverState *bs, 
        if (ret) {

            return ret;

        }

        if (m_data) {

            m_data->valid = 1;

            m_data->l1_index = l1_index;

            m_data->l2_index = l2_index;

            m_data->l2_offset = l2_offset;

            m_data->l2_cache_entry = &l2_table[l2_index];

        }

    }

    *cluster_offset = cluster_sector << BDRV_SECTOR_BITS;

    return VMDK_OK;