Commit ad54ae80 authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Kevin Wolf
Browse files

block: bdrv_aio_* do not return NULL 



Initially done with the following semantic patch:

@ rule1 @
expression E;
statement S;
@@
  E =
(
   bdrv_aio_readv
|  bdrv_aio_writev
|  bdrv_aio_flush
|  bdrv_aio_discard
|  bdrv_aio_ioctl
)
     (...);
(
- if (E == NULL) { ... }
|
- if (E)
    { <... S ...> }
)

which however missed the occurrence in block/blkverify.c
(as it should have done), and left behind some unused
variables.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 222f23f5

block-migration.c

+0 −13
Original line number Diff line number Diff line
@@ -251,22 +251,12 @@ static int mig_save_device_bulk(Monitor *mon, QEMUFile *f, 


    blk->aiocb = bdrv_aio_readv(bs, cur_sector, &blk->qiov,

                                nr_sectors, blk_mig_read_cb, blk);

    if (!blk->aiocb) {

        goto error;

    }

    block_mig_state.submitted++;



    bdrv_reset_dirty(bs, cur_sector, nr_sectors);

    bmds->cur_sector = cur_sector + nr_sectors;



    return (bmds->cur_sector >= total_sectors);



error:

    monitor_printf(mon, "Error reading sector %" PRId64 "\n", cur_sector);

    qemu_file_set_error(f, -EIO);

    g_free(blk->buf);

    g_free(blk);

    return 0;

}



static void set_dirty_tracking(int enable)
@@ -413,9 +403,6 @@ static int mig_save_device_dirty(Monitor *mon, QEMUFile *f, 


                blk->aiocb = bdrv_aio_readv(bmds->bs, sector, &blk->qiov,

                                            nr_sectors, blk_mig_read_cb, blk);

                if (!blk->aiocb) {

                    goto error;

                }

                block_mig_state.submitted++;

                bmds_set_aio_inflight(bmds, sector, nr_sectors, 1);

            } else {

block.c

+1 −23
Original line number Diff line number Diff line
@@ -2812,7 +2812,6 @@ static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 
 */

int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)

{

    BlockDriverAIOCB *acb;

    MultiwriteCB *mcb;

    int i;
@@ -2867,35 +2866,14 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 
    // Run the aio requests

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

        mcb->num_requests++;

        acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,

        bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov,

            reqs[i].nb_sectors, multiwrite_cb, mcb);



        if (acb == NULL) {

            // We can only fail the whole thing if no request has been

            // submitted yet. Otherwise we'll wait for the submitted AIOs to

            // complete and report the error in the callback.

            if (i == 0) {

                trace_bdrv_aio_multiwrite_earlyfail(mcb);

                goto fail;

            } else {

                trace_bdrv_aio_multiwrite_latefail(mcb, i);

                multiwrite_cb(mcb, -EIO);

                break;

            }

        }

    }



    /* Complete the dummy request */

    multiwrite_cb(mcb, 0);



    return 0;



fail:

    for (i = 0; i < mcb->num_callbacks; i++) {

        reqs[i].error = -EIO;

    }

    g_free(mcb);

    return -1;

}



void bdrv_aio_cancel(BlockDriverAIOCB *acb)

block/blkverify.c

+8 −16
Original line number Diff line number Diff line
@@ -310,14 +310,10 @@ static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs, 
    qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);

    blkverify_iovec_clone(&acb->raw_qiov, qiov, acb->buf);



    if (!bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,

                        blkverify_aio_cb, acb)) {

        blkverify_aio_cb(acb, -EIO);

    }

    if (!bdrv_aio_readv(bs->file, sector_num, &acb->raw_qiov, nb_sectors,

                        blkverify_aio_cb, acb)) {

        blkverify_aio_cb(acb, -EIO);

    }

    bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,

                   blkverify_aio_cb, acb);

    bdrv_aio_readv(bs->file, sector_num, &acb->raw_qiov, nb_sectors,

                   blkverify_aio_cb, acb);

    return &acb->common;

}
@@ -329,14 +325,10 @@ static BlockDriverAIOCB *blkverify_aio_writev(BlockDriverState *bs, 
    BlkverifyAIOCB *acb = blkverify_aio_get(bs, true, sector_num, qiov,

                                            nb_sectors, cb, opaque);



    if (!bdrv_aio_writev(s->test_file, sector_num, qiov, nb_sectors,

                         blkverify_aio_cb, acb)) {

        blkverify_aio_cb(acb, -EIO);

    }

    if (!bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,

                         blkverify_aio_cb, acb)) {

        blkverify_aio_cb(acb, -EIO);

    }

    bdrv_aio_writev(s->test_file, sector_num, qiov, nb_sectors,

                    blkverify_aio_cb, acb);

    bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,

                    blkverify_aio_cb, acb);

    return &acb->common;

}

block/qed-table.c

+7 −15
Original line number Diff line number Diff line
@@ -54,7 +54,6 @@ static void qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, 
    QEDReadTableCB *read_table_cb = gencb_alloc(sizeof(*read_table_cb),

                                                cb, opaque);

    QEMUIOVector *qiov = &read_table_cb->qiov;

    BlockDriverAIOCB *aiocb;



    trace_qed_read_table(s, offset, table);
@@ -64,12 +63,9 @@ static void qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, 
    read_table_cb->iov.iov_len = s->header.cluster_size * s->header.table_size,



    qemu_iovec_init_external(qiov, &read_table_cb->iov, 1);

    aiocb = bdrv_aio_readv(s->bs->file, offset / BDRV_SECTOR_SIZE, qiov,

    bdrv_aio_readv(s->bs->file, offset / BDRV_SECTOR_SIZE, qiov,

                   qiov->size / BDRV_SECTOR_SIZE,

                   qed_read_table_cb, read_table_cb);

    if (!aiocb) {

        qed_read_table_cb(read_table_cb, -EIO);

    }

}



typedef struct {
@@ -127,7 +123,6 @@ static void qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, 
                            BlockDriverCompletionFunc *cb, void *opaque)

{

    QEDWriteTableCB *write_table_cb;

    BlockDriverAIOCB *aiocb;

    unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;

    unsigned int start, end, i;

    size_t len_bytes;
@@ -158,13 +153,10 @@ static void qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table, 
    /* Adjust for offset into table */

    offset += start * sizeof(uint64_t);



    aiocb = bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE,

    bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE,

                    &write_table_cb->qiov,

                    write_table_cb->qiov.size / BDRV_SECTOR_SIZE,

                    qed_write_table_cb, write_table_cb);

    if (!aiocb) {

        qed_write_table_cb(write_table_cb, -EIO);

    }

}



/**

block/qed.c

+16 −44
Original line number Diff line number Diff line
@@ -123,7 +123,6 @@ static void qed_write_header_read_cb(void *opaque, int ret) 
{

    QEDWriteHeaderCB *write_header_cb = opaque;

    BDRVQEDState *s = write_header_cb->s;

    BlockDriverAIOCB *acb;



    if (ret) {

        qed_write_header_cb(write_header_cb, ret);
@@ -133,12 +132,9 @@ static void qed_write_header_read_cb(void *opaque, int ret) 
    /* Update header */

    qed_header_cpu_to_le(&s->header, (QEDHeader *)write_header_cb->buf);



    acb = bdrv_aio_writev(s->bs->file, 0, &write_header_cb->qiov,

    bdrv_aio_writev(s->bs->file, 0, &write_header_cb->qiov,

                    write_header_cb->nsectors, qed_write_header_cb,

                    write_header_cb);

    if (!acb) {

        qed_write_header_cb(write_header_cb, -EIO);

    }

}



/**
@@ -156,7 +152,6 @@ static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, 
     * them, and write back.

     */



    BlockDriverAIOCB *acb;

    int nsectors = (sizeof(QEDHeader) + BDRV_SECTOR_SIZE - 1) /

                   BDRV_SECTOR_SIZE;

    size_t len = nsectors * BDRV_SECTOR_SIZE;
@@ -170,11 +165,8 @@ static void qed_write_header(BDRVQEDState *s, BlockDriverCompletionFunc cb, 
    write_header_cb->iov.iov_len = len;

    qemu_iovec_init_external(&write_header_cb->qiov, &write_header_cb->iov, 1);



    acb = bdrv_aio_readv(s->bs->file, 0, &write_header_cb->qiov, nsectors,

    bdrv_aio_readv(s->bs->file, 0, &write_header_cb->qiov, nsectors,

                   qed_write_header_read_cb, write_header_cb);

    if (!acb) {

        qed_write_header_cb(write_header_cb, -EIO);

    }

}



static uint64_t qed_max_image_size(uint32_t cluster_size, uint32_t table_size)
@@ -728,7 +720,6 @@ static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, 
                                  QEMUIOVector *qiov,

                                  BlockDriverCompletionFunc *cb, void *opaque)

{

    BlockDriverAIOCB *aiocb;

    uint64_t backing_length = 0;

    size_t size;
@@ -760,11 +751,8 @@ static void qed_read_backing_file(BDRVQEDState *s, uint64_t pos, 
    size = MIN((uint64_t)backing_length - pos, qiov->size);



    BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING);

    aiocb = bdrv_aio_readv(s->bs->backing_hd, pos / BDRV_SECTOR_SIZE,

    bdrv_aio_readv(s->bs->backing_hd, pos / BDRV_SECTOR_SIZE,

                   qiov, size / BDRV_SECTOR_SIZE, cb, opaque);

    if (!aiocb) {

        cb(opaque, -EIO);

    }

}



typedef struct {
@@ -786,7 +774,6 @@ static void qed_copy_from_backing_file_write(void *opaque, int ret) 
{

    CopyFromBackingFileCB *copy_cb = opaque;

    BDRVQEDState *s = copy_cb->s;

    BlockDriverAIOCB *aiocb;



    if (ret) {

        qed_copy_from_backing_file_cb(copy_cb, ret);
@@ -794,13 +781,9 @@ static void qed_copy_from_backing_file_write(void *opaque, int ret) 
    }



    BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);

    aiocb = bdrv_aio_writev(s->bs->file, copy_cb->offset / BDRV_SECTOR_SIZE,

                            &copy_cb->qiov,

                            copy_cb->qiov.size / BDRV_SECTOR_SIZE,

    bdrv_aio_writev(s->bs->file, copy_cb->offset / BDRV_SECTOR_SIZE,

                    &copy_cb->qiov, copy_cb->qiov.size / BDRV_SECTOR_SIZE,

                    qed_copy_from_backing_file_cb, copy_cb);

    if (!aiocb) {

        qed_copy_from_backing_file_cb(copy_cb, -EIO);

    }

}



/**
@@ -1022,7 +1005,6 @@ static void qed_aio_write_main(void *opaque, int ret) 
    uint64_t offset = acb->cur_cluster +

                      qed_offset_into_cluster(s, acb->cur_pos);

    BlockDriverCompletionFunc *next_fn;

    BlockDriverAIOCB *file_acb;



    trace_qed_aio_write_main(s, acb, ret, offset, acb->cur_qiov.size);
@@ -1042,13 +1024,9 @@ static void qed_aio_write_main(void *opaque, int ret) 
    }



    BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);

    file_acb = bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE,

                               &acb->cur_qiov,

                               acb->cur_qiov.size / BDRV_SECTOR_SIZE,

    bdrv_aio_writev(s->bs->file, offset / BDRV_SECTOR_SIZE,

                    &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,

                    next_fn, acb);

    if (!file_acb) {

        qed_aio_complete(acb, -EIO);

    }

}



/**
@@ -1215,7 +1193,6 @@ static void qed_aio_read_data(void *opaque, int ret, 
    QEDAIOCB *acb = opaque;

    BDRVQEDState *s = acb_to_s(acb);

    BlockDriverState *bs = acb->common.bs;

    BlockDriverAIOCB *file_acb;



    /* Adjust offset into cluster */

    offset += qed_offset_into_cluster(s, acb->cur_pos);
@@ -1240,14 +1217,9 @@ static void qed_aio_read_data(void *opaque, int ret, 
    }



    BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

    file_acb = bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE,

                              &acb->cur_qiov,

                              acb->cur_qiov.size / BDRV_SECTOR_SIZE,

    bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE,

                   &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,

                   qed_aio_next_io, acb);

    if (!file_acb) {

        ret = -EIO;

        goto err;

    }

    return;



err: