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