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 	};
47 	__u32	len;		/* buffer size or number of iovecs */
48 	union {
49 		__kernel_rwf_t	rw_flags;
50 		__u32		fsync_flags;
51 		__u16		poll_events;	/* compatibility */
52 		__u32		poll32_events;	/* word-reversed for BE */
53 		__u32		sync_range_flags;
54 		__u32		msg_flags;
55 		__u32		timeout_flags;
56 		__u32		accept_flags;
57 		__u32		cancel_flags;
58 		__u32		open_flags;
59 		__u32		statx_flags;
60 		__u32		fadvise_advice;
61 		__u32		splice_flags;
62 		__u32		rename_flags;
63 		__u32		unlink_flags;
64 		__u32		hardlink_flags;
65 		__u32		xattr_flags;
66 		__u32		msg_ring_flags;
67 		__u32		uring_cmd_flags;
68 	};
69 	__u64	user_data;	/* data to be passed back at completion time */
70 	/* pack this to avoid bogus arm OABI complaints */
71 	union {
72 		/* index into fixed buffers, if used */
73 		__u16	buf_index;
74 		/* for grouped buffer selection */
75 		__u16	buf_group;
76 	} __attribute__((packed));
77 	/* personality to use, if used */
78 	__u16	personality;
79 	union {
80 		__s32	splice_fd_in;
81 		__u32	file_index;
82 		struct {
83 			__u16	addr_len;
84 			__u16	__pad3[1];
85 		};
86 	};
87 	union {
88 		struct {
89 			__u64	addr3;
90 			__u64	__pad2[1];
91 		};
92 		/*
93 		 * If the ring is initialized with IORING_SETUP_SQE128, then
94 		 * this field is used for 80 bytes of arbitrary command data
95 		 */
96 		__u8	cmd[0];
97 	};
98 };
99 
100 /*
101  * If sqe->file_index is set to this for opcodes that instantiate a new
102  * direct descriptor (like openat/openat2/accept), then io_uring will allocate
103  * an available direct descriptor instead of having the application pass one
104  * in. The picked direct descriptor will be returned in cqe->res, or -ENFILE
105  * if the space is full.
106  */
107 #define IORING_FILE_INDEX_ALLOC		(~0U)
108 
109 enum {
110 	IOSQE_FIXED_FILE_BIT,
111 	IOSQE_IO_DRAIN_BIT,
112 	IOSQE_IO_LINK_BIT,
113 	IOSQE_IO_HARDLINK_BIT,
114 	IOSQE_ASYNC_BIT,
115 	IOSQE_BUFFER_SELECT_BIT,
116 	IOSQE_CQE_SKIP_SUCCESS_BIT,
117 };
118 
119 /*
120  * sqe->flags
121  */
122 /* use fixed fileset */
123 #define IOSQE_FIXED_FILE	(1U << IOSQE_FIXED_FILE_BIT)
124 /* issue after inflight IO */
125 #define IOSQE_IO_DRAIN		(1U << IOSQE_IO_DRAIN_BIT)
126 /* links next sqe */
127 #define IOSQE_IO_LINK		(1U << IOSQE_IO_LINK_BIT)
128 /* like LINK, but stronger */
129 #define IOSQE_IO_HARDLINK	(1U << IOSQE_IO_HARDLINK_BIT)
130 /* always go async */
131 #define IOSQE_ASYNC		(1U << IOSQE_ASYNC_BIT)
132 /* select buffer from sqe->buf_group */
133 #define IOSQE_BUFFER_SELECT	(1U << IOSQE_BUFFER_SELECT_BIT)
134 /* don't post CQE if request succeeded */
135 #define IOSQE_CQE_SKIP_SUCCESS	(1U << IOSQE_CQE_SKIP_SUCCESS_BIT)
136 
137 /*
138  * io_uring_setup() flags
139  */
140 #define IORING_SETUP_IOPOLL	(1U << 0)	/* io_context is polled */
141 #define IORING_SETUP_SQPOLL	(1U << 1)	/* SQ poll thread */
142 #define IORING_SETUP_SQ_AFF	(1U << 2)	/* sq_thread_cpu is valid */
143 #define IORING_SETUP_CQSIZE	(1U << 3)	/* app defines CQ size */
144 #define IORING_SETUP_CLAMP	(1U << 4)	/* clamp SQ/CQ ring sizes */
145 #define IORING_SETUP_ATTACH_WQ	(1U << 5)	/* attach to existing wq */
146 #define IORING_SETUP_R_DISABLED	(1U << 6)	/* start with ring disabled */
147 #define IORING_SETUP_SUBMIT_ALL	(1U << 7)	/* continue submit on error */
148 /*
149  * Cooperative task running. When requests complete, they often require
150  * forcing the submitter to transition to the kernel to complete. If this
151  * flag is set, work will be done when the task transitions anyway, rather
152  * than force an inter-processor interrupt reschedule. This avoids interrupting
153  * a task running in userspace, and saves an IPI.
154  */
155 #define IORING_SETUP_COOP_TASKRUN	(1U << 8)
156 /*
157  * If COOP_TASKRUN is set, get notified if task work is available for
158  * running and a kernel transition would be needed to run it. This sets
159  * IORING_SQ_TASKRUN in the sq ring flags. Not valid with COOP_TASKRUN.
160  */
161 #define IORING_SETUP_TASKRUN_FLAG	(1U << 9)
162 #define IORING_SETUP_SQE128		(1U << 10) /* SQEs are 128 byte */
163 #define IORING_SETUP_CQE32		(1U << 11) /* CQEs are 32 byte */
164 /*
165  * Only one task is allowed to submit requests
166  */
167 #define IORING_SETUP_SINGLE_ISSUER	(1U << 12)
168 
169 /*
170  * Defer running task work to get events.
171  * Rather than running bits of task work whenever the task transitions
172  * try to do it just before it is needed.
173  */
174 #define IORING_SETUP_DEFER_TASKRUN	(1U << 13)
175 
176 /*
177  * Application provides the memory for the rings
178  */
179 #define IORING_SETUP_NO_MMAP		(1U << 14)
180 
181 /*
182  * Register the ring fd in itself for use with
183  * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather
184  * than an fd.
185  */
186 #define IORING_SETUP_REGISTERED_FD_ONLY	(1U << 15)
187 
188 /*
189  * Removes indirection through the SQ index array.
190  */
191 #define IORING_SETUP_NO_SQARRAY		(1U << 16)
192 
193 enum io_uring_op {
194 	IORING_OP_NOP,
195 	IORING_OP_READV,
196 	IORING_OP_WRITEV,
197 	IORING_OP_FSYNC,
198 	IORING_OP_READ_FIXED,
199 	IORING_OP_WRITE_FIXED,
200 	IORING_OP_POLL_ADD,
201 	IORING_OP_POLL_REMOVE,
202 	IORING_OP_SYNC_FILE_RANGE,
203 	IORING_OP_SENDMSG,
204 	IORING_OP_RECVMSG,
205 	IORING_OP_TIMEOUT,
206 	IORING_OP_TIMEOUT_REMOVE,
207 	IORING_OP_ACCEPT,
208 	IORING_OP_ASYNC_CANCEL,
209 	IORING_OP_LINK_TIMEOUT,
210 	IORING_OP_CONNECT,
211 	IORING_OP_FALLOCATE,
212 	IORING_OP_OPENAT,
213 	IORING_OP_CLOSE,
214 	IORING_OP_FILES_UPDATE,
215 	IORING_OP_STATX,
216 	IORING_OP_READ,
217 	IORING_OP_WRITE,
218 	IORING_OP_FADVISE,
219 	IORING_OP_MADVISE,
220 	IORING_OP_SEND,
221 	IORING_OP_RECV,
222 	IORING_OP_OPENAT2,
223 	IORING_OP_EPOLL_CTL,
224 	IORING_OP_SPLICE,
225 	IORING_OP_PROVIDE_BUFFERS,
226 	IORING_OP_REMOVE_BUFFERS,
227 	IORING_OP_TEE,
228 	IORING_OP_SHUTDOWN,
229 	IORING_OP_RENAMEAT,
230 	IORING_OP_UNLINKAT,
231 	IORING_OP_MKDIRAT,
232 	IORING_OP_SYMLINKAT,
233 	IORING_OP_LINKAT,
234 	IORING_OP_MSG_RING,
235 	IORING_OP_FSETXATTR,
236 	IORING_OP_SETXATTR,
237 	IORING_OP_FGETXATTR,
238 	IORING_OP_GETXATTR,
239 	IORING_OP_SOCKET,
240 	IORING_OP_URING_CMD,
241 	IORING_OP_SEND_ZC,
242 	IORING_OP_SENDMSG_ZC,
243 
244 	/* this goes last, obviously */
245 	IORING_OP_LAST,
246 };
247 
248 /*
249  * sqe->uring_cmd_flags
250  * IORING_URING_CMD_FIXED	use registered buffer; pass this flag
251  *				along with setting sqe->buf_index.
252  * IORING_URING_CMD_POLLED	driver use only
253  */
254 #define IORING_URING_CMD_FIXED	(1U << 0)
255 #define IORING_URING_CMD_POLLED	(1U << 31)
256 
257 
258 /*
259  * sqe->fsync_flags
260  */
261 #define IORING_FSYNC_DATASYNC	(1U << 0)
262 
263 /*
264  * sqe->timeout_flags
265  */
266 #define IORING_TIMEOUT_ABS		(1U << 0)
267 #define IORING_TIMEOUT_UPDATE		(1U << 1)
268 #define IORING_TIMEOUT_BOOTTIME		(1U << 2)
269 #define IORING_TIMEOUT_REALTIME		(1U << 3)
270 #define IORING_LINK_TIMEOUT_UPDATE	(1U << 4)
271 #define IORING_TIMEOUT_ETIME_SUCCESS	(1U << 5)
272 #define IORING_TIMEOUT_MULTISHOT	(1U << 6)
273 #define IORING_TIMEOUT_CLOCK_MASK	(IORING_TIMEOUT_BOOTTIME | IORING_TIMEOUT_REALTIME)
274 #define IORING_TIMEOUT_UPDATE_MASK	(IORING_TIMEOUT_UPDATE | IORING_LINK_TIMEOUT_UPDATE)
275 /*
276  * sqe->splice_flags
277  * extends splice(2) flags
278  */
279 #define SPLICE_F_FD_IN_FIXED	(1U << 31) /* the last bit of __u32 */
280 
281 /*
282  * POLL_ADD flags. Note that since sqe->poll_events is the flag space, the
283  * command flags for POLL_ADD are stored in sqe->len.
284  *
285  * IORING_POLL_ADD_MULTI	Multishot poll. Sets IORING_CQE_F_MORE if
286  *				the poll handler will continue to report
287  *				CQEs on behalf of the same SQE.
288  *
289  * IORING_POLL_UPDATE		Update existing poll request, matching
290  *				sqe->addr as the old user_data field.
291  *
292  * IORING_POLL_LEVEL		Level triggered poll.
293  */
294 #define IORING_POLL_ADD_MULTI	(1U << 0)
295 #define IORING_POLL_UPDATE_EVENTS	(1U << 1)
296 #define IORING_POLL_UPDATE_USER_DATA	(1U << 2)
297 #define IORING_POLL_ADD_LEVEL		(1U << 3)
298 
299 /*
300  * ASYNC_CANCEL flags.
301  *
302  * IORING_ASYNC_CANCEL_ALL	Cancel all requests that match the given key
303  * IORING_ASYNC_CANCEL_FD	Key off 'fd' for cancelation rather than the
304  *				request 'user_data'
305  * IORING_ASYNC_CANCEL_ANY	Match any request
306  * IORING_ASYNC_CANCEL_FD_FIXED	'fd' passed in is a fixed descriptor
307  * IORING_ASYNC_CANCEL_USERDATA	Match on user_data, default for no other key
308  * IORING_ASYNC_CANCEL_OP	Match request based on opcode
309  */
310 #define IORING_ASYNC_CANCEL_ALL	(1U << 0)
311 #define IORING_ASYNC_CANCEL_FD	(1U << 1)
312 #define IORING_ASYNC_CANCEL_ANY	(1U << 2)
313 #define IORING_ASYNC_CANCEL_FD_FIXED	(1U << 3)
314 #define IORING_ASYNC_CANCEL_USERDATA	(1U << 4)
315 #define IORING_ASYNC_CANCEL_OP	(1U << 5)
316 
317 /*
318  * send/sendmsg and recv/recvmsg flags (sqe->ioprio)
319  *
320  * IORING_RECVSEND_POLL_FIRST	If set, instead of first attempting to send
321  *				or receive and arm poll if that yields an
322  *				-EAGAIN result, arm poll upfront and skip
323  *				the initial transfer attempt.
324  *
325  * IORING_RECV_MULTISHOT	Multishot recv. Sets IORING_CQE_F_MORE if
326  *				the handler will continue to report
327  *				CQEs on behalf of the same SQE.
328  *
329  * IORING_RECVSEND_FIXED_BUF	Use registered buffers, the index is stored in
330  *				the buf_index field.
331  *
332  * IORING_SEND_ZC_REPORT_USAGE
333  *				If set, SEND[MSG]_ZC should report
334  *				the zerocopy usage in cqe.res
335  *				for the IORING_CQE_F_NOTIF cqe.
336  *				0 is reported if zerocopy was actually possible.
337  *				IORING_NOTIF_USAGE_ZC_COPIED if data was copied
338  *				(at least partially).
339  */
340 #define IORING_RECVSEND_POLL_FIRST	(1U << 0)
341 #define IORING_RECV_MULTISHOT		(1U << 1)
342 #define IORING_RECVSEND_FIXED_BUF	(1U << 2)
343 #define IORING_SEND_ZC_REPORT_USAGE	(1U << 3)
344 
345 /*
346  * cqe.res for IORING_CQE_F_NOTIF if
347  * IORING_SEND_ZC_REPORT_USAGE was requested
348  *
349  * It should be treated as a flag, all other
350  * bits of cqe.res should be treated as reserved!
351  */
352 #define IORING_NOTIF_USAGE_ZC_COPIED    (1U << 31)
353 
354 /*
355  * accept flags stored in sqe->ioprio
356  */
357 #define IORING_ACCEPT_MULTISHOT	(1U << 0)
358 
359 /*
360  * IORING_OP_MSG_RING command types, stored in sqe->addr
361  */
362 enum {
363 	IORING_MSG_DATA,	/* pass sqe->len as 'res' and off as user_data */
364 	IORING_MSG_SEND_FD,	/* send a registered fd to another ring */
365 };
366 
367 /*
368  * IORING_OP_MSG_RING flags (sqe->msg_ring_flags)
369  *
370  * IORING_MSG_RING_CQE_SKIP	Don't post a CQE to the target ring. Not
371  *				applicable for IORING_MSG_DATA, obviously.
372  */
373 #define IORING_MSG_RING_CQE_SKIP	(1U << 0)
374 /* Pass through the flags from sqe->file_index to cqe->flags */
375 #define IORING_MSG_RING_FLAGS_PASS	(1U << 1)
376 
377 /*
378  * IO completion data structure (Completion Queue Entry)
379  */
380 struct io_uring_cqe {
381 	__u64	user_data;	/* sqe->data submission passed back */
382 	__s32	res;		/* result code for this event */
383 	__u32	flags;
384 
385 	/*
386 	 * If the ring is initialized with IORING_SETUP_CQE32, then this field
387 	 * contains 16-bytes of padding, doubling the size of the CQE.
388 	 */
389 	__u64 big_cqe[];
390 };
391 
392 /*
393  * cqe->flags
394  *
395  * IORING_CQE_F_BUFFER	If set, the upper 16 bits are the buffer ID
396  * IORING_CQE_F_MORE	If set, parent SQE will generate more CQE entries
397  * IORING_CQE_F_SOCK_NONEMPTY	If set, more data to read after socket recv
398  * IORING_CQE_F_NOTIF	Set for notification CQEs. Can be used to distinct
399  * 			them from sends.
400  */
401 #define IORING_CQE_F_BUFFER		(1U << 0)
402 #define IORING_CQE_F_MORE		(1U << 1)
403 #define IORING_CQE_F_SOCK_NONEMPTY	(1U << 2)
404 #define IORING_CQE_F_NOTIF		(1U << 3)
405 
406 enum {
407 	IORING_CQE_BUFFER_SHIFT		= 16,
408 };
409 
410 /*
411  * Magic offsets for the application to mmap the data it needs
412  */
413 #define IORING_OFF_SQ_RING		0ULL
414 #define IORING_OFF_CQ_RING		0x8000000ULL
415 #define IORING_OFF_SQES			0x10000000ULL
416 #define IORING_OFF_PBUF_RING		0x80000000ULL
417 #define IORING_OFF_PBUF_SHIFT		16
418 #define IORING_OFF_MMAP_MASK		0xf8000000ULL
419 
420 /*
421  * Filled with the offset for mmap(2)
422  */
423 struct io_sqring_offsets {
424 	__u32 head;
425 	__u32 tail;
426 	__u32 ring_mask;
427 	__u32 ring_entries;
428 	__u32 flags;
429 	__u32 dropped;
430 	__u32 array;
431 	__u32 resv1;
432 	__u64 user_addr;
433 };
434 
435 /*
436  * sq_ring->flags
437  */
438 #define IORING_SQ_NEED_WAKEUP	(1U << 0) /* needs io_uring_enter wakeup */
439 #define IORING_SQ_CQ_OVERFLOW	(1U << 1) /* CQ ring is overflown */
440 #define IORING_SQ_TASKRUN	(1U << 2) /* task should enter the kernel */
441 
442 struct io_cqring_offsets {
443 	__u32 head;
444 	__u32 tail;
445 	__u32 ring_mask;
446 	__u32 ring_entries;
447 	__u32 overflow;
448 	__u32 cqes;
449 	__u32 flags;
450 	__u32 resv1;
451 	__u64 user_addr;
452 };
453 
454 /*
455  * cq_ring->flags
456  */
457 
458 /* disable eventfd notifications */
459 #define IORING_CQ_EVENTFD_DISABLED	(1U << 0)
460 
461 /*
462  * io_uring_enter(2) flags
463  */
464 #define IORING_ENTER_GETEVENTS		(1U << 0)
465 #define IORING_ENTER_SQ_WAKEUP		(1U << 1)
466 #define IORING_ENTER_SQ_WAIT		(1U << 2)
467 #define IORING_ENTER_EXT_ARG		(1U << 3)
468 #define IORING_ENTER_REGISTERED_RING	(1U << 4)
469 
470 /*
471  * Passed in for io_uring_setup(2). Copied back with updated info on success
472  */
473 struct io_uring_params {
474 	__u32 sq_entries;
475 	__u32 cq_entries;
476 	__u32 flags;
477 	__u32 sq_thread_cpu;
478 	__u32 sq_thread_idle;
479 	__u32 features;
480 	__u32 wq_fd;
481 	__u32 resv[3];
482 	struct io_sqring_offsets sq_off;
483 	struct io_cqring_offsets cq_off;
484 };
485 
486 /*
487  * io_uring_params->features flags
488  */
489 #define IORING_FEAT_SINGLE_MMAP		(1U << 0)
490 #define IORING_FEAT_NODROP		(1U << 1)
491 #define IORING_FEAT_SUBMIT_STABLE	(1U << 2)
492 #define IORING_FEAT_RW_CUR_POS		(1U << 3)
493 #define IORING_FEAT_CUR_PERSONALITY	(1U << 4)
494 #define IORING_FEAT_FAST_POLL		(1U << 5)
495 #define IORING_FEAT_POLL_32BITS 	(1U << 6)
496 #define IORING_FEAT_SQPOLL_NONFIXED	(1U << 7)
497 #define IORING_FEAT_EXT_ARG		(1U << 8)
498 #define IORING_FEAT_NATIVE_WORKERS	(1U << 9)
499 #define IORING_FEAT_RSRC_TAGS		(1U << 10)
500 #define IORING_FEAT_CQE_SKIP		(1U << 11)
501 #define IORING_FEAT_LINKED_FILE		(1U << 12)
502 #define IORING_FEAT_REG_REG_RING	(1U << 13)
503 
504 /*
505  * io_uring_register(2) opcodes and arguments
506  */
507 enum {
508 	IORING_REGISTER_BUFFERS			= 0,
509 	IORING_UNREGISTER_BUFFERS		= 1,
510 	IORING_REGISTER_FILES			= 2,
511 	IORING_UNREGISTER_FILES			= 3,
512 	IORING_REGISTER_EVENTFD			= 4,
513 	IORING_UNREGISTER_EVENTFD		= 5,
514 	IORING_REGISTER_FILES_UPDATE		= 6,
515 	IORING_REGISTER_EVENTFD_ASYNC		= 7,
516 	IORING_REGISTER_PROBE			= 8,
517 	IORING_REGISTER_PERSONALITY		= 9,
518 	IORING_UNREGISTER_PERSONALITY		= 10,
519 	IORING_REGISTER_RESTRICTIONS		= 11,
520 	IORING_REGISTER_ENABLE_RINGS		= 12,
521 
522 	/* extended with tagging */
523 	IORING_REGISTER_FILES2			= 13,
524 	IORING_REGISTER_FILES_UPDATE2		= 14,
525 	IORING_REGISTER_BUFFERS2		= 15,
526 	IORING_REGISTER_BUFFERS_UPDATE		= 16,
527 
528 	/* set/clear io-wq thread affinities */
529 	IORING_REGISTER_IOWQ_AFF		= 17,
530 	IORING_UNREGISTER_IOWQ_AFF		= 18,
531 
532 	/* set/get max number of io-wq workers */
533 	IORING_REGISTER_IOWQ_MAX_WORKERS	= 19,
534 
535 	/* register/unregister io_uring fd with the ring */
536 	IORING_REGISTER_RING_FDS		= 20,
537 	IORING_UNREGISTER_RING_FDS		= 21,
538 
539 	/* register ring based provide buffer group */
540 	IORING_REGISTER_PBUF_RING		= 22,
541 	IORING_UNREGISTER_PBUF_RING		= 23,
542 
543 	/* sync cancelation API */
544 	IORING_REGISTER_SYNC_CANCEL		= 24,
545 
546 	/* register a range of fixed file slots for automatic slot allocation */
547 	IORING_REGISTER_FILE_ALLOC_RANGE	= 25,
548 
549 	/* this goes last */
550 	IORING_REGISTER_LAST,
551 
552 	/* flag added to the opcode to use a registered ring fd */
553 	IORING_REGISTER_USE_REGISTERED_RING	= 1U << 31
554 };
555 
556 /* io-wq worker categories */
557 enum {
558 	IO_WQ_BOUND,
559 	IO_WQ_UNBOUND,
560 };
561 
562 /* deprecated, see struct io_uring_rsrc_update */
563 struct io_uring_files_update {
564 	__u32 offset;
565 	__u32 resv;
566 	__aligned_u64 /* __s32 * */ fds;
567 };
568 
569 /*
570  * Register a fully sparse file space, rather than pass in an array of all
571  * -1 file descriptors.
572  */
573 #define IORING_RSRC_REGISTER_SPARSE	(1U << 0)
574 
575 struct io_uring_rsrc_register {
576 	__u32 nr;
577 	__u32 flags;
578 	__u64 resv2;
579 	__aligned_u64 data;
580 	__aligned_u64 tags;
581 };
582 
583 struct io_uring_rsrc_update {
584 	__u32 offset;
585 	__u32 resv;
586 	__aligned_u64 data;
587 };
588 
589 struct io_uring_rsrc_update2 {
590 	__u32 offset;
591 	__u32 resv;
592 	__aligned_u64 data;
593 	__aligned_u64 tags;
594 	__u32 nr;
595 	__u32 resv2;
596 };
597 
598 /* Skip updating fd indexes set to this value in the fd table */
599 #define IORING_REGISTER_FILES_SKIP	(-2)
600 
601 #define IO_URING_OP_SUPPORTED	(1U << 0)
602 
603 struct io_uring_probe_op {
604 	__u8 op;
605 	__u8 resv;
606 	__u16 flags;	/* IO_URING_OP_* flags */
607 	__u32 resv2;
608 };
609 
610 struct io_uring_probe {
611 	__u8 last_op;	/* last opcode supported */
612 	__u8 ops_len;	/* length of ops[] array below */
613 	__u16 resv;
614 	__u32 resv2[3];
615 	struct io_uring_probe_op ops[];
616 };
617 
618 struct io_uring_restriction {
619 	__u16 opcode;
620 	union {
621 		__u8 register_op; /* IORING_RESTRICTION_REGISTER_OP */
622 		__u8 sqe_op;      /* IORING_RESTRICTION_SQE_OP */
623 		__u8 sqe_flags;   /* IORING_RESTRICTION_SQE_FLAGS_* */
624 	};
625 	__u8 resv;
626 	__u32 resv2[3];
627 };
628 
629 struct io_uring_buf {
630 	__u64	addr;
631 	__u32	len;
632 	__u16	bid;
633 	__u16	resv;
634 };
635 
636 struct io_uring_buf_ring {
637 	union {
638 		/*
639 		 * To avoid spilling into more pages than we need to, the
640 		 * ring tail is overlaid with the io_uring_buf->resv field.
641 		 */
642 		struct {
643 			__u64	resv1;
644 			__u32	resv2;
645 			__u16	resv3;
646 			__u16	tail;
647 		};
648 		__DECLARE_FLEX_ARRAY(struct io_uring_buf, bufs);
649 	};
650 };
651 
652 /*
653  * Flags for IORING_REGISTER_PBUF_RING.
654  *
655  * IOU_PBUF_RING_MMAP:	If set, kernel will allocate the memory for the ring.
656  *			The application must not set a ring_addr in struct
657  *			io_uring_buf_reg, instead it must subsequently call
658  *			mmap(2) with the offset set as:
659  *			IORING_OFF_PBUF_RING | (bgid << IORING_OFF_PBUF_SHIFT)
660  *			to get a virtual mapping for the ring.
661  */
662 enum {
663 	IOU_PBUF_RING_MMAP	= 1,
664 };
665 
666 /* argument for IORING_(UN)REGISTER_PBUF_RING */
667 struct io_uring_buf_reg {
668 	__u64	ring_addr;
669 	__u32	ring_entries;
670 	__u16	bgid;
671 	__u16	flags;
672 	__u64	resv[3];
673 };
674 
675 /*
676  * io_uring_restriction->opcode values
677  */
678 enum {
679 	/* Allow an io_uring_register(2) opcode */
680 	IORING_RESTRICTION_REGISTER_OP		= 0,
681 
682 	/* Allow an sqe opcode */
683 	IORING_RESTRICTION_SQE_OP		= 1,
684 
685 	/* Allow sqe flags */
686 	IORING_RESTRICTION_SQE_FLAGS_ALLOWED	= 2,
687 
688 	/* Require sqe flags (these flags must be set on each submission) */
689 	IORING_RESTRICTION_SQE_FLAGS_REQUIRED	= 3,
690 
691 	IORING_RESTRICTION_LAST
692 };
693 
694 struct io_uring_getevents_arg {
695 	__u64	sigmask;
696 	__u32	sigmask_sz;
697 	__u32	pad;
698 	__u64	ts;
699 };
700 
701 /*
702  * Argument for IORING_REGISTER_SYNC_CANCEL
703  */
704 struct io_uring_sync_cancel_reg {
705 	__u64				addr;
706 	__s32				fd;
707 	__u32				flags;
708 	struct __kernel_timespec	timeout;
709 	__u8				opcode;
710 	__u8				pad[7];
711 	__u64				pad2[3];
712 };
713 
714 /*
715  * Argument for IORING_REGISTER_FILE_ALLOC_RANGE
716  * The range is specified as [off, off + len)
717  */
718 struct io_uring_file_index_range {
719 	__u32	off;
720 	__u32	len;
721 	__u64	resv;
722 };
723 
724 struct io_uring_recvmsg_out {
725 	__u32 namelen;
726 	__u32 controllen;
727 	__u32 payloadlen;
728 	__u32 flags;
729 };
730 
731 /*
732  * Argument for IORING_OP_URING_CMD when file is a socket
733  */
734 enum {
735 	SOCKET_URING_OP_SIOCINQ		= 0,
736 	SOCKET_URING_OP_SIOCOUTQ,
737 };
738 
739 #ifdef __cplusplus
740 }
741 #endif
742 
743 #endif
744