mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
New driver: - logicvc vfio: - use aperture API core: - of: Add data-lane helpers and convert drivers - connector: Remove deprecated ida_simple_get() media: - Add various RGB666 and RGB888 format constants panel: - Add HannStar HSD101PWW - Add ETML0700Y5DHA dma-buf: - add sync-file API - set dma mask for udmabuf devices fbcon: - Improve scrolling performance - Sanitize input fbdev: - device unregistering fixes - vesa: Support COMPILE_TEST - Disable firmware-device registration when first native driver loads aperture: - fix segfault during hot-unplug - export for use with other subsystems client: - use driver validated modes dp: - aux: make probing more reliable - mst: Read extended DPCD capabilities during system resume - Support waiting for HDP signal - Port-validation fixes edid: - CEA data-block iterators - struct drm_edid introduction - implement HF-EEODB extension gem: - don't use fb format non-existing planes probe-helper: - use 640x480 as displayport fallback scheduler: - don't kill jobs in interrupt context bridge: - Add support for i.MX8qxp and i.MX8qm - lots of fixes/cleanups - Add TI-DLPC3433 - fy07024di26a30d: Optional GPIO reset - ldb: Add reg and reg-name properties to bindings, Kconfig fixes - lt9611: Fix display sensing; - tc358767: DSI/DPI refactoring and DSI-to-eDP support, DSI lane handling - tc358775: Fix clock settings - ti-sn65dsi83: Allow GPIO to sleep - adv7511: I2C fixes - anx7625: Fix error handling; DPI fixes; Implement HDP timeout via callback - fsl-ldb: Drop DE flip - ti-sn65dsi86: Convert to atomic modesetting amdgpu: - use atomic fence helpers in DM - fix VRAM address calculations - export CRTC bpc via debugfs - Initial devcoredump support - Enable high priority gfx queue on asics which support it - Adjust GART size on newer APUs for S/G display - Soft reset for GFX 11 / SDMA 6 - Add gfxoff status query for vangogh - Fix timestamps for cursor only commits - Adjust GART size on newer APUs for S/G display - fix buddy memory corruption amdkfd: - MMU notifier fixes - P2P DMA support using dma-buf - Add available memory IOCTL - HMM profiler support - Simplify GPUVM validation - Unified memory for CWSR save/restore area i915: - General driver clean-up - DG2 enabling (still under force probe) - DG2 small BAR memory support - HuC loading support - DG2 workarounds - DG2/ATS-M device IDs added - Ponte Vecchio prep work and new blitter engines - add Meteorlake support - Fix sparse warnings - DMC MMIO range checks - Audio related fixes - Runtime PM fixes - PSR fixes - Media freq factor and per-gt enhancements - DSI fixes for ICL+ - Disable DMC flip queue handlers - ADL_P voltage swing updates - Use more the VBT for panel information - Fix on Type-C ports with TBT mode - Improve fastset and allow seamless M/N changes - Accept more fixed modes with VRR/DMRRS panels - Disable connector polling for a headless SKU - ADL-S display PLL w/a - Enable THP on Icelake and beyond - Fix i915_gem_object_ggtt_pin_ww regression on old platforms - Expose per tile media freq factor in sysfs - Fix dma_resv fence handling in multi-batch execbuf - Improve on suspend / resume time with VT-d enabled - export CRTC bpc settings via debugfs msm: - gpu: a619 support - gpu: Fix for unclocked GMU register access - gpu: Devcore dump enhancements - client utilization via fdinfo support - fix fence rollover issue - gem: Lockdep false-positive warning fix - gem: Switch to pfn mappings - WB support on sc7180 - dp: dropped custom bulk clock implementation - fix link retraining on resolution change - hdmi: dropped obsolete GPIO support tegra: - context isolation for host1x engines - tegra234 soc support mediatek: - add vdosys0/1 for mt8195 - add MT8195 dp_intf driver exynos: - Fix resume function issue of exynos decon driver by calling clk_disable_unprepare() properly if clk_prepare_enable() failed. nouveau: - set of misc fixes/cleanups - display cleanups gma500: - Cleanup connector I2C handling hyperv: - Unify VRAM allocation of Gen1 and Gen2 meson: - Support YUV422 output; Refcount fixes mgag200: - Support damage clipping - Support gamma handling - Protect concurrent HW access - Fixes to connector - Store model-specific limits in device-info structure - fix PCI register init panfrost: - Valhall support r128: - Fix bit-shift overflow rockchip: - Locking fixes in error path ssd130x: - Fix built-in linkage udl: - Always advertize VGA connector ast: - Support multiple outputs - fix black screen on resume sun4i: - HDMI PHY cleanups vc4: - Add support for BCM2711 vkms: - Allocate output buffer with vmalloc() mcde: - Fix ref-count leak mxsfb/lcdif: - Support i.MX8MP LCD controller stm/ltdc: - Support dynamic Z order - Support mirroring ingenic: - Fix display at maximum resolution -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEEKbZHaGwW9KfbeusDHTzWXnEhr4FAmLp/7YACgkQDHTzWXnE hr7NjhAAnefa+72EG42OAqajbwTQMENOtFfqyL3k6ueK2ciYbsj/wklw/xc4Ok3o DM5kG54t+nA9L1M7UyE7eaO36/XcuvS8Ea0uKKkamWt+3Ux4g1Vo1J37nP5sK5jI GT/wceKA5sk3nuYly2lBby6mVTGuhAX+3edTAFeOwmd0WvQzzpy4vV+nCAgfshUs ql4gfQPdQdP+wiovUzCIEu6exCSCAI/Oc944fd3AJi5bZbOPFXRS4rMMOLSrdoXV 9P44EZExPbYrDuVUCx/UaZtN8D9myyyBfZe62CtdgNyTYUHXnHCBYue+7D/s5O+y GaLWcP128MsqZNmJNhmcWFIlgqowO24YkKUH68JH0UtBLSWich8rfdEsrxIidYED 0ma1jodRapjyZOjrHEJ3N5deKpoflMmqvCMpvIk1Ev6pT8KX9a6u34kLgsOVCV41 2bDEYD+DbRW2FexGR79yB2huXHGSnguco6069ca1oy9RF4q8cX6Pb1w2u42oS7zX lIgLIashilVR2AYg/qi6IPHavmOQ9ItSXPC+4YasYiMGp/mwePqpmL63b/wkhg0D nXn6/F8Bm6wle2FFbkLGwo1fF1Hn7RzTHSlqRWDKSEaMLhCus6M09VsobFCB19i0 lO4FNVTL8ZtryR94bgVmgi616w9hOhDhM9A+C0kJ9KBkDnDYUJU= =HQ9U -----END PGP SIGNATURE----- Merge tag 'drm-next-2022-08-03' of git://anongit.freedesktop.org/drm/drm Pull drm updates from Dave Airlie: "Highlights: - New driver for logicvc - which is a display IP core. - EDID parser rework to add new extensions - fbcon scrolling improvements - i915 has some more DG2 work but not enabled by default, but should have enough features for userspace to work now. Otherwise it's lots of work all over the place. Detailed summary: New driver: - logicvc vfio: - use aperture API core: - of: Add data-lane helpers and convert drivers - connector: Remove deprecated ida_simple_get() media: - Add various RGB666 and RGB888 format constants panel: - Add HannStar HSD101PWW - Add ETML0700Y5DHA dma-buf: - add sync-file API - set dma mask for udmabuf devices fbcon: - Improve scrolling performance - Sanitize input fbdev: - device unregistering fixes - vesa: Support COMPILE_TEST - Disable firmware-device registration when first native driver loads aperture: - fix segfault during hot-unplug - export for use with other subsystems client: - use driver validated modes dp: - aux: make probing more reliable - mst: Read extended DPCD capabilities during system resume - Support waiting for HDP signal - Port-validation fixes edid: - CEA data-block iterators - struct drm_edid introduction - implement HF-EEODB extension gem: - don't use fb format non-existing planes probe-helper: - use 640x480 as displayport fallback scheduler: - don't kill jobs in interrupt context bridge: - Add support for i.MX8qxp and i.MX8qm - lots of fixes/cleanups - Add TI-DLPC3433 - fy07024di26a30d: Optional GPIO reset - ldb: Add reg and reg-name properties to bindings, Kconfig fixes - lt9611: Fix display sensing; - tc358767: DSI/DPI refactoring and DSI-to-eDP support, DSI lane handling - tc358775: Fix clock settings - ti-sn65dsi83: Allow GPIO to sleep - adv7511: I2C fixes - anx7625: Fix error handling; DPI fixes; Implement HDP timeout via callback - fsl-ldb: Drop DE flip - ti-sn65dsi86: Convert to atomic modesetting amdgpu: - use atomic fence helpers in DM - fix VRAM address calculations - export CRTC bpc via debugfs - Initial devcoredump support - Enable high priority gfx queue on asics which support it - Adjust GART size on newer APUs for S/G display - Soft reset for GFX 11 / SDMA 6 - Add gfxoff status query for vangogh - Fix timestamps for cursor only commits - Adjust GART size on newer APUs for S/G display - fix buddy memory corruption amdkfd: - MMU notifier fixes - P2P DMA support using dma-buf - Add available memory IOCTL - HMM profiler support - Simplify GPUVM validation - Unified memory for CWSR save/restore area i915: - General driver clean-up - DG2 enabling (still under force probe) - DG2 small BAR memory support - HuC loading support - DG2 workarounds - DG2/ATS-M device IDs added - Ponte Vecchio prep work and new blitter engines - add Meteorlake support - Fix sparse warnings - DMC MMIO range checks - Audio related fixes - Runtime PM fixes - PSR fixes - Media freq factor and per-gt enhancements - DSI fixes for ICL+ - Disable DMC flip queue handlers - ADL_P voltage swing updates - Use more the VBT for panel information - Fix on Type-C ports with TBT mode - Improve fastset and allow seamless M/N changes - Accept more fixed modes with VRR/DMRRS panels - Disable connector polling for a headless SKU - ADL-S display PLL w/a - Enable THP on Icelake and beyond - Fix i915_gem_object_ggtt_pin_ww regression on old platforms - Expose per tile media freq factor in sysfs - Fix dma_resv fence handling in multi-batch execbuf - Improve on suspend / resume time with VT-d enabled - export CRTC bpc settings via debugfs msm: - gpu: a619 support - gpu: Fix for unclocked GMU register access - gpu: Devcore dump enhancements - client utilization via fdinfo support - fix fence rollover issue - gem: Lockdep false-positive warning fix - gem: Switch to pfn mappings - WB support on sc7180 - dp: dropped custom bulk clock implementation - fix link retraining on resolution change - hdmi: dropped obsolete GPIO support tegra: - context isolation for host1x engines - tegra234 soc support mediatek: - add vdosys0/1 for mt8195 - add MT8195 dp_intf driver exynos: - Fix resume function issue of exynos decon driver by calling clk_disable_unprepare() properly if clk_prepare_enable() failed. nouveau: - set of misc fixes/cleanups - display cleanups gma500: - Cleanup connector I2C handling hyperv: - Unify VRAM allocation of Gen1 and Gen2 meson: - Support YUV422 output; Refcount fixes mgag200: - Support damage clipping - Support gamma handling - Protect concurrent HW access - Fixes to connector - Store model-specific limits in device-info structure - fix PCI register init panfrost: - Valhall support r128: - Fix bit-shift overflow rockchip: - Locking fixes in error path ssd130x: - Fix built-in linkage udl: - Always advertize VGA connector ast: - Support multiple outputs - fix black screen on resume sun4i: - HDMI PHY cleanups vc4: - Add support for BCM2711 vkms: - Allocate output buffer with vmalloc() mcde: - Fix ref-count leak mxsfb/lcdif: - Support i.MX8MP LCD controller stm/ltdc: - Support dynamic Z order - Support mirroring ingenic: - Fix display at maximum resolution" * tag 'drm-next-2022-08-03' of git://anongit.freedesktop.org/drm/drm: (1480 commits) drm/amd/display: Fix a compilation failure on PowerPC caused by FPU code drm/amdgpu: enable support for psp 13.0.4 block drm/amdgpu: add files for PSP 13.0.4 drm/amdgpu: add header files for MP 13.0.4 drm/amdgpu: correct RLC_RLCS_BOOTLOAD_STATUS offset and index drm/amdgpu: send msg to IMU for the front-door loading drm/amdkfd: use time_is_before_jiffies(a + b) to replace "jiffies - a > b" drm/amdgpu: fix hive reference leak when reflecting psp topology info drm/amd/pm: enable GFX ULV feature support for SMU13.0.0 drm/amd/pm: update driver if header for SMU 13.0.0 drm/amdgpu: move mes self test after drm sched re-started drm/amdgpu: drop non-necessary call trace dump drm/amdgpu: enable VCN cg and JPEG cg/pg drm/amdgpu: vcn_4_0_2 video codec query drm/amdgpu: add VCN_4_0_2 firmware support drm/amdgpu: add VCN function in NBIO v7.7 drm/amdgpu: fix a vcn4 boot poll bug in emulation mode drm/amd/amdgpu: add memory training support for PSP_V13 drm/amdkfd: remove an unnecessary amdgpu_bo_ref drm/amd/pm: Add get_gfx_off_status interface for yellow carp ...
1581 lines
42 KiB
C
1581 lines
42 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Framework for buffer objects that can be shared across devices/subsystems.
|
|
*
|
|
* Copyright(C) 2011 Linaro Limited. All rights reserved.
|
|
* Author: Sumit Semwal <sumit.semwal@ti.com>
|
|
*
|
|
* Many thanks to linaro-mm-sig list, and specially
|
|
* Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and
|
|
* Daniel Vetter <daniel@ffwll.ch> for their support in creation and
|
|
* refining of this idea.
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/dma-buf.h>
|
|
#include <linux/dma-fence.h>
|
|
#include <linux/anon_inodes.h>
|
|
#include <linux/export.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/module.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/sync_file.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/dma-resv.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/pseudo_fs.h>
|
|
|
|
#include <uapi/linux/dma-buf.h>
|
|
#include <uapi/linux/magic.h>
|
|
|
|
#include "dma-buf-sysfs-stats.h"
|
|
|
|
static inline int is_dma_buf_file(struct file *);
|
|
|
|
struct dma_buf_list {
|
|
struct list_head head;
|
|
struct mutex lock;
|
|
};
|
|
|
|
static struct dma_buf_list db_list;
|
|
|
|
static char *dmabuffs_dname(struct dentry *dentry, char *buffer, int buflen)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
char name[DMA_BUF_NAME_LEN];
|
|
size_t ret = 0;
|
|
|
|
dmabuf = dentry->d_fsdata;
|
|
spin_lock(&dmabuf->name_lock);
|
|
if (dmabuf->name)
|
|
ret = strlcpy(name, dmabuf->name, DMA_BUF_NAME_LEN);
|
|
spin_unlock(&dmabuf->name_lock);
|
|
|
|
return dynamic_dname(dentry, buffer, buflen, "/%s:%s",
|
|
dentry->d_name.name, ret > 0 ? name : "");
|
|
}
|
|
|
|
static void dma_buf_release(struct dentry *dentry)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
|
|
dmabuf = dentry->d_fsdata;
|
|
if (unlikely(!dmabuf))
|
|
return;
|
|
|
|
BUG_ON(dmabuf->vmapping_counter);
|
|
|
|
/*
|
|
* If you hit this BUG() it could mean:
|
|
* * There's a file reference imbalance in dma_buf_poll / dma_buf_poll_cb or somewhere else
|
|
* * dmabuf->cb_in/out.active are non-0 despite no pending fence callback
|
|
*/
|
|
BUG_ON(dmabuf->cb_in.active || dmabuf->cb_out.active);
|
|
|
|
dma_buf_stats_teardown(dmabuf);
|
|
dmabuf->ops->release(dmabuf);
|
|
|
|
if (dmabuf->resv == (struct dma_resv *)&dmabuf[1])
|
|
dma_resv_fini(dmabuf->resv);
|
|
|
|
WARN_ON(!list_empty(&dmabuf->attachments));
|
|
module_put(dmabuf->owner);
|
|
kfree(dmabuf->name);
|
|
kfree(dmabuf);
|
|
}
|
|
|
|
static int dma_buf_file_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
|
|
if (!is_dma_buf_file(file))
|
|
return -EINVAL;
|
|
|
|
dmabuf = file->private_data;
|
|
|
|
mutex_lock(&db_list.lock);
|
|
list_del(&dmabuf->list_node);
|
|
mutex_unlock(&db_list.lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct dentry_operations dma_buf_dentry_ops = {
|
|
.d_dname = dmabuffs_dname,
|
|
.d_release = dma_buf_release,
|
|
};
|
|
|
|
static struct vfsmount *dma_buf_mnt;
|
|
|
|
static int dma_buf_fs_init_context(struct fs_context *fc)
|
|
{
|
|
struct pseudo_fs_context *ctx;
|
|
|
|
ctx = init_pseudo(fc, DMA_BUF_MAGIC);
|
|
if (!ctx)
|
|
return -ENOMEM;
|
|
ctx->dops = &dma_buf_dentry_ops;
|
|
return 0;
|
|
}
|
|
|
|
static struct file_system_type dma_buf_fs_type = {
|
|
.name = "dmabuf",
|
|
.init_fs_context = dma_buf_fs_init_context,
|
|
.kill_sb = kill_anon_super,
|
|
};
|
|
|
|
static int dma_buf_mmap_internal(struct file *file, struct vm_area_struct *vma)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
|
|
if (!is_dma_buf_file(file))
|
|
return -EINVAL;
|
|
|
|
dmabuf = file->private_data;
|
|
|
|
/* check if buffer supports mmap */
|
|
if (!dmabuf->ops->mmap)
|
|
return -EINVAL;
|
|
|
|
/* check for overflowing the buffer's size */
|
|
if (vma->vm_pgoff + vma_pages(vma) >
|
|
dmabuf->size >> PAGE_SHIFT)
|
|
return -EINVAL;
|
|
|
|
return dmabuf->ops->mmap(dmabuf, vma);
|
|
}
|
|
|
|
static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
loff_t base;
|
|
|
|
if (!is_dma_buf_file(file))
|
|
return -EBADF;
|
|
|
|
dmabuf = file->private_data;
|
|
|
|
/* only support discovering the end of the buffer,
|
|
but also allow SEEK_SET to maintain the idiomatic
|
|
SEEK_END(0), SEEK_CUR(0) pattern */
|
|
if (whence == SEEK_END)
|
|
base = dmabuf->size;
|
|
else if (whence == SEEK_SET)
|
|
base = 0;
|
|
else
|
|
return -EINVAL;
|
|
|
|
if (offset != 0)
|
|
return -EINVAL;
|
|
|
|
return base + offset;
|
|
}
|
|
|
|
/**
|
|
* DOC: implicit fence polling
|
|
*
|
|
* To support cross-device and cross-driver synchronization of buffer access
|
|
* implicit fences (represented internally in the kernel with &struct dma_fence)
|
|
* can be attached to a &dma_buf. The glue for that and a few related things are
|
|
* provided in the &dma_resv structure.
|
|
*
|
|
* Userspace can query the state of these implicitly tracked fences using poll()
|
|
* and related system calls:
|
|
*
|
|
* - Checking for EPOLLIN, i.e. read access, can be use to query the state of the
|
|
* most recent write or exclusive fence.
|
|
*
|
|
* - Checking for EPOLLOUT, i.e. write access, can be used to query the state of
|
|
* all attached fences, shared and exclusive ones.
|
|
*
|
|
* Note that this only signals the completion of the respective fences, i.e. the
|
|
* DMA transfers are complete. Cache flushing and any other necessary
|
|
* preparations before CPU access can begin still need to happen.
|
|
*
|
|
* As an alternative to poll(), the set of fences on DMA buffer can be
|
|
* exported as a &sync_file using &dma_buf_sync_file_export.
|
|
*/
|
|
|
|
static void dma_buf_poll_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
|
|
{
|
|
struct dma_buf_poll_cb_t *dcb = (struct dma_buf_poll_cb_t *)cb;
|
|
struct dma_buf *dmabuf = container_of(dcb->poll, struct dma_buf, poll);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&dcb->poll->lock, flags);
|
|
wake_up_locked_poll(dcb->poll, dcb->active);
|
|
dcb->active = 0;
|
|
spin_unlock_irqrestore(&dcb->poll->lock, flags);
|
|
dma_fence_put(fence);
|
|
/* Paired with get_file in dma_buf_poll */
|
|
fput(dmabuf->file);
|
|
}
|
|
|
|
static bool dma_buf_poll_add_cb(struct dma_resv *resv, bool write,
|
|
struct dma_buf_poll_cb_t *dcb)
|
|
{
|
|
struct dma_resv_iter cursor;
|
|
struct dma_fence *fence;
|
|
int r;
|
|
|
|
dma_resv_for_each_fence(&cursor, resv, dma_resv_usage_rw(write),
|
|
fence) {
|
|
dma_fence_get(fence);
|
|
r = dma_fence_add_callback(fence, &dcb->cb, dma_buf_poll_cb);
|
|
if (!r)
|
|
return true;
|
|
dma_fence_put(fence);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static __poll_t dma_buf_poll(struct file *file, poll_table *poll)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
struct dma_resv *resv;
|
|
__poll_t events;
|
|
|
|
dmabuf = file->private_data;
|
|
if (!dmabuf || !dmabuf->resv)
|
|
return EPOLLERR;
|
|
|
|
resv = dmabuf->resv;
|
|
|
|
poll_wait(file, &dmabuf->poll, poll);
|
|
|
|
events = poll_requested_events(poll) & (EPOLLIN | EPOLLOUT);
|
|
if (!events)
|
|
return 0;
|
|
|
|
dma_resv_lock(resv, NULL);
|
|
|
|
if (events & EPOLLOUT) {
|
|
struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_out;
|
|
|
|
/* Check that callback isn't busy */
|
|
spin_lock_irq(&dmabuf->poll.lock);
|
|
if (dcb->active)
|
|
events &= ~EPOLLOUT;
|
|
else
|
|
dcb->active = EPOLLOUT;
|
|
spin_unlock_irq(&dmabuf->poll.lock);
|
|
|
|
if (events & EPOLLOUT) {
|
|
/* Paired with fput in dma_buf_poll_cb */
|
|
get_file(dmabuf->file);
|
|
|
|
if (!dma_buf_poll_add_cb(resv, true, dcb))
|
|
/* No callback queued, wake up any other waiters */
|
|
dma_buf_poll_cb(NULL, &dcb->cb);
|
|
else
|
|
events &= ~EPOLLOUT;
|
|
}
|
|
}
|
|
|
|
if (events & EPOLLIN) {
|
|
struct dma_buf_poll_cb_t *dcb = &dmabuf->cb_in;
|
|
|
|
/* Check that callback isn't busy */
|
|
spin_lock_irq(&dmabuf->poll.lock);
|
|
if (dcb->active)
|
|
events &= ~EPOLLIN;
|
|
else
|
|
dcb->active = EPOLLIN;
|
|
spin_unlock_irq(&dmabuf->poll.lock);
|
|
|
|
if (events & EPOLLIN) {
|
|
/* Paired with fput in dma_buf_poll_cb */
|
|
get_file(dmabuf->file);
|
|
|
|
if (!dma_buf_poll_add_cb(resv, false, dcb))
|
|
/* No callback queued, wake up any other waiters */
|
|
dma_buf_poll_cb(NULL, &dcb->cb);
|
|
else
|
|
events &= ~EPOLLIN;
|
|
}
|
|
}
|
|
|
|
dma_resv_unlock(resv);
|
|
return events;
|
|
}
|
|
|
|
/**
|
|
* dma_buf_set_name - Set a name to a specific dma_buf to track the usage.
|
|
* It could support changing the name of the dma-buf if the same
|
|
* piece of memory is used for multiple purpose between different devices.
|
|
*
|
|
* @dmabuf: [in] dmabuf buffer that will be renamed.
|
|
* @buf: [in] A piece of userspace memory that contains the name of
|
|
* the dma-buf.
|
|
*
|
|
* Returns 0 on success. If the dma-buf buffer is already attached to
|
|
* devices, return -EBUSY.
|
|
*
|
|
*/
|
|
static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf)
|
|
{
|
|
char *name = strndup_user(buf, DMA_BUF_NAME_LEN);
|
|
|
|
if (IS_ERR(name))
|
|
return PTR_ERR(name);
|
|
|
|
spin_lock(&dmabuf->name_lock);
|
|
kfree(dmabuf->name);
|
|
dmabuf->name = name;
|
|
spin_unlock(&dmabuf->name_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_SYNC_FILE)
|
|
static long dma_buf_export_sync_file(struct dma_buf *dmabuf,
|
|
void __user *user_data)
|
|
{
|
|
struct dma_buf_export_sync_file arg;
|
|
enum dma_resv_usage usage;
|
|
struct dma_fence *fence = NULL;
|
|
struct sync_file *sync_file;
|
|
int fd, ret;
|
|
|
|
if (copy_from_user(&arg, user_data, sizeof(arg)))
|
|
return -EFAULT;
|
|
|
|
if (arg.flags & ~DMA_BUF_SYNC_RW)
|
|
return -EINVAL;
|
|
|
|
if ((arg.flags & DMA_BUF_SYNC_RW) == 0)
|
|
return -EINVAL;
|
|
|
|
fd = get_unused_fd_flags(O_CLOEXEC);
|
|
if (fd < 0)
|
|
return fd;
|
|
|
|
usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
|
|
ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
|
|
if (ret)
|
|
goto err_put_fd;
|
|
|
|
if (!fence)
|
|
fence = dma_fence_get_stub();
|
|
|
|
sync_file = sync_file_create(fence);
|
|
|
|
dma_fence_put(fence);
|
|
|
|
if (!sync_file) {
|
|
ret = -ENOMEM;
|
|
goto err_put_fd;
|
|
}
|
|
|
|
arg.fd = fd;
|
|
if (copy_to_user(user_data, &arg, sizeof(arg))) {
|
|
ret = -EFAULT;
|
|
goto err_put_file;
|
|
}
|
|
|
|
fd_install(fd, sync_file->file);
|
|
|
|
return 0;
|
|
|
|
err_put_file:
|
|
fput(sync_file->file);
|
|
err_put_fd:
|
|
put_unused_fd(fd);
|
|
return ret;
|
|
}
|
|
|
|
static long dma_buf_import_sync_file(struct dma_buf *dmabuf,
|
|
const void __user *user_data)
|
|
{
|
|
struct dma_buf_import_sync_file arg;
|
|
struct dma_fence *fence;
|
|
enum dma_resv_usage usage;
|
|
int ret = 0;
|
|
|
|
if (copy_from_user(&arg, user_data, sizeof(arg)))
|
|
return -EFAULT;
|
|
|
|
if (arg.flags & ~DMA_BUF_SYNC_RW)
|
|
return -EINVAL;
|
|
|
|
if ((arg.flags & DMA_BUF_SYNC_RW) == 0)
|
|
return -EINVAL;
|
|
|
|
fence = sync_file_get_fence(arg.fd);
|
|
if (!fence)
|
|
return -EINVAL;
|
|
|
|
usage = (arg.flags & DMA_BUF_SYNC_WRITE) ? DMA_RESV_USAGE_WRITE :
|
|
DMA_RESV_USAGE_READ;
|
|
|
|
dma_resv_lock(dmabuf->resv, NULL);
|
|
|
|
ret = dma_resv_reserve_fences(dmabuf->resv, 1);
|
|
if (!ret)
|
|
dma_resv_add_fence(dmabuf->resv, fence, usage);
|
|
|
|
dma_resv_unlock(dmabuf->resv);
|
|
|
|
dma_fence_put(fence);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static long dma_buf_ioctl(struct file *file,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
struct dma_buf_sync sync;
|
|
enum dma_data_direction direction;
|
|
int ret;
|
|
|
|
dmabuf = file->private_data;
|
|
|
|
switch (cmd) {
|
|
case DMA_BUF_IOCTL_SYNC:
|
|
if (copy_from_user(&sync, (void __user *) arg, sizeof(sync)))
|
|
return -EFAULT;
|
|
|
|
if (sync.flags & ~DMA_BUF_SYNC_VALID_FLAGS_MASK)
|
|
return -EINVAL;
|
|
|
|
switch (sync.flags & DMA_BUF_SYNC_RW) {
|
|
case DMA_BUF_SYNC_READ:
|
|
direction = DMA_FROM_DEVICE;
|
|
break;
|
|
case DMA_BUF_SYNC_WRITE:
|
|
direction = DMA_TO_DEVICE;
|
|
break;
|
|
case DMA_BUF_SYNC_RW:
|
|
direction = DMA_BIDIRECTIONAL;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (sync.flags & DMA_BUF_SYNC_END)
|
|
ret = dma_buf_end_cpu_access(dmabuf, direction);
|
|
else
|
|
ret = dma_buf_begin_cpu_access(dmabuf, direction);
|
|
|
|
return ret;
|
|
|
|
case DMA_BUF_SET_NAME_A:
|
|
case DMA_BUF_SET_NAME_B:
|
|
return dma_buf_set_name(dmabuf, (const char __user *)arg);
|
|
|
|
#if IS_ENABLED(CONFIG_SYNC_FILE)
|
|
case DMA_BUF_IOCTL_EXPORT_SYNC_FILE:
|
|
return dma_buf_export_sync_file(dmabuf, (void __user *)arg);
|
|
case DMA_BUF_IOCTL_IMPORT_SYNC_FILE:
|
|
return dma_buf_import_sync_file(dmabuf, (const void __user *)arg);
|
|
#endif
|
|
|
|
default:
|
|
return -ENOTTY;
|
|
}
|
|
}
|
|
|
|
static void dma_buf_show_fdinfo(struct seq_file *m, struct file *file)
|
|
{
|
|
struct dma_buf *dmabuf = file->private_data;
|
|
|
|
seq_printf(m, "size:\t%zu\n", dmabuf->size);
|
|
/* Don't count the temporary reference taken inside procfs seq_show */
|
|
seq_printf(m, "count:\t%ld\n", file_count(dmabuf->file) - 1);
|
|
seq_printf(m, "exp_name:\t%s\n", dmabuf->exp_name);
|
|
spin_lock(&dmabuf->name_lock);
|
|
if (dmabuf->name)
|
|
seq_printf(m, "name:\t%s\n", dmabuf->name);
|
|
spin_unlock(&dmabuf->name_lock);
|
|
}
|
|
|
|
static const struct file_operations dma_buf_fops = {
|
|
.release = dma_buf_file_release,
|
|
.mmap = dma_buf_mmap_internal,
|
|
.llseek = dma_buf_llseek,
|
|
.poll = dma_buf_poll,
|
|
.unlocked_ioctl = dma_buf_ioctl,
|
|
.compat_ioctl = compat_ptr_ioctl,
|
|
.show_fdinfo = dma_buf_show_fdinfo,
|
|
};
|
|
|
|
/*
|
|
* is_dma_buf_file - Check if struct file* is associated with dma_buf
|
|
*/
|
|
static inline int is_dma_buf_file(struct file *file)
|
|
{
|
|
return file->f_op == &dma_buf_fops;
|
|
}
|
|
|
|
static struct file *dma_buf_getfile(struct dma_buf *dmabuf, int flags)
|
|
{
|
|
static atomic64_t dmabuf_inode = ATOMIC64_INIT(0);
|
|
struct file *file;
|
|
struct inode *inode = alloc_anon_inode(dma_buf_mnt->mnt_sb);
|
|
|
|
if (IS_ERR(inode))
|
|
return ERR_CAST(inode);
|
|
|
|
inode->i_size = dmabuf->size;
|
|
inode_set_bytes(inode, dmabuf->size);
|
|
|
|
/*
|
|
* The ->i_ino acquired from get_next_ino() is not unique thus
|
|
* not suitable for using it as dentry name by dmabuf stats.
|
|
* Override ->i_ino with the unique and dmabuffs specific
|
|
* value.
|
|
*/
|
|
inode->i_ino = atomic64_add_return(1, &dmabuf_inode);
|
|
file = alloc_file_pseudo(inode, dma_buf_mnt, "dmabuf",
|
|
flags, &dma_buf_fops);
|
|
if (IS_ERR(file))
|
|
goto err_alloc_file;
|
|
file->f_flags = flags & (O_ACCMODE | O_NONBLOCK);
|
|
file->private_data = dmabuf;
|
|
file->f_path.dentry->d_fsdata = dmabuf;
|
|
|
|
return file;
|
|
|
|
err_alloc_file:
|
|
iput(inode);
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* DOC: dma buf device access
|
|
*
|
|
* For device DMA access to a shared DMA buffer the usual sequence of operations
|
|
* is fairly simple:
|
|
*
|
|
* 1. The exporter defines his exporter instance using
|
|
* DEFINE_DMA_BUF_EXPORT_INFO() and calls dma_buf_export() to wrap a private
|
|
* buffer object into a &dma_buf. It then exports that &dma_buf to userspace
|
|
* as a file descriptor by calling dma_buf_fd().
|
|
*
|
|
* 2. Userspace passes this file-descriptors to all drivers it wants this buffer
|
|
* to share with: First the file descriptor is converted to a &dma_buf using
|
|
* dma_buf_get(). Then the buffer is attached to the device using
|
|
* dma_buf_attach().
|
|
*
|
|
* Up to this stage the exporter is still free to migrate or reallocate the
|
|
* backing storage.
|
|
*
|
|
* 3. Once the buffer is attached to all devices userspace can initiate DMA
|
|
* access to the shared buffer. In the kernel this is done by calling
|
|
* dma_buf_map_attachment() and dma_buf_unmap_attachment().
|
|
*
|
|
* 4. Once a driver is done with a shared buffer it needs to call
|
|
* dma_buf_detach() (after cleaning up any mappings) and then release the
|
|
* reference acquired with dma_buf_get() by calling dma_buf_put().
|
|
*
|
|
* For the detailed semantics exporters are expected to implement see
|
|
* &dma_buf_ops.
|
|
*/
|
|
|
|
/**
|
|
* dma_buf_export - Creates a new dma_buf, and associates an anon file
|
|
* with this buffer, so it can be exported.
|
|
* Also connect the allocator specific data and ops to the buffer.
|
|
* Additionally, provide a name string for exporter; useful in debugging.
|
|
*
|
|
* @exp_info: [in] holds all the export related information provided
|
|
* by the exporter. see &struct dma_buf_export_info
|
|
* for further details.
|
|
*
|
|
* Returns, on success, a newly created struct dma_buf object, which wraps the
|
|
* supplied private data and operations for struct dma_buf_ops. On either
|
|
* missing ops, or error in allocating struct dma_buf, will return negative
|
|
* error.
|
|
*
|
|
* For most cases the easiest way to create @exp_info is through the
|
|
* %DEFINE_DMA_BUF_EXPORT_INFO macro.
|
|
*/
|
|
struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info)
|
|
{
|
|
struct dma_buf *dmabuf;
|
|
struct dma_resv *resv = exp_info->resv;
|
|
struct file *file;
|
|
size_t alloc_size = sizeof(struct dma_buf);
|
|
int ret;
|
|
|
|
if (!exp_info->resv)
|
|
alloc_size += sizeof(struct dma_resv);
|
|
else
|
|
/* prevent &dma_buf[1] == dma_buf->resv */
|
|
alloc_size += 1;
|
|
|
|
if (WARN_ON(!exp_info->priv
|
|
|| !exp_info->ops
|
|
|| !exp_info->ops->map_dma_buf
|
|
|| !exp_info->ops->unmap_dma_buf
|
|
|| !exp_info->ops->release)) {
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
if (WARN_ON(exp_info->ops->cache_sgt_mapping &&
|
|
(exp_info->ops->pin || exp_info->ops->unpin)))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
if (WARN_ON(!exp_info->ops->pin != !exp_info->ops->unpin))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
if (!try_module_get(exp_info->owner))
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
dmabuf = kzalloc(alloc_size, GFP_KERNEL);
|
|
if (!dmabuf) {
|
|
ret = -ENOMEM;
|
|
goto err_module;
|
|
}
|
|
|
|
dmabuf->priv = exp_info->priv;
|
|
dmabuf->ops = exp_info->ops;
|
|
dmabuf->size = exp_info->size;
|
|
dmabuf->exp_name = exp_info->exp_name;
|
|
dmabuf->owner = exp_info->owner;
|
|
spin_lock_init(&dmabuf->name_lock);
|
|
init_waitqueue_head(&dmabuf->poll);
|
|
dmabuf->cb_in.poll = dmabuf->cb_out.poll = &dmabuf->poll;
|
|
dmabuf->cb_in.active = dmabuf->cb_out.active = 0;
|
|
|
|
if (!resv) {
|
|
resv = (struct dma_resv *)&dmabuf[1];
|
|
dma_resv_init(resv);
|
|
}
|
|
dmabuf->resv = resv;
|
|
|
|
file = dma_buf_getfile(dmabuf, exp_info->flags);
|
|
if (IS_ERR(file)) {
|
|
ret = PTR_ERR(file);
|
|
goto err_dmabuf;
|
|
}
|
|
|
|
dmabuf->file = file;
|
|
|
|
mutex_init(&dmabuf->lock);
|
|
INIT_LIST_HEAD(&dmabuf->attachments);
|
|
|
|
mutex_lock(&db_list.lock);
|
|
list_add(&dmabuf->list_node, &db_list.head);
|
|
mutex_unlock(&db_list.lock);
|
|
|
|
ret = dma_buf_stats_setup(dmabuf);
|
|
if (ret)
|
|
goto err_sysfs;
|
|
|
|
return dmabuf;
|
|
|
|
err_sysfs:
|
|
/*
|
|
* Set file->f_path.dentry->d_fsdata to NULL so that when
|
|
* dma_buf_release() gets invoked by dentry_ops, it exits
|
|
* early before calling the release() dma_buf op.
|
|
*/
|
|
file->f_path.dentry->d_fsdata = NULL;
|
|
fput(file);
|
|
err_dmabuf:
|
|
kfree(dmabuf);
|
|
err_module:
|
|
module_put(exp_info->owner);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_export, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_fd - returns a file descriptor for the given struct dma_buf
|
|
* @dmabuf: [in] pointer to dma_buf for which fd is required.
|
|
* @flags: [in] flags to give to fd
|
|
*
|
|
* On success, returns an associated 'fd'. Else, returns error.
|
|
*/
|
|
int dma_buf_fd(struct dma_buf *dmabuf, int flags)
|
|
{
|
|
int fd;
|
|
|
|
if (!dmabuf || !dmabuf->file)
|
|
return -EINVAL;
|
|
|
|
fd = get_unused_fd_flags(flags);
|
|
if (fd < 0)
|
|
return fd;
|
|
|
|
fd_install(fd, dmabuf->file);
|
|
|
|
return fd;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_fd, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_get - returns the struct dma_buf related to an fd
|
|
* @fd: [in] fd associated with the struct dma_buf to be returned
|
|
*
|
|
* On success, returns the struct dma_buf associated with an fd; uses
|
|
* file's refcounting done by fget to increase refcount. returns ERR_PTR
|
|
* otherwise.
|
|
*/
|
|
struct dma_buf *dma_buf_get(int fd)
|
|
{
|
|
struct file *file;
|
|
|
|
file = fget(fd);
|
|
|
|
if (!file)
|
|
return ERR_PTR(-EBADF);
|
|
|
|
if (!is_dma_buf_file(file)) {
|
|
fput(file);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
return file->private_data;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_get, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_put - decreases refcount of the buffer
|
|
* @dmabuf: [in] buffer to reduce refcount of
|
|
*
|
|
* Uses file's refcounting done implicitly by fput().
|
|
*
|
|
* If, as a result of this call, the refcount becomes 0, the 'release' file
|
|
* operation related to this fd is called. It calls &dma_buf_ops.release vfunc
|
|
* in turn, and frees the memory allocated for dmabuf when exported.
|
|
*/
|
|
void dma_buf_put(struct dma_buf *dmabuf)
|
|
{
|
|
if (WARN_ON(!dmabuf || !dmabuf->file))
|
|
return;
|
|
|
|
fput(dmabuf->file);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_put, DMA_BUF);
|
|
|
|
static void mangle_sg_table(struct sg_table *sg_table)
|
|
{
|
|
#ifdef CONFIG_DMABUF_DEBUG
|
|
int i;
|
|
struct scatterlist *sg;
|
|
|
|
/* To catch abuse of the underlying struct page by importers mix
|
|
* up the bits, but take care to preserve the low SG_ bits to
|
|
* not corrupt the sgt. The mixing is undone in __unmap_dma_buf
|
|
* before passing the sgt back to the exporter. */
|
|
for_each_sgtable_sg(sg_table, sg, i)
|
|
sg->page_link ^= ~0xffUL;
|
|
#endif
|
|
|
|
}
|
|
static struct sg_table * __map_dma_buf(struct dma_buf_attachment *attach,
|
|
enum dma_data_direction direction)
|
|
{
|
|
struct sg_table *sg_table;
|
|
signed long ret;
|
|
|
|
sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction);
|
|
if (IS_ERR_OR_NULL(sg_table))
|
|
return sg_table;
|
|
|
|
if (!dma_buf_attachment_is_dynamic(attach)) {
|
|
ret = dma_resv_wait_timeout(attach->dmabuf->resv,
|
|
DMA_RESV_USAGE_KERNEL, true,
|
|
MAX_SCHEDULE_TIMEOUT);
|
|
if (ret < 0) {
|
|
attach->dmabuf->ops->unmap_dma_buf(attach, sg_table,
|
|
direction);
|
|
return ERR_PTR(ret);
|
|
}
|
|
}
|
|
|
|
mangle_sg_table(sg_table);
|
|
return sg_table;
|
|
}
|
|
|
|
/**
|
|
* dma_buf_dynamic_attach - Add the device to dma_buf's attachments list
|
|
* @dmabuf: [in] buffer to attach device to.
|
|
* @dev: [in] device to be attached.
|
|
* @importer_ops: [in] importer operations for the attachment
|
|
* @importer_priv: [in] importer private pointer for the attachment
|
|
*
|
|
* Returns struct dma_buf_attachment pointer for this attachment. Attachments
|
|
* must be cleaned up by calling dma_buf_detach().
|
|
*
|
|
* Optionally this calls &dma_buf_ops.attach to allow device-specific attach
|
|
* functionality.
|
|
*
|
|
* Returns:
|
|
*
|
|
* A pointer to newly created &dma_buf_attachment on success, or a negative
|
|
* error code wrapped into a pointer on failure.
|
|
*
|
|
* Note that this can fail if the backing storage of @dmabuf is in a place not
|
|
* accessible to @dev, and cannot be moved to a more suitable place. This is
|
|
* indicated with the error code -EBUSY.
|
|
*/
|
|
struct dma_buf_attachment *
|
|
dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev,
|
|
const struct dma_buf_attach_ops *importer_ops,
|
|
void *importer_priv)
|
|
{
|
|
struct dma_buf_attachment *attach;
|
|
int ret;
|
|
|
|
if (WARN_ON(!dmabuf || !dev))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
if (WARN_ON(importer_ops && !importer_ops->move_notify))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
attach = kzalloc(sizeof(*attach), GFP_KERNEL);
|
|
if (!attach)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
attach->dev = dev;
|
|
attach->dmabuf = dmabuf;
|
|
if (importer_ops)
|
|
attach->peer2peer = importer_ops->allow_peer2peer;
|
|
attach->importer_ops = importer_ops;
|
|
attach->importer_priv = importer_priv;
|
|
|
|
if (dmabuf->ops->attach) {
|
|
ret = dmabuf->ops->attach(dmabuf, attach);
|
|
if (ret)
|
|
goto err_attach;
|
|
}
|
|
dma_resv_lock(dmabuf->resv, NULL);
|
|
list_add(&attach->node, &dmabuf->attachments);
|
|
dma_resv_unlock(dmabuf->resv);
|
|
|
|
/* When either the importer or the exporter can't handle dynamic
|
|
* mappings we cache the mapping here to avoid issues with the
|
|
* reservation object lock.
|
|
*/
|
|
if (dma_buf_attachment_is_dynamic(attach) !=
|
|
dma_buf_is_dynamic(dmabuf)) {
|
|
struct sg_table *sgt;
|
|
|
|
if (dma_buf_is_dynamic(attach->dmabuf)) {
|
|
dma_resv_lock(attach->dmabuf->resv, NULL);
|
|
ret = dmabuf->ops->pin(attach);
|
|
if (ret)
|
|
goto err_unlock;
|
|
}
|
|
|
|
sgt = __map_dma_buf(attach, DMA_BIDIRECTIONAL);
|
|
if (!sgt)
|
|
sgt = ERR_PTR(-ENOMEM);
|
|
if (IS_ERR(sgt)) {
|
|
ret = PTR_ERR(sgt);
|
|
goto err_unpin;
|
|
}
|
|
if (dma_buf_is_dynamic(attach->dmabuf))
|
|
dma_resv_unlock(attach->dmabuf->resv);
|
|
attach->sgt = sgt;
|
|
attach->dir = DMA_BIDIRECTIONAL;
|
|
}
|
|
|
|
return attach;
|
|
|
|
err_attach:
|
|
kfree(attach);
|
|
return ERR_PTR(ret);
|
|
|
|
err_unpin:
|
|
if (dma_buf_is_dynamic(attach->dmabuf))
|
|
dmabuf->ops->unpin(attach);
|
|
|
|
err_unlock:
|
|
if (dma_buf_is_dynamic(attach->dmabuf))
|
|
dma_resv_unlock(attach->dmabuf->resv);
|
|
|
|
dma_buf_detach(dmabuf, attach);
|
|
return ERR_PTR(ret);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_dynamic_attach, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_attach - Wrapper for dma_buf_dynamic_attach
|
|
* @dmabuf: [in] buffer to attach device to.
|
|
* @dev: [in] device to be attached.
|
|
*
|
|
* Wrapper to call dma_buf_dynamic_attach() for drivers which still use a static
|
|
* mapping.
|
|
*/
|
|
struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
|
|
struct device *dev)
|
|
{
|
|
return dma_buf_dynamic_attach(dmabuf, dev, NULL, NULL);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_attach, DMA_BUF);
|
|
|
|
static void __unmap_dma_buf(struct dma_buf_attachment *attach,
|
|
struct sg_table *sg_table,
|
|
enum dma_data_direction direction)
|
|
{
|
|
/* uses XOR, hence this unmangles */
|
|
mangle_sg_table(sg_table);
|
|
|
|
attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, direction);
|
|
}
|
|
|
|
/**
|
|
* dma_buf_detach - Remove the given attachment from dmabuf's attachments list
|
|
* @dmabuf: [in] buffer to detach from.
|
|
* @attach: [in] attachment to be detached; is free'd after this call.
|
|
*
|
|
* Clean up a device attachment obtained by calling dma_buf_attach().
|
|
*
|
|
* Optionally this calls &dma_buf_ops.detach for device-specific detach.
|
|
*/
|
|
void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach)
|
|
{
|
|
if (WARN_ON(!dmabuf || !attach))
|
|
return;
|
|
|
|
if (attach->sgt) {
|
|
if (dma_buf_is_dynamic(attach->dmabuf))
|
|
dma_resv_lock(attach->dmabuf->resv, NULL);
|
|
|
|
__unmap_dma_buf(attach, attach->sgt, attach->dir);
|
|
|
|
if (dma_buf_is_dynamic(attach->dmabuf)) {
|
|
dmabuf->ops->unpin(attach);
|
|
dma_resv_unlock(attach->dmabuf->resv);
|
|
}
|
|
}
|
|
|
|
dma_resv_lock(dmabuf->resv, NULL);
|
|
list_del(&attach->node);
|
|
dma_resv_unlock(dmabuf->resv);
|
|
if (dmabuf->ops->detach)
|
|
dmabuf->ops->detach(dmabuf, attach);
|
|
|
|
kfree(attach);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_detach, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_pin - Lock down the DMA-buf
|
|
* @attach: [in] attachment which should be pinned
|
|
*
|
|
* Only dynamic importers (who set up @attach with dma_buf_dynamic_attach()) may
|
|
* call this, and only for limited use cases like scanout and not for temporary
|
|
* pin operations. It is not permitted to allow userspace to pin arbitrary
|
|
* amounts of buffers through this interface.
|
|
*
|
|
* Buffers must be unpinned by calling dma_buf_unpin().
|
|
*
|
|
* Returns:
|
|
* 0 on success, negative error code on failure.
|
|
*/
|
|
int dma_buf_pin(struct dma_buf_attachment *attach)
|
|
{
|
|
struct dma_buf *dmabuf = attach->dmabuf;
|
|
int ret = 0;
|
|
|
|
WARN_ON(!dma_buf_attachment_is_dynamic(attach));
|
|
|
|
dma_resv_assert_held(dmabuf->resv);
|
|
|
|
if (dmabuf->ops->pin)
|
|
ret = dmabuf->ops->pin(attach);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_pin, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_unpin - Unpin a DMA-buf
|
|
* @attach: [in] attachment which should be unpinned
|
|
*
|
|
* This unpins a buffer pinned by dma_buf_pin() and allows the exporter to move
|
|
* any mapping of @attach again and inform the importer through
|
|
* &dma_buf_attach_ops.move_notify.
|
|
*/
|
|
void dma_buf_unpin(struct dma_buf_attachment *attach)
|
|
{
|
|
struct dma_buf *dmabuf = attach->dmabuf;
|
|
|
|
WARN_ON(!dma_buf_attachment_is_dynamic(attach));
|
|
|
|
dma_resv_assert_held(dmabuf->resv);
|
|
|
|
if (dmabuf->ops->unpin)
|
|
dmabuf->ops->unpin(attach);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_unpin, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_map_attachment - Returns the scatterlist table of the attachment;
|
|
* mapped into _device_ address space. Is a wrapper for map_dma_buf() of the
|
|
* dma_buf_ops.
|
|
* @attach: [in] attachment whose scatterlist is to be returned
|
|
* @direction: [in] direction of DMA transfer
|
|
*
|
|
* Returns sg_table containing the scatterlist to be returned; returns ERR_PTR
|
|
* on error. May return -EINTR if it is interrupted by a signal.
|
|
*
|
|
* On success, the DMA addresses and lengths in the returned scatterlist are
|
|
* PAGE_SIZE aligned.
|
|
*
|
|
* A mapping must be unmapped by using dma_buf_unmap_attachment(). Note that
|
|
* the underlying backing storage is pinned for as long as a mapping exists,
|
|
* therefore users/importers should not hold onto a mapping for undue amounts of
|
|
* time.
|
|
*
|
|
* Important: Dynamic importers must wait for the exclusive fence of the struct
|
|
* dma_resv attached to the DMA-BUF first.
|
|
*/
|
|
struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach,
|
|
enum dma_data_direction direction)
|
|
{
|
|
struct sg_table *sg_table;
|
|
int r;
|
|
|
|
might_sleep();
|
|
|
|
if (WARN_ON(!attach || !attach->dmabuf))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
if (dma_buf_attachment_is_dynamic(attach))
|
|
dma_resv_assert_held(attach->dmabuf->resv);
|
|
|
|
if (attach->sgt) {
|
|
/*
|
|
* Two mappings with different directions for the same
|
|
* attachment are not allowed.
|
|
*/
|
|
if (attach->dir != direction &&
|
|
attach->dir != DMA_BIDIRECTIONAL)
|
|
return ERR_PTR(-EBUSY);
|
|
|
|
return attach->sgt;
|
|
}
|
|
|
|
if (dma_buf_is_dynamic(attach->dmabuf)) {
|
|
dma_resv_assert_held(attach->dmabuf->resv);
|
|
if (!IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY)) {
|
|
r = attach->dmabuf->ops->pin(attach);
|
|
if (r)
|
|
return ERR_PTR(r);
|
|
}
|
|
}
|
|
|
|
sg_table = __map_dma_buf(attach, direction);
|
|
if (!sg_table)
|
|
sg_table = ERR_PTR(-ENOMEM);
|
|
|
|
if (IS_ERR(sg_table) && dma_buf_is_dynamic(attach->dmabuf) &&
|
|
!IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))
|
|
attach->dmabuf->ops->unpin(attach);
|
|
|
|
if (!IS_ERR(sg_table) && attach->dmabuf->ops->cache_sgt_mapping) {
|
|
attach->sgt = sg_table;
|
|
attach->dir = direction;
|
|
}
|
|
|
|
#ifdef CONFIG_DMA_API_DEBUG
|
|
if (!IS_ERR(sg_table)) {
|
|
struct scatterlist *sg;
|
|
u64 addr;
|
|
int len;
|
|
int i;
|
|
|
|
for_each_sgtable_dma_sg(sg_table, sg, i) {
|
|
addr = sg_dma_address(sg);
|
|
len = sg_dma_len(sg);
|
|
if (!PAGE_ALIGNED(addr) || !PAGE_ALIGNED(len)) {
|
|
pr_debug("%s: addr %llx or len %x is not page aligned!\n",
|
|
__func__, addr, len);
|
|
}
|
|
}
|
|
}
|
|
#endif /* CONFIG_DMA_API_DEBUG */
|
|
return sg_table;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_map_attachment, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might
|
|
* deallocate the scatterlist associated. Is a wrapper for unmap_dma_buf() of
|
|
* dma_buf_ops.
|
|
* @attach: [in] attachment to unmap buffer from
|
|
* @sg_table: [in] scatterlist info of the buffer to unmap
|
|
* @direction: [in] direction of DMA transfer
|
|
*
|
|
* This unmaps a DMA mapping for @attached obtained by dma_buf_map_attachment().
|
|
*/
|
|
void dma_buf_unmap_attachment(struct dma_buf_attachment *attach,
|
|
struct sg_table *sg_table,
|
|
enum dma_data_direction direction)
|
|
{
|
|
might_sleep();
|
|
|
|
if (WARN_ON(!attach || !attach->dmabuf || !sg_table))
|
|
return;
|
|
|
|
if (dma_buf_attachment_is_dynamic(attach))
|
|
dma_resv_assert_held(attach->dmabuf->resv);
|
|
|
|
if (attach->sgt == sg_table)
|
|
return;
|
|
|
|
if (dma_buf_is_dynamic(attach->dmabuf))
|
|
dma_resv_assert_held(attach->dmabuf->resv);
|
|
|
|
__unmap_dma_buf(attach, sg_table, direction);
|
|
|
|
if (dma_buf_is_dynamic(attach->dmabuf) &&
|
|
!IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY))
|
|
dma_buf_unpin(attach);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_unmap_attachment, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_move_notify - notify attachments that DMA-buf is moving
|
|
*
|
|
* @dmabuf: [in] buffer which is moving
|
|
*
|
|
* Informs all attachmenst that they need to destroy and recreated all their
|
|
* mappings.
|
|
*/
|
|
void dma_buf_move_notify(struct dma_buf *dmabuf)
|
|
{
|
|
struct dma_buf_attachment *attach;
|
|
|
|
dma_resv_assert_held(dmabuf->resv);
|
|
|
|
list_for_each_entry(attach, &dmabuf->attachments, node)
|
|
if (attach->importer_ops)
|
|
attach->importer_ops->move_notify(attach);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_move_notify, DMA_BUF);
|
|
|
|
/**
|
|
* DOC: cpu access
|
|
*
|
|
* There are mutliple reasons for supporting CPU access to a dma buffer object:
|
|
*
|
|
* - Fallback operations in the kernel, for example when a device is connected
|
|
* over USB and the kernel needs to shuffle the data around first before
|
|
* sending it away. Cache coherency is handled by braketing any transactions
|
|
* with calls to dma_buf_begin_cpu_access() and dma_buf_end_cpu_access()
|
|
* access.
|
|
*
|
|
* Since for most kernel internal dma-buf accesses need the entire buffer, a
|
|
* vmap interface is introduced. Note that on very old 32-bit architectures
|
|
* vmalloc space might be limited and result in vmap calls failing.
|
|
*
|
|
* Interfaces::
|
|
*
|
|
* void \*dma_buf_vmap(struct dma_buf \*dmabuf, struct iosys_map \*map)
|
|
* void dma_buf_vunmap(struct dma_buf \*dmabuf, struct iosys_map \*map)
|
|
*
|
|
* The vmap call can fail if there is no vmap support in the exporter, or if
|
|
* it runs out of vmalloc space. Note that the dma-buf layer keeps a reference
|
|
* count for all vmap access and calls down into the exporter's vmap function
|
|
* only when no vmapping exists, and only unmaps it once. Protection against
|
|
* concurrent vmap/vunmap calls is provided by taking the &dma_buf.lock mutex.
|
|
*
|
|
* - For full compatibility on the importer side with existing userspace
|
|
* interfaces, which might already support mmap'ing buffers. This is needed in
|
|
* many processing pipelines (e.g. feeding a software rendered image into a
|
|
* hardware pipeline, thumbnail creation, snapshots, ...). Also, Android's ION
|
|
* framework already supported this and for DMA buffer file descriptors to
|
|
* replace ION buffers mmap support was needed.
|
|
*
|
|
* There is no special interfaces, userspace simply calls mmap on the dma-buf
|
|
* fd. But like for CPU access there's a need to braket the actual access,
|
|
* which is handled by the ioctl (DMA_BUF_IOCTL_SYNC). Note that
|
|
* DMA_BUF_IOCTL_SYNC can fail with -EAGAIN or -EINTR, in which case it must
|
|
* be restarted.
|
|
*
|
|
* Some systems might need some sort of cache coherency management e.g. when
|
|
* CPU and GPU domains are being accessed through dma-buf at the same time.
|
|
* To circumvent this problem there are begin/end coherency markers, that
|
|
* forward directly to existing dma-buf device drivers vfunc hooks. Userspace
|
|
* can make use of those markers through the DMA_BUF_IOCTL_SYNC ioctl. The
|
|
* sequence would be used like following:
|
|
*
|
|
* - mmap dma-buf fd
|
|
* - for each drawing/upload cycle in CPU 1. SYNC_START ioctl, 2. read/write
|
|
* to mmap area 3. SYNC_END ioctl. This can be repeated as often as you
|
|
* want (with the new data being consumed by say the GPU or the scanout
|
|
* device)
|
|
* - munmap once you don't need the buffer any more
|
|
*
|
|
* For correctness and optimal performance, it is always required to use
|
|
* SYNC_START and SYNC_END before and after, respectively, when accessing the
|
|
* mapped address. Userspace cannot rely on coherent access, even when there
|
|
* are systems where it just works without calling these ioctls.
|
|
*
|
|
* - And as a CPU fallback in userspace processing pipelines.
|
|
*
|
|
* Similar to the motivation for kernel cpu access it is again important that
|
|
* the userspace code of a given importing subsystem can use the same
|
|
* interfaces with a imported dma-buf buffer object as with a native buffer
|
|
* object. This is especially important for drm where the userspace part of
|
|
* contemporary OpenGL, X, and other drivers is huge, and reworking them to
|
|
* use a different way to mmap a buffer rather invasive.
|
|
*
|
|
* The assumption in the current dma-buf interfaces is that redirecting the
|
|
* initial mmap is all that's needed. A survey of some of the existing
|
|
* subsystems shows that no driver seems to do any nefarious thing like
|
|
* syncing up with outstanding asynchronous processing on the device or
|
|
* allocating special resources at fault time. So hopefully this is good
|
|
* enough, since adding interfaces to intercept pagefaults and allow pte
|
|
* shootdowns would increase the complexity quite a bit.
|
|
*
|
|
* Interface::
|
|
*
|
|
* int dma_buf_mmap(struct dma_buf \*, struct vm_area_struct \*,
|
|
* unsigned long);
|
|
*
|
|
* If the importing subsystem simply provides a special-purpose mmap call to
|
|
* set up a mapping in userspace, calling do_mmap with &dma_buf.file will
|
|
* equally achieve that for a dma-buf object.
|
|
*/
|
|
|
|
static int __dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
|
|
enum dma_data_direction direction)
|
|
{
|
|
bool write = (direction == DMA_BIDIRECTIONAL ||
|
|
direction == DMA_TO_DEVICE);
|
|
struct dma_resv *resv = dmabuf->resv;
|
|
long ret;
|
|
|
|
/* Wait on any implicit rendering fences */
|
|
ret = dma_resv_wait_timeout(resv, dma_resv_usage_rw(write),
|
|
true, MAX_SCHEDULE_TIMEOUT);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* dma_buf_begin_cpu_access - Must be called before accessing a dma_buf from the
|
|
* cpu in the kernel context. Calls begin_cpu_access to allow exporter-specific
|
|
* preparations. Coherency is only guaranteed in the specified range for the
|
|
* specified access direction.
|
|
* @dmabuf: [in] buffer to prepare cpu access for.
|
|
* @direction: [in] length of range for cpu access.
|
|
*
|
|
* After the cpu access is complete the caller should call
|
|
* dma_buf_end_cpu_access(). Only when cpu access is braketed by both calls is
|
|
* it guaranteed to be coherent with other DMA access.
|
|
*
|
|
* This function will also wait for any DMA transactions tracked through
|
|
* implicit synchronization in &dma_buf.resv. For DMA transactions with explicit
|
|
* synchronization this function will only ensure cache coherency, callers must
|
|
* ensure synchronization with such DMA transactions on their own.
|
|
*
|
|
* Can return negative error values, returns 0 on success.
|
|
*/
|
|
int dma_buf_begin_cpu_access(struct dma_buf *dmabuf,
|
|
enum dma_data_direction direction)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (WARN_ON(!dmabuf))
|
|
return -EINVAL;
|
|
|
|
might_lock(&dmabuf->resv->lock.base);
|
|
|
|
if (dmabuf->ops->begin_cpu_access)
|
|
ret = dmabuf->ops->begin_cpu_access(dmabuf, direction);
|
|
|
|
/* Ensure that all fences are waited upon - but we first allow
|
|
* the native handler the chance to do so more efficiently if it
|
|
* chooses. A double invocation here will be reasonably cheap no-op.
|
|
*/
|
|
if (ret == 0)
|
|
ret = __dma_buf_begin_cpu_access(dmabuf, direction);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_begin_cpu_access, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_end_cpu_access - Must be called after accessing a dma_buf from the
|
|
* cpu in the kernel context. Calls end_cpu_access to allow exporter-specific
|
|
* actions. Coherency is only guaranteed in the specified range for the
|
|
* specified access direction.
|
|
* @dmabuf: [in] buffer to complete cpu access for.
|
|
* @direction: [in] length of range for cpu access.
|
|
*
|
|
* This terminates CPU access started with dma_buf_begin_cpu_access().
|
|
*
|
|
* Can return negative error values, returns 0 on success.
|
|
*/
|
|
int dma_buf_end_cpu_access(struct dma_buf *dmabuf,
|
|
enum dma_data_direction direction)
|
|
{
|
|
int ret = 0;
|
|
|
|
WARN_ON(!dmabuf);
|
|
|
|
might_lock(&dmabuf->resv->lock.base);
|
|
|
|
if (dmabuf->ops->end_cpu_access)
|
|
ret = dmabuf->ops->end_cpu_access(dmabuf, direction);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_end_cpu_access, DMA_BUF);
|
|
|
|
|
|
/**
|
|
* dma_buf_mmap - Setup up a userspace mmap with the given vma
|
|
* @dmabuf: [in] buffer that should back the vma
|
|
* @vma: [in] vma for the mmap
|
|
* @pgoff: [in] offset in pages where this mmap should start within the
|
|
* dma-buf buffer.
|
|
*
|
|
* This function adjusts the passed in vma so that it points at the file of the
|
|
* dma_buf operation. It also adjusts the starting pgoff and does bounds
|
|
* checking on the size of the vma. Then it calls the exporters mmap function to
|
|
* set up the mapping.
|
|
*
|
|
* Can return negative error values, returns 0 on success.
|
|
*/
|
|
int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma,
|
|
unsigned long pgoff)
|
|
{
|
|
if (WARN_ON(!dmabuf || !vma))
|
|
return -EINVAL;
|
|
|
|
/* check if buffer supports mmap */
|
|
if (!dmabuf->ops->mmap)
|
|
return -EINVAL;
|
|
|
|
/* check for offset overflow */
|
|
if (pgoff + vma_pages(vma) < pgoff)
|
|
return -EOVERFLOW;
|
|
|
|
/* check for overflowing the buffer's size */
|
|
if (pgoff + vma_pages(vma) >
|
|
dmabuf->size >> PAGE_SHIFT)
|
|
return -EINVAL;
|
|
|
|
/* readjust the vma */
|
|
vma_set_file(vma, dmabuf->file);
|
|
vma->vm_pgoff = pgoff;
|
|
|
|
return dmabuf->ops->mmap(dmabuf, vma);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_mmap, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_vmap - Create virtual mapping for the buffer object into kernel
|
|
* address space. Same restrictions as for vmap and friends apply.
|
|
* @dmabuf: [in] buffer to vmap
|
|
* @map: [out] returns the vmap pointer
|
|
*
|
|
* This call may fail due to lack of virtual mapping address space.
|
|
* These calls are optional in drivers. The intended use for them
|
|
* is for mapping objects linear in kernel space for high use objects.
|
|
*
|
|
* To ensure coherency users must call dma_buf_begin_cpu_access() and
|
|
* dma_buf_end_cpu_access() around any cpu access performed through this
|
|
* mapping.
|
|
*
|
|
* Returns 0 on success, or a negative errno code otherwise.
|
|
*/
|
|
int dma_buf_vmap(struct dma_buf *dmabuf, struct iosys_map *map)
|
|
{
|
|
struct iosys_map ptr;
|
|
int ret = 0;
|
|
|
|
iosys_map_clear(map);
|
|
|
|
if (WARN_ON(!dmabuf))
|
|
return -EINVAL;
|
|
|
|
if (!dmabuf->ops->vmap)
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&dmabuf->lock);
|
|
if (dmabuf->vmapping_counter) {
|
|
dmabuf->vmapping_counter++;
|
|
BUG_ON(iosys_map_is_null(&dmabuf->vmap_ptr));
|
|
*map = dmabuf->vmap_ptr;
|
|
goto out_unlock;
|
|
}
|
|
|
|
BUG_ON(iosys_map_is_set(&dmabuf->vmap_ptr));
|
|
|
|
ret = dmabuf->ops->vmap(dmabuf, &ptr);
|
|
if (WARN_ON_ONCE(ret))
|
|
goto out_unlock;
|
|
|
|
dmabuf->vmap_ptr = ptr;
|
|
dmabuf->vmapping_counter = 1;
|
|
|
|
*map = dmabuf->vmap_ptr;
|
|
|
|
out_unlock:
|
|
mutex_unlock(&dmabuf->lock);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_vmap, DMA_BUF);
|
|
|
|
/**
|
|
* dma_buf_vunmap - Unmap a vmap obtained by dma_buf_vmap.
|
|
* @dmabuf: [in] buffer to vunmap
|
|
* @map: [in] vmap pointer to vunmap
|
|
*/
|
|
void dma_buf_vunmap(struct dma_buf *dmabuf, struct iosys_map *map)
|
|
{
|
|
if (WARN_ON(!dmabuf))
|
|
return;
|
|
|
|
BUG_ON(iosys_map_is_null(&dmabuf->vmap_ptr));
|
|
BUG_ON(dmabuf->vmapping_counter == 0);
|
|
BUG_ON(!iosys_map_is_equal(&dmabuf->vmap_ptr, map));
|
|
|
|
mutex_lock(&dmabuf->lock);
|
|
if (--dmabuf->vmapping_counter == 0) {
|
|
if (dmabuf->ops->vunmap)
|
|
dmabuf->ops->vunmap(dmabuf, map);
|
|
iosys_map_clear(&dmabuf->vmap_ptr);
|
|
}
|
|
mutex_unlock(&dmabuf->lock);
|
|
}
|
|
EXPORT_SYMBOL_NS_GPL(dma_buf_vunmap, DMA_BUF);
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
static int dma_buf_debug_show(struct seq_file *s, void *unused)
|
|
{
|
|
struct dma_buf *buf_obj;
|
|
struct dma_buf_attachment *attach_obj;
|
|
int count = 0, attach_count;
|
|
size_t size = 0;
|
|
int ret;
|
|
|
|
ret = mutex_lock_interruptible(&db_list.lock);
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
seq_puts(s, "\nDma-buf Objects:\n");
|
|
seq_printf(s, "%-8s\t%-8s\t%-8s\t%-8s\texp_name\t%-8s\tname\n",
|
|
"size", "flags", "mode", "count", "ino");
|
|
|
|
list_for_each_entry(buf_obj, &db_list.head, list_node) {
|
|
|
|
ret = dma_resv_lock_interruptible(buf_obj->resv, NULL);
|
|
if (ret)
|
|
goto error_unlock;
|
|
|
|
|
|
spin_lock(&buf_obj->name_lock);
|
|
seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
|
|
buf_obj->size,
|
|
buf_obj->file->f_flags, buf_obj->file->f_mode,
|
|
file_count(buf_obj->file),
|
|
buf_obj->exp_name,
|
|
file_inode(buf_obj->file)->i_ino,
|
|
buf_obj->name ?: "<none>");
|
|
spin_unlock(&buf_obj->name_lock);
|
|
|
|
dma_resv_describe(buf_obj->resv, s);
|
|
|
|
seq_puts(s, "\tAttached Devices:\n");
|
|
attach_count = 0;
|
|
|
|
list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
|
|
seq_printf(s, "\t%s\n", dev_name(attach_obj->dev));
|
|
attach_count++;
|
|
}
|
|
dma_resv_unlock(buf_obj->resv);
|
|
|
|
seq_printf(s, "Total %d devices attached\n\n",
|
|
attach_count);
|
|
|
|
count++;
|
|
size += buf_obj->size;
|
|
}
|
|
|
|
seq_printf(s, "\nTotal %d objects, %zu bytes\n", count, size);
|
|
|
|
mutex_unlock(&db_list.lock);
|
|
return 0;
|
|
|
|
error_unlock:
|
|
mutex_unlock(&db_list.lock);
|
|
return ret;
|
|
}
|
|
|
|
DEFINE_SHOW_ATTRIBUTE(dma_buf_debug);
|
|
|
|
static struct dentry *dma_buf_debugfs_dir;
|
|
|
|
static int dma_buf_init_debugfs(void)
|
|
{
|
|
struct dentry *d;
|
|
int err = 0;
|
|
|
|
d = debugfs_create_dir("dma_buf", NULL);
|
|
if (IS_ERR(d))
|
|
return PTR_ERR(d);
|
|
|
|
dma_buf_debugfs_dir = d;
|
|
|
|
d = debugfs_create_file("bufinfo", S_IRUGO, dma_buf_debugfs_dir,
|
|
NULL, &dma_buf_debug_fops);
|
|
if (IS_ERR(d)) {
|
|
pr_debug("dma_buf: debugfs: failed to create node bufinfo\n");
|
|
debugfs_remove_recursive(dma_buf_debugfs_dir);
|
|
dma_buf_debugfs_dir = NULL;
|
|
err = PTR_ERR(d);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static void dma_buf_uninit_debugfs(void)
|
|
{
|
|
debugfs_remove_recursive(dma_buf_debugfs_dir);
|
|
}
|
|
#else
|
|
static inline int dma_buf_init_debugfs(void)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline void dma_buf_uninit_debugfs(void)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static int __init dma_buf_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = dma_buf_init_sysfs_statistics();
|
|
if (ret)
|
|
return ret;
|
|
|
|
dma_buf_mnt = kern_mount(&dma_buf_fs_type);
|
|
if (IS_ERR(dma_buf_mnt))
|
|
return PTR_ERR(dma_buf_mnt);
|
|
|
|
mutex_init(&db_list.lock);
|
|
INIT_LIST_HEAD(&db_list.head);
|
|
dma_buf_init_debugfs();
|
|
return 0;
|
|
}
|
|
subsys_initcall(dma_buf_init);
|
|
|
|
static void __exit dma_buf_deinit(void)
|
|
{
|
|
dma_buf_uninit_debugfs();
|
|
kern_unmount(dma_buf_mnt);
|
|
dma_buf_uninit_sysfs_statistics();
|
|
}
|
|
__exitcall(dma_buf_deinit);
|