Commit c1b94a0e authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block patches for 2.0.0-rc1

# gpg: Signature made Wed 19 Mar 2014 13:03:27 GMT using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream:
  dataplane: fix implicit IOThread refcount
  block/nfs: report errors from libnfs
  block/nfs: bump libnfs requirement to 1.9.3
  qcow2: Fix fail path in realloc_refcount_block()
  qcow2: Correct comment for realloc_refcount_block()
  qemu-io: Extended "--cmd" description in usage text
  qemu-io-cmds: Fixed typo in example for writev.
  block: Add error handling to bdrv_invalidate_cache()

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 319c66d5 198fd05c

block.c

+22 −6
Original line number Diff line number Diff line
@@ -4781,27 +4781,43 @@ flush_parent: 
    return bdrv_co_flush(bs->file);

}



void bdrv_invalidate_cache(BlockDriverState *bs)

void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)

{

    Error *local_err = NULL;

    int ret;



    if (!bs->drv)  {

        return;

    }



    if (bs->drv->bdrv_invalidate_cache) {

        bs->drv->bdrv_invalidate_cache(bs);

        bs->drv->bdrv_invalidate_cache(bs, &local_err);

    } else if (bs->file) {

        bdrv_invalidate_cache(bs->file);

        bdrv_invalidate_cache(bs->file, &local_err);

    }

    if (local_err) {

        error_propagate(errp, local_err);

        return;

    }



    refresh_total_sectors(bs, bs->total_sectors);

    ret = refresh_total_sectors(bs, bs->total_sectors);

    if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not refresh total sector count");

        return;

    }

}



void bdrv_invalidate_cache_all(void)

void bdrv_invalidate_cache_all(Error **errp)

{

    BlockDriverState *bs;

    Error *local_err = NULL;



    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {

        bdrv_invalidate_cache(bs);

        bdrv_invalidate_cache(bs, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            return;

        }

    }

}

block/nfs.c

+3 −0
Original line number Diff line number Diff line
@@ -112,6 +112,9 @@ nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data, 
    if (task->ret == 0 && task->st) {

        memcpy(task->st, data, sizeof(struct stat));

    }

    if (task->ret < 0) {

        error_report("NFS Error: %s", nfs_get_error(nfs));

    }

    if (task->co) {

        task->bh = qemu_bh_new(nfs_co_generic_bh_cb, task);

        qemu_bh_schedule(task->bh);

block/qcow2-refcount.c

+19 −17
Original line number Diff line number Diff line
@@ -1383,7 +1383,7 @@ static int write_reftable_entry(BlockDriverState *bs, int rt_index) 
 * does _not_ decrement the reference count for the currently occupied cluster.

 *

 * This function prints an informative message to stderr on error (and returns

 * -errno); on success, 0 is returned.

 * -errno); on success, the offset of the newly allocated cluster is returned.

 */

static int64_t realloc_refcount_block(BlockDriverState *bs, int reftable_index,

                                      uint64_t offset)
@@ -1399,14 +1399,14 @@ static int64_t realloc_refcount_block(BlockDriverState *bs, int reftable_index, 
        fprintf(stderr, "Could not allocate new cluster: %s\n",

                strerror(-new_offset));

        ret = new_offset;

        goto fail;

        goto done;

    }



    /* fetch current refcount block content */

    ret = qcow2_cache_get(bs, s->refcount_block_cache, offset, &refcount_block);

    if (ret < 0) {

        fprintf(stderr, "Could not fetch refcount block: %s\n", strerror(-ret));

        goto fail;

        goto fail_free_cluster;

    }



    /* new block has not yet been entered into refcount table, therefore it is
@@ -1417,8 +1417,7 @@ static int64_t realloc_refcount_block(BlockDriverState *bs, int reftable_index, 
                "check failed: %s\n", strerror(-ret));

        /* the image will be marked corrupt, so don't even attempt on freeing

         * the cluster */

        new_offset = 0;

        goto fail;

        goto done;

    }



    /* write to new block */
@@ -1426,7 +1425,7 @@ static int64_t realloc_refcount_block(BlockDriverState *bs, int reftable_index, 
            s->cluster_sectors);

    if (ret < 0) {

        fprintf(stderr, "Could not write refcount block: %s\n", strerror(-ret));

        goto fail;

        goto fail_free_cluster;

    }



    /* update refcount table */
@@ -1436,24 +1435,27 @@ static int64_t realloc_refcount_block(BlockDriverState *bs, int reftable_index, 
    if (ret < 0) {

        fprintf(stderr, "Could not update refcount table: %s\n",

                strerror(-ret));

        goto fail;

        goto fail_free_cluster;

    }



fail:

    if (new_offset && (ret < 0)) {

        qcow2_free_clusters(bs, new_offset, s->cluster_size,

                QCOW2_DISCARD_ALWAYS);

    }

    goto done;



fail_free_cluster:

    qcow2_free_clusters(bs, new_offset, s->cluster_size, QCOW2_DISCARD_OTHER);



done:

    if (refcount_block) {

        if (ret < 0) {

            qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);

        } else {

            ret = qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);

        }

        /* This should never fail, as it would only do so if the given refcount

         * block cannot be found in the cache. As this is impossible as long as

         * there are no bugs, assert the success. */

        int tmp = qcow2_cache_put(bs, s->refcount_block_cache, &refcount_block);

        assert(tmp == 0);

    }



    if (ret < 0) {

        return ret;

    }



    return new_offset;

}

block/qcow2.c

+19 −3
Original line number Diff line number Diff line
@@ -1156,7 +1156,7 @@ static void qcow2_close(BlockDriverState *bs) 
    qcow2_free_snapshots(bs);

}



static void qcow2_invalidate_cache(BlockDriverState *bs)

static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)

{

    BDRVQcowState *s = bs->opaque;

    int flags = s->flags;
@@ -1164,6 +1164,8 @@ static void qcow2_invalidate_cache(BlockDriverState *bs) 
    AES_KEY aes_decrypt_key;

    uint32_t crypt_method = 0;

    QDict *options;

    Error *local_err = NULL;

    int ret;



    /*

     * Backing files are read-only which makes all of their metadata immutable,
@@ -1178,11 +1180,25 @@ static void qcow2_invalidate_cache(BlockDriverState *bs) 


    qcow2_close(bs);



    bdrv_invalidate_cache(bs->file);

    bdrv_invalidate_cache(bs->file, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

        return;

    }



    memset(s, 0, sizeof(BDRVQcowState));

    options = qdict_clone_shallow(bs->options);

    qcow2_open(bs, options, flags, NULL);



    ret = qcow2_open(bs, options, flags, &local_err);

    if (local_err) {

        error_setg(errp, "Could not reopen qcow2 layer: %s",

                   error_get_pretty(local_err));

        error_free(local_err);

        return;

    } else if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not reopen qcow2 layer");

        return;

    }



    QDECREF(options);

block/qed.c

+18 −3
Original line number Diff line number Diff line
@@ -1558,16 +1558,31 @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs, 
    return ret;

}



static void bdrv_qed_invalidate_cache(BlockDriverState *bs)

static void bdrv_qed_invalidate_cache(BlockDriverState *bs, Error **errp)

{

    BDRVQEDState *s = bs->opaque;

    Error *local_err = NULL;

    int ret;



    bdrv_qed_close(bs);



    bdrv_invalidate_cache(bs->file);

    bdrv_invalidate_cache(bs->file, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

        return;

    }



    memset(s, 0, sizeof(BDRVQEDState));

    bdrv_qed_open(bs, NULL, bs->open_flags, NULL);

    ret = bdrv_qed_open(bs, NULL, bs->open_flags, &local_err);

    if (local_err) {

        error_setg(errp, "Could not reopen qed layer: %s",

                   error_get_pretty(local_err));

        error_free(local_err);

        return;

    } else if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not reopen qed layer");

        return;

    }

}



static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result,