net: support for unix domain sockets

Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/HOWTO b/HOWTO
index 24a0f3b09baed3951e85ac9e54185e181f81b073..2e4cdbdf146e17394a8ebcd481097e43846131ba 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -267,7 +267,7 @@ filename=str        Fio normally makes up a filename based on the job name,
                files between threads in a job or several jobs, specify
                a filename for each of them to override the default. If
                the ioengine used is 'net', the filename is the host, port,
-               and protocol to use in the format of =host/port/protocol.
+               and protocol to use in the format of =host,port,protocol.
                See ioengine=net for more. If the ioengine is file based, you
                can specify a number of files by separating the names with a
                ':' colon. So if you wanted a job to open /dev/sda and /dev/sdb

diff --git a/engines/net.c b/engines/net.c
index 781dd10adeb787f65689958fe09754f3517d837a..faa08d5f6741b10641c36f12de933f88406846fe 100644 (file)
--- a/engines/net.c
+++ b/engines/net.c
@@ -14,7 +14,9 @@
 #include <netdb.h>
 #include <sys/poll.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 
 #include "../fio.h"
 
@@ -22,10 +24,11 @@ struct netio_data {
        int listenfd;
        int send_to_net;
        int use_splice;
-       int net_protocol;
+       int type;
        int pipes[2];
        char host[64];
        struct sockaddr_in addr;
+       struct sockaddr_un addr_un;
 };
 
 struct udp_close_msg {
@@ -36,6 +39,10 @@ struct udp_close_msg {
 enum {
        FIO_LINK_CLOSE = 0x89,
        FIO_LINK_CLOSE_MAGIC = 0x6c696e6b,
+
+       FIO_TYPE_TCP    = 1,
+       FIO_TYPE_UDP    = 2,
+       FIO_TYPE_UNIX   = 3,
 };
 
 /*
@@ -226,7 +233,7 @@ static int fio_netio_send(struct thread_data *td, struct io_u *io_u)
        int ret, flags = OS_MSG_DONTWAIT;
 
        do {
-               if (nd->net_protocol == IPPROTO_UDP) {
+               if (nd->type == FIO_TYPE_UDP) {
                        struct sockaddr *to = (struct sockaddr *) &nd->addr;
 
                        ret = sendto(io_u->file->fd, io_u->xfer_buf,
@@ -279,7 +286,7 @@ static int fio_netio_recv(struct thread_data *td, struct io_u *io_u)
        int ret, flags = OS_MSG_DONTWAIT;
 
        do {
-               if (nd->net_protocol == IPPROTO_UDP) {
+               if (nd->type == FIO_TYPE_UDP) {
                        fio_socklen_t len = sizeof(nd->addr);
                        struct sockaddr *from = (struct sockaddr *) &nd->addr;
 
@@ -314,12 +321,14 @@ static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
        fio_ro_check(td, io_u);
 
        if (io_u->ddir == DDIR_WRITE) {
-               if (!nd->use_splice || nd->net_protocol == IPPROTO_UDP)
+               if (!nd->use_splice || nd->type == FIO_TYPE_UDP ||
+                   nd->type == FIO_TYPE_UNIX) 
                        ret = fio_netio_send(td, io_u);
                else
                        ret = fio_netio_splice_out(td, io_u);
        } else if (io_u->ddir == DDIR_READ) {
-               if (!nd->use_splice || nd->net_protocol == IPPROTO_UDP)
+               if (!nd->use_splice || nd->type == FIO_TYPE_UDP ||
+                   nd->type == FIO_TYPE_UDP)
                        ret = fio_netio_recv(td, io_u);
                else
                        ret = fio_netio_splice_in(td, io_u);
@@ -350,25 +359,48 @@ static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
 static int fio_netio_connect(struct thread_data *td, struct fio_file *f)
 {
        struct netio_data *nd = td->io_ops->data;
-       int type;
+       int type, domain;
 
-       if (nd->net_protocol == IPPROTO_TCP)
+       if (nd->type == FIO_TYPE_TCP) {
+               domain = AF_INET;
                type = SOCK_STREAM;
-       else
+       } else if (nd->type == FIO_TYPE_UDP) {
+               domain = AF_INET;
                type = SOCK_DGRAM;
+       } else if (nd->type == FIO_TYPE_UNIX) {
+               domain = AF_UNIX;
+               type = SOCK_STREAM;
+       } else {
+               log_err("fio: bad network type %d\n", nd->type);
+               f->fd = -1;
+               return 1;
+       }
 
-       f->fd = socket(AF_INET, type, nd->net_protocol);
+       f->fd = socket(domain, type, 0);
        if (f->fd < 0) {
                td_verror(td, errno, "socket");
                return 1;
        }
 
-       if (nd->net_protocol == IPPROTO_UDP)
+       if (nd->type == FIO_TYPE_UDP)
                return 0;
+       else if (nd->type == FIO_TYPE_TCP) {
+               fio_socklen_t len = sizeof(nd->addr);
 
-       if (connect(f->fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
-               td_verror(td, errno, "connect");
-               return 1;
+               if (connect(f->fd, (struct sockaddr *) &nd->addr, len) < 0) {
+                       td_verror(td, errno, "connect");
+                       return 1;
+               }
+       } else {
+               struct sockaddr_un *addr = &nd->addr_un;
+               fio_socklen_t len;
+
+               len = sizeof(addr->sun_family) + strlen(addr->sun_path) + 1;
+
+               if (connect(f->fd, (struct sockaddr *) addr, len) < 0) {
+                       td_verror(td, errno, "connect");
+                       return 1;
+               }
        }
 
        return 0;
@@ -379,7 +411,7 @@ static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
        struct netio_data *nd = td->io_ops->data;
        fio_socklen_t socklen = sizeof(nd->addr);
 
-       if (nd->net_protocol == IPPROTO_UDP) {
+       if (nd->type == FIO_TYPE_UDP) {
                f->fd = nd->listenfd;
                return 0;
        }
@@ -400,10 +432,16 @@ static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
 
 static int fio_netio_open_file(struct thread_data *td, struct fio_file *f)
 {
+       int ret;
+
        if (td_read(td))
-               return fio_netio_accept(td, f);
+               ret = fio_netio_accept(td, f);
        else
-               return fio_netio_connect(td, f);
+               ret = fio_netio_connect(td, f);
+
+       if (ret)
+               f->fd = -1;
+       return ret;
 }
 
 static void fio_netio_udp_close(struct thread_data *td, struct fio_file *f)
@@ -430,14 +468,14 @@ static int fio_netio_close_file(struct thread_data *td, struct fio_file *f)
         * If this is an UDP connection, notify the receiver that we are
         * closing down the link
         */
-       if (nd->net_protocol == IPPROTO_UDP)
+       if (nd->type == FIO_TYPE_UDP)
                fio_netio_udp_close(td, f);
 
        return generic_close_file(td, f);
 }
 
-static int fio_netio_setup_connect(struct thread_data *td, const char *host,
-                                  unsigned short port)
+static int fio_netio_setup_connect_inet(struct thread_data *td,
+                                       const char *host, unsigned short port)
 {
        struct netio_data *nd = td->io_ops->data;
 
@@ -459,17 +497,71 @@ static int fio_netio_setup_connect(struct thread_data *td, const char *host,
        return 0;
 }
 
-static int fio_netio_setup_listen(struct thread_data *td, short port)
+static int fio_netio_setup_connect_unix(struct thread_data *td,
+                                       const char *path)
+{
+       struct netio_data *nd = td->io_ops->data;
+       struct sockaddr_un *soun = &nd->addr_un;
+
+       soun->sun_family = AF_UNIX;
+       strcpy(soun->sun_path, path);
+       return 0;
+}
+
+static int fio_netio_setup_connect(struct thread_data *td, const char *host,
+                                  unsigned short port)
+{
+       struct netio_data *nd = td->io_ops->data;
+
+       if (nd->type == FIO_TYPE_UDP || nd->type == FIO_TYPE_TCP)
+               return fio_netio_setup_connect_inet(td, host, port);
+       else
+               return fio_netio_setup_connect_unix(td, host);
+}
+
+static int fio_netio_setup_listen_unix(struct thread_data *td, const char *path)
+{
+       struct netio_data *nd = td->io_ops->data;
+       struct sockaddr_un *addr = &nd->addr_un;
+       mode_t mode;
+       int len, fd;
+
+       fd = socket(AF_UNIX, SOCK_STREAM, 0);
+       if (fd < 0) {
+               log_err("fio: socket: %s\n", strerror(errno));
+               return -1;
+       }
+
+       mode = umask(000);
+
+       memset(addr, 0, sizeof(*addr));
+       addr->sun_family = AF_UNIX;
+       strcpy(addr->sun_path, path);
+       unlink(path);
+
+       len = sizeof(addr->sun_family) + strlen(path) + 1;
+
+       if (bind(fd, (struct sockaddr *) addr, len) < 0) {
+               log_err("fio: bind: %s\n", strerror(errno));
+               return -1;
+       }
+
+       umask(mode);
+       nd->listenfd = fd;
+       return 0;
+}
+
+static int fio_netio_setup_listen_inet(struct thread_data *td, short port)
 {
        struct netio_data *nd = td->io_ops->data;
        int fd, opt, type;
 
-       if (nd->net_protocol == IPPROTO_TCP)
+       if (nd->type == FIO_TYPE_TCP)
                type = SOCK_STREAM;
        else
                type = SOCK_DGRAM;
 
-       fd = socket(AF_INET, type, nd->net_protocol);
+       fd = socket(AF_INET, type, 0);
        if (fd < 0) {
                td_verror(td, errno, "socket");
                return 1;
@@ -495,12 +587,33 @@ static int fio_netio_setup_listen(struct thread_data *td, short port)
                td_verror(td, errno, "bind");
                return 1;
        }
-       if (nd->net_protocol == IPPROTO_TCP && listen(fd, 1) < 0) {
+
+       nd->listenfd = fd;
+       return 0;
+}
+
+static int fio_netio_setup_listen(struct thread_data *td, const char *path,
+                                 short port)
+{
+       struct netio_data *nd = td->io_ops->data;
+       int ret;
+
+       if (nd->type == FIO_TYPE_UDP || nd->type == FIO_TYPE_TCP)
+               ret = fio_netio_setup_listen_inet(td, port);
+       else
+               ret = fio_netio_setup_listen_unix(td, path);
+
+       if (ret)
+               return ret;
+       if (nd->type == FIO_TYPE_UDP)
+               return 0;
+
+       if (listen(nd->listenfd, 10) < 0) {
                td_verror(td, errno, "listen");
+               nd->listenfd = -1;
                return 1;
        }
 
-       nd->listenfd = fd;
        return 0;
 }
 
@@ -523,7 +636,7 @@ static int fio_netio_init(struct thread_data *td)
 
        strcpy(buf, td->o.filename);
 
-       sep = strchr(buf, '/');
+       sep = strchr(buf, ',');
        if (!sep)
                goto bad_host;
 
@@ -535,31 +648,34 @@ static int fio_netio_init(struct thread_data *td)
 
        modep = NULL;
        portp = sep;
-       sep = strchr(portp, '/');
+       sep = strchr(portp, ',');
        if (sep) {
                *sep = '\0';
                modep = sep + 1;
        }
-               
-       port = strtol(portp, NULL, 10);
-       if (!port || port > 65535)
+
+       if (!strncmp("tcp", modep, strlen(modep)) ||
+           !strncmp("TCP", modep, strlen(modep)))
+               nd->type = FIO_TYPE_TCP;
+       else if (!strncmp("udp", modep, strlen(modep)) ||
+                !strncmp("UDP", modep, strlen(modep)))
+               nd->type = FIO_TYPE_UDP;
+       else if (!strncmp("unix", modep, strlen(modep)) ||
+                !strncmp("UNIX", modep, strlen(modep)))
+               nd->type = FIO_TYPE_UNIX;
+       else
                goto bad_host;
 
-       if (modep) {
-               if (!strncmp("tcp", modep, strlen(modep)) ||
-                   !strncmp("TCP", modep, strlen(modep)))
-                       nd->net_protocol = IPPROTO_TCP;
-               else if (!strncmp("udp", modep, strlen(modep)) ||
-                        !strncmp("UDP", modep, strlen(modep)))
-                       nd->net_protocol = IPPROTO_UDP;
-               else
+       if (nd->type != FIO_TYPE_UNIX) {
+               port = strtol(portp, NULL, 10);
+               if (!port || port > 65535)
                        goto bad_host;
        } else
-               nd->net_protocol = IPPROTO_TCP;
+               port = 0;
 
        if (td_read(td)) {
                nd->send_to_net = 0;
-               ret = fio_netio_setup_listen(td, port);
+               ret = fio_netio_setup_listen(td, host, port);
        } else {
                nd->send_to_net = 1;
                ret = fio_netio_setup_connect(td, host, port);

diff --git a/examples/netio b/examples/netio
index 2aa092882184d3032242faf9ae48c9884baab9ef..5b07468a6a560eb6710bc23b19518d27a27f476b 100644 (file)
--- a/examples/netio
+++ b/examples/netio
@@ -1,8 +1,12 @@
 # Example network job, just defines two clients that send/recv data
 [global]
 ioengine=net
-#the below defaults to a tcp connection, add /udp at the end for udp
-filename=localhost/8888
+#this would use UDP over localhost, port 8888
+#filename=localhost,8888,udp
+#this would use a local domain socket /tmp/fio.sock
+#filename=/tmp/fio.sock,,unix
+#TCP, port 8888, localhost
+filename=localhost,8888,tcp
 bs=4k
 size=10g
 #set the below option to enable end-to-end data integrity tests
@@ -12,4 +16,5 @@ size=10g
 rw=read
 
 [sender]
+startdelay=1
 rw=write

diff --git a/fio.1 b/fio.1
index 5e97f6623136a3bcdc1c058f72fa10c1d66d21a0..0517e33fa87e698c4ee08f6dc2eeeacedf7d9127 100644 (file)
--- a/fio.1
+++ b/fio.1
@@ -416,8 +416,9 @@ itself and for debugging and testing purposes.
 .TP
 .B net
 Transfer over the network.  \fBfilename\fR must be set appropriately to
-`\fIhost\fR/\fIport\fR' regardless of data direction.  If receiving, only the
-\fIport\fR argument is used.
+`\fIhost\fR,\fIport\fR,\fItype\fR' regardless of data direction. \fItype\fR
+is one of \fBtcp\fR, \fBudp\fR, or \fBunix\fR. For UNIX domain sockets,
+the \fIhost\fR parameter is a file system path.
 .TP
 .B netsplice
 Like \fBnet\fR, but uses \fIsplice\fR\|(2) and \fIvmsplice\fR\|(2) to map data

diff --git a/options.c b/options.c
index f07cc7c42aedcee338fb5e9a7b7a7bbf773f4998..580d5aa5b95800d707c3fff92a719cc4ac4b1c76 100644 (file)
--- a/options.c
+++ b/options.c
@@ -595,6 +595,14 @@ static char *get_next_file_name(char **ptr)
        return start;
 }
 
+static int str_hostname_cb(void *data, const char *input)
+{
+       struct thread_data *td = data;
+
+       td->o.filename = strdup(input);
+       return 0;
+}
+
 static int str_filename_cb(void *data, const char *input)
 {
        struct thread_data *td = data;
@@ -871,6 +879,12 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .prio   = -1, /* must come after "directory" */
                .help   = "File(s) to use for the workload",
        },
+       {
+               .name   = "hostname",
+               .type   = FIO_OPT_STR_STORE,
+               .cb     = str_hostname_cb,
+               .help   = "Hostname for net IO engine",
+       },
        {
                .name   = "kb_base",
                .type   = FIO_OPT_INT,