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 13 static __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 22 static __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 39 static __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 ¤t_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 96 static __always_inline unsigned int 97 busy_check_reader(struct dma_fence *fence) 98 { 99 return __busy_set_if_active(fence, __busy_read_flag); 100 } 101 102 static __always_inline unsigned int 103 busy_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 111 int 112 i915_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; 160 out: 161 rcu_read_unlock(); 162 return err; 163 } 164