Add strong madvise() hint for cache pruning
[fio.git] / engines / net.c
CommitLineData
ed92ac0c 1/*
da751ca9
JA
2 * net engine
3 *
4 * IO engine that reads/writes to/from sockets.
5 *
ed92ac0c
JA
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>
5fdd124a 15#include <sys/poll.h>
7292056a
JA
16#include <sys/types.h>
17#include <sys/socket.h>
ed92ac0c
JA
18
19#include "../fio.h"
ed92ac0c 20
b5af8293
JA
21struct netio_data {
22 int listenfd;
23 int send_to_net;
9cce02e8 24 int use_splice;
414c2a3e 25 int net_protocol;
9cce02e8 26 int pipes[2];
b5af8293
JA
27 char host[64];
28 struct sockaddr_in addr;
29};
ed92ac0c 30
664fb3bd
JA
31struct udp_close_msg {
32 uint32_t magic;
33 uint32_t cmd;
34};
35
36enum {
37 FIO_LINK_CLOSE = 0x89,
38 FIO_LINK_CLOSE_MAGIC = 0x6c696e6b,
39};
40
371d456c
JA
41/*
42 * Return -1 for error and 'nr events' for a positive number
43 * of events
44 */
45static int poll_wait(struct thread_data *td, int fd, short events)
46{
47 struct pollfd pfd;
48 int ret;
49
50 while (!td->terminate) {
51 pfd.fd = fd;
52 pfd.events = events;
53 ret = poll(&pfd, 1, -1);
54 if (ret < 0) {
55 if (errno == EINTR)
d5b388a5 56 break;
371d456c
JA
57
58 td_verror(td, errno, "poll");
59 return -1;
60 } else if (!ret)
61 continue;
62
63 break;
64 }
65
66 if (pfd.revents & events)
67 return 1;
371d456c
JA
68
69 return -1;
70}
71
ed92ac0c
JA
72static int fio_netio_prep(struct thread_data *td, struct io_u *io_u)
73{
b5af8293 74 struct netio_data *nd = td->io_ops->data;
ed92ac0c 75
7a6499da
JA
76 /*
77 * Make sure we don't see spurious reads to a receiver, and vice versa
78 */
b5af8293
JA
79 if ((nd->send_to_net && io_u->ddir == DDIR_READ) ||
80 (!nd->send_to_net && io_u->ddir == DDIR_WRITE)) {
e1161c32 81 td_verror(td, EINVAL, "bad direction");
7a6499da 82 return 1;
ed92ac0c 83 }
7a6499da 84
f85ac25a 85 return 0;
ed92ac0c
JA
86}
87
5921e80c 88#ifdef FIO_HAVE_SPLICE
cd963e18 89static int splice_io_u(int fdin, int fdout, unsigned int len)
ed92ac0c 90{
9cce02e8 91 int bytes = 0;
7a6499da 92
9cce02e8 93 while (len) {
cd963e18 94 int ret = splice(fdin, NULL, fdout, NULL, len, 0);
9cce02e8
JA
95
96 if (ret < 0) {
97 if (!bytes)
98 bytes = ret;
99
100 break;
101 } else if (!ret)
102 break;
103
104 bytes += ret;
f657a2fb 105 len -= ret;
9cce02e8
JA
106 }
107
108 return bytes;
109}
110
111/*
cd963e18 112 * Receive bytes from a socket and fill them into the internal pipe
9cce02e8 113 */
cd963e18 114static int splice_in(struct thread_data *td, struct io_u *io_u)
9cce02e8
JA
115{
116 struct netio_data *nd = td->io_ops->data;
9cce02e8 117
cd963e18 118 return splice_io_u(io_u->file->fd, nd->pipes[1], io_u->xfer_buflen);
9cce02e8
JA
119}
120
121/*
cd963e18 122 * Transmit 'len' bytes from the internal pipe
9cce02e8 123 */
cd963e18
JA
124static int splice_out(struct thread_data *td, struct io_u *io_u,
125 unsigned int len)
9cce02e8
JA
126{
127 struct netio_data *nd = td->io_ops->data;
cd963e18
JA
128
129 return splice_io_u(nd->pipes[0], io_u->file->fd, len);
130}
131
132static int vmsplice_io_u(struct io_u *io_u, int fd, unsigned int len)
133{
9cce02e8
JA
134 struct iovec iov = {
135 .iov_base = io_u->xfer_buf,
136 .iov_len = len,
137 };
138 int bytes = 0;
139
140 while (iov.iov_len) {
cd963e18 141 int ret = vmsplice(fd, &iov, 1, SPLICE_F_MOVE);
9cce02e8
JA
142
143 if (ret < 0) {
144 if (!bytes)
145 bytes = ret;
146 break;
147 } else if (!ret)
148 break;
149
150 iov.iov_len -= ret;
cd963e18 151 iov.iov_base += ret;
f657a2fb 152 bytes += ret;
9cce02e8
JA
153 }
154
155 return bytes;
cd963e18 156
9cce02e8
JA
157}
158
159/*
cd963e18 160 * vmsplice() pipe to io_u buffer
9cce02e8 161 */
cd963e18
JA
162static int vmsplice_io_u_out(struct thread_data *td, struct io_u *io_u,
163 unsigned int len)
9cce02e8
JA
164{
165 struct netio_data *nd = td->io_ops->data;
9cce02e8 166
cd963e18
JA
167 return vmsplice_io_u(io_u, nd->pipes[0], len);
168}
9cce02e8 169
cd963e18
JA
170/*
171 * vmsplice() io_u to pipe
172 */
173static int vmsplice_io_u_in(struct thread_data *td, struct io_u *io_u)
174{
175 struct netio_data *nd = td->io_ops->data;
ed92ac0c 176
cd963e18 177 return vmsplice_io_u(io_u, nd->pipes[1], io_u->xfer_buflen);
9cce02e8
JA
178}
179
cd963e18
JA
180/*
181 * splice receive - transfer socket data into a pipe using splice, then map
182 * that pipe data into the io_u using vmsplice.
183 */
9cce02e8
JA
184static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
185{
186 int ret;
187
188 ret = splice_in(td, io_u);
cd963e18
JA
189 if (ret > 0)
190 return vmsplice_io_u_out(td, io_u, ret);
9cce02e8 191
cd963e18 192 return ret;
9cce02e8
JA
193}
194
cd963e18
JA
195/*
196 * splice transmit - map data from the io_u into a pipe by using vmsplice,
197 * then transfer that pipe to a socket using splice.
198 */
9cce02e8
JA
199static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
200{
201 int ret;
202
203 ret = vmsplice_io_u_in(td, io_u);
cd963e18
JA
204 if (ret > 0)
205 return splice_out(td, io_u, ret);
9cce02e8 206
cd963e18 207 return ret;
9cce02e8 208}
5921e80c
JA
209#else
210static int fio_netio_splice_in(struct thread_data *td, struct io_u *io_u)
211{
af8771b9 212 errno = EOPNOTSUPP;
5921e80c
JA
213 return -1;
214}
215
216static int fio_netio_splice_out(struct thread_data *td, struct io_u *io_u)
217{
af8771b9 218 errno = EOPNOTSUPP;
5921e80c
JA
219 return -1;
220}
221#endif
9cce02e8
JA
222
223static int fio_netio_send(struct thread_data *td, struct io_u *io_u)
224{
414c2a3e 225 struct netio_data *nd = td->io_ops->data;
664fb3bd 226 int ret, flags = MSG_DONTWAIT;
371d456c 227
664fb3bd
JA
228 do {
229 if (nd->net_protocol == IPPROTO_UDP) {
62b38926
JA
230 struct sockaddr *to = (struct sockaddr *) &nd->addr;
231
664fb3bd 232 ret = sendto(io_u->file->fd, io_u->xfer_buf,
62b38926
JA
233 io_u->xfer_buflen, flags, to,
234 sizeof(*to));
664fb3bd
JA
235 } else {
236 /*
237 * if we are going to write more, set MSG_MORE
238 */
5921e80c 239#ifdef MSG_MORE
664fb3bd
JA
240 if (td->this_io_bytes[DDIR_WRITE] + io_u->xfer_buflen <
241 td->o.size)
242 flags |= MSG_MORE;
5921e80c 243#endif
664fb3bd
JA
244 ret = send(io_u->file->fd, io_u->xfer_buf,
245 io_u->xfer_buflen, flags);
246 }
247 if (ret > 0)
248 break;
9cce02e8 249
664fb3bd
JA
250 ret = poll_wait(td, io_u->file->fd, POLLOUT);
251 if (ret <= 0)
252 break;
253
254 flags &= ~MSG_DONTWAIT;
255 } while (1);
256
257 return ret;
258}
259
260static int is_udp_close(struct io_u *io_u, int len)
261{
262 struct udp_close_msg *msg;
263
264 if (len != sizeof(struct udp_close_msg))
265 return 0;
266
267 msg = io_u->xfer_buf;
268 if (ntohl(msg->magic) != FIO_LINK_CLOSE_MAGIC)
269 return 0;
270 if (ntohl(msg->cmd) != FIO_LINK_CLOSE)
271 return 0;
272
273 return 1;
9cce02e8
JA
274}
275
414c2a3e 276static int fio_netio_recv(struct thread_data *td, struct io_u *io_u)
9cce02e8 277{
414c2a3e 278 struct netio_data *nd = td->io_ops->data;
664fb3bd
JA
279 int ret, flags = MSG_DONTWAIT;
280
281 do {
282 if (nd->net_protocol == IPPROTO_UDP) {
283 socklen_t len = sizeof(nd->addr);
62b38926 284 struct sockaddr *from = (struct sockaddr *) &nd->addr;
664fb3bd
JA
285
286 ret = recvfrom(io_u->file->fd, io_u->xfer_buf,
62b38926 287 io_u->xfer_buflen, flags, from, &len);
664fb3bd
JA
288 if (is_udp_close(io_u, ret)) {
289 td->done = 1;
290 return 0;
291 }
292 } else {
293 ret = recv(io_u->file->fd, io_u->xfer_buf,
294 io_u->xfer_buflen, flags);
295 }
296 if (ret > 0)
297 break;
9cce02e8 298
664fb3bd
JA
299 ret = poll_wait(td, io_u->file->fd, POLLIN);
300 if (ret <= 0)
301 break;
302 flags &= ~MSG_DONTWAIT;
303 flags |= MSG_WAITALL;
304 } while (1);
414c2a3e 305
664fb3bd 306 return ret;
9cce02e8
JA
307}
308
309static int fio_netio_queue(struct thread_data *td, struct io_u *io_u)
310{
311 struct netio_data *nd = td->io_ops->data;
312 int ret;
313
7101d9c2
JA
314 fio_ro_check(td, io_u);
315
9cce02e8 316 if (io_u->ddir == DDIR_WRITE) {
414c2a3e 317 if (!nd->use_splice || nd->net_protocol == IPPROTO_UDP)
9cce02e8 318 ret = fio_netio_send(td, io_u);
414c2a3e
JA
319 else
320 ret = fio_netio_splice_out(td, io_u);
d4f12dd0 321 } else if (io_u->ddir == DDIR_READ) {
414c2a3e
JA
322 if (!nd->use_splice || nd->net_protocol == IPPROTO_UDP)
323 ret = fio_netio_recv(td, io_u);
9cce02e8 324 else
414c2a3e 325 ret = fio_netio_splice_in(td, io_u);
d4f12dd0 326 } else
7a6499da 327 ret = 0; /* must be a SYNC */
ed92ac0c 328
cec6b55d 329 if (ret != (int) io_u->xfer_buflen) {
22819ec2 330 if (ret >= 0) {
cec6b55d
JA
331 io_u->resid = io_u->xfer_buflen - ret;
332 io_u->error = 0;
36167d82 333 return FIO_Q_COMPLETED;
414c2a3e
JA
334 } else {
335 int err = errno;
336
337 if (io_u->ddir == DDIR_WRITE && err == EMSGSIZE)
338 return FIO_Q_BUSY;
339
340 io_u->error = err;
341 }
ed92ac0c
JA
342 }
343
36167d82 344 if (io_u->error)
e1161c32 345 td_verror(td, io_u->error, "xfer");
ed92ac0c 346
36167d82 347 return FIO_Q_COMPLETED;
ed92ac0c
JA
348}
349
b5af8293 350static int fio_netio_connect(struct thread_data *td, struct fio_file *f)
ed92ac0c 351{
b5af8293 352 struct netio_data *nd = td->io_ops->data;
414c2a3e
JA
353 int type;
354
355 if (nd->net_protocol == IPPROTO_TCP)
356 type = SOCK_STREAM;
357 else
358 type = SOCK_DGRAM;
ed92ac0c 359
414c2a3e 360 f->fd = socket(AF_INET, type, nd->net_protocol);
b5af8293
JA
361 if (f->fd < 0) {
362 td_verror(td, errno, "socket");
363 return 1;
ed92ac0c
JA
364 }
365
414c2a3e
JA
366 if (nd->net_protocol == IPPROTO_UDP)
367 return 0;
368
b5af8293
JA
369 if (connect(f->fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
370 td_verror(td, errno, "connect");
371 return 1;
ed92ac0c
JA
372 }
373
374 return 0;
ed92ac0c
JA
375}
376
b5af8293 377static int fio_netio_accept(struct thread_data *td, struct fio_file *f)
5fdd124a 378{
b5af8293
JA
379 struct netio_data *nd = td->io_ops->data;
380 socklen_t socklen = sizeof(nd->addr);
5fdd124a 381
414c2a3e
JA
382 if (nd->net_protocol == IPPROTO_UDP) {
383 f->fd = nd->listenfd;
384 return 0;
385 }
386
6d86144d 387 log_info("fio: waiting for connection\n");
5fdd124a 388
371d456c
JA
389 if (poll_wait(td, nd->listenfd, POLLIN) < 0)
390 return 1;
0c09442b 391
371d456c
JA
392 f->fd = accept(nd->listenfd, (struct sockaddr *) &nd->addr, &socklen);
393 if (f->fd < 0) {
394 td_verror(td, errno, "accept");
395 return 1;
b5af8293 396 }
5fdd124a 397
b5af8293
JA
398 return 0;
399}
400
b5af8293
JA
401static int fio_netio_open_file(struct thread_data *td, struct fio_file *f)
402{
403 if (td_read(td))
404 return fio_netio_accept(td, f);
405 else
406 return fio_netio_connect(td, f);
407}
408
664fb3bd
JA
409static void fio_netio_udp_close(struct thread_data *td, struct fio_file *f)
410{
411 struct netio_data *nd = td->io_ops->data;
412 struct udp_close_msg msg;
62b38926 413 struct sockaddr *to = (struct sockaddr *) &nd->addr;
664fb3bd
JA
414 int ret;
415
416 msg.magic = htonl(FIO_LINK_CLOSE_MAGIC);
417 msg.cmd = htonl(FIO_LINK_CLOSE);
418
62b38926 419 ret = sendto(f->fd, &msg, sizeof(msg), MSG_WAITALL, to,
664fb3bd
JA
420 sizeof(nd->addr));
421 if (ret < 0)
422 td_verror(td, errno, "sendto udp link close");
423}
424
425static int fio_netio_close_file(struct thread_data *td, struct fio_file *f)
426{
427 struct netio_data *nd = td->io_ops->data;
428
429 /*
430 * If this is an UDP connection, notify the receiver that we are
431 * closing down the link
432 */
433 if (nd->net_protocol == IPPROTO_UDP)
434 fio_netio_udp_close(td, f);
435
436 return generic_close_file(td, f);
437}
438
b5af8293
JA
439static int fio_netio_setup_connect(struct thread_data *td, const char *host,
440 unsigned short port)
441{
442 struct netio_data *nd = td->io_ops->data;
443
444 nd->addr.sin_family = AF_INET;
445 nd->addr.sin_port = htons(port);
446
447 if (inet_aton(host, &nd->addr.sin_addr) != 1) {
448 struct hostent *hent;
449
450 hent = gethostbyname(host);
451 if (!hent) {
452 td_verror(td, errno, "gethostbyname");
453 return 1;
5fdd124a 454 }
b5af8293
JA
455
456 memcpy(&nd->addr.sin_addr, hent->h_addr, 4);
5fdd124a
JA
457 }
458
459 return 0;
460}
461
b5af8293 462static int fio_netio_setup_listen(struct thread_data *td, short port)
ed92ac0c 463{
b5af8293 464 struct netio_data *nd = td->io_ops->data;
414c2a3e 465 int fd, opt, type;
ed92ac0c 466
414c2a3e
JA
467 if (nd->net_protocol == IPPROTO_TCP)
468 type = SOCK_STREAM;
469 else
470 type = SOCK_DGRAM;
471
472 fd = socket(AF_INET, type, nd->net_protocol);
ed92ac0c 473 if (fd < 0) {
e1161c32 474 td_verror(td, errno, "socket");
ed92ac0c
JA
475 return 1;
476 }
477
478 opt = 1;
479 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
e1161c32 480 td_verror(td, errno, "setsockopt");
ed92ac0c
JA
481 return 1;
482 }
6bedbfaf
JA
483#ifdef SO_REUSEPORT
484 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
e1161c32 485 td_verror(td, errno, "setsockopt");
6bedbfaf
JA
486 return 1;
487 }
488#endif
ed92ac0c 489
b5af8293
JA
490 nd->addr.sin_family = AF_INET;
491 nd->addr.sin_addr.s_addr = htonl(INADDR_ANY);
492 nd->addr.sin_port = htons(port);
ed92ac0c 493
b5af8293 494 if (bind(fd, (struct sockaddr *) &nd->addr, sizeof(nd->addr)) < 0) {
e1161c32 495 td_verror(td, errno, "bind");
ed92ac0c
JA
496 return 1;
497 }
414c2a3e 498 if (nd->net_protocol == IPPROTO_TCP && listen(fd, 1) < 0) {
e1161c32 499 td_verror(td, errno, "listen");
ed92ac0c
JA
500 return 1;
501 }
502
b5af8293
JA
503 nd->listenfd = fd;
504 return 0;
ed92ac0c
JA
505}
506
9bec88e1 507static int fio_netio_init(struct thread_data *td)
ed92ac0c 508{
b5af8293 509 struct netio_data *nd = td->io_ops->data;
443662ef 510 unsigned int port;
b5af8293 511 char host[64], buf[128];
414c2a3e 512 char *sep, *portp, *modep;
af52b345 513 int ret;
ed92ac0c 514
413dd459 515 if (td_rw(td)) {
ed92ac0c
JA
516 log_err("fio: network connections must be read OR write\n");
517 return 1;
518 }
16d55aae
JA
519 if (td_random(td)) {
520 log_err("fio: network IO can't be random\n");
521 return 1;
522 }
ed92ac0c 523
2dc1bbeb 524 strcpy(buf, td->o.filename);
ed92ac0c 525
9f9214f2 526 sep = strchr(buf, '/');
443662ef
JA
527 if (!sep)
528 goto bad_host;
ed92ac0c
JA
529
530 *sep = '\0';
531 sep++;
532 strcpy(host, buf);
443662ef
JA
533 if (!strlen(host))
534 goto bad_host;
535
414c2a3e
JA
536 modep = NULL;
537 portp = sep;
538 sep = strchr(portp, '/');
539 if (sep) {
540 *sep = '\0';
541 modep = sep + 1;
542 }
543
544 port = strtol(portp, NULL, 10);
443662ef
JA
545 if (!port || port > 65535)
546 goto bad_host;
ed92ac0c 547
414c2a3e 548 if (modep) {
3f8fc5ad
JA
549 if (!strncmp("tcp", modep, strlen(modep)) ||
550 !strncmp("TCP", modep, strlen(modep)))
414c2a3e 551 nd->net_protocol = IPPROTO_TCP;
3f8fc5ad
JA
552 else if (!strncmp("udp", modep, strlen(modep)) ||
553 !strncmp("UDP", modep, strlen(modep)))
414c2a3e
JA
554 nd->net_protocol = IPPROTO_UDP;
555 else
556 goto bad_host;
557 } else
558 nd->net_protocol = IPPROTO_TCP;
559
413dd459 560 if (td_read(td)) {
b5af8293 561 nd->send_to_net = 0;
ed92ac0c
JA
562 ret = fio_netio_setup_listen(td, port);
563 } else {
b5af8293 564 nd->send_to_net = 1;
ed92ac0c
JA
565 ret = fio_netio_setup_connect(td, host, port);
566 }
567
7bb48f84 568 return ret;
443662ef 569bad_host:
414c2a3e 570 log_err("fio: bad network host/port/protocol: %s\n", td->o.filename);
443662ef 571 return 1;
ed92ac0c
JA
572}
573
b5af8293 574static void fio_netio_cleanup(struct thread_data *td)
9bec88e1 575{
b5af8293
JA
576 struct netio_data *nd = td->io_ops->data;
577
578 if (nd) {
64b24cd8
JA
579 if (nd->listenfd != -1)
580 close(nd->listenfd);
581 if (nd->pipes[0] != -1)
582 close(nd->pipes[0]);
583 if (nd->pipes[1] != -1)
584 close(nd->pipes[1]);
585
b5af8293 586 free(nd);
b5af8293
JA
587 }
588}
589
590static int fio_netio_setup(struct thread_data *td)
591{
7bb48f84 592 struct netio_data *nd;
7bb48f84
JA
593
594 if (!td->io_ops->data) {
595 nd = malloc(sizeof(*nd));;
596
597 memset(nd, 0, sizeof(*nd));
598 nd->listenfd = -1;
64b24cd8 599 nd->pipes[0] = nd->pipes[1] = -1;
7bb48f84 600 td->io_ops->data = nd;
7bb48f84 601 }
b5af8293 602
9bec88e1
JA
603 return 0;
604}
605
5921e80c 606#ifdef FIO_HAVE_SPLICE
9cce02e8
JA
607static int fio_netio_setup_splice(struct thread_data *td)
608{
609 struct netio_data *nd;
610
611 fio_netio_setup(td);
612
613 nd = td->io_ops->data;
614 if (nd) {
615 if (pipe(nd->pipes) < 0)
616 return 1;
617
618 nd->use_splice = 1;
619 return 0;
620 }
621
622 return 1;
623}
624
5921e80c
JA
625static struct ioengine_ops ioengine_splice = {
626 .name = "netsplice",
ed92ac0c 627 .version = FIO_IOOPS_VERSION,
ed92ac0c
JA
628 .prep = fio_netio_prep,
629 .queue = fio_netio_queue,
5921e80c 630 .setup = fio_netio_setup_splice,
9bec88e1 631 .init = fio_netio_init,
b5af8293
JA
632 .cleanup = fio_netio_cleanup,
633 .open_file = fio_netio_open_file,
634 .close_file = generic_close_file,
ad830ed7 635 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
9c0d2241 636 FIO_SIGQUIT | FIO_PIPEIO,
ed92ac0c 637};
5921e80c 638#endif
ed92ac0c 639
5921e80c
JA
640static struct ioengine_ops ioengine_rw = {
641 .name = "net",
9cce02e8
JA
642 .version = FIO_IOOPS_VERSION,
643 .prep = fio_netio_prep,
644 .queue = fio_netio_queue,
5921e80c 645 .setup = fio_netio_setup,
9cce02e8
JA
646 .init = fio_netio_init,
647 .cleanup = fio_netio_cleanup,
648 .open_file = fio_netio_open_file,
664fb3bd 649 .close_file = fio_netio_close_file,
ad830ed7 650 .flags = FIO_SYNCIO | FIO_DISKLESSIO | FIO_UNIDIR |
9c0d2241 651 FIO_SIGQUIT | FIO_PIPEIO,
9cce02e8
JA
652};
653
ed92ac0c
JA
654static void fio_init fio_netio_register(void)
655{
9cce02e8 656 register_ioengine(&ioengine_rw);
5921e80c 657#ifdef FIO_HAVE_SPLICE
9cce02e8 658 register_ioengine(&ioengine_splice);
5921e80c 659#endif
ed92ac0c
JA
660}
661
662static void fio_exit fio_netio_unregister(void)
663{
9cce02e8 664 unregister_ioengine(&ioengine_rw);
5921e80c 665#ifdef FIO_HAVE_SPLICE
9cce02e8 666 unregister_ioengine(&ioengine_splice);
5921e80c 667#endif
ed92ac0c 668}