[linux-block.git] / drivers / gpu / drm / drm_auth.c

/*
 * Created: Tue Feb  2 08:37:54 1999 by faith@valinux.com
 *
 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
 * All Rights Reserved.
 *
 * Author Rickard E. (Rik) Faith <faith@valinux.com>
 * Author Gareth Hughes <gareth@valinux.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <drm/drmP.h>
#include "drm_internal.h"
#include "drm_legacy.h"

/**
 * drm_getmagic - Get unique magic of a client
 * @dev: DRM device to operate on
 * @data: ioctl data containing the drm_auth object
 * @file_priv: DRM file that performs the operation
 *
 * This looks up the unique magic of the passed client and returns it. If the
 * client did not have a magic assigned, yet, a new one is registered. The magic
 * is stored in the passed drm_auth object.
 *
 * Returns: 0 on success, negative error code on failure.
 */
int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
	struct drm_auth *auth = data;
	int ret = 0;

	mutex_lock(&dev->master_mutex);
	if (!file_priv->magic) {
		ret = idr_alloc(&file_priv->master->magic_map, file_priv,
				1, 0, GFP_KERNEL);
		if (ret >= 0)
			file_priv->magic = ret;
	}
	auth->magic = file_priv->magic;
	mutex_unlock(&dev->master_mutex);

	DRM_DEBUG("%u\n", auth->magic);

	return ret < 0 ? ret : 0;
}

/**
 * drm_authmagic - Authenticate client with a magic
 * @dev: DRM device to operate on
 * @data: ioctl data containing the drm_auth object
 * @file_priv: DRM file that performs the operation
 *
 * This looks up a DRM client by the passed magic and authenticates it.
 *
 * Returns: 0 on success, negative error code on failure.
 */
int drm_authmagic(struct drm_device *dev, void *data,
		  struct drm_file *file_priv)
{
	struct drm_auth *auth = data;
	struct drm_file *file;

	DRM_DEBUG("%u\n", auth->magic);

	mutex_lock(&dev->master_mutex);
	file = idr_find(&file_priv->master->magic_map, auth->magic);
	if (file) {
		file->authenticated = 1;
		idr_replace(&file_priv->master->magic_map, NULL, auth->magic);
	}
	mutex_unlock(&dev->master_mutex);

	return file ? 0 : -EINVAL;
}

static struct drm_master *drm_master_create(struct drm_device *dev)
{
	struct drm_master *master;

	master = kzalloc(sizeof(*master), GFP_KERNEL);
	if (!master)
		return NULL;

	kref_init(&master->refcount);
	spin_lock_init(&master->lock.spinlock);
	init_waitqueue_head(&master->lock.lock_queue);
	idr_init(&master->magic_map);
	master->dev = dev;

	return master;
}

static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv,
			  bool new_master)
{
	int ret = 0;

	dev->master = drm_master_get(fpriv->master);
	if (dev->driver->master_set) {
		ret = dev->driver->master_set(dev, fpriv, new_master);
		if (unlikely(ret != 0)) {
			drm_master_put(&dev->master);
		}
	}

	return ret;
}

/*
 * drm_new_set_master - Allocate a new master object and become master for the
 * associated master realm.
 *
 * @dev: The associated device.
 * @fpriv: File private identifying the client.
 *
 * This function must be called with dev::master_mutex held.
 * Returns negative error code on failure. Zero on success.
 */
static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv)
{
	struct drm_master *old_master;
	int ret;

	lockdep_assert_held_once(&dev->master_mutex);

	old_master = fpriv->master;
	fpriv->master = drm_master_create(dev);
	if (!fpriv->master) {
		fpriv->master = old_master;
		return -ENOMEM;
	}

	if (dev->driver->master_create) {
		ret = dev->driver->master_create(dev, fpriv->master);
		if (ret)
			goto out_err;
	}
	fpriv->is_master = 1;
	fpriv->authenticated = 1;

	ret = drm_set_master(dev, fpriv, true);
	if (ret)
		goto out_err;

	if (old_master)
		drm_master_put(&old_master);

	return 0;

out_err:
	/* drop references and restore old master on failure */
	drm_master_put(&fpriv->master);
	fpriv->master = old_master;

	return ret;
}

int drm_setmaster_ioctl(struct drm_device *dev, void *data,
			struct drm_file *file_priv)
{
	int ret = 0;

	mutex_lock(&dev->master_mutex);
	if (drm_is_current_master(file_priv))
		goto out_unlock;

	if (dev->master) {
		ret = -EINVAL;
		goto out_unlock;
	}

	if (!file_priv->master) {
		ret = -EINVAL;
		goto out_unlock;
	}

	if (!file_priv->is_master) {
		ret = drm_new_set_master(dev, file_priv);
		goto out_unlock;
	}

	ret = drm_set_master(dev, file_priv, false);
out_unlock:
	mutex_unlock(&dev->master_mutex);
	return ret;
}

static void drm_drop_master(struct drm_device *dev,
			    struct drm_file *fpriv)
{
	if (dev->driver->master_drop)
		dev->driver->master_drop(dev, fpriv);
	drm_master_put(&dev->master);
}

int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
{
	int ret = -EINVAL;

	mutex_lock(&dev->master_mutex);
	if (!drm_is_current_master(file_priv))
		goto out_unlock;

	if (!dev->master)
		goto out_unlock;

	ret = 0;
	drm_drop_master(dev, file_priv);
out_unlock:
	mutex_unlock(&dev->master_mutex);
	return ret;
}

int drm_master_open(struct drm_file *file_priv)
{
	struct drm_device *dev = file_priv->minor->dev;
	int ret = 0;

	/* if there is no current master make this fd it, but do not create
	 * any master object for render clients */
	mutex_lock(&dev->master_mutex);
	if (!dev->master)
		ret = drm_new_set_master(dev, file_priv);
	else
		file_priv->master = drm_master_get(dev->master);
	mutex_unlock(&dev->master_mutex);

	return ret;
}

void drm_master_release(struct drm_file *file_priv)
{
	struct drm_device *dev = file_priv->minor->dev;
	struct drm_master *master = file_priv->master;

	mutex_lock(&dev->master_mutex);
	if (file_priv->magic)
		idr_remove(&file_priv->master->magic_map, file_priv->magic);

	if (!drm_is_current_master(file_priv))
		goto out;

	if (!drm_core_check_feature(dev, DRIVER_MODESET)) {
		/*
		 * Since the master is disappearing, so is the
		 * possibility to lock.
		 */
		mutex_lock(&dev->struct_mutex);
		if (master->lock.hw_lock) {
			if (dev->sigdata.lock == master->lock.hw_lock)
				dev->sigdata.lock = NULL;
			master->lock.hw_lock = NULL;
			master->lock.file_priv = NULL;
			wake_up_interruptible_all(&master->lock.lock_queue);
		}
		mutex_unlock(&dev->struct_mutex);
	}

	if (dev->master == file_priv->master)
		drm_drop_master(dev, file_priv);
out:
	/* drop the master reference held by the file priv */
	if (file_priv->master)
		drm_master_put(&file_priv->master);
	mutex_unlock(&dev->master_mutex);
}

bool drm_is_current_master(struct drm_file *fpriv)
{
	return fpriv->is_master && fpriv->master == fpriv->minor->dev->master;
}
EXPORT_SYMBOL(drm_is_current_master);

struct drm_master *drm_master_get(struct drm_master *master)
{
	kref_get(&master->refcount);
	return master;
}
EXPORT_SYMBOL(drm_master_get);

static void drm_master_destroy(struct kref *kref)
{
	struct drm_master *master = container_of(kref, struct drm_master, refcount);
	struct drm_device *dev = master->dev;

	if (dev->driver->master_destroy)
		dev->driver->master_destroy(dev, master);

	drm_legacy_master_rmmaps(dev, master);

	idr_destroy(&master->magic_map);
	kfree(master->unique);
	kfree(master);
}

void drm_master_put(struct drm_master **master)
{
	kref_put(&(*master)->refcount, drm_master_destroy);
	*master = NULL;
}
EXPORT_SYMBOL(drm_master_put);
Commit	Line	Data
1da177e4 LT	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	*
32e7b94a DH	8	* Author Rickard E. (Rik) Faith <faith@valinux.com>
	9	* Author Gareth Hughes <gareth@valinux.com>
	10	*
1da177e4 LT	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
760285e7	31	#include <drm/drmP.h>
67d0ec4e	32	#include "drm_internal.h"
6548f4e7	33	#include "drm_legacy.h"
1da177e4	34
1da177e4	35	/**
32e7b94a DH	36	* drm_getmagic - Get unique magic of a client
	37	* @dev: DRM device to operate on
	38	* @data: ioctl data containing the drm_auth object
	39	* @file_priv: DRM file that performs the operation
1da177e4	40	*
32e7b94a DH	41	* This looks up the unique magic of the passed client and returns it. If the
	42	* client did not have a magic assigned, yet, a new one is registered. The magic
	43	* is stored in the passed drm_auth object.
1da177e4	44	*
32e7b94a	45	* Returns: 0 on success, negative error code on failure.
1da177e4	46	*/
c153f45f	47	int drm_getmagic(struct drm_device dev, void data, struct drm_file *file_priv)
1da177e4	48	{
c153f45f	49	struct drm_auth *auth = data;
32e7b94a	50	int ret = 0;
1da177e4	51
d2b34ee6	52	mutex_lock(&dev->master_mutex);
32e7b94a DH	53	if (!file_priv->magic) {
	54	ret = idr_alloc(&file_priv->master->magic_map, file_priv,
	55	1, 0, GFP_KERNEL);
	56	if (ret >= 0)
	57	file_priv->magic = ret;
1da177e4	58	}
32e7b94a	59	auth->magic = file_priv->magic;
d2b34ee6	60	mutex_unlock(&dev->master_mutex);
1da177e4	61
c153f45f EA	62	DRM_DEBUG("%u\n", auth->magic);
c153f45f EA	63
32e7b94a	64	return ret < 0 ? ret : 0;
1da177e4 LT	65	}
	66
	67	/**
32e7b94a DH	68	* drm_authmagic - Authenticate client with a magic
	69	* @dev: DRM device to operate on
	70	* @data: ioctl data containing the drm_auth object
	71	* @file_priv: DRM file that performs the operation
1da177e4	72	*
32e7b94a	73	* This looks up a DRM client by the passed magic and authenticates it.
1da177e4	74	*
32e7b94a	75	* Returns: 0 on success, negative error code on failure.
1da177e4	76	*/
c153f45f EA	77	int drm_authmagic(struct drm_device dev, void data,
c153f45f EA	78	struct drm_file *file_priv)
1da177e4	79	{
c153f45f	80	struct drm_auth *auth = data;
84b1fd10	81	struct drm_file *file;
1da177e4	82
c153f45f	83	DRM_DEBUG("%u\n", auth->magic);
32e7b94a	84
d2b34ee6	85	mutex_lock(&dev->master_mutex);
32e7b94a DH	86	file = idr_find(&file_priv->master->magic_map, auth->magic);
32e7b94a DH	87	if (file) {
1da177e4	88	file->authenticated = 1;
32e7b94a	89	idr_replace(&file_priv->master->magic_map, NULL, auth->magic);
1da177e4	90	}
d2b34ee6	91	mutex_unlock(&dev->master_mutex);
32e7b94a DH	92
32e7b94a DH	93	return file ? 0 : -EINVAL;
1da177e4	94	}
6548f4e7 DV	95
	96	static 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
d6ed682e DV	113	static 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);
d6ed682e DV	119	if (dev->driver->master_set) {
	120	ret = dev->driver->master_set(dev, fpriv, new_master);
	121	if (unlikely(ret != 0)) {
d6ed682e DV	122	drm_master_put(&dev->master);
	123	}
	124	}
	125
	126	return ret;
	127	}
	128
6548f4e7 DV	129	/*
	130	* drm_new_set_master - Allocate a new master object and become master for the
	131	* associated master realm.
	132	*
	133	* @dev: The associated device.
	134	* @fpriv: File private identifying the client.
	135	*
d2b34ee6	136	* This function must be called with dev::master_mutex held.
6548f4e7 DV	137	* Returns negative error code on failure. Zero on success.
6548f4e7 DV	138	*/
2cbae7e6	139	static int drm_new_set_master(struct drm_device dev, struct drm_file fpriv)
6548f4e7 DV	140	{
	141	struct drm_master *old_master;
	142	int ret;
	143
	144	lockdep_assert_held_once(&dev->master_mutex);
	145
6548f4e7	146	old_master = fpriv->master;
d6ed682e DV	147	fpriv->master = drm_master_create(dev);
	148	if (!fpriv->master) {
	149	fpriv->master = old_master;
	150	return -ENOMEM;
	151	}
6548f4e7 DV	152
	153	if (dev->driver->master_create) {
	154	ret = dev->driver->master_create(dev, fpriv->master);
	155	if (ret)
	156	goto out_err;
	157	}
0aae5920	158	fpriv->is_master = 1;
6548f4e7	159	fpriv->authenticated = 1;
d6ed682e DV	160
	161	ret = drm_set_master(dev, fpriv, true);
	162	if (ret)
	163	goto out_err;
	164
6548f4e7 DV	165	if (old_master)
	166	drm_master_put(&old_master);
	167
	168	return 0;
	169
	170	out_err:
d6ed682e	171	/* drop references and restore old master on failure */
6548f4e7 DV	172	drm_master_put(&fpriv->master);
	173	fpriv->master = old_master;
	174
	175	return ret;
	176	}
	177
	178	int drm_setmaster_ioctl(struct drm_device dev, void data,
	179	struct drm_file *file_priv)
	180	{
	181	int ret = 0;
	182
	183	mutex_lock(&dev->master_mutex);
b3ac9f25	184	if (drm_is_current_master(file_priv))
6548f4e7 DV	185	goto out_unlock;
6548f4e7 DV	186
95c081c1	187	if (dev->master) {
6548f4e7 DV	188	ret = -EINVAL;
	189	goto out_unlock;
	190	}
	191
	192	if (!file_priv->master) {
	193	ret = -EINVAL;
	194	goto out_unlock;
	195	}
	196
0aae5920	197	if (!file_priv->is_master) {
6548f4e7 DV	198	ret = drm_new_set_master(dev, file_priv);
	199	goto out_unlock;
	200	}
	201
d6ed682e	202	ret = drm_set_master(dev, file_priv, false);
6548f4e7 DV	203	out_unlock:
	204	mutex_unlock(&dev->master_mutex);
	205	return ret;
	206	}
	207
d6ed682e DV	208	static void drm_drop_master(struct drm_device *dev,
	209	struct drm_file *fpriv)
	210	{
	211	if (dev->driver->master_drop)
	212	dev->driver->master_drop(dev, fpriv);
	213	drm_master_put(&dev->master);
d6ed682e DV	214	}
d6ed682e DV	215
6548f4e7 DV	216	int drm_dropmaster_ioctl(struct drm_device dev, void data,
	217	struct drm_file *file_priv)
	218	{
	219	int ret = -EINVAL;
	220
	221	mutex_lock(&dev->master_mutex);
b3ac9f25	222	if (!drm_is_current_master(file_priv))
6548f4e7 DV	223	goto out_unlock;
6548f4e7 DV	224
95c081c1	225	if (!dev->master)
6548f4e7 DV	226	goto out_unlock;
	227
	228	ret = 0;
d6ed682e	229	drm_drop_master(dev, file_priv);
6548f4e7 DV	230	out_unlock:
	231	mutex_unlock(&dev->master_mutex);
	232	return ret;
	233	}
	234
2cbae7e6 DV	235	int drm_master_open(struct drm_file *file_priv)
	236	{
	237	struct drm_device *dev = file_priv->minor->dev;
	238	int ret = 0;
	239
	240	/* if there is no current master make this fd it, but do not create
	241	* any master object for render clients */
	242	mutex_lock(&dev->master_mutex);
95c081c1	243	if (!dev->master)
2cbae7e6 DV	244	ret = drm_new_set_master(dev, file_priv);
2cbae7e6 DV	245	else
95c081c1	246	file_priv->master = drm_master_get(dev->master);
2cbae7e6 DV	247	mutex_unlock(&dev->master_mutex);
	248
	249	return ret;
	250	}
	251
14d71ebd DV	252	void drm_master_release(struct drm_file *file_priv)
	253	{
	254	struct drm_device *dev = file_priv->minor->dev;
0de4cc99	255	struct drm_master *master = file_priv->master;
14d71ebd	256
d2b34ee6	257	mutex_lock(&dev->master_mutex);
a77316bf DV	258	if (file_priv->magic)
a77316bf DV	259	idr_remove(&file_priv->master->magic_map, file_priv->magic);
a77316bf	260
b3ac9f25	261	if (!drm_is_current_master(file_priv))
0de4cc99	262	goto out;
14d71ebd	263
0de4cc99	264	if (!drm_core_check_feature(dev, DRIVER_MODESET)) {
14d71ebd DV	265	/*
	266	* Since the master is disappearing, so is the
	267	* possibility to lock.
	268	*/
	269	mutex_lock(&dev->struct_mutex);
	270	if (master->lock.hw_lock) {
	271	if (dev->sigdata.lock == master->lock.hw_lock)
	272	dev->sigdata.lock = NULL;
	273	master->lock.hw_lock = NULL;
	274	master->lock.file_priv = NULL;
	275	wake_up_interruptible_all(&master->lock.lock_queue);
	276	}
	277	mutex_unlock(&dev->struct_mutex);
14d71ebd DV	278	}
14d71ebd DV	279
d6ed682e DV	280	if (dev->master == file_priv->master)
d6ed682e DV	281	drm_drop_master(dev, file_priv);
0de4cc99	282	out:
14d71ebd DV	283	/* drop the master reference held by the file priv */
	284	if (file_priv->master)
	285	drm_master_put(&file_priv->master);
14d71ebd DV	286	mutex_unlock(&dev->master_mutex);
	287	}
	288
b3ac9f25 DV	289	bool drm_is_current_master(struct drm_file *fpriv)
b3ac9f25 DV	290	{
0aae5920	291	return fpriv->is_master && fpriv->master == fpriv->minor->dev->master;
b3ac9f25 DV	292	}
	293	EXPORT_SYMBOL(drm_is_current_master);
	294
6548f4e7 DV	295	struct drm_master drm_master_get(struct drm_master master)
	296	{
	297	kref_get(&master->refcount);
	298	return master;
	299	}
	300	EXPORT_SYMBOL(drm_master_get);
	301
	302	static void drm_master_destroy(struct kref *kref)
	303	{
	304	struct drm_master *master = container_of(kref, struct drm_master, refcount);
	305	struct drm_device *dev = master->dev;
	306
	307	if (dev->driver->master_destroy)
	308	dev->driver->master_destroy(dev, master);
	309
	310	drm_legacy_master_rmmaps(dev, master);
	311
	312	idr_destroy(&master->magic_map);
	313	kfree(master->unique);
	314	kfree(master);
	315	}
	316
	317	void drm_master_put(struct drm_master **master)
	318	{
	319	kref_put(&(*master)->refcount, drm_master_destroy);
	320	*master = NULL;
	321	}
	322	EXPORT_SYMBOL(drm_master_put);