blob: 7354d310141d2f7b4a9da29827da31ea6a319c67 [file] [log] [blame]
Jens Axboeed92ac02007-02-06 14:43:52 +01001/*
Jens Axboeda751ca2007-03-14 10:59:33 +01002 * net engine
3 *
4 * IO engine that reads/writes to/from sockets.
5 *
Jens Axboeed92ac02007-02-06 14:43:52 +01006 */
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>
Jens Axboe5fdd1242007-02-11 04:00:37 +010015#include <sys/poll.h>
Jens Axboe72920562008-06-02 12:30:06 +020016#include <sys/types.h>
Jens Axboe0fd666b2011-10-06 20:08:53 +020017#include <sys/stat.h>
Jens Axboe72920562008-06-02 12:30:06 +020018#include <sys/socket.h>
Jens Axboe0fd666b2011-10-06 20:08:53 +020019#include <sys/un.h>
Jens Axboeed92ac02007-02-06 14:43:52 +010020
21#include "../fio.h"
Jens Axboeed92ac02007-02-06 14:43:52 +010022
Jens Axboeb5af8292007-03-08 12:43:13 +010023struct netio_data {
24 int listenfd;
Jens Axboe9cce02e2007-06-22 15:42:21 +020025 int use_splice;
26 int pipes[2];
Jens Axboeb5af8292007-03-08 12:43:13 +010027 struct sockaddr_in addr;
Jens Axboe0fd666b2011-10-06 20:08:53 +020028 struct sockaddr_un addr_un;
Jens Axboeb5af8292007-03-08 12:43:13 +010029};
Jens Axboeed92ac02007-02-06 14:43:52 +010030
Steven Langde890a12011-11-09 14:03:34 +010031struct netio_options {
32 struct thread_data *td;
33 unsigned int port;
34 unsigned int proto;
35 unsigned int listen;
36};
37
Jens Axboe664fb3b2009-01-19 13:26:36 +010038struct udp_close_msg {
39 uint32_t magic;
40 uint32_t cmd;
41};
42
43enum {
44 FIO_LINK_CLOSE = 0x89,
45 FIO_LINK_CLOSE_MAGIC = 0x6c696e6b,
Jens Axboe0fd666b2011-10-06 20:08:53 +020046
47 FIO_TYPE_TCP = 1,
48 FIO_TYPE_UDP = 2,
49 FIO_TYPE_UNIX = 3,
Jens Axboe664fb3b2009-01-19 13:26:36 +010050};
51
Steven Langde890a12011-11-09 14:03:34 +010052static int str_hostname_cb(void *data, const char *input);
53static struct fio_option options[] = {
54 {
55 .name = "hostname",
56 .type = FIO_OPT_STR_STORE,
57 .cb = str_hostname_cb,
58 .help = "Hostname for net IO engine",
59 },
60 {
61 .name = "port",
62 .type = FIO_OPT_INT,
63 .off1 = offsetof(struct netio_options, port),
64 .minval = 1,
65 .maxval = 65535,
66 .help = "Port to use for TCP or UDP net connections",
67 },
68 {
69 .name = "protocol",
70 .alias = "proto",
71 .type = FIO_OPT_STR,
72 .off1 = offsetof(struct netio_options, proto),
73 .help = "Network protocol to use",
74 .def = "tcp",
75 .posval = {
76 { .ival = "tcp",
77 .oval = FIO_TYPE_TCP,
78 .help = "Transmission Control Protocol",
79 },
80 { .ival = "udp",
81 .oval = FIO_TYPE_UDP,
Bruce Cranf5cc3d02012-10-10 08:17:44 -060082 .help = "User Datagram Protocol",
Steven Langde890a12011-11-09 14:03:34 +010083 },
84 { .ival = "unix",
85 .oval = FIO_TYPE_UNIX,
86 .help = "UNIX domain socket",
87 },
88 },
89 },
90 {
91 .name = "listen",
92 .type = FIO_OPT_STR_SET,
93 .off1 = offsetof(struct netio_options, listen),
94 .help = "Listen for incoming TCP connections",
95 },
96 {
97 .name = NULL,
98 },
99};
100
Jens Axboe371d4562009-01-19 10:17:06 +0100101/*
102 * Return -1 for error and 'nr events' for a positive number
103 * of events
104 */
105static int poll_wait(struct thread_data *td, int fd, short events)
106{
107 struct pollfd pfd;
108 int ret;
109
110 while (!td->terminate) {
111 pfd.fd = fd;
112 pfd.events = events;
113 ret = poll(&pfd, 1, -1);
114 if (ret < 0) {
115 if (errno == EINTR)
Jens Axboed5b388a2009-01-19 12:38:27 +0100116 break;
Jens Axboe371d4562009-01-19 10:17:06 +0100117
118 td_verror(td, errno, "poll");
119 return -1;
120 } else if (!ret)
121 continue;
122
123 break;
124 }
125
126 if (pfd.revents & events)
127 return 1;
Jens Axboe371d4562009-01-19 10:17:06 +0100128
129 return -1;
130}
131
Jens Axboeed92ac02007-02-06 14:43:52 +0100132static int fio_netio_prep(struct thread_data *td, struct io_u *io_u)
133{
Steven Langde890a12011-11-09 14:03:34 +0100134 struct netio_options *o = td->eo;
Jens Axboeed92ac02007-02-06 14:43:52 +0100135
Jens Axboe7a6499d2007-02-07 09:35:29 +0100136 /*
137 * Make sure we don't see spurious reads to a receiver, and vice versa
138 */
Steven Langde890a12011-11-09 14:03:34 +0100139 if (o->proto == FIO_TYPE_TCP)
140 return 0;
141
142 if ((o->listen && io_u->ddir == DDIR_WRITE) ||
143 (!o->listen && io_u->ddir == DDIR_READ)) {
Jens Axboee1161c32007-02-22 19:36:48 +0100144 td_verror(td, EINVAL, "bad direction");
Jens Axboe7a6499d2007-02-07 09:35:29 +0100145 return 1;
Jens Axboeed92ac02007-02-06 14:43:52 +0100146 }
Jens Axboe7a6499d2007-02-07 09:35:29 +0100147
Jens Axboef85ac252008-03-01 18:09:49 +0100148 return 0;
Jens Axboeed92ac02007-02-06 14:43:52 +0100149}
150
Jens Axboe5921e802008-05-30 15:02:38 +0200151#ifdef FIO_HAVE_SPLICE
Jens Axboecd963e12007-06-24 21:41:46 +0200152static int splice_io_u(int fdin, int fdout, unsigned int len)
Jens Axboe9cce02e2007-06-22 15:42:21 +0200153{
Jens Axboe9cce02e2007-06-22 15:42:21 +0200154 int bytes = 0;
155
156 while (len) {
Jens Axboecd963e12007-06-24 21:41:46 +0200157 int ret = splice(fdin, NULL, fdout, NULL, len, 0);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200158
159 if (ret < 0) {
160 if (!bytes)
161 bytes = ret;
162
163 break;
164 } else if (!ret)
165 break;
166
167 bytes += ret;
Jens Axboef657a2f2007-06-22 20:40:10 +0200168 len -= ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200169 }
170
171 return bytes;
172}
173
174/*
Jens Axboecd963e12007-06-24 21:41:46 +0200175 * Receive bytes from a socket and fill them into the internal pipe
176 */
177static int splice_in(struct thread_data *td, struct io_u *io_u)
178{
179 struct netio_data *nd = td->io_ops->data;
180
181 return splice_io_u(io_u->file->fd, nd->pipes[1], io_u->xfer_buflen);
182}
183
184/*
Jens Axboe9cce02e2007-06-22 15:42:21 +0200185 * Transmit 'len' bytes from the internal pipe
186 */
187static int splice_out(struct thread_data *td, struct io_u *io_u,
188 unsigned int len)
189{
190 struct netio_data *nd = td->io_ops->data;
Jens Axboecd963e12007-06-24 21:41:46 +0200191
192 return splice_io_u(nd->pipes[0], io_u->file->fd, len);
193}
194
195static int vmsplice_io_u(struct io_u *io_u, int fd, unsigned int len)
196{
197 struct iovec iov = {
198 .iov_base = io_u->xfer_buf,
199 .iov_len = len,
200 };
Jens Axboe9cce02e2007-06-22 15:42:21 +0200201 int bytes = 0;
202
Jens Axboecd963e12007-06-24 21:41:46 +0200203 while (iov.iov_len) {
204 int ret = vmsplice(fd, &iov, 1, SPLICE_F_MOVE);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200205
206 if (ret < 0) {
207 if (!bytes)
208 bytes = ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200209 break;
210 } else if (!ret)
211 break;
212
Jens Axboecd963e12007-06-24 21:41:46 +0200213 iov.iov_len -= ret;
214 iov.iov_base += ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200215 bytes += ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200216 }
217
218 return bytes;
Jens Axboecd963e12007-06-24 21:41:46 +0200219
Jens Axboe9cce02e2007-06-22 15:42:21 +0200220}
221
222/*
223 * vmsplice() pipe to io_u buffer
224 */
225static int vmsplice_io_u_out(struct thread_data *td, struct io_u *io_u,
226 unsigned int len)
227{
228 struct netio_data *nd = td->io_ops->data;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200229
Jens Axboecd963e12007-06-24 21:41:46 +0200230 return vmsplice_io_u(io_u, nd->pipes[0], len);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200231}
232
233/*
234 * vmsplice() io_u to pipe
235 */
236static int vmsplice_io_u_in(struct thread_data *td, struct io_u *io_u)
237{
238 struct netio_data *nd = td->io_ops->data;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200239
Jens Axboecd963e12007-06-24 21:41:46 +0200240 return vmsplice_io_u(io_u, nd->pipes[1], io_u->xfer_buflen);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200241}
242
Jens Axboecd963e12007-06-24 21:41:46 +0200243/*
244 * splice receive - transfer socket data into a pipe using splice, then map
245 * that pipe data into the io_u using vmsplice.
246 */
Jens Axboe9cce02e2007-06-22 15:42:21 +0200247static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
248{
249 int ret;
250
251 ret = splice_in(td, io_u);
Jens Axboecd963e12007-06-24 21:41:46 +0200252 if (ret > 0)
253 return vmsplice_io_u_out(td, io_u, ret);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200254
Jens Axboecd963e12007-06-24 21:41:46 +0200255 return ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200256}
257
Jens Axboecd963e12007-06-24 21:41:46 +0200258/*
259 * splice transmit - map data from the io_u into a pipe by using vmsplice,
260 * then transfer that pipe to a socket using splice.
261 */
Jens Axboe9cce02e2007-06-22 15:42:21 +0200262static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
263{
264 int ret;
265
266 ret = vmsplice_io_u_in(td, io_u);
Jens Axboecd963e12007-06-24 21:41:46 +0200267 if (ret > 0)
268 return splice_out(td, io_u, ret);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200269
Jens Axboecd963e12007-06-24 21:41:46 +0200270 return ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200271}
Jens Axboe5921e802008-05-30 15:02:38 +0200272#else
273static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
274{
Jens Axboeaf8771b2008-05-30 22:58:28 +0200275 errno = EOPNOTSUPP;
Jens Axboe5921e802008-05-30 15:02:38 +0200276 return -1;
277}
278
279static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
280{
Jens Axboeaf8771b2008-05-30 22:58:28 +0200281 errno = EOPNOTSUPP;
Jens Axboe5921e802008-05-30 15:02:38 +0200282 return -1;
283}
284#endif
Jens Axboe9cce02e2007-06-22 15:42:21 +0200285
286static int fio_netio_send(struct thread_data *td, struct io_u *io_u)
287{
Jens Axboe414c2a32009-01-16 13:21:15 +0100288 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100289 struct netio_options *o = td->eo;
Jens Axboe8e239ca2010-08-11 10:29:12 -0400290 int ret, flags = OS_MSG_DONTWAIT;
Jens Axboe371d4562009-01-19 10:17:06 +0100291
Jens Axboe664fb3b2009-01-19 13:26:36 +0100292 do {
Steven Langde890a12011-11-09 14:03:34 +0100293 if (o->proto == FIO_TYPE_UDP) {
Jens Axboe62b38922009-05-11 10:37:33 +0200294 struct sockaddr *to = (struct sockaddr *) &nd->addr;
295
Jens Axboe664fb3b2009-01-19 13:26:36 +0100296 ret = sendto(io_u->file->fd, io_u->xfer_buf,
Jens Axboe62b38922009-05-11 10:37:33 +0200297 io_u->xfer_buflen, flags, to,
298 sizeof(*to));
Jens Axboe664fb3b2009-01-19 13:26:36 +0100299 } else {
300 /*
301 * if we are going to write more, set MSG_MORE
302 */
Jens Axboe5921e802008-05-30 15:02:38 +0200303#ifdef MSG_MORE
Jens Axboe664fb3b2009-01-19 13:26:36 +0100304 if (td->this_io_bytes[DDIR_WRITE] + io_u->xfer_buflen <
305 td->o.size)
306 flags |= MSG_MORE;
Jens Axboe5921e802008-05-30 15:02:38 +0200307#endif
Jens Axboe664fb3b2009-01-19 13:26:36 +0100308 ret = send(io_u->file->fd, io_u->xfer_buf,
309 io_u->xfer_buflen, flags);
310 }
311 if (ret > 0)
312 break;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200313
Jens Axboe664fb3b2009-01-19 13:26:36 +0100314 ret = poll_wait(td, io_u->file->fd, POLLOUT);
315 if (ret <= 0)
316 break;
317
Jens Axboe8e239ca2010-08-11 10:29:12 -0400318 flags &= ~OS_MSG_DONTWAIT;
Jens Axboe664fb3b2009-01-19 13:26:36 +0100319 } while (1);
320
321 return ret;
322}
323
324static int is_udp_close(struct io_u *io_u, int len)
325{
326 struct udp_close_msg *msg;
327
328 if (len != sizeof(struct udp_close_msg))
329 return 0;
330
331 msg = io_u->xfer_buf;
332 if (ntohl(msg->magic) != FIO_LINK_CLOSE_MAGIC)
333 return 0;
334 if (ntohl(msg->cmd) != FIO_LINK_CLOSE)
335 return 0;
336
337 return 1;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200338}
339
Jens Axboe414c2a32009-01-16 13:21:15 +0100340static int fio_netio_recv(struct thread_data *td, struct io_u *io_u)
Jens Axboe9cce02e2007-06-22 15:42:21 +0200341{
Jens Axboe414c2a32009-01-16 13:21:15 +0100342 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100343 struct netio_options *o = td->eo;
Jens Axboe8e239ca2010-08-11 10:29:12 -0400344 int ret, flags = OS_MSG_DONTWAIT;
Jens Axboe371d4562009-01-19 10:17:06 +0100345
Jens Axboe664fb3b2009-01-19 13:26:36 +0100346 do {
Steven Langde890a12011-11-09 14:03:34 +0100347 if (o->proto == FIO_TYPE_UDP) {
Jens Axboe5ba13ea2011-10-04 23:50:28 +0200348 fio_socklen_t len = sizeof(nd->addr);
Jens Axboe62b38922009-05-11 10:37:33 +0200349 struct sockaddr *from = (struct sockaddr *) &nd->addr;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200350
Jens Axboe664fb3b2009-01-19 13:26:36 +0100351 ret = recvfrom(io_u->file->fd, io_u->xfer_buf,
Jens Axboe62b38922009-05-11 10:37:33 +0200352 io_u->xfer_buflen, flags, from, &len);
Jens Axboe664fb3b2009-01-19 13:26:36 +0100353 if (is_udp_close(io_u, ret)) {
354 td->done = 1;
355 return 0;
356 }
357 } else {
358 ret = recv(io_u->file->fd, io_u->xfer_buf,
359 io_u->xfer_buflen, flags);
360 }
361 if (ret > 0)
362 break;
Jens Axboe414c2a32009-01-16 13:21:15 +0100363
Jens Axboe664fb3b2009-01-19 13:26:36 +0100364 ret = poll_wait(td, io_u->file->fd, POLLIN);
365 if (ret <= 0)
366 break;
Jens Axboe8e239ca2010-08-11 10:29:12 -0400367 flags &= ~OS_MSG_DONTWAIT;
Jens Axboe664fb3b2009-01-19 13:26:36 +0100368 flags |= MSG_WAITALL;
369 } while (1);
370
371 return ret;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200372}
373
Jens Axboeed92ac02007-02-06 14:43:52 +0100374static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
375{
Jens Axboe9cce02e2007-06-22 15:42:21 +0200376 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100377 struct netio_options *o = td->eo;
Jens Axboe9cce02e2007-06-22 15:42:21 +0200378 int ret;
Jens Axboeed92ac02007-02-06 14:43:52 +0100379
Jens Axboe7101d9c2007-09-12 13:12:39 +0200380 fio_ro_check(td, io_u);
381
Jens Axboe7a6499d2007-02-07 09:35:29 +0100382 if (io_u->ddir == DDIR_WRITE) {
Steven Langde890a12011-11-09 14:03:34 +0100383 if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
384 o->proto == FIO_TYPE_UNIX)
Jens Axboe9cce02e2007-06-22 15:42:21 +0200385 ret = fio_netio_send(td, io_u);
Jens Axboe9cce02e2007-06-22 15:42:21 +0200386 else
Jens Axboe414c2a32009-01-16 13:21:15 +0100387 ret = fio_netio_splice_out(td, io_u);
388 } else if (io_u->ddir == DDIR_READ) {
Steven Langde890a12011-11-09 14:03:34 +0100389 if (!nd->use_splice || o->proto == FIO_TYPE_UDP ||
390 o->proto == FIO_TYPE_UNIX)
Jens Axboe414c2a32009-01-16 13:21:15 +0100391 ret = fio_netio_recv(td, io_u);
392 else
393 ret = fio_netio_splice_in(td, io_u);
Jens Axboed4f12dd2007-02-08 12:59:02 +0100394 } else
Jens Axboe7a6499d2007-02-07 09:35:29 +0100395 ret = 0; /* must be a SYNC */
Jens Axboeed92ac02007-02-06 14:43:52 +0100396
Jens Axboecec6b552007-02-06 20:15:38 +0100397 if (ret != (int) io_u->xfer_buflen) {
Jens Axboe22819ec2007-02-18 07:47:14 +0100398 if (ret >= 0) {
Jens Axboecec6b552007-02-06 20:15:38 +0100399 io_u->resid = io_u->xfer_buflen - ret;
400 io_u->error = 0;
Jens Axboe36167d82007-02-18 05:41:31 +0100401 return FIO_Q_COMPLETED;
Jens Axboe414c2a32009-01-16 13:21:15 +0100402 } else {
403 int err = errno;
404
405 if (io_u->ddir == DDIR_WRITE && err == EMSGSIZE)
406 return FIO_Q_BUSY;
407
408 io_u->error = err;
409 }
Jens Axboeed92ac02007-02-06 14:43:52 +0100410 }
411
Jens Axboe36167d82007-02-18 05:41:31 +0100412 if (io_u->error)
Jens Axboee1161c32007-02-22 19:36:48 +0100413 td_verror(td, io_u->error, "xfer");
Jens Axboeed92ac02007-02-06 14:43:52 +0100414
Jens Axboe36167d82007-02-18 05:41:31 +0100415 return FIO_Q_COMPLETED;
Jens Axboeed92ac02007-02-06 14:43:52 +0100416}
417
Jens Axboeb5af8292007-03-08 12:43:13 +0100418static int fio_netio_connect(struct thread_data *td, struct fio_file *f)
Jens Axboeed92ac02007-02-06 14:43:52 +0100419{
Jens Axboeb5af8292007-03-08 12:43:13 +0100420 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100421 struct netio_options *o = td->eo;
Jens Axboe0fd666b2011-10-06 20:08:53 +0200422 int type, domain;
Jens Axboeed92ac02007-02-06 14:43:52 +0100423
Steven Langde890a12011-11-09 14:03:34 +0100424 if (o->proto == FIO_TYPE_TCP) {
Jens Axboe0fd666b2011-10-06 20:08:53 +0200425 domain = AF_INET;
Jens Axboe414c2a32009-01-16 13:21:15 +0100426 type = SOCK_STREAM;
Steven Langde890a12011-11-09 14:03:34 +0100427 } else if (o->proto == FIO_TYPE_UDP) {
Jens Axboe0fd666b2011-10-06 20:08:53 +0200428 domain = AF_INET;
Jens Axboe414c2a32009-01-16 13:21:15 +0100429 type = SOCK_DGRAM;
Steven Langde890a12011-11-09 14:03:34 +0100430 } else if (o->proto == FIO_TYPE_UNIX) {
Jens Axboe0fd666b2011-10-06 20:08:53 +0200431 domain = AF_UNIX;
432 type = SOCK_STREAM;
433 } else {
Steven Langde890a12011-11-09 14:03:34 +0100434 log_err("fio: bad network type %d\n", o->proto);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200435 f->fd = -1;
436 return 1;
437 }
Jens Axboe414c2a32009-01-16 13:21:15 +0100438
Jens Axboe0fd666b2011-10-06 20:08:53 +0200439 f->fd = socket(domain, type, 0);
Jens Axboeb5af8292007-03-08 12:43:13 +0100440 if (f->fd < 0) {
441 td_verror(td, errno, "socket");
442 return 1;
Jens Axboeed92ac02007-02-06 14:43:52 +0100443 }
444
Steven Langde890a12011-11-09 14:03:34 +0100445 if (o->proto == FIO_TYPE_UDP)
Jens Axboe414c2a32009-01-16 13:21:15 +0100446 return 0;
Steven Langde890a12011-11-09 14:03:34 +0100447 else if (o->proto == FIO_TYPE_TCP) {
Jens Axboe0fd666b2011-10-06 20:08:53 +0200448 fio_socklen_t len = sizeof(nd->addr);
Jens Axboe414c2a32009-01-16 13:21:15 +0100449
Jens Axboe0fd666b2011-10-06 20:08:53 +0200450 if (connect(f->fd, (struct sockaddr *) &nd->addr, len) < 0) {
451 td_verror(td, errno, "connect");
Jens Axboeb94cba42011-10-06 21:27:10 +0200452 close(f->fd);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200453 return 1;
454 }
455 } else {
456 struct sockaddr_un *addr = &nd->addr_un;
457 fio_socklen_t len;
458
459 len = sizeof(addr->sun_family) + strlen(addr->sun_path) + 1;
460
461 if (connect(f->fd, (struct sockaddr *) addr, len) < 0) {
462 td_verror(td, errno, "connect");
Jens Axboeb94cba42011-10-06 21:27:10 +0200463 close(f->fd);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200464 return 1;
465 }
Jens Axboeed92ac02007-02-06 14:43:52 +0100466 }
467
468 return 0;
Jens Axboeed92ac02007-02-06 14:43:52 +0100469}
470
Jens Axboeb5af8292007-03-08 12:43:13 +0100471static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
Jens Axboe5fdd1242007-02-11 04:00:37 +0100472{
Jens Axboeb5af8292007-03-08 12:43:13 +0100473 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100474 struct netio_options *o = td->eo;
Jens Axboe5ba13ea2011-10-04 23:50:28 +0200475 fio_socklen_t socklen = sizeof(nd->addr);
Jens Axboe5fdd1242007-02-11 04:00:37 +0100476
Steven Langde890a12011-11-09 14:03:34 +0100477 if (o->proto == FIO_TYPE_UDP) {
Jens Axboe414c2a32009-01-16 13:21:15 +0100478 f->fd = nd->listenfd;
479 return 0;
480 }
481
Jens Axboe6d861442007-03-15 09:22:23 +0100482 log_info("fio: waiting for connection\n");
Jens Axboe5fdd1242007-02-11 04:00:37 +0100483
Jens Axboe371d4562009-01-19 10:17:06 +0100484 if (poll_wait(td, nd->listenfd, POLLIN) < 0)
485 return 1;
Jens Axboe5fdd1242007-02-11 04:00:37 +0100486
Jens Axboe371d4562009-01-19 10:17:06 +0100487 f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr, &socklen);
488 if (f->fd < 0) {
489 td_verror(td, errno, "accept");
490 return 1;
Jens Axboe5fdd1242007-02-11 04:00:37 +0100491 }
492
493 return 0;
494}
495
Jens Axboeb5af8292007-03-08 12:43:13 +0100496static int fio_netio_open_file(struct thread_data *td, struct fio_file *f)
Jens Axboeed92ac02007-02-06 14:43:52 +0100497{
Jens Axboe0fd666b2011-10-06 20:08:53 +0200498 int ret;
Yufei Ren991802b2011-12-19 08:56:29 +0100499 struct netio_options *o = td->eo;
Jens Axboe0fd666b2011-10-06 20:08:53 +0200500
Yufei Ren991802b2011-12-19 08:56:29 +0100501 if (o->listen)
Jens Axboe0fd666b2011-10-06 20:08:53 +0200502 ret = fio_netio_accept(td, f);
Jens Axboeb5af8292007-03-08 12:43:13 +0100503 else
Jens Axboe0fd666b2011-10-06 20:08:53 +0200504 ret = fio_netio_connect(td, f);
505
506 if (ret)
507 f->fd = -1;
508 return ret;
Jens Axboeb5af8292007-03-08 12:43:13 +0100509}
510
Jens Axboe664fb3b2009-01-19 13:26:36 +0100511static void fio_netio_udp_close(struct thread_data *td, struct fio_file *f)
512{
513 struct netio_data *nd = td->io_ops->data;
514 struct udp_close_msg msg;
Jens Axboe62b38922009-05-11 10:37:33 +0200515 struct sockaddr *to = (struct sockaddr *) &nd->addr;
Jens Axboe664fb3b2009-01-19 13:26:36 +0100516 int ret;
517
518 msg.magic = htonl(FIO_LINK_CLOSE_MAGIC);
519 msg.cmd = htonl(FIO_LINK_CLOSE);
520
Jens Axboe62b38922009-05-11 10:37:33 +0200521 ret = sendto(f->fd, &msg, sizeof(msg), MSG_WAITALL, to,
Jens Axboe664fb3b2009-01-19 13:26:36 +0100522 sizeof(nd->addr));
523 if (ret < 0)
524 td_verror(td, errno, "sendto udp link close");
525}
526
527static int fio_netio_close_file(struct thread_data *td, struct fio_file *f)
528{
Steven Langde890a12011-11-09 14:03:34 +0100529 struct netio_options *o = td->eo;
Jens Axboe664fb3b2009-01-19 13:26:36 +0100530
531 /*
532 * If this is an UDP connection, notify the receiver that we are
533 * closing down the link
534 */
Steven Langde890a12011-11-09 14:03:34 +0100535 if (o->proto == FIO_TYPE_UDP)
Jens Axboe664fb3b2009-01-19 13:26:36 +0100536 fio_netio_udp_close(td, f);
537
538 return generic_close_file(td, f);
539}
540
Jens Axboe0fd666b2011-10-06 20:08:53 +0200541static int fio_netio_setup_connect_inet(struct thread_data *td,
542 const char *host, unsigned short port)
Jens Axboeb5af8292007-03-08 12:43:13 +0100543{
544 struct netio_data *nd = td->io_ops->data;
545
546 nd->addr.sin_family = AF_INET;
547 nd->addr.sin_port = htons(port);
548
549 if (inet_aton(host, &nd->addr.sin_addr) != 1) {
550 struct hostent *hent;
551
552 hent = gethostbyname(host);
553 if (!hent) {
554 td_verror(td, errno, "gethostbyname");
555 return 1;
556 }
557
558 memcpy(&nd->addr.sin_addr, hent->h_addr, 4);
559 }
560
561 return 0;
562}
563
Jens Axboe0fd666b2011-10-06 20:08:53 +0200564static int fio_netio_setup_connect_unix(struct thread_data *td,
565 const char *path)
566{
567 struct netio_data *nd = td->io_ops->data;
568 struct sockaddr_un *soun = &nd->addr_un;
569
570 soun->sun_family = AF_UNIX;
571 strcpy(soun->sun_path, path);
572 return 0;
573}
574
Steven Langde890a12011-11-09 14:03:34 +0100575static int fio_netio_setup_connect(struct thread_data *td)
Jens Axboe0fd666b2011-10-06 20:08:53 +0200576{
Steven Langde890a12011-11-09 14:03:34 +0100577 struct netio_options *o = td->eo;
Jens Axboe0fd666b2011-10-06 20:08:53 +0200578
Steven Langde890a12011-11-09 14:03:34 +0100579 if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
580 return fio_netio_setup_connect_inet(td, td->o.filename,o->port);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200581 else
Steven Langde890a12011-11-09 14:03:34 +0100582 return fio_netio_setup_connect_unix(td, td->o.filename);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200583}
584
585static int fio_netio_setup_listen_unix(struct thread_data *td, const char *path)
586{
587 struct netio_data *nd = td->io_ops->data;
588 struct sockaddr_un *addr = &nd->addr_un;
589 mode_t mode;
590 int len, fd;
591
592 fd = socket(AF_UNIX, SOCK_STREAM, 0);
593 if (fd < 0) {
594 log_err("fio: socket: %s\n", strerror(errno));
595 return -1;
596 }
597
598 mode = umask(000);
599
600 memset(addr, 0, sizeof(*addr));
601 addr->sun_family = AF_UNIX;
602 strcpy(addr->sun_path, path);
603 unlink(path);
604
605 len = sizeof(addr->sun_family) + strlen(path) + 1;
606
607 if (bind(fd, (struct sockaddr *) addr, len) < 0) {
608 log_err("fio: bind: %s\n", strerror(errno));
Jens Axboeb94cba42011-10-06 21:27:10 +0200609 close(fd);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200610 return -1;
611 }
612
613 umask(mode);
614 nd->listenfd = fd;
615 return 0;
616}
617
618static int fio_netio_setup_listen_inet(struct thread_data *td, short port)
Jens Axboeb5af8292007-03-08 12:43:13 +0100619{
620 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100621 struct netio_options *o = td->eo;
Jens Axboe414c2a32009-01-16 13:21:15 +0100622 int fd, opt, type;
Jens Axboeed92ac02007-02-06 14:43:52 +0100623
Steven Langde890a12011-11-09 14:03:34 +0100624 if (o->proto == FIO_TYPE_TCP)
Jens Axboe414c2a32009-01-16 13:21:15 +0100625 type = SOCK_STREAM;
626 else
627 type = SOCK_DGRAM;
628
Jens Axboe0fd666b2011-10-06 20:08:53 +0200629 fd = socket(AF_INET, type, 0);
Jens Axboeed92ac02007-02-06 14:43:52 +0100630 if (fd < 0) {
Jens Axboee1161c32007-02-22 19:36:48 +0100631 td_verror(td, errno, "socket");
Jens Axboeed92ac02007-02-06 14:43:52 +0100632 return 1;
633 }
634
635 opt = 1;
636 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
Jens Axboee1161c32007-02-22 19:36:48 +0100637 td_verror(td, errno, "setsockopt");
Jens Axboeed92ac02007-02-06 14:43:52 +0100638 return 1;
639 }
Jens Axboe6bedbfa2007-02-07 09:54:40 +0100640#ifdef SO_REUSEPORT
641 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
Jens Axboee1161c32007-02-22 19:36:48 +0100642 td_verror(td, errno, "setsockopt");
Jens Axboe6bedbfa2007-02-07 09:54:40 +0100643 return 1;
644 }
645#endif
Jens Axboeed92ac02007-02-06 14:43:52 +0100646
Jens Axboeb5af8292007-03-08 12:43:13 +0100647 nd->addr.sin_family = AF_INET;
648 nd->addr.sin_addr.s_addr = htonl(INADDR_ANY);
649 nd->addr.sin_port = htons(port);
Jens Axboeed92ac02007-02-06 14:43:52 +0100650
Jens Axboeb5af8292007-03-08 12:43:13 +0100651 if (bind(fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
Jens Axboee1161c32007-02-22 19:36:48 +0100652 td_verror(td, errno, "bind");
Jens Axboeed92ac02007-02-06 14:43:52 +0100653 return 1;
654 }
Jens Axboe0fd666b2011-10-06 20:08:53 +0200655
656 nd->listenfd = fd;
657 return 0;
658}
659
Steven Langde890a12011-11-09 14:03:34 +0100660static int fio_netio_setup_listen(struct thread_data *td)
Jens Axboe0fd666b2011-10-06 20:08:53 +0200661{
662 struct netio_data *nd = td->io_ops->data;
Steven Langde890a12011-11-09 14:03:34 +0100663 struct netio_options *o = td->eo;
Jens Axboe0fd666b2011-10-06 20:08:53 +0200664 int ret;
665
Steven Langde890a12011-11-09 14:03:34 +0100666 if (o->proto == FIO_TYPE_UDP || o->proto == FIO_TYPE_TCP)
667 ret = fio_netio_setup_listen_inet(td, o->port);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200668 else
Steven Langde890a12011-11-09 14:03:34 +0100669 ret = fio_netio_setup_listen_unix(td, td->o.filename);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200670
671 if (ret)
672 return ret;
Steven Langde890a12011-11-09 14:03:34 +0100673 if (o->proto == FIO_TYPE_UDP)
Jens Axboe0fd666b2011-10-06 20:08:53 +0200674 return 0;
675
676 if (listen(nd->listenfd, 10) < 0) {
Jens Axboee1161c32007-02-22 19:36:48 +0100677 td_verror(td, errno, "listen");
Jens Axboe0fd666b2011-10-06 20:08:53 +0200678 nd->listenfd = -1;
Jens Axboeed92ac02007-02-06 14:43:52 +0100679 return 1;
680 }
681
Jens Axboeb5af8292007-03-08 12:43:13 +0100682 return 0;
Jens Axboeed92ac02007-02-06 14:43:52 +0100683}
684
Jens Axboe9bec88e2007-03-02 08:55:48 +0100685static int fio_netio_init(struct thread_data *td)
Jens Axboeed92ac02007-02-06 14:43:52 +0100686{
Steven Langde890a12011-11-09 14:03:34 +0100687 struct netio_options *o = td->eo;
Jens Axboeaf52b342007-03-13 10:07:47 +0100688 int ret;
Jens Axboeed92ac02007-02-06 14:43:52 +0100689
Jens Axboe16d55aa2007-05-22 09:21:37 +0200690 if (td_random(td)) {
691 log_err("fio: network IO can't be random\n");
692 return 1;
693 }
Jens Axboeed92ac02007-02-06 14:43:52 +0100694
Steven Langde890a12011-11-09 14:03:34 +0100695 if (o->proto == FIO_TYPE_UNIX && o->port) {
696 log_err("fio: network IO port not valid with unix socket\n");
697 return 1;
698 } else if (o->proto != FIO_TYPE_UNIX && !o->port) {
699 log_err("fio: network IO requires port for tcp or udp\n");
700 return 1;
Jens Axboe414c2a32009-01-16 13:21:15 +0100701 }
Jens Axboe0fd666b2011-10-06 20:08:53 +0200702
Steven Langde890a12011-11-09 14:03:34 +0100703 if (o->proto != FIO_TYPE_TCP) {
704 if (o->listen) {
Jens Axboe9b986062011-12-19 08:57:18 +0100705 log_err("fio: listen only valid for TCP proto IO\n");
706 return 1;
Steven Langde890a12011-11-09 14:03:34 +0100707 }
708 if (td_rw(td)) {
Jens Axboe9b986062011-12-19 08:57:18 +0100709 log_err("fio: datagram network connections must be"
Steven Langde890a12011-11-09 14:03:34 +0100710 " read OR write\n");
Jens Axboe9b986062011-12-19 08:57:18 +0100711 return 1;
712 }
713 if (o->proto == FIO_TYPE_UNIX && !td->o.filename) {
714 log_err("fio: UNIX sockets need host/filename\n");
715 return 1;
Steven Langde890a12011-11-09 14:03:34 +0100716 }
717 o->listen = td_read(td);
718 }
719
720 if (o->proto != FIO_TYPE_UNIX && o->listen && td->o.filename) {
721 log_err("fio: hostname not valid for inbound network IO\n");
722 return 1;
723 }
724
725 if (o->listen)
726 ret = fio_netio_setup_listen(td);
Jens Axboe0fd666b2011-10-06 20:08:53 +0200727 else
Steven Langde890a12011-11-09 14:03:34 +0100728 ret = fio_netio_setup_connect(td);
Jens Axboeed92ac02007-02-06 14:43:52 +0100729
Jens Axboe7bb48f82007-03-27 15:30:28 +0200730 return ret;
Jens Axboeed92ac02007-02-06 14:43:52 +0100731}
732
Jens Axboeb5af8292007-03-08 12:43:13 +0100733static void fio_netio_cleanup(struct thread_data *td)
Jens Axboe9bec88e2007-03-02 08:55:48 +0100734{
Jens Axboeb5af8292007-03-08 12:43:13 +0100735 struct netio_data *nd = td->io_ops->data;
736
737 if (nd) {
Jens Axboe64b24cd2007-06-24 21:28:39 +0200738 if (nd->listenfd != -1)
739 close(nd->listenfd);
740 if (nd->pipes[0] != -1)
741 close(nd->pipes[0]);
742 if (nd->pipes[1] != -1)
743 close(nd->pipes[1]);
744
Jens Axboeb5af8292007-03-08 12:43:13 +0100745 free(nd);
Jens Axboeb5af8292007-03-08 12:43:13 +0100746 }
747}
748
749static int fio_netio_setup(struct thread_data *td)
750{
Jens Axboe7bb48f82007-03-27 15:30:28 +0200751 struct netio_data *nd;
Jens Axboeb5af8292007-03-08 12:43:13 +0100752
Steven Langde890a12011-11-09 14:03:34 +0100753 if (!td->files_index) {
754 add_file(td, td->o.filename ?: "net");
755 td->o.nr_files = td->o.nr_files ?: 1;
756 }
757
Jens Axboe7bb48f82007-03-27 15:30:28 +0200758 if (!td->io_ops->data) {
759 nd = malloc(sizeof(*nd));;
760
761 memset(nd, 0, sizeof(*nd));
762 nd->listenfd = -1;
Jens Axboe64b24cd2007-06-24 21:28:39 +0200763 nd->pipes[0] = nd->pipes[1] = -1;
Jens Axboe7bb48f82007-03-27 15:30:28 +0200764 td->io_ops->data = nd;
Jens Axboe7bb48f82007-03-27 15:30:28 +0200765 }
766
Jens Axboe9bec88e2007-03-02 08:55:48 +0100767 return 0;
768}
769
Jens Axboe5921e802008-05-30 15:02:38 +0200770#ifdef FIO_HAVE_SPLICE
Jens Axboe9cce02e2007-06-22 15:42:21 +0200771static int fio_netio_setup_splice(struct thread_data *td)
772{
773 struct netio_data *nd;
774
775 fio_netio_setup(td);
776
777 nd = td->io_ops->data;
778 if (nd) {
779 if (pipe(nd->pipes) < 0)
780 return 1;
781
782 nd->use_splice = 1;
783 return 0;
784 }
785
786 return 1;
787}
788
Jens Axboe5921e802008-05-30 15:02:38 +0200789static struct ioengine_ops ioengine_splice = {
Steven Langde890a12011-11-09 14:03:34 +0100790 .name = "netsplice",
791 .version = FIO_IOOPS_VERSION,
792 .prep = fio_netio_prep,
793 .queue = fio_netio_queue,
794 .setup = fio_netio_setup_splice,
795 .init = fio_netio_init,
796 .cleanup = fio_netio_cleanup,
797 .open_file = fio_netio_open_file,
798 .close_file = generic_close_file,
799 .options = options,
800 .option_struct_size = sizeof(struct netio_options),
801 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
802 FIO_SIGTERM | FIO_PIPEIO,
Jens Axboe5921e802008-05-30 15:02:38 +0200803};
804#endif
805
Jens Axboe9cce02e2007-06-22 15:42:21 +0200806static struct ioengine_ops ioengine_rw = {
Steven Langde890a12011-11-09 14:03:34 +0100807 .name = "net",
808 .version = FIO_IOOPS_VERSION,
809 .prep = fio_netio_prep,
810 .queue = fio_netio_queue,
811 .setup = fio_netio_setup,
812 .init = fio_netio_init,
813 .cleanup = fio_netio_cleanup,
814 .open_file = fio_netio_open_file,
815 .close_file = fio_netio_close_file,
816 .options = options,
817 .option_struct_size = sizeof(struct netio_options),
818 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
819 FIO_SIGTERM | FIO_PIPEIO,
Jens Axboeed92ac02007-02-06 14:43:52 +0100820};
821
Steven Langde890a12011-11-09 14:03:34 +0100822static int str_hostname_cb(void *data, const char *input)
823{
824 struct netio_options *o = data;
825
826 if (o->td->o.filename)
827 free(o->td->o.filename);
828 o->td->o.filename = strdup(input);
829 return 0;
830}
831
Jens Axboeed92ac02007-02-06 14:43:52 +0100832static void fio_init fio_netio_register(void)
833{
Jens Axboe9cce02e2007-06-22 15:42:21 +0200834 register_ioengine(&ioengine_rw);
Jens Axboe5921e802008-05-30 15:02:38 +0200835#ifdef FIO_HAVE_SPLICE
Jens Axboe9cce02e2007-06-22 15:42:21 +0200836 register_ioengine(&ioengine_splice);
Jens Axboe5921e802008-05-30 15:02:38 +0200837#endif
Jens Axboeed92ac02007-02-06 14:43:52 +0100838}
839
840static void fio_exit fio_netio_unregister(void)
841{
Jens Axboe9cce02e2007-06-22 15:42:21 +0200842 unregister_ioengine(&ioengine_rw);
Jens Axboe5921e802008-05-30 15:02:38 +0200843#ifdef FIO_HAVE_SPLICE
Jens Axboe9cce02e2007-06-22 15:42:21 +0200844 unregister_ioengine(&ioengine_splice);
Jens Axboe5921e802008-05-30 15:02:38 +0200845#endif
Jens Axboeed92ac02007-02-06 14:43:52 +0100846}