drivers/dma-buf/sync_file.c

   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 };