drivers/dma-buf/dma-buf.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Framework for buffer objects that can be shared across devices/subsystems.
   4  *
   5  * Copyright(C) 2011 Linaro Limited. All rights reserved.
   6  * Author: Sumit Semwal <[email protected]>
   7  *
   8  * Many thanks to linaro-mm-sig list, and specially
   9  * Arnd Bergmann <[email protected]>, Rob Clark <[email protected]> and
  10  * Daniel Vetter <[email protected]> for their support in creation and
  11  * refining of this idea.
  12  */
  13
  14 #include <linux/fs.h>
  15 #include <linux/slab.h>
  16 #include <linux/dma-buf.h>
  17 #include <linux/dma-fence.h>
  18 #include <linux/anon_inodes.h>
  19 #include <linux/export.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/module.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/poll.h>
  24 #include <linux/dma-resv.h>
  25 #include <linux/mm.h>
  26 #include <linux/mount.h>
  27 #include <linux/pseudo_fs.h>
  28
  29 #include <uapi/linux/dma-buf.h>
  30 #include <uapi/linux/magic.h>
  31
  32 static inline int is_dma_buf_file(struct file *);
  33
  34 struct dma_buf_list {
  35         struct list_head head;
  36         struct mutex lock;
  37 };
  38
  39 static struct dma_buf_list db_list;
  40
  41 static char *dmabuffs_dname(struct dentry *dentry, char *buffer, int buflen)
  42 {
  43         struct dma_buf *dmabuf;
  44         char name[DMA_BUF_NAME_LEN];
  45         size_t ret = 0;
  46
  47         dmabuf = dentry->d_fsdata;
  48         dma_resv_lock(dmabuf->resv, NULL);
  49         if (dmabuf->name)
  50                 ret = strlcpy(name, dmabuf->name, DMA_BUF_NAME_LEN);
  51         dma_resv_unlock(dmabuf->resv);
  52
  53         return dynamic_dname(dentry, buffer, buflen, "/%s:%s",
  54                              dentry->d_name.name, ret > 0 ? name : "");
  55 }
  56
  57 static const struct dentry_operations dma_buf_dentry_ops = {
  58         .d_dname = dmabuffs_dname,
  59 };
  60
  61 static struct vfsmount *dma_buf_mnt;
  62
  63 static int dma_buf_fs_init_context(struct fs_context *fc)
  64 {
  65         struct pseudo_fs_context *ctx;
  66
  67         ctx = init_pseudo(fc, DMA_BUF_MAGIC);
  68         if (!ctx)
  69                 return -ENOMEM;
  70         ctx->dops = &dma_buf_dentry_ops;
  71         return 0;
  72 }
  73
  74 static struct file_system_type dma_buf_fs_type = {
  75         .name = "dmabuf",
  76         .init_fs_context = dma_buf_fs_init_context,
  77         .kill_sb = kill_anon_super,
  78 };
  79
  80 static int dma_buf_release(struct inode *inode, struct file *file)
  81 {
  82         struct dma_buf *dmabuf;
  83
  84         if (!is_dma_buf_file(file))
  85                 return -EINVAL;
  86
  87         dmabuf = file->private_data;
  88
  89         BUG_ON(dmabuf->vmapping_counter);
  90
  91         /*
  92          * Any fences that a dma-buf poll can wait on should be signaled
  93          * before releasing dma-buf. This is the responsibility of each
  94          * driver that uses the reservation objects.
  95          *
  96          * If you hit this BUG() it means someone dropped their ref to the
  97          * dma-buf while still having pending operation to the buffer.
  98          */
  99         BUG_ON(dmabuf->cb_shared.active || dmabuf->cb_excl.active);
 100
 101         dmabuf->ops->release(dmabuf);
 102
 103         mutex_lock(&db_list.lock);
 104         list_del(&dmabuf->list_node);
 105         mutex_unlock(&db_list.lock);
 106
 107         if (dmabuf->resv == (struct dma_resv *)&dmabuf[1])
 108                 dma_resv_fini(dmabuf->resv);
 109
 110         module_put(dmabuf->owner);
 111         kfree(dmabuf->name);
 112         kfree(dmabuf);
 113         return 0;
 114 }
 115
 116 static int dma_buf_mmap_internal(struct file *file, struct vm_area_struct *vma)
 117 {
 118         struct dma_buf *dmabuf;
 119
 120         if (!is_dma_buf_file(file))
 121                 return -EINVAL;
 122
 123         dmabuf = file->private_data;
 124
 125         /* check if buffer supports mmap */
 126         if (!dmabuf->ops->mmap)
 127                 return -EINVAL;
 128
 129         /* check for overflowing the buffer's size */
 130         if (vma->vm_pgoff + vma_pages(vma) >
 131             dmabuf->size >> PAGE_SHIFT)
 132                 return -EINVAL;
 133
 134         return dmabuf->ops->mmap(dmabuf, vma);
 135 }
 136
 137 static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence)
 138 {
 139         struct dma_buf *dmabuf;
 140         loff_t base;
 141
 142         if (!is_dma_buf_file(file))
 143                 return -EBADF;
 144
 145         dmabuf = file->private_data;
 146
 147         /* only support discovering the end of the buffer,
 148            but also allow SEEK_SET to maintain the idiomatic
 149            SEEK_END(0), SEEK_CUR(0) pattern */
 150         if (whence == SEEK_END)
 151                 base = dmabuf->size;
 152         else if (whence == SEEK_SET)
 153                 base = 0;
 154         else
 155                 return -EINVAL;
 156
 157         if (offset != 0)
 158                 return -EINVAL;
 159
 160         return base + offset;
 161 }
 162
 163 /**
 164  * DOC: fence polling
 165  *
 166  * To support cross-device and cross-driver synchronization of buffer access
 167  * implicit fences (represented internally in the kernel with &struct fence) can
 168  * be attached to a &dma_buf. The glue for that and a few related things are
 169  * provided in the &dma_resv structure.
 170  *
 171  * Userspace can query the state of these implicitly tracked fences using poll()
 172  * and related system calls:
 173  *
 174  * - Checking for EPOLLIN, i.e. read access, can be use to query the state of the
 175  *   most recent write or exclusive fence.
 176  *
 177  * - Checking for EPOLLOUT, i.e. write access, can be used to query the state of
 178  *   all attached fences, shared and exclusive ones.
 179  *
 180  * Note that this only signals the completion of the respective fences, i.e. the
 181  * DMA transfers are complete. Cache flushing and any other necessary
 182  * preparations before CPU access can begin still need to happen.
 183  */
 184
 185 static void dma_buf_poll_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
 186 {
 187         struct dma_buf_poll_cb_t *dcb = (struct dma_buf_poll_cb_t *)cb;
 188         unsigned long flags;
 189
 190         spin_lock_irqsave(&dcb->poll->lock, flags);
 191         wake_up_locked_poll(dcb->poll, dcb->active);
 192         dcb->active = 0;
 193         spin_unlock_irqrestore(&dcb->poll->lock, flags);
 194 }
 195
 196 static __poll_t dma_buf_poll(struct file *file, poll_table *poll)
 197 {
 198         struct dma_buf *dmabuf;
 199         struct dma_resv *resv;
 200         struct dma_resv_list *fobj;
 201         struct dma_fence *fence_excl;
 202         __poll_t events;
 203         unsigned shared_count, seq;
 204
 205         dmabuf = file->private_data;
 206         if (!dmabuf || !dmabuf->resv)
 207                 return EPOLLERR;
 208
 209         resv = dmabuf->resv;
 210
 211         poll_wait(file, &dmabuf->poll, poll);
 212
 213         events = poll_requested_events(poll) & (EPOLLIN | EPOLLOUT);
 214         if (!events)
 215                 return 0;
 216
 217 retry:
 218         seq = read_seqcount_begin(&resv->seq);
 219         rcu_read_lock();
 220
 221         fobj = rcu_dereference(resv->fence);
 222         if (fobj)
 223                 shared_count = fobj->shared_count;
 224         else
 225                 shared_count = 0;
 226         fence_excl = rcu_dereference(resv->fence_excl);
 227         if (read_seqcount_retry(&resv->seq, seq)) {
 228                 rcu_read_unlock();
 229                 goto retry;
 230         }
 231
 232         if (fence_excl && (!(events & EPOLLOUT) || shared_count == 0)) {
 233                 struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_excl;
 234                 __poll_t pevents = EPOLLIN;
 235
 236                 if (shared_count == 0)
 237                         pevents |= EPOLLOUT;
 238
 239                 spin_lock_irq(&dmabuf->poll.lock);
 240                 if (dcb->active) {
 241                         dcb->active |= pevents;
 242                         events &= ~pevents;
 243                 } else
 244                         dcb->active = pevents;
 245                 spin_unlock_irq(&dmabuf->poll.lock);
 246
 247                 if (events & pevents) {
 248                         if (!dma_fence_get_rcu(fence_excl)) {
 249                                 /* force a recheck */
 250                                 events &= ~pevents;
 251                                 dma_buf_poll_cb(NULL, &dcb->cb);
 252                         } else if (!dma_fence_add_callback(fence_excl, &dcb->cb,
 253                                                            dma_buf_poll_cb)) {
 254                                 events &= ~pevents;
 255                                 dma_fence_put(fence_excl);
 256                         } else {
 257                                 /*
 258                                  * No callback queued, wake up any additional
 259                                  * waiters.
 260                                  */
 261                                 dma_fence_put(fence_excl);
 262                                 dma_buf_poll_cb(NULL, &dcb->cb);
 263                         }
 264                 }
 265         }
 266
 267         if ((events & EPOLLOUT) && shared_count > 0) {
 268                 struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_shared;
 269                 int i;
 270
 271                 /* Only queue a new callback if no event has fired yet */
 272                 spin_lock_irq(&dmabuf->poll.lock);
 273                 if (dcb->active)
 274                         events &= ~EPOLLOUT;
 275                 else
 276                         dcb->active = EPOLLOUT;
 277                 spin_unlock_irq(&dmabuf->poll.lock);
 278
 279                 if (!(events & EPOLLOUT))
 280                         goto out;
 281
 282                 for (i = 0; i < shared_count; ++i) {
 283                         struct dma_fence *fence = rcu_dereference(fobj->shared[i]);
 284
 285                         if (!dma_fence_get_rcu(fence)) {
 286                                 /*
 287                                  * fence refcount dropped to zero, this means
 288                                  * that fobj has been freed
 289                                  *
 290                                  * call dma_buf_poll_cb and force a recheck!
 291                                  */
 292                                 events &= ~EPOLLOUT;
 293                                 dma_buf_poll_cb(NULL, &dcb->cb);
 294                                 break;
 295                         }
 296                         if (!dma_fence_add_callback(fence, &dcb->cb,
 297                                                     dma_buf_poll_cb)) {
 298                                 dma_fence_put(fence);
 299                                 events &= ~EPOLLOUT;
 300                                 break;
 301                         }
 302                         dma_fence_put(fence);
 303                 }
 304
 305                 /* No callback queued, wake up any additional waiters. */
 306                 if (i == shared_count)
 307                         dma_buf_poll_cb(NULL, &dcb->cb);
 308         }
 309
 310 out:
 311         rcu_read_unlock();
 312         return events;
 313 }
 314
 315 /**
 316  * dma_buf_set_name - Set a name to a specific dma_buf to track the usage.
 317  * The name of the dma-buf buffer can only be set when the dma-buf is not
 318  * attached to any devices. It could theoritically support changing the
 319  * name of the dma-buf if the same piece of memory is used for multiple
 320  * purpose between different devices.
 321  *
 322  * @dmabuf [in]     dmabuf buffer that will be renamed.
 323  * @buf:   [in]     A piece of userspace memory that contains the name of
 324  *                  the dma-buf.
 325  *
 326  * Returns 0 on success. If the dma-buf buffer is already attached to
 327  * devices, return -EBUSY.
 328  *
 329  */
 330 static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf)
 331 {
 332         char *name = strndup_user(buf, DMA_BUF_NAME_LEN);
 333         long ret = 0;
 334
 335         if (IS_ERR(name))
 336                 return PTR_ERR(name);
 337
 338         dma_resv_lock(dmabuf->resv, NULL);
 339         if (!list_empty(&dmabuf->attachments)) {
 340                 ret = -EBUSY;
 341                 kfree(name);
 342                 goto out_unlock;
 343         }
 344         kfree(dmabuf->name);
 345         dmabuf->name = name;
 346
 347 out_unlock:
 348         dma_resv_unlock(dmabuf->resv);
 349         return ret;
 350 }
 351
 352 static long dma_buf_ioctl(struct file *file,
 353                           unsigned int cmd, unsigned long arg)
 354 {
 355         struct dma_buf *dmabuf;
 356         struct dma_buf_sync sync;
 357         enum dma_data_direction direction;
 358         int ret;
 359
 360         dmabuf = file->private_data;
 361
 362         switch (cmd) {
 363         case DMA_BUF_IOCTL_SYNC:
 364                 if (copy_from_user(&sync, (void __user *) arg, sizeof(sync)))
 365                         return -EFAULT;
 366
 367                 if (sync.flags & ~DMA_BUF_SYNC_VALID_FLAGS_MASK)
 368                         return -EINVAL;
 369
 370                 switch (sync.flags & DMA_BUF_SYNC_RW) {
 371                 case DMA_BUF_SYNC_READ:
 372                         direction = DMA_FROM_DEVICE;
 373                         break;
 374                 case DMA_BUF_SYNC_WRITE:
 375                         direction = DMA_TO_DEVICE;
 376                         break;
 377                 case DMA_BUF_SYNC_RW:
 378                         direction = DMA_BIDIRECTIONAL;
 379                         break;
 380                 default:
 381                         return -EINVAL;
 382                 }
 383
 384                 if (sync.flags & DMA_BUF_SYNC_END)
 385                         ret = dma_buf_end_cpu_access(dmabuf, direction);
 386                 else
 387                         ret = dma_buf_begin_cpu_access(dmabuf, direction);
 388
 389                 return ret;
 390
 391         case DMA_BUF_SET_NAME:
 392                 return dma_buf_set_name(dmabuf, (const char __user *)arg);
 393
 394         default:
 395                 return -ENOTTY;
 396         }
 397 }
 398
 399 static void dma_buf_show_fdinfo(struct seq_file *m, struct file *file)
 400 {
 401         struct dma_buf *dmabuf = file->private_data;
 402
 403         seq_printf(m, "size:\t%zu\n", dmabuf->size);
 404         /* Don't count the temporary reference taken inside procfs seq_show */
 405         seq_printf(m, "count:\t%ld\n", file_count(dmabuf->file) - 1);
 406         seq_printf(m, "exp_name:\t%s\n", dmabuf->exp_name);
 407         dma_resv_lock(dmabuf->resv, NULL);
 408         if (dmabuf->name)
 409                 seq_printf(m, "name:\t%s\n", dmabuf->name);
 410         dma_resv_unlock(dmabuf->resv);
 411 }
 412
 413 static const struct file_operations dma_buf_fops = {
 414         .release        = dma_buf_release,
 415         .mmap           = dma_buf_mmap_internal,
 416         .llseek         = dma_buf_llseek,
 417         .poll           = dma_buf_poll,
 418         .unlocked_ioctl = dma_buf_ioctl,
 419         .compat_ioctl   = compat_ptr_ioctl,
 420         .show_fdinfo    = dma_buf_show_fdinfo,
 421 };
 422
 423 /*
 424  * is_dma_buf_file - Check if struct file* is associated with dma_buf
 425  */
 426 static inline int is_dma_buf_file(struct file *file)
 427 {
 428         return file->f_op == &dma_buf_fops;
 429 }
 430
 431 static struct file *dma_buf_getfile(struct dma_buf *dmabuf, int flags)
 432 {
 433         struct file *file;
 434         struct inode *inode = alloc_anon_inode(dma_buf_mnt->mnt_sb);
 435
 436         if (IS_ERR(inode))
 437                 return ERR_CAST(inode);
 438
 439         inode->i_size = dmabuf->size;
 440         inode_set_bytes(inode, dmabuf->size);
 441
 442         file = alloc_file_pseudo(inode, dma_buf_mnt, "dmabuf",
 443                                  flags, &dma_buf_fops);
 444         if (IS_ERR(file))
 445                 goto err_alloc_file;
 446         file->f_flags = flags & (O_ACCMODE | O_NONBLOCK);
 447         file->private_data = dmabuf;
 448         file->f_path.dentry->d_fsdata = dmabuf;
 449
 450         return file;
 451
 452 err_alloc_file:
 453         iput(inode);
 454         return file;
 455 }
 456
 457 /**
 458  * DOC: dma buf device access
 459  *
 460  * For device DMA access to a shared DMA buffer the usual sequence of operations
 461  * is fairly simple:
 462  *
 463  * 1. The exporter defines his exporter instance using
 464  *    DEFINE_DMA_BUF_EXPORT_INFO() and calls dma_buf_export() to wrap a private
 465  *    buffer object into a &dma_buf. It then exports that &dma_buf to userspace
 466  *    as a file descriptor by calling dma_buf_fd().
 467  *
 468  * 2. Userspace passes this file-descriptors to all drivers it wants this buffer
 469  *    to share with: First the filedescriptor is converted to a &dma_buf using
 470  *    dma_buf_get(). Then the buffer is attached to the device using
 471  *    dma_buf_attach().
 472  *
 473  *    Up to this stage the exporter is still free to migrate or reallocate the
 474  *    backing storage.
 475  *
 476  * 3. Once the buffer is attached to all devices userspace can initiate DMA
 477  *    access to the shared buffer. In the kernel this is done by calling
 478  *    dma_buf_map_attachment() and dma_buf_unmap_attachment().
 479  *
 480  * 4. Once a driver is done with a shared buffer it needs to call
 481  *    dma_buf_detach() (after cleaning up any mappings) and then release the
 482  *    reference acquired with dma_buf_get by calling dma_buf_put().
 483  *
 484  * For the detailed semantics exporters are expected to implement see
 485  * &dma_buf_ops.
 486  */
 487
 488 /**
 489  * dma_buf_export - Creates a new dma_buf, and associates an anon file
 490  * with this buffer, so it can be exported.
 491  * Also connect the allocator specific data and ops to the buffer.
 492  * Additionally, provide a name string for exporter; useful in debugging.
 493  *
 494  * @exp_info:   [in]    holds all the export related information provided
 495  *                      by the exporter. see &struct dma_buf_export_info
 496  *                      for further details.
 497  *
 498  * Returns, on success, a newly created dma_buf object, which wraps the
 499  * supplied private data and operations for dma_buf_ops. On either missing
 500  * ops, or error in allocating struct dma_buf, will return negative error.
 501  *
 502  * For most cases the easiest way to create @exp_info is through the
 503  * %DEFINE_DMA_BUF_EXPORT_INFO macro.
 504  */
 505 struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info)
 506 {
 507         struct dma_buf *dmabuf;
 508         struct dma_resv *resv = exp_info->resv;
 509         struct file *file;
 510         size_t alloc_size = sizeof(struct dma_buf);
 511         int ret;
 512
 513         if (!exp_info->resv)
 514                 alloc_size += sizeof(struct dma_resv);
 515         else
 516                 /* prevent &dma_buf[1] == dma_buf->resv */
 517                 alloc_size += 1;
 518
 519         if (WARN_ON(!exp_info->priv
 520                           || !exp_info->ops
 521                           || !exp_info->ops->map_dma_buf
 522                           || !exp_info->ops->unmap_dma_buf
 523                           || !exp_info->ops->release)) {
 524                 return ERR_PTR(-EINVAL);
 525         }
 526
 527         if (WARN_ON(exp_info->ops->cache_sgt_mapping &&
 528                     (exp_info->ops->pin || exp_info->ops->unpin)))
 529                 return ERR_PTR(-EINVAL);
 530
 531         if (WARN_ON(!exp_info->ops->pin != !exp_info->ops->unpin))
 532                 return ERR_PTR(-EINVAL);
 533
 534         if (!try_module_get(exp_info->owner))
 535                 return ERR_PTR(-ENOENT);
 536
 537         dmabuf = kzalloc(alloc_size, GFP_KERNEL);
 538         if (!dmabuf) {
 539                 ret = -ENOMEM;
 540                 goto err_module;
 541         }
 542
 543         dmabuf->priv = exp_info->priv;
 544         dmabuf->ops = exp_info->ops;
 545         dmabuf->size = exp_info->size;
 546         dmabuf->exp_name = exp_info->exp_name;
 547         dmabuf->owner = exp_info->owner;
 548         init_waitqueue_head(&dmabuf->poll);
 549         dmabuf->cb_excl.poll = dmabuf->cb_shared.poll = &dmabuf->poll;
 550         dmabuf->cb_excl.active = dmabuf->cb_shared.active = 0;
 551
 552         if (!resv) {
 553                 resv = (struct dma_resv *)&dmabuf[1];
 554                 dma_resv_init(resv);
 555         }
 556         dmabuf->resv = resv;
 557
 558         file = dma_buf_getfile(dmabuf, exp_info->flags);
 559         if (IS_ERR(file)) {
 560                 ret = PTR_ERR(file);
 561                 goto err_dmabuf;
 562         }
 563
 564         file->f_mode |= FMODE_LSEEK;
 565         dmabuf->file = file;
 566
 567         mutex_init(&dmabuf->lock);
 568         INIT_LIST_HEAD(&dmabuf->attachments);
 569
 570         mutex_lock(&db_list.lock);
 571         list_add(&dmabuf->list_node, &db_list.head);
 572         mutex_unlock(&db_list.lock);
 573
 574         return dmabuf;
 575
 576 err_dmabuf:
 577         kfree(dmabuf);
 578 err_module:
 579         module_put(exp_info->owner);
 580         return ERR_PTR(ret);
 581 }
 582 EXPORT_SYMBOL_GPL(dma_buf_export);
 583
 584 /**
 585  * dma_buf_fd - returns a file descriptor for the given dma_buf
 586  * @dmabuf:     [in]    pointer to dma_buf for which fd is required.
 587  * @flags:      [in]    flags to give to fd
 588  *
 589  * On success, returns an associated 'fd'. Else, returns error.
 590  */
 591 int dma_buf_fd(struct dma_buf *dmabuf, int flags)
 592 {
 593         int fd;
 594
 595         if (!dmabuf || !dmabuf->file)
 596                 return -EINVAL;
 597
 598         fd = get_unused_fd_flags(flags);
 599         if (fd < 0)
 600                 return fd;
 601
 602         fd_install(fd, dmabuf->file);
 603
 604         return fd;
 605 }
 606 EXPORT_SYMBOL_GPL(dma_buf_fd);
 607
 608 /**
 609  * dma_buf_get - returns the dma_buf structure related to an fd
 610  * @fd: [in]    fd associated with the dma_buf to be returned
 611  *
 612  * On success, returns the dma_buf structure associated with an fd; uses
 613  * file's refcounting done by fget to increase refcount. returns ERR_PTR
 614  * otherwise.
 615  */
 616 struct dma_buf *dma_buf_get(int fd)
 617 {
 618         struct file *file;
 619
 620         file = fget(fd);
 621
 622         if (!file)
 623                 return ERR_PTR(-EBADF);
 624
 625         if (!is_dma_buf_file(file)) {
 626                 fput(file);
 627                 return ERR_PTR(-EINVAL);
 628         }
 629
 630         return file->private_data;
 631 }
 632 EXPORT_SYMBOL_GPL(dma_buf_get);
 633
 634 /**
 635  * dma_buf_put - decreases refcount of the buffer
 636  * @dmabuf:     [in]    buffer to reduce refcount of
 637  *
 638  * Uses file's refcounting done implicitly by fput().
 639  *
 640  * If, as a result of this call, the refcount becomes 0, the 'release' file
 641  * operation related to this fd is called. It calls &dma_buf_ops.release vfunc
 642  * in turn, and frees the memory allocated for dmabuf when exported.
 643  */
 644 void dma_buf_put(struct dma_buf *dmabuf)
 645 {
 646         if (WARN_ON(!dmabuf || !dmabuf->file))
 647                 return;
 648
 649         fput(dmabuf->file);
 650 }
 651 EXPORT_SYMBOL_GPL(dma_buf_put);
 652
 653 /**
 654  * dma_buf_dynamic_attach - Add the device to dma_buf's attachments list; optionally,
 655  * calls attach() of dma_buf_ops to allow device-specific attach functionality
 656  * @dmabuf:             [in]    buffer to attach device to.
 657  * @dev:                [in]    device to be attached.
 658  * @importer_ops        [in]    importer operations for the attachment
 659  * @importer_priv       [in]    importer private pointer for the attachment
 660  *
 661  * Returns struct dma_buf_attachment pointer for this attachment. Attachments
 662  * must be cleaned up by calling dma_buf_detach().
 663  *
 664  * Returns:
 665  *
 666  * A pointer to newly created &dma_buf_attachment on success, or a negative
 667  * error code wrapped into a pointer on failure.
 668  *
 669  * Note that this can fail if the backing storage of @dmabuf is in a place not
 670  * accessible to @dev, and cannot be moved to a more suitable place. This is
 671  * indicated with the error code -EBUSY.
 672  */
 673 struct dma_buf_attachment *
 674 dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev,
 675                        const struct dma_buf_attach_ops *importer_ops,
 676                        void *importer_priv)
 677 {
 678         struct dma_buf_attachment *attach;
 679         int ret;
 680
 681         if (WARN_ON(!dmabuf || !dev))
 682                 return ERR_PTR(-EINVAL);
 683
 684         if (WARN_ON(importer_ops && !importer_ops->move_notify))
 685                 return ERR_PTR(-EINVAL);
 686
 687         attach = kzalloc(sizeof(*attach), GFP_KERNEL);
 688         if (!attach)
 689                 return ERR_PTR(-ENOMEM);
 690
 691         attach->dev = dev;
 692         attach->dmabuf = dmabuf;
 693         attach->importer_ops = importer_ops;
 694         attach->importer_priv = importer_priv;
 695
 696         if (dmabuf->ops->attach) {
 697                 ret = dmabuf->ops->attach(dmabuf, attach);
 698                 if (ret)
 699                         goto err_attach;
 700         }
 701         dma_resv_lock(dmabuf->resv, NULL);
 702         list_add(&attach->node, &dmabuf->attachments);
 703         dma_resv_unlock(dmabuf->resv);
 704
 705         /* When either the importer or the exporter can't handle dynamic
 706          * mappings we cache the mapping here to avoid issues with the
 707          * reservation object lock.
 708          */
 709         if (dma_buf_attachment_is_dynamic(attach) !=
 710             dma_buf_is_dynamic(dmabuf)) {
 711                 struct sg_table *sgt;
 712
 713                 if (dma_buf_is_dynamic(attach->dmabuf)) {
 714                         dma_resv_lock(attach->dmabuf->resv, NULL);
 715                         ret = dma_buf_pin(attach);
 716                         if (ret)
 717                                 goto err_unlock;
 718                 }
 719
 720                 sgt = dmabuf->ops->map_dma_buf(attach, DMA_BIDIRECTIONAL);
 721                 if (!sgt)
 722                         sgt = ERR_PTR(-ENOMEM);
 723                 if (IS_ERR(sgt)) {
 724                         ret = PTR_ERR(sgt);
 725                         goto err_unpin;
 726                 }
 727                 if (dma_buf_is_dynamic(attach->dmabuf))
 728                         dma_resv_unlock(attach->dmabuf->resv);
 729                 attach->sgt = sgt;
 730                 attach->dir = DMA_BIDIRECTIONAL;
 731         }
 732
 733         return attach;
 734
 735 err_attach:
 736         kfree(attach);
 737         return ERR_PTR(ret);
 738
 739 err_unpin:
 740         if (dma_buf_is_dynamic(attach->dmabuf))
 741                 dma_buf_unpin(attach);
 742
 743 err_unlock:
 744         if (dma_buf_is_dynamic(attach->dmabuf))
 745                 dma_resv_unlock(attach->dmabuf->resv);
 746
 747         dma_buf_detach(dmabuf, attach);
 748         return ERR_PTR(ret);
 749 }
 750 EXPORT_SYMBOL_GPL(dma_buf_dynamic_attach);
 751
 752 /**
 753  * dma_buf_attach - Wrapper for dma_buf_dynamic_attach
 754  * @dmabuf:     [in]    buffer to attach device to.
 755  * @dev:        [in]    device to be attached.
 756  *
 757  * Wrapper to call dma_buf_dynamic_attach() for drivers which still use a static
 758  * mapping.
 759  */
 760 struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
 761                                           struct device *dev)
 762 {
 763         return dma_buf_dynamic_attach(dmabuf, dev, NULL, NULL);
 764 }
 765 EXPORT_SYMBOL_GPL(dma_buf_attach);
 766
 767 /**
 768  * dma_buf_detach - Remove the given attachment from dmabuf's attachments list;
 769  * optionally calls detach() of dma_buf_ops for device-specific detach
 770  * @dmabuf:     [in]    buffer to detach from.
 771  * @attach:     [in]    attachment to be detached; is free'd after this call.
 772  *
 773  * Clean up a device attachment obtained by calling dma_buf_attach().
 774  */
 775 void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach)
 776 {
 777         if (WARN_ON(!dmabuf || !attach))
 778                 return;
 779
 780         if (attach->sgt) {
 781                 if (dma_buf_is_dynamic(attach->dmabuf))
 782                         dma_resv_lock(attach->dmabuf->resv, NULL);
 783
 784                 dmabuf->ops->unmap_dma_buf(attach, attach->sgt, attach->dir);
 785
 786                 if (dma_buf_is_dynamic(attach->dmabuf)) {
 787                         dma_buf_unpin(attach);
 788                         dma_resv_unlock(attach->dmabuf->resv);
 789                 }
 790         }
 791
 792         dma_resv_lock(dmabuf->resv, NULL);
 793         list_del(&attach->node);
 794         dma_resv_unlock(dmabuf->resv);
 795         if (dmabuf->ops->detach)
 796                 dmabuf->ops->detach(dmabuf, attach);
 797
 798         kfree(attach);
 799 }
 800 EXPORT_SYMBOL_GPL(dma_buf_detach);
 801
 802 /**
 803  * dma_buf_pin - Lock down the DMA-buf
 804  *
 805  * @attach:     [in]    attachment which should be pinned
 806  *
 807  * Returns:
 808  * 0 on success, negative error code on failure.
 809  */
 810 int dma_buf_pin(struct dma_buf_attachment *attach)
 811 {
 812         struct dma_buf *dmabuf = attach->dmabuf;
 813         int ret = 0;
 814
 815         dma_resv_assert_held(dmabuf->resv);
 816
 817         if (dmabuf->ops->pin)
 818                 ret = dmabuf->ops->pin(attach);
 819
 820         return ret;
 821 }
 822 EXPORT_SYMBOL_GPL(dma_buf_pin);
 823
 824 /**
 825  * dma_buf_unpin - Remove lock from DMA-buf
 826  *
 827  * @attach:     [in]    attachment which should be unpinned
 828  */
 829 void dma_buf_unpin(struct dma_buf_attachment *attach)
 830 {
 831         struct dma_buf *dmabuf = attach->dmabuf;
 832
 833         dma_resv_assert_held(dmabuf->resv);
 834
 835         if (dmabuf->ops->unpin)
 836                 dmabuf->ops->unpin(attach);
 837 }
 838 EXPORT_SYMBOL_GPL(dma_buf_unpin);
 839
 840 /**
 841  * dma_buf_map_attachment - Returns the scatterlist table of the attachment;
 842  * mapped into _device_ address space. Is a wrapper for map_dma_buf() of the
 843  * dma_buf_ops.
 844  * @attach:     [in]    attachment whose scatterlist is to be returned
 845  * @direction:  [in]    direction of DMA transfer
 846  *
 847  * Returns sg_table containing the scatterlist to be returned; returns ERR_PTR
 848  * on error. May return -EINTR if it is interrupted by a signal.
 849  *
 850  * A mapping must be unmapped by using dma_buf_unmap_attachment(). Note that
 851  * the underlying backing storage is pinned for as long as a mapping exists,
 852  * therefore users/importers should not hold onto a mapping for undue amounts of
 853  * time.
 854  */
 855 struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach,
 856                                         enum dma_data_direction direction)
 857 {
 858         struct sg_table *sg_table;
 859         int r;
 860
 861         might_sleep();
 862
 863         if (WARN_ON(!attach || !attach->dmabuf))
 864                 return ERR_PTR(-EINVAL);
 865
 866         if (dma_buf_attachment_is_dynamic(attach))
 867                 dma_resv_assert_held(attach->dmabuf->resv);
 868
 869         if (attach->sgt) {
 870                 /*
 871                  * Two mappings with different directions for the same
 872                  * attachment are not allowed.
 873                  */
 874                 if (attach->dir != direction &&
 875                     attach->dir != DMA_BIDIRECTIONAL)
 876                         return ERR_PTR(-EBUSY);
 877
 878                 return attach->sgt;
 879         }
 880
 881         if (dma_buf_is_dynamic(attach->dmabuf)) {
 882                 dma_resv_assert_held(attach->dmabuf->resv);
 883                 if (!IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY)) {
 884                         r = dma_buf_pin(attach);
 885                         if (r)
 886                                 return ERR_PTR(r);
 887                 }
 888         }
 889
 890         sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction);
 891         if (!sg_table)
 892                 sg_table = ERR_PTR(-ENOMEM);
 893
 894         if (IS_ERR(sg_table) && dma_buf_is_dynamic(attach->dmabuf) &&
 895              !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))
 896                 dma_buf_unpin(attach);
 897
 898         if (!IS_ERR(sg_table) && attach->dmabuf->ops->cache_sgt_mapping) {
 899                 attach->sgt = sg_table;
 900                 attach->dir = direction;
 901         }
 902
 903         return sg_table;
 904 }
 905 EXPORT_SYMBOL_GPL(dma_buf_map_attachment);
 906
 907 /**
 908  * dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might
 909  * deallocate the scatterlist associated. Is a wrapper for unmap_dma_buf() of
 910  * dma_buf_ops.
 911  * @attach:     [in]    attachment to unmap buffer from
 912  * @sg_table:   [in]    scatterlist info of the buffer to unmap
 913  * @direction:  [in]    direction of DMA transfer
 914  *
 915  * This unmaps a DMA mapping for @attached obtained by dma_buf_map_attachment().
 916  */
 917 void dma_buf_unmap_attachment(struct dma_buf_attachment *attach,
 918                                 struct sg_table *sg_table,
 919                                 enum dma_data_direction direction)
 920 {
 921         might_sleep();
 922
 923         if (WARN_ON(!attach || !attach->dmabuf || !sg_table))
 924                 return;
 925
 926         if (dma_buf_attachment_is_dynamic(attach))
 927                 dma_resv_assert_held(attach->dmabuf->resv);
 928
 929         if (attach->sgt == sg_table)
 930                 return;
 931
 932         if (dma_buf_is_dynamic(attach->dmabuf))
 933                 dma_resv_assert_held(attach->dmabuf->resv);
 934
 935         attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, direction);
 936
 937         if (dma_buf_is_dynamic(attach->dmabuf) &&
 938             !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))
 939                 dma_buf_unpin(attach);
 940 }
 941 EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment);
 942
 943 /**
 944  * dma_buf_move_notify - notify attachments that DMA-buf is moving
 945  *
 946  * @dmabuf:     [in]    buffer which is moving
 947  *
 948  * Informs all attachmenst that they need to destroy and recreated all their
 949  * mappings.
 950  */
 951 void dma_buf_move_notify(struct dma_buf *dmabuf)
 952 {
 953         struct dma_buf_attachment *attach;
 954
 955         dma_resv_assert_held(dmabuf->resv);
 956
 957         list_for_each_entry(attach, &dmabuf->attachments, node)
 958                 if (attach->importer_ops)
 959                         attach->importer_ops->move_notify(attach);
 960 }
 961 EXPORT_SYMBOL_GPL(dma_buf_move_notify);
 962
 963 /**
 964  * DOC: cpu access
 965  *
 966  * There are mutliple reasons for supporting CPU access to a dma buffer object:
 967  *
 968  * - Fallback operations in the kernel, for example when a device is connected
 969  *   over USB and the kernel needs to shuffle the data around first before
 970  *   sending it away. Cache coherency is handled by braketing any transactions
 971  *   with calls to dma_buf_begin_cpu_access() and dma_buf_end_cpu_access()
 972  *   access.
 973  *
 974  *   Since for most kernel internal dma-buf accesses need the entire buffer, a
 975  *   vmap interface is introduced. Note that on very old 32-bit architectures
 976  *   vmalloc space might be limited and result in vmap calls failing.
 977  *
 978  *   Interfaces::
 979  *      void \*dma_buf_vmap(struct dma_buf \*dmabuf)
 980  *      void dma_buf_vunmap(struct dma_buf \*dmabuf, void \*vaddr)
 981  *
 982  *   The vmap call can fail if there is no vmap support in the exporter, or if
 983  *   it runs out of vmalloc space. Fallback to kmap should be implemented. Note
 984  *   that the dma-buf layer keeps a reference count for all vmap access and
 985  *   calls down into the exporter's vmap function only when no vmapping exists,
 986  *   and only unmaps it once. Protection against concurrent vmap/vunmap calls is
 987  *   provided by taking the dma_buf->lock mutex.
 988  *
 989  * - For full compatibility on the importer side with existing userspace
 990  *   interfaces, which might already support mmap'ing buffers. This is needed in
 991  *   many processing pipelines (e.g. feeding a software rendered image into a
 992  *   hardware pipeline, thumbnail creation, snapshots, ...). Also, Android's ION
 993  *   framework already supported this and for DMA buffer file descriptors to
 994  *   replace ION buffers mmap support was needed.
 995  *
 996  *   There is no special interfaces, userspace simply calls mmap on the dma-buf
 997  *   fd. But like for CPU access there's a need to braket the actual access,
 998  *   which is handled by the ioctl (DMA_BUF_IOCTL_SYNC). Note that
 999  *   DMA_BUF_IOCTL_SYNC can fail with -EAGAIN or -EINTR, in which case it must
1000  *   be restarted.
1001  *
1002  *   Some systems might need some sort of cache coherency management e.g. when
1003  *   CPU and GPU domains are being accessed through dma-buf at the same time.
1004  *   To circumvent this problem there are begin/end coherency markers, that
1005  *   forward directly to existing dma-buf device drivers vfunc hooks. Userspace
1006  *   can make use of those markers through the DMA_BUF_IOCTL_SYNC ioctl. The
1007  *   sequence would be used like following:
1008  *
1009  *     - mmap dma-buf fd
1010  *     - for each drawing/upload cycle in CPU 1. SYNC_START ioctl, 2. read/write
1011  *       to mmap area 3. SYNC_END ioctl. This can be repeated as often as you
1012  *       want (with the new data being consumed by say the GPU or the scanout
1013  *       device)
1014  *     - munmap once you don't need the buffer any more
1015  *
1016  *    For correctness and optimal performance, it is always required to use
1017  *    SYNC_START and SYNC_END before and after, respectively, when accessing the
1018  *    mapped address. Userspace cannot rely on coherent access, even when there
1019  *    are systems where it just works without calling these ioctls.
1020  *
1021  * - And as a CPU fallback in userspace processing pipelines.
1022  *
1023  *   Similar to the motivation for kernel cpu access it is again important that
1024  *   the userspace code of a given importing subsystem can use the same
1025  *   interfaces with a imported dma-buf buffer object as with a native buffer
1026  *   object. This is especially important for drm where the userspace part of
1027  *   contemporary OpenGL, X, and other drivers is huge, and reworking them to
1028  *   use a different way to mmap a buffer rather invasive.
1029  *
1030  *   The assumption in the current dma-buf interfaces is that redirecting the
1031  *   initial mmap is all that's needed. A survey of some of the existing
1032  *   subsystems shows that no driver seems to do any nefarious thing like
1033  *   syncing up with outstanding asynchronous processing on the device or
1034  *   allocating special resources at fault time. So hopefully this is good
1035  *   enough, since adding interfaces to intercept pagefaults and allow pte
1036  *   shootdowns would increase the complexity quite a bit.
1037  *
1038  *   Interface::
1039  *      int dma_buf_mmap(struct dma_buf \*, struct vm_area_struct \*,
1040  *                     unsigned long);
1041  *
1042  *   If the importing subsystem simply provides a special-purpose mmap call to
1043  *   set up a mapping in userspace, calling do_mmap with dma_buf->file will
1044  *   equally achieve that for a dma-buf object.
1045  */
1046
1047 static int __dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
1048                                       enum dma_data_direction direction)
1049 {
1050         bool write = (direction == DMA_BIDIRECTIONAL ||
1051                       direction == DMA_TO_DEVICE);
1052         struct dma_resv *resv = dmabuf->resv;
1053         long ret;
1054
1055         /* Wait on any implicit rendering fences */
1056         ret = dma_resv_wait_timeout_rcu(resv, write, true,
1057                                                   MAX_SCHEDULE_TIMEOUT);
1058         if (ret < 0)
1059                 return ret;
1060
1061         return 0;
1062 }
1063
1064 /**
1065  * dma_buf_begin_cpu_access - Must be called before accessing a dma_buf from the
1066  * cpu in the kernel context. Calls begin_cpu_access to allow exporter-specific
1067  * preparations. Coherency is only guaranteed in the specified range for the
1068  * specified access direction.
1069  * @dmabuf:     [in]    buffer to prepare cpu access for.
1070  * @direction:  [in]    length of range for cpu access.
1071  *
1072  * After the cpu access is complete the caller should call
1073  * dma_buf_end_cpu_access(). Only when cpu access is braketed by both calls is
1074  * it guaranteed to be coherent with other DMA access.
1075  *
1076  * Can return negative error values, returns 0 on success.
1077  */
1078 int dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
1079                              enum dma_data_direction direction)
1080 {
1081         int ret = 0;
1082
1083         if (WARN_ON(!dmabuf))
1084                 return -EINVAL;
1085
1086         if (dmabuf->ops->begin_cpu_access)
1087                 ret = dmabuf->ops->begin_cpu_access(dmabuf, direction);
1088
1089         /* Ensure that all fences are waited upon - but we first allow
1090          * the native handler the chance to do so more efficiently if it
1091          * chooses. A double invocation here will be reasonably cheap no-op.
1092          */
1093         if (ret == 0)
1094                 ret = __dma_buf_begin_cpu_access(dmabuf, direction);
1095
1096         return ret;
1097 }
1098 EXPORT_SYMBOL_GPL(dma_buf_begin_cpu_access);
1099
1100 /**
1101  * dma_buf_end_cpu_access - Must be called after accessing a dma_buf from the
1102  * cpu in the kernel context. Calls end_cpu_access to allow exporter-specific
1103  * actions. Coherency is only guaranteed in the specified range for the
1104  * specified access direction.
1105  * @dmabuf:     [in]    buffer to complete cpu access for.
1106  * @direction:  [in]    length of range for cpu access.
1107  *
1108  * This terminates CPU access started with dma_buf_begin_cpu_access().
1109  *
1110  * Can return negative error values, returns 0 on success.
1111  */
1112 int dma_buf_end_cpu_access(struct dma_buf *dmabuf,
1113                            enum dma_data_direction direction)
1114 {
1115         int ret = 0;
1116
1117         WARN_ON(!dmabuf);
1118
1119         if (dmabuf->ops->end_cpu_access)
1120                 ret = dmabuf->ops->end_cpu_access(dmabuf, direction);
1121
1122         return ret;
1123 }
1124 EXPORT_SYMBOL_GPL(dma_buf_end_cpu_access);
1125
1126
1127 /**
1128  * dma_buf_mmap - Setup up a userspace mmap with the given vma
1129  * @dmabuf:     [in]    buffer that should back the vma
1130  * @vma:        [in]    vma for the mmap
1131  * @pgoff:      [in]    offset in pages where this mmap should start within the
1132  *                      dma-buf buffer.
1133  *
1134  * This function adjusts the passed in vma so that it points at the file of the
1135  * dma_buf operation. It also adjusts the starting pgoff and does bounds
1136  * checking on the size of the vma. Then it calls the exporters mmap function to
1137  * set up the mapping.
1138  *
1139  * Can return negative error values, returns 0 on success.
1140  */
1141 int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma,
1142                  unsigned long pgoff)
1143 {
1144         struct file *oldfile;
1145         int ret;
1146
1147         if (WARN_ON(!dmabuf || !vma))
1148                 return -EINVAL;
1149
1150         /* check if buffer supports mmap */
1151         if (!dmabuf->ops->mmap)
1152                 return -EINVAL;
1153
1154         /* check for offset overflow */
1155         if (pgoff + vma_pages(vma) < pgoff)
1156                 return -EOVERFLOW;
1157
1158         /* check for overflowing the buffer's size */
1159         if (pgoff + vma_pages(vma) >
1160             dmabuf->size >> PAGE_SHIFT)
1161                 return -EINVAL;
1162
1163         /* readjust the vma */
1164         get_file(dmabuf->file);
1165         oldfile = vma->vm_file;
1166         vma->vm_file = dmabuf->file;
1167         vma->vm_pgoff = pgoff;
1168
1169         ret = dmabuf->ops->mmap(dmabuf, vma);
1170         if (ret) {
1171                 /* restore old parameters on failure */
1172                 vma->vm_file = oldfile;
1173                 fput(dmabuf->file);
1174         } else {
1175                 if (oldfile)
1176                         fput(oldfile);
1177         }
1178         return ret;
1179
1180 }
1181 EXPORT_SYMBOL_GPL(dma_buf_mmap);
1182
1183 /**
1184  * dma_buf_vmap - Create virtual mapping for the buffer object into kernel
1185  * address space. Same restrictions as for vmap and friends apply.
1186  * @dmabuf:     [in]    buffer to vmap
1187  *
1188  * This call may fail due to lack of virtual mapping address space.
1189  * These calls are optional in drivers. The intended use for them
1190  * is for mapping objects linear in kernel space for high use objects.
1191  * Please attempt to use kmap/kunmap before thinking about these interfaces.
1192  *
1193  * Returns NULL on error.
1194  */
1195 void *dma_buf_vmap(struct dma_buf *dmabuf)
1196 {
1197         void *ptr;
1198
1199         if (WARN_ON(!dmabuf))
1200                 return NULL;
1201
1202         if (!dmabuf->ops->vmap)
1203                 return NULL;
1204
1205         mutex_lock(&dmabuf->lock);
1206         if (dmabuf->vmapping_counter) {
1207                 dmabuf->vmapping_counter++;
1208                 BUG_ON(!dmabuf->vmap_ptr);
1209                 ptr = dmabuf->vmap_ptr;
1210                 goto out_unlock;
1211         }
1212
1213         BUG_ON(dmabuf->vmap_ptr);
1214
1215         ptr = dmabuf->ops->vmap(dmabuf);
1216         if (WARN_ON_ONCE(IS_ERR(ptr)))
1217                 ptr = NULL;
1218         if (!ptr)
1219                 goto out_unlock;
1220
1221         dmabuf->vmap_ptr = ptr;
1222         dmabuf->vmapping_counter = 1;
1223
1224 out_unlock:
1225         mutex_unlock(&dmabuf->lock);
1226         return ptr;
1227 }
1228 EXPORT_SYMBOL_GPL(dma_buf_vmap);
1229
1230 /**
1231  * dma_buf_vunmap - Unmap a vmap obtained by dma_buf_vmap.
1232  * @dmabuf:     [in]    buffer to vunmap
1233  * @vaddr:      [in]    vmap to vunmap
1234  */
1235 void dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr)
1236 {
1237         if (WARN_ON(!dmabuf))
1238                 return;
1239
1240         BUG_ON(!dmabuf->vmap_ptr);
1241         BUG_ON(dmabuf->vmapping_counter == 0);
1242         BUG_ON(dmabuf->vmap_ptr != vaddr);
1243
1244         mutex_lock(&dmabuf->lock);
1245         if (--dmabuf->vmapping_counter == 0) {
1246                 if (dmabuf->ops->vunmap)
1247                         dmabuf->ops->vunmap(dmabuf, vaddr);
1248                 dmabuf->vmap_ptr = NULL;
1249         }
1250         mutex_unlock(&dmabuf->lock);
1251 }
1252 EXPORT_SYMBOL_GPL(dma_buf_vunmap);
1253
1254 #ifdef CONFIG_DEBUG_FS
1255 static int dma_buf_debug_show(struct seq_file *s, void *unused)
1256 {
1257         int ret;
1258         struct dma_buf *buf_obj;
1259         struct dma_buf_attachment *attach_obj;
1260         struct dma_resv *robj;
1261         struct dma_resv_list *fobj;
1262         struct dma_fence *fence;
1263         unsigned seq;
1264         int count = 0, attach_count, shared_count, i;
1265         size_t size = 0;
1266
1267         ret = mutex_lock_interruptible(&db_list.lock);
1268
1269         if (ret)
1270                 return ret;
1271
1272         seq_puts(s, "\nDma-buf Objects:\n");
1273         seq_printf(s, "%-8s\t%-8s\t%-8s\t%-8s\texp_name\t%-8s\n",
1274                    "size", "flags", "mode", "count", "ino");
1275
1276         list_for_each_entry(buf_obj, &db_list.head, list_node) {
1277
1278                 ret = dma_resv_lock_interruptible(buf_obj->resv, NULL);
1279                 if (ret)
1280                         goto error_unlock;
1281
1282                 seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
1283                                 buf_obj->size,
1284                                 buf_obj->file->f_flags, buf_obj->file->f_mode,
1285                                 file_count(buf_obj->file),
1286                                 buf_obj->exp_name,
1287                                 file_inode(buf_obj->file)->i_ino,
1288                                 buf_obj->name ?: "");
1289
1290                 robj = buf_obj->resv;
1291                 while (true) {
1292                         seq = read_seqcount_begin(&robj->seq);
1293                         rcu_read_lock();
1294                         fobj = rcu_dereference(robj->fence);
1295                         shared_count = fobj ? fobj->shared_count : 0;
1296                         fence = rcu_dereference(robj->fence_excl);
1297                         if (!read_seqcount_retry(&robj->seq, seq))
1298                                 break;
1299                         rcu_read_unlock();
1300                 }
1301
1302                 if (fence)
1303                         seq_printf(s, "\tExclusive fence: %s %s %ssignalled\n",
1304                                    fence->ops->get_driver_name(fence),
1305                                    fence->ops->get_timeline_name(fence),
1306                                    dma_fence_is_signaled(fence) ? "" : "un");
1307                 for (i = 0; i < shared_count; i++) {
1308                         fence = rcu_dereference(fobj->shared[i]);
1309                         if (!dma_fence_get_rcu(fence))
1310                                 continue;
1311                         seq_printf(s, "\tShared fence: %s %s %ssignalled\n",
1312                                    fence->ops->get_driver_name(fence),
1313                                    fence->ops->get_timeline_name(fence),
1314                                    dma_fence_is_signaled(fence) ? "" : "un");
1315                         dma_fence_put(fence);
1316                 }
1317                 rcu_read_unlock();
1318
1319                 seq_puts(s, "\tAttached Devices:\n");
1320                 attach_count = 0;
1321
1322                 list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
1323                         seq_printf(s, "\t%s\n", dev_name(attach_obj->dev));
1324                         attach_count++;
1325                 }
1326                 dma_resv_unlock(buf_obj->resv);
1327
1328                 seq_printf(s, "Total %d devices attached\n\n",
1329                                 attach_count);
1330
1331                 count++;
1332                 size += buf_obj->size;
1333         }
1334
1335         seq_printf(s, "\nTotal %d objects, %zu bytes\n", count, size);
1336
1337         mutex_unlock(&db_list.lock);
1338         return 0;
1339
1340 error_unlock:
1341         mutex_unlock(&db_list.lock);
1342         return ret;
1343 }
1344
1345 DEFINE_SHOW_ATTRIBUTE(dma_buf_debug);
1346
1347 static struct dentry *dma_buf_debugfs_dir;
1348
1349 static int dma_buf_init_debugfs(void)
1350 {
1351         struct dentry *d;
1352         int err = 0;
1353
1354         d = debugfs_create_dir("dma_buf", NULL);
1355         if (IS_ERR(d))
1356                 return PTR_ERR(d);
1357
1358         dma_buf_debugfs_dir = d;
1359
1360         d = debugfs_create_file("bufinfo", S_IRUGO, dma_buf_debugfs_dir,
1361                                 NULL, &dma_buf_debug_fops);
1362         if (IS_ERR(d)) {
1363                 pr_debug("dma_buf: debugfs: failed to create node bufinfo\n");
1364                 debugfs_remove_recursive(dma_buf_debugfs_dir);
1365                 dma_buf_debugfs_dir = NULL;
1366                 err = PTR_ERR(d);
1367         }
1368
1369         return err;
1370 }
1371
1372 static void dma_buf_uninit_debugfs(void)
1373 {
1374         debugfs_remove_recursive(dma_buf_debugfs_dir);
1375 }
1376 #else
1377 static inline int dma_buf_init_debugfs(void)
1378 {
1379         return 0;
1380 }
1381 static inline void dma_buf_uninit_debugfs(void)
1382 {
1383 }
1384 #endif
1385
1386 static int __init dma_buf_init(void)
1387 {
1388         dma_buf_mnt = kern_mount(&dma_buf_fs_type);
1389         if (IS_ERR(dma_buf_mnt))
1390                 return PTR_ERR(dma_buf_mnt);
1391
1392         mutex_init(&db_list.lock);
1393         INIT_LIST_HEAD(&db_list.head);
1394         dma_buf_init_debugfs();
1395         return 0;
1396 }
1397 subsys_initcall(dma_buf_init);
1398
1399 static void __exit dma_buf_deinit(void)
1400 {
1401         dma_buf_uninit_debugfs();
1402         kern_unmount(dma_buf_mnt);
1403 }
1404 __exitcall(dma_buf_deinit);