i915_gem_busy.c

  1// SPDX-License-Identifier: MIT
  2/*
  3 * Copyright © 2014-2016 Intel Corporation
  4 */
  5
  6#include <linux/dma-fence-array.h>
  7
  8#include "gt/intel_engine.h"
  9
 10#include "i915_gem_ioctls.h"
 11#include "i915_gem_object.h"
 12
 13static __always_inline u32 __busy_read_flag(u16 id)
 14{
 15	if (id == (u16)I915_ENGINE_CLASS_INVALID)
 16		return 0xffff0000u;
 17
 18	GEM_BUG_ON(id >= 16);
 19	return 0x10000u << id;
 20}
 21
 22static __always_inline u32 __busy_write_id(u16 id)
 23{
 24	/*
 25	 * The uABI guarantees an active writer is also amongst the read
 26	 * engines. This would be true if we accessed the activity tracking
 27	 * under the lock, but as we perform the lookup of the object and
 28	 * its activity locklessly we can not guarantee that the last_write
 29	 * being active implies that we have set the same engine flag from
 30	 * last_read - hence we always set both read and write busy for
 31	 * last_write.
 32	 */
 33	if (id == (u16)I915_ENGINE_CLASS_INVALID)
 34		return 0xffffffffu;
 35
 36	return (id + 1) | __busy_read_flag(id);
 37}
 38
 39static __always_inline unsigned int
 40__busy_set_if_active(struct dma_fence *fence, u32 (*flag)(u16 id))
 41{
 42	const struct i915_request *rq;
 43
 44	/*
 45	 * We have to check the current hw status of the fence as the uABI
 46	 * guarantees forward progress. We could rely on the idle worker
 47	 * to eventually flush us, but to minimise latency just ask the
 48	 * hardware.
 49	 *
 50	 * Note we only report on the status of native fences and we currently
 51	 * have two native fences:
 52	 *
 53	 * 1. A composite fence (dma_fence_array) constructed of i915 requests
 54	 * created during a parallel submission. In this case we deconstruct the
 55	 * composite fence into individual i915 requests and check the status of
 56	 * each request.
 57	 *
 58	 * 2. A single i915 request.
 59	 */
 60	if (dma_fence_is_array(fence)) {
 61		struct dma_fence_array *array = to_dma_fence_array(fence);
 62		struct dma_fence **child = array->fences;
 63		unsigned int nchild = array->num_fences;
 64
 65		do {
 66			struct dma_fence *current_fence = *child++;
 67
 68			/* Not an i915 fence, can't be busy per above */
 69			if (!dma_fence_is_i915(current_fence) ||
 70			    !test_bit(I915_FENCE_FLAG_COMPOSITE,
 71				      &current_fence->flags)) {
 72				return 0;
 73			}
 74
 75			rq = to_request(current_fence);
 76			if (!i915_request_completed(rq))
 77				return flag(rq->engine->uabi_class);
 78		} while (--nchild);
 79
 80		/* All requests in array complete, not busy */
 81		return 0;
 82	} else {
 83		if (!dma_fence_is_i915(fence))
 84			return 0;
 85
 86		rq = to_request(fence);
 87		if (i915_request_completed(rq))
 88			return 0;
 89
 90		/* Beware type-expansion follies! */
 91		BUILD_BUG_ON(!typecheck(u16, rq->engine->uabi_class));
 92		return flag(rq->engine->uabi_class);
 93	}
 94}
 95
 96static __always_inline unsigned int
 97busy_check_reader(struct dma_fence *fence)
 98{
 99	return __busy_set_if_active(fence, __busy_read_flag);
100}
101
102static __always_inline unsigned int
103busy_check_writer(struct dma_fence *fence)
104{
105	if (!fence)
106		return 0;
107
108	return __busy_set_if_active(fence, __busy_write_id);
109}
110
111int
112i915_gem_busy_ioctl(struct drm_device *dev, void *data,
113		    struct drm_file *file)
114{
115	struct drm_i915_gem_busy *args = data;
116	struct drm_i915_gem_object *obj;
117	struct dma_resv_iter cursor;
118	struct dma_fence *fence;
119	int err;
120
121	err = -ENOENT;
122	rcu_read_lock();
123	obj = i915_gem_object_lookup_rcu(file, args->handle);
124	if (!obj)
125		goto out;
126
127	/*
128	 * A discrepancy here is that we do not report the status of
129	 * non-i915 fences, i.e. even though we may report the object as idle,
130	 * a call to set-domain may still stall waiting for foreign rendering.
131	 * This also means that wait-ioctl may report an object as busy,
132	 * where busy-ioctl considers it idle.
133	 *
134	 * We trade the ability to warn of foreign fences to report on which
135	 * i915 engines are active for the object.
136	 *
137	 * Alternatively, we can trade that extra information on read/write
138	 * activity with
139	 *	args->busy =
140	 *		!dma_resv_test_signaled(obj->resv, DMA_RESV_USAGE_READ);
141	 * to report the overall busyness. This is what the wait-ioctl does.
142	 *
143	 */
144	args->busy = 0;
145	dma_resv_iter_begin(&cursor, obj->base.resv, DMA_RESV_USAGE_READ);
146	dma_resv_for_each_fence_unlocked(&cursor, fence) {
147		if (dma_resv_iter_is_restarted(&cursor))
148			args->busy = 0;
149
150		if (dma_resv_iter_usage(&cursor) <= DMA_RESV_USAGE_WRITE)
151			/* Translate the write fences to the READ *and* WRITE engine */
152			args->busy |= busy_check_writer(fence);
153		else
154			/* Translate read fences to READ set of engines */
155			args->busy |= busy_check_reader(fence);
156	}
157	dma_resv_iter_end(&cursor);
158
159	err = 0;
160out:
161	rcu_read_unlock();
162	return err;
163}