X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fsplice.c;h=f54b4414ae1851318ae79fb5aa40d67ea8e5b9f3;hb=e84c73a89ef19f38e117ed4fae5eb3bd4aee8a81;hp=026a82bb053b538ac61f83ed721f8ca4448fb8a1;hpb=cec6b55da1c282b5b91ad346c7804171fccf151e;p=fio.git diff --git a/engines/splice.c b/engines/splice.c index 026a82bb..f54b4414 100644 --- a/engines/splice.c +++ b/engines/splice.c @@ -1,5 +1,8 @@ /* - * splice io engine + * splice engine + * + * IO engine that transfers data by doing splices to/from pipes and + * the files. * */ #include @@ -10,49 +13,69 @@ #include #include "../fio.h" -#include "../os.h" #ifdef FIO_HAVE_SPLICE struct spliceio_data { - struct io_u *last_io_u; int pipe[2]; + int vmsplice_to_user; }; -static int fio_spliceio_getevents(struct thread_data *td, int fio_unused min, - int max, struct timespec fio_unused *t) +/* + * vmsplice didn't use to support splicing to user space, this is the old + * variant of getting that job done. Doesn't make a lot of sense, but it + * uses splices to move data from the source into a pipe. + */ +static int fio_splice_read_old(struct thread_data *td, struct io_u *io_u) { - assert(max <= 1); + struct spliceio_data *sd = td->io_ops->data; + struct fio_file *f = io_u->file; + int ret, ret2, buflen; + off_t offset; + void *p; - /* - * we can only have one finished io_u for sync io, since the depth - * is always 1 - */ - if (list_empty(&td->io_u_busylist)) - return 0; + offset = io_u->offset; + buflen = io_u->xfer_buflen; + p = io_u->xfer_buf; + while (buflen) { + int this_len = buflen; - return 1; -} + if (this_len > SPLICE_DEF_SIZE) + this_len = SPLICE_DEF_SIZE; -static struct io_u *fio_spliceio_event(struct thread_data *td, int event) -{ - struct spliceio_data *sd = td->io_ops->data; + ret = splice(f->fd, &offset, sd->pipe[1], NULL, this_len, SPLICE_F_MORE); + if (ret < 0) { + if (errno == ENODATA || errno == EAGAIN) + continue; - assert(event == 0); + return -errno; + } - return sd->last_io_u; + buflen -= ret; + + while (ret) { + ret2 = read(sd->pipe[0], p, ret); + if (ret2 < 0) + return -errno; + + ret -= ret2; + p += ret2; + } + } + + return io_u->xfer_buflen; } /* - * For splice reading, we unfortunately cannot (yet) vmsplice the other way. - * So just splice the data from the file into the pipe, and use regular - * read to fill the buffer. Doesn't make a lot of sense, but... + * We can now vmsplice into userspace, so do the transfer by splicing into + * a pipe and vmsplicing that into userspace. */ static int fio_splice_read(struct thread_data *td, struct io_u *io_u) { struct spliceio_data *sd = td->io_ops->data; struct fio_file *f = io_u->file; - int ret, ret2, buflen; + struct iovec iov; + int ret, buflen; off_t offset; void *p; @@ -70,24 +93,30 @@ static int fio_splice_read(struct thread_data *td, struct io_u *io_u) if (errno == ENODATA || errno == EAGAIN) continue; - return errno; + return -errno; } buflen -= ret; - - while (ret) { - ret2 = read(sd->pipe[0], p, ret); - if (ret2 < 0) - return errno; - - ret -= ret2; - p += ret2; + iov.iov_base = p; + iov.iov_len = ret; + p += ret; + + while (iov.iov_len) { + ret = vmsplice(sd->pipe[0], &iov, 1, SPLICE_F_MOVE); + if (ret < 0) + return -errno; + else if (!ret) + return -ENODATA; + + iov.iov_len -= ret; + iov.iov_base += ret; } } return io_u->xfer_buflen; } + /* * For splice writing, we can vmsplice our data buffer directly into a * pipe and then splice that to a file. @@ -95,32 +124,30 @@ static int fio_splice_read(struct thread_data *td, struct io_u *io_u) static int fio_splice_write(struct thread_data *td, struct io_u *io_u) { struct spliceio_data *sd = td->io_ops->data; - struct iovec iov[1] = { - { - .iov_base = io_u->xfer_buf, - .iov_len = io_u->xfer_buflen, - } + struct iovec iov = { + .iov_base = io_u->xfer_buf, + .iov_len = io_u->xfer_buflen, }; struct pollfd pfd = { .fd = sd->pipe[1], .events = POLLOUT, }; struct fio_file *f = io_u->file; off_t off = io_u->offset; int ret, ret2; - while (iov[0].iov_len) { + while (iov.iov_len) { if (poll(&pfd, 1, -1) < 0) return errno; - ret = vmsplice(sd->pipe[1], iov, 1, SPLICE_F_NONBLOCK); + ret = vmsplice(sd->pipe[1], &iov, 1, SPLICE_F_NONBLOCK); if (ret < 0) - return errno; + return -errno; - iov[0].iov_len -= ret; - iov[0].iov_base += ret; + iov.iov_len -= ret; + iov.iov_base += ret; while (ret) { ret2 = splice(sd->pipe[0], NULL, f->fd, &off, ret, 0); if (ret2 < 0) - return errno; + return -errno; ret -= ret2; } @@ -134,26 +161,29 @@ static int fio_spliceio_queue(struct thread_data *td, struct io_u *io_u) struct spliceio_data *sd = td->io_ops->data; int ret; - if (io_u->ddir == DDIR_READ) - ret = fio_splice_read(td, io_u); - else if (io_u->ddir == DDIR_WRITE) + if (io_u->ddir == DDIR_READ) { + if (sd->vmsplice_to_user) + ret = fio_splice_read(td, io_u); + else + ret = fio_splice_read_old(td, io_u); + } else if (io_u->ddir == DDIR_WRITE) ret = fio_splice_write(td, io_u); else ret = fsync(io_u->file->fd); if (ret != (int) io_u->xfer_buflen) { - if (ret > 0) { + if (ret >= 0) { io_u->resid = io_u->xfer_buflen - ret; io_u->error = 0; - return ret; + return FIO_Q_COMPLETED; } else io_u->error = errno; } - if (!io_u->error) - sd->last_io_u = io_u; + if (io_u->error) + td_verror(td, io_u->error, "xfer"); - return io_u->error; + return FIO_Q_COMPLETED; } static void fio_spliceio_cleanup(struct thread_data *td) @@ -172,13 +202,17 @@ static int fio_spliceio_init(struct thread_data *td) { struct spliceio_data *sd = malloc(sizeof(*sd)); - sd->last_io_u = NULL; if (pipe(sd->pipe) < 0) { - td_verror(td, errno); + td_verror(td, errno, "pipe"); free(sd); return 1; } + /* + * need some check for enabling this, for now just leave it disabled + */ + sd->vmsplice_to_user = 0; + td->io_ops->data = sd; return 0; } @@ -188,9 +222,9 @@ static struct ioengine_ops ioengine = { .version = FIO_IOOPS_VERSION, .init = fio_spliceio_init, .queue = fio_spliceio_queue, - .getevents = fio_spliceio_getevents, - .event = fio_spliceio_event, .cleanup = fio_spliceio_cleanup, + .open_file = generic_open_file, + .close_file = generic_close_file, .flags = FIO_SYNCIO, };