projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Change preferred default clocksource to gettimeofday()
[fio.git] / engines / net.c
... / ...
CommitLineData
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 <errno.h>
11#include <assert.h>
12#include <netinet/in.h>
13#include <arpa/inet.h>
14#include <netdb.h>
15#include <sys/poll.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18#include <sys/socket.h>
19#include <sys/un.h>
20
21#include "../fio.h"
22
23struct netio_data {
24 int listenfd;
25 int use_splice;
26 int pipes[2];
27 struct sockaddr_in addr;
28 struct sockaddr_un addr_un;
29};
30
31struct netio_options {
32 struct thread_data *td;
33 unsigned int port;
34 unsigned int proto;
35 unsigned int listen;
36 unsigned int pingpong;
37};
38
39struct udp_close_msg {
40 uint32_t magic;
41 uint32_t cmd;
42};
43
44enum {
45 FIO_LINK_CLOSE = 0x89,
46 FIO_LINK_OPEN_CLOSE_MAGIC = 0x6c696e6b,
47 FIO_LINK_OPEN = 0x98,
48
49 FIO_TYPE_TCP = 1,
50 FIO_TYPE_UDP = 2,
51 FIO_TYPE_UNIX = 3,
52};
53
54static int str_hostname_cb(void *data, const char *input);
55static struct fio_option options[] = {
56 {
57 .name = "hostname",
58 .type = FIO_OPT_STR_STORE,
59 .cb = str_hostname_cb,
60 .help = "Hostname for net IO engine",
61 },
62 {
63 .name = "port",
64 .type = FIO_OPT_INT,
65 .off1 = offsetof(struct netio_options, port),
66 .minval = 1,
67 .maxval = 65535,
68 .help = "Port to use for TCP or UDP net connections",
69 },
70 {
71 .name = "protocol",
72 .alias = "proto",
73 .type = FIO_OPT_STR,
74 .off1 = offsetof(struct netio_options, proto),
75 .help = "Network protocol to use",
76 .def = "tcp",
77 .posval = {
78 { .ival = "tcp",
79 .oval = FIO_TYPE_TCP,
80 .help = "Transmission Control Protocol",
81 },
82 { .ival = "udp",
83 .oval = FIO_TYPE_UDP,
84 .help = "User Datagram Protocol",
85 },
86 { .ival = "unix",
87 .oval = FIO_TYPE_UNIX,
88 .help = "UNIX domain socket",
89 },
90 },
91 },
92 {
93 .name = "listen",
94 .type = FIO_OPT_STR_SET,
95 .off1 = offsetof(struct netio_options, listen),
96 .help = "Listen for incoming TCP connections",
97 },
98 {
99 .name = "pingpong",
100 .type = FIO_OPT_STR_SET,
101 .off1 = offsetof(struct netio_options, pingpong),
102 .help = "Ping-pong IO requests",
103 },
104 {
105 .name = NULL,
106 },
107};
108
109/*
110 * Return -1 for error and 'nr events' for a positive number
111 * of events
112 */
113static int poll_wait(struct thread_data *td, int fd, short events)
114{
115 struct pollfd pfd;
116 int ret;
117
118 while (!td->terminate) {
119 pfd.fd = fd;
120 pfd.events = events;
121 ret = poll(&pfd, 1, -1);
122 if (ret < 0) {
123 if (errno == EINTR)
124 break;
125
126 td_verror(td, errno, "poll");
127 return -1;
128 } else if (!ret)
129 continue;
130
131 break;
132 }
133
134 if (pfd.revents & events)
135 return 1;
136
137 return -1;
138}
139
140static int fio_netio_prep(struct thread_data *td, struct io_u *io_u)
141{
142 struct netio_options *o = td->eo;
143
144 /*
145 * Make sure we don't see spurious reads to a receiver, and vice versa
146 */
147 if (o->proto == FIO_TYPE_TCP)
148 return 0;
149
150 if ((o->listen && io_u->ddir == DDIR_WRITE) ||
151 (!o->listen && io_u->ddir == DDIR_READ)) {
152 td_verror(td, EINVAL, "bad direction");
153 return 1;
154 }
155
156 return 0;
157}
158
159#ifdef FIO_HAVE_SPLICE
160static int splice_io_u(int fdin, int fdout, unsigned int len)
161{
162 int bytes = 0;
163
164 while (len) {
165 int ret = splice(fdin, NULL, fdout, NULL, len, 0);
166
167 if (ret < 0) {
168 if (!bytes)
169 bytes = ret;
170
171 break;
172 } else if (!ret)
173 break;
174
175 bytes += ret;
176 len -= ret;
177 }
178
179 return bytes;
180}
181
182/*
183 * Receive bytes from a socket and fill them into the internal pipe
184 */
185static int splice_in(struct thread_data *td, struct io_u *io_u)
186{
187 struct netio_data *nd = td->io_ops->data;
188
189 return splice_io_u(io_u->file->fd, nd->pipes[1], io_u->xfer_buflen);
190}
191
192/*
193 * Transmit 'len' bytes from the internal pipe
194 */
195static int splice_out(struct thread_data *td, struct io_u *io_u,
196 unsigned int len)
197{
198 struct netio_data *nd = td->io_ops->data;
199
200 return splice_io_u(nd->pipes[0], io_u->file->fd, len);
201}
202
203static int vmsplice_io_u(struct io_u *io_u, int fd, unsigned int len)
204{
205 struct iovec iov = {
206 .iov_base = io_u->xfer_buf,
207 .iov_len = len,
208 };
209 int bytes = 0;
210
211 while (iov.iov_len) {
212 int ret = vmsplice(fd, &iov, 1, SPLICE_F_MOVE);
213
214 if (ret < 0) {
215 if (!bytes)
216 bytes = ret;
217 break;
218 } else if (!ret)
219 break;
220
221 iov.iov_len -= ret;
222 iov.iov_base += ret;
223 bytes += ret;
224 }
225
226 return bytes;
227
228}
229
230/*
231 * vmsplice() pipe to io_u buffer
232 */
233static int vmsplice_io_u_out(struct thread_data *td, struct io_u *io_u,
234 unsigned int len)
235{
236 struct netio_data *nd = td->io_ops->data;
237
238 return vmsplice_io_u(io_u, nd->pipes[0], len);
239}
240
241/*
242 * vmsplice() io_u to pipe
243 */
244static int vmsplice_io_u_in(struct thread_data *td, struct io_u *io_u)
245{
246 struct netio_data *nd = td->io_ops->data;
247
248 return vmsplice_io_u(io_u, nd->pipes[1], io_u->xfer_buflen);
249}
250
251/*
252 * splice receive - transfer socket data into a pipe using splice, then map
253 * that pipe data into the io_u using vmsplice.
254 */
255static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
256{
257 int ret;
258
259 ret = splice_in(td, io_u);
260 if (ret > 0)
261 return vmsplice_io_u_out(td, io_u, ret);
262
263 return ret;
264}
265
266/*
267 * splice transmit - map data from the io_u into a pipe by using vmsplice,
268 * then transfer that pipe to a socket using splice.
269 */
270static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
271{
272 int ret;
273
274 ret = vmsplice_io_u_in(td, io_u);
275 if (ret > 0)
276 return splice_out(td, io_u, ret);
277
278 return ret;
279}
280#else
281static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
282{
283 errno = EOPNOTSUPP;
284 return -1;
285}
286
287static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
288{
289 errno = EOPNOTSUPP;
290 return -1;
291}
292#endif
293
294static int fio_netio_send(struct thread_data *td, struct io_u *io_u)
295{
296 struct netio_data *nd = td->io_ops->data;
297 struct netio_options *o = td->eo;
298 int ret, flags = 0;
299
300 do {
301 if (o->proto == FIO_TYPE_UDP) {
302 struct sockaddr *to = (struct sockaddr *) &nd->addr;
303
304 ret = sendto(io_u->file->fd, io_u->xfer_buf,
305 io_u->xfer_buflen, flags, to,
306 sizeof(*to));
307 } else {
308 /*
309 * if we are going to write more, set MSG_MORE
310 */
311#ifdef MSG_MORE
312 if ((td->this_io_bytes[DDIR_WRITE] + io_u->xfer_buflen <
313 td->o.size) && !o->pingpong)
314 flags |= MSG_MORE;
315#endif
316 ret = send(io_u->file->fd, io_u->xfer_buf,
317 io_u->xfer_buflen, flags);
318 }
319 if (ret > 0)
320 break;
321
322 ret = poll_wait(td, io_u->file->fd, POLLOUT);
323 if (ret <= 0)
324 break;
325 } while (1);
326
327 return ret;
328}
329
330static int is_udp_close(struct io_u *io_u, int len)
331{
332 struct udp_close_msg *msg;
333
334 if (len != sizeof(struct udp_close_msg))
335 return 0;
336
337 msg = io_u->xfer_buf;
338 if (ntohl(msg->magic) != FIO_LINK_OPEN_CLOSE_MAGIC)
339 return 0;
340 if (ntohl(msg->cmd) != FIO_LINK_CLOSE)
341 return 0;
342
343 return 1;
344}
345
346static int fio_netio_recv(struct thread_data *td, struct io_u *io_u)
347{
348 struct netio_data *nd = td->io_ops->data;
349 struct netio_options *o = td->eo;
350 int ret, flags = 0;
351
352 do {
353 if (o->proto == FIO_TYPE_UDP) {
354 fio_socklen_t len = sizeof(nd->addr);
355 struct sockaddr *from = (struct sockaddr *) &nd->addr;
356
357 ret = recvfrom(io_u->file->fd, io_u->xfer_buf,
358 io_u->xfer_buflen, flags, from, &len);
359 if (is_udp_close(io_u, ret)) {
360 td->done = 1;
361 return 0;
362 }
363 } else {
364 ret = recv(io_u->file->fd, io_u->xfer_buf,
365 io_u->xfer_buflen, flags);
366 }
367 if (ret > 0)
368 break;
369 else if (!ret && (flags & MSG_WAITALL))
370 break;
371
372 ret = poll_wait(td, io_u->file->fd, POLLIN);
373 if (ret <= 0)
374 break;
375 flags |= MSG_WAITALL;
376 } while (1);
377
378 return ret;
379}
380
381static int __fio_netio_queue(struct thread_data *td, struct io_u *io_u,
382 enum fio_ddir ddir)
383{
384 struct netio_data *nd = td->io_ops->data;
385 struct netio_options *o = td->eo;
386 int ret;
387
388 if (ddir == DDIR_WRITE) {
389 if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
390 o->proto == FIO_TYPE_UNIX)
391 ret = fio_netio_send(td, io_u);
392 else
393 ret = fio_netio_splice_out(td, io_u);
394 } else if (ddir == DDIR_READ) {
395 if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
396 o->proto == FIO_TYPE_UNIX)
397 ret = fio_netio_recv(td, io_u);
398 else
399 ret = fio_netio_splice_in(td, io_u);
400 } else
401 ret = 0; /* must be a SYNC */
402
403 if (ret != (int) io_u->xfer_buflen) {
404 if (ret >= 0) {
405 io_u->resid = io_u->xfer_buflen - ret;
406 io_u->error = 0;
407 return FIO_Q_COMPLETED;
408 } else {
409 int err = errno;
410
411 if (ddir == DDIR_WRITE && err == EMSGSIZE)
412 return FIO_Q_BUSY;
413
414 io_u->error = err;
415 }
416 }
417
418 if (io_u->error)
419 td_verror(td, io_u->error, "xfer");
420
421 return FIO_Q_COMPLETED;
422}
423
424static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
425{
426 struct netio_options *o = td->eo;
427 int ret;
428
429 fio_ro_check(td, io_u);
430
431 ret = __fio_netio_queue(td, io_u, io_u->ddir);
432 if (!o->pingpong || ret != FIO_Q_COMPLETED)
433 return ret;
434
435 /*
436 * For ping-pong mode, receive or send reply as needed
437 */
438 if (td_read(td) && io_u->ddir == DDIR_READ)
439 ret = __fio_netio_queue(td, io_u, DDIR_WRITE);
440 else if (td_write(td) && io_u->ddir == DDIR_WRITE)
441 ret = __fio_netio_queue(td, io_u, DDIR_READ);
442
443 return ret;
444}
445
446static int fio_netio_connect(struct thread_data *td, struct fio_file *f)
447{
448 struct netio_data *nd = td->io_ops->data;
449 struct netio_options *o = td->eo;
450 int type, domain;
451
452 if (o->proto == FIO_TYPE_TCP) {
453 domain = AF_INET;
454 type = SOCK_STREAM;
455 } else if (o->proto == FIO_TYPE_UDP) {
456 domain = AF_INET;
457 type = SOCK_DGRAM;
458 } else if (o->proto == FIO_TYPE_UNIX) {
459 domain = AF_UNIX;
460 type = SOCK_STREAM;
461 } else {
462 log_err("fio: bad network type %d\n", o->proto);
463 f->fd = -1;
464 return 1;
465 }
466
467 f->fd = socket(domain, type, 0);
468 if (f->fd < 0) {
469 td_verror(td, errno, "socket");
470 return 1;
471 }
472
473 if (o->proto == FIO_TYPE_UDP)
474 return 0;
475 else if (o->proto == FIO_TYPE_TCP) {
476 fio_socklen_t len = sizeof(nd->addr);
477
478 if (connect(f->fd, (struct sockaddr *) &nd->addr, len) < 0) {
479 td_verror(td, errno, "connect");
480 close(f->fd);
481 return 1;
482 }
483 } else {
484 struct sockaddr_un *addr = &nd->addr_un;
485 fio_socklen_t len;
486
487 len = sizeof(addr->sun_family) + strlen(addr->sun_path) + 1;
488
489 if (connect(f->fd, (struct sockaddr *) addr, len) < 0) {
490 td_verror(td, errno, "connect");
491 close(f->fd);
492 return 1;
493 }
494 }
495
496 return 0;
497}
498
499static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
500{
501 struct netio_data *nd = td->io_ops->data;
502 struct netio_options *o = td->eo;
503 fio_socklen_t socklen = sizeof(nd->addr);
504 int state;
505
506 if (o->proto == FIO_TYPE_UDP) {
507 f->fd = nd->listenfd;
508 return 0;
509 }
510
511 state = td->runstate;
512 td_set_runstate(td, TD_SETTING_UP);
513
514 log_info("fio: waiting for connection\n");
515
516 if (poll_wait(td, nd->listenfd, POLLIN) < 0)
517 goto err;
518
519 f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr, &socklen);
520 if (f->fd < 0) {
521 td_verror(td, errno, "accept");
522 goto err;
523 }
524
525 reset_all_stats(td);
526 td_set_runstate(td, state);
527 return 0;
528err:
529 td_set_runstate(td, state);
530 return 1;
531}
532
533static void fio_netio_udp_close(struct thread_data *td, struct fio_file *f)
534{
535 struct netio_data *nd = td->io_ops->data;
536 struct udp_close_msg msg;
537 struct sockaddr *to = (struct sockaddr *) &nd->addr;
538 int ret;
539
540 msg.magic = htonl(FIO_LINK_OPEN_CLOSE_MAGIC);
541 msg.cmd = htonl(FIO_LINK_CLOSE);
542
543 ret = sendto(f->fd, &msg, sizeof(msg), MSG_WAITALL, to,
544 sizeof(nd->addr));
545 if (ret < 0)
546 td_verror(td, errno, "sendto udp link close");
547}
548
549static int fio_netio_close_file(struct thread_data *td, struct fio_file *f)
550{
551 struct netio_options *o = td->eo;
552
553 /*
554 * If this is an UDP connection, notify the receiver that we are
555 * closing down the link
556 */
557 if (o->proto == FIO_TYPE_UDP)
558 fio_netio_udp_close(td, f);
559
560 return generic_close_file(td, f);
561}
562
563static int fio_netio_udp_recv_open(struct thread_data *td, struct fio_file *f)
564{
565 struct netio_data *nd = td->io_ops->data;
566 struct udp_close_msg msg;
567 struct sockaddr *to = (struct sockaddr *) &nd->addr;
568 fio_socklen_t len = sizeof(nd->addr);
569 int ret;
570
571 ret = recvfrom(f->fd, &msg, sizeof(msg), MSG_WAITALL, to, &len);
572 if (ret < 0) {
573 td_verror(td, errno, "sendto udp link open");
574 return ret;
575 }
576
577 if (ntohl(msg.magic) != FIO_LINK_OPEN_CLOSE_MAGIC ||
578 ntohl(msg.cmd) != FIO_LINK_OPEN) {
579 log_err("fio: bad udp open magic %x/%x\n", ntohl(msg.magic),
580 ntohl(msg.cmd));
581 return -1;
582 }
583
584 return 0;
585}
586
587static int fio_netio_udp_send_open(struct thread_data *td, struct fio_file *f)
588{
589 struct netio_data *nd = td->io_ops->data;
590 struct udp_close_msg msg;
591 struct sockaddr *to = (struct sockaddr *) &nd->addr;
592 int ret;
593
594 msg.magic = htonl(FIO_LINK_OPEN_CLOSE_MAGIC);
595 msg.cmd = htonl(FIO_LINK_OPEN);
596
597 ret = sendto(f->fd, &msg, sizeof(msg), MSG_WAITALL, to,
598 sizeof(nd->addr));
599 if (ret < 0) {
600 td_verror(td, errno, "sendto udp link open");
601 return ret;
602 }
603
604 return 0;
605}
606
607static int fio_netio_open_file(struct thread_data *td, struct fio_file *f)
608{
609 int ret;
610 struct netio_options *o = td->eo;
611
612 if (o->listen)
613 ret = fio_netio_accept(td, f);
614 else
615 ret = fio_netio_connect(td, f);
616
617 if (ret) {
618 f->fd = -1;
619 return ret;
620 }
621
622 if (o->proto == FIO_TYPE_UDP) {
623 if (td_write(td))
624 ret = fio_netio_udp_send_open(td, f);
625 else {
626 int state;
627
628 state = td->runstate;
629 td_set_runstate(td, TD_SETTING_UP);
630 ret = fio_netio_udp_recv_open(td, f);
631 td_set_runstate(td, state);
632 }
633 }
634
635 if (ret)
636 fio_netio_close_file(td, f);
637
638 return ret;
639}
640
641static int fio_netio_setup_connect_inet(struct thread_data *td,
642 const char *host, unsigned short port)
643{
644 struct netio_data *nd = td->io_ops->data;
645
646 if (!host) {
647 log_err("fio: connect with no host to connect to.\n");
648 if (td_read(td))
649 log_err("fio: did you forget to set 'listen'?\n");
650
651 td_verror(td, EINVAL, "no hostname= set");
652 return 1;
653 }
654
655 nd->addr.sin_family = AF_INET;
656 nd->addr.sin_port = htons(port);
657
658 if (inet_aton(host, &nd->addr.sin_addr) != 1) {
659 struct hostent *hent;
660
661 hent = gethostbyname(host);
662 if (!hent) {
663 td_verror(td, errno, "gethostbyname");
664 return 1;
665 }
666
667 memcpy(&nd->addr.sin_addr, hent->h_addr, 4);
668 }
669
670 return 0;
671}
672
673static int fio_netio_setup_connect_unix(struct thread_data *td,
674 const char *path)
675{
676 struct netio_data *nd = td->io_ops->data;
677 struct sockaddr_un *soun = &nd->addr_un;
678
679 soun->sun_family = AF_UNIX;
680 strcpy(soun->sun_path, path);
681 return 0;
682}
683
684static int fio_netio_setup_connect(struct thread_data *td)
685{
686 struct netio_options *o = td->eo;
687
688 if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
689 return fio_netio_setup_connect_inet(td, td->o.filename,o->port);
690 else
691 return fio_netio_setup_connect_unix(td, td->o.filename);
692}
693
694static int fio_netio_setup_listen_unix(struct thread_data *td, const char *path)
695{
696 struct netio_data *nd = td->io_ops->data;
697 struct sockaddr_un *addr = &nd->addr_un;
698 mode_t mode;
699 int len, fd;
700
701 fd = socket(AF_UNIX, SOCK_STREAM, 0);
702 if (fd < 0) {
703 log_err("fio: socket: %s\n", strerror(errno));
704 return -1;
705 }
706
707 mode = umask(000);
708
709 memset(addr, 0, sizeof(*addr));
710 addr->sun_family = AF_UNIX;
711 strcpy(addr->sun_path, path);
712 unlink(path);
713
714 len = sizeof(addr->sun_family) + strlen(path) + 1;
715
716 if (bind(fd, (struct sockaddr *) addr, len) < 0) {
717 log_err("fio: bind: %s\n", strerror(errno));
718 close(fd);
719 return -1;
720 }
721
722 umask(mode);
723 nd->listenfd = fd;
724 return 0;
725}
726
727static int fio_netio_setup_listen_inet(struct thread_data *td, short port)
728{
729 struct netio_data *nd = td->io_ops->data;
730 struct netio_options *o = td->eo;
731 int fd, opt, type;
732
733 if (o->proto == FIO_TYPE_TCP)
734 type = SOCK_STREAM;
735 else
736 type = SOCK_DGRAM;
737
738 fd = socket(AF_INET, type, 0);
739 if (fd < 0) {
740 td_verror(td, errno, "socket");
741 return 1;
742 }
743
744 opt = 1;
745 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
746 td_verror(td, errno, "setsockopt");
747 return 1;
748 }
749#ifdef SO_REUSEPORT
750 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
751 td_verror(td, errno, "setsockopt");
752 return 1;
753 }
754#endif
755
756 nd->addr.sin_family = AF_INET;
757 nd->addr.sin_addr.s_addr = htonl(INADDR_ANY);
758 nd->addr.sin_port = htons(port);
759
760 if (bind(fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
761 td_verror(td, errno, "bind");
762 return 1;
763 }
764
765 nd->listenfd = fd;
766 return 0;
767}
768
769static int fio_netio_setup_listen(struct thread_data *td)
770{
771 struct netio_data *nd = td->io_ops->data;
772 struct netio_options *o = td->eo;
773 int ret;
774
775 if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
776 ret = fio_netio_setup_listen_inet(td, o->port);
777 else
778 ret = fio_netio_setup_listen_unix(td, td->o.filename);
779
780 if (ret)
781 return ret;
782 if (o->proto == FIO_TYPE_UDP)
783 return 0;
784
785 if (listen(nd->listenfd, 10) < 0) {
786 td_verror(td, errno, "listen");
787 nd->listenfd = -1;
788 return 1;
789 }
790
791 return 0;
792}
793
794static int fio_netio_init(struct thread_data *td)
795{
796 struct netio_options *o = td->eo;
797 int ret;
798
799#ifdef WIN32
800 WSADATA wsd;
801 WSAStartup(MAKEWORD(2,2), &wsd);
802#endif
803
804 if (td_random(td)) {
805 log_err("fio: network IO can't be random\n");
806 return 1;
807 }
808
809 if (o->proto == FIO_TYPE_UNIX && o->port) {
810 log_err("fio: network IO port not valid with unix socket\n");
811 return 1;
812 } else if (o->proto != FIO_TYPE_UNIX && !o->port) {
813 log_err("fio: network IO requires port for tcp or udp\n");
814 return 1;
815 }
816
817 if (o->proto != FIO_TYPE_TCP) {
818 if (o->listen) {
819 log_err("fio: listen only valid for TCP proto IO\n");
820 return 1;
821 }
822 if (td_rw(td)) {
823 log_err("fio: datagram network connections must be"
824 " read OR write\n");
825 return 1;
826 }
827 if (o->proto == FIO_TYPE_UNIX && !td->o.filename) {
828 log_err("fio: UNIX sockets need host/filename\n");
829 return 1;
830 }
831 o->listen = td_read(td);
832 }
833
834 if (o->proto != FIO_TYPE_UNIX && o->listen && td->o.filename) {
835 log_err("fio: hostname not valid for inbound network IO\n");
836 return 1;
837 }
838
839 if (o->listen)
840 ret = fio_netio_setup_listen(td);
841 else
842 ret = fio_netio_setup_connect(td);
843
844 return ret;
845}
846
847static void fio_netio_cleanup(struct thread_data *td)
848{
849 struct netio_data *nd = td->io_ops->data;
850
851 if (nd) {
852 if (nd->listenfd != -1)
853 close(nd->listenfd);
854 if (nd->pipes[0] != -1)
855 close(nd->pipes[0]);
856 if (nd->pipes[1] != -1)
857 close(nd->pipes[1]);
858
859 free(nd);
860 }
861}
862
863static int fio_netio_setup(struct thread_data *td)
864{
865 struct netio_data *nd;
866
867 if (!td->files_index) {
868 add_file(td, td->o.filename ?: "net");
869 td->o.nr_files = td->o.nr_files ?: 1;
870 }
871
872 if (!td->io_ops->data) {
873 nd = malloc(sizeof(*nd));;
874
875 memset(nd, 0, sizeof(*nd));
876 nd->listenfd = -1;
877 nd->pipes[0] = nd->pipes[1] = -1;
878 td->io_ops->data = nd;
879 }
880
881 return 0;
882}
883
884#ifdef FIO_HAVE_SPLICE
885static int fio_netio_setup_splice(struct thread_data *td)
886{
887 struct netio_data *nd;
888
889 fio_netio_setup(td);
890
891 nd = td->io_ops->data;
892 if (nd) {
893 if (pipe(nd->pipes) < 0)
894 return 1;
895
896 nd->use_splice = 1;
897 return 0;
898 }
899
900 return 1;
901}
902
903static struct ioengine_ops ioengine_splice = {
904 .name = "netsplice",
905 .version = FIO_IOOPS_VERSION,
906 .prep = fio_netio_prep,
907 .queue = fio_netio_queue,
908 .setup = fio_netio_setup_splice,
909 .init = fio_netio_init,
910 .cleanup = fio_netio_cleanup,
911 .open_file = fio_netio_open_file,
912 .close_file = generic_close_file,
913 .options = options,
914 .option_struct_size = sizeof(struct netio_options),
915 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
916 FIO_SIGTERM | FIO_PIPEIO,
917};
918#endif
919
920static struct ioengine_ops ioengine_rw = {
921 .name = "net",
922 .version = FIO_IOOPS_VERSION,
923 .prep = fio_netio_prep,
924 .queue = fio_netio_queue,
925 .setup = fio_netio_setup,
926 .init = fio_netio_init,
927 .cleanup = fio_netio_cleanup,
928 .open_file = fio_netio_open_file,
929 .close_file = fio_netio_close_file,
930 .options = options,
931 .option_struct_size = sizeof(struct netio_options),
932 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
933 FIO_SIGTERM | FIO_PIPEIO,
934};
935
936static int str_hostname_cb(void *data, const char *input)
937{
938 struct netio_options *o = data;
939
940 if (o->td->o.filename)
941 free(o->td->o.filename);
942 o->td->o.filename = strdup(input);
943 return 0;
944}
945
946static void fio_init fio_netio_register(void)
947{
948 register_ioengine(&ioengine_rw);
949#ifdef FIO_HAVE_SPLICE
950 register_ioengine(&ioengine_splice);
951#endif
952}
953
954static void fio_exit fio_netio_unregister(void)
955{
956 unregister_ioengine(&ioengine_rw);
957#ifdef FIO_HAVE_SPLICE
958 unregister_ioengine(&ioengine_splice);
959#endif
960}
fio - Flexible IO Tester