[mirror_ubuntu-jammy-kernel.git] / drivers / gpu / drm / drm_syncobj.c

/*
 * Copyright 2017 Red Hat
 *
 * 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
 * THE AUTHORS OR COPYRIGHT HOLDERS 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.
 *
 * Authors:
 *
 */

/**
 * DOC: Overview
 *
 * DRM synchronisation objects (syncobj) are a persistent objects,
 * that contain an optional fence. The fence can be updated with a new
 * fence, or be NULL.
 *
 * syncobj's can be export to fd's and back, these fd's are opaque and
 * have no other use case, except passing the syncobj between processes.
 *
 * Their primary use-case is to implement Vulkan fences and semaphores.
 *
 * syncobj have a kref reference count, but also have an optional file.
 * The file is only created once the syncobj is exported.
 * The file takes a reference on the kref.
 */

#include <drm/drmP.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/anon_inodes.h>
#include <linux/sync_file.h>

#include "drm_internal.h"
#include <drm/drm_syncobj.h>

/**
 * drm_syncobj_find - lookup and reference a sync object.
 * @file_private: drm file private pointer
 * @handle: sync object handle to lookup.
 *
 * Returns a reference to the syncobj pointed to by handle or NULL.
 */
struct drm_syncobj *drm_syncobj_find(struct drm_file *file_private,
				     u32 handle)
{
	struct drm_syncobj *syncobj;

	spin_lock(&file_private->syncobj_table_lock);

	/* Check if we currently have a reference on the object */
	syncobj = idr_find(&file_private->syncobj_idr, handle);
	if (syncobj)
		drm_syncobj_get(syncobj);

	spin_unlock(&file_private->syncobj_table_lock);

	return syncobj;
}
EXPORT_SYMBOL(drm_syncobj_find);

/**
 * drm_syncobj_replace_fence - replace fence in a sync object.
 * @syncobj: Sync object to replace fence in
 * @fence: fence to install in sync file.
 *
 * This replaces the fence on a sync object.
 */
void drm_syncobj_replace_fence(struct drm_syncobj *syncobj,
			       struct dma_fence *fence)
{
	struct dma_fence *old_fence;

	if (fence)
		dma_fence_get(fence);
	old_fence = xchg(&syncobj->fence, fence);

	dma_fence_put(old_fence);
}
EXPORT_SYMBOL(drm_syncobj_replace_fence);

int drm_syncobj_fence_get(struct drm_file *file_private,
			  u32 handle,
			  struct dma_fence **fence)
{
	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
	int ret = 0;

	if (!syncobj)
		return -ENOENT;

	*fence = dma_fence_get(syncobj->fence);
	if (!*fence) {
		ret = -EINVAL;
	}
	drm_syncobj_put(syncobj);
	return ret;
}
EXPORT_SYMBOL(drm_syncobj_fence_get);

/**
 * drm_syncobj_free - free a sync object.
 * @kref: kref to free.
 *
 * Only to be called from kref_put in drm_syncobj_put.
 */
void drm_syncobj_free(struct kref *kref)
{
	struct drm_syncobj *syncobj = container_of(kref,
						   struct drm_syncobj,
						   refcount);
	dma_fence_put(syncobj->fence);
	kfree(syncobj);
}
EXPORT_SYMBOL(drm_syncobj_free);

static int drm_syncobj_create(struct drm_file *file_private,
			      u32 *handle)
{
	int ret;
	struct drm_syncobj *syncobj;

	syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL);
	if (!syncobj)
		return -ENOMEM;

	kref_init(&syncobj->refcount);

	idr_preload(GFP_KERNEL);
	spin_lock(&file_private->syncobj_table_lock);
	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
	spin_unlock(&file_private->syncobj_table_lock);

	idr_preload_end();

	if (ret < 0) {
		drm_syncobj_put(syncobj);
		return ret;
	}

	*handle = ret;
	return 0;
}

static int drm_syncobj_destroy(struct drm_file *file_private,
			       u32 handle)
{
	struct drm_syncobj *syncobj;

	spin_lock(&file_private->syncobj_table_lock);
	syncobj = idr_remove(&file_private->syncobj_idr, handle);
	spin_unlock(&file_private->syncobj_table_lock);

	if (!syncobj)
		return -EINVAL;

	drm_syncobj_put(syncobj);
	return 0;
}

static int drm_syncobj_file_release(struct inode *inode, struct file *file)
{
	struct drm_syncobj *syncobj = file->private_data;

	drm_syncobj_put(syncobj);
	return 0;
}

static const struct file_operations drm_syncobj_file_fops = {
	.release = drm_syncobj_file_release,
};

static int drm_syncobj_alloc_file(struct drm_syncobj *syncobj)
{
	struct file *file = anon_inode_getfile("syncobj_file",
					       &drm_syncobj_file_fops,
					       syncobj, 0);
	if (IS_ERR(file))
		return PTR_ERR(file);

	drm_syncobj_get(syncobj);
	if (cmpxchg(&syncobj->file, NULL, file)) {
		/* lost the race */
		fput(file);
	}

	return 0;
}

static int drm_syncobj_handle_to_fd(struct drm_file *file_private,
				    u32 handle, int *p_fd)
{
	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
	int ret;
	int fd;

	if (!syncobj)
		return -EINVAL;

	fd = get_unused_fd_flags(O_CLOEXEC);
	if (fd < 0) {
		drm_syncobj_put(syncobj);
		return fd;
	}

	if (!syncobj->file) {
		ret = drm_syncobj_alloc_file(syncobj);
		if (ret)
			goto out_put_fd;
	}
	fd_install(fd, syncobj->file);
	drm_syncobj_put(syncobj);
	*p_fd = fd;
	return 0;
out_put_fd:
	put_unused_fd(fd);
	drm_syncobj_put(syncobj);
	return ret;
}

static struct drm_syncobj *drm_syncobj_fdget(int fd)
{
	struct file *file = fget(fd);

	if (!file)
		return NULL;
	if (file->f_op != &drm_syncobj_file_fops)
		goto err;

	return file->private_data;
err:
	fput(file);
	return NULL;
};

static int drm_syncobj_fd_to_handle(struct drm_file *file_private,
				    int fd, u32 *handle)
{
	struct drm_syncobj *syncobj = drm_syncobj_fdget(fd);
	int ret;

	if (!syncobj)
		return -EINVAL;

	/* take a reference to put in the idr */
	drm_syncobj_get(syncobj);

	idr_preload(GFP_KERNEL);
	spin_lock(&file_private->syncobj_table_lock);
	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
	spin_unlock(&file_private->syncobj_table_lock);
	idr_preload_end();

	if (ret < 0) {
		fput(syncobj->file);
		return ret;
	}
	*handle = ret;
	return 0;
}

int drm_syncobj_import_sync_file_fence(struct drm_file *file_private,
				       int fd, int handle)
{
	struct dma_fence *fence = sync_file_get_fence(fd);
	struct drm_syncobj *syncobj;

	if (!fence)
		return -EINVAL;

	syncobj = drm_syncobj_find(file_private, handle);
	if (!syncobj) {
		dma_fence_put(fence);
		return -ENOENT;
	}

	drm_syncobj_replace_fence(syncobj, fence);
	dma_fence_put(fence);
	drm_syncobj_put(syncobj);
	return 0;
}

int drm_syncobj_export_sync_file(struct drm_file *file_private,
				 int handle, int *p_fd)
{
	int ret;
	struct dma_fence *fence;
	struct sync_file *sync_file;
	int fd = get_unused_fd_flags(O_CLOEXEC);

	if (fd < 0)
		return fd;

	ret = drm_syncobj_fence_get(file_private, handle, &fence);
	if (ret)
		goto err_put_fd;

	sync_file = sync_file_create(fence);

	dma_fence_put(fence);

	if (!sync_file) {
		ret = -EINVAL;
		goto err_put_fd;
	}

	fd_install(fd, sync_file->file);

	*p_fd = fd;
	return 0;
err_put_fd:
	put_unused_fd(fd);
	return ret;
}
/**
 * drm_syncobj_open - initalizes syncobj file-private structures at devnode open time
 * @file_private: drm file-private structure to set up
 *
 * Called at device open time, sets up the structure for handling refcounting
 * of sync objects.
 */
void
drm_syncobj_open(struct drm_file *file_private)
{
	idr_init(&file_private->syncobj_idr);
	spin_lock_init(&file_private->syncobj_table_lock);
}

static int
drm_syncobj_release_handle(int id, void *ptr, void *data)
{
	struct drm_syncobj *syncobj = ptr;

	drm_syncobj_put(syncobj);
	return 0;
}

/**
 * drm_syncobj_release - release file-private sync object resources
 * @file_private: drm file-private structure to clean up
 *
 * Called at close time when the filp is going away.
 *
 * Releases any remaining references on objects by this filp.
 */
void
drm_syncobj_release(struct drm_file *file_private)
{
	idr_for_each(&file_private->syncobj_idr,
		     &drm_syncobj_release_handle, file_private);
	idr_destroy(&file_private->syncobj_idr);
}

int
drm_syncobj_create_ioctl(struct drm_device *dev, void *data,
			 struct drm_file *file_private)
{
	struct drm_syncobj_create *args = data;

	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
		return -ENODEV;

	/* no valid flags yet */
	if (args->flags)
		return -EINVAL;

	return drm_syncobj_create(file_private,
				  &args->handle);
}

int
drm_syncobj_destroy_ioctl(struct drm_device *dev, void *data,
			  struct drm_file *file_private)
{
	struct drm_syncobj_destroy *args = data;

	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
		return -ENODEV;

	/* make sure padding is empty */
	if (args->pad)
		return -EINVAL;
	return drm_syncobj_destroy(file_private, args->handle);
}

int
drm_syncobj_handle_to_fd_ioctl(struct drm_device *dev, void *data,
				   struct drm_file *file_private)
{
	struct drm_syncobj_handle *args = data;

	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
		return -ENODEV;

	if (args->pad)
		return -EINVAL;

	if (args->flags != 0 &&
	    args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
		return -EINVAL;

	if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
		return drm_syncobj_export_sync_file(file_private, args->handle,
						    &args->fd);

	return drm_syncobj_handle_to_fd(file_private, args->handle,
					&args->fd);
}

int
drm_syncobj_fd_to_handle_ioctl(struct drm_device *dev, void *data,
				   struct drm_file *file_private)
{
	struct drm_syncobj_handle *args = data;

	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
		return -ENODEV;

	if (args->pad)
		return -EINVAL;

	if (args->flags != 0 &&
	    args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
		return -EINVAL;

	if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
		return drm_syncobj_import_sync_file_fence(file_private,
							  args->fd,
							  args->handle);

	return drm_syncobj_fd_to_handle(file_private, args->fd,
					&args->handle);
}
Commit	Line	Data
e9083420 DA	1	/*
	2	* Copyright 2017 Red Hat
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	21	* IN THE SOFTWARE.
	22	*
	23	* Authors:
	24	*
	25	*/
	26
	27	/**
	28	* DOC: Overview
	29	*
	30	* DRM synchronisation objects (syncobj) are a persistent objects,
	31	* that contain an optional fence. The fence can be updated with a new
	32	* fence, or be NULL.
	33	*
	34	* syncobj's can be export to fd's and back, these fd's are opaque and
	35	* have no other use case, except passing the syncobj between processes.
	36	*
	37	* Their primary use-case is to implement Vulkan fences and semaphores.
	38	*
	39	* syncobj have a kref reference count, but also have an optional file.
	40	* The file is only created once the syncobj is exported.
	41	* The file takes a reference on the kref.
	42	*/
	43
	44	#include <drm/drmP.h>
	45	#include <linux/file.h>
	46	#include <linux/fs.h>
	47	#include <linux/anon_inodes.h>
3ee45a3b	48	#include <linux/sync_file.h>
e9083420 DA	49
	50	#include "drm_internal.h"
	51	#include <drm/drm_syncobj.h>
	52
	53	/**
	54	* drm_syncobj_find - lookup and reference a sync object.
	55	* @file_private: drm file private pointer
	56	* @handle: sync object handle to lookup.
	57	*
	58	* Returns a reference to the syncobj pointed to by handle or NULL.
	59	*/
	60	struct drm_syncobj drm_syncobj_find(struct drm_file file_private,
	61	u32 handle)
	62	{
	63	struct drm_syncobj *syncobj;
	64
	65	spin_lock(&file_private->syncobj_table_lock);
	66
	67	/* Check if we currently have a reference on the object */
	68	syncobj = idr_find(&file_private->syncobj_idr, handle);
	69	if (syncobj)
	70	drm_syncobj_get(syncobj);
	71
	72	spin_unlock(&file_private->syncobj_table_lock);
	73
	74	return syncobj;
	75	}
	76	EXPORT_SYMBOL(drm_syncobj_find);
	77
	78	/**
	79	* drm_syncobj_replace_fence - replace fence in a sync object.
e9083420 DA	80	* @syncobj: Sync object to replace fence in
	81	* @fence: fence to install in sync file.
	82	*
	83	* This replaces the fence on a sync object.
	84	*/
00fc2c26	85	void drm_syncobj_replace_fence(struct drm_syncobj *syncobj,
e9083420 DA	86	struct dma_fence *fence)
e9083420 DA	87	{
00fc2c26	88	struct dma_fence *old_fence;
e9083420 DA	89
	90	if (fence)
	91	dma_fence_get(fence);
	92	old_fence = xchg(&syncobj->fence, fence);
	93
	94	dma_fence_put(old_fence);
	95	}
	96	EXPORT_SYMBOL(drm_syncobj_replace_fence);
	97
	98	int drm_syncobj_fence_get(struct drm_file *file_private,
	99	u32 handle,
	100	struct dma_fence **fence)
	101	{
	102	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
	103	int ret = 0;
	104
	105	if (!syncobj)
	106	return -ENOENT;
	107
	108	*fence = dma_fence_get(syncobj->fence);
	109	if (!*fence) {
	110	ret = -EINVAL;
	111	}
	112	drm_syncobj_put(syncobj);
	113	return ret;
	114	}
	115	EXPORT_SYMBOL(drm_syncobj_fence_get);
	116
	117	/**
	118	* drm_syncobj_free - free a sync object.
	119	* @kref: kref to free.
	120	*
	121	* Only to be called from kref_put in drm_syncobj_put.
	122	*/
	123	void drm_syncobj_free(struct kref *kref)
	124	{
	125	struct drm_syncobj *syncobj = container_of(kref,
	126	struct drm_syncobj,
	127	refcount);
	128	dma_fence_put(syncobj->fence);
	129	kfree(syncobj);
	130	}
	131	EXPORT_SYMBOL(drm_syncobj_free);
	132
	133	static int drm_syncobj_create(struct drm_file *file_private,
	134	u32 *handle)
	135	{
	136	int ret;
	137	struct drm_syncobj *syncobj;
	138
	139	syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL);
	140	if (!syncobj)
	141	return -ENOMEM;
	142
	143	kref_init(&syncobj->refcount);
	144
	145	idr_preload(GFP_KERNEL);
	146	spin_lock(&file_private->syncobj_table_lock);
	147	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
	148	spin_unlock(&file_private->syncobj_table_lock);
	149
	150	idr_preload_end();
	151
	152	if (ret < 0) {
153	drm_syncobj_put(syncobj);
154	return ret;
155	}
156
157	*handle = ret;
158	return 0;
159	}
160
161	static int drm_syncobj_destroy(struct drm_file *file_private,
162	u32 handle)
163	{
164	struct drm_syncobj *syncobj;
165
166	spin_lock(&file_private->syncobj_table_lock);
167	syncobj = idr_remove(&file_private->syncobj_idr, handle);
168	spin_unlock(&file_private->syncobj_table_lock);
169
170	if (!syncobj)
171	return -EINVAL;
172
173	drm_syncobj_put(syncobj);
174	return 0;
175	}
176
177	static int drm_syncobj_file_release(struct inode inode, struct file file)
178	{
179	struct drm_syncobj *syncobj = file->private_data;
180
181	drm_syncobj_put(syncobj);
182	return 0;
183	}
184
185	static const struct file_operations drm_syncobj_file_fops = {
186	.release = drm_syncobj_file_release,
187	};
188
189	static int drm_syncobj_alloc_file(struct drm_syncobj *syncobj)
190	{
191	struct file *file = anon_inode_getfile("syncobj_file",
192	&drm_syncobj_file_fops,
193	syncobj, 0);
194	if (IS_ERR(file))
195	return PTR_ERR(file);
196
197	drm_syncobj_get(syncobj);
198	if (cmpxchg(&syncobj->file, NULL, file)) {
199	/* lost the race */
200	fput(file);
201	}
202
203	return 0;
204	}
205
206	static int drm_syncobj_handle_to_fd(struct drm_file *file_private,
207	u32 handle, int *p_fd)
208	{
209	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
210	int ret;
211	int fd;
212
213	if (!syncobj)
214	return -EINVAL;
215
216	fd = get_unused_fd_flags(O_CLOEXEC);
217	if (fd < 0) {
218	drm_syncobj_put(syncobj);
219	return fd;
220	}
221
222	if (!syncobj->file) {
223	ret = drm_syncobj_alloc_file(syncobj);
224	if (ret)
225	goto out_put_fd;
226	}
227	fd_install(fd, syncobj->file);
228	drm_syncobj_put(syncobj);
229	*p_fd = fd;
230	return 0;
231	out_put_fd:
232	put_unused_fd(fd);
233	drm_syncobj_put(syncobj);
234	return ret;
235	}
236
237	static struct drm_syncobj *drm_syncobj_fdget(int fd)
238	{
239	struct file *file = fget(fd);
240
241	if (!file)
242	return NULL;
243	if (file->f_op != &drm_syncobj_file_fops)
244	goto err;
245
246	return file->private_data;
247	err:
248	fput(file);
249	return NULL;
250	};
251
252	static int drm_syncobj_fd_to_handle(struct drm_file *file_private,
253	int fd, u32 *handle)
254	{
255	struct drm_syncobj *syncobj = drm_syncobj_fdget(fd);
256	int ret;
257
258	if (!syncobj)
259	return -EINVAL;
260
261	/* take a reference to put in the idr */
262	drm_syncobj_get(syncobj);
263
264	idr_preload(GFP_KERNEL);
265	spin_lock(&file_private->syncobj_table_lock);
266	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
267	spin_unlock(&file_private->syncobj_table_lock);
268	idr_preload_end();
269
270	if (ret < 0) {
271	fput(syncobj->file);
272	return ret;
273	}
274	*handle = ret;
275	return 0;
276	}
277
3ee45a3b DA	278	int drm_syncobj_import_sync_file_fence(struct drm_file *file_private,
	279	int fd, int handle)
	280	{
	281	struct dma_fence *fence = sync_file_get_fence(fd);
	282	struct drm_syncobj *syncobj;
	283
	284	if (!fence)
	285	return -EINVAL;
	286
	287	syncobj = drm_syncobj_find(file_private, handle);
	288	if (!syncobj) {
	289	dma_fence_put(fence);
	290	return -ENOENT;
	291	}
	292
00fc2c26	293	drm_syncobj_replace_fence(syncobj, fence);
3ee45a3b DA	294	dma_fence_put(fence);
	295	drm_syncobj_put(syncobj);
	296	return 0;
	297	}
	298
	299	int drm_syncobj_export_sync_file(struct drm_file *file_private,
	300	int handle, int *p_fd)
	301	{
	302	int ret;
	303	struct dma_fence *fence;
	304	struct sync_file *sync_file;
	305	int fd = get_unused_fd_flags(O_CLOEXEC);
	306
	307	if (fd < 0)
	308	return fd;
	309
	310	ret = drm_syncobj_fence_get(file_private, handle, &fence);
	311	if (ret)
	312	goto err_put_fd;
	313
	314	sync_file = sync_file_create(fence);
	315
	316	dma_fence_put(fence);
	317
	318	if (!sync_file) {
	319	ret = -EINVAL;
	320	goto err_put_fd;
	321	}
	322
	323	fd_install(fd, sync_file->file);
	324
	325	*p_fd = fd;
	326	return 0;
	327	err_put_fd:
	328	put_unused_fd(fd);
	329	return ret;
	330	}
e9083420 DA	331	/**
e9083420 DA	332	* drm_syncobj_open - initalizes syncobj file-private structures at devnode open time
e9083420 DA	333	* @file_private: drm file-private structure to set up
	334	*
	335	* Called at device open time, sets up the structure for handling refcounting
	336	* of sync objects.
	337	*/
	338	void
	339	drm_syncobj_open(struct drm_file *file_private)
	340	{
	341	idr_init(&file_private->syncobj_idr);
	342	spin_lock_init(&file_private->syncobj_table_lock);
	343	}
	344
	345	static int
	346	drm_syncobj_release_handle(int id, void ptr, void data)
	347	{
	348	struct drm_syncobj *syncobj = ptr;
	349
	350	drm_syncobj_put(syncobj);
	351	return 0;
	352	}
	353
	354	/**
	355	* drm_syncobj_release - release file-private sync object resources
e9083420 DA	356	* @file_private: drm file-private structure to clean up
	357	*
	358	* Called at close time when the filp is going away.
	359	*
	360	* Releases any remaining references on objects by this filp.
	361	*/
	362	void
	363	drm_syncobj_release(struct drm_file *file_private)
	364	{
	365	idr_for_each(&file_private->syncobj_idr,
	366	&drm_syncobj_release_handle, file_private);
	367	idr_destroy(&file_private->syncobj_idr);
	368	}
	369
	370	int
	371	drm_syncobj_create_ioctl(struct drm_device dev, void data,
	372	struct drm_file *file_private)
	373	{
	374	struct drm_syncobj_create *args = data;
	375
	376	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
	377	return -ENODEV;
	378
	379	/* no valid flags yet */
	380	if (args->flags)
	381	return -EINVAL;
	382
	383	return drm_syncobj_create(file_private,
	384	&args->handle);
	385	}
	386
	387	int
	388	drm_syncobj_destroy_ioctl(struct drm_device dev, void data,
	389	struct drm_file *file_private)
	390	{
	391	struct drm_syncobj_destroy *args = data;
	392
	393	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
	394	return -ENODEV;
	395
	396	/* make sure padding is empty */
	397	if (args->pad)
	398	return -EINVAL;
	399	return drm_syncobj_destroy(file_private, args->handle);
	400	}
	401
	402	int
	403	drm_syncobj_handle_to_fd_ioctl(struct drm_device dev, void data,
	404	struct drm_file *file_private)
	405	{
	406	struct drm_syncobj_handle *args = data;
	407
	408	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
	409	return -ENODEV;
	410
3ee45a3b	411	if (args->pad)
e9083420 DA	412	return -EINVAL;
e9083420 DA	413
3ee45a3b DA	414	if (args->flags != 0 &&
	415	args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
	416	return -EINVAL;
	417
	418	if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
	419	return drm_syncobj_export_sync_file(file_private, args->handle,
	420	&args->fd);
	421
e9083420 DA	422	return drm_syncobj_handle_to_fd(file_private, args->handle,
	423	&args->fd);
	424	}
	425
	426	int
	427	drm_syncobj_fd_to_handle_ioctl(struct drm_device dev, void data,
	428	struct drm_file *file_private)
	429	{
	430	struct drm_syncobj_handle *args = data;
	431
	432	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
	433	return -ENODEV;
	434
3ee45a3b DA	435	if (args->pad)
	436	return -EINVAL;
	437
	438	if (args->flags != 0 &&
	439	args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
e9083420 DA	440	return -EINVAL;
e9083420 DA	441
3ee45a3b DA	442	if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
	443	return drm_syncobj_import_sync_file_fence(file_private,
	444	args->fd,
	445	args->handle);
	446
e9083420 DA	447	return drm_syncobj_fd_to_handle(file_private, args->fd,
	448	&args->handle);
	449	}