Commit e0d37956 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 Fri 12 Dec 2014 17:09:56 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:
  linux-aio: simplify removal of completed iocbs from the list
  linux-aio: drop return code from laio_io_unplug and ioq_submit
  linux-aio: rename LaioQueue idx field to "n"
  linux-aio: track whether the queue is blocked
  linux-aio: queue requests that cannot be submitted
  block: drop unused bdrv_clear_incoming_migration_all() prototype
  block: Don't add trailing space in "Formating..." message
  qemu-iotests: Remove traling whitespaces in *.out
  block: vhdx - set .bdrv_has_zero_init to bdrv_has_zero_init_1
  iotests: Fix test 039
  iotests: Filter for "Killed" in qemu-io output
  qemu-io: Add sigraise command
  block: vhdx - change .vhdx_create default block state to ZERO
  block: vhdx - update PAYLOAD_BLOCK_UNMAPPED value to match 1.00 spec
  block: vhdx - remove redundant comments
  block/rbd: fix memory leak
  iotests: Add test for vmdk JSON file names
  vmdk: Fix error for JSON descriptor file names
  block migration: fix return value

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 99c9c3cb 82595da8

block-migration.c

+9 −1
Original line number Diff line number Diff line
@@ -653,6 +653,7 @@ static int block_save_iterate(QEMUFile *f, void *opaque) 
{

    int ret;

    int64_t last_ftell = qemu_ftell(f);

    int64_t delta_ftell;



    DPRINTF("Enter save live iterate submitted %d transferred %d\n",

            block_mig_state.submitted, block_mig_state.transferred);
@@ -702,7 +703,14 @@ static int block_save_iterate(QEMUFile *f, void *opaque) 
    }



    qemu_put_be64(f, BLK_MIG_FLAG_EOS);

    return qemu_ftell(f) - last_ftell;

    delta_ftell = qemu_ftell(f) - last_ftell;

    if (delta_ftell > 0) {

        return 1;

    } else if (delta_ftell < 0) {

        return -1;

    } else {

        return 0;

    }

}



/* Called with iothread lock taken.  */

block.c

+3 −3
Original line number Diff line number Diff line
@@ -229,7 +229,7 @@ size_t bdrv_opt_mem_align(BlockDriverState *bs) 
}



/* check if the path starts with "<protocol>:" */

static int path_has_protocol(const char *path)

int path_has_protocol(const char *path)

{

    const char *p;
@@ -5669,7 +5669,7 @@ void bdrv_img_create(const char *filename, const char *fmt, 


    if (!quiet) {

        printf("Formatting '%s', fmt=%s", filename, fmt);

        qemu_opts_print(opts);

        qemu_opts_print(opts, " ");

        puts("");

    }

block/linux-aio.c

+46 −53
Original line number Diff line number Diff line
@@ -35,14 +35,14 @@ struct qemu_laiocb { 
    size_t nbytes;

    QEMUIOVector *qiov;

    bool is_read;

    QLIST_ENTRY(qemu_laiocb) node;

    QSIMPLEQ_ENTRY(qemu_laiocb) next;

};



typedef struct {

    struct iocb *iocbs[MAX_QUEUED_IO];

    int plugged;

    unsigned int size;

    unsigned int idx;

    unsigned int n;

    bool blocked;

    QSIMPLEQ_HEAD(, qemu_laiocb) pending;

} LaioQueue;



struct qemu_laio_state {
@@ -59,6 +59,8 @@ struct qemu_laio_state { 
    int event_max;

};



static void ioq_submit(struct qemu_laio_state *s);



static inline ssize_t io_event_ret(struct io_event *ev)

{

    return (ssize_t)(((uint64_t)ev->res2 << 32) | ev->res);
@@ -135,6 +137,10 @@ static void qemu_laio_completion_bh(void *opaque) 


        qemu_laio_process_completion(s, laiocb);

    }



    if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {

        ioq_submit(s);

    }

}



static void qemu_laio_completion_cb(EventNotifier *e)
@@ -172,50 +178,41 @@ static const AIOCBInfo laio_aiocb_info = { 


static void ioq_init(LaioQueue *io_q)

{

    io_q->size = MAX_QUEUED_IO;

    io_q->idx = 0;

    QSIMPLEQ_INIT(&io_q->pending);

    io_q->plugged = 0;

    io_q->n = 0;

    io_q->blocked = false;

}



static int ioq_submit(struct qemu_laio_state *s)

static void ioq_submit(struct qemu_laio_state *s)

{

    int ret, i = 0;

    int len = s->io_q.idx;

    int ret, len;

    struct qemu_laiocb *aiocb;

    struct iocb *iocbs[MAX_QUEUED_IO];

    QSIMPLEQ_HEAD(, qemu_laiocb) completed;



    do {

        ret = io_submit(s->ctx, len, s->io_q.iocbs);

    } while (i++ < 3 && ret == -EAGAIN);



    /* empty io queue */

    s->io_q.idx = 0;



    if (ret < 0) {

        i = 0;

    } else {

        i = ret;

        len = 0;

        QSIMPLEQ_FOREACH(aiocb, &s->io_q.pending, next) {

            iocbs[len++] = &aiocb->iocb;

            if (len == MAX_QUEUED_IO) {

                break;

            }

        }



    for (; i < len; i++) {

        struct qemu_laiocb *laiocb =

            container_of(s->io_q.iocbs[i], struct qemu_laiocb, iocb);



        laiocb->ret = (ret < 0) ? ret : -EIO;

        qemu_laio_process_completion(s, laiocb);

        ret = io_submit(s->ctx, len, iocbs);

        if (ret == -EAGAIN) {

            break;

        }

    return ret;

        if (ret < 0) {

            abort();

        }



static void ioq_enqueue(struct qemu_laio_state *s, struct iocb *iocb)

{

    unsigned int idx = s->io_q.idx;



    s->io_q.iocbs[idx++] = iocb;

    s->io_q.idx = idx;



    /* submit immediately if queue is full */

    if (idx == s->io_q.size) {

        ioq_submit(s);

    }

        s->io_q.n -= ret;

        aiocb = container_of(iocbs[ret - 1], struct qemu_laiocb, iocb);

        QSIMPLEQ_SPLIT_AFTER(&s->io_q.pending, aiocb, next, &completed);

    } while (ret == len && !QSIMPLEQ_EMPTY(&s->io_q.pending));

    s->io_q.blocked = (s->io_q.n > 0);

}



void laio_io_plug(BlockDriverState *bs, void *aio_ctx)
@@ -225,22 +222,19 @@ void laio_io_plug(BlockDriverState *bs, void *aio_ctx) 
    s->io_q.plugged++;

}



int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug)

void laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug)

{

    struct qemu_laio_state *s = aio_ctx;

    int ret = 0;



    assert(s->io_q.plugged > 0 || !unplug);



    if (unplug && --s->io_q.plugged > 0) {

        return 0;

        return;

    }



    if (s->io_q.idx > 0) {

        ret = ioq_submit(s);

    if (!s->io_q.blocked && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {

        ioq_submit(s);

    }



    return ret;

}



BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd,
@@ -276,12 +270,11 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, 
    }

    io_set_eventfd(&laiocb->iocb, event_notifier_get_fd(&s->e));



    if (!s->io_q.plugged) {

        if (io_submit(s->ctx, 1, &iocbs) < 0) {

            goto out_free_aiocb;

        }

    } else {

        ioq_enqueue(s, iocbs);

    QSIMPLEQ_INSERT_TAIL(&s->io_q.pending, laiocb, next);

    s->io_q.n++;

    if (!s->io_q.blocked &&

        (!s->io_q.plugged || s->io_q.n >= MAX_QUEUED_IO)) {

        ioq_submit(s);

    }

    return &laiocb->common;

block/raw-aio.h

+1 −1
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, 
void laio_detach_aio_context(void *s, AioContext *old_context);

void laio_attach_aio_context(void *s, AioContext *new_context);

void laio_io_plug(BlockDriverState *bs, void *aio_ctx);

int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug);

void laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug);

#endif



#ifdef _WIN32

block/rbd.c

+4 −4
Original line number Diff line number Diff line
@@ -459,7 +459,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 
    clientname = qemu_rbd_parse_clientname(conf, clientname_buf);

    r = rados_create(&s->cluster, clientname);

    if (r < 0) {

        error_setg(&local_err, "error initializing");

        error_setg(errp, "error initializing");

        goto failed_opts;

    }
@@ -495,19 +495,19 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 


    r = rados_connect(s->cluster);

    if (r < 0) {

        error_setg(&local_err, "error connecting");

        error_setg(errp, "error connecting");

        goto failed_shutdown;

    }



    r = rados_ioctx_create(s->cluster, pool, &s->io_ctx);

    if (r < 0) {

        error_setg(&local_err, "error opening pool %s", pool);

        error_setg(errp, "error opening pool %s", pool);

        goto failed_shutdown;

    }



    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);

    if (r < 0) {

        error_setg(&local_err, "error reading header from %s", s->name);

        error_setg(errp, "error reading header from %s", s->name);

        goto failed_open;

    }