Commit 91c6e4b7 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

block: Remove bdrv_aio_multiwrite() 



Since virtio-blk implements request merging itself these days, the only
remaining users are test cases for the function. That doesn't make the
function exactly useful any more.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
parent 66a0fae4

block/block-backend.c

+0 −14
Original line number Diff line number Diff line
@@ -1067,20 +1067,6 @@ void blk_aio_cancel_async(BlockAIOCB *acb) 
    bdrv_aio_cancel_async(acb);

}



int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)

{

    int i, ret;



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

        ret = blk_check_request(blk, reqs[i].sector, reqs[i].nb_sectors);

        if (ret < 0) {

            return ret;

        }

    }



    return bdrv_aio_multiwrite(blk_bs(blk), reqs, num_reqs);

}



int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)

{

    if (!blk_is_available(blk)) {

block/io.c

+0 −194
Original line number Diff line number Diff line
@@ -1878,200 +1878,6 @@ BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, 
                                 cb, opaque, true);

}





typedef struct MultiwriteCB {

    int error;

    int num_requests;

    int num_callbacks;

    struct {

        BlockCompletionFunc *cb;

        void *opaque;

        QEMUIOVector *free_qiov;

    } callbacks[];

} MultiwriteCB;



static void multiwrite_user_cb(MultiwriteCB *mcb)

{

    int i;



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

        mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error);

        if (mcb->callbacks[i].free_qiov) {

            qemu_iovec_destroy(mcb->callbacks[i].free_qiov);

        }

        g_free(mcb->callbacks[i].free_qiov);

    }

}



static void multiwrite_cb(void *opaque, int ret)

{

    MultiwriteCB *mcb = opaque;



    trace_multiwrite_cb(mcb, ret);



    if (ret < 0 && !mcb->error) {

        mcb->error = ret;

    }



    mcb->num_requests--;

    if (mcb->num_requests == 0) {

        multiwrite_user_cb(mcb);

        g_free(mcb);

    }

}



static int multiwrite_req_compare(const void *a, const void *b)

{

    const BlockRequest *req1 = a, *req2 = b;



    /*

     * Note that we can't simply subtract req2->sector from req1->sector

     * here as that could overflow the return value.

     */

    if (req1->sector > req2->sector) {

        return 1;

    } else if (req1->sector < req2->sector) {

        return -1;

    } else {

        return 0;

    }

}



/*

 * Takes a bunch of requests and tries to merge them. Returns the number of

 * requests that remain after merging.

 */

static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,

    int num_reqs, MultiwriteCB *mcb)

{

    int i, outidx;



    // Sort requests by start sector

    qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare);



    // Check if adjacent requests touch the same clusters. If so, combine them,

    // filling up gaps with zero sectors.

    outidx = 0;

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

        int merge = 0;

        int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors;



        // Handle exactly sequential writes and overlapping writes.

        if (reqs[i].sector <= oldreq_last) {

            merge = 1;

        }



        if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 >

            bs->bl.max_iov) {

            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));

            qemu_iovec_init(qiov,

                reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1);



            // Add the first request to the merged one. If the requests are

            // overlapping, drop the last sectors of the first request.

            size = (reqs[i].sector - reqs[outidx].sector) << 9;

            qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size);



            // We should need to add any zeros between the two requests

            assert (reqs[i].sector <= oldreq_last);



            // Add the second request

            qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size);



            // Add tail of first request, if necessary

            if (qiov->size < reqs[outidx].qiov->size) {

                qemu_iovec_concat(qiov, reqs[outidx].qiov, qiov->size,

                                  reqs[outidx].qiov->size - qiov->size);

            }



            reqs[outidx].nb_sectors = qiov->size >> 9;

            reqs[outidx].qiov = qiov;



            mcb->callbacks[i].free_qiov = reqs[outidx].qiov;

        } else {

            outidx++;

            reqs[outidx].sector     = reqs[i].sector;

            reqs[outidx].nb_sectors = reqs[i].nb_sectors;

            reqs[outidx].qiov       = reqs[i].qiov;

        }

    }



    if (bs->blk) {

        block_acct_merge_done(blk_get_stats(bs->blk), BLOCK_ACCT_WRITE,

                              num_reqs - outidx - 1);

    }



    return outidx + 1;

}



/*

 * Submit multiple AIO write requests at once.

 *

 * On success, the function returns 0 and all requests in the reqs array have

 * been submitted. In error case this function returns -1, and any of the

 * requests may or may not be submitted yet. In particular, this means that the

 * callback will be called for some of the requests, for others it won't. The

 * caller must check the error field of the BlockRequest to wait for the right

 * callbacks (if error != 0, no callback will be called).

 *

 * The implementation may modify the contents of the reqs array, e.g. to merge

 * requests. However, the fields opaque and error are left unmodified as they

 * are used to signal failure for a single request to the caller.

 */

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

{

    MultiwriteCB *mcb;

    int i;



    /* don't submit writes if we don't have a medium */

    if (bs->drv == NULL) {

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

            reqs[i].error = -ENOMEDIUM;

        }

        return -1;

    }



    if (num_reqs == 0) {

        return 0;

    }



    // Create MultiwriteCB structure

    mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks));

    mcb->num_requests = 0;

    mcb->num_callbacks = num_reqs;



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

        mcb->callbacks[i].cb = reqs[i].cb;

        mcb->callbacks[i].opaque = reqs[i].opaque;

    }



    // Check for mergable requests

    num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb);



    trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs);



    /* Run the aio requests. */

    mcb->num_requests = num_reqs;

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

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

                              reqs[i].nb_sectors, reqs[i].flags,

                              multiwrite_cb, mcb,

                              true);

    }



    return 0;

}



void bdrv_aio_cancel(BlockAIOCB *acb)

{

    qemu_aio_ref(acb);

include/block/block.h

+2 −5
Original line number Diff line number Diff line
@@ -329,7 +329,7 @@ void bdrv_aio_cancel(BlockAIOCB *acb); 
void bdrv_aio_cancel_async(BlockAIOCB *acb);



typedef struct BlockRequest {

    /* Fields to be filled by multiwrite caller */

    /* Fields to be filled by caller */

    union {

        struct {

            int64_t sector;
@@ -345,13 +345,10 @@ typedef struct BlockRequest { 
    BlockCompletionFunc *cb;

    void *opaque;



    /* Filled by multiwrite implementation */

    /* Filled by block layer */

    int error;

} BlockRequest;



int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,

    int num_reqs);



/* sg packet commands */

int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);

BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,

include/sysemu/block-backend.h

+0 −1
Original line number Diff line number Diff line
@@ -138,7 +138,6 @@ BlockAIOCB *blk_aio_discard(BlockBackend *blk, 
                            BlockCompletionFunc *cb, void *opaque);

void blk_aio_cancel(BlockAIOCB *acb);

void blk_aio_cancel_async(BlockAIOCB *acb);

int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs);

int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);

BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,

                          BlockCompletionFunc *cb, void *opaque);

qemu-io-cmds.c

+0 −203
Original line number Diff line number Diff line
@@ -574,49 +574,6 @@ static int do_aio_writev(BlockBackend *blk, QEMUIOVector *qiov, 
    return async_ret < 0 ? async_ret : 1;

}



struct multiwrite_async_ret {

    int num_done;

    int error;

};



static void multiwrite_cb(void *opaque, int ret)

{

    struct multiwrite_async_ret *async_ret = opaque;



    async_ret->num_done++;

    if (ret < 0) {

        async_ret->error = ret;

    }

}



static int do_aio_multiwrite(BlockBackend *blk, BlockRequest* reqs,

                             int num_reqs, int *total)

{

    int i, ret;

    struct multiwrite_async_ret async_ret = {

        .num_done = 0,

        .error = 0,

    };



    *total = 0;

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

        reqs[i].cb = multiwrite_cb;

        reqs[i].opaque = &async_ret;

        *total += reqs[i].qiov->size;

    }



    ret = blk_aio_multiwrite(blk, reqs, num_reqs);

    if (ret < 0) {

        return ret;

    }



    while (async_ret.num_done < num_reqs) {

        main_loop_wait(false);

    }



    return async_ret.error < 0 ? async_ret.error : 1;

}



static void read_help(void)

{

    printf(
@@ -1211,165 +1168,6 @@ out: 
    return 0;

}



static void multiwrite_help(void)

{

    printf(

"\n"

" writes a range of bytes from the given offset source from multiple buffers,\n"

" in a batch of requests that may be merged by qemu\n"

"\n"

" Example:\n"

" 'multiwrite 512 1k 1k ; 4k 1k'\n"

"  writes 2 kB at 512 bytes and 1 kB at 4 kB into the open file\n"

"\n"

" Writes into a segment of the currently open file, using a buffer\n"

" filled with a set pattern (0xcdcdcdcd). The pattern byte is increased\n"

" by one for each request contained in the multiwrite command.\n"

" -P, -- use different pattern to fill file\n"

" -C, -- report statistics in a machine parsable format\n"

" -q, -- quiet mode, do not show I/O statistics\n"

"\n");

}



static int multiwrite_f(BlockBackend *blk, int argc, char **argv);



static const cmdinfo_t multiwrite_cmd = {

    .name       = "multiwrite",

    .cfunc      = multiwrite_f,

    .argmin     = 2,

    .argmax     = -1,

    .args       = "[-Cq] [-P pattern ] off len [len..] [; off len [len..]..]",

    .oneline    = "issues multiple write requests at once",

    .help       = multiwrite_help,

};



static int multiwrite_f(BlockBackend *blk, int argc, char **argv)

{

    struct timeval t1, t2;

    bool Cflag = false, qflag = false;

    int c, cnt;

    char **buf;

    int64_t offset, first_offset = 0;

    /* Some compilers get confused and warn if this is not initialized.  */

    int total = 0;

    int nr_iov;

    int nr_reqs;

    int pattern = 0xcd;

    QEMUIOVector *qiovs;

    int i;

    BlockRequest *reqs;



    while ((c = getopt(argc, argv, "CqP:")) != -1) {

        switch (c) {

        case 'C':

            Cflag = true;

            break;

        case 'q':

            qflag = true;

            break;

        case 'P':

            pattern = parse_pattern(optarg);

            if (pattern < 0) {

                return 0;

            }

            break;

        default:

            return qemuio_command_usage(&writev_cmd);

        }

    }



    if (optind > argc - 2) {

        return qemuio_command_usage(&writev_cmd);

    }



    nr_reqs = 1;

    for (i = optind; i < argc; i++) {

        if (!strcmp(argv[i], ";")) {

            nr_reqs++;

        }

    }



    reqs = g_new0(BlockRequest, nr_reqs);

    buf = g_new0(char *, nr_reqs);

    qiovs = g_new(QEMUIOVector, nr_reqs);



    for (i = 0; i < nr_reqs && optind < argc; i++) {

        int j;



        /* Read the offset of the request */

        offset = cvtnum(argv[optind]);

        if (offset < 0) {

            print_cvtnum_err(offset, argv[optind]);

            goto out;

        }

        optind++;



        if (offset & 0x1ff) {

            printf("offset %lld is not sector aligned\n",

                   (long long)offset);

            goto out;

        }



        if (i == 0) {

            first_offset = offset;

        }



        /* Read lengths for qiov entries */

        for (j = optind; j < argc; j++) {

            if (!strcmp(argv[j], ";")) {

                break;

            }

        }



        nr_iov = j - optind;



        /* Build request */

        buf[i] = create_iovec(blk, &qiovs[i], &argv[optind], nr_iov, pattern);

        if (buf[i] == NULL) {

            goto out;

        }



        reqs[i].qiov = &qiovs[i];

        reqs[i].sector = offset >> 9;

        reqs[i].nb_sectors = reqs[i].qiov->size >> 9;



        optind = j + 1;



        pattern++;

    }



    /* If there were empty requests at the end, ignore them */

    nr_reqs = i;



    gettimeofday(&t1, NULL);

    cnt = do_aio_multiwrite(blk, reqs, nr_reqs, &total);

    gettimeofday(&t2, NULL);



    if (cnt < 0) {

        printf("aio_multiwrite failed: %s\n", strerror(-cnt));

        goto out;

    }



    if (qflag) {

        goto out;

    }



    /* Finally, report back -- -C gives a parsable format */

    t2 = tsub(t2, t1);

    print_report("wrote", &t2, first_offset, total, total, cnt, Cflag);

out:

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

        qemu_io_free(buf[i]);

        if (reqs[i].qiov != NULL) {

            qemu_iovec_destroy(&qiovs[i]);

        }

    }

    g_free(buf);

    g_free(reqs);

    g_free(qiovs);

    return 0;

}



struct aio_ctx {

    BlockBackend *blk;

    QEMUIOVector qiov;
@@ -2436,7 +2234,6 @@ static void __attribute((constructor)) init_qemuio_commands(void) 
    qemuio_add_command(&readv_cmd);

    qemuio_add_command(&write_cmd);

    qemuio_add_command(&writev_cmd);

    qemuio_add_command(&multiwrite_cmd);

    qemuio_add_command(&aio_read_cmd);

    qemuio_add_command(&aio_write_cmd);

    qemuio_add_command(&aio_flush_cmd);