drivers/gpu/drm/drm_gem_shmem_helper.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2018 Noralf Trønnes
   4  */
   5
   6 #include <linux/dma-buf.h>
   7 #include <linux/export.h>
   8 #include <linux/mutex.h>
   9 #include <linux/shmem_fs.h>
  10 #include <linux/slab.h>
  11 #include <linux/vmalloc.h>
  12
  13 #include <drm/drm.h>
  14 #include <drm/drm_device.h>
  15 #include <drm/drm_drv.h>
  16 #include <drm/drm_gem_shmem_helper.h>
  17 #include <drm/drm_prime.h>
  18 #include <drm/drm_print.h>
  19
  20 /**
  21  * DOC: overview
  22  *
  23  * This library provides helpers for GEM objects backed by shmem buffers
  24  * allocated using anonymous pageable memory.
  25  */
  26
  27 static const struct drm_gem_object_funcs drm_gem_shmem_funcs = {
  28         .free = drm_gem_shmem_free_object,
  29         .print_info = drm_gem_shmem_print_info,
  30         .pin = drm_gem_shmem_pin,
  31         .unpin = drm_gem_shmem_unpin,
  32         .get_sg_table = drm_gem_shmem_get_sg_table,
  33         .vmap = drm_gem_shmem_vmap,
  34         .vunmap = drm_gem_shmem_vunmap,
  35         .mmap = drm_gem_shmem_mmap,
  36 };
  37
  38 static struct drm_gem_shmem_object *
  39 __drm_gem_shmem_create(struct drm_device *dev, size_t size, bool private)
  40 {
  41         struct drm_gem_shmem_object *shmem;
  42         struct drm_gem_object *obj;
  43         int ret = 0;
  44
  45         size = PAGE_ALIGN(size);
  46
  47         if (dev->driver->gem_create_object)
  48                 obj = dev->driver->gem_create_object(dev, size);
  49         else
  50                 obj = kzalloc(sizeof(*shmem), GFP_KERNEL);
  51         if (!obj)
  52                 return ERR_PTR(-ENOMEM);
  53
  54         if (!obj->funcs)
  55                 obj->funcs = &drm_gem_shmem_funcs;
  56
  57         if (private)
  58                 drm_gem_private_object_init(dev, obj, size);
  59         else
  60                 ret = drm_gem_object_init(dev, obj, size);
  61         if (ret)
  62                 goto err_free;
  63
  64         ret = drm_gem_create_mmap_offset(obj);
  65         if (ret)
  66                 goto err_release;
  67
  68         shmem = to_drm_gem_shmem_obj(obj);
  69         mutex_init(&shmem->pages_lock);
  70         mutex_init(&shmem->vmap_lock);
  71         INIT_LIST_HEAD(&shmem->madv_list);
  72
  73         if (!private) {
  74                 /*
  75                  * Our buffers are kept pinned, so allocating them
  76                  * from the MOVABLE zone is a really bad idea, and
  77                  * conflicts with CMA. See comments above new_inode()
  78                  * why this is required _and_ expected if you're
  79                  * going to pin these pages.
  80                  */
  81                 mapping_set_gfp_mask(obj->filp->f_mapping, GFP_HIGHUSER |
  82                                      __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
  83         }
  84
  85         return shmem;
  86
  87 err_release:
  88         drm_gem_object_release(obj);
  89 err_free:
  90         kfree(obj);
  91
  92         return ERR_PTR(ret);
  93 }
  94 /**
  95  * drm_gem_shmem_create - Allocate an object with the given size
  96  * @dev: DRM device
  97  * @size: Size of the object to allocate
  98  *
  99  * This function creates a shmem GEM object.
 100  *
 101  * Returns:
 102  * A struct drm_gem_shmem_object * on success or an ERR_PTR()-encoded negative
 103  * error code on failure.
 104  */
 105 struct drm_gem_shmem_object *drm_gem_shmem_create(struct drm_device *dev, size_t size)
 106 {
 107         return __drm_gem_shmem_create(dev, size, false);
 108 }
 109 EXPORT_SYMBOL_GPL(drm_gem_shmem_create);
 110
 111 /**
 112  * drm_gem_shmem_free_object - Free resources associated with a shmem GEM object
 113  * @obj: GEM object to free
 114  *
 115  * This function cleans up the GEM object state and frees the memory used to
 116  * store the object itself. It should be used to implement
 117  * &drm_gem_object_funcs.free.
 118  */
 119 void drm_gem_shmem_free_object(struct drm_gem_object *obj)
 120 {
 121         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 122
 123         WARN_ON(shmem->vmap_use_count);
 124
 125         if (obj->import_attach) {
 126                 drm_prime_gem_destroy(obj, shmem->sgt);
 127         } else {
 128                 if (shmem->sgt) {
 129                         dma_unmap_sg(obj->dev->dev, shmem->sgt->sgl,
 130                                      shmem->sgt->nents, DMA_BIDIRECTIONAL);
 131                         sg_free_table(shmem->sgt);
 132                         kfree(shmem->sgt);
 133                 }
 134                 if (shmem->pages)
 135                         drm_gem_shmem_put_pages(shmem);
 136         }
 137
 138         WARN_ON(shmem->pages_use_count);
 139
 140         drm_gem_object_release(obj);
 141         mutex_destroy(&shmem->pages_lock);
 142         mutex_destroy(&shmem->vmap_lock);
 143         kfree(shmem);
 144 }
 145 EXPORT_SYMBOL_GPL(drm_gem_shmem_free_object);
 146
 147 static int drm_gem_shmem_get_pages_locked(struct drm_gem_shmem_object *shmem)
 148 {
 149         struct drm_gem_object *obj = &shmem->base;
 150         struct page **pages;
 151
 152         if (shmem->pages_use_count++ > 0)
 153                 return 0;
 154
 155         pages = drm_gem_get_pages(obj);
 156         if (IS_ERR(pages)) {
 157                 DRM_DEBUG_KMS("Failed to get pages (%ld)\n", PTR_ERR(pages));
 158                 shmem->pages_use_count = 0;
 159                 return PTR_ERR(pages);
 160         }
 161
 162         shmem->pages = pages;
 163
 164         return 0;
 165 }
 166
 167 /*
 168  * drm_gem_shmem_get_pages - Allocate backing pages for a shmem GEM object
 169  * @shmem: shmem GEM object
 170  *
 171  * This function makes sure that backing pages exists for the shmem GEM object
 172  * and increases the use count.
 173  *
 174  * Returns:
 175  * 0 on success or a negative error code on failure.
 176  */
 177 int drm_gem_shmem_get_pages(struct drm_gem_shmem_object *shmem)
 178 {
 179         int ret;
 180
 181         WARN_ON(shmem->base.import_attach);
 182
 183         ret = mutex_lock_interruptible(&shmem->pages_lock);
 184         if (ret)
 185                 return ret;
 186         ret = drm_gem_shmem_get_pages_locked(shmem);
 187         mutex_unlock(&shmem->pages_lock);
 188
 189         return ret;
 190 }
 191 EXPORT_SYMBOL(drm_gem_shmem_get_pages);
 192
 193 static void drm_gem_shmem_put_pages_locked(struct drm_gem_shmem_object *shmem)
 194 {
 195         struct drm_gem_object *obj = &shmem->base;
 196
 197         if (WARN_ON_ONCE(!shmem->pages_use_count))
 198                 return;
 199
 200         if (--shmem->pages_use_count > 0)
 201                 return;
 202
 203         drm_gem_put_pages(obj, shmem->pages,
 204                           shmem->pages_mark_dirty_on_put,
 205                           shmem->pages_mark_accessed_on_put);
 206         shmem->pages = NULL;
 207 }
 208
 209 /*
 210  * drm_gem_shmem_put_pages - Decrease use count on the backing pages for a shmem GEM object
 211  * @shmem: shmem GEM object
 212  *
 213  * This function decreases the use count and puts the backing pages when use drops to zero.
 214  */
 215 void drm_gem_shmem_put_pages(struct drm_gem_shmem_object *shmem)
 216 {
 217         mutex_lock(&shmem->pages_lock);
 218         drm_gem_shmem_put_pages_locked(shmem);
 219         mutex_unlock(&shmem->pages_lock);
 220 }
 221 EXPORT_SYMBOL(drm_gem_shmem_put_pages);
 222
 223 /**
 224  * drm_gem_shmem_pin - Pin backing pages for a shmem GEM object
 225  * @obj: GEM object
 226  *
 227  * This function makes sure the backing pages are pinned in memory while the
 228  * buffer is exported. It should only be used to implement
 229  * &drm_gem_object_funcs.pin.
 230  *
 231  * Returns:
 232  * 0 on success or a negative error code on failure.
 233  */
 234 int drm_gem_shmem_pin(struct drm_gem_object *obj)
 235 {
 236         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 237
 238         WARN_ON(shmem->base.import_attach);
 239
 240         return drm_gem_shmem_get_pages(shmem);
 241 }
 242 EXPORT_SYMBOL(drm_gem_shmem_pin);
 243
 244 /**
 245  * drm_gem_shmem_unpin - Unpin backing pages for a shmem GEM object
 246  * @obj: GEM object
 247  *
 248  * This function removes the requirement that the backing pages are pinned in
 249  * memory. It should only be used to implement &drm_gem_object_funcs.unpin.
 250  */
 251 void drm_gem_shmem_unpin(struct drm_gem_object *obj)
 252 {
 253         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 254
 255         WARN_ON(shmem->base.import_attach);
 256
 257         drm_gem_shmem_put_pages(shmem);
 258 }
 259 EXPORT_SYMBOL(drm_gem_shmem_unpin);
 260
 261 static void *drm_gem_shmem_vmap_locked(struct drm_gem_shmem_object *shmem)
 262 {
 263         struct drm_gem_object *obj = &shmem->base;
 264         struct dma_buf_map map;
 265         int ret = 0;
 266
 267         if (shmem->vmap_use_count++ > 0)
 268                 return shmem->vaddr;
 269
 270         if (obj->import_attach) {
 271                 ret = dma_buf_vmap(obj->import_attach->dmabuf, &map);
 272                 if (!ret)
 273                         shmem->vaddr = map.vaddr;
 274         } else {
 275                 pgprot_t prot = PAGE_KERNEL;
 276
 277                 ret = drm_gem_shmem_get_pages(shmem);
 278                 if (ret)
 279                         goto err_zero_use;
 280
 281                 if (!shmem->map_cached)
 282                         prot = pgprot_writecombine(prot);
 283                 shmem->vaddr = vmap(shmem->pages, obj->size >> PAGE_SHIFT,
 284                                     VM_MAP, prot);
 285                 if (!shmem->vaddr)
 286                         ret = -ENOMEM;
 287         }
 288
 289         if (ret) {
 290                 DRM_DEBUG_KMS("Failed to vmap pages, error %d\n", ret);
 291                 goto err_put_pages;
 292         }
 293
 294         return shmem->vaddr;
 295
 296 err_put_pages:
 297         if (!obj->import_attach)
 298                 drm_gem_shmem_put_pages(shmem);
 299 err_zero_use:
 300         shmem->vmap_use_count = 0;
 301
 302         return ERR_PTR(ret);
 303 }
 304
 305 /*
 306  * drm_gem_shmem_vmap - Create a virtual mapping for a shmem GEM object
 307  * @shmem: shmem GEM object
 308  *
 309  * This function makes sure that a contiguous kernel virtual address mapping
 310  * exists for the buffer backing the shmem GEM object.
 311  *
 312  * This function can be used to implement &drm_gem_object_funcs.vmap. But it can
 313  * also be called by drivers directly, in which case it will hide the
 314  * differences between dma-buf imported and natively allocated objects.
 315  *
 316  * Acquired mappings should be cleaned up by calling drm_gem_shmem_vunmap().
 317  *
 318  * Returns:
 319  * 0 on success or a negative error code on failure.
 320  */
 321 void *drm_gem_shmem_vmap(struct drm_gem_object *obj)
 322 {
 323         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 324         void *vaddr;
 325         int ret;
 326
 327         ret = mutex_lock_interruptible(&shmem->vmap_lock);
 328         if (ret)
 329                 return ERR_PTR(ret);
 330         vaddr = drm_gem_shmem_vmap_locked(shmem);
 331         mutex_unlock(&shmem->vmap_lock);
 332
 333         return vaddr;
 334 }
 335 EXPORT_SYMBOL(drm_gem_shmem_vmap);
 336
 337 static void drm_gem_shmem_vunmap_locked(struct drm_gem_shmem_object *shmem)
 338 {
 339         struct drm_gem_object *obj = &shmem->base;
 340         struct dma_buf_map map = DMA_BUF_MAP_INIT_VADDR(shmem->vaddr);
 341
 342         if (WARN_ON_ONCE(!shmem->vmap_use_count))
 343                 return;
 344
 345         if (--shmem->vmap_use_count > 0)
 346                 return;
 347
 348         if (obj->import_attach)
 349                 dma_buf_vunmap(obj->import_attach->dmabuf, &map);
 350         else
 351                 vunmap(shmem->vaddr);
 352
 353         shmem->vaddr = NULL;
 354         drm_gem_shmem_put_pages(shmem);
 355 }
 356
 357 /*
 358  * drm_gem_shmem_vunmap - Unmap a virtual mapping fo a shmem GEM object
 359  * @shmem: shmem GEM object
 360  *
 361  * This function cleans up a kernel virtual address mapping acquired by
 362  * drm_gem_shmem_vmap(). The mapping is only removed when the use count drops to
 363  * zero.
 364  *
 365  * This function can be used to implement &drm_gem_object_funcs.vmap. But it can
 366  * also be called by drivers directly, in which case it will hide the
 367  * differences between dma-buf imported and natively allocated objects.
 368  */
 369 void drm_gem_shmem_vunmap(struct drm_gem_object *obj, void *vaddr)
 370 {
 371         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 372
 373         mutex_lock(&shmem->vmap_lock);
 374         drm_gem_shmem_vunmap_locked(shmem);
 375         mutex_unlock(&shmem->vmap_lock);
 376 }
 377 EXPORT_SYMBOL(drm_gem_shmem_vunmap);
 378
 379 struct drm_gem_shmem_object *
 380 drm_gem_shmem_create_with_handle(struct drm_file *file_priv,
 381                                  struct drm_device *dev, size_t size,
 382                                  uint32_t *handle)
 383 {
 384         struct drm_gem_shmem_object *shmem;
 385         int ret;
 386
 387         shmem = drm_gem_shmem_create(dev, size);
 388         if (IS_ERR(shmem))
 389                 return shmem;
 390
 391         /*
 392          * Allocate an id of idr table where the obj is registered
 393          * and handle has the id what user can see.
 394          */
 395         ret = drm_gem_handle_create(file_priv, &shmem->base, handle);
 396         /* drop reference from allocate - handle holds it now. */
 397         drm_gem_object_put(&shmem->base);
 398         if (ret)
 399                 return ERR_PTR(ret);
 400
 401         return shmem;
 402 }
 403 EXPORT_SYMBOL(drm_gem_shmem_create_with_handle);
 404
 405 /* Update madvise status, returns true if not purged, else
 406  * false or -errno.
 407  */
 408 int drm_gem_shmem_madvise(struct drm_gem_object *obj, int madv)
 409 {
 410         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 411
 412         mutex_lock(&shmem->pages_lock);
 413
 414         if (shmem->madv >= 0)
 415                 shmem->madv = madv;
 416
 417         madv = shmem->madv;
 418
 419         mutex_unlock(&shmem->pages_lock);
 420
 421         return (madv >= 0);
 422 }
 423 EXPORT_SYMBOL(drm_gem_shmem_madvise);
 424
 425 void drm_gem_shmem_purge_locked(struct drm_gem_object *obj)
 426 {
 427         struct drm_device *dev = obj->dev;
 428         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 429
 430         WARN_ON(!drm_gem_shmem_is_purgeable(shmem));
 431
 432         dma_unmap_sg(obj->dev->dev, shmem->sgt->sgl,
 433                      shmem->sgt->nents, DMA_BIDIRECTIONAL);
 434         sg_free_table(shmem->sgt);
 435         kfree(shmem->sgt);
 436         shmem->sgt = NULL;
 437
 438         drm_gem_shmem_put_pages_locked(shmem);
 439
 440         shmem->madv = -1;
 441
 442         drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping);
 443         drm_gem_free_mmap_offset(obj);
 444
 445         /* Our goal here is to return as much of the memory as
 446          * is possible back to the system as we are called from OOM.
 447          * To do this we must instruct the shmfs to drop all of its
 448          * backing pages, *now*.
 449          */
 450         shmem_truncate_range(file_inode(obj->filp), 0, (loff_t)-1);
 451
 452         invalidate_mapping_pages(file_inode(obj->filp)->i_mapping,
 453                         0, (loff_t)-1);
 454 }
 455 EXPORT_SYMBOL(drm_gem_shmem_purge_locked);
 456
 457 bool drm_gem_shmem_purge(struct drm_gem_object *obj)
 458 {
 459         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 460
 461         if (!mutex_trylock(&shmem->pages_lock))
 462                 return false;
 463         drm_gem_shmem_purge_locked(obj);
 464         mutex_unlock(&shmem->pages_lock);
 465
 466         return true;
 467 }
 468 EXPORT_SYMBOL(drm_gem_shmem_purge);
 469
 470 /**
 471  * drm_gem_shmem_create_object_cached - Create a shmem buffer object with
 472  *                                      cached mappings
 473  * @dev: DRM device
 474  * @size: Size of the object to allocate
 475  *
 476  * By default, shmem buffer objects use writecombine mappings. This
 477  * function implements struct drm_driver.gem_create_object for shmem
 478  * buffer objects with cached mappings.
 479  *
 480  * Returns:
 481  * A struct drm_gem_shmem_object * on success or NULL negative on failure.
 482  */
 483 struct drm_gem_object *
 484 drm_gem_shmem_create_object_cached(struct drm_device *dev, size_t size)
 485 {
 486         struct drm_gem_shmem_object *shmem;
 487
 488         shmem = kzalloc(sizeof(*shmem), GFP_KERNEL);
 489         if (!shmem)
 490                 return NULL;
 491         shmem->map_cached = true;
 492
 493         return &shmem->base;
 494 }
 495 EXPORT_SYMBOL(drm_gem_shmem_create_object_cached);
 496
 497 /**
 498  * drm_gem_shmem_dumb_create - Create a dumb shmem buffer object
 499  * @file: DRM file structure to create the dumb buffer for
 500  * @dev: DRM device
 501  * @args: IOCTL data
 502  *
 503  * This function computes the pitch of the dumb buffer and rounds it up to an
 504  * integer number of bytes per pixel. Drivers for hardware that doesn't have
 505  * any additional restrictions on the pitch can directly use this function as
 506  * their &drm_driver.dumb_create callback.
 507  *
 508  * For hardware with additional restrictions, drivers can adjust the fields
 509  * set up by userspace before calling into this function.
 510  *
 511  * Returns:
 512  * 0 on success or a negative error code on failure.
 513  */
 514 int drm_gem_shmem_dumb_create(struct drm_file *file, struct drm_device *dev,
 515                               struct drm_mode_create_dumb *args)
 516 {
 517         u32 min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
 518         struct drm_gem_shmem_object *shmem;
 519
 520         if (!args->pitch || !args->size) {
 521                 args->pitch = min_pitch;
 522                 args->size = args->pitch * args->height;
 523         } else {
 524                 /* ensure sane minimum values */
 525                 if (args->pitch < min_pitch)
 526                         args->pitch = min_pitch;
 527                 if (args->size < args->pitch * args->height)
 528                         args->size = args->pitch * args->height;
 529         }
 530
 531         shmem = drm_gem_shmem_create_with_handle(file, dev, args->size, &args->handle);
 532
 533         return PTR_ERR_OR_ZERO(shmem);
 534 }
 535 EXPORT_SYMBOL_GPL(drm_gem_shmem_dumb_create);
 536
 537 static vm_fault_t drm_gem_shmem_fault(struct vm_fault *vmf)
 538 {
 539         struct vm_area_struct *vma = vmf->vma;
 540         struct drm_gem_object *obj = vma->vm_private_data;
 541         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 542         loff_t num_pages = obj->size >> PAGE_SHIFT;
 543         struct page *page;
 544
 545         if (vmf->pgoff >= num_pages || WARN_ON_ONCE(!shmem->pages))
 546                 return VM_FAULT_SIGBUS;
 547
 548         page = shmem->pages[vmf->pgoff];
 549
 550         return vmf_insert_page(vma, vmf->address, page);
 551 }
 552
 553 static void drm_gem_shmem_vm_open(struct vm_area_struct *vma)
 554 {
 555         struct drm_gem_object *obj = vma->vm_private_data;
 556         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 557         int ret;
 558
 559         WARN_ON(shmem->base.import_attach);
 560
 561         ret = drm_gem_shmem_get_pages(shmem);
 562         WARN_ON_ONCE(ret != 0);
 563
 564         drm_gem_vm_open(vma);
 565 }
 566
 567 static void drm_gem_shmem_vm_close(struct vm_area_struct *vma)
 568 {
 569         struct drm_gem_object *obj = vma->vm_private_data;
 570         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 571
 572         drm_gem_shmem_put_pages(shmem);
 573         drm_gem_vm_close(vma);
 574 }
 575
 576 static const struct vm_operations_struct drm_gem_shmem_vm_ops = {
 577         .fault = drm_gem_shmem_fault,
 578         .open = drm_gem_shmem_vm_open,
 579         .close = drm_gem_shmem_vm_close,
 580 };
 581
 582 /**
 583  * drm_gem_shmem_mmap - Memory-map a shmem GEM object
 584  * @obj: gem object
 585  * @vma: VMA for the area to be mapped
 586  *
 587  * This function implements an augmented version of the GEM DRM file mmap
 588  * operation for shmem objects. Drivers which employ the shmem helpers should
 589  * use this function as their &drm_gem_object_funcs.mmap handler.
 590  *
 591  * Returns:
 592  * 0 on success or a negative error code on failure.
 593  */
 594 int drm_gem_shmem_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
 595 {
 596         struct drm_gem_shmem_object *shmem;
 597         int ret;
 598
 599         /* Remove the fake offset */
 600         vma->vm_pgoff -= drm_vma_node_start(&obj->vma_node);
 601
 602         if (obj->import_attach)
 603                 return dma_buf_mmap(obj->dma_buf, vma, 0);
 604
 605         shmem = to_drm_gem_shmem_obj(obj);
 606
 607         ret = drm_gem_shmem_get_pages(shmem);
 608         if (ret) {
 609                 drm_gem_vm_close(vma);
 610                 return ret;
 611         }
 612
 613         vma->vm_flags |= VM_MIXEDMAP | VM_DONTEXPAND;
 614         vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
 615         if (!shmem->map_cached)
 616                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 617         vma->vm_ops = &drm_gem_shmem_vm_ops;
 618
 619         return 0;
 620 }
 621 EXPORT_SYMBOL_GPL(drm_gem_shmem_mmap);
 622
 623 /**
 624  * drm_gem_shmem_print_info() - Print &drm_gem_shmem_object info for debugfs
 625  * @p: DRM printer
 626  * @indent: Tab indentation level
 627  * @obj: GEM object
 628  *
 629  * This implements the &drm_gem_object_funcs.info callback.
 630  */
 631 void drm_gem_shmem_print_info(struct drm_printer *p, unsigned int indent,
 632                               const struct drm_gem_object *obj)
 633 {
 634         const struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 635
 636         drm_printf_indent(p, indent, "pages_use_count=%u\n", shmem->pages_use_count);
 637         drm_printf_indent(p, indent, "vmap_use_count=%u\n", shmem->vmap_use_count);
 638         drm_printf_indent(p, indent, "vaddr=%p\n", shmem->vaddr);
 639 }
 640 EXPORT_SYMBOL(drm_gem_shmem_print_info);
 641
 642 /**
 643  * drm_gem_shmem_get_sg_table - Provide a scatter/gather table of pinned
 644  *                              pages for a shmem GEM object
 645  * @obj: GEM object
 646  *
 647  * This function exports a scatter/gather table suitable for PRIME usage by
 648  * calling the standard DMA mapping API. Drivers should not call this function
 649  * directly, instead it should only be used as an implementation for
 650  * &drm_gem_object_funcs.get_sg_table.
 651  *
 652  * Drivers who need to acquire an scatter/gather table for objects need to call
 653  * drm_gem_shmem_get_pages_sgt() instead.
 654  *
 655  * Returns:
 656  * A pointer to the scatter/gather table of pinned pages or NULL on failure.
 657  */
 658 struct sg_table *drm_gem_shmem_get_sg_table(struct drm_gem_object *obj)
 659 {
 660         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 661
 662         WARN_ON(shmem->base.import_attach);
 663
 664         return drm_prime_pages_to_sg(obj->dev, shmem->pages, obj->size >> PAGE_SHIFT);
 665 }
 666 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_sg_table);
 667
 668 /**
 669  * drm_gem_shmem_get_pages_sgt - Pin pages, dma map them, and return a
 670  *                               scatter/gather table for a shmem GEM object.
 671  * @obj: GEM object
 672  *
 673  * This function returns a scatter/gather table suitable for driver usage. If
 674  * the sg table doesn't exist, the pages are pinned, dma-mapped, and a sg
 675  * table created.
 676  *
 677  * This is the main function for drivers to get at backing storage, and it hides
 678  * and difference between dma-buf imported and natively allocated objects.
 679  * drm_gem_shmem_get_sg_table() should not be directly called by drivers.
 680  *
 681  * Returns:
 682  * A pointer to the scatter/gather table of pinned pages or errno on failure.
 683  */
 684 struct sg_table *drm_gem_shmem_get_pages_sgt(struct drm_gem_object *obj)
 685 {
 686         int ret;
 687         struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 688         struct sg_table *sgt;
 689
 690         if (shmem->sgt)
 691                 return shmem->sgt;
 692
 693         WARN_ON(obj->import_attach);
 694
 695         ret = drm_gem_shmem_get_pages(shmem);
 696         if (ret)
 697                 return ERR_PTR(ret);
 698
 699         sgt = drm_gem_shmem_get_sg_table(&shmem->base);
 700         if (IS_ERR(sgt)) {
 701                 ret = PTR_ERR(sgt);
 702                 goto err_put_pages;
 703         }
 704         /* Map the pages for use by the h/w. */
 705         dma_map_sg(obj->dev->dev, sgt->sgl, sgt->nents, DMA_BIDIRECTIONAL);
 706
 707         shmem->sgt = sgt;
 708
 709         return sgt;
 710
 711 err_put_pages:
 712         drm_gem_shmem_put_pages(shmem);
 713         return ERR_PTR(ret);
 714 }
 715 EXPORT_SYMBOL_GPL(drm_gem_shmem_get_pages_sgt);
 716
 717 /**
 718  * drm_gem_shmem_prime_import_sg_table - Produce a shmem GEM object from
 719  *                 another driver's scatter/gather table of pinned pages
 720  * @dev: Device to import into
 721  * @attach: DMA-BUF attachment
 722  * @sgt: Scatter/gather table of pinned pages
 723  *
 724  * This function imports a scatter/gather table exported via DMA-BUF by
 725  * another driver. Drivers that use the shmem helpers should set this as their
 726  * &drm_driver.gem_prime_import_sg_table callback.
 727  *
 728  * Returns:
 729  * A pointer to a newly created GEM object or an ERR_PTR-encoded negative
 730  * error code on failure.
 731  */
 732 struct drm_gem_object *
 733 drm_gem_shmem_prime_import_sg_table(struct drm_device *dev,
 734                                     struct dma_buf_attachment *attach,
 735                                     struct sg_table *sgt)
 736 {
 737         size_t size = PAGE_ALIGN(attach->dmabuf->size);
 738         struct drm_gem_shmem_object *shmem;
 739
 740         shmem = __drm_gem_shmem_create(dev, size, true);
 741         if (IS_ERR(shmem))
 742                 return ERR_CAST(shmem);
 743
 744         shmem->sgt = sgt;
 745
 746         DRM_DEBUG_PRIME("size = %zu\n", size);
 747
 748         return &shmem->base;
 749 }
 750 EXPORT_SYMBOL_GPL(drm_gem_shmem_prime_import_sg_table);