drm/i915: Test request ordering between engines

	return err;

}

static int live_sequential_engines(void *arg)

{

	struct drm_i915_private *i915 = arg;

	struct drm_i915_gem_request *request[I915_NUM_ENGINES] = {};

	struct drm_i915_gem_request *prev = NULL;

	struct intel_engine_cs *engine;

	struct live_test t;

	unsigned int id;

	int err;

	/* Check we can submit requests to all engines sequentially, such

	 * that each successive request waits for the earlier ones. This

	 * tests that we don't execute requests out of order, even though

	 * they are running on independent engines.

	 */

	mutex_lock(&i915->drm.struct_mutex);

	err = begin_live_test(&t, i915, __func__, "");

	if (err)

		goto out_unlock;

	for_each_engine(engine, i915, id) {

		struct i915_vma *batch;

		batch = recursive_batch(i915);

		if (IS_ERR(batch)) {

			err = PTR_ERR(batch);

			pr_err("%s: Unable to create batch for %s, err=%d\n",

			       __func__, engine->name, err);

			goto out_unlock;

		}

		request[id] = i915_gem_request_alloc(engine,

						     i915->kernel_context);

		if (IS_ERR(request[id])) {

			err = PTR_ERR(request[id]);

			pr_err("%s: Request allocation failed for %s with err=%d\n",

			       __func__, engine->name, err);

			goto out_request;

		}

		if (prev) {

			err = i915_gem_request_await_dma_fence(request[id],

							       &prev->fence);

			if (err) {

				i915_add_request(request[id]);

				pr_err("%s: Request await failed for %s with err=%d\n",

				       __func__, engine->name, err);

				goto out_request;

			}

		}

		err = engine->emit_flush(request[id], EMIT_INVALIDATE);

		GEM_BUG_ON(err);

		err = i915_switch_context(request[id]);

		GEM_BUG_ON(err);

		err = engine->emit_bb_start(request[id],

					    batch->node.start,

					    batch->node.size,

					    0);

		GEM_BUG_ON(err);

		request[id]->batch = batch;

		i915_vma_move_to_active(batch, request[id], 0);

		i915_gem_object_set_active_reference(batch->obj);

		i915_vma_get(batch);

		i915_gem_request_get(request[id]);

		i915_add_request(request[id]);

		prev = request[id];

	}

	for_each_engine(engine, i915, id) {

		long timeout;

		if (i915_gem_request_completed(request[id])) {

			pr_err("%s(%s): request completed too early!\n",

			       __func__, engine->name);

			err = -EINVAL;

			goto out_request;

		}

		err = recursive_batch_resolve(request[id]->batch);

		if (err) {

			pr_err("%s: failed to resolve batch, err=%d\n",

			       __func__, err);

			goto out_request;

		}

		timeout = i915_wait_request(request[id],

					    I915_WAIT_LOCKED,

					    MAX_SCHEDULE_TIMEOUT);

		if (timeout < 0) {

			err = timeout;

			pr_err("%s: error waiting for request on %s, err=%d\n",

			       __func__, engine->name, err);

			goto out_request;

		}

		GEM_BUG_ON(!i915_gem_request_completed(request[id]));

	}

	err = end_live_test(&t);

out_request:

	for_each_engine(engine, i915, id) {

		u32 *cmd;

		if (!request[id])

			break;

		cmd = i915_gem_object_pin_map(request[id]->batch->obj,

					      I915_MAP_WC);

		if (!IS_ERR(cmd)) {

			*cmd = MI_BATCH_BUFFER_END;

			wmb();

			i915_gem_object_unpin_map(request[id]->batch->obj);

		}

		i915_vma_put(request[id]->batch);

		i915_gem_request_put(request[id]);

	}

out_unlock:

	mutex_unlock(&i915->drm.struct_mutex);

	return err;

}

int i915_gem_request_live_selftests(struct drm_i915_private *i915)

{

	static const struct i915_subtest tests[] = {

		SUBTEST(live_nop_request),

		SUBTEST(live_all_engines),

		SUBTEST(live_sequential_engines),

	};

	return i915_subtests(tests, i915);

}