1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright © 2014-2016 Intel Corporation
5 */
6
7 #include "gt/intel_engine.h"
8
9 #include "i915_gem_ioctls.h"
10 #include "i915_gem_object.h"
11
12 static __always_inline u32 __busy_read_flag(u16 id)
13 {
14 if (id == (u16)I915_ENGINE_CLASS_INVALID)
15 return 0xffff0000u;
16
17 GEM_BUG_ON(id >= 16);
18 return 0x10000u << id;
19 }
20
21 static __always_inline u32 __busy_write_id(u16 id)
22 {
23 /*
24 * The uABI guarantees an active writer is also amongst the read
25 * engines. This would be true if we accessed the activity tracking
26 * under the lock, but as we perform the lookup of the object and
27 * its activity locklessly we can not guarantee that the last_write
28 * being active implies that we have set the same engine flag from
29 * last_read - hence we always set both read and write busy for
30 * last_write.
31 */
32 if (id == (u16)I915_ENGINE_CLASS_INVALID)
33 return 0xffffffffu;
34
35 return (id + 1) | __busy_read_flag(id);
36 }
37
38 static __always_inline unsigned int
39 __busy_set_if_active(const struct dma_fence *fence, u32 (*flag)(u16 id))
40 {
41 const struct i915_request *rq;
42
43 /*
44 * We have to check the current hw status of the fence as the uABI
45 * guarantees forward progress. We could rely on the idle worker
46 * to eventually flush us, but to minimise latency just ask the
47 * hardware.
48 *
49 * Note we only report on the status of native fences.
50 */
51 if (!dma_fence_is_i915(fence))
52 return 0;
53
54 /* opencode to_request() in order to avoid const warnings */
55 rq = container_of(fence, const struct i915_request, fence);
56 if (i915_request_completed(rq))
57 return 0;
58
59 /* Beware type-expansion follies! */
60 BUILD_BUG_ON(!typecheck(u16, rq->engine->uabi_class));
61 return flag(rq->engine->uabi_class);
62 }
63
64 static __always_inline unsigned int
65 busy_check_reader(const struct dma_fence *fence)
66 {
67 return __busy_set_if_active(fence, __busy_read_flag);
68 }
69
70 static __always_inline unsigned int
71 busy_check_writer(const struct dma_fence *fence)
72 {
73 if (!fence)
74 return 0;
75
76 return __busy_set_if_active(fence, __busy_write_id);
77 }
78
79 int
80 i915_gem_busy_ioctl(struct drm_device *dev, void *data,
81 struct drm_file *file)
82 {
83 struct drm_i915_gem_busy *args = data;
84 struct drm_i915_gem_object *obj;
85 struct dma_resv_list *list;
86 unsigned int seq;
87 int err;
88
89 err = -ENOENT;
90 rcu_read_lock();
91 obj = i915_gem_object_lookup_rcu(file, args->handle);
92 if (!obj)
93 goto out;
94
95 /*
96 * A discrepancy here is that we do not report the status of
97 * non-i915 fences, i.e. even though we may report the object as idle,
98 * a call to set-domain may still stall waiting for foreign rendering.
99 * This also means that wait-ioctl may report an object as busy,
100 * where busy-ioctl considers it idle.
101 *
102 * We trade the ability to warn of foreign fences to report on which
103 * i915 engines are active for the object.
104 *
105 * Alternatively, we can trade that extra information on read/write
106 * activity with
107 * args->busy =
108 * !dma_resv_test_signaled_rcu(obj->resv, true);
109 * to report the overall busyness. This is what the wait-ioctl does.
110 *
111 */
112 retry:
113 seq = raw_read_seqcount(&obj->base.resv->seq);
114
115 /* Translate the exclusive fence to the READ *and* WRITE engine */
116 args->busy =
117 busy_check_writer(rcu_dereference(obj->base.resv->fence_excl));
118
119 /* Translate shared fences to READ set of engines */
120 list = rcu_dereference(obj->base.resv->fence);
121 if (list) {
122 unsigned int shared_count = list->shared_count, i;
123
124 for (i = 0; i < shared_count; ++i) {
125 struct dma_fence *fence =
126 rcu_dereference(list->shared[i]);
127
128 args->busy |= busy_check_reader(fence);
129 }
130 }
131
132 if (args->busy && read_seqcount_retry(&obj->base.resv->seq, seq))
133 goto retry;
134
135 err = 0;
136 out:
137 rcu_read_unlock();
138 return err;
139 }