7c0a4eb41c010f75f97a25023f1a5897160a10c3
[fio.git] / engines / net.c
1 /*
2  * net engine
3  *
4  * IO engine that reads/writes to/from sockets.
5  *
6  */
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <unistd.h>
10 #include <signal.h>
11 #include <errno.h>
12 #include <assert.h>
13 #include <netinet/in.h>
14 #include <netinet/tcp.h>
15 #include <arpa/inet.h>
16 #include <netdb.h>
17 #include <sys/poll.h>
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <sys/socket.h>
21 #include <sys/un.h>
22
23 #include "../fio.h"
24 #include "../verify.h"
25
26 struct netio_data {
27         int listenfd;
28         int use_splice;
29         int seq_off;
30         int pipes[2];
31         struct sockaddr_in addr;
32         struct sockaddr_in6 addr6;
33         struct sockaddr_un addr_un;
34         uint64_t udp_send_seq;
35         uint64_t udp_recv_seq;
36 };
37
38 struct netio_options {
39         struct thread_data *td;
40         unsigned int port;
41         unsigned int proto;
42         unsigned int listen;
43         unsigned int pingpong;
44         unsigned int nodelay;
45         unsigned int ttl;
46         unsigned int window_size;
47         unsigned int mss;
48         char *intfc;
49 };
50
51 struct udp_close_msg {
52         uint32_t magic;
53         uint32_t cmd;
54 };
55
56 struct udp_seq {
57         uint64_t magic;
58         uint64_t seq;
59         uint64_t bs;
60 };
61
62 enum {
63         FIO_LINK_CLOSE = 0x89,
64         FIO_LINK_OPEN_CLOSE_MAGIC = 0x6c696e6b,
65         FIO_LINK_OPEN = 0x98,
66         FIO_UDP_SEQ_MAGIC = 0x657375716e556563ULL,
67
68         FIO_TYPE_TCP    = 1,
69         FIO_TYPE_UDP    = 2,
70         FIO_TYPE_UNIX   = 3,
71         FIO_TYPE_TCP_V6 = 4,
72         FIO_TYPE_UDP_V6 = 5,
73 };
74
75 static int str_hostname_cb(void *data, const char *input);
76 static struct fio_option options[] = {
77         {
78                 .name   = "hostname",
79                 .lname  = "net engine hostname",
80                 .type   = FIO_OPT_STR_STORE,
81                 .cb     = str_hostname_cb,
82                 .help   = "Hostname for net IO engine",
83                 .category = FIO_OPT_C_ENGINE,
84                 .group  = FIO_OPT_G_NETIO,
85         },
86         {
87                 .name   = "port",
88                 .lname  = "net engine port",
89                 .type   = FIO_OPT_INT,
90                 .off1   = offsetof(struct netio_options, port),
91                 .minval = 1,
92                 .maxval = 65535,
93                 .help   = "Port to use for TCP or UDP net connections",
94                 .category = FIO_OPT_C_ENGINE,
95                 .group  = FIO_OPT_G_NETIO,
96         },
97         {
98                 .name   = "protocol",
99                 .lname  = "net engine protocol",
100                 .alias  = "proto",
101                 .type   = FIO_OPT_STR,
102                 .off1   = offsetof(struct netio_options, proto),
103                 .help   = "Network protocol to use",
104                 .def    = "tcp",
105                 .posval = {
106                           { .ival = "tcp",
107                             .oval = FIO_TYPE_TCP,
108                             .help = "Transmission Control Protocol",
109                           },
110 #ifdef CONFIG_IPV6
111                           { .ival = "tcpv6",
112                             .oval = FIO_TYPE_TCP_V6,
113                             .help = "Transmission Control Protocol V6",
114                           },
115 #endif
116                           { .ival = "udp",
117                             .oval = FIO_TYPE_UDP,
118                             .help = "User Datagram Protocol",
119                           },
120 #ifdef CONFIG_IPV6
121                           { .ival = "udpv6",
122                             .oval = FIO_TYPE_UDP_V6,
123                             .help = "User Datagram Protocol V6",
124                           },
125 #endif
126                           { .ival = "unix",
127                             .oval = FIO_TYPE_UNIX,
128                             .help = "UNIX domain socket",
129                           },
130                 },
131                 .category = FIO_OPT_C_ENGINE,
132                 .group  = FIO_OPT_G_NETIO,
133         },
134 #ifdef CONFIG_TCP_NODELAY
135         {
136                 .name   = "nodelay",
137                 .type   = FIO_OPT_BOOL,
138                 .off1   = offsetof(struct netio_options, nodelay),
139                 .help   = "Use TCP_NODELAY on TCP connections",
140                 .category = FIO_OPT_C_ENGINE,
141                 .group  = FIO_OPT_G_NETIO,
142         },
143 #endif
144         {
145                 .name   = "listen",
146                 .lname  = "net engine listen",
147                 .type   = FIO_OPT_STR_SET,
148                 .off1   = offsetof(struct netio_options, listen),
149                 .help   = "Listen for incoming TCP connections",
150                 .category = FIO_OPT_C_ENGINE,
151                 .group  = FIO_OPT_G_NETIO,
152         },
153         {
154                 .name   = "pingpong",
155                 .type   = FIO_OPT_STR_SET,
156                 .off1   = offsetof(struct netio_options, pingpong),
157                 .help   = "Ping-pong IO requests",
158                 .category = FIO_OPT_C_ENGINE,
159                 .group  = FIO_OPT_G_NETIO,
160         },
161         {
162                 .name   = "interface",
163                 .lname  = "net engine interface",
164                 .type   = FIO_OPT_STR_STORE,
165                 .off1   = offsetof(struct netio_options, intfc),
166                 .help   = "Network interface to use",
167                 .category = FIO_OPT_C_ENGINE,
168                 .group  = FIO_OPT_G_NETIO,
169         },
170         {
171                 .name   = "ttl",
172                 .lname  = "net engine multicast ttl",
173                 .type   = FIO_OPT_INT,
174                 .off1   = offsetof(struct netio_options, ttl),
175                 .def    = "1",
176                 .minval = 0,
177                 .help   = "Time-to-live value for outgoing UDP multicast packets",
178                 .category = FIO_OPT_C_ENGINE,
179                 .group  = FIO_OPT_G_NETIO,
180         },
181 #ifdef CONFIG_NET_WINDOWSIZE
182         {
183                 .name   = "window_size",
184                 .lname  = "Window Size",
185                 .type   = FIO_OPT_INT,
186                 .off1   = offsetof(struct netio_options, window_size),
187                 .minval = 0,
188                 .help   = "Set socket buffer window size",
189                 .category = FIO_OPT_C_ENGINE,
190                 .group  = FIO_OPT_G_NETIO,
191         },
192 #endif
193 #ifdef CONFIG_NET_MSS
194         {
195                 .name   = "mss",
196                 .lname  = "Maximum segment size",
197                 .type   = FIO_OPT_INT,
198                 .off1   = offsetof(struct netio_options, mss),
199                 .minval = 0,
200                 .help   = "Set TCP maximum segment size",
201                 .category = FIO_OPT_C_ENGINE,
202                 .group  = FIO_OPT_G_NETIO,
203         },
204 #endif
205         {
206                 .name   = NULL,
207         },
208 };
209
210 static inline int is_udp(struct netio_options *o)
211 {
212         return o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_UDP_V6;
213 }
214
215 static inline int is_tcp(struct netio_options *o)
216 {
217         return o->proto == FIO_TYPE_TCP || o->proto == FIO_TYPE_TCP_V6;
218 }
219
220 static inline int is_ipv6(struct netio_options *o)
221 {
222         return o->proto == FIO_TYPE_UDP_V6 || o->proto == FIO_TYPE_TCP_V6;
223 }
224
225 static int set_window_size(struct thread_data *td, int fd)
226 {
227 #ifdef CONFIG_NET_WINDOWSIZE
228         struct netio_options *o = td->eo;
229         unsigned int wss;
230         int snd, rcv, ret;
231
232         if (!o->window_size)
233                 return 0;
234
235         rcv = o->listen || o->pingpong;
236         snd = !o->listen || o->pingpong;
237         wss = o->window_size;
238         ret = 0;
239
240         if (rcv) {
241                 ret = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (void *) &wss,
242                                         sizeof(wss));
243                 if (ret < 0)
244                         td_verror(td, errno, "rcvbuf window size");
245         }
246         if (snd && !ret) {
247                 ret = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (void *) &wss,
248                                         sizeof(wss));
249                 if (ret < 0)
250                         td_verror(td, errno, "sndbuf window size");
251         }
252
253         return ret;
254 #else
255         td_verror(td, -EINVAL, "setsockopt window size");
256         return -1;
257 #endif
258 }
259
260 static int set_mss(struct thread_data *td, int fd)
261 {
262 #ifdef CONFIG_NET_MSS
263         struct netio_options *o = td->eo;
264         unsigned int mss;
265         int ret;
266
267         if (!o->mss || !is_tcp(o))
268                 return 0;
269
270         mss = o->mss;
271         ret = setsockopt(fd, IPPROTO_TCP, TCP_MAXSEG, (void *) &mss,
272                                 sizeof(mss));
273         if (ret < 0)
274                 td_verror(td, errno, "setsockopt TCP_MAXSEG");
275
276         return ret;
277 #else
278         td_verror(td, -EINVAL, "setsockopt TCP_MAXSEG");
279         return -1;
280 #endif
281 }
282
283
284 /*
285  * Return -1 for error and 'nr events' for a positive number
286  * of events
287  */
288 static int poll_wait(struct thread_data *td, int fd, short events)
289 {
290         struct pollfd pfd;
291         int ret;
292
293         while (!td->terminate) {
294                 pfd.fd = fd;
295                 pfd.events = events;
296                 ret = poll(&pfd, 1, -1);
297                 if (ret < 0) {
298                         if (errno == EINTR)
299                                 break;
300
301                         td_verror(td, errno, "poll");
302                         return -1;
303                 } else if (!ret)
304                         continue;
305
306                 break;
307         }
308
309         if (pfd.revents & events)
310                 return 1;
311
312         return -1;
313 }
314
315 static int fio_netio_is_multicast(const char *mcaddr)
316 {
317         in_addr_t addr = inet_network(mcaddr);
318         if (addr == -1)
319                 return 0;
320
321         if (inet_network("224.0.0.0") <= addr &&
322             inet_network("239.255.255.255") >= addr)
323                 return 1;
324
325         return 0;
326 }
327
328
329 static int fio_netio_prep(struct thread_data *td, struct io_u *io_u)
330 {
331         struct netio_options *o = td->eo;
332
333         /*
334          * Make sure we don't see spurious reads to a receiver, and vice versa
335          */
336         if (is_tcp(o))
337                 return 0;
338
339         if ((o->listen && io_u->ddir == DDIR_WRITE) ||
340             (!o->listen && io_u->ddir == DDIR_READ)) {
341                 td_verror(td, EINVAL, "bad direction");
342                 return 1;
343         }
344
345         return 0;
346 }
347
348 #ifdef CONFIG_LINUX_SPLICE
349 static int splice_io_u(int fdin, int fdout, unsigned int len)
350 {
351         int bytes = 0;
352
353         while (len) {
354                 int ret = splice(fdin, NULL, fdout, NULL, len, 0);
355
356                 if (ret < 0) {
357                         if (!bytes)
358                                 bytes = ret;
359
360                         break;
361                 } else if (!ret)
362                         break;
363
364                 bytes += ret;
365                 len -= ret;
366         }
367
368         return bytes;
369 }
370
371 /*
372  * Receive bytes from a socket and fill them into the internal pipe
373  */
374 static int splice_in(struct thread_data *td, struct io_u *io_u)
375 {
376         struct netio_data *nd = td->io_ops->data;
377
378         return splice_io_u(io_u->file->fd, nd->pipes[1], io_u->xfer_buflen);
379 }
380
381 /*
382  * Transmit 'len' bytes from the internal pipe
383  */
384 static int splice_out(struct thread_data *td, struct io_u *io_u,
385                       unsigned int len)
386 {
387         struct netio_data *nd = td->io_ops->data;
388
389         return splice_io_u(nd->pipes[0], io_u->file->fd, len);
390 }
391
392 static int vmsplice_io_u(struct io_u *io_u, int fd, unsigned int len)
393 {
394         struct iovec iov = {
395                 .iov_base = io_u->xfer_buf,
396                 .iov_len = len,
397         };
398         int bytes = 0;
399
400         while (iov.iov_len) {
401                 int ret = vmsplice(fd, &iov, 1, SPLICE_F_MOVE);
402
403                 if (ret < 0) {
404                         if (!bytes)
405                                 bytes = ret;
406                         break;
407                 } else if (!ret)
408                         break;
409
410                 iov.iov_len -= ret;
411                 iov.iov_base += ret;
412                 bytes += ret;
413         }
414
415         return bytes;
416
417 }
418
419 /*
420  * vmsplice() pipe to io_u buffer
421  */
422 static int vmsplice_io_u_out(struct thread_data *td, struct io_u *io_u,
423                              unsigned int len)
424 {
425         struct netio_data *nd = td->io_ops->data;
426
427         return vmsplice_io_u(io_u, nd->pipes[0], len);
428 }
429
430 /*
431  * vmsplice() io_u to pipe
432  */
433 static int vmsplice_io_u_in(struct thread_data *td, struct io_u *io_u)
434 {
435         struct netio_data *nd = td->io_ops->data;
436
437         return vmsplice_io_u(io_u, nd->pipes[1], io_u->xfer_buflen);
438 }
439
440 /*
441  * splice receive - transfer socket data into a pipe using splice, then map
442  * that pipe data into the io_u using vmsplice.
443  */
444 static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
445 {
446         int ret;
447
448         ret = splice_in(td, io_u);
449         if (ret > 0)
450                 return vmsplice_io_u_out(td, io_u, ret);
451
452         return ret;
453 }
454
455 /*
456  * splice transmit - map data from the io_u into a pipe by using vmsplice,
457  * then transfer that pipe to a socket using splice.
458  */
459 static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
460 {
461         int ret;
462
463         ret = vmsplice_io_u_in(td, io_u);
464         if (ret > 0)
465                 return splice_out(td, io_u, ret);
466
467         return ret;
468 }
469 #else
470 static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
471 {
472         errno = EOPNOTSUPP;
473         return -1;
474 }
475
476 static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
477 {
478         errno = EOPNOTSUPP;
479         return -1;
480 }
481 #endif
482
483 static void store_udp_seq(struct netio_data *nd, struct io_u *io_u)
484 {
485         struct udp_seq *us;
486
487         us = io_u->xfer_buf + io_u->xfer_buflen - sizeof(*us);
488         us->magic = cpu_to_le64(FIO_UDP_SEQ_MAGIC);
489         us->bs = cpu_to_le64((uint64_t) io_u->xfer_buflen);
490         us->seq = cpu_to_le64(nd->udp_send_seq++);
491 }
492
493 static void verify_udp_seq(struct thread_data *td, struct netio_data *nd,
494                            struct io_u *io_u)
495 {
496         struct udp_seq *us;
497         uint64_t seq;
498
499         if (nd->seq_off)
500                 return;
501
502         us = io_u->xfer_buf + io_u->xfer_buflen - sizeof(*us);
503         if (le64_to_cpu(us->magic) != FIO_UDP_SEQ_MAGIC)
504                 return;
505         if (le64_to_cpu(us->bs) != io_u->xfer_buflen) {
506                 nd->seq_off = 1;
507                 return;
508         }
509
510         seq = le64_to_cpu(us->seq);
511
512         if (seq != nd->udp_recv_seq)
513                 td->ts.drop_io_u[io_u->ddir] += seq - nd->udp_recv_seq;
514
515         nd->udp_recv_seq = seq + 1;
516 }
517
518 static int fio_netio_send(struct thread_data *td, struct io_u *io_u)
519 {
520         struct netio_data *nd = td->io_ops->data;
521         struct netio_options *o = td->eo;
522         int ret, flags = 0;
523
524         do {
525                 if (is_udp(o)) {
526                         const struct sockaddr *to;
527                         socklen_t len;
528
529                         if (is_ipv6(o)) {
530                                 to = (struct sockaddr *) &nd->addr6;
531                                 len = sizeof(nd->addr6);
532                         } else {
533                                 to = (struct sockaddr *) &nd->addr;
534                                 len = sizeof(nd->addr);
535                         }
536
537                         if (td->o.verify == VERIFY_NONE)
538                                 store_udp_seq(nd, io_u);
539
540                         ret = sendto(io_u->file->fd, io_u->xfer_buf,
541                                         io_u->xfer_buflen, flags, to, len);
542                 } else {
543                         /*
544                          * if we are going to write more, set MSG_MORE
545                          */
546 #ifdef MSG_MORE
547                         if ((td->this_io_bytes[DDIR_WRITE] + io_u->xfer_buflen <
548                             td->o.size) && !o->pingpong)
549                                 flags |= MSG_MORE;
550 #endif
551                         ret = send(io_u->file->fd, io_u->xfer_buf,
552                                         io_u->xfer_buflen, flags);
553                 }
554                 if (ret > 0)
555                         break;
556
557                 ret = poll_wait(td, io_u->file->fd, POLLOUT);
558                 if (ret <= 0)
559                         break;
560         } while (1);
561
562         return ret;
563 }
564
565 static int is_close_msg(struct io_u *io_u, int len)
566 {
567         struct udp_close_msg *msg;
568
569         if (len != sizeof(struct udp_close_msg))
570                 return 0;
571
572         msg = io_u->xfer_buf;
573         if (le32_to_cpu(msg->magic) != FIO_LINK_OPEN_CLOSE_MAGIC)
574                 return 0;
575         if (le32_to_cpu(msg->cmd) != FIO_LINK_CLOSE)
576                 return 0;
577
578         return 1;
579 }
580
581 static int fio_netio_recv(struct thread_data *td, struct io_u *io_u)
582 {
583         struct netio_data *nd = td->io_ops->data;
584         struct netio_options *o = td->eo;
585         int ret, flags = 0;
586
587         do {
588                 if (is_udp(o)) {
589                         struct sockaddr *from;
590                         socklen_t l, *len = &l;
591
592                         if (o->listen) {
593                                 if (!is_ipv6(o)) {
594                                         from = (struct sockaddr *) &nd->addr;
595                                         *len = sizeof(nd->addr);
596                                 } else {
597                                         from = (struct sockaddr *) &nd->addr6;
598                                         *len = sizeof(nd->addr6);
599                                 }
600                         } else {
601                                 from = NULL;
602                                 len = NULL;
603                         }
604
605                         ret = recvfrom(io_u->file->fd, io_u->xfer_buf,
606                                         io_u->xfer_buflen, flags, from, len);
607
608                         if (is_close_msg(io_u, ret)) {
609                                 td->done = 1;
610                                 return 0;
611                         }
612                 } else {
613                         ret = recv(io_u->file->fd, io_u->xfer_buf,
614                                         io_u->xfer_buflen, flags);
615
616                         if (is_close_msg(io_u, ret)) {
617                                 td->done = 1;
618                                 return 0;
619                         }
620                 }
621                 if (ret > 0)
622                         break;
623                 else if (!ret && (flags & MSG_WAITALL))
624                         break;
625
626                 ret = poll_wait(td, io_u->file->fd, POLLIN);
627                 if (ret <= 0)
628                         break;
629                 flags |= MSG_WAITALL;
630         } while (1);
631
632         if (is_udp(o) && td->o.verify == VERIFY_NONE)
633                 verify_udp_seq(td, nd, io_u);
634
635         return ret;
636 }
637
638 static int __fio_netio_queue(struct thread_data *td, struct io_u *io_u,
639                              enum fio_ddir ddir)
640 {
641         struct netio_data *nd = td->io_ops->data;
642         struct netio_options *o = td->eo;
643         int ret;
644
645         if (ddir == DDIR_WRITE) {
646                 if (!nd->use_splice || is_udp(o) ||
647                     o->proto == FIO_TYPE_UNIX)
648                         ret = fio_netio_send(td, io_u);
649                 else
650                         ret = fio_netio_splice_out(td, io_u);
651         } else if (ddir == DDIR_READ) {
652                 if (!nd->use_splice || is_udp(o) ||
653                     o->proto == FIO_TYPE_UNIX)
654                         ret = fio_netio_recv(td, io_u);
655                 else
656                         ret = fio_netio_splice_in(td, io_u);
657         } else
658                 ret = 0;        /* must be a SYNC */
659
660         if (ret != (int) io_u->xfer_buflen) {
661                 if (ret > 0) {
662                         io_u->resid = io_u->xfer_buflen - ret;
663                         io_u->error = 0;
664                         return FIO_Q_COMPLETED;
665                 } else if (!ret)
666                         return FIO_Q_BUSY;
667                 else {
668                         int err = errno;
669
670                         if (ddir == DDIR_WRITE && err == EMSGSIZE)
671                                 return FIO_Q_BUSY;
672
673                         io_u->error = err;
674                 }
675         }
676
677         if (io_u->error)
678                 td_verror(td, io_u->error, "xfer");
679
680         return FIO_Q_COMPLETED;
681 }
682
683 static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
684 {
685         struct netio_options *o = td->eo;
686         int ret;
687
688         fio_ro_check(td, io_u);
689
690         ret = __fio_netio_queue(td, io_u, io_u->ddir);
691         if (!o->pingpong || ret != FIO_Q_COMPLETED)
692                 return ret;
693
694         /*
695          * For ping-pong mode, receive or send reply as needed
696          */
697         if (td_read(td) && io_u->ddir == DDIR_READ)
698                 ret = __fio_netio_queue(td, io_u, DDIR_WRITE);
699         else if (td_write(td) && io_u->ddir == DDIR_WRITE)
700                 ret = __fio_netio_queue(td, io_u, DDIR_READ);
701
702         return ret;
703 }
704
705 static int fio_netio_connect(struct thread_data *td, struct fio_file *f)
706 {
707         struct netio_data *nd = td->io_ops->data;
708         struct netio_options *o = td->eo;
709         int type, domain;
710
711         if (o->proto == FIO_TYPE_TCP) {
712                 domain = AF_INET;
713                 type = SOCK_STREAM;
714         } else if (o->proto == FIO_TYPE_TCP_V6) {
715                 domain = AF_INET6;
716                 type = SOCK_STREAM;
717         } else if (o->proto == FIO_TYPE_UDP) {
718                 domain = AF_INET;
719                 type = SOCK_DGRAM;
720         } else if (o->proto == FIO_TYPE_UDP_V6) {
721                 domain = AF_INET6;
722                 type = SOCK_DGRAM;
723         } else if (o->proto == FIO_TYPE_UNIX) {
724                 domain = AF_UNIX;
725                 type = SOCK_STREAM;
726         } else {
727                 log_err("fio: bad network type %d\n", o->proto);
728                 f->fd = -1;
729                 return 1;
730         }
731
732         f->fd = socket(domain, type, 0);
733         if (f->fd < 0) {
734                 td_verror(td, errno, "socket");
735                 return 1;
736         }
737
738 #ifdef CONFIG_TCP_NODELAY
739         if (o->nodelay && is_tcp(o)) {
740                 int optval = 1;
741
742                 if (setsockopt(f->fd, IPPROTO_TCP, TCP_NODELAY, (void *) &optval, sizeof(int)) < 0) {
743                         log_err("fio: cannot set TCP_NODELAY option on socket (%s), disable with 'nodelay=0'\n", strerror(errno));
744                         return 1;
745                 }
746         }
747 #endif
748
749         if (set_window_size(td, f->fd)) {
750                 close(f->fd);
751                 return 1;
752         }
753         if (set_mss(td, f->fd)) {
754                 close(f->fd);
755                 return 1;
756         }
757
758         if (is_udp(o)) {
759                 if (!fio_netio_is_multicast(td->o.filename))
760                         return 0;
761                 if (is_ipv6(o)) {
762                         log_err("fio: multicast not supported on IPv6\n");
763                         close(f->fd);
764                         return 1;
765                 }
766
767                 if (o->intfc) {
768                         struct in_addr interface_addr;
769
770                         if (inet_aton(o->intfc, &interface_addr) == 0) {
771                                 log_err("fio: interface not valid interface IP\n");
772                                 close(f->fd);
773                                 return 1;
774                         }
775                         if (setsockopt(f->fd, IPPROTO_IP, IP_MULTICAST_IF, (const char*)&interface_addr, sizeof(interface_addr)) < 0) {
776                                 td_verror(td, errno, "setsockopt IP_MULTICAST_IF");
777                                 close(f->fd);
778                                 return 1;
779                         }
780                 }
781                 if (setsockopt(f->fd, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&o->ttl, sizeof(o->ttl)) < 0) {
782                         td_verror(td, errno, "setsockopt IP_MULTICAST_TTL");
783                         close(f->fd);
784                         return 1;
785                 }
786                 return 0;
787         } else if (o->proto == FIO_TYPE_TCP) {
788                 socklen_t len = sizeof(nd->addr);
789
790                 if (connect(f->fd, (struct sockaddr *) &nd->addr, len) < 0) {
791                         td_verror(td, errno, "connect");
792                         close(f->fd);
793                         return 1;
794                 }
795         } else if (o->proto == FIO_TYPE_TCP_V6) {
796                 socklen_t len = sizeof(nd->addr6);
797
798                 if (connect(f->fd, (struct sockaddr *) &nd->addr6, len) < 0) {
799                         td_verror(td, errno, "connect");
800                         close(f->fd);
801                         return 1;
802                 }
803
804         } else {
805                 struct sockaddr_un *addr = &nd->addr_un;
806                 socklen_t len;
807
808                 len = sizeof(addr->sun_family) + strlen(addr->sun_path) + 1;
809
810                 if (connect(f->fd, (struct sockaddr *) addr, len) < 0) {
811                         td_verror(td, errno, "connect");
812                         close(f->fd);
813                         return 1;
814                 }
815         }
816
817         return 0;
818 }
819
820 static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
821 {
822         struct netio_data *nd = td->io_ops->data;
823         struct netio_options *o = td->eo;
824         socklen_t socklen;
825         int state;
826
827         if (is_udp(o)) {
828                 f->fd = nd->listenfd;
829                 return 0;
830         }
831
832         state = td->runstate;
833         td_set_runstate(td, TD_SETTING_UP);
834
835         log_info("fio: waiting for connection\n");
836
837         if (poll_wait(td, nd->listenfd, POLLIN) < 0)
838                 goto err;
839
840         if (o->proto == FIO_TYPE_TCP) {
841                 socklen = sizeof(nd->addr);
842                 f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr, &socklen);
843         } else {
844                 socklen = sizeof(nd->addr6);
845                 f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr6, &socklen);
846         }
847
848         if (f->fd < 0) {
849                 td_verror(td, errno, "accept");
850                 goto err;
851         }
852
853 #ifdef CONFIG_TCP_NODELAY
854         if (o->nodelay && is_tcp(o)) {
855                 int optval = 1;
856
857                 if (setsockopt(f->fd, IPPROTO_TCP, TCP_NODELAY, (void *) &optval, sizeof(int)) < 0) {
858                         log_err("fio: cannot set TCP_NODELAY option on socket (%s), disable with 'nodelay=0'\n", strerror(errno));
859                         return 1;
860                 }
861         }
862 #endif
863
864         reset_all_stats(td);
865         td_set_runstate(td, state);
866         return 0;
867 err:
868         td_set_runstate(td, state);
869         return 1;
870 }
871
872 static void fio_netio_send_close(struct thread_data *td, struct fio_file *f)
873 {
874         struct netio_data *nd = td->io_ops->data;
875         struct netio_options *o = td->eo;
876         struct udp_close_msg msg;
877         struct sockaddr *to;
878         socklen_t len;
879         int ret;
880
881         if (is_ipv6(o)) {
882                 to = (struct sockaddr *) &nd->addr6;
883                 len = sizeof(nd->addr6);
884         } else {
885                 to = (struct sockaddr *) &nd->addr;
886                 len = sizeof(nd->addr);
887         }
888
889         msg.magic = cpu_to_le32((uint32_t) FIO_LINK_OPEN_CLOSE_MAGIC);
890         msg.cmd = cpu_to_le32((uint32_t) FIO_LINK_CLOSE);
891
892         ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to, len);
893         if (ret < 0)
894                 td_verror(td, errno, "sendto udp link close");
895 }
896
897 static int fio_netio_close_file(struct thread_data *td, struct fio_file *f)
898 {
899         /*
900          * Notify the receiver that we are closing down the link
901          */
902         fio_netio_send_close(td, f);
903
904         return generic_close_file(td, f);
905 }
906
907 static int fio_netio_udp_recv_open(struct thread_data *td, struct fio_file *f)
908 {
909         struct netio_data *nd = td->io_ops->data;
910         struct netio_options *o = td->eo;
911         struct udp_close_msg msg;
912         struct sockaddr *to;
913         socklen_t len;
914         int ret;
915
916         if (is_ipv6(o)) {
917                 len = sizeof(nd->addr6);
918                 to = (struct sockaddr *) &nd->addr6;
919         } else {
920                 len = sizeof(nd->addr);
921                 to = (struct sockaddr *) &nd->addr;
922         }
923
924         ret = recvfrom(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to, &len);
925         if (ret < 0) {
926                 td_verror(td, errno, "recvfrom udp link open");
927                 return ret;
928         }
929
930         if (ntohl(msg.magic) != FIO_LINK_OPEN_CLOSE_MAGIC ||
931             ntohl(msg.cmd) != FIO_LINK_OPEN) {
932                 log_err("fio: bad udp open magic %x/%x\n", ntohl(msg.magic),
933                                                                 ntohl(msg.cmd));
934                 return -1;
935         }
936
937         fio_gettime(&td->start, NULL);
938         return 0;
939 }
940
941 static int fio_netio_send_open(struct thread_data *td, struct fio_file *f)
942 {
943         struct netio_data *nd = td->io_ops->data;
944         struct netio_options *o = td->eo;
945         struct udp_close_msg msg;
946         struct sockaddr *to;
947         socklen_t len;
948         int ret;
949
950         if (is_ipv6(o)) {
951                 len = sizeof(nd->addr6);
952                 to = (struct sockaddr *) &nd->addr6;
953         } else {
954                 len = sizeof(nd->addr);
955                 to = (struct sockaddr *) &nd->addr;
956         }
957
958         msg.magic = htonl(FIO_LINK_OPEN_CLOSE_MAGIC);
959         msg.cmd = htonl(FIO_LINK_OPEN);
960
961         ret = sendto(f->fd, (void *) &msg, sizeof(msg), MSG_WAITALL, to, len);
962         if (ret < 0) {
963                 td_verror(td, errno, "sendto udp link open");
964                 return ret;
965         }
966
967         return 0;
968 }
969
970 static int fio_netio_open_file(struct thread_data *td, struct fio_file *f)
971 {
972         int ret;
973         struct netio_options *o = td->eo;
974
975         if (o->listen)
976                 ret = fio_netio_accept(td, f);
977         else
978                 ret = fio_netio_connect(td, f);
979
980         if (ret) {
981                 f->fd = -1;
982                 return ret;
983         }
984
985         if (is_udp(o)) {
986                 if (td_write(td))
987                         ret = fio_netio_send_open(td, f);
988                 else {
989                         int state;
990
991                         state = td->runstate;
992                         td_set_runstate(td, TD_SETTING_UP);
993                         ret = fio_netio_udp_recv_open(td, f);
994                         td_set_runstate(td, state);
995                 }
996         }
997
998         if (ret)
999                 fio_netio_close_file(td, f);
1000
1001         return ret;
1002 }
1003
1004 static int fio_fill_addr(struct thread_data *td, const char *host, int af,
1005                          void *dst, struct addrinfo **res)
1006 {
1007         struct netio_options *o = td->eo;
1008         struct addrinfo hints;
1009         int ret;
1010
1011         if (inet_pton(af, host, dst))
1012                 return 0;
1013
1014         memset(&hints, 0, sizeof(hints));
1015
1016         if (is_tcp(o))
1017                 hints.ai_socktype = SOCK_STREAM;
1018         else
1019                 hints.ai_socktype = SOCK_DGRAM;
1020
1021         if (is_ipv6(o))
1022                 hints.ai_family = AF_INET6;
1023         else
1024                 hints.ai_family = AF_INET;
1025
1026         ret = getaddrinfo(host, NULL, &hints, res);
1027         if (ret) {
1028                 int e = EINVAL;
1029                 char str[128];
1030
1031                 if (ret == EAI_SYSTEM)
1032                         e = errno;
1033
1034                 snprintf(str, sizeof(str), "getaddrinfo: %s", gai_strerror(ret));
1035                 td_verror(td, e, str);
1036                 return 1;
1037         }
1038
1039         return 0;
1040 }
1041
1042 static int fio_netio_setup_connect_inet(struct thread_data *td,
1043                                         const char *host, unsigned short port)
1044 {
1045         struct netio_data *nd = td->io_ops->data;
1046         struct netio_options *o = td->eo;
1047         struct addrinfo *res = NULL;
1048         void *dst, *src;
1049         int af, len;
1050
1051         if (!host) {
1052                 log_err("fio: connect with no host to connect to.\n");
1053                 if (td_read(td))
1054                         log_err("fio: did you forget to set 'listen'?\n");
1055
1056                 td_verror(td, EINVAL, "no hostname= set");
1057                 return 1;
1058         }
1059
1060         nd->addr.sin_family = AF_INET;
1061         nd->addr.sin_port = htons(port);
1062         nd->addr6.sin6_family = AF_INET6;
1063         nd->addr6.sin6_port = htons(port);
1064
1065         if (is_ipv6(o)) {
1066                 af = AF_INET6;
1067                 dst = &nd->addr6.sin6_addr;
1068         } else {
1069                 af = AF_INET;
1070                 dst = &nd->addr.sin_addr;
1071         }
1072
1073         if (fio_fill_addr(td, host, af, dst, &res))
1074                 return 1;
1075
1076         if (!res)
1077                 return 0;
1078
1079         if (is_ipv6(o)) {
1080                 len = sizeof(nd->addr6.sin6_addr);
1081                 src = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
1082         } else {
1083                 len = sizeof(nd->addr.sin_addr);
1084                 src = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
1085         }
1086
1087         memcpy(dst, src, len);
1088         freeaddrinfo(res);
1089         return 0;
1090 }
1091
1092 static int fio_netio_setup_connect_unix(struct thread_data *td,
1093                                         const char *path)
1094 {
1095         struct netio_data *nd = td->io_ops->data;
1096         struct sockaddr_un *soun = &nd->addr_un;
1097
1098         soun->sun_family = AF_UNIX;
1099         memset(soun->sun_path, 0, sizeof(soun->sun_path));
1100         strncpy(soun->sun_path, path, sizeof(soun->sun_path) - 1);
1101         return 0;
1102 }
1103
1104 static int fio_netio_setup_connect(struct thread_data *td)
1105 {
1106         struct netio_options *o = td->eo;
1107
1108         if (is_udp(o) || is_tcp(o))
1109                 return fio_netio_setup_connect_inet(td, td->o.filename,o->port);
1110         else
1111                 return fio_netio_setup_connect_unix(td, td->o.filename);
1112 }
1113
1114 static int fio_netio_setup_listen_unix(struct thread_data *td, const char *path)
1115 {
1116         struct netio_data *nd = td->io_ops->data;
1117         struct sockaddr_un *addr = &nd->addr_un;
1118         mode_t mode;
1119         int len, fd;
1120
1121         fd = socket(AF_UNIX, SOCK_STREAM, 0);
1122         if (fd < 0) {
1123                 log_err("fio: socket: %s\n", strerror(errno));
1124                 return -1;
1125         }
1126
1127         mode = umask(000);
1128
1129         memset(addr, 0, sizeof(*addr));
1130         addr->sun_family = AF_UNIX;
1131         strncpy(addr->sun_path, path, sizeof(addr->sun_path) - 1);
1132         unlink(path);
1133
1134         len = sizeof(addr->sun_family) + strlen(path) + 1;
1135
1136         if (bind(fd, (struct sockaddr *) addr, len) < 0) {
1137                 log_err("fio: bind: %s\n", strerror(errno));
1138                 close(fd);
1139                 return -1;
1140         }
1141
1142         umask(mode);
1143         nd->listenfd = fd;
1144         return 0;
1145 }
1146
1147 static int fio_netio_setup_listen_inet(struct thread_data *td, short port)
1148 {
1149         struct netio_data *nd = td->io_ops->data;
1150         struct netio_options *o = td->eo;
1151         struct ip_mreq mr;
1152         struct sockaddr_in sin;
1153         struct sockaddr *saddr;
1154         int fd, opt, type, domain;
1155         socklen_t len;
1156
1157         memset(&sin, 0, sizeof(sin));
1158
1159         if (o->proto == FIO_TYPE_TCP) {
1160                 type = SOCK_STREAM;
1161                 domain = AF_INET;
1162         } else if (o->proto == FIO_TYPE_TCP_V6) {
1163                 type = SOCK_STREAM;
1164                 domain = AF_INET6;
1165         } else if (o->proto == FIO_TYPE_UDP) {
1166                 type = SOCK_DGRAM;
1167                 domain = AF_INET;
1168         } else if (o->proto == FIO_TYPE_UDP_V6) {
1169                 type = SOCK_DGRAM;
1170                 domain = AF_INET6;
1171         } else {
1172                 log_err("fio: unknown proto %d\n", o->proto);
1173                 return 1;
1174         }
1175
1176         fd = socket(domain, type, 0);
1177         if (fd < 0) {
1178                 td_verror(td, errno, "socket");
1179                 return 1;
1180         }
1181
1182         opt = 1;
1183         if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *) &opt, sizeof(opt)) < 0) {
1184                 td_verror(td, errno, "setsockopt");
1185                 close(fd);
1186                 return 1;
1187         }
1188 #ifdef SO_REUSEPORT
1189         if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (void *) &opt, sizeof(opt)) < 0) {
1190                 td_verror(td, errno, "setsockopt");
1191                 close(fd);
1192                 return 1;
1193         }
1194 #endif
1195
1196         if (set_window_size(td, fd)) {
1197                 close(fd);
1198                 return 1;
1199         }
1200         if (set_mss(td, fd)) {
1201                 close(fd);
1202                 return 1;
1203         }
1204
1205         if (td->o.filename) {
1206                 if (!is_udp(o) || !fio_netio_is_multicast(td->o.filename)) {
1207                         log_err("fio: hostname not valid for non-multicast inbound network IO\n");
1208                         close(fd);
1209                         return 1;
1210                 }
1211                 if (is_ipv6(o)) {
1212                         log_err("fio: IPv6 not supported for multicast network IO");
1213                         close(fd);
1214                         return 1;
1215                 }
1216
1217                 inet_aton(td->o.filename, &sin.sin_addr);
1218
1219                 mr.imr_multiaddr = sin.sin_addr;
1220                 if (o->intfc) {
1221                         if (inet_aton(o->intfc, &mr.imr_interface) == 0) {
1222                                 log_err("fio: interface not valid interface IP\n");
1223                                 close(fd);
1224                                 return 1;
1225                         }
1226                 } else {
1227                         mr.imr_interface.s_addr = htonl(INADDR_ANY);
1228                 }
1229
1230                 if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char*)&mr, sizeof(mr)) < 0) {
1231                         td_verror(td, errno, "setsockopt IP_ADD_MEMBERSHIP");
1232                         close(fd);
1233                         return 1;
1234                 }
1235         }
1236
1237         if (!is_ipv6(o)) {
1238                 saddr = (struct sockaddr *) &nd->addr;
1239                 len = sizeof(nd->addr);
1240
1241                 nd->addr.sin_family = AF_INET;
1242                 nd->addr.sin_addr.s_addr = sin.sin_addr.s_addr ? sin.sin_addr.s_addr : htonl(INADDR_ANY);
1243                 nd->addr.sin_port = htons(port);
1244         } else {
1245                 saddr = (struct sockaddr *) &nd->addr6;
1246                 len = sizeof(nd->addr6);
1247
1248                 nd->addr6.sin6_family = AF_INET6;
1249                 nd->addr6.sin6_addr = in6addr_any;
1250                 nd->addr6.sin6_port = htons(port);
1251         }
1252
1253         if (bind(fd, saddr, len) < 0) {
1254                 close(fd);
1255                 td_verror(td, errno, "bind");
1256                 return 1;
1257         }
1258
1259         nd->listenfd = fd;
1260         return 0;
1261 }
1262
1263 static int fio_netio_setup_listen(struct thread_data *td)
1264 {
1265         struct netio_data *nd = td->io_ops->data;
1266         struct netio_options *o = td->eo;
1267         int ret;
1268
1269         if (is_udp(o) || is_tcp(o))
1270                 ret = fio_netio_setup_listen_inet(td, o->port);
1271         else
1272                 ret = fio_netio_setup_listen_unix(td, td->o.filename);
1273
1274         if (ret)
1275                 return ret;
1276         if (is_udp(o))
1277                 return 0;
1278
1279         if (listen(nd->listenfd, 10) < 0) {
1280                 td_verror(td, errno, "listen");
1281                 nd->listenfd = -1;
1282                 return 1;
1283         }
1284
1285         return 0;
1286 }
1287
1288 static int fio_netio_init(struct thread_data *td)
1289 {
1290         struct netio_options *o = td->eo;
1291         int ret;
1292
1293 #ifdef WIN32
1294         WSADATA wsd;
1295         WSAStartup(MAKEWORD(2,2), &wsd);
1296 #endif
1297
1298         if (td_random(td)) {
1299                 log_err("fio: network IO can't be random\n");
1300                 return 1;
1301         }
1302
1303         if (o->proto == FIO_TYPE_UNIX && o->port) {
1304                 log_err("fio: network IO port not valid with unix socket\n");
1305                 return 1;
1306         } else if (o->proto != FIO_TYPE_UNIX && !o->port) {
1307                 log_err("fio: network IO requires port for tcp or udp\n");
1308                 return 1;
1309         }
1310
1311         if (!is_tcp(o)) {
1312                 if (o->listen) {
1313                         log_err("fio: listen only valid for TCP proto IO\n");
1314                         return 1;
1315                 }
1316                 if (td_rw(td)) {
1317                         log_err("fio: datagram network connections must be"
1318                                    " read OR write\n");
1319                         return 1;
1320                 }
1321                 if (o->proto == FIO_TYPE_UNIX && !td->o.filename) {
1322                         log_err("fio: UNIX sockets need host/filename\n");
1323                         return 1;
1324                 }
1325                 o->listen = td_read(td);
1326         }
1327
1328         if (o->listen)
1329                 ret = fio_netio_setup_listen(td);
1330         else
1331                 ret = fio_netio_setup_connect(td);
1332
1333         return ret;
1334 }
1335
1336 static void fio_netio_cleanup(struct thread_data *td)
1337 {
1338         struct netio_data *nd = td->io_ops->data;
1339
1340         if (nd) {
1341                 if (nd->listenfd != -1)
1342                         close(nd->listenfd);
1343                 if (nd->pipes[0] != -1)
1344                         close(nd->pipes[0]);
1345                 if (nd->pipes[1] != -1)
1346                         close(nd->pipes[1]);
1347
1348                 free(nd);
1349         }
1350 }
1351
1352 static int fio_netio_setup(struct thread_data *td)
1353 {
1354         struct netio_data *nd;
1355
1356         if (!td->files_index) {
1357                 add_file(td, td->o.filename ?: "net", 0, 0);
1358                 td->o.nr_files = td->o.nr_files ?: 1;
1359                 td->o.open_files++;
1360         }
1361
1362         if (!td->io_ops->data) {
1363                 nd = malloc(sizeof(*nd));;
1364
1365                 memset(nd, 0, sizeof(*nd));
1366                 nd->listenfd = -1;
1367                 nd->pipes[0] = nd->pipes[1] = -1;
1368                 td->io_ops->data = nd;
1369         }
1370
1371         return 0;
1372 }
1373
1374 static void fio_netio_terminate(struct thread_data *td)
1375 {
1376         kill(td->pid, SIGTERM);
1377 }
1378
1379 #ifdef CONFIG_LINUX_SPLICE
1380 static int fio_netio_setup_splice(struct thread_data *td)
1381 {
1382         struct netio_data *nd;
1383
1384         fio_netio_setup(td);
1385
1386         nd = td->io_ops->data;
1387         if (nd) {
1388                 if (pipe(nd->pipes) < 0)
1389                         return 1;
1390
1391                 nd->use_splice = 1;
1392                 return 0;
1393         }
1394
1395         return 1;
1396 }
1397
1398 static struct ioengine_ops ioengine_splice = {
1399         .name                   = "netsplice",
1400         .version                = FIO_IOOPS_VERSION,
1401         .prep                   = fio_netio_prep,
1402         .queue                  = fio_netio_queue,
1403         .setup                  = fio_netio_setup_splice,
1404         .init                   = fio_netio_init,
1405         .cleanup                = fio_netio_cleanup,
1406         .open_file              = fio_netio_open_file,
1407         .close_file             = fio_netio_close_file,
1408         .terminate              = fio_netio_terminate,
1409         .options                = options,
1410         .option_struct_size     = sizeof(struct netio_options),
1411         .flags                  = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
1412                                   FIO_PIPEIO,
1413 };
1414 #endif
1415
1416 static struct ioengine_ops ioengine_rw = {
1417         .name                   = "net",
1418         .version                = FIO_IOOPS_VERSION,
1419         .prep                   = fio_netio_prep,
1420         .queue                  = fio_netio_queue,
1421         .setup                  = fio_netio_setup,
1422         .init                   = fio_netio_init,
1423         .cleanup                = fio_netio_cleanup,
1424         .open_file              = fio_netio_open_file,
1425         .close_file             = fio_netio_close_file,
1426         .terminate              = fio_netio_terminate,
1427         .options                = options,
1428         .option_struct_size     = sizeof(struct netio_options),
1429         .flags                  = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
1430                                   FIO_PIPEIO | FIO_BIT_BASED,
1431 };
1432
1433 static int str_hostname_cb(void *data, const char *input)
1434 {
1435         struct netio_options *o = data;
1436
1437         if (o->td->o.filename)
1438                 free(o->td->o.filename);
1439         o->td->o.filename = strdup(input);
1440         return 0;
1441 }
1442
1443 static void fio_init fio_netio_register(void)
1444 {
1445         register_ioengine(&ioengine_rw);
1446 #ifdef CONFIG_LINUX_SPLICE
1447         register_ioengine(&ioengine_splice);
1448 #endif
1449 }
1450
1451 static void fio_exit fio_netio_unregister(void)
1452 {
1453         unregister_ioengine(&ioengine_rw);
1454 #ifdef CONFIG_LINUX_SPLICE
1455         unregister_ioengine(&ioengine_splice);
1456 #endif
1457 }