[mirror_ubuntu-bionic-kernel.git] / drivers / staging / android / sw_sync.c

/*
 * drivers/dma-buf/sw_sync.c
 *
 * Copyright (C) 2012 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/file.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/sync_file.h>

#include "sync.h"

#define CREATE_TRACE_POINTS
#include "trace/sync.h"

struct sw_sync_create_fence_data {
	__u32	value;
	char	name[32];
	__s32	fence; /* fd of new fence */
};

#define SW_SYNC_IOC_MAGIC	'W'

#define SW_SYNC_IOC_CREATE_FENCE	_IOWR(SW_SYNC_IOC_MAGIC, 0,\
		struct sw_sync_create_fence_data)
#define SW_SYNC_IOC_INC			_IOW(SW_SYNC_IOC_MAGIC, 1, __u32)

static const struct fence_ops timeline_fence_ops;

static inline struct sync_pt *fence_to_sync_pt(struct fence *fence)
{
	if (fence->ops != &timeline_fence_ops)
		return NULL;
	return container_of(fence, struct sync_pt, base);
}

/**
 * sync_timeline_create() - creates a sync object
 * @drv_name:	sync_timeline driver name
 * @name:	sync_timeline name
 *
 * Creates a new sync_timeline. Returns the sync_timeline object or NULL in
 * case of error.
 */
struct sync_timeline *sync_timeline_create(const char *drv_name,
					   const char *name)
{
	struct sync_timeline *obj;

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

	kref_init(&obj->kref);
	obj->context = fence_context_alloc(1);
	strlcpy(obj->name, name, sizeof(obj->name));
	strlcpy(obj->drv_name, drv_name, sizeof(obj->drv_name));

	INIT_LIST_HEAD(&obj->child_list_head);
	INIT_LIST_HEAD(&obj->active_list_head);
	spin_lock_init(&obj->child_list_lock);

	sync_timeline_debug_add(obj);

	return obj;
}

static void sync_timeline_free(struct kref *kref)
{
	struct sync_timeline *obj =
		container_of(kref, struct sync_timeline, kref);

	sync_timeline_debug_remove(obj);

	kfree(obj);
}

static void sync_timeline_get(struct sync_timeline *obj)
{
	kref_get(&obj->kref);
}

static void sync_timeline_put(struct sync_timeline *obj)
{
	kref_put(&obj->kref, sync_timeline_free);
}

/**
 * sync_timeline_destroy() - destroys a sync object
 * @obj:	sync_timeline to destroy
 *
 * A sync implementation should call this when the @obj is going away
 * (i.e. module unload.)  @obj won't actually be freed until all its children
 * fences are freed.
 */
static void sync_timeline_destroy(struct sync_timeline *obj)
{
	smp_wmb();

	sync_timeline_put(obj);
}

/**
 * sync_timeline_signal() - signal a status change on a sync_timeline
 * @obj:	sync_timeline to signal
 * @inc:	num to increment on timeline->value
 *
 * A sync implementation should call this any time one of it's fences
 * has signaled or has an error condition.
 */
static void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
{
	unsigned long flags;
	struct sync_pt *pt, *next;

	trace_sync_timeline(obj);

	spin_lock_irqsave(&obj->child_list_lock, flags);

	obj->value += inc;

	list_for_each_entry_safe(pt, next, &obj->active_list_head,
				 active_list) {
		if (fence_is_signaled_locked(&pt->base))
			list_del_init(&pt->active_list);
	}

	spin_unlock_irqrestore(&obj->child_list_lock, flags);
}

/**
 * sync_pt_create() - creates a sync pt
 * @parent:	fence's parent sync_timeline
 * @size:	size to allocate for this pt
 * @inc:	value of the fence
 *
 * Creates a new sync_pt as a child of @parent.  @size bytes will be
 * allocated allowing for implementation specific data to be kept after
 * the generic sync_timeline struct. Returns the sync_pt object or
 * NULL in case of error.
 */
static struct sync_pt *sync_pt_create(struct sync_timeline *obj, int size,
			     unsigned int value)
{
	unsigned long flags;
	struct sync_pt *pt;

	if (size < sizeof(*pt))
		return NULL;

	pt = kzalloc(size, GFP_KERNEL);
	if (!pt)
		return NULL;

	spin_lock_irqsave(&obj->child_list_lock, flags);
	sync_timeline_get(obj);
	fence_init(&pt->base, &timeline_fence_ops, &obj->child_list_lock,
		   obj->context, value);
	list_add_tail(&pt->child_list, &obj->child_list_head);
	INIT_LIST_HEAD(&pt->active_list);
	spin_unlock_irqrestore(&obj->child_list_lock, flags);
	return pt;
}

static const char *timeline_fence_get_driver_name(struct fence *fence)
{
	struct sync_timeline *parent = fence_parent(fence);

	return parent->drv_name;
}

static const char *timeline_fence_get_timeline_name(struct fence *fence)
{
	struct sync_timeline *parent = fence_parent(fence);

	return parent->name;
}

static void timeline_fence_release(struct fence *fence)
{
	struct sync_pt *pt = fence_to_sync_pt(fence);
	struct sync_timeline *parent = fence_parent(fence);
	unsigned long flags;

	spin_lock_irqsave(fence->lock, flags);
	list_del(&pt->child_list);
	if (WARN_ON_ONCE(!list_empty(&pt->active_list)))
		list_del(&pt->active_list);
	spin_unlock_irqrestore(fence->lock, flags);

	sync_timeline_put(parent);
	fence_free(fence);
}

static bool timeline_fence_signaled(struct fence *fence)
{
	struct sync_timeline *parent = fence_parent(fence);

	return (fence->seqno > parent->value) ? false : true;
}

static bool timeline_fence_enable_signaling(struct fence *fence)
{
	struct sync_pt *pt = fence_to_sync_pt(fence);
	struct sync_timeline *parent = fence_parent(fence);

	if (timeline_fence_signaled(fence))
		return false;

	list_add_tail(&pt->active_list, &parent->active_list_head);
	return true;
}

static void timeline_fence_value_str(struct fence *fence,
				    char *str, int size)
{
	snprintf(str, size, "%d", fence->seqno);
}

static void timeline_fence_timeline_value_str(struct fence *fence,
					     char *str, int size)
{
	struct sync_timeline *parent = fence_parent(fence);

	snprintf(str, size, "%d", parent->value);
}

static const struct fence_ops timeline_fence_ops = {
	.get_driver_name = timeline_fence_get_driver_name,
	.get_timeline_name = timeline_fence_get_timeline_name,
	.enable_signaling = timeline_fence_enable_signaling,
	.signaled = timeline_fence_signaled,
	.wait = fence_default_wait,
	.release = timeline_fence_release,
	.fence_value_str = timeline_fence_value_str,
	.timeline_value_str = timeline_fence_timeline_value_str,
};

/*
 * *WARNING*
 *
 * improper use of this can result in deadlocking kernel drivers from userspace.
 */

/* opening sw_sync create a new sync obj */
static int sw_sync_debugfs_open(struct inode *inode, struct file *file)
{
	struct sync_timeline *obj;
	char task_comm[TASK_COMM_LEN];

	get_task_comm(task_comm, current);

	obj = sync_timeline_create("sw_sync", task_comm);
	if (!obj)
		return -ENOMEM;

	file->private_data = obj;

	return 0;
}

static int sw_sync_debugfs_release(struct inode *inode, struct file *file)
{
	struct sync_timeline *obj = file->private_data;

	sync_timeline_destroy(obj);
	return 0;
}

static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
				       unsigned long arg)
{
	int fd = get_unused_fd_flags(O_CLOEXEC);
	int err;
	struct sync_pt *pt;
	struct sync_file *sync_file;
	struct sw_sync_create_fence_data data;

	if (fd < 0)
		return fd;

	if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
		err = -EFAULT;
		goto err;
	}

	pt = sync_pt_create(obj, sizeof(*pt), data.value);
	if (!pt) {
		err = -ENOMEM;
		goto err;
	}

	sync_file = sync_file_create(&pt->base);
	if (!sync_file) {
		fence_put(&pt->base);
		err = -ENOMEM;
		goto err;
	}

	data.fence = fd;
	if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
		fput(sync_file->file);
		err = -EFAULT;
		goto err;
	}

	fd_install(fd, sync_file->file);

	return 0;

err:
	put_unused_fd(fd);
	return err;
}

static long sw_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
{
	u32 value;

	if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
		return -EFAULT;

	sync_timeline_signal(obj, value);

	return 0;
}

static long sw_sync_ioctl(struct file *file, unsigned int cmd,
			  unsigned long arg)
{
	struct sync_timeline *obj = file->private_data;

	switch (cmd) {
	case SW_SYNC_IOC_CREATE_FENCE:
		return sw_sync_ioctl_create_fence(obj, arg);

	case SW_SYNC_IOC_INC:
		return sw_sync_ioctl_inc(obj, arg);

	default:
		return -ENOTTY;
	}
}

const struct file_operations sw_sync_debugfs_fops = {
	.open           = sw_sync_debugfs_open,
	.release        = sw_sync_debugfs_release,
	.unlocked_ioctl = sw_sync_ioctl,
	.compat_ioctl	= sw_sync_ioctl,
};
Commit	Line	Data
1867a23b GP	1	/*
	2	* drivers/dma-buf/sw_sync.c
	3	*
	4	* Copyright (C) 2012 Google, Inc.
	5	*
	6	* This software is licensed under the terms of the GNU General Public
	7	* License version 2, as published by the Free Software Foundation, and
	8	* may be copied, distributed, and modified under those terms.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	*/
	16
	17	#include <linux/file.h>
	18	#include <linux/fs.h>
	19	#include <linux/uaccess.h>
aff9da10	20	#include <linux/slab.h>
1867a23b GP	21	#include <linux/sync_file.h>
1867a23b GP	22
1867a23b GP	23	#include "sync.h"
1867a23b GP	24
aff9da10 GP	25	#define CREATE_TRACE_POINTS
	26	#include "trace/sync.h"
	27
6f65aa89 GP	28	struct sw_sync_create_fence_data {
	29	__u32 value;
	30	char name[32];
	31	__s32 fence; /* fd of new fence */
	32	};
	33
	34	#define SW_SYNC_IOC_MAGIC 'W'
	35
	36	#define SW_SYNC_IOC_CREATE_FENCE _IOWR(SW_SYNC_IOC_MAGIC, 0,\
	37	struct sw_sync_create_fence_data)
	38	#define SW_SYNC_IOC_INC _IOW(SW_SYNC_IOC_MAGIC, 1, __u32)
	39
aff9da10 GP	40	static const struct fence_ops timeline_fence_ops;
	41
	42	static inline struct sync_pt fence_to_sync_pt(struct fence fence)
	43	{
	44	if (fence->ops != &timeline_fence_ops)
	45	return NULL;
	46	return container_of(fence, struct sync_pt, base);
	47	}
	48
	49	/**
	50	* sync_timeline_create() - creates a sync object
	51	* @drv_name: sync_timeline driver name
	52	* @name: sync_timeline name
	53	*
	54	* Creates a new sync_timeline. Returns the sync_timeline object or NULL in
	55	* case of error.
	56	*/
	57	struct sync_timeline sync_timeline_create(const char drv_name,
	58	const char *name)
	59	{
	60	struct sync_timeline *obj;
	61
	62	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
	63	if (!obj)
	64	return NULL;
	65
	66	kref_init(&obj->kref);
	67	obj->context = fence_context_alloc(1);
	68	strlcpy(obj->name, name, sizeof(obj->name));
	69	strlcpy(obj->drv_name, drv_name, sizeof(obj->drv_name));
	70
	71	INIT_LIST_HEAD(&obj->child_list_head);
	72	INIT_LIST_HEAD(&obj->active_list_head);
	73	spin_lock_init(&obj->child_list_lock);
	74
	75	sync_timeline_debug_add(obj);
	76
	77	return obj;
	78	}
	79
	80	static void sync_timeline_free(struct kref *kref)
	81	{
	82	struct sync_timeline *obj =
	83	container_of(kref, struct sync_timeline, kref);
	84
	85	sync_timeline_debug_remove(obj);
	86
	87	kfree(obj);
	88	}
	89
	90	static void sync_timeline_get(struct sync_timeline *obj)
	91	{
	92	kref_get(&obj->kref);
	93	}
	94
	95	static void sync_timeline_put(struct sync_timeline *obj)
	96	{
	97	kref_put(&obj->kref, sync_timeline_free);
	98	}
	99
	100	/**
	101	* sync_timeline_destroy() - destroys a sync object
	102	* @obj: sync_timeline to destroy
	103	*
104	* A sync implementation should call this when the @obj is going away
105	* (i.e. module unload.) @obj won't actually be freed until all its children
106	* fences are freed.
107	*/
108	static void sync_timeline_destroy(struct sync_timeline *obj)
109	{
aff9da10 GP	110	smp_wmb();
	111
	112	sync_timeline_put(obj);
	113	}
	114
	115	/**
	116	* sync_timeline_signal() - signal a status change on a sync_timeline
	117	* @obj: sync_timeline to signal
	118	* @inc: num to increment on timeline->value
	119	*
	120	* A sync implementation should call this any time one of it's fences
	121	* has signaled or has an error condition.
	122	*/
	123	static void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
	124	{
	125	unsigned long flags;
	126	struct sync_pt pt, next;
	127
	128	trace_sync_timeline(obj);
	129
	130	spin_lock_irqsave(&obj->child_list_lock, flags);
	131
	132	obj->value += inc;
	133
	134	list_for_each_entry_safe(pt, next, &obj->active_list_head,
	135	active_list) {
	136	if (fence_is_signaled_locked(&pt->base))
	137	list_del_init(&pt->active_list);
	138	}
	139
	140	spin_unlock_irqrestore(&obj->child_list_lock, flags);
	141	}
	142
	143	/**
	144	* sync_pt_create() - creates a sync pt
	145	* @parent: fence's parent sync_timeline
	146	* @size: size to allocate for this pt
	147	* @inc: value of the fence
	148	*
	149	* Creates a new sync_pt as a child of @parent. @size bytes will be
	150	* allocated allowing for implementation specific data to be kept after
	151	* the generic sync_timeline struct. Returns the sync_pt object or
	152	* NULL in case of error.
	153	*/
	154	static struct sync_pt sync_pt_create(struct sync_timeline obj, int size,
	155	unsigned int value)
	156	{
	157	unsigned long flags;
	158	struct sync_pt *pt;
	159
	160	if (size < sizeof(*pt))
	161	return NULL;
	162
	163	pt = kzalloc(size, GFP_KERNEL);
	164	if (!pt)
	165	return NULL;
	166
	167	spin_lock_irqsave(&obj->child_list_lock, flags);
	168	sync_timeline_get(obj);
	169	fence_init(&pt->base, &timeline_fence_ops, &obj->child_list_lock,
	170	obj->context, value);
	171	list_add_tail(&pt->child_list, &obj->child_list_head);
	172	INIT_LIST_HEAD(&pt->active_list);
	173	spin_unlock_irqrestore(&obj->child_list_lock, flags);
174	return pt;
175	}
176
177	static const char timeline_fence_get_driver_name(struct fence fence)
178	{
179	struct sync_timeline *parent = fence_parent(fence);
180
181	return parent->drv_name;
182	}
183
184	static const char timeline_fence_get_timeline_name(struct fence fence)
185	{
186	struct sync_timeline *parent = fence_parent(fence);
187
188	return parent->name;
189	}
190
191	static void timeline_fence_release(struct fence *fence)
192	{
193	struct sync_pt *pt = fence_to_sync_pt(fence);
194	struct sync_timeline *parent = fence_parent(fence);
195	unsigned long flags;
196
197	spin_lock_irqsave(fence->lock, flags);
198	list_del(&pt->child_list);
199	if (WARN_ON_ONCE(!list_empty(&pt->active_list)))
200	list_del(&pt->active_list);
201	spin_unlock_irqrestore(fence->lock, flags);
202
203	sync_timeline_put(parent);
204	fence_free(fence);
205	}
206
207	static bool timeline_fence_signaled(struct fence *fence)
208	{
209	struct sync_timeline *parent = fence_parent(fence);
210
211	return (fence->seqno > parent->value) ? false : true;
212	}
213
214	static bool timeline_fence_enable_signaling(struct fence *fence)
215	{
216	struct sync_pt *pt = fence_to_sync_pt(fence);
217	struct sync_timeline *parent = fence_parent(fence);
218
219	if (timeline_fence_signaled(fence))
220	return false;
221
222	list_add_tail(&pt->active_list, &parent->active_list_head);
223	return true;
224	}
225
226	static void timeline_fence_value_str(struct fence *fence,
227	char *str, int size)
228	{
229	snprintf(str, size, "%d", fence->seqno);
230	}
231
232	static void timeline_fence_timeline_value_str(struct fence *fence,
233	char *str, int size)
234	{
235	struct sync_timeline *parent = fence_parent(fence);
236
237	snprintf(str, size, "%d", parent->value);
238	}
239
240	static const struct fence_ops timeline_fence_ops = {
241	.get_driver_name = timeline_fence_get_driver_name,
242	.get_timeline_name = timeline_fence_get_timeline_name,
243	.enable_signaling = timeline_fence_enable_signaling,
244	.signaled = timeline_fence_signaled,
245	.wait = fence_default_wait,
246	.release = timeline_fence_release,
247	.fence_value_str = timeline_fence_value_str,
248	.timeline_value_str = timeline_fence_timeline_value_str,
249	};
250
1867a23b GP	251	/*
	252	* WARNING
	253	*
	254	* improper use of this can result in deadlocking kernel drivers from userspace.
	255	*/
	256
	257	/* opening sw_sync create a new sync obj */
	258	static int sw_sync_debugfs_open(struct inode inode, struct file file)
	259	{
	260	struct sync_timeline *obj;
	261	char task_comm[TASK_COMM_LEN];
	262
	263	get_task_comm(task_comm, current);
	264
	265	obj = sync_timeline_create("sw_sync", task_comm);
	266	if (!obj)
	267	return -ENOMEM;
	268
	269	file->private_data = obj;
	270
	271	return 0;
	272	}
	273
	274	static int sw_sync_debugfs_release(struct inode inode, struct file file)
	275	{
	276	struct sync_timeline *obj = file->private_data;
	277
	278	sync_timeline_destroy(obj);
	279	return 0;
	280	}
	281
	282	static long sw_sync_ioctl_create_fence(struct sync_timeline *obj,
	283	unsigned long arg)
	284	{
	285	int fd = get_unused_fd_flags(O_CLOEXEC);
	286	int err;
	287	struct sync_pt *pt;
	288	struct sync_file *sync_file;
	289	struct sw_sync_create_fence_data data;
	290
	291	if (fd < 0)
	292	return fd;
	293
	294	if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
	295	err = -EFAULT;
	296	goto err;
	297	}
	298
	299	pt = sync_pt_create(obj, sizeof(*pt), data.value);
	300	if (!pt) {
	301	err = -ENOMEM;
	302	goto err;
	303	}
	304
	305	sync_file = sync_file_create(&pt->base);
	306	if (!sync_file) {
	307	fence_put(&pt->base);
	308	err = -ENOMEM;
	309	goto err;
	310	}
	311
	312	data.fence = fd;
	313	if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
	314	fput(sync_file->file);
315	err = -EFAULT;
316	goto err;
317	}
318
319	fd_install(fd, sync_file->file);
320
321	return 0;
322
323	err:
324	put_unused_fd(fd);
325	return err;
326	}
327
328	static long sw_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
329	{
330	u32 value;
331
332	if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
333	return -EFAULT;
334
335	sync_timeline_signal(obj, value);
336
337	return 0;
338	}
339
340	static long sw_sync_ioctl(struct file *file, unsigned int cmd,
341	unsigned long arg)
342	{
343	struct sync_timeline *obj = file->private_data;
344
345	switch (cmd) {
346	case SW_SYNC_IOC_CREATE_FENCE:
347	return sw_sync_ioctl_create_fence(obj, arg);
348
349	case SW_SYNC_IOC_INC:
350	return sw_sync_ioctl_inc(obj, arg);
351
352	default:
353	return -ENOTTY;
354	}
355	}
356
357	const struct file_operations sw_sync_debugfs_fops = {
358	.open = sw_sync_debugfs_open,
359	.release = sw_sync_debugfs_release,
360	.unlocked_ioctl = sw_sync_ioctl,
361	.compat_ioctl = sw_sync_ioctl,
362	};