xref: /linux/drivers/dma-buf/sync_file.c (revision 908fc4c2) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * drivers/dma-buf/sync_file.c
4  *
5  * Copyright (C) 2012 Google, Inc.
6  */
7 
8 #include <linux/dma-fence-unwrap.h>
9 #include <linux/export.h>
10 #include <linux/file.h>
11 #include <linux/fs.h>
12 #include <linux/kernel.h>
13 #include <linux/poll.h>
14 #include <linux/sched.h>
15 #include <linux/slab.h>
16 #include <linux/uaccess.h>
17 #include <linux/anon_inodes.h>
18 #include <linux/sync_file.h>
19 #include <uapi/linux/sync_file.h>
20 
21 static const struct file_operations sync_file_fops;
22 
23 static struct sync_file *sync_file_alloc(void)
24 {
25 	struct sync_file *sync_file;
26 
27 	sync_file = kzalloc(sizeof(*sync_file), GFP_KERNEL);
28 	if (!sync_file)
29 		return NULL;
30 
31 	sync_file->file = anon_inode_getfile("sync_file", &sync_file_fops,
32 					     sync_file, 0);
33 	if (IS_ERR(sync_file->file))
34 		goto err;
35 
36 	init_waitqueue_head(&sync_file->wq);
37 
38 	INIT_LIST_HEAD(&sync_file->cb.node);
39 
40 	return sync_file;
41 
42 err:
43 	kfree(sync_file);
44 	return NULL;
45 }
46 
47 static void fence_check_cb_func(struct dma_fence *f, struct dma_fence_cb *cb)
48 {
49 	struct sync_file *sync_file;
50 
51 	sync_file = container_of(cb, struct sync_file, cb);
52 
53 	wake_up_all(&sync_file->wq);
54 }
55 
56 /**
57  * sync_file_create() - creates a sync file
58  * @fence:	fence to add to the sync_fence
59  *
60  * Creates a sync_file containg @fence. This function acquires and additional
61  * reference of @fence for the newly-created &sync_file, if it succeeds. The
62  * sync_file can be released with fput(sync_file->file). Returns the
63  * sync_file or NULL in case of error.
64  */
65 struct sync_file *sync_file_create(struct dma_fence *fence)
66 {
67 	struct sync_file *sync_file;
68 
69 	sync_file = sync_file_alloc();
70 	if (!sync_file)
71 		return NULL;
72 
73 	sync_file->fence = dma_fence_get(fence);
74 
75 	return sync_file;
76 }
77 EXPORT_SYMBOL(sync_file_create);
78 
79 static struct sync_file *sync_file_fdget(int fd)
80 {
81 	struct file *file = fget(fd);
82 
83 	if (!file)
84 		return NULL;
85 
86 	if (file->f_op != &sync_file_fops)
87 		goto err;
88 
89 	return file->private_data;
90 
91 err:
92 	fput(file);
93 	return NULL;
94 }
95 
96 /**
97  * sync_file_get_fence - get the fence related to the sync_file fd
98  * @fd:		sync_file fd to get the fence from
99  *
100  * Ensures @fd references a valid sync_file and returns a fence that
101  * represents all fence in the sync_file. On error NULL is returned.
102  */
103 struct dma_fence *sync_file_get_fence(int fd)
104 {
105 	struct sync_file *sync_file;
106 	struct dma_fence *fence;
107 
108 	sync_file = sync_file_fdget(fd);
109 	if (!sync_file)
110 		return NULL;
111 
112 	fence = dma_fence_get(sync_file->fence);
113 	fput(sync_file->file);
114 
115 	return fence;
116 }
117 EXPORT_SYMBOL(sync_file_get_fence);
118 
119 /**
120  * sync_file_get_name - get the name of the sync_file
121  * @sync_file:		sync_file to get the fence from
122  * @buf:		destination buffer to copy sync_file name into
123  * @len:		available size of destination buffer.
124  *
125  * Each sync_file may have a name assigned either by the user (when merging
126  * sync_files together) or created from the fence it contains. In the latter
127  * case construction of the name is deferred until use, and so requires
128  * sync_file_get_name().
129  *
130  * Returns: a string representing the name.
131  */
132 char *sync_file_get_name(struct sync_file *sync_file, char *buf, int len)
133 {
134 	if (sync_file->user_name[0]) {
135 		strlcpy(buf, sync_file->user_name, len);
136 	} else {
137 		struct dma_fence *fence = sync_file->fence;
138 
139 		snprintf(buf, len, "%s-%s%llu-%lld",
140 			 fence->ops->get_driver_name(fence),
141 			 fence->ops->get_timeline_name(fence),
142 			 fence->context,
143 			 fence->seqno);
144 	}
145 
146 	return buf;
147 }
148 
149 static int sync_file_set_fence(struct sync_file *sync_file,
150 			       struct dma_fence **fences, int num_fences)
151 {
152 	struct dma_fence_array *array;
153 
154 	/*
155 	 * The reference for the fences in the new sync_file and held
156 	 * in add_fence() during the merge procedure, so for num_fences == 1
157 	 * we already own a new reference to the fence. For num_fence > 1
158 	 * we own the reference of the dma_fence_array creation.
159 	 */
160 
161 	if (num_fences == 0) {
162 		sync_file->fence = dma_fence_get_stub();
163 		kfree(fences);
164 
165 	} else if (num_fences == 1) {
166 		sync_file->fence = fences[0];
167 		kfree(fences);
168 
169 	} else {
170 		array = dma_fence_array_create(num_fences, fences,
171 					       dma_fence_context_alloc(1),
172 					       1, false);
173 		if (!array)
174 			return -ENOMEM;
175 
176 		sync_file->fence = &array->base;
177 	}
178 
179 	return 0;
180 }
181 
182 static void add_fence(struct dma_fence **fences,
183 		      int *i, struct dma_fence *fence)
184 {
185 	fences[*i] = fence;
186 
187 	if (!dma_fence_is_signaled(fence)) {
188 		dma_fence_get(fence);
189 		(*i)++;
190 	}
191 }
192 
193 /**
194  * sync_file_merge() - merge two sync_files
195  * @name:	name of new fence
196  * @a:		sync_file a
197  * @b:		sync_file b
198  *
199  * Creates a new sync_file which contains copies of all the fences in both
200  * @a and @b.  @a and @b remain valid, independent sync_file. Returns the
201  * new merged sync_file or NULL in case of error.
202  */
203 static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
204 					 struct sync_file *b)
205 {
206 	struct dma_fence *a_fence, *b_fence, **fences;
207 	struct dma_fence_unwrap a_iter, b_iter;
208 	unsigned int index, num_fences;
209 	struct sync_file *sync_file;
210 
211 	sync_file = sync_file_alloc();
212 	if (!sync_file)
213 		return NULL;
214 
215 	num_fences = 0;
216 	dma_fence_unwrap_for_each(a_fence, &a_iter, a->fence)
217 		++num_fences;
218 	dma_fence_unwrap_for_each(b_fence, &b_iter, b->fence)
219 		++num_fences;
220 
221 	if (num_fences > INT_MAX)
222 		goto err_free_sync_file;
223 
224 	fences = kcalloc(num_fences, sizeof(*fences), GFP_KERNEL);
225 	if (!fences)
226 		goto err_free_sync_file;
227 
228 	/*
229 	 * We can't guarantee that fences in both a and b are ordered, but it is
230 	 * still quite likely.
231 	 *
232 	 * So attempt to order the fences as we pass over them and merge fences
233 	 * with the same context.
234 	 */
235 
236 	index = 0;
237 	for (a_fence = dma_fence_unwrap_first(a->fence, &a_iter),
238 	     b_fence = dma_fence_unwrap_first(b->fence, &b_iter);
239 	     a_fence || b_fence; ) {
240 
241 		if (!b_fence) {
242 			add_fence(fences, &index, a_fence);
243 			a_fence = dma_fence_unwrap_next(&a_iter);
244 
245 		} else if (!a_fence) {
246 			add_fence(fences, &index, b_fence);
247 			b_fence = dma_fence_unwrap_next(&b_iter);
248 
249 		} else if (a_fence->context < b_fence->context) {
250 			add_fence(fences, &index, a_fence);
251 			a_fence = dma_fence_unwrap_next(&a_iter);
252 
253 		} else if (b_fence->context < a_fence->context) {
254 			add_fence(fences, &index, b_fence);
255 			b_fence = dma_fence_unwrap_next(&b_iter);
256 
257 		} else if (__dma_fence_is_later(a_fence->seqno, b_fence->seqno,
258 						a_fence->ops)) {
259 			add_fence(fences, &index, a_fence);
260 			a_fence = dma_fence_unwrap_next(&a_iter);
261 			b_fence = dma_fence_unwrap_next(&b_iter);
262 
263 		} else {
264 			add_fence(fences, &index, b_fence);
265 			a_fence = dma_fence_unwrap_next(&a_iter);
266 			b_fence = dma_fence_unwrap_next(&b_iter);
267 		}
268 	}
269 
270 	if (sync_file_set_fence(sync_file, fences, index) < 0)
271 		goto err_put_fences;
272 
273 	strlcpy(sync_file->user_name, name, sizeof(sync_file->user_name));
274 	return sync_file;
275 
276 err_put_fences:
277 	while (index)
278 		dma_fence_put(fences[--index]);
279 	kfree(fences);
280 
281 err_free_sync_file:
282 	fput(sync_file->file);
283 	return NULL;
284 }
285 
286 static int sync_file_release(struct inode *inode, struct file *file)
287 {
288 	struct sync_file *sync_file = file->private_data;
289 
290 	if (test_bit(POLL_ENABLED, &sync_file->flags))
291 		dma_fence_remove_callback(sync_file->fence, &sync_file->cb);
292 	dma_fence_put(sync_file->fence);
293 	kfree(sync_file);
294 
295 	return 0;
296 }
297 
298 static __poll_t sync_file_poll(struct file *file, poll_table *wait)
299 {
300 	struct sync_file *sync_file = file->private_data;
301 
302 	poll_wait(file, &sync_file->wq, wait);
303 
304 	if (list_empty(&sync_file->cb.node) &&
305 	    !test_and_set_bit(POLL_ENABLED, &sync_file->flags)) {
306 		if (dma_fence_add_callback(sync_file->fence, &sync_file->cb,
307 					   fence_check_cb_func) < 0)
308 			wake_up_all(&sync_file->wq);
309 	}
310 
311 	return dma_fence_is_signaled(sync_file->fence) ? EPOLLIN : 0;
312 }
313 
314 static long sync_file_ioctl_merge(struct sync_file *sync_file,
315 				  unsigned long arg)
316 {
317 	int fd = get_unused_fd_flags(O_CLOEXEC);
318 	int err;
319 	struct sync_file *fence2, *fence3;
320 	struct sync_merge_data data;
321 
322 	if (fd < 0)
323 		return fd;
324 
325 	if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
326 		err = -EFAULT;
327 		goto err_put_fd;
328 	}
329 
330 	if (data.flags || data.pad) {
331 		err = -EINVAL;
332 		goto err_put_fd;
333 	}
334 
335 	fence2 = sync_file_fdget(data.fd2);
336 	if (!fence2) {
337 		err = -ENOENT;
338 		goto err_put_fd;
339 	}
340 
341 	data.name[sizeof(data.name) - 1] = '\0';
342 	fence3 = sync_file_merge(data.name, sync_file, fence2);
343 	if (!fence3) {
344 		err = -ENOMEM;
345 		goto err_put_fence2;
346 	}
347 
348 	data.fence = fd;
349 	if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
350 		err = -EFAULT;
351 		goto err_put_fence3;
352 	}
353 
354 	fd_install(fd, fence3->file);
355 	fput(fence2->file);
356 	return 0;
357 
358 err_put_fence3:
359 	fput(fence3->file);
360 
361 err_put_fence2:
362 	fput(fence2->file);
363 
364 err_put_fd:
365 	put_unused_fd(fd);
366 	return err;
367 }
368 
369 static int sync_fill_fence_info(struct dma_fence *fence,
370 				 struct sync_fence_info *info)
371 {
372 	strlcpy(info->obj_name, fence->ops->get_timeline_name(fence),
373 		sizeof(info->obj_name));
374 	strlcpy(info->driver_name, fence->ops->get_driver_name(fence),
375 		sizeof(info->driver_name));
376 
377 	info->status = dma_fence_get_status(fence);
378 	while (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags) &&
379 	       !test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT, &fence->flags))
380 		cpu_relax();
381 	info->timestamp_ns =
382 		test_bit(DMA_FENCE_FLAG_TIMESTAMP_BIT, &fence->flags) ?
383 		ktime_to_ns(fence->timestamp) :
384 		ktime_set(0, 0);
385 
386 	return info->status;
387 }
388 
389 static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
390 				       unsigned long arg)
391 {
392 	struct sync_fence_info *fence_info = NULL;
393 	struct dma_fence_unwrap iter;
394 	struct sync_file_info info;
395 	unsigned int num_fences;
396 	struct dma_fence *fence;
397 	int ret;
398 	__u32 size;
399 
400 	if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
401 		return -EFAULT;
402 
403 	if (info.flags || info.pad)
404 		return -EINVAL;
405 
406 	num_fences = 0;
407 	dma_fence_unwrap_for_each(fence, &iter, sync_file->fence)
408 		++num_fences;
409 
410 	/*
411 	 * Passing num_fences = 0 means that userspace doesn't want to
412 	 * retrieve any sync_fence_info. If num_fences = 0 we skip filling
413 	 * sync_fence_info and return the actual number of fences on
414 	 * info->num_fences.
415 	 */
416 	if (!info.num_fences) {
417 		info.status = dma_fence_get_status(sync_file->fence);
418 		goto no_fences;
419 	} else {
420 		info.status = 1;
421 	}
422 
423 	if (info.num_fences < num_fences)
424 		return -EINVAL;
425 
426 	size = num_fences * sizeof(*fence_info);
427 	fence_info = kzalloc(size, GFP_KERNEL);
428 	if (!fence_info)
429 		return -ENOMEM;
430 
431 	num_fences = 0;
432 	dma_fence_unwrap_for_each(fence, &iter, sync_file->fence) {
433 		int status;
434 
435 		status = sync_fill_fence_info(fence, &fence_info[num_fences++]);
436 		info.status = info.status <= 0 ? info.status : status;
437 	}
438 
439 	if (copy_to_user(u64_to_user_ptr(info.sync_fence_info), fence_info,
440 			 size)) {
441 		ret = -EFAULT;
442 		goto out;
443 	}
444 
445 no_fences:
446 	sync_file_get_name(sync_file, info.name, sizeof(info.name));
447 	info.num_fences = num_fences;
448 
449 	if (copy_to_user((void __user *)arg, &info, sizeof(info)))
450 		ret = -EFAULT;
451 	else
452 		ret = 0;
453 
454 out:
455 	kfree(fence_info);
456 
457 	return ret;
458 }
459 
460 static long sync_file_ioctl(struct file *file, unsigned int cmd,
461 			    unsigned long arg)
462 {
463 	struct sync_file *sync_file = file->private_data;
464 
465 	switch (cmd) {
466 	case SYNC_IOC_MERGE:
467 		return sync_file_ioctl_merge(sync_file, arg);
468 
469 	case SYNC_IOC_FILE_INFO:
470 		return sync_file_ioctl_fence_info(sync_file, arg);
471 
472 	default:
473 		return -ENOTTY;
474 	}
475 }
476 
477 static const struct file_operations sync_file_fops = {
478 	.release = sync_file_release,
479 	.poll = sync_file_poll,
480 	.unlocked_ioctl = sync_file_ioctl,
481 	.compat_ioctl = compat_ptr_ioctl,
482 };
483