• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * drivers/base/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/kernel.h>
18 #include <linux/init.h>
19 #include <linux/export.h>
20 #include <linux/file.h>
21 #include <linux/fs.h>
22 #include <linux/miscdevice.h>
23 #include <linux/syscalls.h>
24 #include <linux/uaccess.h>
25 
26 #include "sw_sync.h"
27 
sw_sync_cmp(u32 a,u32 b)28 static int sw_sync_cmp(u32 a, u32 b)
29 {
30 	if (a == b)
31 		return 0;
32 
33 	return ((s32)a - (s32)b) < 0 ? -1 : 1;
34 }
35 
sw_sync_pt_create(struct sw_sync_timeline * obj,u32 value)36 struct sync_pt *sw_sync_pt_create(struct sw_sync_timeline *obj, u32 value)
37 {
38 	struct sw_sync_pt *pt;
39 
40 	pt = (struct sw_sync_pt *)
41 		sync_pt_create(&obj->obj, sizeof(struct sw_sync_pt));
42 
43 	pt->value = value;
44 
45 	return (struct sync_pt *)pt;
46 }
47 EXPORT_SYMBOL(sw_sync_pt_create);
48 
sw_sync_pt_dup(struct sync_pt * sync_pt)49 static struct sync_pt *sw_sync_pt_dup(struct sync_pt *sync_pt)
50 {
51 	struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
52 	struct sw_sync_timeline *obj =
53 		(struct sw_sync_timeline *)sync_pt_parent(sync_pt);
54 
55 	return (struct sync_pt *)sw_sync_pt_create(obj, pt->value);
56 }
57 
sw_sync_pt_has_signaled(struct sync_pt * sync_pt)58 static int sw_sync_pt_has_signaled(struct sync_pt *sync_pt)
59 {
60 	struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
61 	struct sw_sync_timeline *obj =
62 		(struct sw_sync_timeline *)sync_pt_parent(sync_pt);
63 
64 	return sw_sync_cmp(obj->value, pt->value) >= 0;
65 }
66 
sw_sync_pt_compare(struct sync_pt * a,struct sync_pt * b)67 static int sw_sync_pt_compare(struct sync_pt *a, struct sync_pt *b)
68 {
69 	struct sw_sync_pt *pt_a = (struct sw_sync_pt *)a;
70 	struct sw_sync_pt *pt_b = (struct sw_sync_pt *)b;
71 
72 	return sw_sync_cmp(pt_a->value, pt_b->value);
73 }
74 
sw_sync_fill_driver_data(struct sync_pt * sync_pt,void * data,int size)75 static int sw_sync_fill_driver_data(struct sync_pt *sync_pt,
76 				    void *data, int size)
77 {
78 	struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
79 
80 	if (size < sizeof(pt->value))
81 		return -ENOMEM;
82 
83 	memcpy(data, &pt->value, sizeof(pt->value));
84 
85 	return sizeof(pt->value);
86 }
87 
sw_sync_timeline_value_str(struct sync_timeline * sync_timeline,char * str,int size)88 static void sw_sync_timeline_value_str(struct sync_timeline *sync_timeline,
89 				       char *str, int size)
90 {
91 	struct sw_sync_timeline *timeline =
92 		(struct sw_sync_timeline *)sync_timeline;
93 	snprintf(str, size, "%d", timeline->value);
94 }
95 
sw_sync_pt_value_str(struct sync_pt * sync_pt,char * str,int size)96 static void sw_sync_pt_value_str(struct sync_pt *sync_pt,
97 				 char *str, int size)
98 {
99 	struct sw_sync_pt *pt = (struct sw_sync_pt *)sync_pt;
100 
101 	snprintf(str, size, "%d", pt->value);
102 }
103 
104 static struct sync_timeline_ops sw_sync_timeline_ops = {
105 	.driver_name = "sw_sync",
106 	.dup = sw_sync_pt_dup,
107 	.has_signaled = sw_sync_pt_has_signaled,
108 	.compare = sw_sync_pt_compare,
109 	.fill_driver_data = sw_sync_fill_driver_data,
110 	.timeline_value_str = sw_sync_timeline_value_str,
111 	.pt_value_str = sw_sync_pt_value_str,
112 };
113 
sw_sync_timeline_create(const char * name)114 struct sw_sync_timeline *sw_sync_timeline_create(const char *name)
115 {
116 	struct sw_sync_timeline *obj = (struct sw_sync_timeline *)
117 		sync_timeline_create(&sw_sync_timeline_ops,
118 				     sizeof(struct sw_sync_timeline),
119 				     name);
120 
121 	return obj;
122 }
123 EXPORT_SYMBOL(sw_sync_timeline_create);
124 
sw_sync_timeline_inc(struct sw_sync_timeline * obj,u32 inc)125 void sw_sync_timeline_inc(struct sw_sync_timeline *obj, u32 inc)
126 {
127 	obj->value += inc;
128 
129 	sync_timeline_signal(&obj->obj);
130 }
131 EXPORT_SYMBOL(sw_sync_timeline_inc);
132 
133 #ifdef CONFIG_SW_SYNC_USER
134 /* *WARNING*
135  *
136  * improper use of this can result in deadlocking kernel drivers from userspace.
137  */
138 
139 /* opening sw_sync create a new sync obj */
sw_sync_open(struct inode * inode,struct file * file)140 static int sw_sync_open(struct inode *inode, struct file *file)
141 {
142 	struct sw_sync_timeline *obj;
143 	char task_comm[TASK_COMM_LEN];
144 
145 	get_task_comm(task_comm, current);
146 
147 	obj = sw_sync_timeline_create(task_comm);
148 	if (!obj)
149 		return -ENOMEM;
150 
151 	file->private_data = obj;
152 
153 	return 0;
154 }
155 
sw_sync_release(struct inode * inode,struct file * file)156 static int sw_sync_release(struct inode *inode, struct file *file)
157 {
158 	struct sw_sync_timeline *obj = file->private_data;
159 
160 	sync_timeline_destroy(&obj->obj);
161 	return 0;
162 }
163 
sw_sync_ioctl_create_fence(struct sw_sync_timeline * obj,unsigned long arg)164 static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj,
165 				       unsigned long arg)
166 {
167 	int fd = get_unused_fd_flags(O_CLOEXEC);
168 	int err;
169 	struct sync_pt *pt;
170 	struct sync_fence *fence;
171 	struct sw_sync_create_fence_data data;
172 
173 	if (fd < 0)
174 		return fd;
175 
176 	if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
177 		err = -EFAULT;
178 		goto err;
179 	}
180 
181 	pt = sw_sync_pt_create(obj, data.value);
182 	if (!pt) {
183 		err = -ENOMEM;
184 		goto err;
185 	}
186 
187 	data.name[sizeof(data.name) - 1] = '\0';
188 	fence = sync_fence_create(data.name, pt);
189 	if (!fence) {
190 		sync_pt_free(pt);
191 		err = -ENOMEM;
192 		goto err;
193 	}
194 
195 	data.fence = fd;
196 	if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
197 		sync_fence_put(fence);
198 		err = -EFAULT;
199 		goto err;
200 	}
201 
202 	sync_fence_install(fence, fd);
203 
204 	return 0;
205 
206 err:
207 	put_unused_fd(fd);
208 	return err;
209 }
210 
sw_sync_ioctl_inc(struct sw_sync_timeline * obj,unsigned long arg)211 static long sw_sync_ioctl_inc(struct sw_sync_timeline *obj, unsigned long arg)
212 {
213 	u32 value;
214 
215 	if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
216 		return -EFAULT;
217 
218 	sw_sync_timeline_inc(obj, value);
219 
220 	return 0;
221 }
222 
sw_sync_ioctl(struct file * file,unsigned int cmd,unsigned long arg)223 static long sw_sync_ioctl(struct file *file, unsigned int cmd,
224 			  unsigned long arg)
225 {
226 	struct sw_sync_timeline *obj = file->private_data;
227 
228 	switch (cmd) {
229 	case SW_SYNC_IOC_CREATE_FENCE:
230 		return sw_sync_ioctl_create_fence(obj, arg);
231 
232 	case SW_SYNC_IOC_INC:
233 		return sw_sync_ioctl_inc(obj, arg);
234 
235 	default:
236 		return -ENOTTY;
237 	}
238 }
239 
240 static const struct file_operations sw_sync_fops = {
241 	.owner = THIS_MODULE,
242 	.open = sw_sync_open,
243 	.release = sw_sync_release,
244 	.unlocked_ioctl = sw_sync_ioctl,
245 	.compat_ioctl = sw_sync_ioctl,
246 };
247 
248 static struct miscdevice sw_sync_dev = {
249 	.minor	= MISC_DYNAMIC_MINOR,
250 	.name	= "sw_sync",
251 	.fops	= &sw_sync_fops,
252 };
253 
sw_sync_device_init(void)254 static int __init sw_sync_device_init(void)
255 {
256 	return misc_register(&sw_sync_dev);
257 }
258 device_initcall(sw_sync_device_init);
259 
260 #endif /* CONFIG_SW_SYNC_USER */
261