Merge tag 'f2fs-for-v5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeu...
[sfrench/cifs-2.6.git] / drivers / gpu / drm / drm_auth.c
1 /*
2  * Created: Tue Feb  2 08:37:54 1999 by faith@valinux.com
3  *
4  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
5  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
6  * All Rights Reserved.
7  *
8  * Author Rickard E. (Rik) Faith <faith@valinux.com>
9  * Author Gareth Hughes <gareth@valinux.com>
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a
12  * copy of this software and associated documentation files (the "Software"),
13  * to deal in the Software without restriction, including without limitation
14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15  * and/or sell copies of the Software, and to permit persons to whom the
16  * Software is furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice (including the next
19  * paragraph) shall be included in all copies or substantial portions of the
20  * Software.
21  *
22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
25  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
26  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
27  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28  * OTHER DEALINGS IN THE SOFTWARE.
29  */
30
31 #include <drm/drmP.h>
32 #include "drm_internal.h"
33 #include "drm_legacy.h"
34 #include <drm/drm_lease.h>
35
36 /**
37  * DOC: master and authentication
38  *
39  * &struct drm_master is used to track groups of clients with open
40  * primary/legacy device nodes. For every &struct drm_file which has had at
41  * least once successfully became the device master (either through the
42  * SET_MASTER IOCTL, or implicitly through opening the primary device node when
43  * no one else is the current master that time) there exists one &drm_master.
44  * This is noted in &drm_file.is_master. All other clients have just a pointer
45  * to the &drm_master they are associated with.
46  *
47  * In addition only one &drm_master can be the current master for a &drm_device.
48  * It can be switched through the DROP_MASTER and SET_MASTER IOCTL, or
49  * implicitly through closing/openeing the primary device node. See also
50  * drm_is_current_master().
51  *
52  * Clients can authenticate against the current master (if it matches their own)
53  * using the GETMAGIC and AUTHMAGIC IOCTLs. Together with exchanging masters,
54  * this allows controlled access to the device for an entire group of mutually
55  * trusted clients.
56  */
57
58 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
59 {
60         struct drm_auth *auth = data;
61         int ret = 0;
62
63         mutex_lock(&dev->master_mutex);
64         if (!file_priv->magic) {
65                 ret = idr_alloc(&file_priv->master->magic_map, file_priv,
66                                 1, 0, GFP_KERNEL);
67                 if (ret >= 0)
68                         file_priv->magic = ret;
69         }
70         auth->magic = file_priv->magic;
71         mutex_unlock(&dev->master_mutex);
72
73         DRM_DEBUG("%u\n", auth->magic);
74
75         return ret < 0 ? ret : 0;
76 }
77
78 int drm_authmagic(struct drm_device *dev, void *data,
79                   struct drm_file *file_priv)
80 {
81         struct drm_auth *auth = data;
82         struct drm_file *file;
83
84         DRM_DEBUG("%u\n", auth->magic);
85
86         mutex_lock(&dev->master_mutex);
87         file = idr_find(&file_priv->master->magic_map, auth->magic);
88         if (file) {
89                 file->authenticated = 1;
90                 idr_replace(&file_priv->master->magic_map, NULL, auth->magic);
91         }
92         mutex_unlock(&dev->master_mutex);
93
94         return file ? 0 : -EINVAL;
95 }
96
97 struct drm_master *drm_master_create(struct drm_device *dev)
98 {
99         struct drm_master *master;
100
101         master = kzalloc(sizeof(*master), GFP_KERNEL);
102         if (!master)
103                 return NULL;
104
105         kref_init(&master->refcount);
106         drm_master_legacy_init(master);
107         idr_init(&master->magic_map);
108         master->dev = dev;
109
110         /* initialize the tree of output resource lessees */
111         INIT_LIST_HEAD(&master->lessees);
112         INIT_LIST_HEAD(&master->lessee_list);
113         idr_init(&master->leases);
114         idr_init(&master->lessee_idr);
115
116         return master;
117 }
118
119 static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv,
120                           bool new_master)
121 {
122         int ret = 0;
123
124         dev->master = drm_master_get(fpriv->master);
125         if (dev->driver->master_set) {
126                 ret = dev->driver->master_set(dev, fpriv, new_master);
127                 if (unlikely(ret != 0)) {
128                         drm_master_put(&dev->master);
129                 }
130         }
131
132         return ret;
133 }
134
135 static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
136 {
137         struct drm_master *old_master;
138         int ret;
139
140         lockdep_assert_held_once(&dev->master_mutex);
141
142         WARN_ON(fpriv->is_master);
143         old_master = fpriv->master;
144         fpriv->master = drm_master_create(dev);
145         if (!fpriv->master) {
146                 fpriv->master = old_master;
147                 return -ENOMEM;
148         }
149
150         if (dev->driver->master_create) {
151                 ret = dev->driver->master_create(dev, fpriv->master);
152                 if (ret)
153                         goto out_err;
154         }
155         fpriv->is_master = 1;
156         fpriv->authenticated = 1;
157
158         ret = drm_set_master(dev, fpriv, true);
159         if (ret)
160                 goto out_err;
161
162         if (old_master)
163                 drm_master_put(&old_master);
164
165         return 0;
166
167 out_err:
168         /* drop references and restore old master on failure */
169         drm_master_put(&fpriv->master);
170         fpriv->master = old_master;
171         fpriv->is_master = 0;
172
173         return ret;
174 }
175
176 int drm_setmaster_ioctl(struct drm_device *dev, void *data,
177                         struct drm_file *file_priv)
178 {
179         int ret = 0;
180
181         mutex_lock(&dev->master_mutex);
182         if (drm_is_current_master(file_priv))
183                 goto out_unlock;
184
185         if (dev->master) {
186                 ret = -EINVAL;
187                 goto out_unlock;
188         }
189
190         if (!file_priv->master) {
191                 ret = -EINVAL;
192                 goto out_unlock;
193         }
194
195         if (!file_priv->is_master) {
196                 ret = drm_new_set_master(dev, file_priv);
197                 goto out_unlock;
198         }
199
200         if (file_priv->master->lessor != NULL) {
201                 DRM_DEBUG_LEASE("Attempt to set lessee %d as master\n", file_priv->master->lessee_id);
202                 ret = -EINVAL;
203                 goto out_unlock;
204         }
205
206         ret = drm_set_master(dev, file_priv, false);
207 out_unlock:
208         mutex_unlock(&dev->master_mutex);
209         return ret;
210 }
211
212 static void drm_drop_master(struct drm_device *dev,
213                             struct drm_file *fpriv)
214 {
215         if (dev->driver->master_drop)
216                 dev->driver->master_drop(dev, fpriv);
217         drm_master_put(&dev->master);
218 }
219
220 int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
221                          struct drm_file *file_priv)
222 {
223         int ret = -EINVAL;
224
225         mutex_lock(&dev->master_mutex);
226         if (!drm_is_current_master(file_priv))
227                 goto out_unlock;
228
229         if (!dev->master)
230                 goto out_unlock;
231
232         if (file_priv->master->lessor != NULL) {
233                 DRM_DEBUG_LEASE("Attempt to drop lessee %d as master\n", file_priv->master->lessee_id);
234                 ret = -EINVAL;
235                 goto out_unlock;
236         }
237
238         ret = 0;
239         drm_drop_master(dev, file_priv);
240 out_unlock:
241         mutex_unlock(&dev->master_mutex);
242         return ret;
243 }
244
245 int drm_master_open(struct drm_file *file_priv)
246 {
247         struct drm_device *dev = file_priv->minor->dev;
248         int ret = 0;
249
250         /* if there is no current master make this fd it, but do not create
251          * any master object for render clients */
252         mutex_lock(&dev->master_mutex);
253         if (!dev->master)
254                 ret = drm_new_set_master(dev, file_priv);
255         else
256                 file_priv->master = drm_master_get(dev->master);
257         mutex_unlock(&dev->master_mutex);
258
259         return ret;
260 }
261
262 void drm_master_release(struct drm_file *file_priv)
263 {
264         struct drm_device *dev = file_priv->minor->dev;
265         struct drm_master *master = file_priv->master;
266
267         mutex_lock(&dev->master_mutex);
268         if (file_priv->magic)
269                 idr_remove(&file_priv->master->magic_map, file_priv->magic);
270
271         if (!drm_is_current_master(file_priv))
272                 goto out;
273
274         drm_legacy_lock_master_cleanup(dev, master);
275
276         if (dev->master == file_priv->master)
277                 drm_drop_master(dev, file_priv);
278 out:
279         if (drm_core_check_feature(dev, DRIVER_MODESET) && file_priv->is_master) {
280                 /* Revoke any leases held by this or lessees, but only if
281                  * this is the "real" master
282                  */
283                 drm_lease_revoke(master);
284         }
285
286         /* drop the master reference held by the file priv */
287         if (file_priv->master)
288                 drm_master_put(&file_priv->master);
289         mutex_unlock(&dev->master_mutex);
290 }
291
292 /**
293  * drm_is_current_master - checks whether @priv is the current master
294  * @fpriv: DRM file private
295  *
296  * Checks whether @fpriv is current master on its device. This decides whether a
297  * client is allowed to run DRM_MASTER IOCTLs.
298  *
299  * Most of the modern IOCTL which require DRM_MASTER are for kernel modesetting
300  * - the current master is assumed to own the non-shareable display hardware.
301  */
302 bool drm_is_current_master(struct drm_file *fpriv)
303 {
304         return fpriv->is_master && drm_lease_owner(fpriv->master) == fpriv->minor->dev->master;
305 }
306 EXPORT_SYMBOL(drm_is_current_master);
307
308 /**
309  * drm_master_get - reference a master pointer
310  * @master: &struct drm_master
311  *
312  * Increments the reference count of @master and returns a pointer to @master.
313  */
314 struct drm_master *drm_master_get(struct drm_master *master)
315 {
316         kref_get(&master->refcount);
317         return master;
318 }
319 EXPORT_SYMBOL(drm_master_get);
320
321 static void drm_master_destroy(struct kref *kref)
322 {
323         struct drm_master *master = container_of(kref, struct drm_master, refcount);
324         struct drm_device *dev = master->dev;
325
326         if (drm_core_check_feature(dev, DRIVER_MODESET))
327                 drm_lease_destroy(master);
328
329         if (dev->driver->master_destroy)
330                 dev->driver->master_destroy(dev, master);
331
332         drm_legacy_master_rmmaps(dev, master);
333
334         idr_destroy(&master->magic_map);
335         idr_destroy(&master->leases);
336         idr_destroy(&master->lessee_idr);
337
338         kfree(master->unique);
339         kfree(master);
340 }
341
342 /**
343  * drm_master_put - unreference and clear a master pointer
344  * @master: pointer to a pointer of &struct drm_master
345  *
346  * This decrements the &drm_master behind @master and sets it to NULL.
347  */
348 void drm_master_put(struct drm_master **master)
349 {
350         kref_put(&(*master)->refcount, drm_master_destroy);
351         *master = NULL;
352 }
353 EXPORT_SYMBOL(drm_master_put);