Commit b6560007 authored by Chris Wilson's avatar Chris Wilson
Browse files

drm/i915/selftests: Drop live_preempt_hang 



live_preempt_hang's use of hang injection has been superseded by
live_preempt_reset's use of an non-preemptible spinner. The latter does
not require intrusive hacks into the code.

Signed-off-by: default avatarChris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: default avatarMika Kuoppala <mika.kuoppala@linux.intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200209230838.361154-2-chris@chris-wilson.co.uk
parent 3ce291a6

drivers/gpu/drm/i915/gt/intel_engine.h

+0 −20
Original line number Diff line number Diff line
@@ -305,26 +305,6 @@ intel_engine_find_active_request(struct intel_engine_cs *engine); 


u32 intel_engine_context_size(struct intel_gt *gt, u8 class);



#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)



static inline bool inject_preempt_hang(struct intel_engine_execlists *execlists)

{

	if (!execlists->preempt_hang.inject_hang)

		return false;



	complete(&execlists->preempt_hang.completion);

	return true;

}



#else



static inline bool inject_preempt_hang(struct intel_engine_execlists *execlists)

{

	return false;

}



#endif



void intel_engine_init_active(struct intel_engine_cs *engine,

			      unsigned int subclass);

#define ENGINE_PHYSICAL	0

drivers/gpu/drm/i915/gt/intel_engine_types.h

+0 −1
Original line number Diff line number Diff line
@@ -127,7 +127,6 @@ DECLARE_EWMA(_engine_latency, 6, 4) 
struct st_preempt_hang {

	struct completion completion;

	unsigned int count;

	bool inject_hang;

};



/**

drivers/gpu/drm/i915/gt/intel_lrc.c

+4 −4
Original line number Diff line number Diff line
@@ -2296,19 +2296,19 @@ static void process_csb(struct intel_engine_cs *engine) 
		if (promote) {

			struct i915_request * const *old = execlists->active;



			/* Point active to the new ELSP; prevent overwriting */

			WRITE_ONCE(execlists->active, execlists->pending);

			GEM_BUG_ON(!assert_pending_valid(execlists, "promote"));



			if (!inject_preempt_hang(execlists))

			ring_set_paused(engine, 0);



			/* Point active to the new ELSP; prevent overwriting */

			WRITE_ONCE(execlists->active, execlists->pending);



			/* cancel old inflight, prepare for switch */

			trace_ports(execlists, "preempted", old);

			while (*old)

				execlists_schedule_out(*old++);



			/* switch pending to inflight */

			GEM_BUG_ON(!assert_pending_valid(execlists, "promote"));

			WRITE_ONCE(execlists->active,

				   memcpy(execlists->inflight,

					  execlists->pending,

drivers/gpu/drm/i915/gt/selftest_lrc.c

+0 −122
Original line number Diff line number Diff line
@@ -2431,127 +2431,6 @@ static int live_preempt_gang(void *arg) 
	return 0;

}



static int live_preempt_hang(void *arg)

{

	struct intel_gt *gt = arg;

	struct i915_gem_context *ctx_hi, *ctx_lo;

	struct igt_spinner spin_hi, spin_lo;

	struct intel_engine_cs *engine;

	enum intel_engine_id id;

	int err = -ENOMEM;



	if (!HAS_LOGICAL_RING_PREEMPTION(gt->i915))

		return 0;



	if (!intel_has_reset_engine(gt))

		return 0;



	if (igt_spinner_init(&spin_hi, gt))

		return -ENOMEM;



	if (igt_spinner_init(&spin_lo, gt))

		goto err_spin_hi;



	ctx_hi = kernel_context(gt->i915);

	if (!ctx_hi)

		goto err_spin_lo;

	ctx_hi->sched.priority =

		I915_USER_PRIORITY(I915_CONTEXT_MAX_USER_PRIORITY);



	ctx_lo = kernel_context(gt->i915);

	if (!ctx_lo)

		goto err_ctx_hi;

	ctx_lo->sched.priority =

		I915_USER_PRIORITY(I915_CONTEXT_MIN_USER_PRIORITY);



	for_each_engine(engine, gt, id) {

		unsigned long heartbeat;

		struct i915_request *rq;



		if (!intel_engine_has_preemption(engine))

			continue;



		engine_heartbeat_disable(engine, &heartbeat);



		rq = spinner_create_request(&spin_lo, ctx_lo, engine,

					    MI_ARB_CHECK);

		if (IS_ERR(rq)) {

			err = PTR_ERR(rq);

			engine_heartbeat_enable(engine, heartbeat);

			goto err_ctx_lo;

		}



		i915_request_add(rq);

		if (!igt_wait_for_spinner(&spin_lo, rq)) {

			GEM_TRACE("lo spinner failed to start\n");

			GEM_TRACE_DUMP();

			intel_gt_set_wedged(gt);

			err = -EIO;

			engine_heartbeat_enable(engine, heartbeat);

			goto err_ctx_lo;

		}



		rq = spinner_create_request(&spin_hi, ctx_hi, engine,

					    MI_ARB_CHECK);

		if (IS_ERR(rq)) {

			igt_spinner_end(&spin_lo);

			engine_heartbeat_enable(engine, heartbeat);

			err = PTR_ERR(rq);

			goto err_ctx_lo;

		}



		init_completion(&engine->execlists.preempt_hang.completion);

		engine->execlists.preempt_hang.inject_hang = true;



		i915_request_add(rq);



		if (!wait_for_completion_timeout(&engine->execlists.preempt_hang.completion,

						 HZ / 10)) {

			pr_err("Preemption did not occur within timeout!");

			GEM_TRACE_DUMP();

			intel_gt_set_wedged(gt);

			engine_heartbeat_enable(engine, heartbeat);

			err = -EIO;

			goto err_ctx_lo;

		}



		set_bit(I915_RESET_ENGINE + id, &gt->reset.flags);

		intel_engine_reset(engine, NULL);

		clear_bit(I915_RESET_ENGINE + id, &gt->reset.flags);



		engine->execlists.preempt_hang.inject_hang = false;



		if (!igt_wait_for_spinner(&spin_hi, rq)) {

			GEM_TRACE("hi spinner failed to start\n");

			GEM_TRACE_DUMP();

			intel_gt_set_wedged(gt);

			engine_heartbeat_enable(engine, heartbeat);

			err = -EIO;

			goto err_ctx_lo;

		}



		igt_spinner_end(&spin_hi);

		igt_spinner_end(&spin_lo);

		engine_heartbeat_enable(engine, heartbeat);



		if (igt_flush_test(gt->i915)) {

			err = -EIO;

			goto err_ctx_lo;

		}

	}



	err = 0;

err_ctx_lo:

	kernel_context_close(ctx_lo);

err_ctx_hi:

	kernel_context_close(ctx_hi);

err_spin_lo:

	igt_spinner_fini(&spin_lo);

err_spin_hi:

	igt_spinner_fini(&spin_hi);

	return err;

}



static int live_preempt_timeout(void *arg)

{

	struct intel_gt *gt = arg;
@@ -3750,7 +3629,6 @@ int intel_execlists_live_selftests(struct drm_i915_private *i915) 
		SUBTEST(live_suppress_wait_preempt),

		SUBTEST(live_chain_preempt),

		SUBTEST(live_preempt_gang),

		SUBTEST(live_preempt_hang),

		SUBTEST(live_preempt_timeout),

		SUBTEST(live_preempt_smoke),

		SUBTEST(live_virtual_engine),

CRA Git | Maintained and supported by SUSTech CRA and CCSE