xref: /openbmc/linux/drivers/gpu/drm/drm_auth.c (revision 82e6fdd6)
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 	spin_lock_init(&master->lock.spinlock);
107 	init_waitqueue_head(&master->lock.lock_queue);
108 	idr_init(&master->magic_map);
109 	master->dev = dev;
110 
111 	/* initialize the tree of output resource lessees */
112 	master->lessor = NULL;
113 	master->lessee_id = 0;
114 	INIT_LIST_HEAD(&master->lessees);
115 	INIT_LIST_HEAD(&master->lessee_list);
116 	idr_init(&master->leases);
117 	idr_init(&master->lessee_idr);
118 
119 	return master;
120 }
121 
122 static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv,
123 			  bool new_master)
124 {
125 	int ret = 0;
126 
127 	dev->master = drm_master_get(fpriv->master);
128 	if (dev->driver->master_set) {
129 		ret = dev->driver->master_set(dev, fpriv, new_master);
130 		if (unlikely(ret != 0)) {
131 			drm_master_put(&dev->master);
132 		}
133 	}
134 
135 	return ret;
136 }
137 
138 static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
139 {
140 	struct drm_master *old_master;
141 	int ret;
142 
143 	lockdep_assert_held_once(&dev->master_mutex);
144 
145 	old_master = fpriv->master;
146 	fpriv->master = drm_master_create(dev);
147 	if (!fpriv->master) {
148 		fpriv->master = old_master;
149 		return -ENOMEM;
150 	}
151 
152 	if (dev->driver->master_create) {
153 		ret = dev->driver->master_create(dev, fpriv->master);
154 		if (ret)
155 			goto out_err;
156 	}
157 	fpriv->is_master = 1;
158 	fpriv->authenticated = 1;
159 
160 	ret = drm_set_master(dev, fpriv, true);
161 	if (ret)
162 		goto out_err;
163 
164 	if (old_master)
165 		drm_master_put(&old_master);
166 
167 	return 0;
168 
169 out_err:
170 	/* drop references and restore old master on failure */
171 	drm_master_put(&fpriv->master);
172 	fpriv->master = old_master;
173 
174 	return ret;
175 }
176 
177 int drm_setmaster_ioctl(struct drm_device *dev, void *data,
178 			struct drm_file *file_priv)
179 {
180 	int ret = 0;
181 
182 	mutex_lock(&dev->master_mutex);
183 	if (drm_is_current_master(file_priv))
184 		goto out_unlock;
185 
186 	if (dev->master) {
187 		ret = -EINVAL;
188 		goto out_unlock;
189 	}
190 
191 	if (!file_priv->master) {
192 		ret = -EINVAL;
193 		goto out_unlock;
194 	}
195 
196 	if (!file_priv->is_master) {
197 		ret = drm_new_set_master(dev, file_priv);
198 		goto out_unlock;
199 	}
200 
201 	if (file_priv->master->lessor != NULL) {
202 		DRM_DEBUG_LEASE("Attempt to set lessee %d as master\n", file_priv->master->lessee_id);
203 		ret = -EINVAL;
204 		goto out_unlock;
205 	}
206 
207 	ret = drm_set_master(dev, file_priv, false);
208 out_unlock:
209 	mutex_unlock(&dev->master_mutex);
210 	return ret;
211 }
212 
213 static void drm_drop_master(struct drm_device *dev,
214 			    struct drm_file *fpriv)
215 {
216 	if (dev->driver->master_drop)
217 		dev->driver->master_drop(dev, fpriv);
218 	drm_master_put(&dev->master);
219 }
220 
221 int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
222 			 struct drm_file *file_priv)
223 {
224 	int ret = -EINVAL;
225 
226 	mutex_lock(&dev->master_mutex);
227 	if (!drm_is_current_master(file_priv))
228 		goto out_unlock;
229 
230 	if (!dev->master)
231 		goto out_unlock;
232 
233 	if (file_priv->master->lessor != NULL) {
234 		DRM_DEBUG_LEASE("Attempt to drop lessee %d as master\n", file_priv->master->lessee_id);
235 		ret = -EINVAL;
236 		goto out_unlock;
237 	}
238 
239 	ret = 0;
240 	drm_drop_master(dev, file_priv);
241 out_unlock:
242 	mutex_unlock(&dev->master_mutex);
243 	return ret;
244 }
245 
246 int drm_master_open(struct drm_file *file_priv)
247 {
248 	struct drm_device *dev = file_priv->minor->dev;
249 	int ret = 0;
250 
251 	/* if there is no current master make this fd it, but do not create
252 	 * any master object for render clients */
253 	mutex_lock(&dev->master_mutex);
254 	if (!dev->master)
255 		ret = drm_new_set_master(dev, file_priv);
256 	else
257 		file_priv->master = drm_master_get(dev->master);
258 	mutex_unlock(&dev->master_mutex);
259 
260 	return ret;
261 }
262 
263 void drm_master_release(struct drm_file *file_priv)
264 {
265 	struct drm_device *dev = file_priv->minor->dev;
266 	struct drm_master *master = file_priv->master;
267 
268 	mutex_lock(&dev->master_mutex);
269 	if (file_priv->magic)
270 		idr_remove(&file_priv->master->magic_map, file_priv->magic);
271 
272 	if (!drm_is_current_master(file_priv))
273 		goto out;
274 
275 	if (drm_core_check_feature(dev, DRIVER_LEGACY)) {
276 		/*
277 		 * Since the master is disappearing, so is the
278 		 * possibility to lock.
279 		 */
280 		mutex_lock(&dev->struct_mutex);
281 		if (master->lock.hw_lock) {
282 			if (dev->sigdata.lock == master->lock.hw_lock)
283 				dev->sigdata.lock = NULL;
284 			master->lock.hw_lock = NULL;
285 			master->lock.file_priv = NULL;
286 			wake_up_interruptible_all(&master->lock.lock_queue);
287 		}
288 		mutex_unlock(&dev->struct_mutex);
289 	}
290 
291 	if (dev->master == file_priv->master)
292 		drm_drop_master(dev, file_priv);
293 out:
294 	if (drm_core_check_feature(dev, DRIVER_MODESET) && file_priv->is_master) {
295 		/* Revoke any leases held by this or lessees, but only if
296 		 * this is the "real" master
297 		 */
298 		drm_lease_revoke(master);
299 	}
300 
301 	/* drop the master reference held by the file priv */
302 	if (file_priv->master)
303 		drm_master_put(&file_priv->master);
304 	mutex_unlock(&dev->master_mutex);
305 }
306 
307 /**
308  * drm_is_current_master - checks whether @priv is the current master
309  * @fpriv: DRM file private
310  *
311  * Checks whether @fpriv is current master on its device. This decides whether a
312  * client is allowed to run DRM_MASTER IOCTLs.
313  *
314  * Most of the modern IOCTL which require DRM_MASTER are for kernel modesetting
315  * - the current master is assumed to own the non-shareable display hardware.
316  */
317 bool drm_is_current_master(struct drm_file *fpriv)
318 {
319 	return fpriv->is_master && drm_lease_owner(fpriv->master) == fpriv->minor->dev->master;
320 }
321 EXPORT_SYMBOL(drm_is_current_master);
322 
323 /**
324  * drm_master_get - reference a master pointer
325  * @master: &struct drm_master
326  *
327  * Increments the reference count of @master and returns a pointer to @master.
328  */
329 struct drm_master *drm_master_get(struct drm_master *master)
330 {
331 	kref_get(&master->refcount);
332 	return master;
333 }
334 EXPORT_SYMBOL(drm_master_get);
335 
336 static void drm_master_destroy(struct kref *kref)
337 {
338 	struct drm_master *master = container_of(kref, struct drm_master, refcount);
339 	struct drm_device *dev = master->dev;
340 
341 	if (drm_core_check_feature(dev, DRIVER_MODESET))
342 		drm_lease_destroy(master);
343 
344 	if (dev->driver->master_destroy)
345 		dev->driver->master_destroy(dev, master);
346 
347 	drm_legacy_master_rmmaps(dev, master);
348 
349 	idr_destroy(&master->magic_map);
350 	idr_destroy(&master->leases);
351 	idr_destroy(&master->lessee_idr);
352 
353 	kfree(master->unique);
354 	kfree(master);
355 }
356 
357 /**
358  * drm_master_put - unreference and clear a master pointer
359  * @master: pointer to a pointer of &struct drm_master
360  *
361  * This decrements the &drm_master behind @master and sets it to NULL.
362  */
363 void drm_master_put(struct drm_master **master)
364 {
365 	kref_put(&(*master)->refcount, drm_master_destroy);
366 	*master = NULL;
367 }
368 EXPORT_SYMBOL(drm_master_put);
369