Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 1 | /* |
| 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 Padovan | 460bfc4 | 2016-04-28 10:46:57 -0300 | [diff] [blame] | 26 | #include <linux/sync_file.h> |
| 27 | #include <uapi/linux/sync_file.h> |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 28 | |
| 29 | static const struct file_operations sync_file_fops; |
| 30 | |
| 31 | static 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 | |
| 50 | err: |
| 51 | kfree(sync_file); |
| 52 | return NULL; |
| 53 | } |
| 54 | |
| 55 | static 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 Padovan | c240a71 | 2016-04-28 10:46:55 -0300 | [diff] [blame] | 68 | * sync_file_create() - creates a sync file |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 69 | * @fence: fence to add to the sync_fence |
| 70 | * |
| 71 | * Creates a sync_file containg @fence. Once this is called, the sync_file |
Gustavo Padovan | c240a71 | 2016-04-28 10:46:55 -0300 | [diff] [blame] | 72 | * 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 Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 74 | */ |
| 75 | struct 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); |
Gustavo Padovan | 041916a | 2016-06-03 12:46:31 -0300 | [diff] [blame] | 85 | snprintf(sync_file->name, sizeof(sync_file->name), "%s-%s%llu-%d", |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 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 | } |
| 98 | EXPORT_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 | */ |
| 107 | static 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 | |
| 119 | err: |
| 120 | fput(file); |
| 121 | return NULL; |
| 122 | } |
| 123 | |
| 124 | static 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 | */ |
| 147 | static 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 | |
| 205 | static 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 | |
| 220 | static 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 | |
| 228 | static 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 | |
| 244 | static long sync_file_ioctl_merge(struct sync_file *sync_file, |
Gustavo Padovan | 92e0621 | 2016-04-28 10:46:56 -0300 | [diff] [blame] | 245 | unsigned long arg) |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 246 | { |
| 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 | |
| 288 | err_put_fence3: |
| 289 | fput(fence3->file); |
| 290 | |
| 291 | err_put_fence2: |
| 292 | fput(fence2->file); |
| 293 | |
| 294 | err_put_fd: |
| 295 | put_unused_fd(fd); |
| 296 | return err; |
| 297 | } |
| 298 | |
| 299 | static void sync_fill_fence_info(struct fence *fence, |
Gustavo Padovan | 92e0621 | 2016-04-28 10:46:56 -0300 | [diff] [blame] | 300 | struct sync_fence_info *info) |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 301 | { |
| 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 | |
| 313 | static long sync_file_ioctl_fence_info(struct sync_file *sync_file, |
Gustavo Padovan | 92e0621 | 2016-04-28 10:46:56 -0300 | [diff] [blame] | 314 | unsigned long arg) |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 315 | { |
| 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 | |
| 353 | no_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 | |
| 366 | out: |
| 367 | kfree(fence_info); |
| 368 | |
| 369 | return ret; |
| 370 | } |
| 371 | |
| 372 | static long sync_file_ioctl(struct file *file, unsigned int cmd, |
Gustavo Padovan | 92e0621 | 2016-04-28 10:46:56 -0300 | [diff] [blame] | 373 | unsigned long arg) |
Gustavo Padovan | d4cab38 | 2016-04-28 10:46:54 -0300 | [diff] [blame] | 374 | { |
| 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 | |
| 389 | static 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 | |