blob: f08cf2d8309eaf233e4ba31280c9609c2d34b6e5 [file] [log] [blame]
Gustavo Padovand4cab382016-04-28 10:46:54 -03001/*
2 * drivers/dma-buf/sync_file.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/export.h>
18#include <linux/file.h>
19#include <linux/fs.h>
20#include <linux/kernel.h>
21#include <linux/poll.h>
22#include <linux/sched.h>
23#include <linux/slab.h>
24#include <linux/uaccess.h>
25#include <linux/anon_inodes.h>
Gustavo Padovan460bfc42016-04-28 10:46:57 -030026#include <linux/sync_file.h>
27#include <uapi/linux/sync_file.h>
Gustavo Padovand4cab382016-04-28 10:46:54 -030028
29static const struct file_operations sync_file_fops;
30
31static struct sync_file *sync_file_alloc(int size)
32{
33 struct sync_file *sync_file;
34
35 sync_file = kzalloc(size, GFP_KERNEL);
36 if (!sync_file)
37 return NULL;
38
39 sync_file->file = anon_inode_getfile("sync_file", &sync_file_fops,
40 sync_file, 0);
41 if (IS_ERR(sync_file->file))
42 goto err;
43
44 kref_init(&sync_file->kref);
45
46 init_waitqueue_head(&sync_file->wq);
47
48 return sync_file;
49
50err:
51 kfree(sync_file);
52 return NULL;
53}
54
55static void fence_check_cb_func(struct fence *f, struct fence_cb *cb)
56{
57 struct sync_file_cb *check;
58 struct sync_file *sync_file;
59
60 check = container_of(cb, struct sync_file_cb, cb);
61 sync_file = check->sync_file;
62
63 if (atomic_dec_and_test(&sync_file->status))
64 wake_up_all(&sync_file->wq);
65}
66
67/**
Gustavo Padovanc240a712016-04-28 10:46:55 -030068 * sync_file_create() - creates a sync file
Gustavo Padovand4cab382016-04-28 10:46:54 -030069 * @fence: fence to add to the sync_fence
70 *
71 * Creates a sync_file containg @fence. Once this is called, the sync_file
Gustavo Padovanc240a712016-04-28 10:46:55 -030072 * takes ownership of @fence. The sync_file can be released with
73 * fput(sync_file->file). Returns the sync_file or NULL in case of error.
Gustavo Padovand4cab382016-04-28 10:46:54 -030074 */
75struct sync_file *sync_file_create(struct fence *fence)
76{
77 struct sync_file *sync_file;
78
79 sync_file = sync_file_alloc(offsetof(struct sync_file, cbs[1]));
80 if (!sync_file)
81 return NULL;
82
83 sync_file->num_fences = 1;
84 atomic_set(&sync_file->status, 1);
85 snprintf(sync_file->name, sizeof(sync_file->name), "%s-%s%d-%d",
86 fence->ops->get_driver_name(fence),
87 fence->ops->get_timeline_name(fence), fence->context,
88 fence->seqno);
89
90 sync_file->cbs[0].fence = fence;
91 sync_file->cbs[0].sync_file = sync_file;
92 if (fence_add_callback(fence, &sync_file->cbs[0].cb,
93 fence_check_cb_func))
94 atomic_dec(&sync_file->status);
95
96 return sync_file;
97}
98EXPORT_SYMBOL(sync_file_create);
99
100/**
101 * sync_file_fdget() - get a sync_file from an fd
102 * @fd: fd referencing a fence
103 *
104 * Ensures @fd references a valid sync_file, increments the refcount of the
105 * backing file. Returns the sync_file or NULL in case of error.
106 */
107static struct sync_file *sync_file_fdget(int fd)
108{
109 struct file *file = fget(fd);
110
111 if (!file)
112 return NULL;
113
114 if (file->f_op != &sync_file_fops)
115 goto err;
116
117 return file->private_data;
118
119err:
120 fput(file);
121 return NULL;
122}
123
124static void sync_file_add_pt(struct sync_file *sync_file, int *i,
125 struct fence *fence)
126{
127 sync_file->cbs[*i].fence = fence;
128 sync_file->cbs[*i].sync_file = sync_file;
129
130 if (!fence_add_callback(fence, &sync_file->cbs[*i].cb,
131 fence_check_cb_func)) {
132 fence_get(fence);
133 (*i)++;
134 }
135}
136
137/**
138 * sync_file_merge() - merge two sync_files
139 * @name: name of new fence
140 * @a: sync_file a
141 * @b: sync_file b
142 *
143 * Creates a new sync_file which contains copies of all the fences in both
144 * @a and @b. @a and @b remain valid, independent sync_file. Returns the
145 * new merged sync_file or NULL in case of error.
146 */
147static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
148 struct sync_file *b)
149{
150 int num_fences = a->num_fences + b->num_fences;
151 struct sync_file *sync_file;
152 int i, i_a, i_b;
153 unsigned long size = offsetof(struct sync_file, cbs[num_fences]);
154
155 sync_file = sync_file_alloc(size);
156 if (!sync_file)
157 return NULL;
158
159 atomic_set(&sync_file->status, num_fences);
160
161 /*
162 * Assume sync_file a and b are both ordered and have no
163 * duplicates with the same context.
164 *
165 * If a sync_file can only be created with sync_file_merge
166 * and sync_file_create, this is a reasonable assumption.
167 */
168 for (i = i_a = i_b = 0; i_a < a->num_fences && i_b < b->num_fences; ) {
169 struct fence *pt_a = a->cbs[i_a].fence;
170 struct fence *pt_b = b->cbs[i_b].fence;
171
172 if (pt_a->context < pt_b->context) {
173 sync_file_add_pt(sync_file, &i, pt_a);
174
175 i_a++;
176 } else if (pt_a->context > pt_b->context) {
177 sync_file_add_pt(sync_file, &i, pt_b);
178
179 i_b++;
180 } else {
181 if (pt_a->seqno - pt_b->seqno <= INT_MAX)
182 sync_file_add_pt(sync_file, &i, pt_a);
183 else
184 sync_file_add_pt(sync_file, &i, pt_b);
185
186 i_a++;
187 i_b++;
188 }
189 }
190
191 for (; i_a < a->num_fences; i_a++)
192 sync_file_add_pt(sync_file, &i, a->cbs[i_a].fence);
193
194 for (; i_b < b->num_fences; i_b++)
195 sync_file_add_pt(sync_file, &i, b->cbs[i_b].fence);
196
197 if (num_fences > i)
198 atomic_sub(num_fences - i, &sync_file->status);
199 sync_file->num_fences = i;
200
201 strlcpy(sync_file->name, name, sizeof(sync_file->name));
202 return sync_file;
203}
204
205static void sync_file_free(struct kref *kref)
206{
207 struct sync_file *sync_file = container_of(kref, struct sync_file,
208 kref);
209 int i;
210
211 for (i = 0; i < sync_file->num_fences; ++i) {
212 fence_remove_callback(sync_file->cbs[i].fence,
213 &sync_file->cbs[i].cb);
214 fence_put(sync_file->cbs[i].fence);
215 }
216
217 kfree(sync_file);
218}
219
220static int sync_file_release(struct inode *inode, struct file *file)
221{
222 struct sync_file *sync_file = file->private_data;
223
224 kref_put(&sync_file->kref, sync_file_free);
225 return 0;
226}
227
228static unsigned int sync_file_poll(struct file *file, poll_table *wait)
229{
230 struct sync_file *sync_file = file->private_data;
231 int status;
232
233 poll_wait(file, &sync_file->wq, wait);
234
235 status = atomic_read(&sync_file->status);
236
237 if (!status)
238 return POLLIN;
239 if (status < 0)
240 return POLLERR;
241 return 0;
242}
243
244static long sync_file_ioctl_merge(struct sync_file *sync_file,
Gustavo Padovan92e06212016-04-28 10:46:56 -0300245 unsigned long arg)
Gustavo Padovand4cab382016-04-28 10:46:54 -0300246{
247 int fd = get_unused_fd_flags(O_CLOEXEC);
248 int err;
249 struct sync_file *fence2, *fence3;
250 struct sync_merge_data data;
251
252 if (fd < 0)
253 return fd;
254
255 if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
256 err = -EFAULT;
257 goto err_put_fd;
258 }
259
260 if (data.flags || data.pad) {
261 err = -EINVAL;
262 goto err_put_fd;
263 }
264
265 fence2 = sync_file_fdget(data.fd2);
266 if (!fence2) {
267 err = -ENOENT;
268 goto err_put_fd;
269 }
270
271 data.name[sizeof(data.name) - 1] = '\0';
272 fence3 = sync_file_merge(data.name, sync_file, fence2);
273 if (!fence3) {
274 err = -ENOMEM;
275 goto err_put_fence2;
276 }
277
278 data.fence = fd;
279 if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
280 err = -EFAULT;
281 goto err_put_fence3;
282 }
283
284 fd_install(fd, fence3->file);
285 fput(fence2->file);
286 return 0;
287
288err_put_fence3:
289 fput(fence3->file);
290
291err_put_fence2:
292 fput(fence2->file);
293
294err_put_fd:
295 put_unused_fd(fd);
296 return err;
297}
298
299static void sync_fill_fence_info(struct fence *fence,
Gustavo Padovan92e06212016-04-28 10:46:56 -0300300 struct sync_fence_info *info)
Gustavo Padovand4cab382016-04-28 10:46:54 -0300301{
302 strlcpy(info->obj_name, fence->ops->get_timeline_name(fence),
303 sizeof(info->obj_name));
304 strlcpy(info->driver_name, fence->ops->get_driver_name(fence),
305 sizeof(info->driver_name));
306 if (fence_is_signaled(fence))
307 info->status = fence->status >= 0 ? 1 : fence->status;
308 else
309 info->status = 0;
310 info->timestamp_ns = ktime_to_ns(fence->timestamp);
311}
312
313static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
Gustavo Padovan92e06212016-04-28 10:46:56 -0300314 unsigned long arg)
Gustavo Padovand4cab382016-04-28 10:46:54 -0300315{
316 struct sync_file_info info;
317 struct sync_fence_info *fence_info = NULL;
318 __u32 size;
319 int ret, i;
320
321 if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
322 return -EFAULT;
323
324 if (info.flags || info.pad)
325 return -EINVAL;
326
327 /*
328 * Passing num_fences = 0 means that userspace doesn't want to
329 * retrieve any sync_fence_info. If num_fences = 0 we skip filling
330 * sync_fence_info and return the actual number of fences on
331 * info->num_fences.
332 */
333 if (!info.num_fences)
334 goto no_fences;
335
336 if (info.num_fences < sync_file->num_fences)
337 return -EINVAL;
338
339 size = sync_file->num_fences * sizeof(*fence_info);
340 fence_info = kzalloc(size, GFP_KERNEL);
341 if (!fence_info)
342 return -ENOMEM;
343
344 for (i = 0; i < sync_file->num_fences; ++i)
345 sync_fill_fence_info(sync_file->cbs[i].fence, &fence_info[i]);
346
347 if (copy_to_user(u64_to_user_ptr(info.sync_fence_info), fence_info,
348 size)) {
349 ret = -EFAULT;
350 goto out;
351 }
352
353no_fences:
354 strlcpy(info.name, sync_file->name, sizeof(info.name));
355 info.status = atomic_read(&sync_file->status);
356 if (info.status >= 0)
357 info.status = !info.status;
358
359 info.num_fences = sync_file->num_fences;
360
361 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
362 ret = -EFAULT;
363 else
364 ret = 0;
365
366out:
367 kfree(fence_info);
368
369 return ret;
370}
371
372static long sync_file_ioctl(struct file *file, unsigned int cmd,
Gustavo Padovan92e06212016-04-28 10:46:56 -0300373 unsigned long arg)
Gustavo Padovand4cab382016-04-28 10:46:54 -0300374{
375 struct sync_file *sync_file = file->private_data;
376
377 switch (cmd) {
378 case SYNC_IOC_MERGE:
379 return sync_file_ioctl_merge(sync_file, arg);
380
381 case SYNC_IOC_FILE_INFO:
382 return sync_file_ioctl_fence_info(sync_file, arg);
383
384 default:
385 return -ENOTTY;
386 }
387}
388
389static const struct file_operations sync_file_fops = {
390 .release = sync_file_release,
391 .poll = sync_file_poll,
392 .unlocked_ioctl = sync_file_ioctl,
393 .compat_ioctl = sync_file_ioctl,
394};
395