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