drivers/gpu/drm/drm_prime.c

   1 /*
   2  * Copyright © 2012 Red Hat
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Dave Airlie <[email protected]>
  25  *      Rob Clark <[email protected]>
  26  *
  27  */
  28
  29 #include <linux/export.h>
  30 #include <linux/dma-buf.h>
  31 #include <linux/rbtree.h>
  32 #include <drm/drm_prime.h>
  33 #include <drm/drm_gem.h>
  34 #include <drm/drmP.h>
  35
  36 #include "drm_internal.h"
  37
  38 /*
  39  * DMA-BUF/GEM Object references and lifetime overview:
  40  *
  41  * On the export the dma_buf holds a reference to the exporting GEM
  42  * object. It takes this reference in handle_to_fd_ioctl, when it
  43  * first calls .prime_export and stores the exporting GEM object in
  44  * the dma_buf priv. This reference needs to be released when the
  45  * final reference to the &dma_buf itself is dropped and its
  46  * &dma_buf_ops.release function is called. For GEM-based drivers,
  47  * the dma_buf should be exported using drm_gem_dmabuf_export() and
  48  * then released by drm_gem_dmabuf_release().
  49  *
  50  * On the import the importing GEM object holds a reference to the
  51  * dma_buf (which in turn holds a ref to the exporting GEM object).
  52  * It takes that reference in the fd_to_handle ioctl.
  53  * It calls dma_buf_get, creates an attachment to it and stores the
  54  * attachment in the GEM object. When this attachment is destroyed
  55  * when the imported object is destroyed, we remove the attachment
  56  * and drop the reference to the dma_buf.
  57  *
  58  * When all the references to the &dma_buf are dropped, i.e. when
  59  * userspace has closed both handles to the imported GEM object (through the
  60  * FD_TO_HANDLE IOCTL) and closed the file descriptor of the exported
  61  * (through the HANDLE_TO_FD IOCTL) dma_buf, and all kernel-internal references
  62  * are also gone, then the dma_buf gets destroyed.  This can also happen as a
  63  * part of the clean up procedure in the drm_release() function if userspace
  64  * fails to properly clean up.  Note that both the kernel and userspace (by
  65  * keeeping the PRIME file descriptors open) can hold references onto a
  66  * &dma_buf.
  67  *
  68  * Thus the chain of references always flows in one direction
  69  * (avoiding loops): importing_gem -> dmabuf -> exporting_gem
  70  *
  71  * Self-importing: if userspace is using PRIME as a replacement for flink
  72  * then it will get a fd->handle request for a GEM object that it created.
  73  * Drivers should detect this situation and return back the gem object
  74  * from the dma-buf private.  Prime will do this automatically for drivers that
  75  * use the drm_gem_prime_{import,export} helpers.
  76  *
  77  * GEM struct &dma_buf_ops symbols are now exported. They can be resued by
  78  * drivers which implement GEM interface.
  79  */
  80
  81 struct drm_prime_member {
  82         struct dma_buf *dma_buf;
  83         uint32_t handle;
  84
  85         struct rb_node dmabuf_rb;
  86         struct rb_node handle_rb;
  87 };
  88
  89 struct drm_prime_attachment {
  90         struct sg_table *sgt;
  91         enum dma_data_direction dir;
  92 };
  93
  94 static int drm_prime_add_buf_handle(struct drm_prime_file_private *prime_fpriv,
  95                                     struct dma_buf *dma_buf, uint32_t handle)
  96 {
  97         struct drm_prime_member *member;
  98         struct rb_node **p, *rb;
  99
 100         member = kmalloc(sizeof(*member), GFP_KERNEL);
 101         if (!member)
 102                 return -ENOMEM;
 103
 104         get_dma_buf(dma_buf);
 105         member->dma_buf = dma_buf;
 106         member->handle = handle;
 107
 108         rb = NULL;
 109         p = &prime_fpriv->dmabufs.rb_node;
 110         while (*p) {
 111                 struct drm_prime_member *pos;
 112
 113                 rb = *p;
 114                 pos = rb_entry(rb, struct drm_prime_member, dmabuf_rb);
 115                 if (dma_buf > pos->dma_buf)
 116                         p = &rb->rb_right;
 117                 else
 118                         p = &rb->rb_left;
 119         }
 120         rb_link_node(&member->dmabuf_rb, rb, p);
 121         rb_insert_color(&member->dmabuf_rb, &prime_fpriv->dmabufs);
 122
 123         rb = NULL;
 124         p = &prime_fpriv->handles.rb_node;
 125         while (*p) {
 126                 struct drm_prime_member *pos;
 127
 128                 rb = *p;
 129                 pos = rb_entry(rb, struct drm_prime_member, handle_rb);
 130                 if (handle > pos->handle)
 131                         p = &rb->rb_right;
 132                 else
 133                         p = &rb->rb_left;
 134         }
 135         rb_link_node(&member->handle_rb, rb, p);
 136         rb_insert_color(&member->handle_rb, &prime_fpriv->handles);
 137
 138         return 0;
 139 }
 140
 141 static struct dma_buf *drm_prime_lookup_buf_by_handle(struct drm_prime_file_private *prime_fpriv,
 142                                                       uint32_t handle)
 143 {
 144         struct rb_node *rb;
 145
 146         rb = prime_fpriv->handles.rb_node;
 147         while (rb) {
 148                 struct drm_prime_member *member;
 149
 150                 member = rb_entry(rb, struct drm_prime_member, handle_rb);
 151                 if (member->handle == handle)
 152                         return member->dma_buf;
 153                 else if (member->handle < handle)
 154                         rb = rb->rb_right;
 155                 else
 156                         rb = rb->rb_left;
 157         }
 158
 159         return NULL;
 160 }
 161
 162 static int drm_prime_lookup_buf_handle(struct drm_prime_file_private *prime_fpriv,
 163                                        struct dma_buf *dma_buf,
 164                                        uint32_t *handle)
 165 {
 166         struct rb_node *rb;
 167
 168         rb = prime_fpriv->dmabufs.rb_node;
 169         while (rb) {
 170                 struct drm_prime_member *member;
 171
 172                 member = rb_entry(rb, struct drm_prime_member, dmabuf_rb);
 173                 if (member->dma_buf == dma_buf) {
 174                         *handle = member->handle;
 175                         return 0;
 176                 } else if (member->dma_buf < dma_buf) {
 177                         rb = rb->rb_right;
 178                 } else {
 179                         rb = rb->rb_left;
 180                 }
 181         }
 182
 183         return -ENOENT;
 184 }
 185
 186 /**
 187  * drm_gem_map_attach - dma_buf attach implementation for GEM
 188  * @dma_buf: buffer to attach device to
 189  * @target_dev: not used
 190  * @attach: buffer attachment data
 191  *
 192  * Allocates &drm_prime_attachment and calls &drm_driver.gem_prime_pin for
 193  * device specific attachment. This can be used as the &dma_buf_ops.attach
 194  * callback.
 195  *
 196  * Returns 0 on success, negative error code on failure.
 197  */
 198 int drm_gem_map_attach(struct dma_buf *dma_buf, struct device *target_dev,
 199                        struct dma_buf_attachment *attach)
 200 {
 201         struct drm_prime_attachment *prime_attach;
 202         struct drm_gem_object *obj = dma_buf->priv;
 203         struct drm_device *dev = obj->dev;
 204
 205         prime_attach = kzalloc(sizeof(*prime_attach), GFP_KERNEL);
 206         if (!prime_attach)
 207                 return -ENOMEM;
 208
 209         prime_attach->dir = DMA_NONE;
 210         attach->priv = prime_attach;
 211
 212         if (!dev->driver->gem_prime_pin)
 213                 return 0;
 214
 215         return dev->driver->gem_prime_pin(obj);
 216 }
 217 EXPORT_SYMBOL(drm_gem_map_attach);
 218
 219 /**
 220  * drm_gem_map_detach - dma_buf detach implementation for GEM
 221  * @dma_buf: buffer to detach from
 222  * @attach: attachment to be detached
 223  *
 224  * Cleans up &dma_buf_attachment. This can be used as the &dma_buf_ops.detach
 225  * callback.
 226  */
 227 void drm_gem_map_detach(struct dma_buf *dma_buf,
 228                         struct dma_buf_attachment *attach)
 229 {
 230         struct drm_prime_attachment *prime_attach = attach->priv;
 231         struct drm_gem_object *obj = dma_buf->priv;
 232         struct drm_device *dev = obj->dev;
 233
 234         if (prime_attach) {
 235                 struct sg_table *sgt = prime_attach->sgt;
 236
 237                 if (sgt) {
 238                         if (prime_attach->dir != DMA_NONE)
 239                                 dma_unmap_sg_attrs(attach->dev, sgt->sgl,
 240                                                    sgt->nents,
 241                                                    prime_attach->dir,
 242                                                    DMA_ATTR_SKIP_CPU_SYNC);
 243                         sg_free_table(sgt);
 244                 }
 245
 246                 kfree(sgt);
 247                 kfree(prime_attach);
 248                 attach->priv = NULL;
 249         }
 250
 251         if (dev->driver->gem_prime_unpin)
 252                 dev->driver->gem_prime_unpin(obj);
 253 }
 254 EXPORT_SYMBOL(drm_gem_map_detach);
 255
 256 void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv,
 257                                         struct dma_buf *dma_buf)
 258 {
 259         struct rb_node *rb;
 260
 261         rb = prime_fpriv->dmabufs.rb_node;
 262         while (rb) {
 263                 struct drm_prime_member *member;
 264
 265                 member = rb_entry(rb, struct drm_prime_member, dmabuf_rb);
 266                 if (member->dma_buf == dma_buf) {
 267                         rb_erase(&member->handle_rb, &prime_fpriv->handles);
 268                         rb_erase(&member->dmabuf_rb, &prime_fpriv->dmabufs);
 269
 270                         dma_buf_put(dma_buf);
 271                         kfree(member);
 272                         return;
 273                 } else if (member->dma_buf < dma_buf) {
 274                         rb = rb->rb_right;
 275                 } else {
 276                         rb = rb->rb_left;
 277                 }
 278         }
 279 }
 280
 281 /**
 282  * drm_gem_map_dma_buf - map_dma_buf implementation for GEM
 283  * @attach: attachment whose scatterlist is to be returned
 284  * @dir: direction of DMA transfer
 285  *
 286  * Calls &drm_driver.gem_prime_get_sg_table and then maps the scatterlist. This
 287  * can be used as the &dma_buf_ops.map_dma_buf callback.
 288  *
 289  * Returns sg_table containing the scatterlist to be returned; returns ERR_PTR
 290  * on error. May return -EINTR if it is interrupted by a signal.
 291  */
 292
 293 struct sg_table *drm_gem_map_dma_buf(struct dma_buf_attachment *attach,
 294                                      enum dma_data_direction dir)
 295 {
 296         struct drm_prime_attachment *prime_attach = attach->priv;
 297         struct drm_gem_object *obj = attach->dmabuf->priv;
 298         struct sg_table *sgt;
 299
 300         if (WARN_ON(dir == DMA_NONE || !prime_attach))
 301                 return ERR_PTR(-EINVAL);
 302
 303         /* return the cached mapping when possible */
 304         if (prime_attach->dir == dir)
 305                 return prime_attach->sgt;
 306
 307         /*
 308          * two mappings with different directions for the same attachment are
 309          * not allowed
 310          */
 311         if (WARN_ON(prime_attach->dir != DMA_NONE))
 312                 return ERR_PTR(-EBUSY);
 313
 314         sgt = obj->dev->driver->gem_prime_get_sg_table(obj);
 315
 316         if (!IS_ERR(sgt)) {
 317                 if (!dma_map_sg_attrs(attach->dev, sgt->sgl, sgt->nents, dir,
 318                                       DMA_ATTR_SKIP_CPU_SYNC)) {
 319                         sg_free_table(sgt);
 320                         kfree(sgt);
 321                         sgt = ERR_PTR(-ENOMEM);
 322                 } else {
 323                         prime_attach->sgt = sgt;
 324                         prime_attach->dir = dir;
 325                 }
 326         }
 327
 328         return sgt;
 329 }
 330 EXPORT_SYMBOL(drm_gem_map_dma_buf);
 331
 332 /**
 333  * drm_gem_unmap_dma_buf - unmap_dma_buf implementation for GEM
 334  *
 335  * Not implemented. The unmap is done at drm_gem_map_detach().  This can be
 336  * used as the &dma_buf_ops.unmap_dma_buf callback.
 337  */
 338 void drm_gem_unmap_dma_buf(struct dma_buf_attachment *attach,
 339                            struct sg_table *sgt,
 340                            enum dma_data_direction dir)
 341 {
 342         /* nothing to be done here */
 343 }
 344 EXPORT_SYMBOL(drm_gem_unmap_dma_buf);
 345
 346 /**
 347  * drm_gem_dmabuf_export - dma_buf export implementation for GEM
 348  * @dev: parent device for the exported dmabuf
 349  * @exp_info: the export information used by dma_buf_export()
 350  *
 351  * This wraps dma_buf_export() for use by generic GEM drivers that are using
 352  * drm_gem_dmabuf_release(). In addition to calling dma_buf_export(), we take
 353  * a reference to the &drm_device and the exported &drm_gem_object (stored in
 354  * &dma_buf_export_info.priv) which is released by drm_gem_dmabuf_release().
 355  *
 356  * Returns the new dmabuf.
 357  */
 358 struct dma_buf *drm_gem_dmabuf_export(struct drm_device *dev,
 359                                       struct dma_buf_export_info *exp_info)
 360 {
 361         struct dma_buf *dma_buf;
 362
 363         dma_buf = dma_buf_export(exp_info);
 364         if (IS_ERR(dma_buf))
 365                 return dma_buf;
 366
 367         drm_dev_get(dev);
 368         drm_gem_object_get(exp_info->priv);
 369
 370         return dma_buf;
 371 }
 372 EXPORT_SYMBOL(drm_gem_dmabuf_export);
 373
 374 /**
 375  * drm_gem_dmabuf_release - dma_buf release implementation for GEM
 376  * @dma_buf: buffer to be released
 377  *
 378  * Generic release function for dma_bufs exported as PRIME buffers. GEM drivers
 379  * must use this in their dma_buf ops structure as the release callback.
 380  * drm_gem_dmabuf_release() should be used in conjunction with
 381  * drm_gem_dmabuf_export().
 382  */
 383 void drm_gem_dmabuf_release(struct dma_buf *dma_buf)
 384 {
 385         struct drm_gem_object *obj = dma_buf->priv;
 386         struct drm_device *dev = obj->dev;
 387
 388         /* drop the reference on the export fd holds */
 389         drm_gem_object_put_unlocked(obj);
 390
 391         drm_dev_put(dev);
 392 }
 393 EXPORT_SYMBOL(drm_gem_dmabuf_release);
 394
 395 /**
 396  * drm_gem_dmabuf_vmap - dma_buf vmap implementation for GEM
 397  * @dma_buf: buffer to be mapped
 398  *
 399  * Sets up a kernel virtual mapping. This can be used as the &dma_buf_ops.vmap
 400  * callback.
 401  *
 402  * Returns the kernel virtual address.
 403  */
 404 void *drm_gem_dmabuf_vmap(struct dma_buf *dma_buf)
 405 {
 406         struct drm_gem_object *obj = dma_buf->priv;
 407         struct drm_device *dev = obj->dev;
 408
 409         return dev->driver->gem_prime_vmap(obj);
 410 }
 411 EXPORT_SYMBOL(drm_gem_dmabuf_vmap);
 412
 413 /**
 414  * drm_gem_dmabuf_vunmap - dma_buf vunmap implementation for GEM
 415  * @dma_buf: buffer to be unmapped
 416  * @vaddr: the virtual address of the buffer
 417  *
 418  * Releases a kernel virtual mapping. This can be used as the
 419  * &dma_buf_ops.vunmap callback.
 420  */
 421 void drm_gem_dmabuf_vunmap(struct dma_buf *dma_buf, void *vaddr)
 422 {
 423         struct drm_gem_object *obj = dma_buf->priv;
 424         struct drm_device *dev = obj->dev;
 425
 426         dev->driver->gem_prime_vunmap(obj, vaddr);
 427 }
 428 EXPORT_SYMBOL(drm_gem_dmabuf_vunmap);
 429
 430 /**
 431  * drm_gem_dmabuf_kmap_atomic - map_atomic implementation for GEM
 432  *
 433  * Not implemented. This can be used as the &dma_buf_ops.map_atomic callback.
 434  */
 435 void *drm_gem_dmabuf_kmap_atomic(struct dma_buf *dma_buf,
 436                                  unsigned long page_num)
 437 {
 438         return NULL;
 439 }
 440 EXPORT_SYMBOL(drm_gem_dmabuf_kmap_atomic);
 441
 442 /**
 443  * drm_gem_dmabuf_kunmap_atomic - unmap_atomic implementation for GEM
 444  *
 445  * Not implemented. This can be used as the &dma_buf_ops.unmap_atomic callback.
 446  */
 447 void drm_gem_dmabuf_kunmap_atomic(struct dma_buf *dma_buf,
 448                                   unsigned long page_num, void *addr)
 449 {
 450
 451 }
 452 EXPORT_SYMBOL(drm_gem_dmabuf_kunmap_atomic);
 453
 454 /**
 455  * drm_gem_dmabuf_kmap - map implementation for GEM
 456  *
 457  * Not implemented. This can be used as the &dma_buf_ops.map callback.
 458  */
 459 void *drm_gem_dmabuf_kmap(struct dma_buf *dma_buf, unsigned long page_num)
 460 {
 461         return NULL;
 462 }
 463 EXPORT_SYMBOL(drm_gem_dmabuf_kmap);
 464
 465 /**
 466  * drm_gem_dmabuf_kunmap - unmap implementation for GEM
 467  *
 468  * Not implemented. This can be used as the &dma_buf_ops.unmap callback.
 469  */
 470 void drm_gem_dmabuf_kunmap(struct dma_buf *dma_buf, unsigned long page_num,
 471                            void *addr)
 472 {
 473
 474 }
 475 EXPORT_SYMBOL(drm_gem_dmabuf_kunmap);
 476
 477 /**
 478  * drm_gem_dmabuf_mmap - dma_buf mmap implementation for GEM
 479  * @dma_buf: buffer to be mapped
 480  * @vma: virtual address range
 481  *
 482  * Provides memory mapping for the buffer. This can be used as the
 483  * &dma_buf_ops.mmap callback.
 484  *
 485  * Returns 0 on success or a negative error code on failure.
 486  */
 487 int drm_gem_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
 488 {
 489         struct drm_gem_object *obj = dma_buf->priv;
 490         struct drm_device *dev = obj->dev;
 491
 492         if (!dev->driver->gem_prime_mmap)
 493                 return -ENOSYS;
 494
 495         return dev->driver->gem_prime_mmap(obj, vma);
 496 }
 497 EXPORT_SYMBOL(drm_gem_dmabuf_mmap);
 498
 499 static const struct dma_buf_ops drm_gem_prime_dmabuf_ops =  {
 500         .attach = drm_gem_map_attach,
 501         .detach = drm_gem_map_detach,
 502         .map_dma_buf = drm_gem_map_dma_buf,
 503         .unmap_dma_buf = drm_gem_unmap_dma_buf,
 504         .release = drm_gem_dmabuf_release,
 505         .map = drm_gem_dmabuf_kmap,
 506         .map_atomic = drm_gem_dmabuf_kmap_atomic,
 507         .unmap = drm_gem_dmabuf_kunmap,
 508         .unmap_atomic = drm_gem_dmabuf_kunmap_atomic,
 509         .mmap = drm_gem_dmabuf_mmap,
 510         .vmap = drm_gem_dmabuf_vmap,
 511         .vunmap = drm_gem_dmabuf_vunmap,
 512 };
 513
 514 /**
 515  * DOC: PRIME Helpers
 516  *
 517  * Drivers can implement @gem_prime_export and @gem_prime_import in terms of
 518  * simpler APIs by using the helper functions @drm_gem_prime_export and
 519  * @drm_gem_prime_import.  These functions implement dma-buf support in terms of
 520  * six lower-level driver callbacks:
 521  *
 522  * Export callbacks:
 523  *
 524  *  * @gem_prime_pin (optional): prepare a GEM object for exporting
 525  *  * @gem_prime_get_sg_table: provide a scatter/gather table of pinned pages
 526  *  * @gem_prime_vmap: vmap a buffer exported by your driver
 527  *  * @gem_prime_vunmap: vunmap a buffer exported by your driver
 528  *  * @gem_prime_mmap (optional): mmap a buffer exported by your driver
 529  *
 530  * Import callback:
 531  *
 532  *  * @gem_prime_import_sg_table (import): produce a GEM object from another
 533  *    driver's scatter/gather table
 534  */
 535
 536 /**
 537  * drm_gem_prime_export - helper library implementation of the export callback
 538  * @dev: drm_device to export from
 539  * @obj: GEM object to export
 540  * @flags: flags like DRM_CLOEXEC and DRM_RDWR
 541  *
 542  * This is the implementation of the gem_prime_export functions for GEM drivers
 543  * using the PRIME helpers.
 544  */
 545 struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
 546                                      struct drm_gem_object *obj,
 547                                      int flags)
 548 {
 549         struct dma_buf_export_info exp_info = {
 550                 .exp_name = KBUILD_MODNAME, /* white lie for debug */
 551                 .owner = dev->driver->fops->owner,
 552                 .ops = &drm_gem_prime_dmabuf_ops,
 553                 .size = obj->size,
 554                 .flags = flags,
 555                 .priv = obj,
 556         };
 557
 558         if (dev->driver->gem_prime_res_obj)
 559                 exp_info.resv = dev->driver->gem_prime_res_obj(obj);
 560
 561         return drm_gem_dmabuf_export(dev, &exp_info);
 562 }
 563 EXPORT_SYMBOL(drm_gem_prime_export);
 564
 565 static struct dma_buf *export_and_register_object(struct drm_device *dev,
 566                                                   struct drm_gem_object *obj,
 567                                                   uint32_t flags)
 568 {
 569         struct dma_buf *dmabuf;
 570
 571         /* prevent races with concurrent gem_close. */
 572         if (obj->handle_count == 0) {
 573                 dmabuf = ERR_PTR(-ENOENT);
 574                 return dmabuf;
 575         }
 576
 577         dmabuf = dev->driver->gem_prime_export(dev, obj, flags);
 578         if (IS_ERR(dmabuf)) {
 579                 /* normally the created dma-buf takes ownership of the ref,
 580                  * but if that fails then drop the ref
 581                  */
 582                 return dmabuf;
 583         }
 584
 585         /*
 586          * Note that callers do not need to clean up the export cache
 587          * since the check for obj->handle_count guarantees that someone
 588          * will clean it up.
 589          */
 590         obj->dma_buf = dmabuf;
 591         get_dma_buf(obj->dma_buf);
 592
 593         return dmabuf;
 594 }
 595
 596 /**
 597  * drm_gem_prime_handle_to_fd - PRIME export function for GEM drivers
 598  * @dev: dev to export the buffer from
 599  * @file_priv: drm file-private structure
 600  * @handle: buffer handle to export
 601  * @flags: flags like DRM_CLOEXEC
 602  * @prime_fd: pointer to storage for the fd id of the create dma-buf
 603  *
 604  * This is the PRIME export function which must be used mandatorily by GEM
 605  * drivers to ensure correct lifetime management of the underlying GEM object.
 606  * The actual exporting from GEM object to a dma-buf is done through the
 607  * gem_prime_export driver callback.
 608  */
 609 int drm_gem_prime_handle_to_fd(struct drm_device *dev,
 610                                struct drm_file *file_priv, uint32_t handle,
 611                                uint32_t flags,
 612                                int *prime_fd)
 613 {
 614         struct drm_gem_object *obj;
 615         int ret = 0;
 616         struct dma_buf *dmabuf;
 617
 618         mutex_lock(&file_priv->prime.lock);
 619         obj = drm_gem_object_lookup(file_priv, handle);
 620         if (!obj)  {
 621                 ret = -ENOENT;
 622                 goto out_unlock;
 623         }
 624
 625         dmabuf = drm_prime_lookup_buf_by_handle(&file_priv->prime, handle);
 626         if (dmabuf) {
 627                 get_dma_buf(dmabuf);
 628                 goto out_have_handle;
 629         }
 630
 631         mutex_lock(&dev->object_name_lock);
 632         /* re-export the original imported object */
 633         if (obj->import_attach) {
 634                 dmabuf = obj->import_attach->dmabuf;
 635                 get_dma_buf(dmabuf);
 636                 goto out_have_obj;
 637         }
 638
 639         if (obj->dma_buf) {
 640                 get_dma_buf(obj->dma_buf);
 641                 dmabuf = obj->dma_buf;
 642                 goto out_have_obj;
 643         }
 644
 645         dmabuf = export_and_register_object(dev, obj, flags);
 646         if (IS_ERR(dmabuf)) {
 647                 /* normally the created dma-buf takes ownership of the ref,
 648                  * but if that fails then drop the ref
 649                  */
 650                 ret = PTR_ERR(dmabuf);
 651                 mutex_unlock(&dev->object_name_lock);
 652                 goto out;
 653         }
 654
 655 out_have_obj:
 656         /*
 657          * If we've exported this buffer then cheat and add it to the import list
 658          * so we get the correct handle back. We must do this under the
 659          * protection of dev->object_name_lock to ensure that a racing gem close
 660          * ioctl doesn't miss to remove this buffer handle from the cache.
 661          */
 662         ret = drm_prime_add_buf_handle(&file_priv->prime,
 663                                        dmabuf, handle);
 664         mutex_unlock(&dev->object_name_lock);
 665         if (ret)
 666                 goto fail_put_dmabuf;
 667
 668 out_have_handle:
 669         ret = dma_buf_fd(dmabuf, flags);
 670         /*
 671          * We must _not_ remove the buffer from the handle cache since the newly
 672          * created dma buf is already linked in the global obj->dma_buf pointer,
 673          * and that is invariant as long as a userspace gem handle exists.
 674          * Closing the handle will clean out the cache anyway, so we don't leak.
 675          */
 676         if (ret < 0) {
 677                 goto fail_put_dmabuf;
 678         } else {
 679                 *prime_fd = ret;
 680                 ret = 0;
 681         }
 682
 683         goto out;
 684
 685 fail_put_dmabuf:
 686         dma_buf_put(dmabuf);
 687 out:
 688         drm_gem_object_put_unlocked(obj);
 689 out_unlock:
 690         mutex_unlock(&file_priv->prime.lock);
 691
 692         return ret;
 693 }
 694 EXPORT_SYMBOL(drm_gem_prime_handle_to_fd);
 695
 696 /**
 697  * drm_gem_prime_import_dev - core implementation of the import callback
 698  * @dev: drm_device to import into
 699  * @dma_buf: dma-buf object to import
 700  * @attach_dev: struct device to dma_buf attach
 701  *
 702  * This is the core of drm_gem_prime_import. It's designed to be called by
 703  * drivers who want to use a different device structure than dev->dev for
 704  * attaching via dma_buf.
 705  */
 706 struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev,
 707                                             struct dma_buf *dma_buf,
 708                                             struct device *attach_dev)
 709 {
 710         struct dma_buf_attachment *attach;
 711         struct sg_table *sgt;
 712         struct drm_gem_object *obj;
 713         int ret;
 714
 715         if (dma_buf->ops == &drm_gem_prime_dmabuf_ops) {
 716                 obj = dma_buf->priv;
 717                 if (obj->dev == dev) {
 718                         /*
 719                          * Importing dmabuf exported from out own gem increases
 720                          * refcount on gem itself instead of f_count of dmabuf.
 721                          */
 722                         drm_gem_object_get(obj);
 723                         return obj;
 724                 }
 725         }
 726
 727         if (!dev->driver->gem_prime_import_sg_table)
 728                 return ERR_PTR(-EINVAL);
 729
 730         attach = dma_buf_attach(dma_buf, attach_dev);
 731         if (IS_ERR(attach))
 732                 return ERR_CAST(attach);
 733
 734         get_dma_buf(dma_buf);
 735
 736         sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
 737         if (IS_ERR(sgt)) {
 738                 ret = PTR_ERR(sgt);
 739                 goto fail_detach;
 740         }
 741
 742         obj = dev->driver->gem_prime_import_sg_table(dev, attach, sgt);
 743         if (IS_ERR(obj)) {
 744                 ret = PTR_ERR(obj);
 745                 goto fail_unmap;
 746         }
 747
 748         obj->import_attach = attach;
 749
 750         return obj;
 751
 752 fail_unmap:
 753         dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
 754 fail_detach:
 755         dma_buf_detach(dma_buf, attach);
 756         dma_buf_put(dma_buf);
 757
 758         return ERR_PTR(ret);
 759 }
 760 EXPORT_SYMBOL(drm_gem_prime_import_dev);
 761
 762 /**
 763  * drm_gem_prime_import - helper library implementation of the import callback
 764  * @dev: drm_device to import into
 765  * @dma_buf: dma-buf object to import
 766  *
 767  * This is the implementation of the gem_prime_import functions for GEM drivers
 768  * using the PRIME helpers.
 769  */
 770 struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
 771                                             struct dma_buf *dma_buf)
 772 {
 773         return drm_gem_prime_import_dev(dev, dma_buf, dev->dev);
 774 }
 775 EXPORT_SYMBOL(drm_gem_prime_import);
 776
 777 /**
 778  * drm_gem_prime_fd_to_handle - PRIME import function for GEM drivers
 779  * @dev: dev to export the buffer from
 780  * @file_priv: drm file-private structure
 781  * @prime_fd: fd id of the dma-buf which should be imported
 782  * @handle: pointer to storage for the handle of the imported buffer object
 783  *
 784  * This is the PRIME import function which must be used mandatorily by GEM
 785  * drivers to ensure correct lifetime management of the underlying GEM object.
 786  * The actual importing of GEM object from the dma-buf is done through the
 787  * gem_import_export driver callback.
 788  */
 789 int drm_gem_prime_fd_to_handle(struct drm_device *dev,
 790                                struct drm_file *file_priv, int prime_fd,
 791                                uint32_t *handle)
 792 {
 793         struct dma_buf *dma_buf;
 794         struct drm_gem_object *obj;
 795         int ret;
 796
 797         dma_buf = dma_buf_get(prime_fd);
 798         if (IS_ERR(dma_buf))
 799                 return PTR_ERR(dma_buf);
 800
 801         mutex_lock(&file_priv->prime.lock);
 802
 803         ret = drm_prime_lookup_buf_handle(&file_priv->prime,
 804                         dma_buf, handle);
 805         if (ret == 0)
 806                 goto out_put;
 807
 808         /* never seen this one, need to import */
 809         mutex_lock(&dev->object_name_lock);
 810         obj = dev->driver->gem_prime_import(dev, dma_buf);
 811         if (IS_ERR(obj)) {
 812                 ret = PTR_ERR(obj);
 813                 goto out_unlock;
 814         }
 815
 816         if (obj->dma_buf) {
 817                 WARN_ON(obj->dma_buf != dma_buf);
 818         } else {
 819                 obj->dma_buf = dma_buf;
 820                 get_dma_buf(dma_buf);
 821         }
 822
 823         /* _handle_create_tail unconditionally unlocks dev->object_name_lock. */
 824         ret = drm_gem_handle_create_tail(file_priv, obj, handle);
 825         drm_gem_object_put_unlocked(obj);
 826         if (ret)
 827                 goto out_put;
 828
 829         ret = drm_prime_add_buf_handle(&file_priv->prime,
 830                         dma_buf, *handle);
 831         mutex_unlock(&file_priv->prime.lock);
 832         if (ret)
 833                 goto fail;
 834
 835         dma_buf_put(dma_buf);
 836
 837         return 0;
 838
 839 fail:
 840         /* hmm, if driver attached, we are relying on the free-object path
 841          * to detach.. which seems ok..
 842          */
 843         drm_gem_handle_delete(file_priv, *handle);
 844         dma_buf_put(dma_buf);
 845         return ret;
 846
 847 out_unlock:
 848         mutex_unlock(&dev->object_name_lock);
 849 out_put:
 850         mutex_unlock(&file_priv->prime.lock);
 851         dma_buf_put(dma_buf);
 852         return ret;
 853 }
 854 EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);
 855
 856 int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
 857                                  struct drm_file *file_priv)
 858 {
 859         struct drm_prime_handle *args = data;
 860
 861         if (!drm_core_check_feature(dev, DRIVER_PRIME))
 862                 return -EINVAL;
 863
 864         if (!dev->driver->prime_handle_to_fd)
 865                 return -ENOSYS;
 866
 867         /* check flags are valid */
 868         if (args->flags & ~(DRM_CLOEXEC | DRM_RDWR))
 869                 return -EINVAL;
 870
 871         return dev->driver->prime_handle_to_fd(dev, file_priv,
 872                         args->handle, args->flags, &args->fd);
 873 }
 874
 875 int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
 876                                  struct drm_file *file_priv)
 877 {
 878         struct drm_prime_handle *args = data;
 879
 880         if (!drm_core_check_feature(dev, DRIVER_PRIME))
 881                 return -EINVAL;
 882
 883         if (!dev->driver->prime_fd_to_handle)
 884                 return -ENOSYS;
 885
 886         return dev->driver->prime_fd_to_handle(dev, file_priv,
 887                         args->fd, &args->handle);
 888 }
 889
 890 /**
 891  * drm_prime_pages_to_sg - converts a page array into an sg list
 892  * @pages: pointer to the array of page pointers to convert
 893  * @nr_pages: length of the page vector
 894  *
 895  * This helper creates an sg table object from a set of pages
 896  * the driver is responsible for mapping the pages into the
 897  * importers address space for use with dma_buf itself.
 898  */
 899 struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages)
 900 {
 901         struct sg_table *sg = NULL;
 902         int ret;
 903
 904         sg = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
 905         if (!sg) {
 906                 ret = -ENOMEM;
 907                 goto out;
 908         }
 909
 910         ret = sg_alloc_table_from_pages(sg, pages, nr_pages, 0,
 911                                 nr_pages << PAGE_SHIFT, GFP_KERNEL);
 912         if (ret)
 913                 goto out;
 914
 915         return sg;
 916 out:
 917         kfree(sg);
 918         return ERR_PTR(ret);
 919 }
 920 EXPORT_SYMBOL(drm_prime_pages_to_sg);
 921
 922 /**
 923  * drm_prime_sg_to_page_addr_arrays - convert an sg table into a page array
 924  * @sgt: scatter-gather table to convert
 925  * @pages: optional array of page pointers to store the page array in
 926  * @addrs: optional array to store the dma bus address of each page
 927  * @max_entries: size of both the passed-in arrays
 928  *
 929  * Exports an sg table into an array of pages and addresses. This is currently
 930  * required by the TTM driver in order to do correct fault handling.
 931  */
 932 int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
 933                                      dma_addr_t *addrs, int max_entries)
 934 {
 935         unsigned count;
 936         struct scatterlist *sg;
 937         struct page *page;
 938         u32 len, index;
 939         dma_addr_t addr;
 940
 941         index = 0;
 942         for_each_sg(sgt->sgl, sg, sgt->nents, count) {
 943                 len = sg->length;
 944                 page = sg_page(sg);
 945                 addr = sg_dma_address(sg);
 946
 947                 while (len > 0) {
 948                         if (WARN_ON(index >= max_entries))
 949                                 return -1;
 950                         if (pages)
 951                                 pages[index] = page;
 952                         if (addrs)
 953                                 addrs[index] = addr;
 954
 955                         page++;
 956                         addr += PAGE_SIZE;
 957                         len -= PAGE_SIZE;
 958                         index++;
 959                 }
 960         }
 961         return 0;
 962 }
 963 EXPORT_SYMBOL(drm_prime_sg_to_page_addr_arrays);
 964
 965 /**
 966  * drm_prime_gem_destroy - helper to clean up a PRIME-imported GEM object
 967  * @obj: GEM object which was created from a dma-buf
 968  * @sg: the sg-table which was pinned at import time
 969  *
 970  * This is the cleanup functions which GEM drivers need to call when they use
 971  * @drm_gem_prime_import to import dma-bufs.
 972  */
 973 void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
 974 {
 975         struct dma_buf_attachment *attach;
 976         struct dma_buf *dma_buf;
 977         attach = obj->import_attach;
 978         if (sg)
 979                 dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
 980         dma_buf = attach->dmabuf;
 981         dma_buf_detach(attach->dmabuf, attach);
 982         /* remove the reference */
 983         dma_buf_put(dma_buf);
 984 }
 985 EXPORT_SYMBOL(drm_prime_gem_destroy);
 986
 987 void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv)
 988 {
 989         mutex_init(&prime_fpriv->lock);
 990         prime_fpriv->dmabufs = RB_ROOT;
 991         prime_fpriv->handles = RB_ROOT;
 992 }
 993
 994 void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv)
 995 {
 996         /* by now drm_gem_release should've made sure the list is empty */
 997         WARN_ON(!RB_EMPTY_ROOT(&prime_fpriv->dmabufs));
 998 }