1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/export.h>
37#include <drm/drmP.h>
38#include "drm_legacy.h"
39#include "drm_internal.h"
40
41static int drm_notifier(void *priv);
42
43static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
44
45
46
47
48
49
50
51
52
53
54
55
56int drm_legacy_lock(struct drm_device *dev, void *data,
57 struct drm_file *file_priv)
58{
59 DECLARE_WAITQUEUE(entry, current);
60 struct drm_lock *lock = data;
61 struct drm_master *master = file_priv->master;
62 int ret = 0;
63
64 ++file_priv->lock_count;
65
66 if (lock->context == DRM_KERNEL_CONTEXT) {
67 DRM_ERROR("Process %d using kernel context %d\n",
68 task_pid_nr(current), lock->context);
69 return -EINVAL;
70 }
71
72 DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
73 lock->context, task_pid_nr(current),
74 master->lock.hw_lock->lock, lock->flags);
75
76 add_wait_queue(&master->lock.lock_queue, &entry);
77 spin_lock_bh(&master->lock.spinlock);
78 master->lock.user_waiters++;
79 spin_unlock_bh(&master->lock.spinlock);
80
81 for (;;) {
82 __set_current_state(TASK_INTERRUPTIBLE);
83 if (!master->lock.hw_lock) {
84
85 send_sig(SIGTERM, current, 0);
86 ret = -EINTR;
87 break;
88 }
89 if (drm_lock_take(&master->lock, lock->context)) {
90 master->lock.file_priv = file_priv;
91 master->lock.lock_time = jiffies;
92 break;
93 }
94
95
96 mutex_unlock(&drm_global_mutex);
97 schedule();
98 mutex_lock(&drm_global_mutex);
99 if (signal_pending(current)) {
100 ret = -EINTR;
101 break;
102 }
103 }
104 spin_lock_bh(&master->lock.spinlock);
105 master->lock.user_waiters--;
106 spin_unlock_bh(&master->lock.spinlock);
107 __set_current_state(TASK_RUNNING);
108 remove_wait_queue(&master->lock.lock_queue, &entry);
109
110 DRM_DEBUG("%d %s\n", lock->context,
111 ret ? "interrupted" : "has lock");
112 if (ret) return ret;
113
114
115
116
117 if (!file_priv->is_master) {
118 sigemptyset(&dev->sigmask);
119 sigaddset(&dev->sigmask, SIGSTOP);
120 sigaddset(&dev->sigmask, SIGTSTP);
121 sigaddset(&dev->sigmask, SIGTTIN);
122 sigaddset(&dev->sigmask, SIGTTOU);
123 dev->sigdata.context = lock->context;
124 dev->sigdata.lock = master->lock.hw_lock;
125 block_all_signals(drm_notifier, dev, &dev->sigmask);
126 }
127
128 if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT))
129 {
130 if (dev->driver->dma_quiescent(dev)) {
131 DRM_DEBUG("%d waiting for DMA quiescent\n",
132 lock->context);
133 return -EBUSY;
134 }
135 }
136
137 return 0;
138}
139
140
141
142
143
144
145
146
147
148
149
150
151int drm_legacy_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
152{
153 struct drm_lock *lock = data;
154 struct drm_master *master = file_priv->master;
155
156 if (lock->context == DRM_KERNEL_CONTEXT) {
157 DRM_ERROR("Process %d using kernel context %d\n",
158 task_pid_nr(current), lock->context);
159 return -EINVAL;
160 }
161
162 if (drm_legacy_lock_free(&master->lock, lock->context)) {
163
164 }
165
166 unblock_all_signals();
167 return 0;
168}
169
170
171
172
173
174
175
176
177
178
179static
180int drm_lock_take(struct drm_lock_data *lock_data,
181 unsigned int context)
182{
183 unsigned int old, new, prev;
184 volatile unsigned int *lock = &lock_data->hw_lock->lock;
185
186 spin_lock_bh(&lock_data->spinlock);
187 do {
188 old = *lock;
189 if (old & _DRM_LOCK_HELD)
190 new = old | _DRM_LOCK_CONT;
191 else {
192 new = context | _DRM_LOCK_HELD |
193 ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
194 _DRM_LOCK_CONT : 0);
195 }
196 prev = cmpxchg(lock, old, new);
197 } while (prev != old);
198 spin_unlock_bh(&lock_data->spinlock);
199
200 if (_DRM_LOCKING_CONTEXT(old) == context) {
201 if (old & _DRM_LOCK_HELD) {
202 if (context != DRM_KERNEL_CONTEXT) {
203 DRM_ERROR("%d holds heavyweight lock\n",
204 context);
205 }
206 return 0;
207 }
208 }
209
210 if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
211
212 return 1;
213 }
214 return 0;
215}
216
217
218
219
220
221
222
223
224
225
226
227
228
229static int drm_lock_transfer(struct drm_lock_data *lock_data,
230 unsigned int context)
231{
232 unsigned int old, new, prev;
233 volatile unsigned int *lock = &lock_data->hw_lock->lock;
234
235 lock_data->file_priv = NULL;
236 do {
237 old = *lock;
238 new = context | _DRM_LOCK_HELD;
239 prev = cmpxchg(lock, old, new);
240 } while (prev != old);
241 return 1;
242}
243
244
245
246
247
248
249
250
251
252
253
254
255int drm_legacy_lock_free(struct drm_lock_data *lock_data, unsigned int context)
256{
257 unsigned int old, new, prev;
258 volatile unsigned int *lock = &lock_data->hw_lock->lock;
259
260 spin_lock_bh(&lock_data->spinlock);
261 if (lock_data->kernel_waiters != 0) {
262 drm_lock_transfer(lock_data, 0);
263 lock_data->idle_has_lock = 1;
264 spin_unlock_bh(&lock_data->spinlock);
265 return 1;
266 }
267 spin_unlock_bh(&lock_data->spinlock);
268
269 do {
270 old = *lock;
271 new = _DRM_LOCKING_CONTEXT(old);
272 prev = cmpxchg(lock, old, new);
273 } while (prev != old);
274
275 if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
276 DRM_ERROR("%d freed heavyweight lock held by %d\n",
277 context, _DRM_LOCKING_CONTEXT(old));
278 return 1;
279 }
280 wake_up_interruptible(&lock_data->lock_queue);
281 return 0;
282}
283
284
285
286
287
288
289
290
291
292
293
294
295static int drm_notifier(void *priv)
296{
297 struct drm_device *dev = priv;
298 struct drm_hw_lock *lock = dev->sigdata.lock;
299 unsigned int old, new, prev;
300
301
302 if (!lock || !_DRM_LOCK_IS_HELD(lock->lock)
303 || _DRM_LOCKING_CONTEXT(lock->lock) != dev->sigdata.context)
304 return 1;
305
306
307
308 do {
309 old = lock->lock;
310 new = old | _DRM_LOCK_CONT;
311 prev = cmpxchg(&lock->lock, old, new);
312 } while (prev != old);
313 return 0;
314}
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329void drm_legacy_idlelock_take(struct drm_lock_data *lock_data)
330{
331 int ret;
332
333 spin_lock_bh(&lock_data->spinlock);
334 lock_data->kernel_waiters++;
335 if (!lock_data->idle_has_lock) {
336
337 spin_unlock_bh(&lock_data->spinlock);
338 ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
339 spin_lock_bh(&lock_data->spinlock);
340
341 if (ret == 1)
342 lock_data->idle_has_lock = 1;
343 }
344 spin_unlock_bh(&lock_data->spinlock);
345}
346EXPORT_SYMBOL(drm_legacy_idlelock_take);
347
348void drm_legacy_idlelock_release(struct drm_lock_data *lock_data)
349{
350 unsigned int old, prev;
351 volatile unsigned int *lock = &lock_data->hw_lock->lock;
352
353 spin_lock_bh(&lock_data->spinlock);
354 if (--lock_data->kernel_waiters == 0) {
355 if (lock_data->idle_has_lock) {
356 do {
357 old = *lock;
358 prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT);
359 } while (prev != old);
360 wake_up_interruptible(&lock_data->lock_queue);
361 lock_data->idle_has_lock = 0;
362 }
363 }
364 spin_unlock_bh(&lock_data->spinlock);
365}
366EXPORT_SYMBOL(drm_legacy_idlelock_release);
367
368int drm_legacy_i_have_hw_lock(struct drm_device *dev,
369 struct drm_file *file_priv)
370{
371 struct drm_master *master = file_priv->master;
372 return (file_priv->lock_count && master->lock.hw_lock &&
373 _DRM_LOCK_IS_HELD(master->lock.hw_lock->lock) &&
374 master->lock.file_priv == file_priv);
375}
376