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