drivers/video/tegra/nvmap/nvmap_handle.c

   1 /*
   2  * drivers/video/tegra/nvmap/nvmap_handle.c
   3  *
   4  * Handle allocation and freeing routines for nvmap
   5  *
   6  * Copyright (c) 2009-2014, NVIDIA CORPORATION. All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  */
  22
  23 #define pr_fmt(fmt)     "%s: " fmt, __func__
  24
  25 #include <linux/err.h>
  26 #include <linux/io.h>
  27 #include <linux/kernel.h>
  28 #include <linux/list.h>
  29 #include <linux/mm.h>
  30 #include <linux/rbtree.h>
  31 #include <linux/dma-buf.h>
  32 #include <linux/moduleparam.h>
  33 #include <linux/nvmap.h>
  34 #include <linux/tegra-soc.h>
  35
  36 #include <asm/pgtable.h>
  37
  38 #include <trace/events/nvmap.h>
  39
  40 #include "nvmap_priv.h"
  41 #include "nvmap_ioctl.h"
  42
  43 bool zero_memory;
  44
  45 static int zero_memory_set(const char *arg, const struct kernel_param *kp)
  46 {
  47         param_set_bool(arg, kp);
  48         nvmap_page_pool_clear();
  49         return 0;
  50 }
  51
  52 static struct kernel_param_ops zero_memory_ops = {
  53         .get = param_get_bool,
  54         .set = zero_memory_set,
  55 };
  56
  57 module_param_cb(zero_memory, &zero_memory_ops, &zero_memory, 0644);
  58
  59 u32 nvmap_max_handle_count;
  60
  61 /* handles may be arbitrarily large (16+MiB), and any handle allocated from
  62  * the kernel (i.e., not a carveout handle) includes its array of pages. to
  63  * preserve kmalloc space, if the array of pages exceeds PAGELIST_VMALLOC_MIN,
  64  * the array is allocated using vmalloc. */
  65 #define PAGELIST_VMALLOC_MIN    (PAGE_SIZE)
  66
  67 void *nvmap_altalloc(size_t len)
  68 {
  69         if (len > PAGELIST_VMALLOC_MIN)
  70                 return vmalloc(len);
  71         else
  72                 return kmalloc(len, GFP_KERNEL);
  73 }
  74
  75 void nvmap_altfree(void *ptr, size_t len)
  76 {
  77         if (!ptr)
  78                 return;
  79
  80         if (len > PAGELIST_VMALLOC_MIN)
  81                 vfree(ptr);
  82         else
  83                 kfree(ptr);
  84 }
  85
  86 void _nvmap_handle_free(struct nvmap_handle *h)
  87 {
  88         unsigned int i, nr_page, page_index = 0;
  89 #if defined(CONFIG_NVMAP_PAGE_POOLS) && \
  90         !defined(CONFIG_NVMAP_FORCE_ZEROED_USER_PAGES)
  91         struct nvmap_page_pool *pool;
  92 #endif
  93
  94         if (h->nvhost_priv)
  95                 h->nvhost_priv_delete(h->nvhost_priv);
  96
  97         if (nvmap_handle_remove(nvmap_dev, h) != 0)
  98                 return;
  99
 100         if (!h->alloc)
 101                 goto out;
 102
 103         nvmap_stats_inc(NS_RELEASE, h->size);
 104         nvmap_stats_dec(NS_TOTAL, PAGE_ALIGN(h->orig_size));
 105         if (!h->heap_pgalloc) {
 106                 nvmap_heap_free(h->carveout);
 107                 goto out;
 108         }
 109
 110         nr_page = DIV_ROUND_UP(h->size, PAGE_SIZE);
 111
 112         BUG_ON(h->size & ~PAGE_MASK);
 113         BUG_ON(!h->pgalloc.pages);
 114
 115 #ifdef NVMAP_LAZY_VFREE
 116         if (h->vaddr)
 117                 vm_unmap_ram(h->vaddr, h->size >> PAGE_SHIFT);
 118 #endif
 119
 120         for (i = 0; i < nr_page; i++)
 121                 h->pgalloc.pages[i] = nvmap_to_page(h->pgalloc.pages[i]);
 122
 123 #if defined(CONFIG_NVMAP_PAGE_POOLS) && \
 124         !defined(CONFIG_NVMAP_FORCE_ZEROED_USER_PAGES)
 125         if (!zero_memory) {
 126                 pool = &nvmap_dev->pool;
 127
 128                 nvmap_page_pool_lock(pool);
 129                 page_index = __nvmap_page_pool_fill_lots_locked(pool,
 130                                                 h->pgalloc.pages, nr_page);
 131                 nvmap_page_pool_unlock(pool);
 132         }
 133 #endif
 134
 135         for (i = page_index; i < nr_page; i++)
 136                 __free_page(h->pgalloc.pages[i]);
 137
 138         nvmap_altfree(h->pgalloc.pages, nr_page * sizeof(struct page *));
 139
 140 out:
 141         kfree(h);
 142 }
 143
 144 static struct page *nvmap_alloc_pages_exact(gfp_t gfp, size_t size)
 145 {
 146         struct page *page, *p, *e;
 147         unsigned int order;
 148
 149         size = PAGE_ALIGN(size);
 150         order = get_order(size);
 151         page = alloc_pages(gfp, order);
 152
 153         if (!page)
 154                 return NULL;
 155
 156         split_page(page, order);
 157         e = page + (1 << order);
 158         for (p = page + (size >> PAGE_SHIFT); p < e; p++)
 159                 __free_page(p);
 160
 161         return page;
 162 }
 163
 164 static int handle_page_alloc(struct nvmap_client *client,
 165                              struct nvmap_handle *h, bool contiguous)
 166 {
 167         size_t size = PAGE_ALIGN(h->size);
 168         unsigned int nr_page = size >> PAGE_SHIFT;
 169         pgprot_t prot;
 170         unsigned int i = 0, page_index = 0;
 171         struct page **pages;
 172 #ifdef CONFIG_NVMAP_PAGE_POOLS
 173         struct nvmap_page_pool *pool = NULL;
 174 #endif
 175         gfp_t gfp = GFP_NVMAP;
 176
 177         if (zero_memory)
 178                 gfp |= __GFP_ZERO;
 179
 180         pages = nvmap_altalloc(nr_page * sizeof(*pages));
 181         if (!pages)
 182                 return -ENOMEM;
 183
 184         prot = nvmap_pgprot(h, PG_PROT_KERNEL);
 185
 186         if (contiguous) {
 187                 struct page *page;
 188                 page = nvmap_alloc_pages_exact(gfp, size);
 189                 if (!page)
 190                         goto fail;
 191
 192                 for (i = 0; i < nr_page; i++)
 193                         pages[i] = nth_page(page, i);
 194
 195         } else {
 196 #ifdef CONFIG_NVMAP_PAGE_POOLS
 197                 pool = &nvmap_dev->pool;
 198
 199                 /*
 200                  * Get as many pages from the pools as possible.
 201                  */
 202                 nvmap_page_pool_lock(pool);
 203                 page_index = __nvmap_page_pool_alloc_lots_locked(pool, pages,
 204                                                                  nr_page);
 205                 nvmap_page_pool_unlock(pool);
 206 #endif
 207                 for (i = page_index; i < nr_page; i++) {
 208                         pages[i] = nvmap_alloc_pages_exact(gfp, PAGE_SIZE);
 209                         if (!pages[i])
 210                                 goto fail;
 211                 }
 212         }
 213
 214         /*
 215          * Make sure any data in the caches is cleaned out before
 216          * passing these pages to userspace. otherwise, It can lead to
 217          * corruption in pages that get mapped as something other than WB in
 218          * userspace and leaked kernel data structures.
 219          *
 220          * FIXME: For ARMv7 we don't have __clean_dcache_page() so we continue
 221          * to use the flush cache version.
 222          */
 223 #ifdef ARM64
 224         nvmap_clean_cache(pages, nr_page);
 225 #else
 226         nvmap_flush_cache(pages, nr_page);
 227 #endif
 228
 229         h->size = size;
 230         h->pgalloc.pages = pages;
 231         h->pgalloc.contig = contiguous;
 232         atomic_set(&h->pgalloc.ndirty, 0);
 233         return 0;
 234
 235 fail:
 236         while (i--)
 237                 __free_page(pages[i]);
 238         nvmap_altfree(pages, nr_page * sizeof(*pages));
 239         wmb();
 240         return -ENOMEM;
 241 }
 242
 243 static void alloc_handle(struct nvmap_client *client,
 244                          struct nvmap_handle *h, unsigned int type)
 245 {
 246         unsigned int carveout_mask = NVMAP_HEAP_CARVEOUT_MASK;
 247         unsigned int iovmm_mask = NVMAP_HEAP_IOVMM;
 248
 249         BUG_ON(type & (type - 1));
 250
 251 #ifdef CONFIG_NVMAP_CONVERT_CARVEOUT_TO_IOVMM
 252         /* Convert generic carveout requests to iovmm requests. */
 253         carveout_mask &= ~NVMAP_HEAP_CARVEOUT_GENERIC;
 254         iovmm_mask |= NVMAP_HEAP_CARVEOUT_GENERIC;
 255 #endif
 256
 257         if (type & carveout_mask) {
 258                 struct nvmap_heap_block *b;
 259
 260                 b = nvmap_carveout_alloc(client, h, type);
 261                 if (b) {
 262                         h->heap_type = type;
 263                         h->heap_pgalloc = false;
 264                         /* barrier to ensure all handle alloc data
 265                          * is visible before alloc is seen by other
 266                          * processors.
 267                          */
 268                         mb();
 269                         h->alloc = true;
 270                 }
 271         } else if (type & iovmm_mask) {
 272                 int ret;
 273
 274                 ret = handle_page_alloc(client, h,
 275                         h->userflags & NVMAP_HANDLE_PHYS_CONTIG);
 276                 if (ret)
 277                         return;
 278                 h->heap_type = NVMAP_HEAP_IOVMM;
 279                 h->heap_pgalloc = true;
 280                 mb();
 281                 h->alloc = true;
 282         }
 283 }
 284
 285 /* small allocations will try to allocate from generic OS memory before
 286  * any of the limited heaps, to increase the effective memory for graphics
 287  * allocations, and to reduce fragmentation of the graphics heaps with
 288  * sub-page splinters */
 289 static const unsigned int heap_policy_small[] = {
 290         NVMAP_HEAP_CARVEOUT_VPR,
 291         NVMAP_HEAP_CARVEOUT_IRAM,
 292         NVMAP_HEAP_CARVEOUT_MASK,
 293         NVMAP_HEAP_IOVMM,
 294         0,
 295 };
 296
 297 static const unsigned int heap_policy_large[] = {
 298         NVMAP_HEAP_CARVEOUT_VPR,
 299         NVMAP_HEAP_CARVEOUT_IRAM,
 300         NVMAP_HEAP_IOVMM,
 301         NVMAP_HEAP_CARVEOUT_MASK,
 302         0,
 303 };
 304
 305 int nvmap_alloc_handle(struct nvmap_client *client,
 306                        struct nvmap_handle *h, unsigned int heap_mask,
 307                        size_t align,
 308                        u8 kind,
 309                        unsigned int flags)
 310 {
 311         const unsigned int *alloc_policy;
 312         int nr_page;
 313         int err = -ENOMEM;
 314
 315         h = nvmap_handle_get(h);
 316
 317         if (!h)
 318                 return -EINVAL;
 319
 320         if (h->alloc) {
 321                 nvmap_handle_put(h);
 322                 return -EEXIST;
 323         }
 324
 325         nvmap_stats_inc(NS_TOTAL, PAGE_ALIGN(h->orig_size));
 326         nvmap_stats_inc(NS_ALLOC, PAGE_ALIGN(h->size));
 327         trace_nvmap_alloc_handle(client, h,
 328                 h->size, heap_mask, align, flags,
 329                 nvmap_stats_read(NS_TOTAL),
 330                 nvmap_stats_read(NS_ALLOC));
 331         h->userflags = flags;
 332         nr_page = ((h->size + PAGE_SIZE - 1) >> PAGE_SHIFT);
 333         h->flags = (flags & NVMAP_HANDLE_CACHE_FLAG);
 334         h->align = max_t(size_t, align, L1_CACHE_BYTES);
 335         h->kind = kind;
 336
 337         /* convert iovmm requests to generic carveout. */
 338         if (heap_mask & NVMAP_HEAP_IOVMM) {
 339                 heap_mask = (heap_mask & ~NVMAP_HEAP_IOVMM) |
 340                             NVMAP_HEAP_CARVEOUT_GENERIC;
 341         }
 342
 343         if (!heap_mask) {
 344                 err = -EINVAL;
 345                 goto out;
 346         }
 347
 348         alloc_policy = (nr_page == 1) ? heap_policy_small : heap_policy_large;
 349
 350         while (!h->alloc && *alloc_policy) {
 351                 unsigned int heap_type;
 352
 353                 heap_type = *alloc_policy++;
 354                 heap_type &= heap_mask;
 355
 356                 if (!heap_type)
 357                         continue;
 358
 359                 heap_mask &= ~heap_type;
 360
 361                 while (heap_type && !h->alloc) {
 362                         unsigned int heap;
 363
 364                         /* iterate possible heaps MSB-to-LSB, since higher-
 365                          * priority carveouts will have higher usage masks */
 366                         heap = 1 << __fls(heap_type);
 367                         alloc_handle(client, h, heap);
 368                         heap_type &= ~heap;
 369                 }
 370         }
 371
 372 out:
 373         if (h->alloc) {
 374                 if (client->kernel_client)
 375                         nvmap_stats_inc(NS_KALLOC, h->size);
 376                 else
 377                         nvmap_stats_inc(NS_UALLOC, h->size);
 378         } else {
 379                 nvmap_stats_dec(NS_TOTAL, PAGE_ALIGN(h->orig_size));
 380                 nvmap_stats_dec(NS_ALLOC, PAGE_ALIGN(h->orig_size));
 381         }
 382
 383         err = (h->alloc) ? 0 : err;
 384         nvmap_handle_put(h);
 385         return err;
 386 }
 387
 388 void nvmap_free_handle(struct nvmap_client *client,
 389                        struct nvmap_handle *handle)
 390 {
 391         struct nvmap_handle_ref *ref;
 392         struct nvmap_handle *h;
 393         int pins;
 394
 395         nvmap_ref_lock(client);
 396
 397         ref = __nvmap_validate_locked(client, handle);
 398         if (!ref) {
 399                 nvmap_ref_unlock(client);
 400                 return;
 401         }
 402
 403         trace_nvmap_free_handle(client, handle);
 404         BUG_ON(!ref->handle);
 405         h = ref->handle;
 406
 407         if (atomic_dec_return(&ref->dupes)) {
 408                 nvmap_ref_unlock(client);
 409                 goto out;
 410         }
 411
 412         smp_rmb();
 413         pins = atomic_read(&ref->pin);
 414         rb_erase(&ref->node, &client->handle_refs);
 415         client->handle_count--;
 416         atomic_dec(&ref->handle->share_count);
 417
 418         if (h->alloc && !h->heap_pgalloc) {
 419                 mutex_lock(&h->lock);
 420                 nvmap_carveout_commit_subtract(client,
 421                         nvmap_heap_to_arg(nvmap_block_to_heap(h->carveout)),
 422                         h->size);
 423                 mutex_unlock(&h->lock);
 424         }
 425
 426         nvmap_ref_unlock(client);
 427
 428         if (pins)
 429                 pr_debug("%s freeing pinned handle %p\n",
 430                             current->group_leader->comm, h);
 431
 432         while (atomic_read(&ref->pin))
 433                 __nvmap_unpin(ref);
 434
 435         if (h->owner == client)
 436                 h->owner = NULL;
 437
 438         dma_buf_put(ref->handle->dmabuf);
 439         kfree(ref);
 440
 441 out:
 442         BUG_ON(!atomic_read(&h->ref));
 443         nvmap_handle_put(h);
 444 }
 445 EXPORT_SYMBOL(nvmap_free_handle);
 446
 447 void nvmap_free_handle_user_id(struct nvmap_client *client,
 448                                unsigned long user_id)
 449 {
 450         nvmap_free_handle(client, unmarshal_user_id(user_id));
 451 }
 452
 453 static void add_handle_ref(struct nvmap_client *client,
 454                            struct nvmap_handle_ref *ref)
 455 {
 456         struct rb_node **p, *parent = NULL;
 457
 458         nvmap_ref_lock(client);
 459         p = &client->handle_refs.rb_node;
 460         while (*p) {
 461                 struct nvmap_handle_ref *node;
 462                 parent = *p;
 463                 node = rb_entry(parent, struct nvmap_handle_ref, node);
 464                 if (ref->handle > node->handle)
 465                         p = &parent->rb_right;
 466                 else
 467                         p = &parent->rb_left;
 468         }
 469         rb_link_node(&ref->node, parent, p);
 470         rb_insert_color(&ref->node, &client->handle_refs);
 471         client->handle_count++;
 472         if (client->handle_count > nvmap_max_handle_count)
 473                 nvmap_max_handle_count = client->handle_count;
 474         atomic_inc(&ref->handle->share_count);
 475         nvmap_ref_unlock(client);
 476 }
 477
 478 struct nvmap_handle_ref *nvmap_create_handle(struct nvmap_client *client,
 479                                              size_t size)
 480 {
 481         void *err = ERR_PTR(-ENOMEM);
 482         struct nvmap_handle *h;
 483         struct nvmap_handle_ref *ref = NULL;
 484
 485         if (!client)
 486                 return ERR_PTR(-EINVAL);
 487
 488         if (!size)
 489                 return ERR_PTR(-EINVAL);
 490
 491         h = kzalloc(sizeof(*h), GFP_KERNEL);
 492         if (!h)
 493                 return ERR_PTR(-ENOMEM);
 494
 495         ref = kzalloc(sizeof(*ref), GFP_KERNEL);
 496         if (!ref)
 497                 goto ref_alloc_fail;
 498
 499         atomic_set(&h->ref, 1);
 500         atomic_set(&h->pin, 0);
 501         h->owner = client;
 502         BUG_ON(!h->owner);
 503         h->size = h->orig_size = size;
 504         h->flags = NVMAP_HANDLE_WRITE_COMBINE;
 505         mutex_init(&h->lock);
 506         INIT_LIST_HEAD(&h->vmas);
 507
 508         /*
 509          * This takes out 1 ref on the dambuf. This corresponds to the
 510          * handle_ref that gets automatically made by nvmap_create_handle().
 511          */
 512         h->dmabuf = __nvmap_make_dmabuf(client, h);
 513         if (IS_ERR(h->dmabuf)) {
 514                 err = h->dmabuf;
 515                 goto make_dmabuf_fail;
 516         }
 517
 518         /*
 519          * Pre-attach nvmap to this new dmabuf. This gets unattached during the
 520          * dma_buf_release() operation.
 521          */
 522         h->attachment = dma_buf_attach(h->dmabuf, nvmap_dev->dev_user.parent);
 523         if (IS_ERR(h->attachment)) {
 524                 err = h->attachment;
 525                 goto dma_buf_attach_fail;
 526         }
 527
 528         nvmap_handle_add(nvmap_dev, h);
 529
 530         /*
 531          * Major assumption here: the dma_buf object that the handle contains
 532          * is created with a ref count of 1.
 533          */
 534         atomic_set(&ref->dupes, 1);
 535         ref->handle = h;
 536         atomic_set(&ref->pin, 0);
 537         add_handle_ref(client, ref);
 538         trace_nvmap_create_handle(client, client->name, h, size, ref);
 539         return ref;
 540
 541 dma_buf_attach_fail:
 542         dma_buf_put(h->dmabuf);
 543 make_dmabuf_fail:
 544         kfree(ref);
 545 ref_alloc_fail:
 546         kfree(h);
 547         return err;
 548 }
 549
 550 struct nvmap_handle_ref *nvmap_duplicate_handle(struct nvmap_client *client,
 551                                         struct nvmap_handle *h, bool skip_val)
 552 {
 553         struct nvmap_handle_ref *ref = NULL;
 554
 555         BUG_ON(!client);
 556         /* on success, the reference count for the handle should be
 557          * incremented, so the success paths will not call nvmap_handle_put */
 558         h = nvmap_validate_get(h);
 559
 560         if (!h) {
 561                 pr_debug("%s duplicate handle failed\n",
 562                             current->group_leader->comm);
 563                 return ERR_PTR(-EPERM);
 564         }
 565
 566         if (!h->alloc) {
 567                 pr_err("%s duplicating unallocated handle\n",
 568                         current->group_leader->comm);
 569                 nvmap_handle_put(h);
 570                 return ERR_PTR(-EINVAL);
 571         }
 572
 573         nvmap_ref_lock(client);
 574         ref = __nvmap_validate_locked(client, h);
 575
 576         if (ref) {
 577                 /* handle already duplicated in client; just increment
 578                  * the reference count rather than re-duplicating it */
 579                 atomic_inc(&ref->dupes);
 580                 nvmap_ref_unlock(client);
 581                 return ref;
 582         }
 583
 584         nvmap_ref_unlock(client);
 585
 586         ref = kzalloc(sizeof(*ref), GFP_KERNEL);
 587         if (!ref) {
 588                 nvmap_handle_put(h);
 589                 return ERR_PTR(-ENOMEM);
 590         }
 591
 592         if (!h->heap_pgalloc) {
 593                 mutex_lock(&h->lock);
 594                 nvmap_carveout_commit_add(client,
 595                         nvmap_heap_to_arg(nvmap_block_to_heap(h->carveout)),
 596                         h->size);
 597                 mutex_unlock(&h->lock);
 598         }
 599
 600         atomic_set(&ref->dupes, 1);
 601         ref->handle = h;
 602         atomic_set(&ref->pin, 0);
 603         add_handle_ref(client, ref);
 604
 605         /*
 606          * Ref counting on the dma_bufs follows the creation and destruction of
 607          * nvmap_handle_refs. That is every time a handle_ref is made the
 608          * dma_buf ref count goes up and everytime a handle_ref is destroyed
 609          * the dma_buf ref count goes down.
 610          */
 611         get_dma_buf(h->dmabuf);
 612
 613         trace_nvmap_duplicate_handle(client, h, ref);
 614         return ref;
 615 }
 616
 617 struct nvmap_handle_ref *nvmap_create_handle_from_fd(
 618                         struct nvmap_client *client, int fd)
 619 {
 620         struct nvmap_handle *handle;
 621         struct nvmap_handle_ref *ref;
 622
 623         BUG_ON(!client);
 624
 625         handle = nvmap_get_id_from_dmabuf_fd(client, fd);
 626         if (IS_ERR(handle))
 627                 return ERR_CAST(handle);
 628         ref = nvmap_duplicate_handle(client, handle, 1);
 629         return ref;
 630 }
 631
 632 struct nvmap_handle *nvmap_duplicate_handle_id_ex(struct nvmap_client *client,
 633                                                         struct nvmap_handle *h)
 634 {
 635         struct nvmap_handle_ref *ref = nvmap_duplicate_handle(client, h, 0);
 636
 637         if (IS_ERR(ref))
 638                 return 0;
 639
 640         return __nvmap_ref_to_id(ref);
 641 }
 642 EXPORT_SYMBOL(nvmap_duplicate_handle_id_ex);
 643
 644 int nvmap_get_page_list_info(struct nvmap_client *client,
 645                                 struct nvmap_handle *handle, u32 *size,
 646                                 u32 *flags, u32 *nr_page, bool *contig)
 647 {
 648         struct nvmap_handle *h;
 649
 650         BUG_ON(!size || !flags || !nr_page || !contig);
 651         BUG_ON(!client);
 652
 653         *size = 0;
 654         *flags = 0;
 655         *nr_page = 0;
 656
 657         h = nvmap_handle_get(handle);
 658
 659         if (!h) {
 660                 pr_err("%s query invalid handle %p\n",
 661                         current->group_leader->comm, handle);
 662                 return -EINVAL;
 663         }
 664
 665         if (!h->alloc || !h->heap_pgalloc) {
 666                 pr_err("%s query unallocated handle %p\n",
 667                         current->group_leader->comm, handle);
 668                 nvmap_handle_put(h);
 669                 return -EINVAL;
 670         }
 671
 672         *flags = h->flags;
 673         *size = h->orig_size;
 674         *nr_page = PAGE_ALIGN(h->size) >> PAGE_SHIFT;
 675         *contig = h->pgalloc.contig;
 676
 677         nvmap_handle_put(h);
 678         return 0;
 679 }
 680 EXPORT_SYMBOL(nvmap_get_page_list_info);
 681
 682 int nvmap_acquire_page_list(struct nvmap_client *client,
 683                         struct nvmap_handle *handle, struct page **pages,
 684                         u32 nr_page)
 685 {
 686         struct nvmap_handle *h;
 687         struct nvmap_handle_ref *ref;
 688         int idx;
 689         phys_addr_t dummy;
 690
 691         BUG_ON(!client);
 692
 693         h = nvmap_handle_get(handle);
 694
 695         if (!h) {
 696                 pr_err("%s query invalid handle %p\n",
 697                           current->group_leader->comm, handle);
 698                 return -EINVAL;
 699         }
 700
 701         if (!h->alloc || !h->heap_pgalloc) {
 702                 pr_err("%s query unallocated handle %p\n",
 703                           current->group_leader->comm, handle);
 704                 nvmap_handle_put(h);
 705                 return -EINVAL;
 706         }
 707
 708         BUG_ON(nr_page != PAGE_ALIGN(h->size) >> PAGE_SHIFT);
 709
 710         for (idx = 0; idx < nr_page; idx++)
 711                 pages[idx] = h->pgalloc.pages[idx];
 712
 713         nvmap_ref_lock(client);
 714         ref = __nvmap_validate_locked(client, h);
 715         if (ref)
 716                 __nvmap_pin(ref, &dummy);
 717         nvmap_ref_unlock(client);
 718
 719         return 0;
 720 }
 721 EXPORT_SYMBOL(nvmap_acquire_page_list);
 722
 723 int nvmap_release_page_list(struct nvmap_client *client,
 724                                 struct nvmap_handle *handle)
 725 {
 726         struct nvmap_handle_ref *ref;
 727         struct nvmap_handle *h = NULL;
 728
 729         BUG_ON(!client);
 730
 731         nvmap_ref_lock(client);
 732
 733         ref = __nvmap_validate_locked(client, handle);
 734         if (ref)
 735                 __nvmap_unpin(ref);
 736
 737         nvmap_ref_unlock(client);
 738
 739         if (ref)
 740                 h = ref->handle;
 741         if (h)
 742                 nvmap_handle_put(h);
 743
 744         return 0;
 745 }
 746 EXPORT_SYMBOL(nvmap_release_page_list);
 747
 748 int __nvmap_get_handle_param(struct nvmap_client *client,
 749                              struct nvmap_handle *h, u32 param, u64 *result)
 750 {
 751         int err = 0;
 752
 753         if (WARN_ON(!virt_addr_valid(h)))
 754                 return -EINVAL;
 755
 756         switch (param) {
 757         case NVMAP_HANDLE_PARAM_SIZE:
 758                 *result = h->orig_size;
 759                 break;
 760         case NVMAP_HANDLE_PARAM_ALIGNMENT:
 761                 *result = h->align;
 762                 break;
 763         case NVMAP_HANDLE_PARAM_BASE:
 764                 if (!h->alloc || !atomic_read(&h->pin))
 765                         *result = -EINVAL;
 766                 else if (!h->heap_pgalloc) {
 767                         mutex_lock(&h->lock);
 768                         *result = h->carveout->base;
 769                         mutex_unlock(&h->lock);
 770                 } else if (h->attachment->priv)
 771                         *result = sg_dma_address(
 772                                 ((struct sg_table *)h->attachment->priv)->sgl);
 773                 else
 774                         *result = -EINVAL;
 775                 break;
 776         case NVMAP_HANDLE_PARAM_HEAP:
 777                 if (!h->alloc)
 778                         *result = 0;
 779                 else if (!h->heap_pgalloc) {
 780                         mutex_lock(&h->lock);
 781                         *result = nvmap_carveout_usage(client, h->carveout);
 782                         mutex_unlock(&h->lock);
 783                 } else
 784                         *result = NVMAP_HEAP_IOVMM;
 785                 break;
 786         case NVMAP_HANDLE_PARAM_KIND:
 787                 *result = h->kind;
 788                 break;
 789         case NVMAP_HANDLE_PARAM_COMPR:
 790                 /* ignored, to be removed */
 791                 break;
 792         default:
 793                 err = -EINVAL;
 794                 break;
 795         }
 796         return err;
 797 }
 798
 799 int nvmap_get_handle_param(struct nvmap_client *client,
 800                            struct nvmap_handle_ref *ref, u32 param, u64 *result)
 801 {
 802         if (WARN_ON(!virt_addr_valid(ref)) ||
 803             WARN_ON(!virt_addr_valid(client)) ||
 804             WARN_ON(!result))
 805                 return -EINVAL;
 806
 807         return __nvmap_get_handle_param(client, ref->handle, param, result);
 808 }