4 * IO engine that uses the Linux binject interface to directly inject
5 * bio's to block devices.
18 #ifdef FIO_HAVE_BINJECT
21 struct b_user_cmd *cmds;
27 static void binject_buc_init(struct binject_data *bd, struct io_u *io_u)
29 struct b_user_cmd *buc = &io_u->buc;
31 memset(buc, 0, sizeof(*buc));
32 binject_buc_set_magic(buc);
34 buc->buf = (unsigned long) io_u->xfer_buf;
35 buc->len = io_u->xfer_buflen;
36 buc->offset = io_u->offset;
37 buc->usr_ptr = (unsigned long) io_u;
39 buc->flags = B_FLAG_NOIDLE | B_FLAG_UNPLUG;
43 static int pollin_events(struct pollfd *pfds, int fds)
47 for (i = 0; i < fds; i++)
48 if (pfds[i].revents & POLLIN)
54 static int fio_binject_getevents(struct thread_data *td, unsigned int min,
55 unsigned int max, struct timespec fio_unused *t)
57 struct binject_data *bd = td->io_ops->data;
58 int left = max, ret, r = 0, ev_index = 0;
60 unsigned int i, events;
64 * Fill in the file descriptors
66 for_each_file(td, f, i) {
68 * don't block for min events == 0
71 bd->fd_flags[i] = fcntl(f->fd, F_GETFL);
72 fcntl(f->fd, F_SETFL, bd->fd_flags[i] | O_NONBLOCK);
74 bd->pfds[i].fd = f->fd;
75 bd->pfds[i].events = POLLIN;
85 ret = poll(bd->pfds, td->o.nr_files, -1);
89 td_verror(td, errno, "poll");
94 if (pollin_events(bd->pfds, td->o.nr_files))
104 for_each_file(td, f, i) {
105 ret = read(f->fd, p, left * sizeof(struct b_user_cmd));
110 td_verror(td, errno, "read");
114 events += ret / sizeof(struct b_user_cmd);
128 for (i = 0; i < events; i++) {
129 struct b_user_cmd *buc = (struct b_user_cmd *) buf + i;
131 bd->events[ev_index] = (struct io_u *) buc->usr_ptr;
137 for_each_file(td, f, i)
138 fcntl(f->fd, F_SETFL, bd->fd_flags[i]);
142 assert(ev_index == r);
147 static int fio_binject_doio(struct thread_data *td, struct io_u *io_u)
149 struct b_user_cmd *buc = &io_u->buc;
150 struct fio_file *f = io_u->file;
153 ret = write(f->fd, buc, sizeof(*buc));
160 static int fio_binject_prep(struct thread_data *td, struct io_u *io_u)
162 struct binject_data *bd = td->io_ops->data;
163 unsigned int bs = io_u->file->file_data;
164 struct b_user_cmd *buc = &io_u->buc;
166 if (io_u->xfer_buflen & (bs - 1)) {
167 log_err("read/write not sector aligned\n");
171 if (io_u->ddir == DDIR_READ) {
172 binject_buc_init(bd, io_u);
173 buc->type = B_TYPE_READ;
174 } else if (io_u->ddir == DDIR_WRITE) {
175 binject_buc_init(bd, io_u);
176 buc->type = B_TYPE_WRITE;
177 } else if (io_u->ddir == DDIR_TRIM) {
178 binject_buc_init(bd, io_u);
179 buc->type = B_TYPE_DISCARD;
187 static int fio_binject_queue(struct thread_data *td, struct io_u *io_u)
191 fio_ro_check(td, io_u);
193 ret = fio_binject_doio(td, io_u);
199 td_verror(td, io_u->error, "xfer");
200 return FIO_Q_COMPLETED;
206 static struct io_u *fio_binject_event(struct thread_data *td, int event)
208 struct binject_data *bd = td->io_ops->data;
210 return bd->events[event];
213 static int fio_binject_open_file(struct thread_data *td, struct fio_file *f)
218 ret = generic_open_file(td, f);
222 if (f->filetype != FIO_TYPE_BD) {
223 log_err("fio: binject only works with block devices\n");
226 if (ioctl(f->fd, BLKSSZGET, &bs) < 0) {
227 td_verror(td, errno, "BLKSSZGET");
235 static void fio_binject_cleanup(struct thread_data *td)
237 struct binject_data *bd = td->io_ops->data;
248 static int fio_binject_init(struct thread_data *td)
250 struct binject_data *bd;
252 bd = malloc(sizeof(*bd));
253 memset(bd, 0, sizeof(*bd));
255 bd->cmds = malloc(td->o.iodepth * sizeof(struct b_user_cmd));
256 memset(bd->cmds, 0, td->o.iodepth * sizeof(struct b_user_cmd));
258 bd->events = malloc(td->o.iodepth * sizeof(struct io_u *));
259 memset(bd->events, 0, td->o.iodepth * sizeof(struct io_u *));
261 bd->pfds = malloc(sizeof(struct pollfd) * td->o.nr_files);
262 memset(bd->pfds, 0, sizeof(struct pollfd) * td->o.nr_files);
264 bd->fd_flags = malloc(sizeof(int) * td->o.nr_files);
265 memset(bd->fd_flags, 0, sizeof(int) * td->o.nr_files);
267 td->io_ops->data = bd;
271 static struct ioengine_ops ioengine = {
273 .version = FIO_IOOPS_VERSION,
274 .init = fio_binject_init,
275 .prep = fio_binject_prep,
276 .queue = fio_binject_queue,
277 .getevents = fio_binject_getevents,
278 .event = fio_binject_event,
279 .cleanup = fio_binject_cleanup,
280 .open_file = fio_binject_open_file,
281 .close_file = generic_close_file,
282 .get_file_size = generic_get_file_size,
286 #else /* FIO_HAVE_BINJECT */
289 * When we have a proper configure system in place, we simply wont build
290 * and install this io engine. For now install a crippled version that
291 * just complains and fails to load.
293 static int fio_binject_init(struct thread_data fio_unused *td)
295 log_err("fio: ioengine binject not available\n");
299 static struct ioengine_ops ioengine = {
301 .version = FIO_IOOPS_VERSION,
302 .init = fio_binject_init,
307 static void fio_init fio_binject_register(void)
309 register_ioengine(&ioengine);
312 static void fio_exit fio_binject_unregister(void)
314 unregister_ioengine(&ioengine);