1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/dma-buf.h>
24#include <linux/reservation.h>
25
26#include "vgem_drv.h"
27
28#define VGEM_FENCE_TIMEOUT (10*HZ)
29
30struct vgem_fence {
31 struct dma_fence base;
32 struct spinlock lock;
33 struct timer_list timer;
34};
35
36static const char *vgem_fence_get_driver_name(struct dma_fence *fence)
37{
38 return "vgem";
39}
40
41static const char *vgem_fence_get_timeline_name(struct dma_fence *fence)
42{
43 return "unbound";
44}
45
46static bool vgem_fence_signaled(struct dma_fence *fence)
47{
48 return false;
49}
50
51static bool vgem_fence_enable_signaling(struct dma_fence *fence)
52{
53 return true;
54}
55
56static void vgem_fence_release(struct dma_fence *base)
57{
58 struct vgem_fence *fence = container_of(base, typeof(*fence), base);
59
60 del_timer_sync(&fence->timer);
61 dma_fence_free(&fence->base);
62}
63
64static void vgem_fence_value_str(struct dma_fence *fence, char *str, int size)
65{
66 snprintf(str, size, "%u", fence->seqno);
67}
68
69static void vgem_fence_timeline_value_str(struct dma_fence *fence, char *str,
70 int size)
71{
72 snprintf(str, size, "%u",
73 dma_fence_is_signaled(fence) ? fence->seqno : 0);
74}
75
76static const struct dma_fence_ops vgem_fence_ops = {
77 .get_driver_name = vgem_fence_get_driver_name,
78 .get_timeline_name = vgem_fence_get_timeline_name,
79 .enable_signaling = vgem_fence_enable_signaling,
80 .signaled = vgem_fence_signaled,
81 .wait = dma_fence_default_wait,
82 .release = vgem_fence_release,
83
84 .fence_value_str = vgem_fence_value_str,
85 .timeline_value_str = vgem_fence_timeline_value_str,
86};
87
88static void vgem_fence_timeout(unsigned long data)
89{
90 struct vgem_fence *fence = (struct vgem_fence *)data;
91
92 dma_fence_signal(&fence->base);
93}
94
95static struct dma_fence *vgem_fence_create(struct vgem_file *vfile,
96 unsigned int flags)
97{
98 struct vgem_fence *fence;
99
100 fence = kzalloc(sizeof(*fence), GFP_KERNEL);
101 if (!fence)
102 return NULL;
103
104 spin_lock_init(&fence->lock);
105 dma_fence_init(&fence->base, &vgem_fence_ops, &fence->lock,
106 dma_fence_context_alloc(1), 1);
107
108 setup_timer(&fence->timer, vgem_fence_timeout, (unsigned long)fence);
109
110
111 mod_timer(&fence->timer, jiffies + VGEM_FENCE_TIMEOUT);
112
113 return &fence->base;
114}
115
116static int attach_dmabuf(struct drm_device *dev,
117 struct drm_gem_object *obj)
118{
119 struct dma_buf *dmabuf;
120
121 if (obj->dma_buf)
122 return 0;
123
124 dmabuf = dev->driver->gem_prime_export(dev, obj, 0);
125 if (IS_ERR(dmabuf))
126 return PTR_ERR(dmabuf);
127
128 obj->dma_buf = dmabuf;
129 return 0;
130}
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152int vgem_fence_attach_ioctl(struct drm_device *dev,
153 void *data,
154 struct drm_file *file)
155{
156 struct drm_vgem_fence_attach *arg = data;
157 struct vgem_file *vfile = file->driver_priv;
158 struct reservation_object *resv;
159 struct drm_gem_object *obj;
160 struct dma_fence *fence;
161 int ret;
162
163 if (arg->flags & ~VGEM_FENCE_WRITE)
164 return -EINVAL;
165
166 if (arg->pad)
167 return -EINVAL;
168
169 obj = drm_gem_object_lookup(file, arg->handle);
170 if (!obj)
171 return -ENOENT;
172
173 ret = attach_dmabuf(dev, obj);
174 if (ret)
175 goto err;
176
177 fence = vgem_fence_create(vfile, arg->flags);
178 if (!fence) {
179 ret = -ENOMEM;
180 goto err;
181 }
182
183
184 resv = obj->dma_buf->resv;
185 if (!reservation_object_test_signaled_rcu(resv,
186 arg->flags & VGEM_FENCE_WRITE)) {
187 ret = -EBUSY;
188 goto err_fence;
189 }
190
191
192 ret = 0;
193 reservation_object_lock(resv, NULL);
194 if (arg->flags & VGEM_FENCE_WRITE)
195 reservation_object_add_excl_fence(resv, fence);
196 else if ((ret = reservation_object_reserve_shared(resv)) == 0)
197 reservation_object_add_shared_fence(resv, fence);
198 reservation_object_unlock(resv);
199
200
201 if (ret == 0) {
202 mutex_lock(&vfile->fence_mutex);
203 ret = idr_alloc(&vfile->fence_idr, fence, 1, 0, GFP_KERNEL);
204 mutex_unlock(&vfile->fence_mutex);
205 if (ret > 0) {
206 arg->out_fence = ret;
207 ret = 0;
208 }
209 }
210err_fence:
211 if (ret) {
212 dma_fence_signal(fence);
213 dma_fence_put(fence);
214 }
215err:
216 drm_gem_object_unreference_unlocked(obj);
217 return ret;
218}
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236int vgem_fence_signal_ioctl(struct drm_device *dev,
237 void *data,
238 struct drm_file *file)
239{
240 struct vgem_file *vfile = file->driver_priv;
241 struct drm_vgem_fence_signal *arg = data;
242 struct dma_fence *fence;
243 int ret = 0;
244
245 if (arg->flags)
246 return -EINVAL;
247
248 mutex_lock(&vfile->fence_mutex);
249 fence = idr_replace(&vfile->fence_idr, NULL, arg->fence);
250 mutex_unlock(&vfile->fence_mutex);
251 if (!fence)
252 return -ENOENT;
253 if (IS_ERR(fence))
254 return PTR_ERR(fence);
255
256 if (dma_fence_is_signaled(fence))
257 ret = -ETIMEDOUT;
258
259 dma_fence_signal(fence);
260 dma_fence_put(fence);
261 return ret;
262}
263
264int vgem_fence_open(struct vgem_file *vfile)
265{
266 mutex_init(&vfile->fence_mutex);
267 idr_init(&vfile->fence_idr);
268
269 return 0;
270}
271
272static int __vgem_fence_idr_fini(int id, void *p, void *data)
273{
274 dma_fence_signal(p);
275 dma_fence_put(p);
276 return 0;
277}
278
279void vgem_fence_close(struct vgem_file *vfile)
280{
281 idr_for_each(&vfile->fence_idr, __vgem_fence_idr_fini, vfile);
282 idr_destroy(&vfile->fence_idr);
283}
284