[linux.git] / lib / kunit_iov_iter.c

// SPDX-License-Identifier: GPL-2.0-only
/* I/O iterator tests.  This can only test kernel-backed iterator types.
 *
 * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/uio.h>
#include <linux/bvec.h>
#include <kunit/test.h>

MODULE_DESCRIPTION("iov_iter testing");
MODULE_AUTHOR("David Howells <[email protected]>");
MODULE_LICENSE("GPL");

struct kvec_test_range {
	int	from, to;
};

static const struct kvec_test_range kvec_test_ranges[] = {
	{ 0x00002, 0x00002 },
	{ 0x00027, 0x03000 },
	{ 0x05193, 0x18794 },
	{ 0x20000, 0x20000 },
	{ 0x20000, 0x24000 },
	{ 0x24000, 0x27001 },
	{ 0x29000, 0xffffb },
	{ 0xffffd, 0xffffe },
	{ -1 }
};

static inline u8 pattern(unsigned long x)
{
	return x & 0xff;
}

static void iov_kunit_unmap(void *data)
{
	vunmap(data);
}

static void *__init iov_kunit_create_buffer(struct kunit *test,
					    struct page ***ppages,
					    size_t npages)
{
	struct page **pages;
	unsigned long got;
	void *buffer;

	pages = kunit_kcalloc(test, npages, sizeof(struct page *), GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pages);
	*ppages = pages;

	got = alloc_pages_bulk_array(GFP_KERNEL, npages, pages);
	if (got != npages) {
		release_pages(pages, got);
		KUNIT_ASSERT_EQ(test, got, npages);
	}

	buffer = vmap(pages, npages, VM_MAP | VM_MAP_PUT_PAGES, PAGE_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buffer);

	kunit_add_action_or_reset(test, iov_kunit_unmap, buffer);
	return buffer;
}

static void __init iov_kunit_load_kvec(struct kunit *test,
				       struct iov_iter *iter, int dir,
				       struct kvec *kvec, unsigned int kvmax,
				       void *buffer, size_t bufsize,
				       const struct kvec_test_range *pr)
{
	size_t size = 0;
	int i;

	for (i = 0; i < kvmax; i++, pr++) {
		if (pr->from < 0)
			break;
		KUNIT_ASSERT_GE(test, pr->to, pr->from);
		KUNIT_ASSERT_LE(test, pr->to, bufsize);
		kvec[i].iov_base = buffer + pr->from;
		kvec[i].iov_len = pr->to - pr->from;
		size += pr->to - pr->from;
	}
	KUNIT_ASSERT_LE(test, size, bufsize);

	iov_iter_kvec(iter, dir, kvec, i, size);
}

/*
 * Test copying to a ITER_KVEC-type iterator.
 */
static void __init iov_kunit_copy_to_kvec(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct page **spages, **bpages;
	struct kvec kvec[8];
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, patt;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	for (i = 0; i < bufsize; i++)
		scratch[i] = pattern(i);

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	memset(buffer, 0, bufsize);

	iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
			    buffer, bufsize, kvec_test_ranges);
	size = iter.count;

	copied = copy_to_iter(scratch, size, &iter);

	KUNIT_EXPECT_EQ(test, copied, size);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

	/* Build the expected image in the scratch buffer. */
	patt = 0;
	memset(scratch, 0, bufsize);
	for (pr = kvec_test_ranges; pr->from >= 0; pr++)
		for (i = pr->from; i < pr->to; i++)
			scratch[i] = pattern(patt++);

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
		if (buffer[i] != scratch[i])
			return;
	}

	KUNIT_SUCCEED();
}

/*
 * Test copying from a ITER_KVEC-type iterator.
 */
static void __init iov_kunit_copy_from_kvec(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct page **spages, **bpages;
	struct kvec kvec[8];
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, j;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	for (i = 0; i < bufsize; i++)
		buffer[i] = pattern(i);

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	memset(scratch, 0, bufsize);

	iov_kunit_load_kvec(test, &iter, WRITE, kvec, ARRAY_SIZE(kvec),
			    buffer, bufsize, kvec_test_ranges);
	size = min(iter.count, bufsize);

	copied = copy_from_iter(scratch, size, &iter);

	KUNIT_EXPECT_EQ(test, copied, size);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

	/* Build the expected image in the main buffer. */
	i = 0;
	memset(buffer, 0, bufsize);
	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
		for (j = pr->from; j < pr->to; j++) {
			buffer[i++] = pattern(j);
			if (i >= bufsize)
				goto stop;
		}
	}
stop:

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
		if (scratch[i] != buffer[i])
			return;
	}

	KUNIT_SUCCEED();
}

struct bvec_test_range {
	int	page, from, to;
};

static const struct bvec_test_range bvec_test_ranges[] = {
	{ 0, 0x0002, 0x0002 },
	{ 1, 0x0027, 0x0893 },
	{ 2, 0x0193, 0x0794 },
	{ 3, 0x0000, 0x1000 },
	{ 4, 0x0000, 0x1000 },
	{ 5, 0x0000, 0x1000 },
	{ 6, 0x0000, 0x0ffb },
	{ 6, 0x0ffd, 0x0ffe },
	{ -1, -1, -1 }
};

static void __init iov_kunit_load_bvec(struct kunit *test,
				       struct iov_iter *iter, int dir,
				       struct bio_vec *bvec, unsigned int bvmax,
				       struct page **pages, size_t npages,
				       size_t bufsize,
				       const struct bvec_test_range *pr)
{
	struct page *can_merge = NULL, *page;
	size_t size = 0;
	int i;

	for (i = 0; i < bvmax; i++, pr++) {
		if (pr->from < 0)
			break;
		KUNIT_ASSERT_LT(test, pr->page, npages);
		KUNIT_ASSERT_LT(test, pr->page * PAGE_SIZE, bufsize);
		KUNIT_ASSERT_GE(test, pr->from, 0);
		KUNIT_ASSERT_GE(test, pr->to, pr->from);
		KUNIT_ASSERT_LE(test, pr->to, PAGE_SIZE);

		page = pages[pr->page];
		if (pr->from == 0 && pr->from != pr->to && page == can_merge) {
			i--;
			bvec[i].bv_len += pr->to;
		} else {
			bvec_set_page(&bvec[i], page, pr->to - pr->from, pr->from);
		}

		size += pr->to - pr->from;
		if ((pr->to & ~PAGE_MASK) == 0)
			can_merge = page + pr->to / PAGE_SIZE;
		else
			can_merge = NULL;
	}

	iov_iter_bvec(iter, dir, bvec, i, size);
}

/*
 * Test copying to a ITER_BVEC-type iterator.
 */
static void __init iov_kunit_copy_to_bvec(struct kunit *test)
{
	const struct bvec_test_range *pr;
	struct iov_iter iter;
	struct bio_vec bvec[8];
	struct page **spages, **bpages;
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, b, patt;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	for (i = 0; i < bufsize; i++)
		scratch[i] = pattern(i);

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	memset(buffer, 0, bufsize);

	iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
			    bpages, npages, bufsize, bvec_test_ranges);
	size = iter.count;

	copied = copy_to_iter(scratch, size, &iter);

	KUNIT_EXPECT_EQ(test, copied, size);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

	/* Build the expected image in the scratch buffer. */
	b = 0;
	patt = 0;
	memset(scratch, 0, bufsize);
	for (pr = bvec_test_ranges; pr->from >= 0; pr++, b++) {
		u8 *p = scratch + pr->page * PAGE_SIZE;

		for (i = pr->from; i < pr->to; i++)
			p[i] = pattern(patt++);
	}

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
		if (buffer[i] != scratch[i])
			return;
	}

	KUNIT_SUCCEED();
}

/*
 * Test copying from a ITER_BVEC-type iterator.
 */
static void __init iov_kunit_copy_from_bvec(struct kunit *test)
{
	const struct bvec_test_range *pr;
	struct iov_iter iter;
	struct bio_vec bvec[8];
	struct page **spages, **bpages;
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, j;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	for (i = 0; i < bufsize; i++)
		buffer[i] = pattern(i);

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	memset(scratch, 0, bufsize);

	iov_kunit_load_bvec(test, &iter, WRITE, bvec, ARRAY_SIZE(bvec),
			    bpages, npages, bufsize, bvec_test_ranges);
	size = iter.count;

	copied = copy_from_iter(scratch, size, &iter);

	KUNIT_EXPECT_EQ(test, copied, size);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);

	/* Build the expected image in the main buffer. */
	i = 0;
	memset(buffer, 0, bufsize);
	for (pr = bvec_test_ranges; pr->from >= 0; pr++) {
		size_t patt = pr->page * PAGE_SIZE;

		for (j = pr->from; j < pr->to; j++) {
			buffer[i++] = pattern(patt + j);
			if (i >= bufsize)
				goto stop;
		}
	}
stop:

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
		if (scratch[i] != buffer[i])
			return;
	}

	KUNIT_SUCCEED();
}

static void iov_kunit_destroy_xarray(void *data)
{
	struct xarray *xarray = data;

	xa_destroy(xarray);
	kfree(xarray);
}

static void __init iov_kunit_load_xarray(struct kunit *test,
					 struct iov_iter *iter, int dir,
					 struct xarray *xarray,
					 struct page **pages, size_t npages)
{
	size_t size = 0;
	int i;

	for (i = 0; i < npages; i++) {
		void *x = xa_store(xarray, i, pages[i], GFP_KERNEL);

		KUNIT_ASSERT_FALSE(test, xa_is_err(x));
		size += PAGE_SIZE;
	}
	iov_iter_xarray(iter, dir, xarray, 0, size);
}

static struct xarray *iov_kunit_create_xarray(struct kunit *test)
{
	struct xarray *xarray;

	xarray = kzalloc(sizeof(struct xarray), GFP_KERNEL);
	xa_init(xarray);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xarray);
	kunit_add_action_or_reset(test, iov_kunit_destroy_xarray, xarray);
	return xarray;
}

/*
 * Test copying to a ITER_XARRAY-type iterator.
 */
static void __init iov_kunit_copy_to_xarray(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct xarray *xarray;
	struct page **spages, **bpages;
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, patt;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	xarray = iov_kunit_create_xarray(test);

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	for (i = 0; i < bufsize; i++)
		scratch[i] = pattern(i);

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	memset(buffer, 0, bufsize);

	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

	i = 0;
	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
		size = pr->to - pr->from;
		KUNIT_ASSERT_LE(test, pr->to, bufsize);

		iov_iter_xarray(&iter, READ, xarray, pr->from, size);
		copied = copy_to_iter(scratch + i, size, &iter);

		KUNIT_EXPECT_EQ(test, copied, size);
		KUNIT_EXPECT_EQ(test, iter.count, 0);
		KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
		i += size;
	}

	/* Build the expected image in the scratch buffer. */
	patt = 0;
	memset(scratch, 0, bufsize);
	for (pr = kvec_test_ranges; pr->from >= 0; pr++)
		for (i = pr->from; i < pr->to; i++)
			scratch[i] = pattern(patt++);

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
		if (buffer[i] != scratch[i])
			return;
	}

	KUNIT_SUCCEED();
}

/*
 * Test copying from a ITER_XARRAY-type iterator.
 */
static void __init iov_kunit_copy_from_xarray(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct xarray *xarray;
	struct page **spages, **bpages;
	u8 *scratch, *buffer;
	size_t bufsize, npages, size, copied;
	int i, j;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	xarray = iov_kunit_create_xarray(test);

	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	for (i = 0; i < bufsize; i++)
		buffer[i] = pattern(i);

	scratch = iov_kunit_create_buffer(test, &spages, npages);
	memset(scratch, 0, bufsize);

	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

	i = 0;
	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
		size = pr->to - pr->from;
		KUNIT_ASSERT_LE(test, pr->to, bufsize);

		iov_iter_xarray(&iter, WRITE, xarray, pr->from, size);
		copied = copy_from_iter(scratch + i, size, &iter);

		KUNIT_EXPECT_EQ(test, copied, size);
		KUNIT_EXPECT_EQ(test, iter.count, 0);
		KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
		i += size;
	}

	/* Build the expected image in the main buffer. */
	i = 0;
	memset(buffer, 0, bufsize);
	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
		for (j = pr->from; j < pr->to; j++) {
			buffer[i++] = pattern(j);
			if (i >= bufsize)
				goto stop;
		}
	}
stop:

	/* Compare the images */
	for (i = 0; i < bufsize; i++) {
		KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
		if (scratch[i] != buffer[i])
			return;
	}

	KUNIT_SUCCEED();
}

/*
 * Test the extraction of ITER_KVEC-type iterators.
 */
static void __init iov_kunit_extract_pages_kvec(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct page **bpages, *pagelist[8], **pages = pagelist;
	struct kvec kvec[8];
	u8 *buffer;
	ssize_t len;
	size_t bufsize, size = 0, npages;
	int i, from;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	buffer = iov_kunit_create_buffer(test, &bpages, npages);

	iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
			    buffer, bufsize, kvec_test_ranges);
	size = iter.count;

	pr = kvec_test_ranges;
	from = pr->from;
	do {
		size_t offset0 = LONG_MAX;

		for (i = 0; i < ARRAY_SIZE(pagelist); i++)
			pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;

		len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
					     ARRAY_SIZE(pagelist), 0, &offset0);
		KUNIT_EXPECT_GE(test, len, 0);
		if (len < 0)
			break;
		KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
		KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
		KUNIT_EXPECT_LE(test, len, size);
		KUNIT_EXPECT_EQ(test, iter.count, size - len);
		size -= len;

		if (len == 0)
			break;

		for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
			struct page *p;
			ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
			int ix;

			KUNIT_ASSERT_GE(test, part, 0);
			while (from == pr->to) {
				pr++;
				from = pr->from;
				if (from < 0)
					goto stop;
			}
			ix = from / PAGE_SIZE;
			KUNIT_ASSERT_LT(test, ix, npages);
			p = bpages[ix];
			KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
			KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
			from += part;
			len -= part;
			KUNIT_ASSERT_GE(test, len, 0);
			if (len == 0)
				break;
			offset0 = 0;
		}

		if (test->status == KUNIT_FAILURE)
			break;
	} while (iov_iter_count(&iter) > 0);

stop:
	KUNIT_EXPECT_EQ(test, size, 0);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_SUCCEED();
}

/*
 * Test the extraction of ITER_BVEC-type iterators.
 */
static void __init iov_kunit_extract_pages_bvec(struct kunit *test)
{
	const struct bvec_test_range *pr;
	struct iov_iter iter;
	struct page **bpages, *pagelist[8], **pages = pagelist;
	struct bio_vec bvec[8];
	ssize_t len;
	size_t bufsize, size = 0, npages;
	int i, from;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	iov_kunit_create_buffer(test, &bpages, npages);
	iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
			    bpages, npages, bufsize, bvec_test_ranges);
	size = iter.count;

	pr = bvec_test_ranges;
	from = pr->from;
	do {
		size_t offset0 = LONG_MAX;

		for (i = 0; i < ARRAY_SIZE(pagelist); i++)
			pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;

		len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
					     ARRAY_SIZE(pagelist), 0, &offset0);
		KUNIT_EXPECT_GE(test, len, 0);
		if (len < 0)
			break;
		KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
		KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
		KUNIT_EXPECT_LE(test, len, size);
		KUNIT_EXPECT_EQ(test, iter.count, size - len);
		size -= len;

		if (len == 0)
			break;

		for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
			struct page *p;
			ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
			int ix;

			KUNIT_ASSERT_GE(test, part, 0);
			while (from == pr->to) {
				pr++;
				from = pr->from;
				if (from < 0)
					goto stop;
			}
			ix = pr->page + from / PAGE_SIZE;
			KUNIT_ASSERT_LT(test, ix, npages);
			p = bpages[ix];
			KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
			KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
			from += part;
			len -= part;
			KUNIT_ASSERT_GE(test, len, 0);
			if (len == 0)
				break;
			offset0 = 0;
		}

		if (test->status == KUNIT_FAILURE)
			break;
	} while (iov_iter_count(&iter) > 0);

stop:
	KUNIT_EXPECT_EQ(test, size, 0);
	KUNIT_EXPECT_EQ(test, iter.count, 0);
	KUNIT_SUCCEED();
}

/*
 * Test the extraction of ITER_XARRAY-type iterators.
 */
static void __init iov_kunit_extract_pages_xarray(struct kunit *test)
{
	const struct kvec_test_range *pr;
	struct iov_iter iter;
	struct xarray *xarray;
	struct page **bpages, *pagelist[8], **pages = pagelist;
	ssize_t len;
	size_t bufsize, size = 0, npages;
	int i, from;

	bufsize = 0x100000;
	npages = bufsize / PAGE_SIZE;

	xarray = iov_kunit_create_xarray(test);

	iov_kunit_create_buffer(test, &bpages, npages);
	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);

	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
		from = pr->from;
		size = pr->to - from;
		KUNIT_ASSERT_LE(test, pr->to, bufsize);

		iov_iter_xarray(&iter, WRITE, xarray, from, size);

		do {
			size_t offset0 = LONG_MAX;

			for (i = 0; i < ARRAY_SIZE(pagelist); i++)
				pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;

			len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
						     ARRAY_SIZE(pagelist), 0, &offset0);
			KUNIT_EXPECT_GE(test, len, 0);
			if (len < 0)
				break;
			KUNIT_EXPECT_LE(test, len, size);
			KUNIT_EXPECT_EQ(test, iter.count, size - len);
			if (len == 0)
				break;
			size -= len;
			KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
			KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);

			for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
				struct page *p;
				ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
				int ix;

				KUNIT_ASSERT_GE(test, part, 0);
				ix = from / PAGE_SIZE;
				KUNIT_ASSERT_LT(test, ix, npages);
				p = bpages[ix];
				KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
				KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
				from += part;
				len -= part;
				KUNIT_ASSERT_GE(test, len, 0);
				if (len == 0)
					break;
				offset0 = 0;
			}

			if (test->status == KUNIT_FAILURE)
				goto stop;
		} while (iov_iter_count(&iter) > 0);

		KUNIT_EXPECT_EQ(test, size, 0);
		KUNIT_EXPECT_EQ(test, iter.count, 0);
		KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to - pr->from);
	}

stop:
	KUNIT_SUCCEED();
}

static struct kunit_case __refdata iov_kunit_cases[] = {
	KUNIT_CASE(iov_kunit_copy_to_kvec),
	KUNIT_CASE(iov_kunit_copy_from_kvec),
	KUNIT_CASE(iov_kunit_copy_to_bvec),
	KUNIT_CASE(iov_kunit_copy_from_bvec),
	KUNIT_CASE(iov_kunit_copy_to_xarray),
	KUNIT_CASE(iov_kunit_copy_from_xarray),
	KUNIT_CASE(iov_kunit_extract_pages_kvec),
	KUNIT_CASE(iov_kunit_extract_pages_bvec),
	KUNIT_CASE(iov_kunit_extract_pages_xarray),
	{}
};

static struct kunit_suite iov_kunit_suite = {
	.name = "iov_iter",
	.test_cases = iov_kunit_cases,
};

kunit_test_suites(&iov_kunit_suite);
Commit	Line	Data
2d71340f DH	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/* I/O iterator tests. This can only test kernel-backed iterator types.
	3	*
	4	* Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells ([email protected])
	6	*/
	7
	8	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	9
	10	#include <linux/module.h>
	11	#include <linux/vmalloc.h>
	12	#include <linux/mm.h>
	13	#include <linux/uio.h>
	14	#include <linux/bvec.h>
	15	#include <kunit/test.h>
	16
	17	MODULE_DESCRIPTION("iov_iter testing");
	18	MODULE_AUTHOR("David Howells <[email protected]>");
	19	MODULE_LICENSE("GPL");
	20
	21	struct kvec_test_range {
	22	int from, to;
	23	};
	24
	25	static const struct kvec_test_range kvec_test_ranges[] = {
	26	{ 0x00002, 0x00002 },
	27	{ 0x00027, 0x03000 },
	28	{ 0x05193, 0x18794 },
	29	{ 0x20000, 0x20000 },
	30	{ 0x20000, 0x24000 },
	31	{ 0x24000, 0x27001 },
	32	{ 0x29000, 0xffffb },
	33	{ 0xffffd, 0xffffe },
	34	{ -1 }
	35	};
	36
	37	static inline u8 pattern(unsigned long x)
	38	{
	39	return x & 0xff;
	40	}
	41
	42	static void iov_kunit_unmap(void *data)
	43	{
	44	vunmap(data);
	45	}
	46
	47	static void __init iov_kunit_create_buffer(struct kunit test,
	48	struct page ***ppages,
	49	size_t npages)
	50	{
	51	struct page **pages;
	52	unsigned long got;
	53	void *buffer;
	54
	55	pages = kunit_kcalloc(test, npages, sizeof(struct page *), GFP_KERNEL);
	56	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pages);
	57	*ppages = pages;
	58
	59	got = alloc_pages_bulk_array(GFP_KERNEL, npages, pages);
	60	if (got != npages) {
	61	release_pages(pages, got);
	62	KUNIT_ASSERT_EQ(test, got, npages);
	63	}
	64
65	buffer = vmap(pages, npages, VM_MAP \| VM_MAP_PUT_PAGES, PAGE_KERNEL);
66	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buffer);
67
68	kunit_add_action_or_reset(test, iov_kunit_unmap, buffer);
69	return buffer;
70	}
71
72	static void __init iov_kunit_load_kvec(struct kunit *test,
73	struct iov_iter *iter, int dir,
74	struct kvec *kvec, unsigned int kvmax,
75	void *buffer, size_t bufsize,
76	const struct kvec_test_range *pr)
77	{
78	size_t size = 0;
79	int i;
80
81	for (i = 0; i < kvmax; i++, pr++) {
82	if (pr->from < 0)
83	break;
84	KUNIT_ASSERT_GE(test, pr->to, pr->from);
85	KUNIT_ASSERT_LE(test, pr->to, bufsize);
86	kvec[i].iov_base = buffer + pr->from;
87	kvec[i].iov_len = pr->to - pr->from;
88	size += pr->to - pr->from;
89	}
90	KUNIT_ASSERT_LE(test, size, bufsize);
91
92	iov_iter_kvec(iter, dir, kvec, i, size);
93	}
94
95	/*
96	* Test copying to a ITER_KVEC-type iterator.
97	*/
98	static void __init iov_kunit_copy_to_kvec(struct kunit *test)
99	{
100	const struct kvec_test_range *pr;
101	struct iov_iter iter;
102	struct page spages, bpages;
103	struct kvec kvec[8];
104	u8 scratch, buffer;
105	size_t bufsize, npages, size, copied;
106	int i, patt;
107
108	bufsize = 0x100000;
109	npages = bufsize / PAGE_SIZE;
110
111	scratch = iov_kunit_create_buffer(test, &spages, npages);
112	for (i = 0; i < bufsize; i++)
113	scratch[i] = pattern(i);
114
115	buffer = iov_kunit_create_buffer(test, &bpages, npages);
116	memset(buffer, 0, bufsize);
117
118	iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
119	buffer, bufsize, kvec_test_ranges);
120	size = iter.count;
121
122	copied = copy_to_iter(scratch, size, &iter);
123
124	KUNIT_EXPECT_EQ(test, copied, size);
125	KUNIT_EXPECT_EQ(test, iter.count, 0);
126	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
127
128	/* Build the expected image in the scratch buffer. */
129	patt = 0;
130	memset(scratch, 0, bufsize);
131	for (pr = kvec_test_ranges; pr->from >= 0; pr++)
132	for (i = pr->from; i < pr->to; i++)
133	scratch[i] = pattern(patt++);
134
135	/* Compare the images */
136	for (i = 0; i < bufsize; i++) {
137	KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
138	if (buffer[i] != scratch[i])
139	return;
140	}
141
142	KUNIT_SUCCEED();
143	}
144
145	/*
146	* Test copying from a ITER_KVEC-type iterator.
147	*/
148	static void __init iov_kunit_copy_from_kvec(struct kunit *test)
149	{
150	const struct kvec_test_range *pr;
151	struct iov_iter iter;
152	struct page spages, bpages;
153	struct kvec kvec[8];
154	u8 scratch, buffer;
155	size_t bufsize, npages, size, copied;
156	int i, j;
157
158	bufsize = 0x100000;
159	npages = bufsize / PAGE_SIZE;
160
161	buffer = iov_kunit_create_buffer(test, &bpages, npages);
162	for (i = 0; i < bufsize; i++)
163	buffer[i] = pattern(i);
164
165	scratch = iov_kunit_create_buffer(test, &spages, npages);
166	memset(scratch, 0, bufsize);
167
168	iov_kunit_load_kvec(test, &iter, WRITE, kvec, ARRAY_SIZE(kvec),
169	buffer, bufsize, kvec_test_ranges);
170	size = min(iter.count, bufsize);
171
172	copied = copy_from_iter(scratch, size, &iter);
173
174	KUNIT_EXPECT_EQ(test, copied, size);
175	KUNIT_EXPECT_EQ(test, iter.count, 0);
176	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
177
178	/* Build the expected image in the main buffer. */
179	i = 0;
180	memset(buffer, 0, bufsize);
181	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
182	for (j = pr->from; j < pr->to; j++) {
183	buffer[i++] = pattern(j);
184	if (i >= bufsize)
185	goto stop;
186	}
187	}
188	stop:
189
190	/* Compare the images */
191	for (i = 0; i < bufsize; i++) {
192	KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
193	if (scratch[i] != buffer[i])
194	return;
195	}
196
197	KUNIT_SUCCEED();
198	}
199
200	struct bvec_test_range {
201	int page, from, to;
202	};
203
204	static const struct bvec_test_range bvec_test_ranges[] = {
205	{ 0, 0x0002, 0x0002 },
206	{ 1, 0x0027, 0x0893 },
207	{ 2, 0x0193, 0x0794 },
208	{ 3, 0x0000, 0x1000 },
209	{ 4, 0x0000, 0x1000 },
210	{ 5, 0x0000, 0x1000 },
211	{ 6, 0x0000, 0x0ffb },
212	{ 6, 0x0ffd, 0x0ffe },
213	{ -1, -1, -1 }
214	};
215
216	static void __init iov_kunit_load_bvec(struct kunit *test,
217	struct iov_iter *iter, int dir,
218	struct bio_vec *bvec, unsigned int bvmax,
219	struct page **pages, size_t npages,
220	size_t bufsize,
221	const struct bvec_test_range *pr)
222	{
223	struct page can_merge = NULL, page;
224	size_t size = 0;
225	int i;
226
227	for (i = 0; i < bvmax; i++, pr++) {
228	if (pr->from < 0)
229	break;
230	KUNIT_ASSERT_LT(test, pr->page, npages);
231	KUNIT_ASSERT_LT(test, pr->page * PAGE_SIZE, bufsize);
232	KUNIT_ASSERT_GE(test, pr->from, 0);
233	KUNIT_ASSERT_GE(test, pr->to, pr->from);
234	KUNIT_ASSERT_LE(test, pr->to, PAGE_SIZE);
235
236	page = pages[pr->page];
237	if (pr->from == 0 && pr->from != pr->to && page == can_merge) {
238	i--;
239	bvec[i].bv_len += pr->to;
240	} else {
241	bvec_set_page(&bvec[i], page, pr->to - pr->from, pr->from);
242	}
243
244	size += pr->to - pr->from;
245	if ((pr->to & ~PAGE_MASK) == 0)
246	can_merge = page + pr->to / PAGE_SIZE;
247	else
248	can_merge = NULL;
249	}
250
251	iov_iter_bvec(iter, dir, bvec, i, size);
252	}
253
254	/*
255	* Test copying to a ITER_BVEC-type iterator.
256	*/
257	static void __init iov_kunit_copy_to_bvec(struct kunit *test)
258	{
259	const struct bvec_test_range *pr;
260	struct iov_iter iter;
261	struct bio_vec bvec[8];
262	struct page spages, bpages;
263	u8 scratch, buffer;
264	size_t bufsize, npages, size, copied;
265	int i, b, patt;
266
267	bufsize = 0x100000;
268	npages = bufsize / PAGE_SIZE;
269
270	scratch = iov_kunit_create_buffer(test, &spages, npages);
271	for (i = 0; i < bufsize; i++)
272	scratch[i] = pattern(i);
273
274	buffer = iov_kunit_create_buffer(test, &bpages, npages);
275	memset(buffer, 0, bufsize);
276
277	iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
278	bpages, npages, bufsize, bvec_test_ranges);
279	size = iter.count;
280
281	copied = copy_to_iter(scratch, size, &iter);
282
283	KUNIT_EXPECT_EQ(test, copied, size);
284	KUNIT_EXPECT_EQ(test, iter.count, 0);
285	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
286
287	/* Build the expected image in the scratch buffer. */
288	b = 0;
289	patt = 0;
290	memset(scratch, 0, bufsize);
291	for (pr = bvec_test_ranges; pr->from >= 0; pr++, b++) {
292	u8 p = scratch + pr->page PAGE_SIZE;
293
294	for (i = pr->from; i < pr->to; i++)
295	p[i] = pattern(patt++);
296	}
297
298	/* Compare the images */
299	for (i = 0; i < bufsize; i++) {
300	KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
301	if (buffer[i] != scratch[i])
302	return;
303	}
304
305	KUNIT_SUCCEED();
306	}
307
308	/*
309	* Test copying from a ITER_BVEC-type iterator.
310	*/
311	static void __init iov_kunit_copy_from_bvec(struct kunit *test)
312	{
313	const struct bvec_test_range *pr;
314	struct iov_iter iter;
315	struct bio_vec bvec[8];
316	struct page spages, bpages;
317	u8 scratch, buffer;
318	size_t bufsize, npages, size, copied;
319	int i, j;
320
321	bufsize = 0x100000;
322	npages = bufsize / PAGE_SIZE;
323
324	buffer = iov_kunit_create_buffer(test, &bpages, npages);
325	for (i = 0; i < bufsize; i++)
326	buffer[i] = pattern(i);
327
328	scratch = iov_kunit_create_buffer(test, &spages, npages);
329	memset(scratch, 0, bufsize);
330
331	iov_kunit_load_bvec(test, &iter, WRITE, bvec, ARRAY_SIZE(bvec),
332	bpages, npages, bufsize, bvec_test_ranges);
333	size = iter.count;
334
335	copied = copy_from_iter(scratch, size, &iter);
336
337	KUNIT_EXPECT_EQ(test, copied, size);
338	KUNIT_EXPECT_EQ(test, iter.count, 0);
339	KUNIT_EXPECT_EQ(test, iter.nr_segs, 0);
340
341	/* Build the expected image in the main buffer. */
342	i = 0;
343	memset(buffer, 0, bufsize);
344	for (pr = bvec_test_ranges; pr->from >= 0; pr++) {
345	size_t patt = pr->page * PAGE_SIZE;
346
347	for (j = pr->from; j < pr->to; j++) {
348	buffer[i++] = pattern(patt + j);
349	if (i >= bufsize)
350	goto stop;
351	}
352	}
353	stop:
354
355	/* Compare the images */
356	for (i = 0; i < bufsize; i++) {
357	KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
358	if (scratch[i] != buffer[i])
359	return;
360	}
361
362	KUNIT_SUCCEED();
363	}
364
365	static void iov_kunit_destroy_xarray(void *data)
366	{
367	struct xarray *xarray = data;
368
369	xa_destroy(xarray);
370	kfree(xarray);
371	}
372
373	static void __init iov_kunit_load_xarray(struct kunit *test,
374	struct iov_iter *iter, int dir,
375	struct xarray *xarray,
376	struct page **pages, size_t npages)
377	{
378	size_t size = 0;
379	int i;
380
381	for (i = 0; i < npages; i++) {
382	void *x = xa_store(xarray, i, pages[i], GFP_KERNEL);
383
384	KUNIT_ASSERT_FALSE(test, xa_is_err(x));
385	size += PAGE_SIZE;
386	}
387	iov_iter_xarray(iter, dir, xarray, 0, size);
388	}
389
390	static struct xarray iov_kunit_create_xarray(struct kunit test)
391	{
392	struct xarray *xarray;
393
394	xarray = kzalloc(sizeof(struct xarray), GFP_KERNEL);
395	xa_init(xarray);
396	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xarray);
397	kunit_add_action_or_reset(test, iov_kunit_destroy_xarray, xarray);
398	return xarray;
399	}
400
401	/*
402	* Test copying to a ITER_XARRAY-type iterator.
403	*/
404	static void __init iov_kunit_copy_to_xarray(struct kunit *test)
405	{
406	const struct kvec_test_range *pr;
407	struct iov_iter iter;
408	struct xarray *xarray;
409	struct page spages, bpages;
410	u8 scratch, buffer;
411	size_t bufsize, npages, size, copied;
412	int i, patt;
413
414	bufsize = 0x100000;
415	npages = bufsize / PAGE_SIZE;
416
417	xarray = iov_kunit_create_xarray(test);
418
419	scratch = iov_kunit_create_buffer(test, &spages, npages);
420	for (i = 0; i < bufsize; i++)
421	scratch[i] = pattern(i);
422
423	buffer = iov_kunit_create_buffer(test, &bpages, npages);
424	memset(buffer, 0, bufsize);
425
426	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
427
428	i = 0;
429	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
430	size = pr->to - pr->from;
431	KUNIT_ASSERT_LE(test, pr->to, bufsize);
432
433	iov_iter_xarray(&iter, READ, xarray, pr->from, size);
434	copied = copy_to_iter(scratch + i, size, &iter);
435
436	KUNIT_EXPECT_EQ(test, copied, size);
437	KUNIT_EXPECT_EQ(test, iter.count, 0);
438	KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
439	i += size;
440	}
441
442	/* Build the expected image in the scratch buffer. */
443	patt = 0;
444	memset(scratch, 0, bufsize);
445	for (pr = kvec_test_ranges; pr->from >= 0; pr++)
446	for (i = pr->from; i < pr->to; i++)
447	scratch[i] = pattern(patt++);
448
449	/* Compare the images */
450	for (i = 0; i < bufsize; i++) {
451	KUNIT_EXPECT_EQ_MSG(test, buffer[i], scratch[i], "at i=%x", i);
452	if (buffer[i] != scratch[i])
453	return;
454	}
455
456	KUNIT_SUCCEED();
457	}
458
459	/*
460	* Test copying from a ITER_XARRAY-type iterator.
461	*/
462	static void __init iov_kunit_copy_from_xarray(struct kunit *test)
463	{
464	const struct kvec_test_range *pr;
465	struct iov_iter iter;
466	struct xarray *xarray;
467	struct page spages, bpages;
468	u8 scratch, buffer;
469	size_t bufsize, npages, size, copied;
470	int i, j;
471
472	bufsize = 0x100000;
473	npages = bufsize / PAGE_SIZE;
474
475	xarray = iov_kunit_create_xarray(test);
476
477	buffer = iov_kunit_create_buffer(test, &bpages, npages);
478	for (i = 0; i < bufsize; i++)
479	buffer[i] = pattern(i);
480
481	scratch = iov_kunit_create_buffer(test, &spages, npages);
482	memset(scratch, 0, bufsize);
483
484	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
485
486	i = 0;
487	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
488	size = pr->to - pr->from;
489	KUNIT_ASSERT_LE(test, pr->to, bufsize);
490
491	iov_iter_xarray(&iter, WRITE, xarray, pr->from, size);
492	copied = copy_from_iter(scratch + i, size, &iter);
493
494	KUNIT_EXPECT_EQ(test, copied, size);
495	KUNIT_EXPECT_EQ(test, iter.count, 0);
496	KUNIT_EXPECT_EQ(test, iter.iov_offset, size);
497	i += size;
498	}
499
500	/* Build the expected image in the main buffer. */
501	i = 0;
502	memset(buffer, 0, bufsize);
503	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
504	for (j = pr->from; j < pr->to; j++) {
505	buffer[i++] = pattern(j);
506	if (i >= bufsize)
507	goto stop;
508	}
509	}
510	stop:
511
512	/* Compare the images */
513	for (i = 0; i < bufsize; i++) {
514	KUNIT_EXPECT_EQ_MSG(test, scratch[i], buffer[i], "at i=%x", i);
515	if (scratch[i] != buffer[i])
516	return;
517	}
518
519	KUNIT_SUCCEED();
520	}
521
a3c57ab7 DH	522	/*
	523	* Test the extraction of ITER_KVEC-type iterators.
	524	*/
	525	static void __init iov_kunit_extract_pages_kvec(struct kunit *test)
	526	{
	527	const struct kvec_test_range *pr;
	528	struct iov_iter iter;
	529	struct page *bpages, pagelist[8], **pages = pagelist;
	530	struct kvec kvec[8];
	531	u8 *buffer;
	532	ssize_t len;
	533	size_t bufsize, size = 0, npages;
	534	int i, from;
	535
	536	bufsize = 0x100000;
	537	npages = bufsize / PAGE_SIZE;
	538
	539	buffer = iov_kunit_create_buffer(test, &bpages, npages);
	540
	541	iov_kunit_load_kvec(test, &iter, READ, kvec, ARRAY_SIZE(kvec),
	542	buffer, bufsize, kvec_test_ranges);
	543	size = iter.count;
	544
	545	pr = kvec_test_ranges;
	546	from = pr->from;
	547	do {
	548	size_t offset0 = LONG_MAX;
	549
	550	for (i = 0; i < ARRAY_SIZE(pagelist); i++)
	551	pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
	552
	553	len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
	554	ARRAY_SIZE(pagelist), 0, &offset0);
	555	KUNIT_EXPECT_GE(test, len, 0);
	556	if (len < 0)
	557	break;
	558	KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
	559	KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
	560	KUNIT_EXPECT_LE(test, len, size);
	561	KUNIT_EXPECT_EQ(test, iter.count, size - len);
	562	size -= len;
	563
	564	if (len == 0)
	565	break;
	566
	567	for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
	568	struct page *p;
	569	ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
	570	int ix;
	571
	572	KUNIT_ASSERT_GE(test, part, 0);
	573	while (from == pr->to) {
	574	pr++;
	575	from = pr->from;
	576	if (from < 0)
	577	goto stop;
	578	}
	579	ix = from / PAGE_SIZE;
	580	KUNIT_ASSERT_LT(test, ix, npages);
	581	p = bpages[ix];
	582	KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
	583	KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
	584	from += part;
	585	len -= part;
586	KUNIT_ASSERT_GE(test, len, 0);
587	if (len == 0)
588	break;
589	offset0 = 0;
590	}
591
592	if (test->status == KUNIT_FAILURE)
593	break;
594	} while (iov_iter_count(&iter) > 0);
595
596	stop:
597	KUNIT_EXPECT_EQ(test, size, 0);
598	KUNIT_EXPECT_EQ(test, iter.count, 0);
599	KUNIT_SUCCEED();
600	}
601
602	/*
603	* Test the extraction of ITER_BVEC-type iterators.
604	*/
605	static void __init iov_kunit_extract_pages_bvec(struct kunit *test)
606	{
607	const struct bvec_test_range *pr;
608	struct iov_iter iter;
609	struct page *bpages, pagelist[8], **pages = pagelist;
610	struct bio_vec bvec[8];
611	ssize_t len;
612	size_t bufsize, size = 0, npages;
613	int i, from;
614
615	bufsize = 0x100000;
616	npages = bufsize / PAGE_SIZE;
617
618	iov_kunit_create_buffer(test, &bpages, npages);
619	iov_kunit_load_bvec(test, &iter, READ, bvec, ARRAY_SIZE(bvec),
620	bpages, npages, bufsize, bvec_test_ranges);
621	size = iter.count;
622
623	pr = bvec_test_ranges;
624	from = pr->from;
625	do {
626	size_t offset0 = LONG_MAX;
627
628	for (i = 0; i < ARRAY_SIZE(pagelist); i++)
629	pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
630
631	len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
632	ARRAY_SIZE(pagelist), 0, &offset0);
633	KUNIT_EXPECT_GE(test, len, 0);
634	if (len < 0)
635	break;
636	KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
637	KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
638	KUNIT_EXPECT_LE(test, len, size);
639	KUNIT_EXPECT_EQ(test, iter.count, size - len);
640	size -= len;
641
642	if (len == 0)
643	break;
644
645	for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
646	struct page *p;
647	ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
648	int ix;
649
650	KUNIT_ASSERT_GE(test, part, 0);
651	while (from == pr->to) {
652	pr++;
653	from = pr->from;
654	if (from < 0)
655	goto stop;
656	}
657	ix = pr->page + from / PAGE_SIZE;
658	KUNIT_ASSERT_LT(test, ix, npages);
659	p = bpages[ix];
660	KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
661	KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
662	from += part;
663	len -= part;
664	KUNIT_ASSERT_GE(test, len, 0);
665	if (len == 0)
666	break;
667	offset0 = 0;
668	}
669
670	if (test->status == KUNIT_FAILURE)
671	break;
672	} while (iov_iter_count(&iter) > 0);
673
674	stop:
675	KUNIT_EXPECT_EQ(test, size, 0);
676	KUNIT_EXPECT_EQ(test, iter.count, 0);
677	KUNIT_SUCCEED();
678	}
679
680	/*
681	* Test the extraction of ITER_XARRAY-type iterators.
682	*/
683	static void __init iov_kunit_extract_pages_xarray(struct kunit *test)
684	{
685	const struct kvec_test_range *pr;
686	struct iov_iter iter;
687	struct xarray *xarray;
688	struct page *bpages, pagelist[8], **pages = pagelist;
689	ssize_t len;
690	size_t bufsize, size = 0, npages;
691	int i, from;
692
693	bufsize = 0x100000;
694	npages = bufsize / PAGE_SIZE;
695
696	xarray = iov_kunit_create_xarray(test);
697
698	iov_kunit_create_buffer(test, &bpages, npages);
699	iov_kunit_load_xarray(test, &iter, READ, xarray, bpages, npages);
700
701	for (pr = kvec_test_ranges; pr->from >= 0; pr++) {
702	from = pr->from;
703	size = pr->to - from;
704	KUNIT_ASSERT_LE(test, pr->to, bufsize);
705
706	iov_iter_xarray(&iter, WRITE, xarray, from, size);
707
708	do {
709	size_t offset0 = LONG_MAX;
710
711	for (i = 0; i < ARRAY_SIZE(pagelist); i++)
712	pagelist[i] = (void *)(unsigned long)0xaa55aa55aa55aa55ULL;
713
714	len = iov_iter_extract_pages(&iter, &pages, 100 * 1024,
715	ARRAY_SIZE(pagelist), 0, &offset0);
716	KUNIT_EXPECT_GE(test, len, 0);
717	if (len < 0)
718	break;
719	KUNIT_EXPECT_LE(test, len, size);
720	KUNIT_EXPECT_EQ(test, iter.count, size - len);
721	if (len == 0)
722	break;
723	size -= len;
724	KUNIT_EXPECT_GE(test, (ssize_t)offset0, 0);
725	KUNIT_EXPECT_LT(test, offset0, PAGE_SIZE);
726
727	for (i = 0; i < ARRAY_SIZE(pagelist); i++) {
728	struct page *p;
729	ssize_t part = min_t(ssize_t, len, PAGE_SIZE - offset0);
730	int ix;
731
732	KUNIT_ASSERT_GE(test, part, 0);
733	ix = from / PAGE_SIZE;
734	KUNIT_ASSERT_LT(test, ix, npages);
735	p = bpages[ix];
736	KUNIT_EXPECT_PTR_EQ(test, pagelist[i], p);
737	KUNIT_EXPECT_EQ(test, offset0, from % PAGE_SIZE);
738	from += part;
739	len -= part;
740	KUNIT_ASSERT_GE(test, len, 0);
741	if (len == 0)
742	break;
743	offset0 = 0;
744	}
745
746	if (test->status == KUNIT_FAILURE)
747	goto stop;
748	} while (iov_iter_count(&iter) > 0);
749
750	KUNIT_EXPECT_EQ(test, size, 0);
751	KUNIT_EXPECT_EQ(test, iter.count, 0);
752	KUNIT_EXPECT_EQ(test, iter.iov_offset, pr->to - pr->from);
753	}
754
755	stop:
756	KUNIT_SUCCEED();
757	}
758
2d71340f DH	759	static struct kunit_case __refdata iov_kunit_cases[] = {
	760	KUNIT_CASE(iov_kunit_copy_to_kvec),
	761	KUNIT_CASE(iov_kunit_copy_from_kvec),
	762	KUNIT_CASE(iov_kunit_copy_to_bvec),
	763	KUNIT_CASE(iov_kunit_copy_from_bvec),
	764	KUNIT_CASE(iov_kunit_copy_to_xarray),
	765	KUNIT_CASE(iov_kunit_copy_from_xarray),
a3c57ab7 DH	766	KUNIT_CASE(iov_kunit_extract_pages_kvec),
	767	KUNIT_CASE(iov_kunit_extract_pages_bvec),
	768	KUNIT_CASE(iov_kunit_extract_pages_xarray),
2d71340f DH	769	{}
	770	};
	771
	772	static struct kunit_suite iov_kunit_suite = {
	773	.name = "iov_iter",
	774	.test_cases = iov_kunit_cases,
	775	};
	776
	777	kunit_test_suites(&iov_kunit_suite);