xref: /linux/include/uapi/linux/io_uring.h (revision f679ebf6aa9b42d0edb5b261e16dc7b1e3c3550e)
1 /* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR MIT */
2 /*
3  * Header file for the io_uring interface.
4  *
5  * Copyright (C) 2019 Jens Axboe
6  * Copyright (C) 2019 Christoph Hellwig
7  */
8 #ifndef LINUX_IO_URING_H
9 #define LINUX_IO_URING_H
10 
11 #include <linux/fs.h>
12 #include <linux/types.h>
13 /*
14  * this file is shared with liburing and that has to autodetect
15  * if linux/time_types.h is available or not, it can
16  * define UAPI_LINUX_IO_URING_H_SKIP_LINUX_TIME_TYPES_H
17  * if linux/time_types.h is not available
18  */
19 #ifndef UAPI_LINUX_IO_URING_H_SKIP_LINUX_TIME_TYPES_H
20 #include <linux/time_types.h>
21 #endif
22 
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 
27 /*
28  * IO submission data structure (Submission Queue Entry)
29  */
30 struct io_uring_sqe {
31 	__u8	opcode;		/* type of operation for this sqe */
32 	__u8	flags;		/* IOSQE_ flags */
33 	__u16	ioprio;		/* ioprio for the request */
34 	__s32	fd;		/* file descriptor to do IO on */
35 	union {
36 		__u64	off;	/* offset into file */
37 		__u64	addr2;
38 		struct {
39 			__u32	cmd_op;
40 			__u32	__pad1;
41 		};
42 	};
43 	union {
44 		__u64	addr;	/* pointer to buffer or iovecs */
45 		__u64	splice_off_in;
46 		struct {
47 			__u32	level;
48 			__u32	optname;
49 		};
50 	};
51 	__u32	len;		/* buffer size or number of iovecs */
52 	union {
53 		__kernel_rwf_t	rw_flags;
54 		__u32		fsync_flags;
55 		__u16		poll_events;	/* compatibility */
56 		__u32		poll32_events;	/* word-reversed for BE */
57 		__u32		sync_range_flags;
58 		__u32		msg_flags;
59 		__u32		timeout_flags;
60 		__u32		accept_flags;
61 		__u32		cancel_flags;
62 		__u32		open_flags;
63 		__u32		statx_flags;
64 		__u32		fadvise_advice;
65 		__u32		splice_flags;
66 		__u32		rename_flags;
67 		__u32		unlink_flags;
68 		__u32		hardlink_flags;
69 		__u32		xattr_flags;
70 		__u32		msg_ring_flags;
71 		__u32		uring_cmd_flags;
72 		__u32		waitid_flags;
73 		__u32		futex_flags;
74 		__u32		install_fd_flags;
75 		__u32		nop_flags;
76 	};
77 	__u64	user_data;	/* data to be passed back at completion time */
78 	/* pack this to avoid bogus arm OABI complaints */
79 	union {
80 		/* index into fixed buffers, if used */
81 		__u16	buf_index;
82 		/* for grouped buffer selection */
83 		__u16	buf_group;
84 	} __attribute__((packed));
85 	/* personality to use, if used */
86 	__u16	personality;
87 	union {
88 		__s32	splice_fd_in;
89 		__u32	file_index;
90 		__u32	optlen;
91 		struct {
92 			__u16	addr_len;
93 			__u16	__pad3[1];
94 		};
95 	};
96 	union {
97 		struct {
98 			__u64	addr3;
99 			__u64	__pad2[1];
100 		};
101 		struct {
102 			__u64	attr_ptr; /* pointer to attribute information */
103 			__u64	attr_type_mask; /* bit mask of attributes */
104 		};
105 		__u64	optval;
106 		/*
107 		 * If the ring is initialized with IORING_SETUP_SQE128, then
108 		 * this field is used for 80 bytes of arbitrary command data
109 		 */
110 		__u8	cmd[0];
111 	};
112 };
113 
114 /* sqe->attr_type_mask flags */
115 #define IORING_RW_ATTR_FLAG_PI	(1U << 0)
116 /* PI attribute information */
117 struct io_uring_attr_pi {
118 		__u16	flags;
119 		__u16	app_tag;
120 		__u32	len;
121 		__u64	addr;
122 		__u64	seed;
123 		__u64	rsvd;
124 };
125 
126 /*
127  * If sqe->file_index is set to this for opcodes that instantiate a new
128  * direct descriptor (like openat/openat2/accept), then io_uring will allocate
129  * an available direct descriptor instead of having the application pass one
130  * in. The picked direct descriptor will be returned in cqe->res, or -ENFILE
131  * if the space is full.
132  */
133 #define IORING_FILE_INDEX_ALLOC		(~0U)
134 
135 enum io_uring_sqe_flags_bit {
136 	IOSQE_FIXED_FILE_BIT,
137 	IOSQE_IO_DRAIN_BIT,
138 	IOSQE_IO_LINK_BIT,
139 	IOSQE_IO_HARDLINK_BIT,
140 	IOSQE_ASYNC_BIT,
141 	IOSQE_BUFFER_SELECT_BIT,
142 	IOSQE_CQE_SKIP_SUCCESS_BIT,
143 };
144 
145 /*
146  * sqe->flags
147  */
148 /* use fixed fileset */
149 #define IOSQE_FIXED_FILE	(1U << IOSQE_FIXED_FILE_BIT)
150 /* issue after inflight IO */
151 #define IOSQE_IO_DRAIN		(1U << IOSQE_IO_DRAIN_BIT)
152 /* links next sqe */
153 #define IOSQE_IO_LINK		(1U << IOSQE_IO_LINK_BIT)
154 /* like LINK, but stronger */
155 #define IOSQE_IO_HARDLINK	(1U << IOSQE_IO_HARDLINK_BIT)
156 /* always go async */
157 #define IOSQE_ASYNC		(1U << IOSQE_ASYNC_BIT)
158 /* select buffer from sqe->buf_group */
159 #define IOSQE_BUFFER_SELECT	(1U << IOSQE_BUFFER_SELECT_BIT)
160 /* don't post CQE if request succeeded */
161 #define IOSQE_CQE_SKIP_SUCCESS	(1U << IOSQE_CQE_SKIP_SUCCESS_BIT)
162 
163 /*
164  * io_uring_setup() flags
165  */
166 #define IORING_SETUP_IOPOLL	(1U << 0)	/* io_context is polled */
167 #define IORING_SETUP_SQPOLL	(1U << 1)	/* SQ poll thread */
168 #define IORING_SETUP_SQ_AFF	(1U << 2)	/* sq_thread_cpu is valid */
169 #define IORING_SETUP_CQSIZE	(1U << 3)	/* app defines CQ size */
170 #define IORING_SETUP_CLAMP	(1U << 4)	/* clamp SQ/CQ ring sizes */
171 #define IORING_SETUP_ATTACH_WQ	(1U << 5)	/* attach to existing wq */
172 #define IORING_SETUP_R_DISABLED	(1U << 6)	/* start with ring disabled */
173 #define IORING_SETUP_SUBMIT_ALL	(1U << 7)	/* continue submit on error */
174 /*
175  * Cooperative task running. When requests complete, they often require
176  * forcing the submitter to transition to the kernel to complete. If this
177  * flag is set, work will be done when the task transitions anyway, rather
178  * than force an inter-processor interrupt reschedule. This avoids interrupting
179  * a task running in userspace, and saves an IPI.
180  */
181 #define IORING_SETUP_COOP_TASKRUN	(1U << 8)
182 /*
183  * If COOP_TASKRUN is set, get notified if task work is available for
184  * running and a kernel transition would be needed to run it. This sets
185  * IORING_SQ_TASKRUN in the sq ring flags. Not valid with COOP_TASKRUN.
186  */
187 #define IORING_SETUP_TASKRUN_FLAG	(1U << 9)
188 #define IORING_SETUP_SQE128		(1U << 10) /* SQEs are 128 byte */
189 #define IORING_SETUP_CQE32		(1U << 11) /* CQEs are 32 byte */
190 /*
191  * Only one task is allowed to submit requests
192  */
193 #define IORING_SETUP_SINGLE_ISSUER	(1U << 12)
194 
195 /*
196  * Defer running task work to get events.
197  * Rather than running bits of task work whenever the task transitions
198  * try to do it just before it is needed.
199  */
200 #define IORING_SETUP_DEFER_TASKRUN	(1U << 13)
201 
202 /*
203  * Application provides the memory for the rings
204  */
205 #define IORING_SETUP_NO_MMAP		(1U << 14)
206 
207 /*
208  * Register the ring fd in itself for use with
209  * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather
210  * than an fd.
211  */
212 #define IORING_SETUP_REGISTERED_FD_ONLY	(1U << 15)
213 
214 /*
215  * Removes indirection through the SQ index array.
216  */
217 #define IORING_SETUP_NO_SQARRAY		(1U << 16)
218 
219 /* Use hybrid poll in iopoll process */
220 #define IORING_SETUP_HYBRID_IOPOLL	(1U << 17)
221 
222 enum io_uring_op {
223 	IORING_OP_NOP,
224 	IORING_OP_READV,
225 	IORING_OP_WRITEV,
226 	IORING_OP_FSYNC,
227 	IORING_OP_READ_FIXED,
228 	IORING_OP_WRITE_FIXED,
229 	IORING_OP_POLL_ADD,
230 	IORING_OP_POLL_REMOVE,
231 	IORING_OP_SYNC_FILE_RANGE,
232 	IORING_OP_SENDMSG,
233 	IORING_OP_RECVMSG,
234 	IORING_OP_TIMEOUT,
235 	IORING_OP_TIMEOUT_REMOVE,
236 	IORING_OP_ACCEPT,
237 	IORING_OP_ASYNC_CANCEL,
238 	IORING_OP_LINK_TIMEOUT,
239 	IORING_OP_CONNECT,
240 	IORING_OP_FALLOCATE,
241 	IORING_OP_OPENAT,
242 	IORING_OP_CLOSE,
243 	IORING_OP_FILES_UPDATE,
244 	IORING_OP_STATX,
245 	IORING_OP_READ,
246 	IORING_OP_WRITE,
247 	IORING_OP_FADVISE,
248 	IORING_OP_MADVISE,
249 	IORING_OP_SEND,
250 	IORING_OP_RECV,
251 	IORING_OP_OPENAT2,
252 	IORING_OP_EPOLL_CTL,
253 	IORING_OP_SPLICE,
254 	IORING_OP_PROVIDE_BUFFERS,
255 	IORING_OP_REMOVE_BUFFERS,
256 	IORING_OP_TEE,
257 	IORING_OP_SHUTDOWN,
258 	IORING_OP_RENAMEAT,
259 	IORING_OP_UNLINKAT,
260 	IORING_OP_MKDIRAT,
261 	IORING_OP_SYMLINKAT,
262 	IORING_OP_LINKAT,
263 	IORING_OP_MSG_RING,
264 	IORING_OP_FSETXATTR,
265 	IORING_OP_SETXATTR,
266 	IORING_OP_FGETXATTR,
267 	IORING_OP_GETXATTR,
268 	IORING_OP_SOCKET,
269 	IORING_OP_URING_CMD,
270 	IORING_OP_SEND_ZC,
271 	IORING_OP_SENDMSG_ZC,
272 	IORING_OP_READ_MULTISHOT,
273 	IORING_OP_WAITID,
274 	IORING_OP_FUTEX_WAIT,
275 	IORING_OP_FUTEX_WAKE,
276 	IORING_OP_FUTEX_WAITV,
277 	IORING_OP_FIXED_FD_INSTALL,
278 	IORING_OP_FTRUNCATE,
279 	IORING_OP_BIND,
280 	IORING_OP_LISTEN,
281 
282 	/* this goes last, obviously */
283 	IORING_OP_LAST,
284 };
285 
286 /*
287  * sqe->uring_cmd_flags		top 8bits aren't available for userspace
288  * IORING_URING_CMD_FIXED	use registered buffer; pass this flag
289  *				along with setting sqe->buf_index.
290  */
291 #define IORING_URING_CMD_FIXED	(1U << 0)
292 #define IORING_URING_CMD_MASK	IORING_URING_CMD_FIXED
293 
294 
295 /*
296  * sqe->fsync_flags
297  */
298 #define IORING_FSYNC_DATASYNC	(1U << 0)
299 
300 /*
301  * sqe->timeout_flags
302  */
303 #define IORING_TIMEOUT_ABS		(1U << 0)
304 #define IORING_TIMEOUT_UPDATE		(1U << 1)
305 #define IORING_TIMEOUT_BOOTTIME		(1U << 2)
306 #define IORING_TIMEOUT_REALTIME		(1U << 3)
307 #define IORING_LINK_TIMEOUT_UPDATE	(1U << 4)
308 #define IORING_TIMEOUT_ETIME_SUCCESS	(1U << 5)
309 #define IORING_TIMEOUT_MULTISHOT	(1U << 6)
310 #define IORING_TIMEOUT_CLOCK_MASK	(IORING_TIMEOUT_BOOTTIME | IORING_TIMEOUT_REALTIME)
311 #define IORING_TIMEOUT_UPDATE_MASK	(IORING_TIMEOUT_UPDATE | IORING_LINK_TIMEOUT_UPDATE)
312 /*
313  * sqe->splice_flags
314  * extends splice(2) flags
315  */
316 #define SPLICE_F_FD_IN_FIXED	(1U << 31) /* the last bit of __u32 */
317 
318 /*
319  * POLL_ADD flags. Note that since sqe->poll_events is the flag space, the
320  * command flags for POLL_ADD are stored in sqe->len.
321  *
322  * IORING_POLL_ADD_MULTI	Multishot poll. Sets IORING_CQE_F_MORE if
323  *				the poll handler will continue to report
324  *				CQEs on behalf of the same SQE.
325  *
326  * IORING_POLL_UPDATE		Update existing poll request, matching
327  *				sqe->addr as the old user_data field.
328  *
329  * IORING_POLL_LEVEL		Level triggered poll.
330  */
331 #define IORING_POLL_ADD_MULTI	(1U << 0)
332 #define IORING_POLL_UPDATE_EVENTS	(1U << 1)
333 #define IORING_POLL_UPDATE_USER_DATA	(1U << 2)
334 #define IORING_POLL_ADD_LEVEL		(1U << 3)
335 
336 /*
337  * ASYNC_CANCEL flags.
338  *
339  * IORING_ASYNC_CANCEL_ALL	Cancel all requests that match the given key
340  * IORING_ASYNC_CANCEL_FD	Key off 'fd' for cancelation rather than the
341  *				request 'user_data'
342  * IORING_ASYNC_CANCEL_ANY	Match any request
343  * IORING_ASYNC_CANCEL_FD_FIXED	'fd' passed in is a fixed descriptor
344  * IORING_ASYNC_CANCEL_USERDATA	Match on user_data, default for no other key
345  * IORING_ASYNC_CANCEL_OP	Match request based on opcode
346  */
347 #define IORING_ASYNC_CANCEL_ALL	(1U << 0)
348 #define IORING_ASYNC_CANCEL_FD	(1U << 1)
349 #define IORING_ASYNC_CANCEL_ANY	(1U << 2)
350 #define IORING_ASYNC_CANCEL_FD_FIXED	(1U << 3)
351 #define IORING_ASYNC_CANCEL_USERDATA	(1U << 4)
352 #define IORING_ASYNC_CANCEL_OP	(1U << 5)
353 
354 /*
355  * send/sendmsg and recv/recvmsg flags (sqe->ioprio)
356  *
357  * IORING_RECVSEND_POLL_FIRST	If set, instead of first attempting to send
358  *				or receive and arm poll if that yields an
359  *				-EAGAIN result, arm poll upfront and skip
360  *				the initial transfer attempt.
361  *
362  * IORING_RECV_MULTISHOT	Multishot recv. Sets IORING_CQE_F_MORE if
363  *				the handler will continue to report
364  *				CQEs on behalf of the same SQE.
365  *
366  * IORING_RECVSEND_FIXED_BUF	Use registered buffers, the index is stored in
367  *				the buf_index field.
368  *
369  * IORING_SEND_ZC_REPORT_USAGE
370  *				If set, SEND[MSG]_ZC should report
371  *				the zerocopy usage in cqe.res
372  *				for the IORING_CQE_F_NOTIF cqe.
373  *				0 is reported if zerocopy was actually possible.
374  *				IORING_NOTIF_USAGE_ZC_COPIED if data was copied
375  *				(at least partially).
376  *
377  * IORING_RECVSEND_BUNDLE	Used with IOSQE_BUFFER_SELECT. If set, send or
378  *				recv will grab as many buffers from the buffer
379  *				group ID given and send them all. The completion
380  *				result 	will be the number of buffers send, with
381  *				the starting buffer ID in cqe->flags as per
382  *				usual for provided buffer usage. The buffers
383  *				will be	contiguous from the starting buffer ID.
384  */
385 #define IORING_RECVSEND_POLL_FIRST	(1U << 0)
386 #define IORING_RECV_MULTISHOT		(1U << 1)
387 #define IORING_RECVSEND_FIXED_BUF	(1U << 2)
388 #define IORING_SEND_ZC_REPORT_USAGE	(1U << 3)
389 #define IORING_RECVSEND_BUNDLE		(1U << 4)
390 
391 /*
392  * cqe.res for IORING_CQE_F_NOTIF if
393  * IORING_SEND_ZC_REPORT_USAGE was requested
394  *
395  * It should be treated as a flag, all other
396  * bits of cqe.res should be treated as reserved!
397  */
398 #define IORING_NOTIF_USAGE_ZC_COPIED    (1U << 31)
399 
400 /*
401  * accept flags stored in sqe->ioprio
402  */
403 #define IORING_ACCEPT_MULTISHOT	(1U << 0)
404 #define IORING_ACCEPT_DONTWAIT	(1U << 1)
405 #define IORING_ACCEPT_POLL_FIRST	(1U << 2)
406 
407 /*
408  * IORING_OP_MSG_RING command types, stored in sqe->addr
409  */
410 enum io_uring_msg_ring_flags {
411 	IORING_MSG_DATA,	/* pass sqe->len as 'res' and off as user_data */
412 	IORING_MSG_SEND_FD,	/* send a registered fd to another ring */
413 };
414 
415 /*
416  * IORING_OP_MSG_RING flags (sqe->msg_ring_flags)
417  *
418  * IORING_MSG_RING_CQE_SKIP	Don't post a CQE to the target ring. Not
419  *				applicable for IORING_MSG_DATA, obviously.
420  */
421 #define IORING_MSG_RING_CQE_SKIP	(1U << 0)
422 /* Pass through the flags from sqe->file_index to cqe->flags */
423 #define IORING_MSG_RING_FLAGS_PASS	(1U << 1)
424 
425 /*
426  * IORING_OP_FIXED_FD_INSTALL flags (sqe->install_fd_flags)
427  *
428  * IORING_FIXED_FD_NO_CLOEXEC	Don't mark the fd as O_CLOEXEC
429  */
430 #define IORING_FIXED_FD_NO_CLOEXEC	(1U << 0)
431 
432 /*
433  * IORING_OP_NOP flags (sqe->nop_flags)
434  *
435  * IORING_NOP_INJECT_RESULT	Inject result from sqe->result
436  */
437 #define IORING_NOP_INJECT_RESULT	(1U << 0)
438 #define IORING_NOP_FILE			(1U << 1)
439 #define IORING_NOP_FIXED_FILE		(1U << 2)
440 #define IORING_NOP_FIXED_BUFFER		(1U << 3)
441 
442 /*
443  * IO completion data structure (Completion Queue Entry)
444  */
445 struct io_uring_cqe {
446 	__u64	user_data;	/* sqe->user_data value passed back */
447 	__s32	res;		/* result code for this event */
448 	__u32	flags;
449 
450 	/*
451 	 * If the ring is initialized with IORING_SETUP_CQE32, then this field
452 	 * contains 16-bytes of padding, doubling the size of the CQE.
453 	 */
454 	__u64 big_cqe[];
455 };
456 
457 /*
458  * cqe->flags
459  *
460  * IORING_CQE_F_BUFFER	If set, the upper 16 bits are the buffer ID
461  * IORING_CQE_F_MORE	If set, parent SQE will generate more CQE entries
462  * IORING_CQE_F_SOCK_NONEMPTY	If set, more data to read after socket recv
463  * IORING_CQE_F_NOTIF	Set for notification CQEs. Can be used to distinct
464  * 			them from sends.
465  * IORING_CQE_F_BUF_MORE If set, the buffer ID set in the completion will get
466  *			more completions. In other words, the buffer is being
467  *			partially consumed, and will be used by the kernel for
468  *			more completions. This is only set for buffers used via
469  *			the incremental buffer consumption, as provided by
470  *			a ring buffer setup with IOU_PBUF_RING_INC. For any
471  *			other provided buffer type, all completions with a
472  *			buffer passed back is automatically returned to the
473  *			application.
474  */
475 #define IORING_CQE_F_BUFFER		(1U << 0)
476 #define IORING_CQE_F_MORE		(1U << 1)
477 #define IORING_CQE_F_SOCK_NONEMPTY	(1U << 2)
478 #define IORING_CQE_F_NOTIF		(1U << 3)
479 #define IORING_CQE_F_BUF_MORE		(1U << 4)
480 
481 #define IORING_CQE_BUFFER_SHIFT		16
482 
483 /*
484  * Magic offsets for the application to mmap the data it needs
485  */
486 #define IORING_OFF_SQ_RING		0ULL
487 #define IORING_OFF_CQ_RING		0x8000000ULL
488 #define IORING_OFF_SQES			0x10000000ULL
489 #define IORING_OFF_PBUF_RING		0x80000000ULL
490 #define IORING_OFF_PBUF_SHIFT		16
491 #define IORING_OFF_MMAP_MASK		0xf8000000ULL
492 
493 /*
494  * Filled with the offset for mmap(2)
495  */
496 struct io_sqring_offsets {
497 	__u32 head;
498 	__u32 tail;
499 	__u32 ring_mask;
500 	__u32 ring_entries;
501 	__u32 flags;
502 	__u32 dropped;
503 	__u32 array;
504 	__u32 resv1;
505 	__u64 user_addr;
506 };
507 
508 /*
509  * sq_ring->flags
510  */
511 #define IORING_SQ_NEED_WAKEUP	(1U << 0) /* needs io_uring_enter wakeup */
512 #define IORING_SQ_CQ_OVERFLOW	(1U << 1) /* CQ ring is overflown */
513 #define IORING_SQ_TASKRUN	(1U << 2) /* task should enter the kernel */
514 
515 struct io_cqring_offsets {
516 	__u32 head;
517 	__u32 tail;
518 	__u32 ring_mask;
519 	__u32 ring_entries;
520 	__u32 overflow;
521 	__u32 cqes;
522 	__u32 flags;
523 	__u32 resv1;
524 	__u64 user_addr;
525 };
526 
527 /*
528  * cq_ring->flags
529  */
530 
531 /* disable eventfd notifications */
532 #define IORING_CQ_EVENTFD_DISABLED	(1U << 0)
533 
534 /*
535  * io_uring_enter(2) flags
536  */
537 #define IORING_ENTER_GETEVENTS		(1U << 0)
538 #define IORING_ENTER_SQ_WAKEUP		(1U << 1)
539 #define IORING_ENTER_SQ_WAIT		(1U << 2)
540 #define IORING_ENTER_EXT_ARG		(1U << 3)
541 #define IORING_ENTER_REGISTERED_RING	(1U << 4)
542 #define IORING_ENTER_ABS_TIMER		(1U << 5)
543 #define IORING_ENTER_EXT_ARG_REG	(1U << 6)
544 
545 /*
546  * Passed in for io_uring_setup(2). Copied back with updated info on success
547  */
548 struct io_uring_params {
549 	__u32 sq_entries;
550 	__u32 cq_entries;
551 	__u32 flags;
552 	__u32 sq_thread_cpu;
553 	__u32 sq_thread_idle;
554 	__u32 features;
555 	__u32 wq_fd;
556 	__u32 resv[3];
557 	struct io_sqring_offsets sq_off;
558 	struct io_cqring_offsets cq_off;
559 };
560 
561 /*
562  * io_uring_params->features flags
563  */
564 #define IORING_FEAT_SINGLE_MMAP		(1U << 0)
565 #define IORING_FEAT_NODROP		(1U << 1)
566 #define IORING_FEAT_SUBMIT_STABLE	(1U << 2)
567 #define IORING_FEAT_RW_CUR_POS		(1U << 3)
568 #define IORING_FEAT_CUR_PERSONALITY	(1U << 4)
569 #define IORING_FEAT_FAST_POLL		(1U << 5)
570 #define IORING_FEAT_POLL_32BITS 	(1U << 6)
571 #define IORING_FEAT_SQPOLL_NONFIXED	(1U << 7)
572 #define IORING_FEAT_EXT_ARG		(1U << 8)
573 #define IORING_FEAT_NATIVE_WORKERS	(1U << 9)
574 #define IORING_FEAT_RSRC_TAGS		(1U << 10)
575 #define IORING_FEAT_CQE_SKIP		(1U << 11)
576 #define IORING_FEAT_LINKED_FILE		(1U << 12)
577 #define IORING_FEAT_REG_REG_RING	(1U << 13)
578 #define IORING_FEAT_RECVSEND_BUNDLE	(1U << 14)
579 #define IORING_FEAT_MIN_TIMEOUT		(1U << 15)
580 #define IORING_FEAT_RW_ATTR		(1U << 16)
581 
582 /*
583  * io_uring_register(2) opcodes and arguments
584  */
585 enum io_uring_register_op {
586 	IORING_REGISTER_BUFFERS			= 0,
587 	IORING_UNREGISTER_BUFFERS		= 1,
588 	IORING_REGISTER_FILES			= 2,
589 	IORING_UNREGISTER_FILES			= 3,
590 	IORING_REGISTER_EVENTFD			= 4,
591 	IORING_UNREGISTER_EVENTFD		= 5,
592 	IORING_REGISTER_FILES_UPDATE		= 6,
593 	IORING_REGISTER_EVENTFD_ASYNC		= 7,
594 	IORING_REGISTER_PROBE			= 8,
595 	IORING_REGISTER_PERSONALITY		= 9,
596 	IORING_UNREGISTER_PERSONALITY		= 10,
597 	IORING_REGISTER_RESTRICTIONS		= 11,
598 	IORING_REGISTER_ENABLE_RINGS		= 12,
599 
600 	/* extended with tagging */
601 	IORING_REGISTER_FILES2			= 13,
602 	IORING_REGISTER_FILES_UPDATE2		= 14,
603 	IORING_REGISTER_BUFFERS2		= 15,
604 	IORING_REGISTER_BUFFERS_UPDATE		= 16,
605 
606 	/* set/clear io-wq thread affinities */
607 	IORING_REGISTER_IOWQ_AFF		= 17,
608 	IORING_UNREGISTER_IOWQ_AFF		= 18,
609 
610 	/* set/get max number of io-wq workers */
611 	IORING_REGISTER_IOWQ_MAX_WORKERS	= 19,
612 
613 	/* register/unregister io_uring fd with the ring */
614 	IORING_REGISTER_RING_FDS		= 20,
615 	IORING_UNREGISTER_RING_FDS		= 21,
616 
617 	/* register ring based provide buffer group */
618 	IORING_REGISTER_PBUF_RING		= 22,
619 	IORING_UNREGISTER_PBUF_RING		= 23,
620 
621 	/* sync cancelation API */
622 	IORING_REGISTER_SYNC_CANCEL		= 24,
623 
624 	/* register a range of fixed file slots for automatic slot allocation */
625 	IORING_REGISTER_FILE_ALLOC_RANGE	= 25,
626 
627 	/* return status information for a buffer group */
628 	IORING_REGISTER_PBUF_STATUS		= 26,
629 
630 	/* set/clear busy poll settings */
631 	IORING_REGISTER_NAPI			= 27,
632 	IORING_UNREGISTER_NAPI			= 28,
633 
634 	IORING_REGISTER_CLOCK			= 29,
635 
636 	/* clone registered buffers from source ring to current ring */
637 	IORING_REGISTER_CLONE_BUFFERS		= 30,
638 
639 	/* send MSG_RING without having a ring */
640 	IORING_REGISTER_SEND_MSG_RING		= 31,
641 
642 	/* 32 reserved for zc rx */
643 
644 	/* resize CQ ring */
645 	IORING_REGISTER_RESIZE_RINGS		= 33,
646 
647 	IORING_REGISTER_MEM_REGION		= 34,
648 
649 	/* this goes last */
650 	IORING_REGISTER_LAST,
651 
652 	/* flag added to the opcode to use a registered ring fd */
653 	IORING_REGISTER_USE_REGISTERED_RING	= 1U << 31
654 };
655 
656 /* io-wq worker categories */
657 enum io_wq_type {
658 	IO_WQ_BOUND,
659 	IO_WQ_UNBOUND,
660 };
661 
662 /* deprecated, see struct io_uring_rsrc_update */
663 struct io_uring_files_update {
664 	__u32 offset;
665 	__u32 resv;
666 	__aligned_u64 /* __s32 * */ fds;
667 };
668 
669 enum {
670 	/* initialise with user provided memory pointed by user_addr */
671 	IORING_MEM_REGION_TYPE_USER		= 1,
672 };
673 
674 struct io_uring_region_desc {
675 	__u64 user_addr;
676 	__u64 size;
677 	__u32 flags;
678 	__u32 id;
679 	__u64 mmap_offset;
680 	__u64 __resv[4];
681 };
682 
683 enum {
684 	/* expose the region as registered wait arguments */
685 	IORING_MEM_REGION_REG_WAIT_ARG		= 1,
686 };
687 
688 struct io_uring_mem_region_reg {
689 	__u64 region_uptr; /* struct io_uring_region_desc * */
690 	__u64 flags;
691 	__u64 __resv[2];
692 };
693 
694 /*
695  * Register a fully sparse file space, rather than pass in an array of all
696  * -1 file descriptors.
697  */
698 #define IORING_RSRC_REGISTER_SPARSE	(1U << 0)
699 
700 struct io_uring_rsrc_register {
701 	__u32 nr;
702 	__u32 flags;
703 	__u64 resv2;
704 	__aligned_u64 data;
705 	__aligned_u64 tags;
706 };
707 
708 struct io_uring_rsrc_update {
709 	__u32 offset;
710 	__u32 resv;
711 	__aligned_u64 data;
712 };
713 
714 struct io_uring_rsrc_update2 {
715 	__u32 offset;
716 	__u32 resv;
717 	__aligned_u64 data;
718 	__aligned_u64 tags;
719 	__u32 nr;
720 	__u32 resv2;
721 };
722 
723 /* Skip updating fd indexes set to this value in the fd table */
724 #define IORING_REGISTER_FILES_SKIP	(-2)
725 
726 #define IO_URING_OP_SUPPORTED	(1U << 0)
727 
728 struct io_uring_probe_op {
729 	__u8 op;
730 	__u8 resv;
731 	__u16 flags;	/* IO_URING_OP_* flags */
732 	__u32 resv2;
733 };
734 
735 struct io_uring_probe {
736 	__u8 last_op;	/* last opcode supported */
737 	__u8 ops_len;	/* length of ops[] array below */
738 	__u16 resv;
739 	__u32 resv2[3];
740 	struct io_uring_probe_op ops[];
741 };
742 
743 struct io_uring_restriction {
744 	__u16 opcode;
745 	union {
746 		__u8 register_op; /* IORING_RESTRICTION_REGISTER_OP */
747 		__u8 sqe_op;      /* IORING_RESTRICTION_SQE_OP */
748 		__u8 sqe_flags;   /* IORING_RESTRICTION_SQE_FLAGS_* */
749 	};
750 	__u8 resv;
751 	__u32 resv2[3];
752 };
753 
754 struct io_uring_clock_register {
755 	__u32	clockid;
756 	__u32	__resv[3];
757 };
758 
759 enum {
760 	IORING_REGISTER_SRC_REGISTERED	= (1U << 0),
761 	IORING_REGISTER_DST_REPLACE	= (1U << 1),
762 };
763 
764 struct io_uring_clone_buffers {
765 	__u32	src_fd;
766 	__u32	flags;
767 	__u32	src_off;
768 	__u32	dst_off;
769 	__u32	nr;
770 	__u32	pad[3];
771 };
772 
773 struct io_uring_buf {
774 	__u64	addr;
775 	__u32	len;
776 	__u16	bid;
777 	__u16	resv;
778 };
779 
780 struct io_uring_buf_ring {
781 	union {
782 		/*
783 		 * To avoid spilling into more pages than we need to, the
784 		 * ring tail is overlaid with the io_uring_buf->resv field.
785 		 */
786 		struct {
787 			__u64	resv1;
788 			__u32	resv2;
789 			__u16	resv3;
790 			__u16	tail;
791 		};
792 		__DECLARE_FLEX_ARRAY(struct io_uring_buf, bufs);
793 	};
794 };
795 
796 /*
797  * Flags for IORING_REGISTER_PBUF_RING.
798  *
799  * IOU_PBUF_RING_MMAP:	If set, kernel will allocate the memory for the ring.
800  *			The application must not set a ring_addr in struct
801  *			io_uring_buf_reg, instead it must subsequently call
802  *			mmap(2) with the offset set as:
803  *			IORING_OFF_PBUF_RING | (bgid << IORING_OFF_PBUF_SHIFT)
804  *			to get a virtual mapping for the ring.
805  * IOU_PBUF_RING_INC:	If set, buffers consumed from this buffer ring can be
806  *			consumed incrementally. Normally one (or more) buffers
807  *			are fully consumed. With incremental consumptions, it's
808  *			feasible to register big ranges of buffers, and each
809  *			use of it will consume only as much as it needs. This
810  *			requires that both the kernel and application keep
811  *			track of where the current read/recv index is at.
812  */
813 enum io_uring_register_pbuf_ring_flags {
814 	IOU_PBUF_RING_MMAP	= 1,
815 	IOU_PBUF_RING_INC	= 2,
816 };
817 
818 /* argument for IORING_(UN)REGISTER_PBUF_RING */
819 struct io_uring_buf_reg {
820 	__u64	ring_addr;
821 	__u32	ring_entries;
822 	__u16	bgid;
823 	__u16	flags;
824 	__u64	resv[3];
825 };
826 
827 /* argument for IORING_REGISTER_PBUF_STATUS */
828 struct io_uring_buf_status {
829 	__u32	buf_group;	/* input */
830 	__u32	head;		/* output */
831 	__u32	resv[8];
832 };
833 
834 enum io_uring_napi_op {
835 	/* register/ungister backward compatible opcode */
836 	IO_URING_NAPI_REGISTER_OP = 0,
837 
838 	/* opcodes to update napi_list when static tracking is used */
839 	IO_URING_NAPI_STATIC_ADD_ID = 1,
840 	IO_URING_NAPI_STATIC_DEL_ID = 2
841 };
842 
843 enum io_uring_napi_tracking_strategy {
844 	/* value must be 0 for backward compatibility */
845 	IO_URING_NAPI_TRACKING_DYNAMIC = 0,
846 	IO_URING_NAPI_TRACKING_STATIC = 1,
847 	IO_URING_NAPI_TRACKING_INACTIVE = 255
848 };
849 
850 /* argument for IORING_(UN)REGISTER_NAPI */
851 struct io_uring_napi {
852 	__u32	busy_poll_to;
853 	__u8	prefer_busy_poll;
854 
855 	/* a io_uring_napi_op value */
856 	__u8	opcode;
857 	__u8	pad[2];
858 
859 	/*
860 	 * for IO_URING_NAPI_REGISTER_OP, it is a
861 	 * io_uring_napi_tracking_strategy value.
862 	 *
863 	 * for IO_URING_NAPI_STATIC_ADD_ID/IO_URING_NAPI_STATIC_DEL_ID
864 	 * it is the napi id to add/del from napi_list.
865 	 */
866 	__u32	op_param;
867 	__u32	resv;
868 };
869 
870 /*
871  * io_uring_restriction->opcode values
872  */
873 enum io_uring_register_restriction_op {
874 	/* Allow an io_uring_register(2) opcode */
875 	IORING_RESTRICTION_REGISTER_OP		= 0,
876 
877 	/* Allow an sqe opcode */
878 	IORING_RESTRICTION_SQE_OP		= 1,
879 
880 	/* Allow sqe flags */
881 	IORING_RESTRICTION_SQE_FLAGS_ALLOWED	= 2,
882 
883 	/* Require sqe flags (these flags must be set on each submission) */
884 	IORING_RESTRICTION_SQE_FLAGS_REQUIRED	= 3,
885 
886 	IORING_RESTRICTION_LAST
887 };
888 
889 enum {
890 	IORING_REG_WAIT_TS		= (1U << 0),
891 };
892 
893 /*
894  * Argument for io_uring_enter(2) with
895  * IORING_GETEVENTS | IORING_ENTER_EXT_ARG_REG set, where the actual argument
896  * is an index into a previously registered fixed wait region described by
897  * the below structure.
898  */
899 struct io_uring_reg_wait {
900 	struct __kernel_timespec	ts;
901 	__u32				min_wait_usec;
902 	__u32				flags;
903 	__u64				sigmask;
904 	__u32				sigmask_sz;
905 	__u32				pad[3];
906 	__u64				pad2[2];
907 };
908 
909 /*
910  * Argument for io_uring_enter(2) with IORING_GETEVENTS | IORING_ENTER_EXT_ARG
911  */
912 struct io_uring_getevents_arg {
913 	__u64	sigmask;
914 	__u32	sigmask_sz;
915 	__u32	min_wait_usec;
916 	__u64	ts;
917 };
918 
919 /*
920  * Argument for IORING_REGISTER_SYNC_CANCEL
921  */
922 struct io_uring_sync_cancel_reg {
923 	__u64				addr;
924 	__s32				fd;
925 	__u32				flags;
926 	struct __kernel_timespec	timeout;
927 	__u8				opcode;
928 	__u8				pad[7];
929 	__u64				pad2[3];
930 };
931 
932 /*
933  * Argument for IORING_REGISTER_FILE_ALLOC_RANGE
934  * The range is specified as [off, off + len)
935  */
936 struct io_uring_file_index_range {
937 	__u32	off;
938 	__u32	len;
939 	__u64	resv;
940 };
941 
942 struct io_uring_recvmsg_out {
943 	__u32 namelen;
944 	__u32 controllen;
945 	__u32 payloadlen;
946 	__u32 flags;
947 };
948 
949 /*
950  * Argument for IORING_OP_URING_CMD when file is a socket
951  */
952 enum io_uring_socket_op {
953 	SOCKET_URING_OP_SIOCINQ		= 0,
954 	SOCKET_URING_OP_SIOCOUTQ,
955 	SOCKET_URING_OP_GETSOCKOPT,
956 	SOCKET_URING_OP_SETSOCKOPT,
957 };
958 
959 #ifdef __cplusplus
960 }
961 #endif
962 
963 #endif
964