blob: fb1906206a039be8e13f5cc00118307b6febd1dd [file] [log] [blame]
/*
* binject engine
*
* IO engine that uses the Linux binject interface to directly inject
* bio's to block devices.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
#include <sys/poll.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "../fio.h"
#ifdef FIO_HAVE_BINJECT
struct binject_data {
struct b_user_cmd *cmds;
struct io_u **events;
struct pollfd *pfds;
int *fd_flags;
};
struct binject_file {
unsigned int bs;
int minor;
int fd;
};
static void binject_buc_init(struct binject_data *bd, struct io_u *io_u)
{
struct b_user_cmd *buc = &io_u->buc;
memset(buc, 0, sizeof(*buc));
binject_buc_set_magic(buc);
buc->buf = (unsigned long) io_u->xfer_buf;
buc->len = io_u->xfer_buflen;
buc->offset = io_u->offset;
buc->usr_ptr = (unsigned long) io_u;
buc->flags = B_FLAG_NOIDLE | B_FLAG_UNPLUG;
assert(buc->buf);
}
static int pollin_events(struct pollfd *pfds, int fds)
{
int i;
for (i = 0; i < fds; i++)
if (pfds[i].revents & POLLIN)
return 1;
return 0;
}
static unsigned int binject_read_commands(struct thread_data *td, void *p,
int left, int *err)
{
struct binject_file *bf;
struct fio_file *f;
int i, ret, events;
one_more:
events = 0;
for_each_file(td, f, i) {
bf = (struct binject_file *) (uintptr_t) f->engine_data;
ret = read(bf->fd, p, left * sizeof(struct b_user_cmd));
if (ret < 0) {
if (errno == EAGAIN)
continue;
*err = -errno;
td_verror(td, errno, "read");
break;
} else if (ret) {
p += ret;
events += ret / sizeof(struct b_user_cmd);
}
}
if (*err || events)
return events;
usleep(1000);
goto one_more;
}
static int fio_binject_getevents(struct thread_data *td, unsigned int min,
unsigned int max, struct timespec fio_unused *t)
{
struct binject_data *bd = td->io_ops->data;
int left = max, ret, r = 0, ev_index = 0;
void *buf = bd->cmds;
unsigned int i, events;
struct fio_file *f;
struct binject_file *bf;
/*
* Fill in the file descriptors
*/
for_each_file(td, f, i) {
bf = (struct binject_file *) (uintptr_t) f->engine_data;
/*
* don't block for min events == 0
*/
if (!min) {
bd->fd_flags[i] = fcntl(bf->fd, F_GETFL);
fcntl(bf->fd, F_SETFL, bd->fd_flags[i] | O_NONBLOCK);
}
bd->pfds[i].fd = bf->fd;
bd->pfds[i].events = POLLIN;
}
while (left) {
while (!min) {
ret = poll(bd->pfds, td->o.nr_files, -1);
if (ret < 0) {
if (!r)
r = -errno;
td_verror(td, errno, "poll");
break;
} else if (!ret)
continue;
if (pollin_events(bd->pfds, td->o.nr_files))
break;
}
if (r < 0)
break;
events = binject_read_commands(td, buf, left, &r);
if (r < 0)
break;
left -= events;
r += events;
for (i = 0; i < events; i++) {
struct b_user_cmd *buc = (struct b_user_cmd *) buf + i;
bd->events[ev_index] = (struct io_u *) (unsigned long) buc->usr_ptr;
ev_index++;
}
}
if (!min) {
for_each_file(td, f, i) {
bf = (struct binject_file *) (uintptr_t) f->engine_data;
fcntl(bf->fd, F_SETFL, bd->fd_flags[i]);
}
}
if (r > 0)
assert(ev_index == r);
return r;
}
static int fio_binject_doio(struct thread_data *td, struct io_u *io_u)
{
struct b_user_cmd *buc = &io_u->buc;
struct binject_file *bf = (struct binject_file *) (uintptr_t) io_u->file->engine_data;
int ret;
ret = write(bf->fd, buc, sizeof(*buc));
if (ret < 0)
return ret;
return FIO_Q_QUEUED;
}
static int fio_binject_prep(struct thread_data *td, struct io_u *io_u)
{
struct binject_data *bd = td->io_ops->data;
struct b_user_cmd *buc = &io_u->buc;
struct binject_file *bf = (struct binject_file *) (uintptr_t) io_u->file->engine_data;
if (io_u->xfer_buflen & (bf->bs - 1)) {
log_err("read/write not sector aligned\n");
return EINVAL;
}
if (io_u->ddir == DDIR_READ) {
binject_buc_init(bd, io_u);
buc->type = B_TYPE_READ;
} else if (io_u->ddir == DDIR_WRITE) {
binject_buc_init(bd, io_u);
if (io_u->flags & IO_U_F_BARRIER)
buc->type = B_TYPE_WRITEBARRIER;
else
buc->type = B_TYPE_WRITE;
} else if (io_u->ddir == DDIR_TRIM) {
binject_buc_init(bd, io_u);
buc->type = B_TYPE_DISCARD;
} else {
assert(0);
}
return 0;
}
static int fio_binject_queue(struct thread_data *td, struct io_u *io_u)
{
int ret;
fio_ro_check(td, io_u);
ret = fio_binject_doio(td, io_u);
if (ret < 0)
io_u->error = errno;
if (io_u->error) {
td_verror(td, io_u->error, "xfer");
return FIO_Q_COMPLETED;
}
return ret;
}
static struct io_u *fio_binject_event(struct thread_data *td, int event)
{
struct binject_data *bd = td->io_ops->data;
return bd->events[event];
}
static int binject_open_ctl(struct thread_data *td)
{
int fd;
fd = open("/dev/binject-ctl", O_RDWR);
if (fd < 0)
td_verror(td, errno, "open binject-ctl");
return fd;
}
static void binject_unmap_dev(struct thread_data *td, struct binject_file *bf)
{
struct b_ioctl_cmd bic;
int fdb;
if (bf->fd >= 0) {
close(bf->fd);
bf->fd = -1;
}
fdb = binject_open_ctl(td);
if (fdb < 0)
return;
bic.minor = bf->minor;
if (ioctl(fdb, B_IOCTL_DEL, &bic) < 0)
td_verror(td, errno, "binject dev unmap");
close(fdb);
}
static int binject_map_dev(struct thread_data *td, struct binject_file *bf,
int fd)
{
struct b_ioctl_cmd bic;
char name[80];
struct stat sb;
int fdb, dev_there, loops;
fdb = binject_open_ctl(td);
if (fdb < 0)
return 1;
bic.fd = fd;
if (ioctl(fdb, B_IOCTL_ADD, &bic) < 0) {
td_verror(td, errno, "binject dev map");
close(fdb);
return 1;
}
bf->minor = bic.minor;
sprintf(name, "/dev/binject%u", bf->minor);
/*
* Wait for udev to create the node...
*/
dev_there = loops = 0;
do {
if (!stat(name, &sb)) {
dev_there = 1;
break;
}
usleep(10000);
} while (++loops < 100);
close(fdb);
if (!dev_there) {
log_err("fio: timed out waiting for binject dev\n");
goto err_unmap;
}
bf->fd = open(name, O_RDWR);
if (bf->fd < 0) {
td_verror(td, errno, "binject dev open");
err_unmap:
binject_unmap_dev(td, bf);
return 1;
}
return 0;
}
static int fio_binject_close_file(struct thread_data *td, struct fio_file *f)
{
struct binject_file *bf = (struct binject_file *) (uintptr_t) f->engine_data;
if (bf) {
binject_unmap_dev(td, bf);
free(bf);
f->engine_data = 0;
return generic_close_file(td, f);
}
return 0;
}
static int fio_binject_open_file(struct thread_data *td, struct fio_file *f)
{
struct binject_file *bf;
unsigned int bs;
int ret;
ret = generic_open_file(td, f);
if (ret)
return 1;
if (f->filetype != FIO_TYPE_BD) {
log_err("fio: binject only works with block devices\n");
goto err_close;
}
if (ioctl(f->fd, BLKSSZGET, &bs) < 0) {
td_verror(td, errno, "BLKSSZGET");
goto err_close;
}
bf = malloc(sizeof(*bf));
bf->bs = bs;
bf->minor = bf->fd = -1;
f->engine_data = (uintptr_t) bf;
if (binject_map_dev(td, bf, f->fd)) {
err_close:
ret = generic_close_file(td, f);
return 1;
}
return 0;
}
static void fio_binject_cleanup(struct thread_data *td)
{
struct binject_data *bd = td->io_ops->data;
if (bd) {
free(bd->events);
free(bd->cmds);
free(bd->fd_flags);
free(bd->pfds);
free(bd);
}
}
static int fio_binject_init(struct thread_data *td)
{
struct binject_data *bd;
bd = malloc(sizeof(*bd));
memset(bd, 0, sizeof(*bd));
bd->cmds = malloc(td->o.iodepth * sizeof(struct b_user_cmd));
memset(bd->cmds, 0, td->o.iodepth * sizeof(struct b_user_cmd));
bd->events = malloc(td->o.iodepth * sizeof(struct io_u *));
memset(bd->events, 0, td->o.iodepth * sizeof(struct io_u *));
bd->pfds = malloc(sizeof(struct pollfd) * td->o.nr_files);
memset(bd->pfds, 0, sizeof(struct pollfd) * td->o.nr_files);
bd->fd_flags = malloc(sizeof(int) * td->o.nr_files);
memset(bd->fd_flags, 0, sizeof(int) * td->o.nr_files);
td->io_ops->data = bd;
return 0;
}
static struct ioengine_ops ioengine = {
.name = "binject",
.version = FIO_IOOPS_VERSION,
.init = fio_binject_init,
.prep = fio_binject_prep,
.queue = fio_binject_queue,
.getevents = fio_binject_getevents,
.event = fio_binject_event,
.cleanup = fio_binject_cleanup,
.open_file = fio_binject_open_file,
.close_file = fio_binject_close_file,
.get_file_size = generic_get_file_size,
.flags = FIO_RAWIO | FIO_BARRIER | FIO_MEMALIGN,
};
#else /* FIO_HAVE_BINJECT */
/*
* When we have a proper configure system in place, we simply wont build
* and install this io engine. For now install a crippled version that
* just complains and fails to load.
*/
static int fio_binject_init(struct thread_data fio_unused *td)
{
log_err("fio: ioengine binject not available\n");
return 1;
}
static struct ioengine_ops ioengine = {
.name = "binject",
.version = FIO_IOOPS_VERSION,
.init = fio_binject_init,
};
#endif
static void fio_init fio_binject_register(void)
{
register_ioengine(&ioengine);
}
static void fio_exit fio_binject_unregister(void)
{
unregister_ioengine(&ioengine);
}