Context Navigation

iocall.cfa@ d2b5d2d

Visit:

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast new-ast-unique-expr pthread-emulation qualifiedEnum

Last change on this file since d2b5d2d was 4998155, checked in by Thierry Delisle <tdelisle@…>, 5 years ago
I/O now uses onshot semaphore instead of raw park/unpark. I/O now uses linux/types.h types instead of stdint.h types
Property mode set to `100644`
File size: 19.5 KB

Line
1	//
2	// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo
3	//
4	// The contents of this file are covered under the licence agreement in the
5	// file "LICENCE" distributed with Cforall.
6	//
7	// iocall.cfa --
8	//
9	// Author : Thierry Delisle
10	// Created On : Wed Jul 1 14:51:00 2020
11	// Last Modified By :
12	// Last Modified On :
13	// Update Count :
14	//
15
16	#define __cforall_thread__
17
18	#include "bits/defs.hfa"
19	#include "kernel.hfa"
20
21	//=============================================================================================
22	// I/O uring backend
23	//=============================================================================================
24
25	#if defined(CFA_HAVE_LINUX_IO_URING_H)
26	#include <assert.h>
27	#include <stdint.h>
28	#include <errno.h>
29	#include <linux/io_uring.h>
30
31	#include "kernel/fwd.hfa"
32	#include "io/types.hfa"
33
34	extern [* struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data );
35	extern void __submit( struct io_context * ctx, __u32 idx ) __attribute__((nonnull (1)));
36
37	static inline void ?{}(struct io_uring_sqe & this, __u8 opcode, int fd) {
38	this.opcode = opcode;
39	#if !defined(IOSQE_ASYNC)
40	this.flags = 0;
41	#else
42	this.flags = IOSQE_ASYNC;
43	#endif
44	this.ioprio = 0;
45	this.fd = fd;
46	this.off = 0;
47	this.addr = 0;
48	this.len = 0;
49	this.rw_flags = 0;
50	this.__pad2[0] = this.__pad2[1] = this.__pad2[2] = 0;
51	}
52
53	static inline void ?{}(struct io_uring_sqe & this, __u8 opcode, int fd, void * addr, __u32 len, __u64 off ) {
54	(this){ opcode, fd };
55	this.off = off;
56	this.addr = (__u64)(uintptr_t)addr;
57	this.len = len;
58	}
59
60	static inline io_context * __get_io_context( void ) {
61	cluster * cltr = active_cluster();
62	/* paranoid */ verifyf( cltr, "No active cluster for io operation\n");
63	assertf( cltr->io.cnt > 0, "Cluster %p has no default io contexts and no context was specified\n", cltr );
64	/* paranoid */ verifyf( cltr->io.ctxs, "default io contexts for cluster %p are missing\n", cltr);
65	return &cltr->io.ctxs[ __tls_rand() % cltr->io.cnt ];
66	}
67
68
69	#if defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
70	#define REGULAR_FLAGS (IOSQE_FIXED_FILE \| IOSQE_IO_DRAIN \| IOSQE_ASYNC)
71	#elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_ASYNC)
72	#define REGULAR_FLAGS (IOSQE_FIXED_FILE \| IOSQE_ASYNC)
73	#elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN)
74	#define REGULAR_FLAGS (IOSQE_FIXED_FILE \| IOSQE_IO_DRAIN)
75	#elif defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
76	#define REGULAR_FLAGS (IOSQE_IO_DRAIN \| IOSQE_ASYNC)
77	#elif defined(CFA_HAVE_IOSQE_FIXED_FILE)
78	#define REGULAR_FLAGS (IOSQE_FIXED_FILE)
79	#elif defined(CFA_HAVE_IOSQE_IO_DRAIN)
80	#define REGULAR_FLAGS (IOSQE_IO_DRAIN)
81	#elif defined(CFA_HAVE_IOSQE_ASYNC)
82	#define REGULAR_FLAGS (IOSQE_ASYNC)
83	#else
84	#define REGULAR_FLAGS (0)
85	#endif
86
87	#if defined(CFA_HAVE_IOSQE_IO_LINK) && defined(CFA_HAVE_IOSQE_IO_HARDLINK)
88	#define LINK_FLAGS (IOSQE_IO_LINK \| IOSQE_IO_HARDLINK)
89	#elif defined(CFA_HAVE_IOSQE_IO_LINK)
90	#define LINK_FLAGS (IOSQE_IO_LINK)
91	#elif defined(CFA_HAVE_IOSQE_IO_HARDLINK)
92	#define LINK_FLAGS (IOSQE_IO_HARDLINK)
93	#else
94	#define LINK_FLAGS (0)
95	#endif
96
97	#if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
98	#define SPLICE_FLAGS (SPLICE_F_FD_IN_FIXED)
99	#else
100	#define SPLICE_FLAGS (0)
101	#endif
102
103	#define __submit_prelude \
104	if( 0 != (submit_flags & LINK_FLAGS) ) { errno = ENOTSUP; return -1; } \
105	(void)timeout; (void)cancellation; \
106	if( !context ) context = __get_io_context(); \
107	__io_user_data_t data = { 0 }; \
108	struct __io_data & ring = *context->thrd.ring; \
109	struct io_uring_sqe * sqe; \
110	__u32 idx; \
111	__u8 sflags = REGULAR_FLAGS & submit_flags; \
112	[sqe, idx] = __submit_alloc( ring, (__u64)(uintptr_t)&data ); \
113	sqe->flags = sflags;
114
115	#define __submit_wait \
116	/__cfaabi_bits_print_safe( STDERR_FILENO, "Preparing user data %p for %p\n", &data, data.thrd );/ \
117	verify( sqe->user_data == (__u64)(uintptr_t)&data ); \
118	__submit( context, idx ); \
119	wait( data.sem ); \
120	if( data.result < 0 ) { \
121	errno = -data.result; \
122	return -1; \
123	} \
124	return data.result;
125	#endif
126
127	//=============================================================================================
128	// I/O Forwards
129	//=============================================================================================
130	#include <time.hfa>
131
132	// Some forward declarations
133	#include <errno.h>
134	#include <unistd.h>
135
136	extern "C" {
137	#include <sys/types.h>
138	#include <sys/socket.h>
139	#include <sys/syscall.h>
140
141	#if defined(HAVE_PREADV2)
142	struct iovec;
143	extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
144	#endif
145	#if defined(HAVE_PWRITEV2)
146	struct iovec;
147	extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
148	#endif
149
150	extern int fsync(int fd);
151
152	typedef __off64_t off_t;
153	typedef __off64_t off64_t;
154	extern int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags);
155
156	struct msghdr;
157	struct sockaddr;
158	extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
159	extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
160	extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
161	extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
162	extern int accept4(int sockfd, struct sockaddr addr, socklen_t addrlen, int flags);
163	extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
164
165	extern int fallocate(int fd, int mode, off_t offset, off_t len);
166	extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
167	extern int madvise(void *addr, size_t length, int advice);
168
169	extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
170	extern int close(int fd);
171
172	extern ssize_t read (int fd, void *buf, size_t count);
173
174	extern ssize_t splice(int fd_in, loff_t off_in, int fd_out, loff_t off_out, size_t len, unsigned int flags);
175	extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
176	}
177
178	//=============================================================================================
179	// I/O Interface
180	//=============================================================================================
181
182	//-----------------------------------------------------------------------------
183	// Asynchronous operations
184	#if defined(HAVE_PREADV2)
185	ssize_t cfa_preadv2(int fd, const struct iovec iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
186	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_READV)
187	return preadv2(fd, iov, iovcnt, offset, flags);
188	#else
189	__submit_prelude
190
191	sqe->opcode = IORING_OP_READV;
192	sqe->ioprio = 0;
193	sqe->fd = fd;
194	sqe->off = offset;
195	sqe->addr = (__u64)iov;
196	sqe->len = iovcnt;
197	sqe->rw_flags = 0;
198	sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
199
200	__submit_wait
201	#endif
202	}
203	#endif
204
205	#if defined(HAVE_PWRITEV2)
206	ssize_t cfa_pwritev2(int fd, const struct iovec iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
207	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_WRITEV)
208	return pwritev2(fd, iov, iovcnt, offset, flags);
209	#else
210	__submit_prelude
211
212	sqe->opcode = IORING_OP_WRITEV;
213	sqe->ioprio = 0;
214	sqe->fd = fd;
215	sqe->off = offset;
216	sqe->addr = (__u64)iov;
217	sqe->len = iovcnt;
218	sqe->rw_flags = 0;
219	sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
220
221	__submit_wait
222	#endif
223	}
224	#endif
225
226	int cfa_fsync(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
227	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_FSYNC)
228	return fsync(fd);
229	#else
230	__submit_prelude
231
232	sqe->opcode = IORING_OP_FSYNC;
233	sqe->ioprio = 0;
234	sqe->fd = fd;
235	sqe->off = 0;
236	sqe->addr = 0;
237	sqe->len = 0;
238	sqe->rw_flags = 0;
239	sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
240
241	__submit_wait
242	#endif
243	}
244
245	int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
246	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE)
247	return sync_file_range(fd, offset, nbytes, flags);
248	#else
249	__submit_prelude
250
251	(*sqe){ IORING_OP_SYNC_FILE_RANGE, fd };
252	sqe->off = offset;
253	sqe->len = nbytes;
254	sqe->sync_range_flags = flags;
255
256	__submit_wait
257	#endif
258	}
259
260
261	ssize_t cfa_sendmsg(int sockfd, const struct msghdr msg, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
262	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_SENDMSG)
263	return sendmsg(sockfd, msg, flags);
264	#else
265	__submit_prelude
266
267	(*sqe){ IORING_OP_SENDMSG, sockfd, msg, 1, 0 };
268	sqe->msg_flags = flags;
269
270	__submit_wait
271	#endif
272	}
273
274	ssize_t cfa_recvmsg(int sockfd, struct msghdr msg, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
275	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_RECVMSG)
276	return recvmsg(sockfd, msg, flags);
277	#else
278	__submit_prelude
279
280	(*sqe){ IORING_OP_RECVMSG, sockfd, msg, 1, 0 };
281	sqe->msg_flags = flags;
282
283	__submit_wait
284	#endif
285	}
286
287	ssize_t cfa_send(int sockfd, const void buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
288	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_SEND)
289	return send( sockfd, buf, len, flags );
290	#else
291	__submit_prelude
292
293	(*sqe){ IORING_OP_SEND, sockfd };
294	sqe->addr = (__u64)buf;
295	sqe->len = len;
296	sqe->msg_flags = flags;
297
298	__submit_wait
299	#endif
300	}
301
302	ssize_t cfa_recv(int sockfd, void buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
303	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_RECV)
304	return recv( sockfd, buf, len, flags );
305	#else
306	__submit_prelude
307
308	(*sqe){ IORING_OP_RECV, sockfd };
309	sqe->addr = (__u64)buf;
310	sqe->len = len;
311	sqe->msg_flags = flags;
312
313	__submit_wait
314	#endif
315	}
316
317	int cfa_accept4(int sockfd, struct sockaddr addr, socklen_t addrlen, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
318	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_ACCEPT)
319	return accept4( sockfd, addr, addrlen, flags );
320	#else
321	__submit_prelude
322
323	(*sqe){ IORING_OP_ACCEPT, sockfd };
324	sqe->addr = (__u64)addr;
325	sqe->addr2 = (__u64)addrlen;
326	sqe->accept_flags = flags;
327
328	__submit_wait
329	#endif
330	}
331
332	int cfa_connect(int sockfd, const struct sockaddr addr, socklen_t addrlen, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
333	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_CONNECT)
334	return connect( sockfd, addr, addrlen );
335	#else
336	__submit_prelude
337
338	(*sqe){ IORING_OP_CONNECT, sockfd };
339	sqe->addr = (__u64)addr;
340	sqe->off = (__u64)addrlen;
341
342	__submit_wait
343	#endif
344	}
345
346	int cfa_fallocate(int fd, int mode, off_t offset, off_t len, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
347	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_FALLOCATE)
348	return fallocate( fd, mode, offset, len );
349	#else
350	__submit_prelude
351
352	#warning FALLOCATE documentation for linux 5.7 is incorrect, and does not handle mode
353
354	(*sqe){ IORING_OP_FALLOCATE, fd };
355	sqe->off = offset;
356	sqe->len = mode;
357	sqe->addr = len;
358
359	__submit_wait
360	#endif
361	}
362
363	int cfa_fadvise(int fd, off_t offset, off_t len, int advice, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
364	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_FADVISE)
365	return posix_fadvise( fd, offset, len, advice );
366	#else
367	__submit_prelude
368
369	(*sqe){ IORING_OP_FADVISE, fd };
370	sqe->off = (__u64)offset;
371	sqe->len = len;
372	sqe->fadvise_advice = advice;
373
374	__submit_wait
375	#endif
376	}
377
378	int cfa_madvise(void addr, size_t length, int advice, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
379	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_MADVISE)
380	return madvise( addr, length, advice );
381	#else
382	__submit_prelude
383
384	(*sqe){ IORING_OP_MADVISE, 0 };
385	sqe->addr = (__u64)addr;
386	sqe->len = length;
387	sqe->fadvise_advice = advice;
388
389	__submit_wait
390	#endif
391	}
392
393	int cfa_openat(int dirfd, const char pathname, int flags, mode_t mode, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
394	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_OPENAT)
395	return openat( dirfd, pathname, flags, mode );
396	#else
397	__submit_prelude
398
399	(*sqe){ IORING_OP_OPENAT, dirfd };
400	sqe->addr = (__u64)pathname;
401	sqe->open_flags = flags;
402	sqe->len = mode;
403
404	__submit_wait
405	#endif
406	}
407
408	int cfa_close(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
409	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_CLOSE)
410	return close( fd );
411	#else
412	__submit_prelude
413
414	(*sqe){ IORING_OP_CLOSE, fd };
415
416	__submit_wait
417	#endif
418	}
419
420	// Forward declare in case it is not supported
421	struct statx;
422	int cfa_statx(int dirfd, const char pathname, int flags, unsigned int mask, struct statx statxbuf, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
423	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_STATX)
424	#if defined(__NR_statx)
425	return syscall( __NR_statx, dirfd, pathname, flags, mask, statxbuf );
426	#else
427	errno = ENOTSUP;
428	return -1;
429	#endif
430	#else
431	__submit_prelude
432
433	(*sqe){ IORING_OP_STATX, dirfd, pathname, mask, (__u64)statxbuf };
434	sqe->statx_flags = flags;
435
436	__submit_wait
437	#endif
438	}
439
440	ssize_t cfa_read(int fd, void buf, size_t count, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
441	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_READ)
442	return read( fd, buf, count );
443	#else
444	__submit_prelude
445
446	(*sqe){ IORING_OP_READ, fd, buf, count, 0 };
447
448	__submit_wait
449	#endif
450	}
451
452	ssize_t cfa_write(int fd, void buf, size_t count, int submit_flags, Duration timeout, io_cancellation cancellation, io_context * context) {
453	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_WRITE)
454	return read( fd, buf, count );
455	#else
456	__submit_prelude
457
458	(*sqe){ IORING_OP_WRITE, fd, buf, count, 0 };
459
460	__submit_wait
461	#endif
462	}
463
464	ssize_t cfa_splice(int fd_in, loff_t off_in, int fd_out, loff_t off_out, size_t len, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
465	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_SPLICE)
466	return splice( fd_in, off_in, fd_out, off_out, len, flags );
467	#else
468	__submit_prelude
469
470	(*sqe){ IORING_OP_SPLICE, fd_out };
471	if( off_out ) {
472	sqe->off = *off_out;
473	}
474	else {
475	sqe->off = (__u64)-1;
476	}
477	sqe->len = len;
478	sqe->splice_fd_in = fd_in;
479	if( off_in ) {
480	sqe->splice_off_in = *off_in;
481	}
482	else {
483	sqe->splice_off_in = (__u64)-1;
484	}
485	sqe->splice_flags = flags \| (SPLICE_FLAGS & submit_flags);
486
487	__submit_wait
488	#endif
489	}
490
491	ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {
492	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_TEE)
493	return tee( fd_in, fd_out, len, flags );
494	#else
495	__submit_prelude
496
497	(*sqe){ IORING_OP_TEE, fd_out, 0p, len, 0 };
498	sqe->splice_fd_in = fd_in;
499	sqe->splice_flags = flags \| (SPLICE_FLAGS & submit_flags);
500
501	__submit_wait
502	#endif
503	}
504
505	//-----------------------------------------------------------------------------
506	// Check if a function is asynchronous
507
508	// Macro magic to reduce the size of the following switch case
509	#define IS_DEFINED_APPLY(f, ...) f(__VA_ARGS__)
510	#define IS_DEFINED_SECOND(first, second, ...) second
511	#define IS_DEFINED_TEST(expansion) _CFA_IO_FEATURE_##expansion
512	#define IS_DEFINED(macro) IS_DEFINED_APPLY( IS_DEFINED_SECOND,IS_DEFINED_TEST(macro) false, true)
513
514	bool has_user_level_blocking( fptr_t func ) {
515	#if defined(CFA_HAVE_LINUX_IO_URING_H)
516	#if defined(HAVE_PREADV2)
517	if( /func == (fptr_t)preadv2 \|\| /
518	func == (fptr_t)cfa_preadv2 )
519	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READV ,
520	return IS_DEFINED(CFA_HAVE_IORING_OP_READV);
521	#endif
522
523	#if defined(HAVE_PWRITEV2)
524	if( /func == (fptr_t)pwritev2 \|\| /
525	func == (fptr_t)cfa_pwritev2 )
526	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITEV ,
527	return IS_DEFINED(CFA_HAVE_IORING_OP_WRITEV);
528	#endif
529
530	if( /func == (fptr_t)fsync \|\| /
531	func == (fptr_t)cfa_fsync )
532	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FSYNC ,
533	return IS_DEFINED(CFA_HAVE_IORING_OP_FSYNC);
534
535	if( /func == (fptr_t)ync_file_range \|\| /
536	func == (fptr_t)cfa_sync_file_range )
537	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SYNC_FILE_RANGE ,
538	return IS_DEFINED(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE);
539
540	if( /func == (fptr_t)sendmsg \|\| /
541	func == (fptr_t)cfa_sendmsg )
542	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SENDMSG ,
543	return IS_DEFINED(CFA_HAVE_IORING_OP_SENDMSG);
544
545	if( /func == (fptr_t)recvmsg \|\| /
546	func == (fptr_t)cfa_recvmsg )
547	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECVMSG ,
548	return IS_DEFINED(CFA_HAVE_IORING_OP_RECVMSG);
549
550	if( /func == (fptr_t)send \|\| /
551	func == (fptr_t)cfa_send )
552	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SEND ,
553	return IS_DEFINED(CFA_HAVE_IORING_OP_SEND);
554
555	if( /func == (fptr_t)recv \|\| /
556	func == (fptr_t)cfa_recv )
557	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECV ,
558	return IS_DEFINED(CFA_HAVE_IORING_OP_RECV);
559
560	if( /func == (fptr_t)accept4 \|\| /
561	func == (fptr_t)cfa_accept4 )
562	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_ACCEPT ,
563	return IS_DEFINED(CFA_HAVE_IORING_OP_ACCEPT);
564
565	if( /func == (fptr_t)connect \|\| /
566	func == (fptr_t)cfa_connect )
567	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CONNECT ,
568	return IS_DEFINED(CFA_HAVE_IORING_OP_CONNECT);
569
570	if( /func == (fptr_t)fallocate \|\| /
571	func == (fptr_t)cfa_fallocate )
572	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FALLOCATE ,
573	return IS_DEFINED(CFA_HAVE_IORING_OP_FALLOCATE);
574
575	if( /func == (fptr_t)posix_fadvise \|\| /
576	func == (fptr_t)cfa_fadvise )
577	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FADVISE ,
578	return IS_DEFINED(CFA_HAVE_IORING_OP_FADVISE);
579
580	if( /func == (fptr_t)madvise \|\| /
581	func == (fptr_t)cfa_madvise )
582	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_MADVISE ,
583	return IS_DEFINED(CFA_HAVE_IORING_OP_MADVISE);
584
585	if( /func == (fptr_t)openat \|\| /
586	func == (fptr_t)cfa_openat )
587	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_OPENAT ,
588	return IS_DEFINED(CFA_HAVE_IORING_OP_OPENAT);
589
590	if( /func == (fptr_t)close \|\| /
591	func == (fptr_t)cfa_close )
592	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CLOSE ,
593	return IS_DEFINED(CFA_HAVE_IORING_OP_CLOSE);
594
595	if( /func == (fptr_t)read \|\| /
596	func == (fptr_t)cfa_read )
597	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READ ,
598	return IS_DEFINED(CFA_HAVE_IORING_OP_READ);
599
600	if( /func == (fptr_t)write \|\| /
601	func == (fptr_t)cfa_write )
602	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITE ,
603	return IS_DEFINED(CFA_HAVE_IORING_OP_WRITE);
604
605	if( /func == (fptr_t)splice \|\| /
606	func == (fptr_t)cfa_splice )
607	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SPLICE ,
608	return IS_DEFINED(CFA_HAVE_IORING_OP_SPLICE);
609
610	if( /func == (fptr_t)tee \|\| /
611	func == (fptr_t)cfa_tee )
612	#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_TEE ,
613	return IS_DEFINED(CFA_HAVE_IORING_OP_TEE);
614	#endif
615
616	return false;
617	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format