[mirror_ubuntu-artful-kernel.git] / drivers / gpu / drm / i915 / selftests / scatterlist.c

/*
 * Copyright © 2016 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <linux/prime_numbers.h>
#include <linux/random.h>

#include "../i915_selftest.h"

#define PFN_BIAS (1 << 10)

struct pfn_table {
	struct sg_table st;
	unsigned long start, end;
};

typedef unsigned int (*npages_fn_t)(unsigned long n,
				    unsigned long count,
				    struct rnd_state *rnd);

static noinline int expect_pfn_sg(struct pfn_table *pt,
				  npages_fn_t npages_fn,
				  struct rnd_state *rnd,
				  const char *who,
				  unsigned long timeout)
{
	struct scatterlist *sg;
	unsigned long pfn, n;

	pfn = pt->start;
	for_each_sg(pt->st.sgl, sg, pt->st.nents, n) {
		struct page *page = sg_page(sg);
		unsigned int npages = npages_fn(n, pt->st.nents, rnd);

		if (page_to_pfn(page) != pfn) {
			pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sg)\n",
			       __func__, who, pfn, page_to_pfn(page));
			return -EINVAL;
		}

		if (sg->length != npages * PAGE_SIZE) {
			pr_err("%s: %s copied wrong sg length, expected size %lu, found %u (using for_each_sg)\n",
			       __func__, who, npages * PAGE_SIZE, sg->length);
			return -EINVAL;
		}

		if (igt_timeout(timeout, "%s timed out\n", who))
			return -EINTR;

		pfn += npages;
	}
	if (pfn != pt->end) {
		pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
		       __func__, who, pt->end, pfn);
		return -EINVAL;
	}

	return 0;
}

static noinline int expect_pfn_sg_page_iter(struct pfn_table *pt,
					    const char *who,
					    unsigned long timeout)
{
	struct sg_page_iter sgiter;
	unsigned long pfn;

	pfn = pt->start;
	for_each_sg_page(pt->st.sgl, &sgiter, pt->st.nents, 0) {
		struct page *page = sg_page_iter_page(&sgiter);

		if (page != pfn_to_page(pfn)) {
			pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sg_page)\n",
			       __func__, who, pfn, page_to_pfn(page));
			return -EINVAL;
		}

		if (igt_timeout(timeout, "%s timed out\n", who))
			return -EINTR;

		pfn++;
	}
	if (pfn != pt->end) {
		pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
		       __func__, who, pt->end, pfn);
		return -EINVAL;
	}

	return 0;
}

static noinline int expect_pfn_sgtiter(struct pfn_table *pt,
				       const char *who,
				       unsigned long timeout)
{
	struct sgt_iter sgt;
	struct page *page;
	unsigned long pfn;

	pfn = pt->start;
	for_each_sgt_page(page, sgt, &pt->st) {
		if (page != pfn_to_page(pfn)) {
			pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sgt_page)\n",
			       __func__, who, pfn, page_to_pfn(page));
			return -EINVAL;
		}

		if (igt_timeout(timeout, "%s timed out\n", who))
			return -EINTR;

		pfn++;
	}
	if (pfn != pt->end) {
		pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
		       __func__, who, pt->end, pfn);
		return -EINVAL;
	}

	return 0;
}

static int expect_pfn_sgtable(struct pfn_table *pt,
			      npages_fn_t npages_fn,
			      struct rnd_state *rnd,
			      const char *who,
			      unsigned long timeout)
{
	int err;

	err = expect_pfn_sg(pt, npages_fn, rnd, who, timeout);
	if (err)
		return err;

	err = expect_pfn_sg_page_iter(pt, who, timeout);
	if (err)
		return err;

	err = expect_pfn_sgtiter(pt, who, timeout);
	if (err)
		return err;

	return 0;
}

static unsigned int one(unsigned long n,
			unsigned long count,
			struct rnd_state *rnd)
{
	return 1;
}

static unsigned int grow(unsigned long n,
			 unsigned long count,
			 struct rnd_state *rnd)
{
	return n + 1;
}

static unsigned int shrink(unsigned long n,
			   unsigned long count,
			   struct rnd_state *rnd)
{
	return count - n;
}

static unsigned int random(unsigned long n,
			   unsigned long count,
			   struct rnd_state *rnd)
{
	return 1 + (prandom_u32_state(rnd) % 1024);
}

static inline bool page_contiguous(struct page *first,
				   struct page *last,
				   unsigned long npages)
{
	return first + npages == last;
}

static int alloc_table(struct pfn_table *pt,
		       unsigned long count, unsigned long max,
		       npages_fn_t npages_fn,
		       struct rnd_state *rnd,
		       int alloc_error)
{
	struct scatterlist *sg;
	unsigned long n, pfn;

	if (sg_alloc_table(&pt->st, max,
			   GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN))
		return alloc_error;

	/* count should be less than 20 to prevent overflowing sg->length */
	GEM_BUG_ON(overflows_type(count * PAGE_SIZE, sg->length));

	/* Construct a table where each scatterlist contains different number
	 * of entries. The idea is to check that we can iterate the individual
	 * pages from inside the coalesced lists.
	 */
	pt->start = PFN_BIAS;
	pfn = pt->start;
	sg = pt->st.sgl;
	for (n = 0; n < count; n++) {
		unsigned long npages = npages_fn(n, count, rnd);

		/* Nobody expects the Sparse Memmap! */
		if (!page_contiguous(pfn_to_page(pfn),
				     pfn_to_page(pfn + npages),
				     npages)) {
			sg_free_table(&pt->st);
			return -ENOSPC;
		}

		if (n)
			sg = sg_next(sg);
		sg_set_page(sg, pfn_to_page(pfn), npages * PAGE_SIZE, 0);

		GEM_BUG_ON(page_to_pfn(sg_page(sg)) != pfn);
		GEM_BUG_ON(sg->length != npages * PAGE_SIZE);
		GEM_BUG_ON(sg->offset != 0);

		pfn += npages;
	}
	sg_mark_end(sg);
	pt->st.nents = n;
	pt->end = pfn;

	return 0;
}

static const npages_fn_t npages_funcs[] = {
	one,
	grow,
	shrink,
	random,
	NULL,
};

static int igt_sg_alloc(void *ignored)
{
	IGT_TIMEOUT(end_time);
	const unsigned long max_order = 20; /* approximating a 4GiB object */
	struct rnd_state prng;
	unsigned long prime;
	int alloc_error = -ENOMEM;

	for_each_prime_number(prime, max_order) {
		unsigned long size = BIT(prime);
		int offset;

		for (offset = -1; offset <= 1; offset++) {
			unsigned long sz = size + offset;
			const npages_fn_t *npages;
			struct pfn_table pt;
			int err;

			for (npages = npages_funcs; *npages; npages++) {
				prandom_seed_state(&prng,
						   i915_selftest.random_seed);
				err = alloc_table(&pt, sz, sz, *npages, &prng,
						  alloc_error);
				if (err == -ENOSPC)
					break;
				if (err)
					return err;

				prandom_seed_state(&prng,
						   i915_selftest.random_seed);
				err = expect_pfn_sgtable(&pt, *npages, &prng,
							 "sg_alloc_table",
							 end_time);
				sg_free_table(&pt.st);
				if (err)
					return err;
			}
		}

		/* Test at least one continuation before accepting oom */
		if (size > SG_MAX_SINGLE_ALLOC)
			alloc_error = -ENOSPC;
	}

	return 0;
}

static int igt_sg_trim(void *ignored)
{
	IGT_TIMEOUT(end_time);
	const unsigned long max = PAGE_SIZE; /* not prime! */
	struct pfn_table pt;
	unsigned long prime;
	int alloc_error = -ENOMEM;

	for_each_prime_number(prime, max) {
		const npages_fn_t *npages;
		int err;

		for (npages = npages_funcs; *npages; npages++) {
			struct rnd_state prng;

			prandom_seed_state(&prng, i915_selftest.random_seed);
			err = alloc_table(&pt, prime, max, *npages, &prng,
					  alloc_error);
			if (err == -ENOSPC)
				break;
			if (err)
				return err;

			if (i915_sg_trim(&pt.st)) {
				if (pt.st.orig_nents != prime ||
				    pt.st.nents != prime) {
					pr_err("i915_sg_trim failed (nents %u, orig_nents %u), expected %lu\n",
					       pt.st.nents, pt.st.orig_nents, prime);
					err = -EINVAL;
				} else {
					prandom_seed_state(&prng,
							   i915_selftest.random_seed);
					err = expect_pfn_sgtable(&pt,
								 *npages, &prng,
								 "i915_sg_trim",
								 end_time);
				}
			}
			sg_free_table(&pt.st);
			if (err)
				return err;
		}

		/* Test at least one continuation before accepting oom */
		if (prime > SG_MAX_SINGLE_ALLOC)
			alloc_error = -ENOSPC;
	}

	return 0;
}

int scatterlist_mock_selftests(void)
{
	static const struct i915_subtest tests[] = {
		SUBTEST(igt_sg_alloc),
		SUBTEST(igt_sg_trim),
	};

	return i915_subtests(tests, NULL);
}
Commit	Line	Data
935a2f77 CW	1	/*
	2	* Copyright © 2016 Intel Corporation
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	21	* IN THE SOFTWARE.
	22	*/
	23
	24	#include <linux/prime_numbers.h>
	25	#include <linux/random.h>
	26
	27	#include "../i915_selftest.h"
	28
	29	#define PFN_BIAS (1 << 10)
	30
	31	struct pfn_table {
	32	struct sg_table st;
	33	unsigned long start, end;
	34	};
	35
	36	typedef unsigned int (*npages_fn_t)(unsigned long n,
	37	unsigned long count,
	38	struct rnd_state *rnd);
	39
	40	static noinline int expect_pfn_sg(struct pfn_table *pt,
	41	npages_fn_t npages_fn,
	42	struct rnd_state *rnd,
	43	const char *who,
	44	unsigned long timeout)
	45	{
	46	struct scatterlist *sg;
	47	unsigned long pfn, n;
	48
	49	pfn = pt->start;
	50	for_each_sg(pt->st.sgl, sg, pt->st.nents, n) {
	51	struct page *page = sg_page(sg);
	52	unsigned int npages = npages_fn(n, pt->st.nents, rnd);
	53
	54	if (page_to_pfn(page) != pfn) {
	55	pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sg)\n",
	56	__func__, who, pfn, page_to_pfn(page));
	57	return -EINVAL;
	58	}
	59
	60	if (sg->length != npages * PAGE_SIZE) {
	61	pr_err("%s: %s copied wrong sg length, expected size %lu, found %u (using for_each_sg)\n",
	62	__func__, who, npages * PAGE_SIZE, sg->length);
	63	return -EINVAL;
	64	}
65
66	if (igt_timeout(timeout, "%s timed out\n", who))
67	return -EINTR;
68
69	pfn += npages;
70	}
71	if (pfn != pt->end) {
72	pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
73	__func__, who, pt->end, pfn);
74	return -EINVAL;
75	}
76
77	return 0;
78	}
79
80	static noinline int expect_pfn_sg_page_iter(struct pfn_table *pt,
81	const char *who,
82	unsigned long timeout)
83	{
84	struct sg_page_iter sgiter;
85	unsigned long pfn;
86
87	pfn = pt->start;
88	for_each_sg_page(pt->st.sgl, &sgiter, pt->st.nents, 0) {
89	struct page *page = sg_page_iter_page(&sgiter);
90
91	if (page != pfn_to_page(pfn)) {
92	pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sg_page)\n",
93	__func__, who, pfn, page_to_pfn(page));
94	return -EINVAL;
95	}
96
97	if (igt_timeout(timeout, "%s timed out\n", who))
98	return -EINTR;
99
100	pfn++;
101	}
102	if (pfn != pt->end) {
103	pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
104	__func__, who, pt->end, pfn);
105	return -EINVAL;
106	}
107
108	return 0;
109	}
110
111	static noinline int expect_pfn_sgtiter(struct pfn_table *pt,
112	const char *who,
113	unsigned long timeout)
114	{
115	struct sgt_iter sgt;
116	struct page *page;
117	unsigned long pfn;
118
119	pfn = pt->start;
120	for_each_sgt_page(page, sgt, &pt->st) {
121	if (page != pfn_to_page(pfn)) {
122	pr_err("%s: %s left pages out of order, expected pfn %lu, found pfn %lu (using for_each_sgt_page)\n",
123	__func__, who, pfn, page_to_pfn(page));
124	return -EINVAL;
125	}
126
127	if (igt_timeout(timeout, "%s timed out\n", who))
128	return -EINTR;
129
130	pfn++;
131	}
132	if (pfn != pt->end) {
133	pr_err("%s: %s finished on wrong pfn, expected %lu, found %lu\n",
134	__func__, who, pt->end, pfn);
135	return -EINVAL;
136	}
137
138	return 0;
139	}
140
141	static int expect_pfn_sgtable(struct pfn_table *pt,
142	npages_fn_t npages_fn,
143	struct rnd_state *rnd,
144	const char *who,
145	unsigned long timeout)
146	{
147	int err;
148
149	err = expect_pfn_sg(pt, npages_fn, rnd, who, timeout);
150	if (err)
151	return err;
152
153	err = expect_pfn_sg_page_iter(pt, who, timeout);
154	if (err)
155	return err;
156
157	err = expect_pfn_sgtiter(pt, who, timeout);
158	if (err)
159	return err;
160
161	return 0;
162	}
163
164	static unsigned int one(unsigned long n,
165	unsigned long count,
166	struct rnd_state *rnd)
167	{
168	return 1;
169	}
170
171	static unsigned int grow(unsigned long n,
172	unsigned long count,
173	struct rnd_state *rnd)
174	{
175	return n + 1;
176	}
177
178	static unsigned int shrink(unsigned long n,
179	unsigned long count,
180	struct rnd_state *rnd)
181	{
182	return count - n;
183	}
184
185	static unsigned int random(unsigned long n,
186	unsigned long count,
187	struct rnd_state *rnd)
188	{
189	return 1 + (prandom_u32_state(rnd) % 1024);
190	}
191
272bce17 AB	192	static inline bool page_contiguous(struct page *first,
	193	struct page *last,
	194	unsigned long npages)
	195	{
	196	return first + npages == last;
	197	}
	198
935a2f77 CW	199	static int alloc_table(struct pfn_table *pt,
	200	unsigned long count, unsigned long max,
	201	npages_fn_t npages_fn,
	202	struct rnd_state *rnd,
	203	int alloc_error)
	204	{
	205	struct scatterlist *sg;
	206	unsigned long n, pfn;
	207
	208	if (sg_alloc_table(&pt->st, max,
	209	GFP_KERNEL \| __GFP_NORETRY \| __GFP_NOWARN))
	210	return alloc_error;
	211
	212	/* count should be less than 20 to prevent overflowing sg->length */
	213	GEM_BUG_ON(overflows_type(count * PAGE_SIZE, sg->length));
	214
	215	/* Construct a table where each scatterlist contains different number
	216	* of entries. The idea is to check that we can iterate the individual
	217	* pages from inside the coalesced lists.
	218	*/
	219	pt->start = PFN_BIAS;
	220	pfn = pt->start;
	221	sg = pt->st.sgl;
	222	for (n = 0; n < count; n++) {
	223	unsigned long npages = npages_fn(n, count, rnd);
	224
	225	/* Nobody expects the Sparse Memmap! */
272bce17 AB	226	if (!page_contiguous(pfn_to_page(pfn),
	227	pfn_to_page(pfn + npages),
	228	npages)) {
935a2f77 CW	229	sg_free_table(&pt->st);
	230	return -ENOSPC;
	231	}
	232
	233	if (n)
	234	sg = sg_next(sg);
	235	sg_set_page(sg, pfn_to_page(pfn), npages * PAGE_SIZE, 0);
	236
	237	GEM_BUG_ON(page_to_pfn(sg_page(sg)) != pfn);
	238	GEM_BUG_ON(sg->length != npages * PAGE_SIZE);
	239	GEM_BUG_ON(sg->offset != 0);
	240
	241	pfn += npages;
	242	}
	243	sg_mark_end(sg);
	244	pt->st.nents = n;
	245	pt->end = pfn;
	246
	247	return 0;
	248	}
	249
	250	static const npages_fn_t npages_funcs[] = {
	251	one,
	252	grow,
	253	shrink,
	254	random,
	255	NULL,
	256	};
	257
	258	static int igt_sg_alloc(void *ignored)
	259	{
	260	IGT_TIMEOUT(end_time);
	261	const unsigned long max_order = 20; /* approximating a 4GiB object */
	262	struct rnd_state prng;
	263	unsigned long prime;
	264	int alloc_error = -ENOMEM;
	265
	266	for_each_prime_number(prime, max_order) {
	267	unsigned long size = BIT(prime);
	268	int offset;
	269
	270	for (offset = -1; offset <= 1; offset++) {
	271	unsigned long sz = size + offset;
	272	const npages_fn_t *npages;
	273	struct pfn_table pt;
	274	int err;
	275
	276	for (npages = npages_funcs; *npages; npages++) {
	277	prandom_seed_state(&prng,
	278	i915_selftest.random_seed);
	279	err = alloc_table(&pt, sz, sz, *npages, &prng,
	280	alloc_error);
	281	if (err == -ENOSPC)
	282	break;
	283	if (err)
	284	return err;
	285
	286	prandom_seed_state(&prng,
	287	i915_selftest.random_seed);
	288	err = expect_pfn_sgtable(&pt, *npages, &prng,
	289	"sg_alloc_table",
	290	end_time);
	291	sg_free_table(&pt.st);
	292	if (err)
293	return err;
294	}
295	}
296
297	/* Test at least one continuation before accepting oom */
298	if (size > SG_MAX_SINGLE_ALLOC)
299	alloc_error = -ENOSPC;
300	}
301
302	return 0;
303	}
304
305	static int igt_sg_trim(void *ignored)
306	{
307	IGT_TIMEOUT(end_time);
308	const unsigned long max = PAGE_SIZE; /* not prime! */
309	struct pfn_table pt;
310	unsigned long prime;
311	int alloc_error = -ENOMEM;
312
313	for_each_prime_number(prime, max) {
314	const npages_fn_t *npages;
315	int err;
316
317	for (npages = npages_funcs; *npages; npages++) {
318	struct rnd_state prng;
319
320	prandom_seed_state(&prng, i915_selftest.random_seed);
321	err = alloc_table(&pt, prime, max, *npages, &prng,
322	alloc_error);
323	if (err == -ENOSPC)
324	break;
325	if (err)
326	return err;
327
328	if (i915_sg_trim(&pt.st)) {
329	if (pt.st.orig_nents != prime \|\|
330	pt.st.nents != prime) {
331	pr_err("i915_sg_trim failed (nents %u, orig_nents %u), expected %lu\n",
332	pt.st.nents, pt.st.orig_nents, prime);
333	err = -EINVAL;
334	} else {
335	prandom_seed_state(&prng,
336	i915_selftest.random_seed);
337	err = expect_pfn_sgtable(&pt,
338	*npages, &prng,
339	"i915_sg_trim",
340	end_time);
341	}
342	}
343	sg_free_table(&pt.st);
344	if (err)
345	return err;
346	}
347
348	/* Test at least one continuation before accepting oom */
349	if (prime > SG_MAX_SINGLE_ALLOC)
350	alloc_error = -ENOSPC;
351	}
352
353	return 0;
354	}
355
356	int scatterlist_mock_selftests(void)
357	{
358	static const struct i915_subtest tests[] = {
359	SUBTEST(igt_sg_alloc),
360	SUBTEST(igt_sg_trim),
361	};
362
363	return i915_subtests(tests, NULL);
364	}