Function io_uring_alloc_huge

src/setup.c:238–325

* Returns negative for error, or number of bytes used in the buffer on success */

 * Returns negative for error, or number of bytes used in the buffer on success
 */
static int io_uring_alloc_huge(unsigned entries, struct io_uring_params *p,
			       struct io_uring_sq *sq, struct io_uring_cq *cq,
			       void *buf, size_t buf_size)
{
	unsigned long page_size = get_page_size();
	unsigned sq_entries, cq_entries;
	size_t sqes_size = 0, ring_mem, sqes_mem;
	unsigned long mem_used = 0;
	void *ptr;
	int ret;

	ret = get_sq_cq_entries(entries, p, &sq_entries, &cq_entries);
	if (ret)
		return ret;

	sqes_mem = params_sqes_size(p, sq_entries);
	sqes_mem = (sqes_mem + page_size - 1) & ~(page_size - 1);

	ring_mem = KRING_SIZE;
	ring_mem += params_cq_size(p, cq_entries);
	if (!(p->flags & IORING_SETUP_NO_SQARRAY))
		ring_mem += sq_entries * sizeof(unsigned);
	mem_used = sqes_mem + ring_mem;
	mem_used = (mem_used + page_size - 1) & ~(page_size - 1);

	/*
	 * A maxed-out number of CQ entries with IORING_SETUP_CQE32 fills a 2MB
	 * huge page by itself, so the SQ entries won't fit in the same huge
	 * page. For SQEs, that shouldn't be possible given KERN_MAX_ENTRIES,
	 * but check that too to future-proof (e.g. against different huge page
	 * sizes). Bail out early so we don't overrun.
	 */
	if (!buf && (sqes_mem > huge_page_size || ring_mem > huge_page_size))
		return -ENOMEM;

	if (buf) {
		if (mem_used > buf_size)
			return -ENOMEM;
		ptr = buf;
	} else {
		int map_hugetlb = 0;
		if (sqes_mem <= page_size)
			buf_size = page_size;
		else {
			buf_size = huge_page_size;
			map_hugetlb = MAP_HUGETLB | MAP_HUGE_2MB;
		}
		sqes_size = buf_size;
		ptr = __sys_mmap(NULL, sqes_size, PROT_READ|PROT_WRITE,
					MAP_SHARED|MAP_ANONYMOUS|map_hugetlb,
					-1, 0);
		if (IS_ERR(ptr))
			return PTR_ERR(ptr);
	}

	sq->sqes = ptr;
	sq->sqes_sz = (unsigned int) sqes_size;
	if (mem_used <= buf_size) {