engines/splice.c

   1 /*
   2  * splice engine
   3  *
   4  * IO engine that transfers data by doing splices to/from pipes and
   5  * the files.
   6  *
   7  */
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <errno.h>
  12 #include <assert.h>
  13 #include <sys/poll.h>
  14
  15 #include "../fio.h"
  16 #include "../os.h"
  17
  18 #ifdef FIO_HAVE_SPLICE
  19
  20 struct spliceio_data {
  21         int pipe[2];
  22 };
  23
  24 /*
  25  * For splice reading, we unfortunately cannot (yet) vmsplice the other way.
  26  * So just splice the data from the file into the pipe, and use regular
  27  * read to fill the buffer. Doesn't make a lot of sense, but...
  28  */
  29 static int fio_splice_read(struct thread_data *td, struct io_u *io_u)
  30 {
  31         struct spliceio_data *sd = td->io_ops->data;
  32         struct fio_file *f = io_u->file;
  33         int ret, ret2, buflen;
  34         off_t offset;
  35         void *p;
  36
  37         offset = io_u->offset;
  38         buflen = io_u->xfer_buflen;
  39         p = io_u->xfer_buf;
  40         while (buflen) {
  41                 int this_len = buflen;
  42
  43                 if (this_len > SPLICE_DEF_SIZE)
  44                         this_len = SPLICE_DEF_SIZE;
  45
  46                 ret = splice(f->fd, &offset, sd->pipe[1], NULL, this_len, SPLICE_F_MORE);
  47                 if (ret < 0) {
  48                         if (errno == ENODATA || errno == EAGAIN)
  49                                 continue;
  50
  51                         return errno;
  52                 }
  53
  54                 buflen -= ret;
  55
  56                 while (ret) {
  57                         ret2 = read(sd->pipe[0], p, ret);
  58                         if (ret2 < 0)
  59                                 return errno;
  60
  61                         ret -= ret2;
  62                         p += ret2;
  63                 }
  64         }
  65
  66         return io_u->xfer_buflen;
  67 }
  68
  69 /*
  70  * For splice writing, we can vmsplice our data buffer directly into a
  71  * pipe and then splice that to a file.
  72  */
  73 static int fio_splice_write(struct thread_data *td, struct io_u *io_u)
  74 {
  75         struct spliceio_data *sd = td->io_ops->data;
  76         struct iovec iov[1] = {
  77                 {
  78                         .iov_base = io_u->xfer_buf,
  79                         .iov_len = io_u->xfer_buflen,
  80                 }
  81         };
  82         struct pollfd pfd = { .fd = sd->pipe[1], .events = POLLOUT, };
  83         struct fio_file *f = io_u->file;
  84         off_t off = io_u->offset;
  85         int ret, ret2;
  86
  87         while (iov[0].iov_len) {
  88                 if (poll(&pfd, 1, -1) < 0)
  89                         return errno;
  90
  91                 ret = vmsplice(sd->pipe[1], iov, 1, SPLICE_F_NONBLOCK);
  92                 if (ret < 0)
  93                         return errno;
  94
  95                 iov[0].iov_len -= ret;
  96                 iov[0].iov_base += ret;
  97
  98                 while (ret) {
  99                         ret2 = splice(sd->pipe[0], NULL, f->fd, &off, ret, 0);
 100                         if (ret2 < 0)
 101                                 return errno;
 102
 103                         ret -= ret2;
 104                 }
 105         }
 106
 107         return io_u->xfer_buflen;
 108 }
 109
 110 static int fio_spliceio_queue(struct thread_data *td, struct io_u *io_u)
 111 {
 112         int ret;
 113
 114         if (io_u->ddir == DDIR_READ)
 115                 ret = fio_splice_read(td, io_u);
 116         else if (io_u->ddir == DDIR_WRITE)
 117                 ret = fio_splice_write(td, io_u);
 118         else
 119                 ret = fsync(io_u->file->fd);
 120
 121         if (ret != (int) io_u->xfer_buflen) {
 122                 if (ret >= 0) {
 123                         io_u->resid = io_u->xfer_buflen - ret;
 124                         io_u->error = 0;
 125                         return FIO_Q_COMPLETED;
 126                 } else
 127                         io_u->error = errno;
 128         }
 129
 130         if (io_u->error)
 131                 td_verror(td, io_u->error, "xfer");
 132
 133         return FIO_Q_COMPLETED;
 134 }
 135
 136 static void fio_spliceio_cleanup(struct thread_data *td)
 137 {
 138         struct spliceio_data *sd = td->io_ops->data;
 139
 140         if (sd) {
 141                 close(sd->pipe[0]);
 142                 close(sd->pipe[1]);
 143                 free(sd);
 144                 td->io_ops->data = NULL;
 145         }
 146 }
 147
 148 static int fio_spliceio_init(struct thread_data *td)
 149 {
 150         struct spliceio_data *sd = malloc(sizeof(*sd));
 151
 152         if (pipe(sd->pipe) < 0) {
 153                 td_verror(td, errno, "pipe");
 154                 free(sd);
 155                 return 1;
 156         }
 157
 158         td->io_ops->data = sd;
 159         return 0;
 160 }
 161
 162 static struct ioengine_ops ioengine = {
 163         .name           = "splice",
 164         .version        = FIO_IOOPS_VERSION,
 165         .init           = fio_spliceio_init,
 166         .queue          = fio_spliceio_queue,
 167         .cleanup        = fio_spliceio_cleanup,
 168         .open_file      = generic_open_file,
 169         .close_file     = generic_close_file,
 170         .flags          = FIO_SYNCIO,
 171 };
 172
 173 #else /* FIO_HAVE_SPLICE */
 174
 175 /*
 176  * When we have a proper configure system in place, we simply wont build
 177  * and install this io engine. For now install a crippled version that
 178  * just complains and fails to load.
 179  */
 180 static int fio_spliceio_init(struct thread_data fio_unused *td)
 181 {
 182         fprintf(stderr, "fio: splice not available\n");
 183         return 1;
 184 }
 185
 186 static struct ioengine_ops ioengine = {
 187         .name           = "splice",
 188         .version        = FIO_IOOPS_VERSION,
 189         .init           = fio_spliceio_init,
 190 };
 191
 192 #endif
 193
 194 static void fio_init fio_spliceio_register(void)
 195 {
 196         register_ioengine(&ioengine);
 197 }
 198
 199 static void fio_exit fio_spliceio_unregister(void)
 200 {
 201         unregister_ioengine(&ioengine);
 202 }