[mirror_ubuntu-kernels.git] / tools / io_uring / liburing.h

#ifndef LIB_URING_H
#define LIB_URING_H

#ifdef __cplusplus
extern "C" {
#endif

#include <sys/uio.h>
#include <signal.h>
#include <string.h>
#include "../../include/uapi/linux/io_uring.h"
#include <inttypes.h>
#include <linux/swab.h>
#include "barrier.h"

/*
 * Library interface to io_uring
 */
struct io_uring_sq {
	unsigned *khead;
	unsigned *ktail;
	unsigned *kring_mask;
	unsigned *kring_entries;
	unsigned *kflags;
	unsigned *kdropped;
	unsigned *array;
	struct io_uring_sqe *sqes;

	unsigned sqe_head;
	unsigned sqe_tail;

	size_t ring_sz;
};

struct io_uring_cq {
	unsigned *khead;
	unsigned *ktail;
	unsigned *kring_mask;
	unsigned *kring_entries;
	unsigned *koverflow;
	struct io_uring_cqe *cqes;

	size_t ring_sz;
};

struct io_uring {
	struct io_uring_sq sq;
	struct io_uring_cq cq;
	int ring_fd;
};

/*
 * System calls
 */
extern int io_uring_setup(unsigned entries, struct io_uring_params *p);
extern int io_uring_enter(int fd, unsigned to_submit,
	unsigned min_complete, unsigned flags, sigset_t *sig);
extern int io_uring_register(int fd, unsigned int opcode, void *arg,
	unsigned int nr_args);

/*
 * Library interface
 */
extern int io_uring_queue_init(unsigned entries, struct io_uring *ring,
	unsigned flags);
extern int io_uring_queue_mmap(int fd, struct io_uring_params *p,
	struct io_uring *ring);
extern void io_uring_queue_exit(struct io_uring *ring);
extern int io_uring_peek_cqe(struct io_uring *ring,
	struct io_uring_cqe **cqe_ptr);
extern int io_uring_wait_cqe(struct io_uring *ring,
	struct io_uring_cqe **cqe_ptr);
extern int io_uring_submit(struct io_uring *ring);
extern struct io_uring_sqe *io_uring_get_sqe(struct io_uring *ring);

/*
 * Must be called after io_uring_{peek,wait}_cqe() after the cqe has
 * been processed by the application.
 */
static inline void io_uring_cqe_seen(struct io_uring *ring,
				     struct io_uring_cqe *cqe)
{
	if (cqe) {
		struct io_uring_cq *cq = &ring->cq;

		(*cq->khead)++;
		/*
		 * Ensure that the kernel sees our new head, the kernel has
		 * the matching read barrier.
		 */
		write_barrier();
	}
}

/*
 * Command prep helpers
 */
static inline void io_uring_sqe_set_data(struct io_uring_sqe *sqe, void *data)
{
	sqe->user_data = (unsigned long) data;
}

static inline void *io_uring_cqe_get_data(struct io_uring_cqe *cqe)
{
	return (void *) (uintptr_t) cqe->user_data;
}

static inline void io_uring_prep_rw(int op, struct io_uring_sqe *sqe, int fd,
				    const void *addr, unsigned len,
				    off_t offset)
{
	memset(sqe, 0, sizeof(*sqe));
	sqe->opcode = op;
	sqe->fd = fd;
	sqe->off = offset;
	sqe->addr = (unsigned long) addr;
	sqe->len = len;
}

static inline void io_uring_prep_readv(struct io_uring_sqe *sqe, int fd,
				       const struct iovec *iovecs,
				       unsigned nr_vecs, off_t offset)
{
	io_uring_prep_rw(IORING_OP_READV, sqe, fd, iovecs, nr_vecs, offset);
}

static inline void io_uring_prep_read_fixed(struct io_uring_sqe *sqe, int fd,
					    void *buf, unsigned nbytes,
					    off_t offset)
{
	io_uring_prep_rw(IORING_OP_READ_FIXED, sqe, fd, buf, nbytes, offset);
}

static inline void io_uring_prep_writev(struct io_uring_sqe *sqe, int fd,
					const struct iovec *iovecs,
					unsigned nr_vecs, off_t offset)
{
	io_uring_prep_rw(IORING_OP_WRITEV, sqe, fd, iovecs, nr_vecs, offset);
}

static inline void io_uring_prep_write_fixed(struct io_uring_sqe *sqe, int fd,
					     const void *buf, unsigned nbytes,
					     off_t offset)
{
	io_uring_prep_rw(IORING_OP_WRITE_FIXED, sqe, fd, buf, nbytes, offset);
}

static inline void io_uring_prep_poll_add(struct io_uring_sqe *sqe, int fd,
					  unsigned poll_mask)
{
	memset(sqe, 0, sizeof(*sqe));
	sqe->opcode = IORING_OP_POLL_ADD;
	sqe->fd = fd;
#if __BYTE_ORDER == __BIG_ENDIAN
	poll_mask = __swahw32(poll_mask);
#endif
	sqe->poll_events = poll_mask;
}

static inline void io_uring_prep_poll_remove(struct io_uring_sqe *sqe,
					     void *user_data)
{
	memset(sqe, 0, sizeof(*sqe));
	sqe->opcode = IORING_OP_POLL_REMOVE;
	sqe->addr = (unsigned long) user_data;
}

static inline void io_uring_prep_fsync(struct io_uring_sqe *sqe, int fd,
				       unsigned fsync_flags)
{
	memset(sqe, 0, sizeof(*sqe));
	sqe->opcode = IORING_OP_FSYNC;
	sqe->fd = fd;
	sqe->fsync_flags = fsync_flags;
}

static inline void io_uring_prep_nop(struct io_uring_sqe *sqe)
{
	memset(sqe, 0, sizeof(*sqe));
	sqe->opcode = IORING_OP_NOP;
}

#ifdef __cplusplus
}
#endif

#endif
Commit	Line	Data
21b4aa5d JA	1	#ifndef LIB_URING_H
	2	#define LIB_URING_H
	3
004d564f JA	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
21b4aa5d JA	8	#include <sys/uio.h>
	9	#include <signal.h>
	10	#include <string.h>
	11	#include "../../include/uapi/linux/io_uring.h"
004d564f	12	#include <inttypes.h>
5769a351	13	#include <linux/swab.h>
004d564f	14	#include "barrier.h"
21b4aa5d JA	15
	16	/*
	17	* Library interface to io_uring
	18	*/
	19	struct io_uring_sq {
	20	unsigned *khead;
	21	unsigned *ktail;
	22	unsigned *kring_mask;
	23	unsigned *kring_entries;
	24	unsigned *kflags;
	25	unsigned *kdropped;
	26	unsigned *array;
	27	struct io_uring_sqe *sqes;
	28
	29	unsigned sqe_head;
	30	unsigned sqe_tail;
	31
	32	size_t ring_sz;
	33	};
	34
	35	struct io_uring_cq {
	36	unsigned *khead;
	37	unsigned *ktail;
	38	unsigned *kring_mask;
	39	unsigned *kring_entries;
	40	unsigned *koverflow;
	41	struct io_uring_cqe *cqes;
	42
	43	size_t ring_sz;
	44	};
	45
	46	struct io_uring {
	47	struct io_uring_sq sq;
	48	struct io_uring_cq cq;
	49	int ring_fd;
	50	};
	51
	52	/*
	53	* System calls
	54	*/
	55	extern int io_uring_setup(unsigned entries, struct io_uring_params *p);
004d564f	56	extern int io_uring_enter(int fd, unsigned to_submit,
21b4aa5d JA	57	unsigned min_complete, unsigned flags, sigset_t *sig);
	58	extern int io_uring_register(int fd, unsigned int opcode, void *arg,
	59	unsigned int nr_args);
	60
	61	/*
	62	* Library interface
	63	*/
	64	extern int io_uring_queue_init(unsigned entries, struct io_uring *ring,
	65	unsigned flags);
	66	extern int io_uring_queue_mmap(int fd, struct io_uring_params *p,
	67	struct io_uring *ring);
	68	extern void io_uring_queue_exit(struct io_uring *ring);
004d564f	69	extern int io_uring_peek_cqe(struct io_uring *ring,
21b4aa5d	70	struct io_uring_cqe **cqe_ptr);
004d564f	71	extern int io_uring_wait_cqe(struct io_uring *ring,
21b4aa5d JA	72	struct io_uring_cqe **cqe_ptr);
	73	extern int io_uring_submit(struct io_uring *ring);
	74	extern struct io_uring_sqe io_uring_get_sqe(struct io_uring ring);
	75
004d564f JA	76	/*
	77	* Must be called after io_uring_{peek,wait}_cqe() after the cqe has
	78	* been processed by the application.
	79	*/
	80	static inline void io_uring_cqe_seen(struct io_uring *ring,
	81	struct io_uring_cqe *cqe)
	82	{
	83	if (cqe) {
	84	struct io_uring_cq *cq = &ring->cq;
	85
	86	(*cq->khead)++;
	87	/*
	88	* Ensure that the kernel sees our new head, the kernel has
	89	* the matching read barrier.
	90	*/
	91	write_barrier();
	92	}
	93	}
	94
21b4aa5d JA	95	/*
	96	* Command prep helpers
	97	*/
	98	static inline void io_uring_sqe_set_data(struct io_uring_sqe sqe, void data)
	99	{
	100	sqe->user_data = (unsigned long) data;
	101	}
	102
004d564f JA	103	static inline void io_uring_cqe_get_data(struct io_uring_cqe cqe)
	104	{
	105	return (void *) (uintptr_t) cqe->user_data;
	106	}
	107
21b4aa5d	108	static inline void io_uring_prep_rw(int op, struct io_uring_sqe *sqe, int fd,
004d564f JA	109	const void *addr, unsigned len,
004d564f JA	110	off_t offset)
21b4aa5d JA	111	{
	112	memset(sqe, 0, sizeof(*sqe));
	113	sqe->opcode = op;
	114	sqe->fd = fd;
	115	sqe->off = offset;
	116	sqe->addr = (unsigned long) addr;
	117	sqe->len = len;
	118	}
	119
	120	static inline void io_uring_prep_readv(struct io_uring_sqe *sqe, int fd,
004d564f JA	121	const struct iovec *iovecs,
004d564f JA	122	unsigned nr_vecs, off_t offset)
21b4aa5d JA	123	{
	124	io_uring_prep_rw(IORING_OP_READV, sqe, fd, iovecs, nr_vecs, offset);
	125	}
	126
	127	static inline void io_uring_prep_read_fixed(struct io_uring_sqe *sqe, int fd,
	128	void *buf, unsigned nbytes,
	129	off_t offset)
	130	{
	131	io_uring_prep_rw(IORING_OP_READ_FIXED, sqe, fd, buf, nbytes, offset);
	132	}
	133
	134	static inline void io_uring_prep_writev(struct io_uring_sqe *sqe, int fd,
004d564f JA	135	const struct iovec *iovecs,
004d564f JA	136	unsigned nr_vecs, off_t offset)
21b4aa5d JA	137	{
	138	io_uring_prep_rw(IORING_OP_WRITEV, sqe, fd, iovecs, nr_vecs, offset);
	139	}
	140
	141	static inline void io_uring_prep_write_fixed(struct io_uring_sqe *sqe, int fd,
004d564f	142	const void *buf, unsigned nbytes,
21b4aa5d JA	143	off_t offset)
	144	{
	145	io_uring_prep_rw(IORING_OP_WRITE_FIXED, sqe, fd, buf, nbytes, offset);
	146	}
	147
	148	static inline void io_uring_prep_poll_add(struct io_uring_sqe *sqe, int fd,
5769a351	149	unsigned poll_mask)
21b4aa5d JA	150	{
	151	memset(sqe, 0, sizeof(*sqe));
	152	sqe->opcode = IORING_OP_POLL_ADD;
	153	sqe->fd = fd;
5769a351 JX	154	#if __BYTE_ORDER == __BIG_ENDIAN
	155	poll_mask = __swahw32(poll_mask);
	156	#endif
21b4aa5d JA	157	sqe->poll_events = poll_mask;
	158	}
	159
	160	static inline void io_uring_prep_poll_remove(struct io_uring_sqe *sqe,
	161	void *user_data)
	162	{
	163	memset(sqe, 0, sizeof(*sqe));
	164	sqe->opcode = IORING_OP_POLL_REMOVE;
	165	sqe->addr = (unsigned long) user_data;
	166	}
	167
	168	static inline void io_uring_prep_fsync(struct io_uring_sqe *sqe, int fd,
004d564f	169	unsigned fsync_flags)
21b4aa5d JA	170	{
	171	memset(sqe, 0, sizeof(*sqe));
	172	sqe->opcode = IORING_OP_FSYNC;
	173	sqe->fd = fd;
004d564f JA	174	sqe->fsync_flags = fsync_flags;
	175	}
	176
	177	static inline void io_uring_prep_nop(struct io_uring_sqe *sqe)
	178	{
	179	memset(sqe, 0, sizeof(*sqe));
	180	sqe->opcode = IORING_OP_NOP;
	181	}
	182
	183	#ifdef __cplusplus
21b4aa5d	184	}
004d564f	185	#endif
21b4aa5d JA	186
21b4aa5d JA	187	#endif