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