1#include <sys/types.h> 2#include <sys/stat.h> 3#include <sys/mman.h> 4#include <unistd.h> 5#include <errno.h> 6#include <string.h> 7 8#include "liburing.h" 9 10static int io_uring_mmap(int fd, struct io_uring_params *p, 11 struct io_uring_sq *sq, struct io_uring_cq *cq) 12{ 13 size_t size; 14 void *ptr; 15 int ret; 16 17 sq->ring_sz = p->sq_off.array + p->sq_entries * sizeof(unsigned); 18 ptr = mmap(0, sq->ring_sz, PROT_READ | PROT_WRITE, 19 MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_SQ_RING); 20 if (ptr == MAP_FAILED) 21 return -errno; 22 sq->khead = ptr + p->sq_off.head; 23 sq->ktail = ptr + p->sq_off.tail; 24 sq->kring_mask = ptr + p->sq_off.ring_mask; 25 sq->kring_entries = ptr + p->sq_off.ring_entries; 26 sq->kflags = ptr + p->sq_off.flags; 27 sq->kdropped = ptr + p->sq_off.dropped; 28 sq->array = ptr + p->sq_off.array; 29 30 size = p->sq_entries * sizeof(struct io_uring_sqe); 31 sq->sqes = mmap(0, size, PROT_READ | PROT_WRITE, 32 MAP_SHARED | MAP_POPULATE, fd, 33 IORING_OFF_SQES); 34 if (sq->sqes == MAP_FAILED) { 35 ret = -errno; 36err: 37 munmap(sq->khead, sq->ring_sz); 38 return ret; 39 } 40 41 cq->ring_sz = p->cq_off.cqes + p->cq_entries * sizeof(struct io_uring_cqe); 42 ptr = mmap(0, cq->ring_sz, PROT_READ | PROT_WRITE, 43 MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_CQ_RING); 44 if (ptr == MAP_FAILED) { 45 ret = -errno; 46 munmap(sq->sqes, p->sq_entries * sizeof(struct io_uring_sqe)); 47 goto err; 48 } 49 cq->khead = ptr + p->cq_off.head; 50 cq->ktail = ptr + p->cq_off.tail; 51 cq->kring_mask = ptr + p->cq_off.ring_mask; 52 cq->kring_entries = ptr + p->cq_off.ring_entries; 53 cq->koverflow = ptr + p->cq_off.overflow; 54 cq->cqes = ptr + p->cq_off.cqes; 55 return 0; 56} 57 58/* 59 * For users that want to specify sq_thread_cpu or sq_thread_idle, this 60 * interface is a convenient helper for mmap()ing the rings. 61 * Returns -1 on error, or zero on success. On success, 'ring' 62 * contains the necessary information to read/write to the rings. 63 */ 64int io_uring_queue_mmap(int fd, struct io_uring_params *p, struct io_uring *ring) 65{ 66 int ret; 67 68 memset(ring, 0, sizeof(*ring)); 69 ret = io_uring_mmap(fd, p, &ring->sq, &ring->cq); 70 if (!ret) 71 ring->ring_fd = fd; 72 return ret; 73} 74 75/* 76 * Returns -1 on error, or zero on success. On success, 'ring' 77 * contains the necessary information to read/write to the rings. 78 */ 79int io_uring_queue_init(unsigned entries, struct io_uring *ring, unsigned flags) 80{ 81 struct io_uring_params p; 82 int fd, ret; 83 84 memset(&p, 0, sizeof(p)); 85 p.flags = flags; 86 87 fd = io_uring_setup(entries, &p); 88 if (fd < 0) 89 return fd; 90 91 ret = io_uring_queue_mmap(fd, &p, ring); 92 if (ret) 93 close(fd); 94 95 return ret; 96} 97 98void io_uring_queue_exit(struct io_uring *ring) 99{ 100 struct io_uring_sq *sq = &ring->sq; 101 struct io_uring_cq *cq = &ring->cq; 102 103 munmap(sq->sqes, *sq->kring_entries * sizeof(struct io_uring_sqe)); 104 munmap(sq->khead, sq->ring_sz); 105 munmap(cq->khead, cq->ring_sz); 106 close(ring->ring_fd); 107} 108