Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 782a3e9e authored by Chris Wilson's avatar Chris Wilson
Browse files

drm/i915: Exercise i915_vma_pin/i915_vma_insert 



High-level testing of the struct drm_mm by verifying our handling of
weird requests to i915_vma_pin.

Signed-off-by: default avatarChris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: default avatarJoonas Lahtinen <joonas.lahtinen@linux.intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20170213171558.20942-35-chris@chris-wilson.co.uk
parent e3c7a1c5

drivers/gpu/drm/i915/i915_vma.c

+2 −2
Original line number Diff line number Diff line
@@ -327,8 +327,8 @@ void i915_vma_unpin_and_release(struct i915_vma **p_vma) 
	__i915_gem_object_release_unless_active(obj);

}



bool

i915_vma_misplaced(struct i915_vma *vma, u64 size, u64 alignment, u64 flags)

bool i915_vma_misplaced(const struct i915_vma *vma,

			u64 size, u64 alignment, u64 flags)

{

	if (!drm_mm_node_allocated(&vma->node))

		return false;

drivers/gpu/drm/i915/i915_vma.h

+2 −2
Original line number Diff line number Diff line
@@ -228,8 +228,8 @@ i915_vma_compare(struct i915_vma *vma, 
int i915_vma_bind(struct i915_vma *vma, enum i915_cache_level cache_level,

		  u32 flags);

bool i915_gem_valid_gtt_space(struct i915_vma *vma, unsigned long cache_level);

bool

i915_vma_misplaced(struct i915_vma *vma, u64 size, u64 alignment, u64 flags);

bool i915_vma_misplaced(const struct i915_vma *vma,

			u64 size, u64 alignment, u64 flags);

void __i915_vma_set_map_and_fenceable(struct i915_vma *vma);

int __must_check i915_vma_unbind(struct i915_vma *vma);

void i915_vma_close(struct i915_vma *vma);

drivers/gpu/drm/i915/selftests/i915_vma.c

+151 −0
Original line number Diff line number Diff line
@@ -202,10 +202,161 @@ static int igt_vma_create(void *arg) 
	return err;

}



struct pin_mode {

	u64 size;

	u64 flags;

	bool (*assert)(const struct i915_vma *,

		       const struct pin_mode *mode,

		       int result);

	const char *string;

};



static bool assert_pin_valid(const struct i915_vma *vma,

			     const struct pin_mode *mode,

			     int result)

{

	if (result)

		return false;



	if (i915_vma_misplaced(vma, mode->size, 0, mode->flags))

		return false;



	return true;

}



__maybe_unused

static bool assert_pin_e2big(const struct i915_vma *vma,

			     const struct pin_mode *mode,

			     int result)

{

	return result == -E2BIG;

}



__maybe_unused

static bool assert_pin_enospc(const struct i915_vma *vma,

			      const struct pin_mode *mode,

			      int result)

{

	return result == -ENOSPC;

}



__maybe_unused

static bool assert_pin_einval(const struct i915_vma *vma,

			      const struct pin_mode *mode,

			      int result)

{

	return result == -EINVAL;

}



static int igt_vma_pin1(void *arg)

{

	struct drm_i915_private *i915 = arg;

	const struct pin_mode modes[] = {

#define VALID(sz, fl) { .size = (sz), .flags = (fl), .assert = assert_pin_valid, .string = #sz ", " #fl ", (valid) " }

#define __INVALID(sz, fl, check, eval) { .size = (sz), .flags = (fl), .assert = (check), .string = #sz ", " #fl ", (invalid " #eval ")" }

#define INVALID(sz, fl) __INVALID(sz, fl, assert_pin_einval, EINVAL)

#define TOOBIG(sz, fl) __INVALID(sz, fl, assert_pin_e2big, E2BIG)

#define NOSPACE(sz, fl) __INVALID(sz, fl, assert_pin_enospc, ENOSPC)

		VALID(0, PIN_GLOBAL),

		VALID(0, PIN_GLOBAL | PIN_MAPPABLE),



		VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 4096),

		VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 8192),

		VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),

		VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),

		VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.base.total - 4096)),



		VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (i915->ggtt.mappable_end - 4096)),

		INVALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | i915->ggtt.mappable_end),

		VALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | (i915->ggtt.base.total - 4096)),

		INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | i915->ggtt.base.total),

		INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | round_down(U64_MAX, PAGE_SIZE)),



		VALID(4096, PIN_GLOBAL),

		VALID(8192, PIN_GLOBAL),

		VALID(i915->ggtt.mappable_end - 4096, PIN_GLOBAL | PIN_MAPPABLE),

		VALID(i915->ggtt.mappable_end, PIN_GLOBAL | PIN_MAPPABLE),

		TOOBIG(i915->ggtt.mappable_end + 4096, PIN_GLOBAL | PIN_MAPPABLE),

		VALID(i915->ggtt.base.total - 4096, PIN_GLOBAL),

		VALID(i915->ggtt.base.total, PIN_GLOBAL),

		TOOBIG(i915->ggtt.base.total + 4096, PIN_GLOBAL),

		TOOBIG(round_down(U64_MAX, PAGE_SIZE), PIN_GLOBAL),

		INVALID(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (i915->ggtt.mappable_end - 4096)),

		INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (i915->ggtt.base.total - 4096)),

		INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (round_down(U64_MAX, PAGE_SIZE) - 4096)),



		VALID(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),



#if !IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)

		/* Misusing BIAS is a programming error (it is not controllable

		 * from userspace) so when debugging is enabled, it explodes.

		 * However, the tests are still quite interesting for checking

		 * variable start, end and size.

		 */

		NOSPACE(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | i915->ggtt.mappable_end),

		NOSPACE(0, PIN_GLOBAL | PIN_OFFSET_BIAS | i915->ggtt.base.total),

		NOSPACE(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),

		NOSPACE(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.base.total - 4096)),

#endif

		{ },

#undef NOSPACE

#undef TOOBIG

#undef INVALID

#undef __INVALID

#undef VALID

	}, *m;

	struct drm_i915_gem_object *obj;

	struct i915_vma *vma;

	int err = -EINVAL;



	/* Exercise all the weird and wonderful i915_vma_pin requests,

	 * focusing on error handling of boundary conditions.

	 */



	GEM_BUG_ON(!drm_mm_clean(&i915->ggtt.base.mm));



	obj = i915_gem_object_create_internal(i915, PAGE_SIZE);

	if (IS_ERR(obj))

		return PTR_ERR(obj);



	vma = checked_vma_instance(obj, &i915->ggtt.base, NULL);

	if (IS_ERR(vma))

		goto out;



	for (m = modes; m->assert; m++) {

		err = i915_vma_pin(vma, m->size, 0, m->flags);

		if (!m->assert(vma, m, err)) {

			pr_err("%s to pin single page into GGTT with mode[%d:%s]: size=%llx flags=%llx, err=%d\n",

			       m->assert == assert_pin_valid ? "Failed" : "Unexpectedly succeeded",

			       (int)(m - modes), m->string, m->size, m->flags,

			       err);

			if (!err)

				i915_vma_unpin(vma);

			err = -EINVAL;

			goto out;

		}



		if (!err) {

			i915_vma_unpin(vma);

			err = i915_vma_unbind(vma);

			if (err) {

				pr_err("Failed to unbind single page from GGTT, err=%d\n", err);

				goto out;

			}

		}

	}



	err = 0;

out:

	i915_gem_object_put(obj);

	return err;

}



int i915_vma_mock_selftests(void)

{

	static const struct i915_subtest tests[] = {

		SUBTEST(igt_vma_create),

		SUBTEST(igt_vma_pin1),

	};

	struct drm_i915_private *i915;

	int err;