1/* 2 * Framework for buffer objects that can be shared across devices/subsystems. 3 * 4 * Copyright(C) 2011 Linaro Limited. All rights reserved. 5 * Author: Sumit Semwal <sumit.semwal@ti.com> 6 * 7 * Many thanks to linaro-mm-sig list, and specially 8 * Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and 9 * Daniel Vetter <daniel@ffwll.ch> for their support in creation and 10 * refining of this idea. 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License version 2 as published by 14 * the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, but WITHOUT 17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 19 * more details. 20 * 21 * You should have received a copy of the GNU General Public License along with 22 * this program. If not, see <http://www.gnu.org/licenses/>. 23 */ 24 25#include <linux/fs.h> 26#include <linux/slab.h> 27#include <linux/dma-buf.h> 28#include <linux/fence.h> 29#include <linux/anon_inodes.h> 30#include <linux/export.h> 31#include <linux/debugfs.h> 32#include <linux/seq_file.h> 33#include <linux/poll.h> 34#include <linux/reservation.h> 35 36static inline int is_dma_buf_file(struct file *); 37 38struct dma_buf_list { 39 struct list_head head; 40 struct mutex lock; 41}; 42 43static struct dma_buf_list db_list; 44 45static int dma_buf_release(struct inode *inode, struct file *file) 46{ 47 struct dma_buf *dmabuf; 48 49 if (!is_dma_buf_file(file)) 50 return -EINVAL; 51 52 dmabuf = file->private_data; 53 54 BUG_ON(dmabuf->vmapping_counter); 55 56 /* 57 * Any fences that a dma-buf poll can wait on should be signaled 58 * before releasing dma-buf. This is the responsibility of each 59 * driver that uses the reservation objects. 60 * 61 * If you hit this BUG() it means someone dropped their ref to the 62 * dma-buf while still having pending operation to the buffer. 63 */ 64 BUG_ON(dmabuf->cb_shared.active || dmabuf->cb_excl.active); 65 66 dmabuf->ops->release(dmabuf); 67 68 mutex_lock(&db_list.lock); 69 list_del(&dmabuf->list_node); 70 mutex_unlock(&db_list.lock); 71 72 if (dmabuf->resv == (struct reservation_object *)&dmabuf[1]) 73 reservation_object_fini(dmabuf->resv); 74 75 kfree(dmabuf); 76 return 0; 77} 78 79static int dma_buf_mmap_internal(struct file *file, struct vm_area_struct *vma) 80{ 81 struct dma_buf *dmabuf; 82 83 if (!is_dma_buf_file(file)) 84 return -EINVAL; 85 86 dmabuf = file->private_data; 87 88 /* check for overflowing the buffer's size */ 89 if (vma->vm_pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) > 90 dmabuf->size >> PAGE_SHIFT) 91 return -EINVAL; 92 93 return dmabuf->ops->mmap(dmabuf, vma); 94} 95 96static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence) 97{ 98 struct dma_buf *dmabuf; 99 loff_t base; 100 101 if (!is_dma_buf_file(file)) 102 return -EBADF; 103 104 dmabuf = file->private_data; 105 106 /* only support discovering the end of the buffer, 107 but also allow SEEK_SET to maintain the idiomatic 108 SEEK_END(0), SEEK_CUR(0) pattern */ 109 if (whence == SEEK_END) 110 base = dmabuf->size; 111 else if (whence == SEEK_SET) 112 base = 0; 113 else 114 return -EINVAL; 115 116 if (offset != 0) 117 return -EINVAL; 118 119 return base + offset; 120} 121 122static void dma_buf_poll_cb(struct fence *fence, struct fence_cb *cb) 123{ 124 struct dma_buf_poll_cb_t *dcb = (struct dma_buf_poll_cb_t *)cb; 125 unsigned long flags; 126 127 spin_lock_irqsave(&dcb->poll->lock, flags); 128 wake_up_locked_poll(dcb->poll, dcb->active); 129 dcb->active = 0; 130 spin_unlock_irqrestore(&dcb->poll->lock, flags); 131} 132 133static unsigned int dma_buf_poll(struct file *file, poll_table *poll) 134{ 135 struct dma_buf *dmabuf; 136 struct reservation_object *resv; 137 struct reservation_object_list *fobj; 138 struct fence *fence_excl; 139 unsigned long events; 140 unsigned shared_count, seq; 141 142 dmabuf = file->private_data; 143 if (!dmabuf || !dmabuf->resv) 144 return POLLERR; 145 146 resv = dmabuf->resv; 147 148 poll_wait(file, &dmabuf->poll, poll); 149 150 events = poll_requested_events(poll) & (POLLIN | POLLOUT); 151 if (!events) 152 return 0; 153 154retry: 155 seq = read_seqcount_begin(&resv->seq); 156 rcu_read_lock(); 157 158 fobj = rcu_dereference(resv->fence); 159 if (fobj) 160 shared_count = fobj->shared_count; 161 else 162 shared_count = 0; 163 fence_excl = rcu_dereference(resv->fence_excl); 164 if (read_seqcount_retry(&resv->seq, seq)) { 165 rcu_read_unlock(); 166 goto retry; 167 } 168 169 if (fence_excl && (!(events & POLLOUT) || shared_count == 0)) { 170 struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_excl; 171 unsigned long pevents = POLLIN; 172 173 if (shared_count == 0) 174 pevents |= POLLOUT; 175 176 spin_lock_irq(&dmabuf->poll.lock); 177 if (dcb->active) { 178 dcb->active |= pevents; 179 events &= ~pevents; 180 } else 181 dcb->active = pevents; 182 spin_unlock_irq(&dmabuf->poll.lock); 183 184 if (events & pevents) { 185 if (!fence_get_rcu(fence_excl)) { 186 /* force a recheck */ 187 events &= ~pevents; 188 dma_buf_poll_cb(NULL, &dcb->cb); 189 } else if (!fence_add_callback(fence_excl, &dcb->cb, 190 dma_buf_poll_cb)) { 191 events &= ~pevents; 192 fence_put(fence_excl); 193 } else { 194 /* 195 * No callback queued, wake up any additional 196 * waiters. 197 */ 198 fence_put(fence_excl); 199 dma_buf_poll_cb(NULL, &dcb->cb); 200 } 201 } 202 } 203 204 if ((events & POLLOUT) && shared_count > 0) { 205 struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_shared; 206 int i; 207 208 /* Only queue a new callback if no event has fired yet */ 209 spin_lock_irq(&dmabuf->poll.lock); 210 if (dcb->active) 211 events &= ~POLLOUT; 212 else 213 dcb->active = POLLOUT; 214 spin_unlock_irq(&dmabuf->poll.lock); 215 216 if (!(events & POLLOUT)) 217 goto out; 218 219 for (i = 0; i < shared_count; ++i) { 220 struct fence *fence = rcu_dereference(fobj->shared[i]); 221 222 if (!fence_get_rcu(fence)) { 223 /* 224 * fence refcount dropped to zero, this means 225 * that fobj has been freed 226 * 227 * call dma_buf_poll_cb and force a recheck! 228 */ 229 events &= ~POLLOUT; 230 dma_buf_poll_cb(NULL, &dcb->cb); 231 break; 232 } 233 if (!fence_add_callback(fence, &dcb->cb, 234 dma_buf_poll_cb)) { 235 fence_put(fence); 236 events &= ~POLLOUT; 237 break; 238 } 239 fence_put(fence); 240 } 241 242 /* No callback queued, wake up any additional waiters. */ 243 if (i == shared_count) 244 dma_buf_poll_cb(NULL, &dcb->cb); 245 } 246 247out: 248 rcu_read_unlock(); 249 return events; 250} 251 252static const struct file_operations dma_buf_fops = { 253 .release = dma_buf_release, 254 .mmap = dma_buf_mmap_internal, 255 .llseek = dma_buf_llseek, 256 .poll = dma_buf_poll, 257}; 258 259/* 260 * is_dma_buf_file - Check if struct file* is associated with dma_buf 261 */ 262static inline int is_dma_buf_file(struct file *file) 263{ 264 return file->f_op == &dma_buf_fops; 265} 266 267/** 268 * dma_buf_export - Creates a new dma_buf, and associates an anon file 269 * with this buffer, so it can be exported. 270 * Also connect the allocator specific data and ops to the buffer. 271 * Additionally, provide a name string for exporter; useful in debugging. 272 * 273 * @exp_info: [in] holds all the export related information provided 274 * by the exporter. see struct dma_buf_export_info 275 * for further details. 276 * 277 * Returns, on success, a newly created dma_buf object, which wraps the 278 * supplied private data and operations for dma_buf_ops. On either missing 279 * ops, or error in allocating struct dma_buf, will return negative error. 280 * 281 */ 282struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info) 283{ 284 struct dma_buf *dmabuf; 285 struct reservation_object *resv = exp_info->resv; 286 struct file *file; 287 size_t alloc_size = sizeof(struct dma_buf); 288 if (!exp_info->resv) 289 alloc_size += sizeof(struct reservation_object); 290 else 291 /* prevent &dma_buf[1] == dma_buf->resv */ 292 alloc_size += 1; 293 294 if (WARN_ON(!exp_info->priv 295 || !exp_info->ops 296 || !exp_info->ops->map_dma_buf 297 || !exp_info->ops->unmap_dma_buf 298 || !exp_info->ops->release 299 || !exp_info->ops->kmap_atomic 300 || !exp_info->ops->kmap 301 || !exp_info->ops->mmap)) { 302 return ERR_PTR(-EINVAL); 303 } 304 305 dmabuf = kzalloc(alloc_size, GFP_KERNEL); 306 if (dmabuf == NULL) 307 return ERR_PTR(-ENOMEM); 308 309 dmabuf->priv = exp_info->priv; 310 dmabuf->ops = exp_info->ops; 311 dmabuf->size = exp_info->size; 312 dmabuf->exp_name = exp_info->exp_name; 313 init_waitqueue_head(&dmabuf->poll); 314 dmabuf->cb_excl.poll = dmabuf->cb_shared.poll = &dmabuf->poll; 315 dmabuf->cb_excl.active = dmabuf->cb_shared.active = 0; 316 317 if (!resv) { 318 resv = (struct reservation_object *)&dmabuf[1]; 319 reservation_object_init(resv); 320 } 321 dmabuf->resv = resv; 322 323 file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, 324 exp_info->flags); 325 if (IS_ERR(file)) { 326 kfree(dmabuf); 327 return ERR_CAST(file); 328 } 329 330 file->f_mode |= FMODE_LSEEK; 331 dmabuf->file = file; 332 333 mutex_init(&dmabuf->lock); 334 INIT_LIST_HEAD(&dmabuf->attachments); 335 336 mutex_lock(&db_list.lock); 337 list_add(&dmabuf->list_node, &db_list.head); 338 mutex_unlock(&db_list.lock); 339 340 return dmabuf; 341} 342EXPORT_SYMBOL_GPL(dma_buf_export); 343 344/** 345 * dma_buf_fd - returns a file descriptor for the given dma_buf 346 * @dmabuf: [in] pointer to dma_buf for which fd is required. 347 * @flags: [in] flags to give to fd 348 * 349 * On success, returns an associated 'fd'. Else, returns error. 350 */ 351int dma_buf_fd(struct dma_buf *dmabuf, int flags) 352{ 353 int fd; 354 355 if (!dmabuf || !dmabuf->file) 356 return -EINVAL; 357 358 fd = get_unused_fd_flags(flags); 359 if (fd < 0) 360 return fd; 361 362 fd_install(fd, dmabuf->file); 363 364 return fd; 365} 366EXPORT_SYMBOL_GPL(dma_buf_fd); 367 368/** 369 * dma_buf_get - returns the dma_buf structure related to an fd 370 * @fd: [in] fd associated with the dma_buf to be returned 371 * 372 * On success, returns the dma_buf structure associated with an fd; uses 373 * file's refcounting done by fget to increase refcount. returns ERR_PTR 374 * otherwise. 375 */ 376struct dma_buf *dma_buf_get(int fd) 377{ 378 struct file *file; 379 380 file = fget(fd); 381 382 if (!file) 383 return ERR_PTR(-EBADF); 384 385 if (!is_dma_buf_file(file)) { 386 fput(file); 387 return ERR_PTR(-EINVAL); 388 } 389 390 return file->private_data; 391} 392EXPORT_SYMBOL_GPL(dma_buf_get); 393 394/** 395 * dma_buf_put - decreases refcount of the buffer 396 * @dmabuf: [in] buffer to reduce refcount of 397 * 398 * Uses file's refcounting done implicitly by fput() 399 */ 400void dma_buf_put(struct dma_buf *dmabuf) 401{ 402 if (WARN_ON(!dmabuf || !dmabuf->file)) 403 return; 404 405 fput(dmabuf->file); 406} 407EXPORT_SYMBOL_GPL(dma_buf_put); 408 409/** 410 * dma_buf_attach - Add the device to dma_buf's attachments list; optionally, 411 * calls attach() of dma_buf_ops to allow device-specific attach functionality 412 * @dmabuf: [in] buffer to attach device to. 413 * @dev: [in] device to be attached. 414 * 415 * Returns struct dma_buf_attachment * for this attachment; returns ERR_PTR on 416 * error. 417 */ 418struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, 419 struct device *dev) 420{ 421 struct dma_buf_attachment *attach; 422 int ret; 423 424 if (WARN_ON(!dmabuf || !dev)) 425 return ERR_PTR(-EINVAL); 426 427 attach = kzalloc(sizeof(struct dma_buf_attachment), GFP_KERNEL); 428 if (attach == NULL) 429 return ERR_PTR(-ENOMEM); 430 431 attach->dev = dev; 432 attach->dmabuf = dmabuf; 433 434 mutex_lock(&dmabuf->lock); 435 436 if (dmabuf->ops->attach) { 437 ret = dmabuf->ops->attach(dmabuf, dev, attach); 438 if (ret) 439 goto err_attach; 440 } 441 list_add(&attach->node, &dmabuf->attachments); 442 443 mutex_unlock(&dmabuf->lock); 444 return attach; 445 446err_attach: 447 kfree(attach); 448 mutex_unlock(&dmabuf->lock); 449 return ERR_PTR(ret); 450} 451EXPORT_SYMBOL_GPL(dma_buf_attach); 452 453/** 454 * dma_buf_detach - Remove the given attachment from dmabuf's attachments list; 455 * optionally calls detach() of dma_buf_ops for device-specific detach 456 * @dmabuf: [in] buffer to detach from. 457 * @attach: [in] attachment to be detached; is free'd after this call. 458 * 459 */ 460void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) 461{ 462 if (WARN_ON(!dmabuf || !attach)) 463 return; 464 465 mutex_lock(&dmabuf->lock); 466 list_del(&attach->node); 467 if (dmabuf->ops->detach) 468 dmabuf->ops->detach(dmabuf, attach); 469 470 mutex_unlock(&dmabuf->lock); 471 kfree(attach); 472} 473EXPORT_SYMBOL_GPL(dma_buf_detach); 474 475/** 476 * dma_buf_map_attachment - Returns the scatterlist table of the attachment; 477 * mapped into _device_ address space. Is a wrapper for map_dma_buf() of the 478 * dma_buf_ops. 479 * @attach: [in] attachment whose scatterlist is to be returned 480 * @direction: [in] direction of DMA transfer 481 * 482 * Returns sg_table containing the scatterlist to be returned; returns ERR_PTR 483 * on error. 484 */ 485struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, 486 enum dma_data_direction direction) 487{ 488 struct sg_table *sg_table = ERR_PTR(-EINVAL); 489 490 might_sleep(); 491 492 if (WARN_ON(!attach || !attach->dmabuf)) 493 return ERR_PTR(-EINVAL); 494 495 sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); 496 if (!sg_table) 497 sg_table = ERR_PTR(-ENOMEM); 498 499 return sg_table; 500} 501EXPORT_SYMBOL_GPL(dma_buf_map_attachment); 502 503/** 504 * dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might 505 * deallocate the scatterlist associated. Is a wrapper for unmap_dma_buf() of 506 * dma_buf_ops. 507 * @attach: [in] attachment to unmap buffer from 508 * @sg_table: [in] scatterlist info of the buffer to unmap 509 * @direction: [in] direction of DMA transfer 510 * 511 */ 512void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, 513 struct sg_table *sg_table, 514 enum dma_data_direction direction) 515{ 516 might_sleep(); 517 518 if (WARN_ON(!attach || !attach->dmabuf || !sg_table)) 519 return; 520 521 attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, 522 direction); 523} 524EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); 525 526 527/** 528 * dma_buf_begin_cpu_access - Must be called before accessing a dma_buf from the 529 * cpu in the kernel context. Calls begin_cpu_access to allow exporter-specific 530 * preparations. Coherency is only guaranteed in the specified range for the 531 * specified access direction. 532 * @dmabuf: [in] buffer to prepare cpu access for. 533 * @start: [in] start of range for cpu access. 534 * @len: [in] length of range for cpu access. 535 * @direction: [in] length of range for cpu access. 536 * 537 * Can return negative error values, returns 0 on success. 538 */ 539int dma_buf_begin_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len, 540 enum dma_data_direction direction) 541{ 542 int ret = 0; 543 544 if (WARN_ON(!dmabuf)) 545 return -EINVAL; 546 547 if (dmabuf->ops->begin_cpu_access) 548 ret = dmabuf->ops->begin_cpu_access(dmabuf, start, len, direction); 549 550 return ret; 551} 552EXPORT_SYMBOL_GPL(dma_buf_begin_cpu_access); 553 554/** 555 * dma_buf_end_cpu_access - Must be called after accessing a dma_buf from the 556 * cpu in the kernel context. Calls end_cpu_access to allow exporter-specific 557 * actions. Coherency is only guaranteed in the specified range for the 558 * specified access direction. 559 * @dmabuf: [in] buffer to complete cpu access for. 560 * @start: [in] start of range for cpu access. 561 * @len: [in] length of range for cpu access. 562 * @direction: [in] length of range for cpu access. 563 * 564 * This call must always succeed. 565 */ 566void dma_buf_end_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len, 567 enum dma_data_direction direction) 568{ 569 WARN_ON(!dmabuf); 570 571 if (dmabuf->ops->end_cpu_access) 572 dmabuf->ops->end_cpu_access(dmabuf, start, len, direction); 573} 574EXPORT_SYMBOL_GPL(dma_buf_end_cpu_access); 575 576/** 577 * dma_buf_kmap_atomic - Map a page of the buffer object into kernel address 578 * space. The same restrictions as for kmap_atomic and friends apply. 579 * @dmabuf: [in] buffer to map page from. 580 * @page_num: [in] page in PAGE_SIZE units to map. 581 * 582 * This call must always succeed, any necessary preparations that might fail 583 * need to be done in begin_cpu_access. 584 */ 585void *dma_buf_kmap_atomic(struct dma_buf *dmabuf, unsigned long page_num) 586{ 587 WARN_ON(!dmabuf); 588 589 return dmabuf->ops->kmap_atomic(dmabuf, page_num); 590} 591EXPORT_SYMBOL_GPL(dma_buf_kmap_atomic); 592 593/** 594 * dma_buf_kunmap_atomic - Unmap a page obtained by dma_buf_kmap_atomic. 595 * @dmabuf: [in] buffer to unmap page from. 596 * @page_num: [in] page in PAGE_SIZE units to unmap. 597 * @vaddr: [in] kernel space pointer obtained from dma_buf_kmap_atomic. 598 * 599 * This call must always succeed. 600 */ 601void dma_buf_kunmap_atomic(struct dma_buf *dmabuf, unsigned long page_num, 602 void *vaddr) 603{ 604 WARN_ON(!dmabuf); 605 606 if (dmabuf->ops->kunmap_atomic) 607 dmabuf->ops->kunmap_atomic(dmabuf, page_num, vaddr); 608} 609EXPORT_SYMBOL_GPL(dma_buf_kunmap_atomic); 610 611/** 612 * dma_buf_kmap - Map a page of the buffer object into kernel address space. The 613 * same restrictions as for kmap and friends apply. 614 * @dmabuf: [in] buffer to map page from. 615 * @page_num: [in] page in PAGE_SIZE units to map. 616 * 617 * This call must always succeed, any necessary preparations that might fail 618 * need to be done in begin_cpu_access. 619 */ 620void *dma_buf_kmap(struct dma_buf *dmabuf, unsigned long page_num) 621{ 622 WARN_ON(!dmabuf); 623 624 return dmabuf->ops->kmap(dmabuf, page_num); 625} 626EXPORT_SYMBOL_GPL(dma_buf_kmap); 627 628/** 629 * dma_buf_kunmap - Unmap a page obtained by dma_buf_kmap. 630 * @dmabuf: [in] buffer to unmap page from. 631 * @page_num: [in] page in PAGE_SIZE units to unmap. 632 * @vaddr: [in] kernel space pointer obtained from dma_buf_kmap. 633 * 634 * This call must always succeed. 635 */ 636void dma_buf_kunmap(struct dma_buf *dmabuf, unsigned long page_num, 637 void *vaddr) 638{ 639 WARN_ON(!dmabuf); 640 641 if (dmabuf->ops->kunmap) 642 dmabuf->ops->kunmap(dmabuf, page_num, vaddr); 643} 644EXPORT_SYMBOL_GPL(dma_buf_kunmap); 645 646 647/** 648 * dma_buf_mmap - Setup up a userspace mmap with the given vma 649 * @dmabuf: [in] buffer that should back the vma 650 * @vma: [in] vma for the mmap 651 * @pgoff: [in] offset in pages where this mmap should start within the 652 * dma-buf buffer. 653 * 654 * This function adjusts the passed in vma so that it points at the file of the 655 * dma_buf operation. It also adjusts the starting pgoff and does bounds 656 * checking on the size of the vma. Then it calls the exporters mmap function to 657 * set up the mapping. 658 * 659 * Can return negative error values, returns 0 on success. 660 */ 661int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma, 662 unsigned long pgoff) 663{ 664 struct file *oldfile; 665 int ret; 666 667 if (WARN_ON(!dmabuf || !vma)) 668 return -EINVAL; 669 670 /* check for offset overflow */ 671 if (pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) < pgoff) 672 return -EOVERFLOW; 673 674 /* check for overflowing the buffer's size */ 675 if (pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) > 676 dmabuf->size >> PAGE_SHIFT) 677 return -EINVAL; 678 679 /* readjust the vma */ 680 get_file(dmabuf->file); 681 oldfile = vma->vm_file; 682 vma->vm_file = dmabuf->file; 683 vma->vm_pgoff = pgoff; 684 685 ret = dmabuf->ops->mmap(dmabuf, vma); 686 if (ret) { 687 /* restore old parameters on failure */ 688 vma->vm_file = oldfile; 689 fput(dmabuf->file); 690 } else { 691 if (oldfile) 692 fput(oldfile); 693 } 694 return ret; 695 696} 697EXPORT_SYMBOL_GPL(dma_buf_mmap); 698 699/** 700 * dma_buf_vmap - Create virtual mapping for the buffer object into kernel 701 * address space. Same restrictions as for vmap and friends apply. 702 * @dmabuf: [in] buffer to vmap 703 * 704 * This call may fail due to lack of virtual mapping address space. 705 * These calls are optional in drivers. The intended use for them 706 * is for mapping objects linear in kernel space for high use objects. 707 * Please attempt to use kmap/kunmap before thinking about these interfaces. 708 * 709 * Returns NULL on error. 710 */ 711void *dma_buf_vmap(struct dma_buf *dmabuf) 712{ 713 void *ptr; 714 715 if (WARN_ON(!dmabuf)) 716 return NULL; 717 718 if (!dmabuf->ops->vmap) 719 return NULL; 720 721 mutex_lock(&dmabuf->lock); 722 if (dmabuf->vmapping_counter) { 723 dmabuf->vmapping_counter++; 724 BUG_ON(!dmabuf->vmap_ptr); 725 ptr = dmabuf->vmap_ptr; 726 goto out_unlock; 727 } 728 729 BUG_ON(dmabuf->vmap_ptr); 730 731 ptr = dmabuf->ops->vmap(dmabuf); 732 if (WARN_ON_ONCE(IS_ERR(ptr))) 733 ptr = NULL; 734 if (!ptr) 735 goto out_unlock; 736 737 dmabuf->vmap_ptr = ptr; 738 dmabuf->vmapping_counter = 1; 739 740out_unlock: 741 mutex_unlock(&dmabuf->lock); 742 return ptr; 743} 744EXPORT_SYMBOL_GPL(dma_buf_vmap); 745 746/** 747 * dma_buf_vunmap - Unmap a vmap obtained by dma_buf_vmap. 748 * @dmabuf: [in] buffer to vunmap 749 * @vaddr: [in] vmap to vunmap 750 */ 751void dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr) 752{ 753 if (WARN_ON(!dmabuf)) 754 return; 755 756 BUG_ON(!dmabuf->vmap_ptr); 757 BUG_ON(dmabuf->vmapping_counter == 0); 758 BUG_ON(dmabuf->vmap_ptr != vaddr); 759 760 mutex_lock(&dmabuf->lock); 761 if (--dmabuf->vmapping_counter == 0) { 762 if (dmabuf->ops->vunmap) 763 dmabuf->ops->vunmap(dmabuf, vaddr); 764 dmabuf->vmap_ptr = NULL; 765 } 766 mutex_unlock(&dmabuf->lock); 767} 768EXPORT_SYMBOL_GPL(dma_buf_vunmap); 769 770#ifdef CONFIG_DEBUG_FS 771static int dma_buf_describe(struct seq_file *s) 772{ 773 int ret; 774 struct dma_buf *buf_obj; 775 struct dma_buf_attachment *attach_obj; 776 int count = 0, attach_count; 777 size_t size = 0; 778 779 ret = mutex_lock_interruptible(&db_list.lock); 780 781 if (ret) 782 return ret; 783 784 seq_puts(s, "\nDma-buf Objects:\n"); 785 seq_puts(s, "size\tflags\tmode\tcount\texp_name\n"); 786 787 list_for_each_entry(buf_obj, &db_list.head, list_node) { 788 ret = mutex_lock_interruptible(&buf_obj->lock); 789 790 if (ret) { 791 seq_puts(s, 792 "\tERROR locking buffer object: skipping\n"); 793 continue; 794 } 795 796 seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\n", 797 buf_obj->size, 798 buf_obj->file->f_flags, buf_obj->file->f_mode, 799 file_count(buf_obj->file), 800 buf_obj->exp_name); 801 802 seq_puts(s, "\tAttached Devices:\n"); 803 attach_count = 0; 804 805 list_for_each_entry(attach_obj, &buf_obj->attachments, node) { 806 seq_puts(s, "\t"); 807 808 seq_printf(s, "%s\n", dev_name(attach_obj->dev)); 809 attach_count++; 810 } 811 812 seq_printf(s, "Total %d devices attached\n\n", 813 attach_count); 814 815 count++; 816 size += buf_obj->size; 817 mutex_unlock(&buf_obj->lock); 818 } 819 820 seq_printf(s, "\nTotal %d objects, %zu bytes\n", count, size); 821 822 mutex_unlock(&db_list.lock); 823 return 0; 824} 825 826static int dma_buf_show(struct seq_file *s, void *unused) 827{ 828 void (*func)(struct seq_file *) = s->private; 829 func(s); 830 return 0; 831} 832 833static int dma_buf_debug_open(struct inode *inode, struct file *file) 834{ 835 return single_open(file, dma_buf_show, inode->i_private); 836} 837 838static const struct file_operations dma_buf_debug_fops = { 839 .open = dma_buf_debug_open, 840 .read = seq_read, 841 .llseek = seq_lseek, 842 .release = single_release, 843}; 844 845static struct dentry *dma_buf_debugfs_dir; 846 847static int dma_buf_init_debugfs(void) 848{ 849 int err = 0; 850 dma_buf_debugfs_dir = debugfs_create_dir("dma_buf", NULL); 851 if (IS_ERR(dma_buf_debugfs_dir)) { 852 err = PTR_ERR(dma_buf_debugfs_dir); 853 dma_buf_debugfs_dir = NULL; 854 return err; 855 } 856 857 err = dma_buf_debugfs_create_file("bufinfo", dma_buf_describe); 858 859 if (err) 860 pr_debug("dma_buf: debugfs: failed to create node bufinfo\n"); 861 862 return err; 863} 864 865static void dma_buf_uninit_debugfs(void) 866{ 867 if (dma_buf_debugfs_dir) 868 debugfs_remove_recursive(dma_buf_debugfs_dir); 869} 870 871int dma_buf_debugfs_create_file(const char *name, 872 int (*write)(struct seq_file *)) 873{ 874 struct dentry *d; 875 876 d = debugfs_create_file(name, S_IRUGO, dma_buf_debugfs_dir, 877 write, &dma_buf_debug_fops); 878 879 return PTR_ERR_OR_ZERO(d); 880} 881#else 882static inline int dma_buf_init_debugfs(void) 883{ 884 return 0; 885} 886static inline void dma_buf_uninit_debugfs(void) 887{ 888} 889#endif 890 891static int __init dma_buf_init(void) 892{ 893 mutex_init(&db_list.lock); 894 INIT_LIST_HEAD(&db_list.head); 895 dma_buf_init_debugfs(); 896 return 0; 897} 898subsys_initcall(dma_buf_init); 899 900static void __exit dma_buf_deinit(void) 901{ 902 dma_buf_uninit_debugfs(); 903} 904__exitcall(dma_buf_deinit); 905