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#include <drm/drmP.h>
32#include "drm_internal.h"
33#include "drm_legacy.h"
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
58{
59 struct drm_auth *auth = data;
60 int ret = 0;
61
62 mutex_lock(&dev->master_mutex);
63 if (!file_priv->magic) {
64 ret = idr_alloc(&file_priv->master->magic_map, file_priv,
65 1, 0, GFP_KERNEL);
66 if (ret >= 0)
67 file_priv->magic = ret;
68 }
69 auth->magic = file_priv->magic;
70 mutex_unlock(&dev->master_mutex);
71
72 DRM_DEBUG("%u\n", auth->magic);
73
74 return ret < 0 ? ret : 0;
75}
76
77int drm_authmagic(struct drm_device *dev, void *data,
78 struct drm_file *file_priv)
79{
80 struct drm_auth *auth = data;
81 struct drm_file *file;
82
83 DRM_DEBUG("%u\n", auth->magic);
84
85 mutex_lock(&dev->master_mutex);
86 file = idr_find(&file_priv->master->magic_map, auth->magic);
87 if (file) {
88 file->authenticated = 1;
89 idr_replace(&file_priv->master->magic_map, NULL, auth->magic);
90 }
91 mutex_unlock(&dev->master_mutex);
92
93 return file ? 0 : -EINVAL;
94}
95
96static struct drm_master *drm_master_create(struct drm_device *dev)
97{
98 struct drm_master *master;
99
100 master = kzalloc(sizeof(*master), GFP_KERNEL);
101 if (!master)
102 return NULL;
103
104 kref_init(&master->refcount);
105 spin_lock_init(&master->lock.spinlock);
106 init_waitqueue_head(&master->lock.lock_queue);
107 idr_init(&master->magic_map);
108 master->dev = dev;
109
110 return master;
111}
112
113static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv,
114 bool new_master)
115{
116 int ret = 0;
117
118 dev->master = drm_master_get(fpriv->master);
119 if (dev->driver->master_set) {
120 ret = dev->driver->master_set(dev, fpriv, new_master);
121 if (unlikely(ret != 0)) {
122 drm_master_put(&dev->master);
123 }
124 }
125
126 return ret;
127}
128
129static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
130{
131 struct drm_master *old_master;
132 int ret;
133
134 lockdep_assert_held_once(&dev->master_mutex);
135
136 old_master = fpriv->master;
137 fpriv->master = drm_master_create(dev);
138 if (!fpriv->master) {
139 fpriv->master = old_master;
140 return -ENOMEM;
141 }
142
143 if (dev->driver->master_create) {
144 ret = dev->driver->master_create(dev, fpriv->master);
145 if (ret)
146 goto out_err;
147 }
148 fpriv->is_master = 1;
149 fpriv->authenticated = 1;
150
151 ret = drm_set_master(dev, fpriv, true);
152 if (ret)
153 goto out_err;
154
155 if (old_master)
156 drm_master_put(&old_master);
157
158 return 0;
159
160out_err:
161
162 drm_master_put(&fpriv->master);
163 fpriv->master = old_master;
164
165 return ret;
166}
167
168int drm_setmaster_ioctl(struct drm_device *dev, void *data,
169 struct drm_file *file_priv)
170{
171 int ret = 0;
172
173 mutex_lock(&dev->master_mutex);
174 if (drm_is_current_master(file_priv))
175 goto out_unlock;
176
177 if (dev->master) {
178 ret = -EINVAL;
179 goto out_unlock;
180 }
181
182 if (!file_priv->master) {
183 ret = -EINVAL;
184 goto out_unlock;
185 }
186
187 if (!file_priv->is_master) {
188 ret = drm_new_set_master(dev, file_priv);
189 goto out_unlock;
190 }
191
192 ret = drm_set_master(dev, file_priv, false);
193out_unlock:
194 mutex_unlock(&dev->master_mutex);
195 return ret;
196}
197
198static void drm_drop_master(struct drm_device *dev,
199 struct drm_file *fpriv)
200{
201 if (dev->driver->master_drop)
202 dev->driver->master_drop(dev, fpriv);
203 drm_master_put(&dev->master);
204}
205
206int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
207 struct drm_file *file_priv)
208{
209 int ret = -EINVAL;
210
211 mutex_lock(&dev->master_mutex);
212 if (!drm_is_current_master(file_priv))
213 goto out_unlock;
214
215 if (!dev->master)
216 goto out_unlock;
217
218 ret = 0;
219 drm_drop_master(dev, file_priv);
220out_unlock:
221 mutex_unlock(&dev->master_mutex);
222 return ret;
223}
224
225int drm_master_open(struct drm_file *file_priv)
226{
227 struct drm_device *dev = file_priv->minor->dev;
228 int ret = 0;
229
230
231
232 mutex_lock(&dev->master_mutex);
233 if (!dev->master)
234 ret = drm_new_set_master(dev, file_priv);
235 else
236 file_priv->master = drm_master_get(dev->master);
237 mutex_unlock(&dev->master_mutex);
238
239 return ret;
240}
241
242void drm_master_release(struct drm_file *file_priv)
243{
244 struct drm_device *dev = file_priv->minor->dev;
245 struct drm_master *master = file_priv->master;
246
247 mutex_lock(&dev->master_mutex);
248 if (file_priv->magic)
249 idr_remove(&file_priv->master->magic_map, file_priv->magic);
250
251 if (!drm_is_current_master(file_priv))
252 goto out;
253
254 if (drm_core_check_feature(dev, DRIVER_LEGACY)) {
255
256
257
258
259 mutex_lock(&dev->struct_mutex);
260 if (master->lock.hw_lock) {
261 if (dev->sigdata.lock == master->lock.hw_lock)
262 dev->sigdata.lock = NULL;
263 master->lock.hw_lock = NULL;
264 master->lock.file_priv = NULL;
265 wake_up_interruptible_all(&master->lock.lock_queue);
266 }
267 mutex_unlock(&dev->struct_mutex);
268 }
269
270 if (dev->master == file_priv->master)
271 drm_drop_master(dev, file_priv);
272out:
273
274 if (file_priv->master)
275 drm_master_put(&file_priv->master);
276 mutex_unlock(&dev->master_mutex);
277}
278
279
280
281
282
283
284
285
286
287
288
289bool drm_is_current_master(struct drm_file *fpriv)
290{
291 return fpriv->is_master && fpriv->master == fpriv->minor->dev->master;
292}
293EXPORT_SYMBOL(drm_is_current_master);
294
295
296
297
298
299
300
301struct drm_master *drm_master_get(struct drm_master *master)
302{
303 kref_get(&master->refcount);
304 return master;
305}
306EXPORT_SYMBOL(drm_master_get);
307
308static void drm_master_destroy(struct kref *kref)
309{
310 struct drm_master *master = container_of(kref, struct drm_master, refcount);
311 struct drm_device *dev = master->dev;
312
313 if (dev->driver->master_destroy)
314 dev->driver->master_destroy(dev, master);
315
316 drm_legacy_master_rmmaps(dev, master);
317
318 idr_destroy(&master->magic_map);
319 kfree(master->unique);
320 kfree(master);
321}
322
323
324
325
326
327
328
329void drm_master_put(struct drm_master **master)
330{
331 kref_put(&(*master)->refcount, drm_master_destroy);
332 *master = NULL;
333}
334EXPORT_SYMBOL(drm_master_put);
335