Commit 9a33c0c8 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



# gpg: Signature made Mon 03 Nov 2014 11:50:53 GMT using RSA key ID 81AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"

* remotes/stefanha/tags/block-pull-request: (53 commits)
  block: declare blockjobs and dataplane friends!
  block: let commit blockjob run in BDS AioContext
  block: let mirror blockjob run in BDS AioContext
  block: let stream blockjob run in BDS AioContext
  block: let backup blockjob run in BDS AioContext
  block: add bdrv_drain()
  blockjob: add block_job_defer_to_main_loop()
  blockdev: add note that block_job_cb() must be thread-safe
  blockdev: acquire AioContext in blockdev_mark_auto_del()
  blockdev: acquire AioContext in do_qmp_query_block_jobs_one()
  block: acquire AioContext in generic blockjob QMP commands
  iotests: Expand test 061
  block/qcow2: Simplify shared L2 handling in amend
  block/qcow2: Make get_refcount() global
  block/qcow2: Implement status CB for amend
  qemu-img: Fix insignificant memleak
  qemu-img: Add progress output for amend
  block: Add status callback to bdrv_amend_options()
  block: qemu-iotest 107 supports NFS
  iotests: Add test for qcow2's bdrv_make_empty
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents eb5f222b b112a65c

block.c

+55 −14
Original line number Diff line number Diff line
@@ -519,6 +519,7 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) 
            return;

        }

        bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length;

        bs->bl.max_transfer_length = bs->file->bl.max_transfer_length;

        bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment;

    } else {

        bs->bl.opt_mem_alignment = 512;
@@ -533,6 +534,9 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) 
        bs->bl.opt_transfer_length =

            MAX(bs->bl.opt_transfer_length,

                bs->backing_hd->bl.opt_transfer_length);

        bs->bl.max_transfer_length =

            MIN_NON_ZERO(bs->bl.max_transfer_length,

                         bs->backing_hd->bl.max_transfer_length);

        bs->bl.opt_mem_alignment =

            MAX(bs->bl.opt_mem_alignment,

                bs->backing_hd->bl.opt_mem_alignment);
@@ -1900,6 +1904,34 @@ static bool bdrv_requests_pending(BlockDriverState *bs) 
    return false;

}



static bool bdrv_drain_one(BlockDriverState *bs)

{

    bool bs_busy;



    bdrv_flush_io_queue(bs);

    bdrv_start_throttled_reqs(bs);

    bs_busy = bdrv_requests_pending(bs);

    bs_busy |= aio_poll(bdrv_get_aio_context(bs), bs_busy);

    return bs_busy;

}



/*

 * Wait for pending requests to complete on a single BlockDriverState subtree

 *

 * See the warning in bdrv_drain_all().  This function can only be called if

 * you are sure nothing can generate I/O because you have op blockers

 * installed.

 *

 * Note that unlike bdrv_drain_all(), the caller must hold the BlockDriverState

 * AioContext.

 */

void bdrv_drain(BlockDriverState *bs)

{

    while (bdrv_drain_one(bs)) {

        /* Keep iterating */

    }

}



/*

 * Wait for pending requests to complete across all BlockDriverStates

 *
@@ -1923,16 +1955,10 @@ void bdrv_drain_all(void) 


        QTAILQ_FOREACH(bs, &bdrv_states, device_list) {

            AioContext *aio_context = bdrv_get_aio_context(bs);

            bool bs_busy;



            aio_context_acquire(aio_context);

            bdrv_flush_io_queue(bs);

            bdrv_start_throttled_reqs(bs);

            bs_busy = bdrv_requests_pending(bs);

            bs_busy |= aio_poll(aio_context, bs_busy);

            busy |= bdrv_drain_one(bs);

            aio_context_release(aio_context);



            busy |= bs_busy;

        }

    }

}
@@ -3540,10 +3566,10 @@ static void send_qmp_error_event(BlockDriverState *bs, 
                                 BlockErrorAction action,

                                 bool is_read, int error)

{

    BlockErrorAction ac;

    IoOperationType optype;



    ac = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;

    qapi_event_send_block_io_error(bdrv_get_device_name(bs), ac, action,

    optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;

    qapi_event_send_block_io_error(bdrv_get_device_name(bs), optype, action,

                                   bdrv_iostatus_is_enabled(bs),

                                   error == ENOSPC, strerror(error),

                                   &error_abort);
@@ -4442,6 +4468,11 @@ static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 
            merge = 0;

        }



        if (bs->bl.max_transfer_length && reqs[outidx].nb_sectors +

            reqs[i].nb_sectors > bs->bl.max_transfer_length) {

            merge = 0;

        }



        if (merge) {

            size_t size;

            QEMUIOVector *qiov = g_malloc0(sizeof(*qiov));
@@ -5750,12 +5781,13 @@ void bdrv_add_before_write_notifier(BlockDriverState *bs, 
    notifier_with_return_list_add(&bs->before_write_notifiers, notifier);

}



int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)

int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,

                       BlockDriverAmendStatusCB *status_cb)

{

    if (!bs->drv->bdrv_amend_options) {

        return -ENOTSUP;

    }

    return bs->drv->bdrv_amend_options(bs, opts);

    return bs->drv->bdrv_amend_options(bs, opts, status_cb);

}



/* This function will be called by the bdrv_recurse_is_first_non_filter method
@@ -5818,13 +5850,19 @@ bool bdrv_is_first_non_filter(BlockDriverState *candidate) 
BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)

{

    BlockDriverState *to_replace_bs = bdrv_find_node(node_name);

    AioContext *aio_context;



    if (!to_replace_bs) {

        error_setg(errp, "Node name '%s' not found", node_name);

        return NULL;

    }



    aio_context = bdrv_get_aio_context(to_replace_bs);

    aio_context_acquire(aio_context);



    if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {

        return NULL;

        to_replace_bs = NULL;

        goto out;

    }



    /* We don't want arbitrary node of the BDS chain to be replaced only the top
@@ -5834,9 +5872,12 @@ BlockDriverState *check_to_replace_node(const char *node_name, Error **errp) 
     */

    if (!bdrv_is_first_non_filter(to_replace_bs)) {

        error_setg(errp, "Only top most non filter can be replaced");

        return NULL;

        to_replace_bs = NULL;

        goto out;

    }



out:

    aio_context_release(aio_context);

    return to_replace_bs;

}

block/Makefile.objs

+1 −2
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ block-obj-y += block-backend.o snapshot.o qapi.o 
block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o

block-obj-$(CONFIG_POSIX) += raw-posix.o

block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o

block-obj-y += null.o

block-obj-y += null.o mirror.o



block-obj-y += nbd.o nbd-client.o sheepdog.o

block-obj-$(CONFIG_LIBISCSI) += iscsi.o
@@ -23,7 +23,6 @@ block-obj-y += accounting.o 


common-obj-y += stream.o

common-obj-y += commit.o

common-obj-y += mirror.o

common-obj-y += backup.o



iscsi.o-cflags     := $(LIBISCSI_CFLAGS)

block/backup.c

+19 −2
Original line number Diff line number Diff line
@@ -227,9 +227,25 @@ static BlockErrorAction backup_error_action(BackupBlockJob *job, 
    }

}



typedef struct {

    int ret;

} BackupCompleteData;



static void backup_complete(BlockJob *job, void *opaque)

{

    BackupBlockJob *s = container_of(job, BackupBlockJob, common);

    BackupCompleteData *data = opaque;



    bdrv_unref(s->target);



    block_job_completed(job, data->ret);

    g_free(data);

}



static void coroutine_fn backup_run(void *opaque)

{

    BackupBlockJob *job = opaque;

    BackupCompleteData *data;

    BlockDriverState *bs = job->common.bs;

    BlockDriverState *target = job->target;

    BlockdevOnError on_target_error = job->on_target_error;
@@ -344,9 +360,10 @@ static void coroutine_fn backup_run(void *opaque) 
    hbitmap_free(job->bitmap);



    bdrv_iostatus_disable(target);

    bdrv_unref(target);



    block_job_completed(&job->common, ret);

    data = g_malloc(sizeof(*data));

    data->ret = ret;

    block_job_defer_to_main_loop(&job->common, backup_complete, data);

}



void backup_start(BlockDriverState *bs, BlockDriverState *target,

block/blkdebug.c

+2 −0
Original line number Diff line number Diff line
@@ -195,6 +195,8 @@ static const char *event_names[BLKDBG_EVENT_MAX] = { 
    [BLKDBG_PWRITEV]                        = "pwritev",

    [BLKDBG_PWRITEV_ZERO]                   = "pwritev_zero",

    [BLKDBG_PWRITEV_DONE]                   = "pwritev_done",



    [BLKDBG_EMPTY_IMAGE_PREPARE]            = "empty_image_prepare",

};



static int get_event_by_name(const char *name, BlkDebugEvent *event)

block/commit.c

+44 −26
Original line number Diff line number Diff line
@@ -60,17 +60,50 @@ static int coroutine_fn commit_populate(BlockDriverState *bs, 
    return 0;

}



static void coroutine_fn commit_run(void *opaque)

typedef struct {

    int ret;

} CommitCompleteData;



static void commit_complete(BlockJob *job, void *opaque)

{

    CommitBlockJob *s = opaque;

    CommitBlockJob *s = container_of(job, CommitBlockJob, common);

    CommitCompleteData *data = opaque;

    BlockDriverState *active = s->active;

    BlockDriverState *top = s->top;

    BlockDriverState *base = s->base;

    BlockDriverState *overlay_bs;

    int ret = data->ret;



    if (!block_job_is_cancelled(&s->common) && ret == 0) {

        /* success */

        ret = bdrv_drop_intermediate(active, top, base, s->backing_file_str);

    }



    /* restore base open flags here if appropriate (e.g., change the base back

     * to r/o). These reopens do not need to be atomic, since we won't abort

     * even on failure here */

    if (s->base_flags != bdrv_get_flags(base)) {

        bdrv_reopen(base, s->base_flags, NULL);

    }

    overlay_bs = bdrv_find_overlay(active, top);

    if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {

        bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);

    }

    g_free(s->backing_file_str);

    block_job_completed(&s->common, ret);

    g_free(data);

}



static void coroutine_fn commit_run(void *opaque)

{

    CommitBlockJob *s = opaque;

    CommitCompleteData *data;

    BlockDriverState *top = s->top;

    BlockDriverState *base = s->base;

    int64_t sector_num, end;

    int ret = 0;

    int n = 0;

    void *buf;

    void *buf = NULL;

    int bytes_written = 0;

    int64_t base_len;
@@ -78,18 +111,18 @@ static void coroutine_fn commit_run(void *opaque) 




    if (s->common.len < 0) {

        goto exit_restore_reopen;

        goto out;

    }



    ret = base_len = bdrv_getlength(base);

    if (base_len < 0) {

        goto exit_restore_reopen;

        goto out;

    }



    if (base_len < s->common.len) {

        ret = bdrv_truncate(base, s->common.len);

        if (ret) {

            goto exit_restore_reopen;

            goto out;

        }

    }
@@ -128,7 +161,7 @@ wait: 
            if (s->on_error == BLOCKDEV_ON_ERROR_STOP ||

                s->on_error == BLOCKDEV_ON_ERROR_REPORT||

                (s->on_error == BLOCKDEV_ON_ERROR_ENOSPC && ret == -ENOSPC)) {

                goto exit_free_buf;

                goto out;

            } else {

                n = 0;

                continue;
@@ -140,27 +173,12 @@ wait: 


    ret = 0;



    if (!block_job_is_cancelled(&s->common) && sector_num == end) {

        /* success */

        ret = bdrv_drop_intermediate(active, top, base, s->backing_file_str);

    }



exit_free_buf:

out:

    qemu_vfree(buf);



exit_restore_reopen:

    /* restore base open flags here if appropriate (e.g., change the base back

     * to r/o). These reopens do not need to be atomic, since we won't abort

     * even on failure here */

    if (s->base_flags != bdrv_get_flags(base)) {

        bdrv_reopen(base, s->base_flags, NULL);

    }

    overlay_bs = bdrv_find_overlay(active, top);

    if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {

        bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);

    }

    g_free(s->backing_file_str);

    block_job_completed(&s->common, ret);

    data = g_malloc(sizeof(*data));

    data->ret = ret;

    block_job_defer_to_main_loop(&s->common, commit_complete, data);

}



static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)