xref: /openbmc/linux/drivers/dma-buf/sync_file.c (revision b83ce9cb)
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 
sync_file_alloc(void)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 
fence_check_cb_func(struct dma_fence * f,struct dma_fence_cb * cb)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  */
sync_file_create(struct dma_fence * fence)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 
sync_file_fdget(int fd)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  */
sync_file_get_fence(int fd)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  */
sync_file_get_name(struct sync_file * sync_file,char * buf,int len)132 char *sync_file_get_name(struct sync_file *sync_file, char *buf, int len)
133 {
134 	if (sync_file->user_name[0]) {
135 		strscpy(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 /**
150  * sync_file_merge() - merge two sync_files
151  * @name:	name of new fence
152  * @a:		sync_file a
153  * @b:		sync_file b
154  *
155  * Creates a new sync_file which contains copies of all the fences in both
156  * @a and @b.  @a and @b remain valid, independent sync_file. Returns the
157  * new merged sync_file or NULL in case of error.
158  */
sync_file_merge(const char * name,struct sync_file * a,struct sync_file * b)159 static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
160 					 struct sync_file *b)
161 {
162 	struct sync_file *sync_file;
163 	struct dma_fence *fence;
164 
165 	sync_file = sync_file_alloc();
166 	if (!sync_file)
167 		return NULL;
168 
169 	fence = dma_fence_unwrap_merge(a->fence, b->fence);
170 	if (!fence) {
171 		fput(sync_file->file);
172 		return NULL;
173 	}
174 	sync_file->fence = fence;
175 	strscpy(sync_file->user_name, name, sizeof(sync_file->user_name));
176 	return sync_file;
177 }
178 
sync_file_release(struct inode * inode,struct file * file)179 static int sync_file_release(struct inode *inode, struct file *file)
180 {
181 	struct sync_file *sync_file = file->private_data;
182 
183 	if (test_bit(POLL_ENABLED, &sync_file->flags))
184 		dma_fence_remove_callback(sync_file->fence, &sync_file->cb);
185 	dma_fence_put(sync_file->fence);
186 	kfree(sync_file);
187 
188 	return 0;
189 }
190 
sync_file_poll(struct file * file,poll_table * wait)191 static __poll_t sync_file_poll(struct file *file, poll_table *wait)
192 {
193 	struct sync_file *sync_file = file->private_data;
194 
195 	poll_wait(file, &sync_file->wq, wait);
196 
197 	if (list_empty(&sync_file->cb.node) &&
198 	    !test_and_set_bit(POLL_ENABLED, &sync_file->flags)) {
199 		if (dma_fence_add_callback(sync_file->fence, &sync_file->cb,
200 					   fence_check_cb_func) < 0)
201 			wake_up_all(&sync_file->wq);
202 	}
203 
204 	return dma_fence_is_signaled(sync_file->fence) ? EPOLLIN : 0;
205 }
206 
sync_file_ioctl_merge(struct sync_file * sync_file,unsigned long arg)207 static long sync_file_ioctl_merge(struct sync_file *sync_file,
208 				  unsigned long arg)
209 {
210 	int fd = get_unused_fd_flags(O_CLOEXEC);
211 	int err;
212 	struct sync_file *fence2, *fence3;
213 	struct sync_merge_data data;
214 
215 	if (fd < 0)
216 		return fd;
217 
218 	if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
219 		err = -EFAULT;
220 		goto err_put_fd;
221 	}
222 
223 	if (data.flags || data.pad) {
224 		err = -EINVAL;
225 		goto err_put_fd;
226 	}
227 
228 	fence2 = sync_file_fdget(data.fd2);
229 	if (!fence2) {
230 		err = -ENOENT;
231 		goto err_put_fd;
232 	}
233 
234 	data.name[sizeof(data.name) - 1] = '\0';
235 	fence3 = sync_file_merge(data.name, sync_file, fence2);
236 	if (!fence3) {
237 		err = -ENOMEM;
238 		goto err_put_fence2;
239 	}
240 
241 	data.fence = fd;
242 	if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
243 		err = -EFAULT;
244 		goto err_put_fence3;
245 	}
246 
247 	fd_install(fd, fence3->file);
248 	fput(fence2->file);
249 	return 0;
250 
251 err_put_fence3:
252 	fput(fence3->file);
253 
254 err_put_fence2:
255 	fput(fence2->file);
256 
257 err_put_fd:
258 	put_unused_fd(fd);
259 	return err;
260 }
261 
sync_fill_fence_info(struct dma_fence * fence,struct sync_fence_info * info)262 static int sync_fill_fence_info(struct dma_fence *fence,
263 				 struct sync_fence_info *info)
264 {
265 	strscpy(info->obj_name, fence->ops->get_timeline_name(fence),
266 		sizeof(info->obj_name));
267 	strscpy(info->driver_name, fence->ops->get_driver_name(fence),
268 		sizeof(info->driver_name));
269 
270 	info->status = dma_fence_get_status(fence);
271 	info->timestamp_ns =
272 		dma_fence_is_signaled(fence) ?
273 			ktime_to_ns(dma_fence_timestamp(fence)) :
274 			ktime_set(0, 0);
275 
276 	return info->status;
277 }
278 
sync_file_ioctl_fence_info(struct sync_file * sync_file,unsigned long arg)279 static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
280 				       unsigned long arg)
281 {
282 	struct sync_fence_info *fence_info = NULL;
283 	struct dma_fence_unwrap iter;
284 	struct sync_file_info info;
285 	unsigned int num_fences;
286 	struct dma_fence *fence;
287 	int ret;
288 	__u32 size;
289 
290 	if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
291 		return -EFAULT;
292 
293 	if (info.flags || info.pad)
294 		return -EINVAL;
295 
296 	num_fences = 0;
297 	dma_fence_unwrap_for_each(fence, &iter, sync_file->fence)
298 		++num_fences;
299 
300 	/*
301 	 * Passing num_fences = 0 means that userspace doesn't want to
302 	 * retrieve any sync_fence_info. If num_fences = 0 we skip filling
303 	 * sync_fence_info and return the actual number of fences on
304 	 * info->num_fences.
305 	 */
306 	if (!info.num_fences) {
307 		info.status = dma_fence_get_status(sync_file->fence);
308 		goto no_fences;
309 	} else {
310 		info.status = 1;
311 	}
312 
313 	if (info.num_fences < num_fences)
314 		return -EINVAL;
315 
316 	size = num_fences * sizeof(*fence_info);
317 	fence_info = kzalloc(size, GFP_KERNEL);
318 	if (!fence_info)
319 		return -ENOMEM;
320 
321 	num_fences = 0;
322 	dma_fence_unwrap_for_each(fence, &iter, sync_file->fence) {
323 		int status;
324 
325 		status = sync_fill_fence_info(fence, &fence_info[num_fences++]);
326 		info.status = info.status <= 0 ? info.status : status;
327 	}
328 
329 	if (copy_to_user(u64_to_user_ptr(info.sync_fence_info), fence_info,
330 			 size)) {
331 		ret = -EFAULT;
332 		goto out;
333 	}
334 
335 no_fences:
336 	sync_file_get_name(sync_file, info.name, sizeof(info.name));
337 	info.num_fences = num_fences;
338 
339 	if (copy_to_user((void __user *)arg, &info, sizeof(info)))
340 		ret = -EFAULT;
341 	else
342 		ret = 0;
343 
344 out:
345 	kfree(fence_info);
346 
347 	return ret;
348 }
349 
sync_file_ioctl(struct file * file,unsigned int cmd,unsigned long arg)350 static long sync_file_ioctl(struct file *file, unsigned int cmd,
351 			    unsigned long arg)
352 {
353 	struct sync_file *sync_file = file->private_data;
354 
355 	switch (cmd) {
356 	case SYNC_IOC_MERGE:
357 		return sync_file_ioctl_merge(sync_file, arg);
358 
359 	case SYNC_IOC_FILE_INFO:
360 		return sync_file_ioctl_fence_info(sync_file, arg);
361 
362 	default:
363 		return -ENOTTY;
364 	}
365 }
366 
367 static const struct file_operations sync_file_fops = {
368 	.release = sync_file_release,
369 	.poll = sync_file_poll,
370 	.unlocked_ioctl = sync_file_ioctl,
371 	.compat_ioctl = compat_ptr_ioctl,
372 };
373