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(fence: current_fence) ||
70 !test_bit(I915_FENCE_FLAG_COMPOSITE,
71 &current_fence->flags)) {
72 return 0;
73 }
74
75 rq = to_request(fence: 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, flag: __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, flag: __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, handle: 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: &cursor, obj: obj->base.resv, usage: DMA_RESV_USAGE_READ);
146 dma_resv_for_each_fence_unlocked(&cursor, fence) {
147 if (dma_resv_iter_is_restarted(cursor: &cursor))
148 args->busy = 0;
149
150 if (dma_resv_iter_usage(cursor: &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: &cursor);
158
159 err = 0;
160out:
161 rcu_read_unlock();
162 return err;
163}
164