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