The C and C++ Include Header Files

/usr/include/linux/io_uring.h


$ cat -n /usr/include/linux/io_uring.h

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