Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

14 participants
3704 discussions

Re: [PATCH v2 0/3] media: synchronize CPU access to imported DMA-BUFs

by Laurent Pinchart

Hi Karl, We discussed in v1 how this is not the right approach. Why are you posting a v2 without addressing that ? You need to go back to the design table. On Sat, Nov 07, 2026 at 11:47:00AM +0100, Karl Mehltretter wrote: > uvcvideo and vivid (when using vb2-vmalloc) access imported DMA-BUFs > through a kernel vmap without cache synchronization. When a non-coherent > importer such as V3D maps the same DMA-BUF persistently, captured data > remains in the CPU cache while physical RAM holds stale bytes. > > Add an opt-in uses_cpu_access queue flag for vb2-vmalloc queues to > bracket the interval from buf_prepare() through buf_finish() with > dma_buf_begin_cpu_access() and dma_buf_end_cpu_access(). Keep this > opt-in because some vb2-vmalloc drivers pass imported buffers to > hardware, and end CPU access in process context because DMA-BUF > callbacks may sleep. > > This follows the per-queue flag proposed here: > https://lore.kernel.org/r/CAAFQd5Am5jBev5P1HmsdeHoJfROZat3bi1W=UsN7wpVqw-XU… > > Based on Linux 7.4-rc1 with prerequisite patch "media: videobuf2: finish > prepared buffers in VIDIOC_REMOVE_BUFS": > https://lore.kernel.org/r/20261026071735.37220-1-kmehltretter@gmail.com/ > > Changes in v2: > - Split patch 1 of v1 into the standalone VIDIOC_REMOVE_BUFS patch above > and use its __vb2_buf_cancel() helper so queue cancellation and > VIDIOC_REMOVE_BUFS share the finish path (Tomasz). > - Scope uses_cpu_access to vb2-vmalloc queues and drop the attach_dmabuf > dma_dir parameter from vb2_mem_ops, videobuf2-dma-contig, > videobuf2-dma-sg and videobuf2-vmalloc (Tomasz). > - Enable uses_cpu_access in vivid only when vivid uses > vb2_vmalloc_memops (Tomasz). > > Link to v1: > https://lore.kernel.org/r/cover.1792392288.git.kmehltretter@gmail.com/ > > Testing: > > - Raspberry Pi 500+ (6.18.34+rpt-rpi-2712, aarch64, 16 KiB pages, > Sunplus UVC camera 1bcf:2701 and Broadcom V3D 7.1 GPU), backport of > the prerequisite patch plus patches 1 and 2: eight 640x480 YUYV frames > (614,400 B) captured into DMA-BUFs pre-seeded with 0xA5 and imported > into persistent EGL_LINUX_DMA_BUF_EXT textures before VIDIOC_STREAMON, > then copied by V3D 7.1 immediately after VIDIOC_DQBUF: > > Heap Baseline stale Patched v2 stale > /dev/dma_heap/linux,cma 8/8 (329,890 B) 0/8 (0 B) > /dev/dma_heap/system 8/8 (509,818 B) 0/8 (0 B) > > - QEMU virt (arm64, Linux 7.4-rc1 with the prerequisite patch and > patches 1-3, VIDEO_ADV_DEBUG=y, DEBUG_ATOMIC_SLEEP=y): six vivid > lifecycle cases (stream, streamoff-queued, prepare-reqbufs0, > prepare-remove, close-streaming, replace-dmabuf) across single-planar > and multi-planar queues with kprobe counters on > dma_buf_begin_cpu_access() and dma_buf_end_cpu_access(): > > Queue begin/end calls Unbalanced Warnings > vivid vb2-vmalloc (SP) 34 / 34 0 0 > vivid vb2-vmalloc (MP) 34 / 34 0 0 > vivid vb2-dma-contig (SP) 0 / 0 0 0 > vivid vb2-dma-contig (MP) 0 / 0 0 0 > 20x prepare-remove (vmalloc) 20 / 20 0 0 > > Assisted by an LLM for code changes, test harnesses and commit message > drafting. > > Karl Mehltretter (3): > media: videobuf2: add opt-in DMA-BUF CPU access > media: uvcvideo: synchronize imported DMA-BUFs for CPU access > media: vivid: synchronize imported DMA-BUFs for CPU access > > .../media/common/videobuf2/videobuf2-core.c | 76 +++++++++++++++++++ > drivers/media/test-drivers/vivid/vivid-core.c | 4 +- > drivers/media/usb/uvc/uvc_queue.c | 1 + > include/media/videobuf2-core.h | 5 ++ > 4 files changed, 85 insertions(+), 1 deletion(-) > > > base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4 > prerequisite-patch-id: aa99d5c3c27082cbe003ed94a195e3de415777c9 > -- > 2.39.5 (Apple Git-154) -- Regards, Laurent Pinchart

9 hours, 25 minutes

[PATCH] kselftests: dmabuf-heaps: Open heap device files O_RDONLY

by T.J. Mercier

Write permissions on the /dev/dma_heap/* device files are not required to issue ioctls and allocate dmabufs. Applications should be opening these file as O_RDONLY. The BPF dmabuf_iter selftest already does this. [1] Users are pointing to these selftests as examples of how use dmabuf, and encountering permission errors on systems where write permissions are not available on /dev/dma_heap/*. Apply the principle of least privilege to selftests which open dmabuf heaps by removing the write access mode and using O_RDONLY for the open() instead. The same is true for the vgem test using /dev/dri/card. [1] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/too… Signed-off-by: T.J. Mercier <tjmercier(a)google.com> --- tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c index fc9694fc4e89..45b420e37c97 100644 --- a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c +++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c @@ -48,7 +48,7 @@ static int open_vgem(void) snprintf(name, 80, "%s%u", drmstr, i); - fd = open(name, O_RDWR); + fd = open(name, O_RDONLY); if (fd < 0) continue; @@ -96,7 +96,7 @@ static int dmabuf_heap_open(char *name) if (ret < 0) ksft_exit_fail_msg("snprintf failed! %d\n", ret); - fd = open(buf, O_RDWR); + fd = open(buf, O_RDONLY); if (fd < 0) ksft_exit_fail_msg("open %s failed: %s\n", buf, strerror(errno)); base-commit: 9a11db68872055e6ead919bad04d6330851c522d -- 2.55.0.679.g6767b8d81c-goog

1 day, 1 hour

Re: [PATCH 2/7] dma-buf/udmabuf: account the page array metadata to memcg

by Christian König

On 11/6/26 14:18, Tao Cui wrote: > From: Tao Cui <cuitao(a)kylinos.cn> > > udmabuf pins the pages of a memfd and hands them out as a dma-buf. The > data pages keep the accounting of the memfd they were instantiated in, > but the bookkeeping around them does not: the page pointer array and > the pinned_folios array, both sized by the buffer page count, plus the > transient folios array sized by the memfd folio count, are plain > GFP_KERNEL. A 1GB buffer costs about 4MB of uncharged SUnreclaim > memory, and size_limit_mb defaults to INT_MAX. > > Charge the three kvmalloc allocations so the creator pays for the > metadata it induces. The system heap in the same subsystem already > accounts its buffer allocation; the data pages here stay with the > memfd. T.J. needs to take a look here, but I fear that this might break uAPI. A lot of the DMA-buf resources are intentionally not charged against memcg. Regards, Christian. > > Signed-off-by: Tao Cui <cuitao(a)kylinos.cn> > --- > drivers/dma-buf/udmabuf.c | 7 ++++--- > 1 file changed, 4 insertions(+), 3 deletions(-) > > diff --git a/drivers/dma-buf/udmabuf.c b/drivers/dma-buf/udmabuf.c > index df6dd0046242..40182c82df6b 100644 > --- a/drivers/dma-buf/udmabuf.c > +++ b/drivers/dma-buf/udmabuf.c > @@ -190,11 +190,12 @@ static void unpin_all_folios(struct udmabuf *ubuf) > > static __always_inline int init_udmabuf(struct udmabuf *ubuf, pgoff_t pgcnt) > { > - ubuf->pages = kvmalloc_objs(*ubuf->pages, pgcnt); > + ubuf->pages = kvmalloc_objs(*ubuf->pages, pgcnt, GFP_KERNEL_ACCOUNT); > if (!ubuf->pages) > return -ENOMEM; > > - ubuf->pinned_folios = kvmalloc_objs(*ubuf->pinned_folios, pgcnt); > + ubuf->pinned_folios = kvmalloc_objs(*ubuf->pinned_folios, pgcnt, > + GFP_KERNEL_ACCOUNT); > if (!ubuf->pinned_folios) > return -ENOMEM; > > @@ -387,7 +388,7 @@ static long udmabuf_create(struct miscdevice *device, > if (ret) > goto err; > > - folios = kvmalloc_objs(*folios, max_nr_folios); > + folios = kvmalloc_objs(*folios, max_nr_folios, GFP_KERNEL_ACCOUNT); > if (!folios) { > ret = -ENOMEM; > goto err; > -- > 2.43.0 >

1 day, 3 hours

Re: [PATCH v9 14/14] irqchip/gic-v3-its: Preallocate VPE L1 tables

by Aneesh Kumar K.V

Marc Zyngier <maz(a)kernel.org> writes: > On Wed, 04 Nov 2026 16:45:55 +0000, > "Aneesh Kumar K.V (Arm)" <aneesh.kumar(a)kernel.org> wrote: >> >> VPE L1 tables are allocated from the CPU-starting callback, where sleeping is >> not allowed. Remove the page allocation from this atomic path. >> >> Use a blocking allocation for the boot CPU and record the resulting table >> order. Allocate a page of that order from the sleepable CPU hotplug prepare >> stage for each secondary CPU. Consume the preallocated page only when the CPU >> cannot inherit an existing redistributor or ITS table. >> >> Reclaim unused preallocations after the CPU reaches the online state, and from >> the prepare-state teardown when CPU bring-up aborts. > > No. The way to do it is to move the ITS probing out of the > non-sleepable CPU hotplug path. > > I proposed a potential hack at [1] (which I find far more palatable > than this proposal), but the real fix is to probe the ITSs as > devices. > Could you share a bit more detail on what you have in mind? Are you suggesting that we create a platform device for each ITS and initialize it through the driver's probe callback, while the rest of the GIC initialization stays in the existing early boot path? Would that mean the main GIC is operational during early boot, while ITS-dependent features, such as MSI delivery and direct injection, become available after the ITS devices probe? Is that the split you have in mind? -aneesh

1 day, 4 hours

Re: [PATCH v9 01/14] mm: Add an allocator for CoCo shared memory

by Aneesh Kumar K.V

Suzuki K Poulose <suzuki.poulose(a)arm.com> writes: > On 04/11/2026 16:45, Aneesh Kumar K.V (Arm) wrote: >> Confidential-computing guests may require memory shared with the host to >> be aligned and transitioned in units larger than PAGE_SIZE. Several DMA >> users need struct page-backed allocations satisfying these requirements. >> Provide a common allocator instead of requiring each user to open-code >> this sequence. >> >> Add alloc_cc_shared_pages() and its node-aware variant. The allocator >> rounds the requested size to the architecture's shared granule, >> allocates suitably aligned contiguous pages and transitions the >> complete range to shared state. It also preserves the caller's GFP >> policy. >> >> A private-to-shared transition may alter memory contents. Mask >> __GFP_ZERO from the underlying allocation and when requested, clear the >> complete transitioned range after cc_make_shared() succeeds. > > This is not true for pKVM though. It is the other way around. i.e, > pages must be cleared before transition (e.g., from private to shared) > to make sure the contents don't leak into the host. > > Do we need to handle such cases with a pre_conversion and > post_conversion hook ? > Patch 2 does something similar. -aneesh

1 day, 4 hours

[PATCH v4 0/8] memcg: dma-buf cgroup accounting and charge transfer

by Albert Esteve

Shared-memory allocator services (e.g., Android's gralloc) allocate dma-bufs on behalf of client processes in different cgroups. Today those allocations are charged to the allocator's own cgroup, leaving client cgroups with no visibility into their actual memory consumption and defeating resource limits. This series adds memory cgroup accounting for dma-buf allocations, building on T.J. Mercier's earlier series [1] and incorporating feedback from previous versions and LPC discussions [2]. Patch 1 introduces the MEMCG_DMABUF stat and reserve/cancel and uncharge helpers in mm/memcontrol.c Patch 2 wires up the charging policy: dma_buf_export() stores exp_info.memcg and updates the stat, a new charge_fd field in DMA_HEAP_IOCTL_ALLOC accepts a pidfd or cgroupfd to identify the target cgroup, and __GFP_ACCOUNT is removed from system-heap allocations to avoid double counting. Patch 3 adds DMA_BUF_IOCTL_XFER_CHARGE, a general ioctl on any dma-buf fd to transfer charges post-allocation. This covers the double-hop allocator case (SurfaceFlinger -> gralloc -> kernel) and works for buffers from any exporter (DRM, V4L2, etc.). Charging is gated by dmabuf->memcg being set at export time, ensuring that transfer is only applied for buffers backed by system memory where size reflects actual bytes. If the receiving cgroup lacks capacity for the charge, the ioctl returns -ENOMEM and the original charge is preserved. Patches 4-7 add access control for cross-cgroup charging. Letting userspace decide who to charge needs to be a privileged operation because it has material impact on OOM decission and resource limits. We gate it via LSM hooks for the two charge_fd flavours: security_dma_buf_charge_task() gates the pidfd path (target identified by task credentials) and security_dma_buf_charge_cgroup() gates the cgroupfd path (target identified by cgroup directory label), with SELinux implementations under a dma_buf object class. Patch 8 adds selftests. Known limitations: - Single-owner model: a dma-buf carries one memcg charge regardless of how many processes share it. - Only memcg accounting. CMA heaps would additionally need dmem controller integration. - If a transfer of an uncharged buffer fails, the buffer remains charged to the original cgroup. The allocator (userspace) is expected to handle this (retry, free, ...). - The LSM hooks are intentionally narrow. Broader cgroup access controls (e.g. for the memfd/kexec handover case [2]) could be a separate effort reusing the same pattern. - Only system heap sets exp_info.memcg today. Other exporters (DRM, V4L2, etc.) can opt in by setting it, but are not covered by this series. - Related to the above: lazy backing-store allocation is not supported. This can be extended later, e.g., by adding a flag on the dma-buf struct for explicitly marking when memory is committed. [1] https://lore.kernel.org/cgroups/20230109213809.418135-1-tjmercier@google.co… [2] https://lpc.events/event/20/contributions/2416/ Signed-off-by: Albert Esteve <aesteve(a)redhat.com> --- Changes in v4: - Remove memcg_account flag; exp_info.memcg != NULL is the opt-in - Centralize memcg bookkeeping in dma_buf_export() - Drop mem_cgroup_commit_dmabuf() - Make mem_cgroup_transfer_charge() generic (not dma-buf specific) - Add EXPORT_SYMBOL_GPL for reserve/cancel (system_heap is tristate) - Reorder: move xfer ioctl before LSM patches - Serialize dmabuf->memcg updates with the dma-buf resv lock instead of cmpxchg - Link to v3: https://lore.kernel.org/r/20261027-v2_20230123_tjmercier_google_com-v3-0-78… Changes in v3: - Split mem_cgroup_charge_dmabuf() into reserve/commit/cancel three-phase API - Extract mem_cgroup_get_from_fd() helper shared by allocate and xfer paths - Rename __padding to flags in struct dma_buf_transfer_charge - Fix UAF race: move mod_memcg_state() before cmpxchg in transfer - Add memcg_account opt-in flag; xfer returns -EOPNOTSUPP if unset - Wrap dma_buf_charge_cgroup hook in #ifdef CONFIG_CGROUPS - Fix TOCTOU in SELinux charge_cgroup xattr length handling - Link to v2: https://lore.kernel.org/r/20261021-v2_20230123_tjmercier_google_com-v2-0-ef… Changes in v2: - Move charge_pid_fd to charge_fd, accepting cgroupfd in addition to pidfd per Christian König. - New DMA_BUF_IOCTL_XFER_CHARGE ioctl for post-allocation charge transfer on any dma-buf, not just dma-heap buffers per Christian König and T.J. Mercier. - Moved __GFP_ACCOUNT removal to patch 1 per Barry Song. - dma-buf charge/uncharge helpers take struct dma_buf * directly to avoid the need for caller to manage size calculations. - Added test_xfer_charge_cgroupfd_self to dmabuf-heap selftests. - Added LSM and SELinux hooks for cgroupfd-based charging. - Rebased to v7.3-rc7. - Link to v1: https://lore.kernel.org/r/20260512-v2_20230123_tjmercier_google_com-v1-0-63… --- Albert Esteve (7): dma-heap: charge dma-buf memory via explicit memcg dma-buf: transfer memcg charges via DMA_BUF_IOCTL_XFER_CHARGE security: dma-buf: Add dma_buf_charge_task LSM hook security: dma-buf: Add dma_buf_charge_cgroup LSM hook selinux: Restrict cross-cgroup dma-buf charging selinux: Restrict dma-buf direct cgroup charging selftests/dmabuf-heaps: Add dma-buf memcg accounting tests T.J. Mercier (1): memcg: Add MEMCG_DMABUF accounting infrastructure Documentation/admin-guide/cgroup-v2.rst | 5 + drivers/dma-buf/dma-buf.c | 50 ++++ drivers/dma-buf/dma-heap.c | 28 +- drivers/dma-buf/heaps/cma_heap.c | 3 +- drivers/dma-buf/heaps/system_heap.c | 21 +- drivers/tee/tee_heap.c | 3 +- include/linux/dma-buf.h | 9 + include/linux/dma-heap.h | 3 +- include/linux/lsm_hook_defs.h | 4 + include/linux/memcontrol.h | 47 ++++ include/linux/security.h | 18 ++ include/uapi/linux/dma-buf.h | 26 ++ include/uapi/linux/dma-heap.h | 7 + mm/memcontrol.c | 176 +++++++++++++ security/security.c | 34 +++ security/selinux/hooks.c | 44 ++++ security/selinux/include/classmap.h | 1 + tools/testing/selftests/cgroup/Makefile | 2 +- tools/testing/selftests/cgroup/test_memcontrol.c | 290 ++++++++++++++++++++- tools/testing/selftests/dmabuf-heaps/config | 1 + tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c | 227 +++++++++++++++- tools/testing/selftests/dmabuf-heaps/vmtest.sh | 226 ++++++++++++++++ 22 files changed, 1210 insertions(+), 15 deletions(-) --- base-commit: 24a19b953e2a3d0ea5a8c4951a0ab8f32720c907 change-id: 20260508-v2_20230123_tjmercier_google_com-f44fcfb16530 Best regards, -- Albert Esteve <aesteve(a)redhat.com>

1 day, 5 hours

Re: [PATCH v4] dma-buf/sw_sync: Avoid taking references to released fences

by Christian König

On 11/5/26 15:26, Kirtikumar Anandrao Ramchandani wrote: > The last dma_fence_put() can drop a sync point's reference count to zero > before timeline_fence_release() acquires the timeline lock. If > sync_timeline_signal() takes the lock in that window, dma_fence_get() > attempts to increment a zero reference count. > > Use dma_fence_get_rcu() for the temporary signaling reference and skip a > point whose reference count has reached zero. The timeline lock serializes > with timeline_fence_release(), keeping the point allocated while its > reference count is examined. The release callback removes the point from > the list and tree after acquiring the lock. > > For a live point, retain the temporary reference until after dropping the > lock, avoiding recursive locking through signaling callbacks. > > Reported-by: syzbot+cba1a1f459230395a076(a)syzkaller.appspotmail.com > Closes: https://syzkaller.appspot.com/bug?extid=cba1a1f459230395a076 > Signed-off-by: Kirtikumar Anandrao Ramchandani <kirtiar15502(a)gmail.com> Reviewed-by: Christian König <christian.koenig(a)amd.com> I will push this to drm-misc-next soon. Thanks, Christian. > --- > Changes in v4: > - Document why the timeline lock makes the conditional reference > acquisition safe without an RCU read-side critical section. > - Leave list and rb-tree removal to timeline_fence_release(). > - Drop the Fixes tag because SW_SYNC fixes are not intended for stable. > > Changes in v3: > - Unlink zero-reference points from both indexes while holding the > timeline lock. > > drivers/dma-buf/sw_sync.c | 7 ++++++- > 1 file changed, 6 insertions(+), 1 deletion(-) > > diff --git a/drivers/dma-buf/sw_sync.c b/drivers/dma-buf/sw_sync.c > index 8df20b021..8aa3ed777 100644 > --- a/drivers/dma-buf/sw_sync.c > +++ b/drivers/dma-buf/sw_sync.c > @@ -221,7 +221,12 @@ static void sync_timeline_signal(struct > sync_timeline *obj, unsigned int inc) > if (!timeline_fence_signaled(&pt->base)) > break; > > - dma_fence_get(&pt->base); > + /* > + * The timeline lock prevents timeline_fence_release() from > + * removing and freeing pt while its reference count is examined. > + */ > + if (!dma_fence_get_rcu(&pt->base)) > + continue; > > list_move_tail(&pt->link, &signalled); > rb_erase(&pt->node, &obj->pt_tree); > > base-commit: 05441d697f7f9a927264f4058cbbc6a03dfcac9d

2 days, 5 hours

Re: [PATCH] dma-buf/sw_sync: Avoid taking references to released fences

by Christian König

On 11/4/26 23:18, Kirtikumar Anandrao Ramchandani wrote: > The last dma_fence_put() can drop a sync point's reference count to > zero before timeline_fence_release() acquires the timeline lock to > remove it from pt_list. If sync_timeline_signal() acquires the lock in > that window, dma_fence_get() attempts to increment a zero reference > count and triggers a refcount warning. > > Use dma_fence_get_rcu() to acquire the temporary signaling reference > only if the fence is still referenced, as sync_pt_create() already > does when looking up an existing point. Skip a point whose reference > count has reached zero: its release callback will remove it from the > list and tree once the timeline lock is released. > > The timeline lock prevents the release callback from removing or > freeing a listed point during this check. For a live point, retain the > temporary reference until after dropping the lock, preserving the > protection against recursive locking from signaling callbacks. Please add this explanation as code comment to the patch. > > Fixes: e531fdb5cd5e ("dma-buf/sw_sync: Avoid recursive lock during fence signal") Drop that here. SW_SYNC is a unit testing functionality which can intentionally crash the kernel. You get literally tons of warnings and a tainted kernel when it is enabled/used. So bugs like those are generally not backported. Apart from that the patch looks good to me, Christian. > Reported-by: syzbot+cba1a1f459230395a076(a)syzkaller.appspotmail.com <mailto:syzbot%2Bcba1a1f459230395a076@syzkaller.appspotmail.com> > Closes: https://syzkaller.appspot.com/bug?extid=cba1a1f459230395a076 <https://syzkaller.appspot.com/bug?extid=cba1a1f459230395a076> > Signed-off-by: Kirtikumar Anandrao Ramchandani <kirtiar15502(a)gmail.com <mailto:kirtiar15502@gmail.com>> > --- > > drivers/dma-buf/sw_sync.c | 3 ++- > 1 file changed, 2 insertions(+), 1 deletion(-) > > diff --git a/drivers/dma-buf/sw_sync.c b/drivers/dma-buf/sw_sync.c > index 8df20b0218a9..7f1eadee4cdf 100644 > --- a/drivers/dma-buf/sw_sync.c > +++ b/drivers/dma-buf/sw_sync.c > @@ -221,7 +221,8 @@ > if (!timeline_fence_signaled(&pt->base)) > break; > > - dma_fence_get(&pt->base); > + if (!dma_fence_get_rcu(&pt->base)) > + continue; > > list_move_tail(&pt->link, &signalled); > rb_erase(&pt->node, &obj->pt_tree); > > base-commit: 05441d697f7f9a927264f4058cbbc6a03dfcac9d

2 days, 8 hours

[PATCH v13 00/19] PCI/P2PDMA: Route peer-to-peer DMA by TLP class

by Leon Romanovsky

Punch line for Linus from Jason: "Enhance detecting if the PCI fabric can support a peer to peer path by evaluating the full bi-directional fabric path over each of the three traffic type ACS controls. Expand the number of fabric configurations where the P2P algorithm makes the correct determination of support to include non-uniform ACS and situations where translated takes different routes from untranslated." -------------------------------------------------------------------------- PCI P2PDMA applies Request and Completion Redirect throughout both paths. This misclassifies asymmetric and nested switches, and reports one answer for every kind of TLP. Three ACS controls act on TLP attributes the Requester chooses rather than on the topology: Translation Blocking and Direct Translated P2P act on a Request's Address Type, and Completion Redirect skips Completions carrying Relaxed Ordering. Evaluate each direction at the path divergence, decide every class from the one walk, and treat a client with ATS enabled as translating unless its driver declares per-mapping ATS. This completes the P2PDMA side; dma-buf and mlx5 follow separately. Signed-off-by: Leon Romanovsky <leonro(a)nvidia.com> --- Changes in v13: - Read the Intel SPT PCH ACS Control dword at its nonstandard offset so Translation Blocking is honored on host routes, addressing the Sashiko review of patch 10. - Distinguished unreadable forwarding controls from missing forwarding and retained redirect advice when clearing controls restores a direct route, addressing the Sashiko review of patch 5. - Updated the directional routing documentation for shared ancestors. - Reused the ACS isolation-test mock setup - Link to v12: https://patch.msgid.link/20261103-fix-p2p-acs-v4-0-v12-0-912101f93517@nvidi… Changes in v12: - Rebaed to v7.4-rc1 - Link to v11: https://patch.msgid.link/20261013-fix-p2p-acs-v4-0-v11-0-72cf8c96e617@nvidi… Changes in v11: - Applied the client ATS policy in pci_p2pdma_distance_many() too, as local Sashiko pointed out. - Read the ATS Enable bit once per query, so the class and the ATS policy always agree. - Documented that pcim_p2pdma_set_ats_per_mapping() needs a successful pcim_p2pdma_init(). - The path diagnostics no longer read ACS Control or the bridge bus range, and they report a failed cache store. - Added a KUnit case for Direct Translated P2P without a redirect. - Clarified the Relaxed Ordering and diagnostics commit messages. - Honored device-specific ACS redirection, such as Zhaoxin Downstream Ports, in a new first patch with a KUnit case, as local Sashiko pointed out. Relaxed Ordering Completions are redirected at such a port too. - Clarified in the documentation that a quirk also redirects Relaxed Ordering Completions and that Translation Blocking applies only to upstream Requests, and labelled the ACS routing debug line with its class, as local Sashiko pointed out. - Treated ACS registers that read as all ones as unreadable, and named ports that a quirk redirects instead of suggesting pci=disable_acs_redir= for them, as local Sashiko pointed out. - Ignored ACS quirks of endpoints, which only describe traffic between their own functions. - Link to v10: https://patch.msgid.link/20261012-fix-p2p-acs-v4-0-v10-0-6ffe7b7a4517@nvidi… Changes in v10: - Fixed the Relaxed Ordering description: a Completion carries the attribute of its Request (PCIe r7.0 sec 2.2.9.1). - Used the PCIe terms Requester and Completer for TLPs, ACS and ports; client and provider remain for P2PDMA objects. - Rebased on pci/p2pdma, which includes the prerequisite P2PDMA fixes. - Added a topology example to the path divergence patch. - Removed a repeated sentence from the disable_acs_redir documentation. - Explained the path divergence in the documentation. - Link to v9: https://patch.msgid.link/20261001-fix-p2p-acs-v4-0-v9-0-1a8e0f50ddd9@nvidia… Changes in v9: - Removed dmabuf patches for now. - Removed mlx5 per-mapping ATS declaration for now; it comes back with the dmabuf patches. - Link to v8: https://patch.msgid.link/20260928-fix-p2p-acs-v4-0-v8-0-404453b9c435@nvidia… Changes in v8: - Added extra Reviewed-by from Logan. - Added patches to take care of ATS per-device vs. per-mapping option - Link to v7: https://patch.msgid.link/20260920-fix-p2p-acs-v4-0-v7-0-ca0828ab697c@nvidia… Changes in v7: - Removed "Document pdev->p2pdma lifetime rules" patch, it gives nothing after p2pmem fix. - Split dmabuf patch. - Tushar retested the series, so added his Tested-by. - Added Logan's ROB tags and fixed minor documentation issues pointed by him. - Link to v6: https://lore.kernel.org/all/20260914-fix-p2p-acs-v4-0-v6-0-5ef07ec9ef06@nvi… Changes in v6: - Changed DMABUF to use callbacks and not directly stored pointer. - Link to v5: https://patch.msgid.link/20260910-fix-p2p-acs-v4-0-v5-0-856087f63c0d@nvidia… Changes in v5: - Rebase on the posted fixes. - Dropped tags from changed patches. - Remove Egress Control Vector interpretation and coverage. - Keep enabled Egress Control conservative as a Request redirect. - Use pci_dbg()/dev_dbg() for diagnostics and drop the "debug" prefix. - Removed code comments from "Document the pdev->p2pdma lifetime and RCU rules" patch and reduced description to actual lifetime explanation. - Added note that Linux assumes that TLPs are in strict-ordering and untranslated. - Added code to calculate p2p paths per-TLP type. - Converted mlx5 to use that new proposed API. - Link to https://patch.msgid.link/20260821-fix-p2p-acs-v4-0-v4-0-94426b96de73@nvidia… Changes in v4: - Reject ACS Violations and unreadable routing state instead of treating them as host-bridge redirects - Added Tested-by tags from Tushar Dave - Added support to asymmetric ACS routing - Limited redirect checks to the two ports at the path divergence - Added standalone ACS routing diagnostics for hardware retesting - Dropped " PCI: Account for Direct Translated P2P in ACS isolation checks" patch - Link to v3: https://patch.msgid.link/20260811-fix-p2p-acs-v3-0-efc488ee7c03@nvidia.com Changes in v3: - Fixed pci_p2pdma_add_resource() error unwinding - Made pdev->p2pdma teardown wait unconditionally for RCU readers - Restricted pci_p2pmem_find_many() to pool-backed providers - Documented the pdev->p2pdma lifetime and RCU rules - Fixed calc_map_type_and_dist() handling of the verbose argument - Required the ACS port and target to share a bus before indexing the Egress Control Vector - Gave pci_acs_enabled() and pci_acs_path_enabled() a scope, so the ACS Direct Translated P2P rule no longer stops pci_enable_pasid() from enabling PASID - Dropped "Report ACS ports when the paths share no upstream bridge": the mapping type cannot change without a shared upstream bridge, so the pci=disable_acs_redir= hint was not actionable there and the ACS walk only cost config space reads - Folded the Request Redirect rule into pci_acs_rr_ineffective(), so pci_acs_flags_enabled() and the Intel SPT PCH quirk share one copy - Renamed pci_acs_egress_ctrl_set() to pci_acs_egress_ctrl_is_set(), it reads the bit rather than setting it - Reworded the blocked-path warning: ACS may also leave the direct route indeterminate rather than blocked - Added KUnit coverage for the shared-bus guard, a device with no ACS capability and an unreadable ACS Control register - Added the missing Fixes: tags, a second one on the pci_p2pdma_add_resource() unwinding fix (the dangling devres action dates to f58ef9d1d135) and one on the Egress Control isolation change - Link to v2: https://patch.msgid.link/20260806-fix-p2p-acs-v2-0-0cec14812965@nvidia.com Changes in v2: - Added Logan's ROB tags - Added commas in Documentation patch - Link to v1: https://patch.msgid.link/20260802-fix-p2p-acs-v1-0-a7c5eb64fff6@nvidia.com --- Leon Romanovsky (19): PCI/P2PDMA: Honor device-specific ACS redirection PCI/P2PDMA: Document the TLP attribute assumptions PCI/P2PDMA: Derive routing from directional ACS controls PCI: Reject unreadable ACS controls in isolation checks PCI/P2PDMA: Evaluate ACS controls at the path divergence PCI/P2PDMA: Document directional ACS routing PCI/P2PDMA: Collect the path's ACS controls before deciding PCI/P2PDMA: Answer routing per TLP class PCI/P2PDMA: Route Relaxed Ordering Completions directly PCI/P2PDMA: Reject Translated Requests blocked by Translation Blocking PCI/P2PDMA: Route Translated Requests under Direct Translated P2P PCI/P2PDMA: Log detailed ACS routing diagnostics PCI/P2PDMA: Add KUnit tests for the ACS routing decisions PCI/P2PDMA: Test the ACS P2P routing walk PCI: Add KUnit coverage for ACS isolation checks PCI/P2PDMA: Document TLP-class routing PCI/P2PDMA: Let a client declare that it selects ATS per mapping PCI/P2PDMA: Evaluate the ATS path for clients with ATS enabled PCI/P2PDMA: Test the routing of clients with ATS enabled Documentation/admin-guide/kernel-parameters.txt | 11 +- Documentation/driver-api/pci/p2pdma.rst | 106 ++ drivers/pci/Kconfig | 15 + drivers/pci/Makefile | 1 + drivers/pci/p2pdma.c | 961 ++++++++++++++-- drivers/pci/pci.c | 8 +- drivers/pci/pci.h | 63 + drivers/pci/pci_acs_test.c | 1409 +++++++++++++++++++++++ drivers/pci/quirks.c | 23 +- include/linux/pci-p2pdma.h | 12 +- 10 files changed, 2517 insertions(+), 92 deletions(-) --- base-commit: 6628e7d4c6b25c8d18f1345e3a20d21829aae7e4 change-id: 20260821-fix-p2p-acs-v4-0-e72455e3a261 Best regards, -- Leon Romanovsky <leonro(a)nvidia.com>

2 days, 10 hours

Re: [PATCH v2 01/23] treewide: Rename dma_buf_(un)map_attachment() to dma_buf_(un)map_sgt()

by Christian König

On 11/5/26 07:40, Alistair Popple wrote: > From: Jason Gunthorpe <jgg(a)nvidia.com> > > These map and unmap functions only work with SGT importers. Rename them, > and their _unlocked variants, so the scatterlist based interface is > clearly named as such before further mapping types are added. > > Signed-off-by: Jason Gunthorpe <jgg(a)nvidia.com> > Signed-off-by: Alistair Popple <apopple(a)nvidia.com> Acked-by: Christian König <christian.koenig(a)amd.com> If nobody objects by the end of the week I'm going to push this to drm-misc-next. Regards, Christian. > --- > drivers/accel/amdxdna/amdxdna_gem.c | 6 +-- > drivers/accel/ivpu/ivpu_gem.c | 6 +-- > drivers/accel/qaic/qaic_data.c | 6 +-- > drivers/dma-buf/dma-buf.c | 54 +++++++++++----------- > drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 4 +- > drivers/gpu/drm/armada/armada_gem.c | 16 +++---- > drivers/gpu/drm/drm_prime.c | 6 +-- > drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c | 8 ++-- > drivers/gpu/drm/i915/gem/i915_gem_object.c | 2 +- > .../gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c | 4 +- > drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c | 4 +- > drivers/gpu/drm/tegra/gem.c | 14 +++--- > drivers/gpu/drm/virtio/virtgpu_prime.c | 8 ++-- > drivers/gpu/drm/xe/xe_bo.c | 16 +++---- > drivers/iio/industrialio-buffer.c | 6 +-- > drivers/infiniband/core/umem_dmabuf.c | 8 ++-- > drivers/media/common/videobuf2/videobuf2-core.c | 2 +- > .../media/common/videobuf2/videobuf2-dma-contig.c | 8 ++-- > drivers/media/common/videobuf2/videobuf2-dma-sg.c | 4 +- > .../media/platform/nvidia/tegra-vde/dmabuf-cache.c | 6 +-- > drivers/misc/fastrpc.c | 6 +-- > drivers/nvme/host/pci-dmabuf.c | 6 +-- > drivers/usb/gadget/function/f_fs.c | 4 +- > drivers/xen/gntdev-dmabuf.c | 8 ++-- > include/linux/dma-buf.h | 26 +++++------ > io_uring/zcrx.c | 6 +-- > net/core/devmem.c | 8 ++-- > 27 files changed, 126 insertions(+), 126 deletions(-) > > diff --git a/drivers/accel/amdxdna/amdxdna_gem.c b/drivers/accel/amdxdna/amdxdna_gem.c > index f14484bc31ec..adee6e806eed 100644 > --- a/drivers/accel/amdxdna/amdxdna_gem.c > +++ b/drivers/accel/amdxdna/amdxdna_gem.c > @@ -701,7 +701,7 @@ static struct dma_buf *amdxdna_gem_prime_export(struct drm_gem_object *gobj, int > > static void amdxdna_imported_obj_free(struct amdxdna_gem_obj *abo) > { > - dma_buf_unmap_attachment_unlocked(abo->attach, abo->base.sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(abo->attach, abo->base.sgt, DMA_BIDIRECTIONAL); > dma_buf_detach(abo->dma_buf, abo->attach); > dma_buf_put(abo->dma_buf); > drm_gem_object_release(to_gobj(abo)); > @@ -1075,7 +1075,7 @@ amdxdna_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf) > goto put_buf; > } > > - sgt = dma_buf_map_attachment_unlocked(attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt_unlocked(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) { > ret = PTR_ERR(sgt); > goto fail_detach; > @@ -1096,7 +1096,7 @@ amdxdna_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf) > return gobj; > > fail_unmap: > - dma_buf_unmap_attachment_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > fail_detach: > dma_buf_detach(dma_buf, attach); > put_buf: > diff --git a/drivers/accel/ivpu/ivpu_gem.c b/drivers/accel/ivpu/ivpu_gem.c > index c521a53f89bb..276f2a04aeda 100644 > --- a/drivers/accel/ivpu/ivpu_gem.c > +++ b/drivers/accel/ivpu/ivpu_gem.c > @@ -54,7 +54,7 @@ static struct sg_table *ivpu_bo_map_attachment(struct ivpu_device *vdev, struct > > sgt = bo->base.sgt; > if (!sgt) { > - sgt = dma_buf_map_attachment(bo->base.base.import_attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt(bo->base.base.import_attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) > ivpu_err(vdev, "Failed to map BO in IOMMU: %ld\n", PTR_ERR(sgt)); > else > @@ -158,8 +158,8 @@ static void ivpu_bo_unbind_locked(struct ivpu_bo *bo) > > if (bo->base.sgt) { > if (drm_gem_is_imported(&bo->base.base)) { > - dma_buf_unmap_attachment(bo->base.base.import_attach, > - bo->base.sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(bo->base.base.import_attach, > + bo->base.sgt, DMA_BIDIRECTIONAL); > } else { > dma_unmap_sgtable(vdev->drm.dev, bo->base.sgt, DMA_BIDIRECTIONAL, 0); > sg_free_table(bo->base.sgt); > diff --git a/drivers/accel/qaic/qaic_data.c b/drivers/accel/qaic/qaic_data.c > index ee35e13091b3..d65578f0368e 100644 > --- a/drivers/accel/qaic/qaic_data.c > +++ b/drivers/accel/qaic/qaic_data.c > @@ -869,7 +869,7 @@ struct drm_gem_object *qaic_gem_prime_import(struct drm_device *dev, struct dma_ > > drm_gem_private_object_init(dev, obj, attach->dmabuf->size); > /* > - * skipping dma_buf_map_attachment() as we do not know the direction > + * skipping dma_buf_map_sgt() as we do not know the direction > * just yet. Once the direction is known in the subsequent IOCTL to > * attach slicing, we can do it then. > */ > @@ -895,7 +895,7 @@ static int qaic_prepare_import_bo(struct qaic_bo *bo, struct qaic_attach_slice_h > struct sg_table *sgt; > int ret; > > - sgt = dma_buf_map_attachment(obj->import_attach, hdr->dir); > + sgt = dma_buf_map_sgt(obj->import_attach, hdr->dir); > if (IS_ERR(sgt)) { > ret = PTR_ERR(sgt); > return ret; > @@ -936,7 +936,7 @@ static int qaic_prepare_bo(struct qaic_device *qdev, struct qaic_bo *bo, > > static void qaic_unprepare_import_bo(struct qaic_bo *bo) > { > - dma_buf_unmap_attachment(bo->base.import_attach, bo->sgt, bo->dir); > + dma_buf_unmap_sgt(bo->base.import_attach, bo->sgt, bo->dir); > bo->sgt = NULL; > } > > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index 36cdc342627e..0dd8d0999a92 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -677,7 +677,7 @@ static struct file *dma_buf_getfile(size_t size, int flags) > * > * 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(). > + * dma_buf_map_sgt() and dma_buf_unmap_sgt(). > * > * 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 > @@ -955,8 +955,8 @@ dma_buf_pin_on_map(struct dma_buf_attachment *attach) > * > * - dma_buf_pin() > * - dma_buf_unpin() > - * - dma_buf_map_attachment() > - * - dma_buf_unmap_attachment() > + * - dma_buf_map_sgt() > + * - dma_buf_unmap_sgt() > * - dma_buf_vmap() > * - dma_buf_vunmap() > * > @@ -973,8 +973,8 @@ dma_buf_pin_on_map(struct dma_buf_attachment *attach) > * - dma_buf_mmap() > * - dma_buf_begin_cpu_access() > * - dma_buf_end_cpu_access() > - * - dma_buf_map_attachment_unlocked() > - * - dma_buf_unmap_attachment_unlocked() > + * - dma_buf_map_sgt_unlocked() > + * - dma_buf_unmap_sgt_unlocked() > * - dma_buf_vmap_unlocked() > * - dma_buf_vunmap_unlocked() > * > @@ -1165,7 +1165,7 @@ void dma_buf_unpin(struct dma_buf_attachment *attach) > EXPORT_SYMBOL_NS_GPL(dma_buf_unpin, "DMA_BUF"); > > /** > - * dma_buf_map_attachment - Returns the scatterlist table of the attachment; > + * dma_buf_map_sgt - 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 > @@ -1177,7 +1177,7 @@ EXPORT_SYMBOL_NS_GPL(dma_buf_unpin, "DMA_BUF"); > * 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 > + * A mapping must be unmapped by using dma_buf_unmap_sgt(). 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. > @@ -1185,8 +1185,8 @@ EXPORT_SYMBOL_NS_GPL(dma_buf_unpin, "DMA_BUF"); > * 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 *dma_buf_map_sgt(struct dma_buf_attachment *attach, > + enum dma_data_direction direction) > { > struct sg_table *sg_table; > signed long ret; > @@ -1257,20 +1257,20 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, > > return sg_table; > } > -EXPORT_SYMBOL_NS_GPL(dma_buf_map_attachment, "DMA_BUF"); > +EXPORT_SYMBOL_NS_GPL(dma_buf_map_sgt, "DMA_BUF"); > > /** > - * dma_buf_map_attachment_unlocked - Returns the scatterlist table of the attachment; > + * dma_buf_map_sgt_unlocked - 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 > * > - * Unlocked variant of dma_buf_map_attachment(). > + * Unlocked variant of dma_buf_map_sgt(). > */ > struct sg_table * > -dma_buf_map_attachment_unlocked(struct dma_buf_attachment *attach, > - enum dma_data_direction direction) > +dma_buf_map_sgt_unlocked(struct dma_buf_attachment *attach, > + enum dma_data_direction direction) > { > struct sg_table *sg_table; > > @@ -1280,24 +1280,24 @@ dma_buf_map_attachment_unlocked(struct dma_buf_attachment *attach, > return ERR_PTR(-EINVAL); > > dma_resv_lock(attach->dmabuf->resv, NULL); > - sg_table = dma_buf_map_attachment(attach, direction); > + sg_table = dma_buf_map_sgt(attach, direction); > dma_resv_unlock(attach->dmabuf->resv); > > return sg_table; > } > -EXPORT_SYMBOL_NS_GPL(dma_buf_map_attachment_unlocked, "DMA_BUF"); > +EXPORT_SYMBOL_NS_GPL(dma_buf_map_sgt_unlocked, "DMA_BUF"); > > /** > - * dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might > + * dma_buf_unmap_sgt - 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(). > + * This unmaps a DMA mapping for @attached obtained by dma_buf_map_sgt(). > */ > -void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, > +void dma_buf_unmap_sgt(struct dma_buf_attachment *attach, > struct sg_table *sg_table, > enum dma_data_direction direction) > { > @@ -1314,21 +1314,21 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, > if (dma_buf_pin_on_map(attach)) > attach->dmabuf->ops->unpin(attach); > } > -EXPORT_SYMBOL_NS_GPL(dma_buf_unmap_attachment, "DMA_BUF"); > +EXPORT_SYMBOL_NS_GPL(dma_buf_unmap_sgt, "DMA_BUF"); > > /** > - * dma_buf_unmap_attachment_unlocked - unmaps and decreases usecount of the buffer;might > + * dma_buf_unmap_sgt_unlocked - 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 > * > - * Unlocked variant of dma_buf_unmap_attachment(). > + * Unlocked variant of dma_buf_unmap_sgt(). > */ > -void dma_buf_unmap_attachment_unlocked(struct dma_buf_attachment *attach, > - struct sg_table *sg_table, > - enum dma_data_direction direction) > +void dma_buf_unmap_sgt_unlocked(struct dma_buf_attachment *attach, > + struct sg_table *sg_table, > + enum dma_data_direction direction) > { > might_sleep(); > > @@ -1336,10 +1336,10 @@ void dma_buf_unmap_attachment_unlocked(struct dma_buf_attachment *attach, > return; > > dma_resv_lock(attach->dmabuf->resv, NULL); > - dma_buf_unmap_attachment(attach, sg_table, direction); > + dma_buf_unmap_sgt(attach, sg_table, direction); > dma_resv_unlock(attach->dmabuf->resv); > } > -EXPORT_SYMBOL_NS_GPL(dma_buf_unmap_attachment_unlocked, "DMA_BUF"); > +EXPORT_SYMBOL_NS_GPL(dma_buf_unmap_sgt_unlocked, "DMA_BUF"); > > /** > * dma_buf_attach_revocable - check if a DMA-buf importer implements > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > index 0f86777250fc..30ec5cb9ddf5 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > @@ -962,7 +962,7 @@ static int amdgpu_ttm_backend_bind(struct ttm_device *bdev, > struct sg_table *sgt; > > attach = gtt->gobj->import_attach; > - sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) > return PTR_ERR(sgt); > > @@ -1083,7 +1083,7 @@ static void amdgpu_ttm_backend_unbind(struct ttm_device *bdev, > struct dma_buf_attachment *attach; > > attach = gtt->gobj->import_attach; > - dma_buf_unmap_attachment(attach, ttm->sg, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(attach, ttm->sg, DMA_BIDIRECTIONAL); > ttm->sg = NULL; > } > > diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c > index da7335cbe82d..044acdef6351 100644 > --- a/drivers/gpu/drm/armada/armada_gem.c > +++ b/drivers/gpu/drm/armada/armada_gem.c > @@ -67,8 +67,8 @@ void armada_gem_free_object(struct drm_gem_object *obj) > if (dobj->obj.import_attach) { > /* We only ever display imported data */ > if (dobj->sgt) > - dma_buf_unmap_attachment_unlocked(dobj->obj.import_attach, > - dobj->sgt, DMA_TO_DEVICE); > + dma_buf_unmap_sgt_unlocked(dobj->obj.import_attach, > + dobj->sgt, DMA_TO_DEVICE); > drm_prime_gem_destroy(&dobj->obj, NULL); > } > > @@ -529,7 +529,7 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) > get_dma_buf(buf); > > /* > - * Don't call dma_buf_map_attachment() here - it maps the > + * Don't call dma_buf_map_sgt() here - it maps the > * scatterlist immediately for DMA, and this is not always > * an appropriate thing to do. > */ > @@ -540,20 +540,20 @@ int armada_gem_map_import(struct armada_gem_object *dobj) > { > int ret; > > - dobj->sgt = dma_buf_map_attachment_unlocked(dobj->obj.import_attach, > - DMA_TO_DEVICE); > + dobj->sgt = dma_buf_map_sgt_unlocked(dobj->obj.import_attach, > + DMA_TO_DEVICE); > if (IS_ERR(dobj->sgt)) { > ret = PTR_ERR(dobj->sgt); > dobj->sgt = NULL; > - DRM_ERROR("dma_buf_map_attachment() error: %d\n", ret); > + DRM_ERROR("dma_buf_map_sgt() error: %d\n", ret); > return ret; > } > if (dobj->sgt->nents > 1) { > - DRM_ERROR("dma_buf_map_attachment() returned an (unsupported) scattered list\n"); > + DRM_ERROR("dma_buf_map_sgt() returned an (unsupported) scattered list\n"); > return -EINVAL; > } > if (sg_dma_len(dobj->sgt->sgl) < dobj->obj.size) { > - DRM_ERROR("dma_buf_map_attachment() returned a small buffer\n"); > + DRM_ERROR("dma_buf_map_sgt() returned a small buffer\n"); > return -EINVAL; > } > dobj->dev_addr = sg_dma_address(dobj->sgt->sgl); > diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c > index fe3436d1235d..e27bda3423ed 100644 > --- a/drivers/gpu/drm/drm_prime.c > +++ b/drivers/gpu/drm/drm_prime.c > @@ -993,7 +993,7 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > > get_dma_buf(dma_buf); > > - sgt = dma_buf_map_attachment_unlocked(attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt_unlocked(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) { > ret = PTR_ERR(sgt); > goto fail_detach; > @@ -1011,7 +1011,7 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, > return obj; > > fail_unmap: > - dma_buf_unmap_attachment_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > fail_detach: > dma_buf_detach(dma_buf, attach); > dma_buf_put(dma_buf); > @@ -1109,7 +1109,7 @@ void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg) > > attach = obj->import_attach; > if (sg) > - dma_buf_unmap_attachment_unlocked(attach, sg, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(attach, sg, DMA_BIDIRECTIONAL); > dma_buf = attach->dmabuf; > dma_buf_detach(attach->dmabuf, attach); > /* remove the reference */ > diff --git a/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c > index b43d34c7d641..4ab54d2e616f 100644 > --- a/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c > @@ -240,8 +240,8 @@ static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj) > > assert_object_held(obj); > > - sgt = dma_buf_map_attachment(obj->base.import_attach, > - DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt(obj->base.import_attach, > + DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) > return PTR_ERR(sgt); > > @@ -268,8 +268,8 @@ static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj) > static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj, > struct sg_table *sgt) > { > - dma_buf_unmap_attachment(obj->base.import_attach, sgt, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(obj->base.import_attach, sgt, > + DMA_BIDIRECTIONAL); > } > > static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = { > diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c > index 9e01f8b2079a..1e0aafc3643b 100644 > --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c > +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c > @@ -367,7 +367,7 @@ void __i915_gem_object_pages_fini(struct drm_i915_gem_object *obj) > atomic_set(&obj->mm.pages_pin_count, 0); > > /* > - * dma_buf_unmap_attachment() requires reservation to be > + * dma_buf_unmap_sgt() requires reservation to be > * locked. The imported GEM shouldn't share reservation lock > * and ttm_bo_cleanup_memtype_use() shouldn't be invoked for > * dma-buf, so it's safe to take the lock. > diff --git a/drivers/gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c > index 2fda549dd82d..af9ced05f7a8 100644 > --- a/drivers/gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c > +++ b/drivers/gpu/drm/i915/gem/selftests/i915_gem_dmabuf.c > @@ -293,7 +293,7 @@ static int igt_dmabuf_import_same_driver(struct drm_i915_private *i915, > goto out_import; > } > > - st = dma_buf_map_attachment_unlocked(import_attach, DMA_BIDIRECTIONAL); > + st = dma_buf_map_sgt_unlocked(import_attach, DMA_BIDIRECTIONAL); > if (IS_ERR(st)) { > err = PTR_ERR(st); > goto out_detach; > @@ -306,7 +306,7 @@ static int igt_dmabuf_import_same_driver(struct drm_i915_private *i915, > timeout = -ETIME; > } > err = timeout > 0 ? 0 : timeout; > - dma_buf_unmap_attachment_unlocked(import_attach, st, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(import_attach, st, DMA_BIDIRECTIONAL); > out_detach: > dma_buf_detach(dmabuf, import_attach); > out_import: > diff --git a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > index 30cf1cdc1aa3..afae0a56da8c 100644 > --- a/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > +++ b/drivers/gpu/drm/omapdrm/omap_gem_dmabuf.c > @@ -120,7 +120,7 @@ struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > > get_dma_buf(dma_buf); > > - sgt = dma_buf_map_attachment_unlocked(attach, DMA_TO_DEVICE); > + sgt = dma_buf_map_sgt_unlocked(attach, DMA_TO_DEVICE); > if (IS_ERR(sgt)) { > ret = PTR_ERR(sgt); > goto fail_detach; > @@ -137,7 +137,7 @@ struct drm_gem_object *omap_gem_prime_import(struct drm_device *dev, > return obj; > > fail_unmap: > - dma_buf_unmap_attachment_unlocked(attach, sgt, DMA_TO_DEVICE); > + dma_buf_unmap_sgt_unlocked(attach, sgt, DMA_TO_DEVICE); > fail_detach: > dma_buf_detach(dma_buf, attach); > dma_buf_put(dma_buf); > diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c > index f76af733ea79..e6aa6dae4ec8 100644 > --- a/drivers/gpu/drm/tegra/gem.c > +++ b/drivers/gpu/drm/tegra/gem.c > @@ -86,7 +86,7 @@ static struct host1x_bo_mapping *tegra_bo_pin(struct device *dev, struct host1x_ > goto free; > } > > - map->sgt = dma_buf_map_attachment_unlocked(map->attach, direction); > + map->sgt = dma_buf_map_sgt_unlocked(map->attach, direction); > if (IS_ERR(map->sgt)) { > dma_buf_detach(buf, map->attach); > err = PTR_ERR(map->sgt); > @@ -162,8 +162,8 @@ static struct host1x_bo_mapping *tegra_bo_pin(struct device *dev, struct host1x_ > static void tegra_bo_unpin(struct host1x_bo_mapping *map) > { > if (map->attach) { > - dma_buf_unmap_attachment_unlocked(map->attach, map->sgt, > - map->direction); > + dma_buf_unmap_sgt_unlocked(map->attach, map->sgt, > + map->direction); > dma_buf_detach(map->attach->dmabuf, map->attach); > } else { > dma_unmap_sgtable(map->dev, map->sgt, map->direction, 0); > @@ -479,7 +479,7 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > goto free; > } > > - bo->sgt = dma_buf_map_attachment_unlocked(attach, DMA_TO_DEVICE); > + bo->sgt = dma_buf_map_sgt_unlocked(attach, DMA_TO_DEVICE); > if (IS_ERR(bo->sgt)) { > err = PTR_ERR(bo->sgt); > goto detach; > @@ -499,7 +499,7 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm, > > detach: > if (!IS_ERR_OR_NULL(bo->sgt)) > - dma_buf_unmap_attachment_unlocked(attach, bo->sgt, DMA_TO_DEVICE); > + dma_buf_unmap_sgt_unlocked(attach, bo->sgt, DMA_TO_DEVICE); > > dma_buf_detach(buf, attach); > dma_buf_put(buf); > @@ -520,8 +520,8 @@ void tegra_bo_free_object(struct drm_gem_object *gem) > tegra_bo_iommu_unmap(tegra, bo); > > if (drm_gem_is_imported(gem)) { > - dma_buf_unmap_attachment_unlocked(gem->import_attach, bo->sgt, > - DMA_TO_DEVICE); > + dma_buf_unmap_sgt_unlocked(gem->import_attach, bo->sgt, > + DMA_TO_DEVICE); > dma_buf_detach(gem->import_attach->dmabuf, gem->import_attach); > } > } > diff --git a/drivers/gpu/drm/virtio/virtgpu_prime.c b/drivers/gpu/drm/virtio/virtgpu_prime.c > index ebf471044d06..a47783b47dcc 100644 > --- a/drivers/gpu/drm/virtio/virtgpu_prime.c > +++ b/drivers/gpu/drm/virtio/virtgpu_prime.c > @@ -161,13 +161,13 @@ int virtgpu_dma_buf_import_sgt(struct virtio_gpu_mem_entry **ents, > if (ret <= 0) > return ret < 0 ? ret : -ETIMEDOUT; > > - sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) > return PTR_ERR(sgt); > > *ents = kvmalloc_objs(struct virtio_gpu_mem_entry, sgt->nents); > if (!(*ents)) { > - dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(attach, sgt, DMA_BIDIRECTIONAL); > return -ENOMEM; > } > > @@ -192,8 +192,8 @@ static void virtgpu_dma_buf_unmap(struct virtio_gpu_object *bo) > virtio_gpu_detach_object_fenced(bo); > > if (bo->sgt) > - dma_buf_unmap_attachment(attach, bo->sgt, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(attach, bo->sgt, > + DMA_BIDIRECTIONAL); > > bo->sgt = NULL; > } > diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c > index 12e523c61c1f..14b71d951659 100644 > --- a/drivers/gpu/drm/xe/xe_bo.c > +++ b/drivers/gpu/drm/xe/xe_bo.c > @@ -869,7 +869,7 @@ static int xe_bo_move_dmabuf(struct ttm_buffer_object *ttm_bo, > ttm_bo->sg) { > dma_resv_wait_timeout(ttm_bo->base.resv, DMA_RESV_USAGE_BOOKKEEP, > false, MAX_SCHEDULE_TIMEOUT); > - dma_buf_unmap_attachment(attach, ttm_bo->sg, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(attach, ttm_bo->sg, DMA_BIDIRECTIONAL); > ttm_bo->sg = NULL; > } > > @@ -877,11 +877,11 @@ static int xe_bo_move_dmabuf(struct ttm_buffer_object *ttm_bo, > goto out; > > if (ttm_bo->sg) { > - dma_buf_unmap_attachment(attach, ttm_bo->sg, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(attach, ttm_bo->sg, DMA_BIDIRECTIONAL); > ttm_bo->sg = NULL; > } > > - sg = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); > + sg = dma_buf_map_sgt(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sg)) > return PTR_ERR(sg); > > @@ -1750,9 +1750,9 @@ int xe_bo_dma_unmap_pinned(struct xe_bo *bo) > struct xe_ttm_tt *xe_tt = container_of(tt, typeof(*xe_tt), ttm); > > if (ttm_bo->type == ttm_bo_type_sg && ttm_bo->sg) { > - dma_buf_unmap_attachment(ttm_bo->base.import_attach, > - ttm_bo->sg, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(ttm_bo->base.import_attach, > + ttm_bo->sg, > + DMA_BIDIRECTIONAL); > ttm_bo->sg = NULL; > xe_tt->sg = NULL; > } else if (xe_tt->sg) { > @@ -1867,8 +1867,8 @@ static void xe_ttm_bo_delete_mem_notify(struct ttm_buffer_object *ttm_bo) > struct xe_ttm_tt *xe_tt = container_of(ttm_bo->ttm, > struct xe_ttm_tt, ttm); > > - dma_buf_unmap_attachment(ttm_bo->base.import_attach, ttm_bo->sg, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(ttm_bo->base.import_attach, ttm_bo->sg, > + DMA_BIDIRECTIONAL); > ttm_bo->sg = NULL; > xe_tt->sg = NULL; > } > diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c > index 4294101810fd..4a1063e4891f 100644 > --- a/drivers/iio/industrialio-buffer.c > +++ b/drivers/iio/industrialio-buffer.c > @@ -1593,7 +1593,7 @@ static void iio_buffer_dmabuf_release(struct kref *ref) > struct iio_buffer *buffer = priv->buffer; > struct dma_buf *dmabuf = attach->dmabuf; > > - dma_buf_unmap_attachment_unlocked(attach, priv->sgt, priv->dir); > + dma_buf_unmap_sgt_unlocked(attach, priv->sgt, priv->dir); > > buffer->access->detach_dmabuf(buffer, priv->block); > > @@ -1733,7 +1733,7 @@ static int iio_buffer_attach_dmabuf(struct iio_dev_buffer_pair *ib, > priv->dir = buffer->direction == IIO_BUFFER_DIRECTION_IN > ? DMA_FROM_DEVICE : DMA_TO_DEVICE; > > - priv->sgt = dma_buf_map_attachment(attach, priv->dir); > + priv->sgt = dma_buf_map_sgt(attach, priv->dir); > if (IS_ERR(priv->sgt)) { > err = PTR_ERR(priv->sgt); > dev_err(&indio_dev->dev, "Unable to map attachment: %d\n", err); > @@ -1781,7 +1781,7 @@ static int iio_buffer_attach_dmabuf(struct iio_dev_buffer_pair *ib, > return 0; > > err_dmabuf_unmap_attachment: > - dma_buf_unmap_attachment(attach, priv->sgt, priv->dir); > + dma_buf_unmap_sgt(attach, priv->sgt, priv->dir); > err_resv_unlock: > dma_resv_unlock(dmabuf->resv); > err_dmabuf_detach: > diff --git a/drivers/infiniband/core/umem_dmabuf.c b/drivers/infiniband/core/umem_dmabuf.c > index 39b5564a4c35..f233fdac9a17 100644 > --- a/drivers/infiniband/core/umem_dmabuf.c > +++ b/drivers/infiniband/core/umem_dmabuf.c > @@ -29,8 +29,8 @@ int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf) > if (umem_dmabuf->sgt) > goto wait_fence; > > - sgt = dma_buf_map_attachment(umem_dmabuf->attach, > - DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt(umem_dmabuf->attach, > + DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) > return PTR_ERR(sgt); > > @@ -106,8 +106,8 @@ void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf) > umem_dmabuf->last_sg_trim = 0; > } > > - dma_buf_unmap_attachment(umem_dmabuf->attach, umem_dmabuf->sgt, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt(umem_dmabuf->attach, umem_dmabuf->sgt, > + DMA_BIDIRECTIONAL); > > umem_dmabuf->sgt = NULL; > } > diff --git a/drivers/media/common/videobuf2/videobuf2-core.c b/drivers/media/common/videobuf2/videobuf2-core.c > index b0a6084f1757..61a614074222 100644 > --- a/drivers/media/common/videobuf2/videobuf2-core.c > +++ b/drivers/media/common/videobuf2/videobuf2-core.c > @@ -1464,7 +1464,7 @@ static int __prepare_dmabuf(struct vb2_buffer *vb) > vb->planes[plane].mem_priv = mem_priv; > > /* > - * This pins the buffer(s) with dma_buf_map_attachment()). It's done > + * This pins the buffer(s) with dma_buf_map_sgt()). It's done > * here instead just before the DMA, while queueing the buffer(s) so > * userspace knows sooner rather than later if the dma-buf map fails. > */ > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-contig.c b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > index 9ce6284cd5f2..284482335c1a 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-contig.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-contig.c > @@ -705,7 +705,7 @@ static int vb2_dc_map_dmabuf(void *mem_priv) > } > > /* get the associated scatterlist for this buffer */ > - sgt = dma_buf_map_attachment_unlocked(buf->db_attach, buf->dma_dir); > + sgt = dma_buf_map_sgt_unlocked(buf->db_attach, buf->dma_dir); > if (IS_ERR(sgt)) { > pr_err("Error getting dmabuf scatterlist\n"); > return -EINVAL; > @@ -716,8 +716,8 @@ static int vb2_dc_map_dmabuf(void *mem_priv) > if (contig_size < buf->size) { > pr_err("contiguous chunk is too small %lu/%lu\n", > contig_size, buf->size); > - dma_buf_unmap_attachment_unlocked(buf->db_attach, sgt, > - buf->dma_dir); > + dma_buf_unmap_sgt_unlocked(buf->db_attach, sgt, > + buf->dma_dir); > return -EFAULT; > } > > @@ -748,7 +748,7 @@ static void vb2_dc_unmap_dmabuf(void *mem_priv) > dma_buf_vunmap_unlocked(buf->db_attach->dmabuf, &map); > buf->vaddr = NULL; > } > - dma_buf_unmap_attachment_unlocked(buf->db_attach, sgt, buf->dma_dir); > + dma_buf_unmap_sgt_unlocked(buf->db_attach, sgt, buf->dma_dir); > > buf->dma_addr = 0; > buf->dma_sgt = NULL; > diff --git a/drivers/media/common/videobuf2/videobuf2-dma-sg.c b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > index b1d0695cda26..54b07e3840ac 100644 > --- a/drivers/media/common/videobuf2/videobuf2-dma-sg.c > +++ b/drivers/media/common/videobuf2/videobuf2-dma-sg.c > @@ -565,7 +565,7 @@ static int vb2_dma_sg_map_dmabuf(void *mem_priv) > } > > /* get the associated scatterlist for this buffer */ > - sgt = dma_buf_map_attachment_unlocked(buf->db_attach, buf->dma_dir); > + sgt = dma_buf_map_sgt_unlocked(buf->db_attach, buf->dma_dir); > if (IS_ERR(sgt)) { > pr_err("Error getting dmabuf scatterlist\n"); > return -EINVAL; > @@ -597,7 +597,7 @@ static void vb2_dma_sg_unmap_dmabuf(void *mem_priv) > dma_buf_vunmap_unlocked(buf->db_attach->dmabuf, &map); > buf->vaddr = NULL; > } > - dma_buf_unmap_attachment_unlocked(buf->db_attach, sgt, buf->dma_dir); > + dma_buf_unmap_sgt_unlocked(buf->db_attach, sgt, buf->dma_dir); > > buf->dma_sgt = NULL; > } > diff --git a/drivers/media/platform/nvidia/tegra-vde/dmabuf-cache.c b/drivers/media/platform/nvidia/tegra-vde/dmabuf-cache.c > index 7752064be783..d9bac7cd855a 100644 > --- a/drivers/media/platform/nvidia/tegra-vde/dmabuf-cache.c > +++ b/drivers/media/platform/nvidia/tegra-vde/dmabuf-cache.c > @@ -38,7 +38,7 @@ static void tegra_vde_release_entry(struct tegra_vde_cache_entry *entry) > if (entry->vde->domain) > tegra_vde_iommu_unmap(entry->vde, entry->iova); > > - dma_buf_unmap_attachment_unlocked(entry->a, entry->sgt, entry->dma_dir); > + dma_buf_unmap_sgt_unlocked(entry->a, entry->sgt, entry->dma_dir); > dma_buf_detach(dmabuf, entry->a); > dma_buf_put(dmabuf); > > @@ -102,7 +102,7 @@ int tegra_vde_dmabuf_cache_map(struct tegra_vde *vde, > goto err_unlock; > } > > - sgt = dma_buf_map_attachment_unlocked(attachment, dma_dir); > + sgt = dma_buf_map_sgt_unlocked(attachment, dma_dir); > if (IS_ERR(sgt)) { > dev_err(dev, "Failed to get dmabufs sg_table\n"); > err = PTR_ERR(sgt); > @@ -152,7 +152,7 @@ int tegra_vde_dmabuf_cache_map(struct tegra_vde *vde, > err_free: > kfree(entry); > err_unmap: > - dma_buf_unmap_attachment_unlocked(attachment, sgt, dma_dir); > + dma_buf_unmap_sgt_unlocked(attachment, sgt, dma_dir); > err_detach: > dma_buf_detach(dmabuf, attachment); > err_unlock: > diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c > index af18ff1992ee..76c8dc05fa10 100644 > --- a/drivers/misc/fastrpc.c > +++ b/drivers/misc/fastrpc.c > @@ -401,8 +401,8 @@ static void fastrpc_free_map(struct kref *ref) > return; > } > } > - dma_buf_unmap_attachment_unlocked(map->attach, map->table, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(map->attach, map->table, > + DMA_BIDIRECTIONAL); > dma_buf_detach(map->buf, map->attach); > dma_buf_put(map->buf); > } > @@ -911,7 +911,7 @@ static int fastrpc_map_attach(struct fastrpc_user *fl, int fd, > goto attach_err; > } > > - table = dma_buf_map_attachment_unlocked(map->attach, DMA_BIDIRECTIONAL); > + table = dma_buf_map_sgt_unlocked(map->attach, DMA_BIDIRECTIONAL); > if (IS_ERR(table)) { > err = PTR_ERR(table); > goto map_err; > diff --git a/drivers/nvme/host/pci-dmabuf.c b/drivers/nvme/host/pci-dmabuf.c > index 161e4ffa6919..fe741dc0d54a 100644 > --- a/drivers/nvme/host/pci-dmabuf.c > +++ b/drivers/nvme/host/pci-dmabuf.c > @@ -41,7 +41,7 @@ static struct dma_buf_io_map *nvme_dma_buf_io_map(struct dma_buf_io_ctx *ctx) > return ERR_PTR(-ENOMEM); > map->nr_entries = nr_entries; > > - sgt = dma_buf_map_attachment(attach, ctx->dir); > + sgt = dma_buf_map_sgt(attach, ctx->dir); > if (IS_ERR(sgt)) { > ret = PTR_ERR(sgt); > sgt = NULL; > @@ -71,7 +71,7 @@ static struct dma_buf_io_map *nvme_dma_buf_io_map(struct dma_buf_io_ctx *ctx) > return &map->base; > err: > if (sgt) > - dma_buf_unmap_attachment(attach, sgt, ctx->dir); > + dma_buf_unmap_sgt(attach, sgt, ctx->dir); > kvfree(map); > return ERR_PTR(ret); > } > @@ -84,7 +84,7 @@ static void nvme_dma_buf_io_unmap(struct dma_buf_io_ctx *ctx, > > dma_resv_assert_held(ctx->dmabuf->resv); > > - dma_buf_unmap_attachment(nvme_ctx->attach, map->sgt, ctx->dir); > + dma_buf_unmap_sgt(nvme_ctx->attach, map->sgt, ctx->dir); > kvfree(map); > } > > diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c > index c64a268e98a4..2f221d0a983f 100644 > --- a/drivers/usb/gadget/function/f_fs.c > +++ b/drivers/usb/gadget/function/f_fs.c > @@ -1365,7 +1365,7 @@ static void ffs_dmabuf_release(struct kref *ref) > struct dma_buf *dmabuf = attach->dmabuf; > > pr_vdebug("FFS DMABUF release\n"); > - dma_buf_unmap_attachment_unlocked(attach, priv->sgt, priv->dir); > + dma_buf_unmap_sgt_unlocked(attach, priv->sgt, priv->dir); > > dma_buf_detach(attach->dmabuf, attach); > dma_buf_put(dmabuf); > @@ -1566,7 +1566,7 @@ static int ffs_dmabuf_attach(struct file *file, int fd) > if (err) > goto err_free_priv; > > - sg_table = dma_buf_map_attachment(attach, dir); > + sg_table = dma_buf_map_sgt(attach, dir); > dma_resv_unlock(dmabuf->resv); > > if (IS_ERR(sg_table)) { > diff --git a/drivers/xen/gntdev-dmabuf.c b/drivers/xen/gntdev-dmabuf.c > index df1883aca850..e07e34515421 100644 > --- a/drivers/xen/gntdev-dmabuf.c > +++ b/drivers/xen/gntdev-dmabuf.c > @@ -587,7 +587,7 @@ dmabuf_imp_to_refs(struct gntdev_dmabuf_priv *priv, struct device *dev, > > gntdev_dmabuf->u.imp.attach = attach; > > - sgt = dma_buf_map_attachment_unlocked(attach, DMA_BIDIRECTIONAL); > + sgt = dma_buf_map_sgt_unlocked(attach, DMA_BIDIRECTIONAL); > if (IS_ERR(sgt)) { > ret = ERR_CAST(sgt); > goto fail_detach; > @@ -650,7 +650,7 @@ dmabuf_imp_to_refs(struct gntdev_dmabuf_priv *priv, struct device *dev, > fail_end_access: > dmabuf_imp_end_foreign_access(gntdev_dmabuf->u.imp.refs, count); > fail_unmap: > - dma_buf_unmap_attachment_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(attach, sgt, DMA_BIDIRECTIONAL); > fail_detach: > dma_buf_detach(dma_buf, attach); > fail_free_obj: > @@ -700,8 +700,8 @@ static int dmabuf_imp_release(struct gntdev_dmabuf_priv *priv, u32 fd) > attach = gntdev_dmabuf->u.imp.attach; > > if (gntdev_dmabuf->u.imp.sgt) > - dma_buf_unmap_attachment_unlocked(attach, gntdev_dmabuf->u.imp.sgt, > - DMA_BIDIRECTIONAL); > + dma_buf_unmap_sgt_unlocked(attach, gntdev_dmabuf->u.imp.sgt, > + DMA_BIDIRECTIONAL); > dma_buf = attach->dmabuf; > dma_buf_detach(attach->dmabuf, attach); > dma_buf_put(dma_buf); > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index d15b2b31d3c9..cedeb8ebc99e 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -116,7 +116,7 @@ struct dma_buf_ops { > /** > * @map_dma_buf: > * > - * This is called by dma_buf_map_attachment() and is used to map a > + * This is called by dma_buf_map_sgt() and is used to map a > * shared &dma_buf into device address space, and it is mandatory. It > * can only be called if @attach has been called successfully. > * > @@ -173,7 +173,7 @@ struct dma_buf_ops { > /** > * @unmap_dma_buf: > * > - * This is called by dma_buf_unmap_attachment() and should unmap and > + * This is called by dma_buf_unmap_sgt() and should unmap and > * release the &sg_table allocated in @map_dma_buf, and it is mandatory. > * For static dma_buf handling this might also unpin the backing > * storage if this is the last mapping of the DMA buffer. > @@ -470,7 +470,7 @@ struct dma_buf_attach_ops { > * @peer2peer: true if the importer can handle peer resources without pages. > * @priv: exporter specific attachment data. > * @importer_ops: importer operations for this attachment, if provided > - * dma_buf_map/unmap_attachment() must be called with the dma_resv lock held. > + * dma_buf_map/unmap_sgt() must be called with the dma_resv lock held. > * @importer_priv: importer specific attachment data. > * > * This structure holds the attachment information between the dma_buf buffer > @@ -479,8 +479,8 @@ struct dma_buf_attach_ops { > * > * An attachment is created by calling dma_buf_attach(), and released again by > * calling dma_buf_detach(). The DMA mapping itself needed to initiate a > - * transfer is created by dma_buf_map_attachment() and freed again by calling > - * dma_buf_unmap_attachment(). > + * transfer is created by dma_buf_map_sgt() and freed again by calling > + * dma_buf_unmap_sgt(). > */ > struct dma_buf_attachment { > struct dma_buf *dmabuf; > @@ -571,10 +571,10 @@ void dma_buf_fd_install(struct dma_buf *dmabuf, int fd); > struct dma_buf *dma_buf_get(int fd); > void dma_buf_put(struct dma_buf *dmabuf); > > -struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *, > - enum dma_data_direction); > -void dma_buf_unmap_attachment(struct dma_buf_attachment *, struct sg_table *, > - enum dma_data_direction); > +struct sg_table *dma_buf_map_sgt(struct dma_buf_attachment *, > + enum dma_data_direction); > +void dma_buf_unmap_sgt(struct dma_buf_attachment *, struct sg_table *, > + enum dma_data_direction); > void dma_buf_invalidate_mappings(struct dma_buf *dma_buf); > bool dma_buf_attach_revocable(struct dma_buf_attachment *attach); > int dma_buf_begin_cpu_access(struct dma_buf *dma_buf, > @@ -582,11 +582,11 @@ int dma_buf_begin_cpu_access(struct dma_buf *dma_buf, > int dma_buf_end_cpu_access(struct dma_buf *dma_buf, > enum dma_data_direction dir); > struct sg_table * > -dma_buf_map_attachment_unlocked(struct dma_buf_attachment *attach, > +dma_buf_map_sgt_unlocked(struct dma_buf_attachment *attach, > + enum dma_data_direction direction); > +void dma_buf_unmap_sgt_unlocked(struct dma_buf_attachment *attach, > + struct sg_table *sg_table, > enum dma_data_direction direction); > -void dma_buf_unmap_attachment_unlocked(struct dma_buf_attachment *attach, > - struct sg_table *sg_table, > - enum dma_data_direction direction); > > int dma_buf_mmap(struct dma_buf *, struct vm_area_struct *, > unsigned long); > diff --git a/io_uring/zcrx.c b/io_uring/zcrx.c > index 6d7abb1636e7..7c8ce3d2188a 100644 > --- a/io_uring/zcrx.c > +++ b/io_uring/zcrx.c > @@ -132,8 +132,8 @@ static void io_unmap_dmabuf(struct io_zcrx_mem *mem) > if (!IS_ENABLED(CONFIG_DMA_SHARED_BUFFER)) > return; > if (mem->sgt) > - dma_buf_unmap_attachment_unlocked(mem->attach, mem->sgt, > - DMA_FROM_DEVICE); > + dma_buf_unmap_sgt_unlocked(mem->attach, mem->sgt, > + DMA_FROM_DEVICE); > if (mem->attach) > dma_buf_detach(mem->dmabuf, mem->attach); > mem->sgt = NULL; > @@ -182,7 +182,7 @@ static int io_import_dmabuf(struct io_zcrx_ifq *ifq, > goto err; > } > > - mem->sgt = dma_buf_map_attachment_unlocked(mem->attach, DMA_FROM_DEVICE); > + mem->sgt = dma_buf_map_sgt_unlocked(mem->attach, DMA_FROM_DEVICE); > if (IS_ERR(mem->sgt)) { > ret = PTR_ERR(mem->sgt); > mem->sgt = NULL; > diff --git a/net/core/devmem.c b/net/core/devmem.c > index 32fafbfa1359..5a984df959f7 100644 > --- a/net/core/devmem.c > +++ b/net/core/devmem.c > @@ -75,8 +75,8 @@ void __net_devmem_dmabuf_binding_free(struct work_struct *wq) > > kvfree(binding->area.niovs); > dma_resv_lock(binding->dmabuf->resv, NULL); > - dma_buf_unmap_attachment(binding->attachment, binding->sgt, > - binding->direction); > + dma_buf_unmap_sgt(binding->attachment, binding->sgt, > + binding->direction); > dma_buf_unpin(binding->attachment); > dma_resv_unlock(binding->dmabuf->resv); > dma_buf_detach(binding->dmabuf, binding->attachment); > @@ -250,7 +250,7 @@ net_devmem_bind_dmabuf(struct net_device *dev, void *vdev, > goto err_unlock; > } > > - binding->sgt = dma_buf_map_attachment(binding->attachment, direction); > + binding->sgt = dma_buf_map_sgt(binding->attachment, direction); > if (IS_ERR(binding->sgt)) { > err = PTR_ERR(binding->sgt); > NL_SET_ERR_MSG(extack, "Failed to map dmabuf attachment"); > @@ -357,7 +357,7 @@ net_devmem_bind_dmabuf(struct net_device *dev, void *vdev, > kvfree(binding->tx_vec); > err_unmap: > dma_resv_lock(dmabuf->resv, NULL); > - dma_buf_unmap_attachment(binding->attachment, binding->sgt, direction); > + dma_buf_unmap_sgt(binding->attachment, binding->sgt, direction); > err_unpin: > dma_buf_unpin(binding->attachment); > err_unlock: >

2 days, 10 hours

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig