On Wed, Oct 14, 2026 at 12:02:02PM +0100, Pavel Begunkov wrote:
> Premapped buffers don't require a generic bio_vec since these have
> already been dma mapped. Repurpose the bi_io_vec space to store dmabuf
> maps as they are mutually exclusive.
>
> The bio splitting differs from the normal path because it's already
> pre-mapped and for the block layer it's just an offset into the dma-buf.
> The actual segmentation is only available to the importer driver and not
> the block layer, however, it doesn't contain alignment gaps and we don't
> have to check it. For the same reason we can't precisely split by the
> number of segments, but we use ->min_seg_shift stored in the map to
> calculate the minimum number of bytes a request consisting of
> lim->max_segments full segments can cover and split by that. It's
> stricter and can add extra splitting. E.g. for a {4K, 4G} segmentation,
> the min segment size is 4K, and we'll split it into bios of
> (4K * lim->max_segments) bytes each, but it should be good enough for
> now to cover the most popular use cases.
>
> Suggested-by: Keith Busch <kbusch(a)kernel.org>
> Signed-off-by: Pavel Begunkov <asml.silence(a)gmail.com>
> ---
> block/bio.c | 15 +++++++++--
> block/blk-merge.c | 52 +++++++++++++++++++++++++++++++++++++++
> block/blk-mq.c | 6 +++++
> block/fops.c | 2 +-
> include/linux/bio.h | 9 ++++---
> include/linux/blk-mq.h | 7 ++++++
> include/linux/blk_types.h | 14 ++++++++++-
> include/linux/bvec.h | 3 ++-
> 8 files changed, 99 insertions(+), 9 deletions(-)
>
> diff --git a/block/bio.c b/block/bio.c
> index b48091c7663f..1e0d9714c541 100644
> --- a/block/bio.c
> +++ b/block/bio.c
> @@ -881,7 +881,11 @@ static int __bio_clone(struct bio *bio, struct bio *bio_src, gfp_t gfp)
> bio->bi_write_stream = bio_src->bi_write_stream;
> bio->bi_bvec_gap_bit = bio_src->bi_bvec_gap_bit;
> bio->bi_iter = bio_src->bi_iter;
> - bio->bi_io_vec = bio_src->bi_io_vec;
> +
> + if (op_is_dmabuf(bio->bi_opf))
> + bio->bi_dmabuf_map = bio_src->bi_dmabuf_map;
> + else
> + bio->bi_io_vec = bio_src->bi_io_vec;
>
> if (bio->bi_bdev) {
> if (bio->bi_bdev == bio_src->bi_bdev &&
> @@ -1204,16 +1208,23 @@ EXPORT_SYMBOL_GPL(__bio_release_pages);
>
> bool bio_iov_iter_set(struct bio *bio, const struct iov_iter *iter)
> {
> - if (!iov_iter_is_bvec(iter))
> + if (!iov_iter_is_bvec(iter) && !iov_iter_is_dmabuf_map(iter))
> return false;
>
> WARN_ON_ONCE(bio->bi_max_vecs);
>
> + static_assert(offsetof(struct bio, bi_io_vec) ==
> + offsetof(struct bio, bi_dmabuf_map));
> + static_assert(offsetof(struct iov_iter, bvec) ==
> + offsetof(struct iov_iter, dmabuf_map));
> +
> bio->bi_io_vec = (struct bio_vec *)iter->bvec;
> bio->bi_iter.bi_idx = 0;
> bio->bi_iter.bi_offset = iter->iov_offset;
> bio->bi_iter.bi_size = iov_iter_count(iter);
> bio_set_flag(bio, BIO_CLONED);
> + if (iov_iter_is_dmabuf_map(iter))
> + bio->bi_opf |= REQ_NOMERGE | REQ_DMABUF;
> return true;
> }
>
> diff --git a/block/blk-merge.c b/block/blk-merge.c
> index 258a726071d1..501ddc01c449 100644
> --- a/block/blk-merge.c
> +++ b/block/blk-merge.c
> @@ -9,6 +9,7 @@
> #include <linux/blk-integrity.h>
> #include <linux/part_stat.h>
> #include <linux/blk-cgroup.h>
> +#include <linux/dma-buf-io.h>
>
> #include <trace/events/block.h>
>
> @@ -319,6 +320,41 @@ static inline unsigned int bvec_seg_gap(struct bio_vec *bvprv,
> return bv->bv_offset | (bvprv->bv_offset + bvprv->bv_len);
> }
>
> +static inline int bio_split_io_at_dmabuf(struct bio *bio,
> + const struct queue_limits *lim, unsigned *segs,
> + unsigned max_bytes, unsigned len_align_mask,
> + unsigned start_align_mask)
> +{
> + unsigned bytes = min(bio->bi_iter.bi_size, max_bytes);
> + unsigned seg_shift = bio->bi_dmabuf_map->min_seg_shift;
> + unsigned offset = bio->bi_iter.bi_offset & ((1U << seg_shift) - 1);
> + u64 max_segs_bytes;
> +
> + /*
> + * dma-buf maps don't expose the underlying segmentation, but they're
> + * guaranteed to not have alignment gaps, we only need to check the
> + * start and length alignment.
> + */
> + if ((bio->bi_iter.bi_offset & start_align_mask) ||
> + (bio->bi_iter.bi_size & len_align_mask))
> + return -EINVAL;
> +
> + /* Presented as a single contiguous range into the dma-buf */
> + *segs = 1;
> +
> + /*
> + * Limit by the number of segments by using the minimal segment size.
> + * Any I/O consisting of N full segments should be able to cover at
> + * least N multiplied by the segment size. It's stricter than walking
> + * the segments and might cause extra splitting.
> + */
> + max_segs_bytes = (u64)lim->max_segments << seg_shift;
> + bytes = min_t(u64, bytes, max_segs_bytes - offset);
> + if (bytes != bio->bi_iter.bi_size)
> + return bytes;
> + return 0;
> +}
> +
> /**
> * bio_split_io_at - check if and where to split a bio
> * @bio: [in] bio to be split
> @@ -346,6 +382,19 @@ int bio_split_io_at(struct bio *bio, const struct queue_limits *lim,
> len_align_mask |= (bc->bc_key->crypto_cfg.data_unit_size - 1);
> }
>
> + if (op_is_dmabuf(bio->bi_opf)) {
> + int ret;
> +
> + ret = bio_split_io_at_dmabuf(bio, lim, &nsegs, max_bytes,
> + len_align_mask, start_align_mask);
> + if (ret < 0)
> + return ret;
> + if (!ret)
> + goto out;
> + bytes = ret;
> + goto split;
> + }
> +
> bio_for_each_bvec(bv, bio, iter) {
> if (bv.bv_offset & start_align_mask ||
> bv.bv_len & len_align_mask)
> @@ -376,6 +425,7 @@ int bio_split_io_at(struct bio *bio, const struct queue_limits *lim,
> bvprvp = &bvprv;
> }
>
> +out:
> *segs = nsegs;
> bio->bi_bvec_gap_bit = ffs(gaps);
> return 0;
> @@ -493,6 +543,8 @@ unsigned int blk_recalc_rq_segments(struct request *rq)
>
> if (!rq->bio)
> return 0;
> + if (op_is_dmabuf(rq->bio->bi_opf))
> + return 1;
>
> switch (bio_op(rq->bio)) {
> case REQ_OP_DISCARD:
> diff --git a/block/blk-mq.c b/block/blk-mq.c
> index e929f94b25c7..1b7f8cbbda8b 100644
> --- a/block/blk-mq.c
> +++ b/block/blk-mq.c
> @@ -3150,6 +3150,12 @@ void blk_mq_submit_bio(struct bio *bio)
> goto queue_exit;
> }
>
> + if (unlikely(op_is_dmabuf(bio->bi_opf) &&
> + bdev_has_integrity_csum(bio->bi_bdev))) {
> + bio_endio_status(bio, BLK_STS_NOTSUPP);
Wrong indentation, conditions are never indented the same level as
the following code block, even with the weirdest preferences.
/me note the patch from Anuj on the list actually got this right..
Otherwise looks good:
Reviewed-by: Christoph Hellwig <hch(a)lst.de>
On Mon, Oct 12, 2026 at 02:21:41PM -0600, Jens Axboe wrote:
> I've queued this series up for some testing, in a separate branch. JFYI.
More testing it obviously good. I've been waiting for addressing
of the Sashiko comments on the nvme patches before doing more ACKs,
and while I can't really judge the code those in the dma-buf code
also look somewhat serious. So it would be useful to get them addressed
and the series reposted. Same for folding in the PI vs dmabuf fix
from Anuj, although making the combination work would of course be
even better.
Hi Karl,
On Tue, 13 Oct 2026 at 00:21, Karl Mehltretter <kmehltretter(a)gmail.com> wrote:
>
> On Mon, Oct 12, 2026 at 10:12:02AM +0100, Thorsten Leemhuis wrote:
> >
> > What's the status here given that 7.3 will likely be released in a few
> > days? Note, I can see from the discussion that this is a complex problem
> > that can't be quickly solved. That's how it is sometimes. But I wonder
> > if the current state of things is the best compromise for now or if
> > Rob's revert or some other option would be better.
> >
>
> I think reverting my commit 143755bdabaa ("dma-buf: Make DMABUF_DEBUG
> default to y on DEBUG_KERNEL kernels") is the best interim solution for
> v7.3.
>
> Christian, Sumit, could one of you apply Jianfeng's revert before the
> final release?
>
> https://lore.kernel.org/r/20260926022026.10539-1-liujianfeng1994@gmail.com/
>
> Thanks,
> Karl
I have pushed the revert to drm-misc-fixes; I'll request Dave to push
it out to Linus along with drm-fixes.
We should revisit this for the next cycle in a couple of weeks for sure.
Best,
Sumit.
Hi Karl,
On Tue, 13 Oct, 2026, 12:21 am Karl Mehltretter, <kmehltretter(a)gmail.com>
wrote:
> On Mon, Oct 12, 2026 at 10:12:02AM +0100, Thorsten Leemhuis wrote:
> >
> > What's the status here given that 7.3 will likely be released in a few
> > days? Note, I can see from the discussion that this is a complex problem
> > that can't be quickly solved. That's how it is sometimes. But I wonder
> > if the current state of things is the best compromise for now or if
> > Rob's revert or some other option would be better.
> >
>
> I think reverting my commit 143755bdabaa ("dma-buf: Make DMABUF_DEBUG
> default to y on DEBUG_KERNEL kernels") is the best interim solution for
> v7.3.
>
> Christian, Sumit, could one of you apply Jianfeng's revert before the
> final release?
>
> https://lore.kernel.org/r/20260926022026.10539-1-liujianfeng1994@gmail.com/
>
>
Ok, I'll try and revert it for 7.3. We may need to reapply it for the next
cycle along with the solution Rob and folks are working on.
Thanks,
> Karl
>
Best,
Sumit.
>
Kiryl Shutsemau <kas(a)kernel.org> writes:
> On Thu, Sep 24, 2026 at 03:35:17PM +0530, Aneesh Kumar K.V (Arm) wrote:
>> diff --git a/arch/x86/coco/tdx/tdx.c b/arch/x86/coco/tdx/tdx.c
>> index f904a636d449..1f1f39082391 100644
>> --- a/arch/x86/coco/tdx/tdx.c
>> +++ b/arch/x86/coco/tdx/tdx.c
>> @@ -978,6 +978,9 @@ static bool tdx_enc_status_changed(unsigned long vaddr, int numpages, bool enc)
>> static int tdx_enc_status_change_prepare(unsigned long vaddr, int numpages,
>> bool enc)
>> {
>> + if (!enc)
>> + memset((void *)vaddr, 0, (size_t)numpages << PAGE_SHIFT);
>> +
>> /*
>> * Only handle shared->private conversion here.
>> * See the comment in tdx_early_init().
>
> This doesn't make sense to me.
>
> On TDX the memset zeroes a page that is about to be dropped.
> MapGPA(shared) makes the VMM back the GPA with different memory, and
> what the guest reads afterwards through the shared mapping is whatever
> the host has there.
>
Does TDX require the guest contents to be preserved when pages are
converted to shared?
The memset() is done here because CoCo shared-memory allocations now
ignore __GFP_ZERO and instead always zero the memory explicitly. For
CoCo architectures such as CCA, this must be done after the memory is
converted to shared because shared memory uses a different encryption
context.
The full patch avoids zeroing the memory twice. If __GFP_ZERO is used
for a CoCo shared-page allocation, the page is first zeroed during
allocation, then converted to shared, and must be zeroed again. I only
changed Arm CCA in this series because I was unsure whether the other
architectures required similar changes. Therefore, every CoCo
architecture other than CCA currently performs the memset() before
conversion, while CCA performs it afterward.
If the host expects to see the guest contents from before the conversion
to shared, we will have to pass the allocation flags down to these
helpers and perform the memset() only when __GFP_ZERO was requested,
along the lines of:
https://lore.kernel.org/all/yq5aa4p82sqt.fsf@kernel.org
To keep the changes minimal, the current approach always performs the
memset() rather than passing down a flag.
-aneesh
Hi Zack,
On 07/10/2026 16:24, Zack Rusin wrote:
> On Tue, Oct 6, 2026 at 3:15 PM Matt Evans <matt(a)ozlabs.org> wrote:
>>
>> The dmabuf release path is split between file and dentry release:
>> dma_buf_file_release() is called shortly before the file is freed, and
>> dma_buf_release() calls an exporter's dmabuf->ops->release when the
>> dentry is freed. However, the dentry can outlive the file (for
>> example, if opened with O_PATH), meaning .release might be called some
>> time after the file is freed.
>>
>> This presents a window, when closing a DMABUF file, in which
>> dmabuf->file points to freed memory yet .release op has not yet been
>> called.
>>
>> For VFIO, if a buffer's .release has not been called it's considered
>> still active and subject to move/cleanup. If so, it attempts to
>> get_file_active() on dmabuf->file: a file close with dentry held open
>> will call this function with a stale pointer, a UAF.
>>
>> To make this pattern safe, set dmabuf->file to NULL in
>> dma_buf_file_release() to reflect that the associated file is now dead
>> even if the DMABUF is not yet gone. A get_file_active() ... fput()
>> sequence concurrent with a file close will only execute as one of:
>>
>> - Gets the file before file_ref_put() (dmabuf->file valid)
>> - Observes dmabuf->file pointing to a file, but it's DEAD (no file)
>> - Observes dmabuf->file = NULL (no file)
>>
>> Originally, drivers could assume dmabuf->file was valid until .release
>> was called from fops->release. This assumption was no longer valid
>> after 4ab59c3c638c6 ("dma-buf: Move dma_buf_release() from fops to
>> dentry_ops"), which moved the callback to the dentry release (by which
>> point the file might have been freed). With this commit, drivers must
>> still consider that dmabuf->file could be NULL before .release.
>>
>> Fixes: 4ab59c3c638c6 ("dma-buf: Move dma_buf_release() from fops to dentry_ops")
>> Signed-off-by: Matt Evans <matt(a)ozlabs.org>
>> ---
>>
>> Hi,
>>
>> This issue was found (by Claude Opus 5.5) in the context of VFIO's
>> DMABUF export path. VFIO iterates live DMABUFs with a
>> get_file_active()/fput() block, which now becomes safe if the file is
>> closed (and memory freed!) yet DMABUF .release hasn't yet occurred.
>>
>> However, there are a couple of other places that directly use
>> dmabuf->file and seem able to race a closing file (i.e. without holding
>> the file reference)? If this is so, they'd be a UAF today; with this
>> patch that goes away, but instead of a stale pointer dmabuf->file could
>> be NULL:
>>
>> 1. drivers/gpu/drm/vmwgfx/ttm_object.c:get_dma_buf_unless_doomed()
>>
>> file_ref_get(&dmabuf->file->f_ref); on a non-refcounted DMABUF
>
> Yes, that's a real UAF today. vmwgfx relied on the exporter's
> dma_buf_ops.release running inside __fput() before file_free(), which
> stopped being true with 4ab59c3c638c and we missed it.
>
> But this patch on its own makes vmwgfx worse. In the ordinary case,
> where closing the file drops the last dentry reference, a close racing
> PRIME_HANDLE_TO_FD is safe today: ttm_prime_dmabuf_release() runs from
> the same __fput() and blocks on prime->mutex, keeping the file
> allocated, so file_ref_get() just fails on the dead refcount. With
> this patch dmabuf->file is NULL in that window and we oops. So this
> shouldn't go to stable without a vmwgfx fix.
>
> For vmwgfx we'd probably need this one line change in
> drivers/gpu/drm/vmwgfx/ttm_object.c to accompany this patch:
> @@ -471,7 +475,7 @@ void ttm_object_device_release(struct
> ttm_object_device **p_tdev)
> */
> static bool __must_check get_dma_buf_unless_doomed(struct dma_buf *dmabuf)
> {
> - return file_ref_get(&dmabuf->file->f_ref);
> + return get_file_active(&dmabuf->file) != NULL;
> }
>
> under prime->mutex, which keeps the struct dma_buf alive. It needs the
> NULL store from this patch to fix the existing UAF, since otherwise
> the recheck can accept a recycled file through the unchanged stale
> pointer.
Thanks for confirming! Ah, so get_file_active() is good here, cheers.
I'll repost as a 2-part series to first include this in vmwgfx and
second add the anNULL.
>> The commit message of 90ee6ed776c0 ("fs: port files to file_ref") hints
>> this might be more subtle than replacing it with a get_file() variant
>> (so as to accept a NULL file *).
>>
>> 2. drivers/gpu/drm/i915/gvt/dmabuf.c:intel_vgpu_get_dmabuf()
>>
>> gvt_dbg_dpy(... file_count(dmabuf->file) ...);
FWIW aside, I re-read this, and there does appear to be a ref held
(dma_buf_export() has just happened, and dma_buf_fd() generated) so
dmabuf->file is stable at that point.
>> Respective vmwgfx & i915 maintainers, what is your view?
>> Or, indeed, if anyone sees any other questionable uses of dmabuf->file.
>>
>> Thanks,
>>
>>
>> Matt
>>
>>
>> drivers/dma-buf/dma-buf.c | 6 +++++-
>> 1 file changed, 5 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c
>> index 4c9add51f9ef..726639130477 100644
>> --- a/drivers/dma-buf/dma-buf.c
>> +++ b/drivers/dma-buf/dma-buf.c
>> @@ -193,11 +193,15 @@ static void dma_buf_release(struct dentry *dentry)
>>
>> static int dma_buf_file_release(struct inode *inode, struct file *file)
>> {
>> + struct dma_buf *dmabuf = file->private_data;
>> +
>> if (!is_dma_buf_file(file))
>> return -EINVAL;
>>
>> - __dma_buf_list_del(file->private_data);
>> + __dma_buf_list_del(dmabuf);
>>
>> + /* Must be observed by __get_file_rcu() before file_free() */
>> + smp_store_mb(dmabuf->file, NULL);
>
> I think Alex is right and dmabuf can be NULL here. An early if
> (!dmabuf) return 0" will fix that.
Yep, on it.
Many thanks,
Matt
On 10/5/26 15:20, Fred Griffoul wrote:
> On 10/5/26 Christian König wrote:
>> Well filling page tables by the importer is an absolutely clear NO-GO
>> for the DMA-buf design, we have gotten down that path already and it
>> took us years to remove this functionality again.
>
> Understood, thanks for the quick and clear answers on this patch and on
> patch 3.
>
>> The problem you are facing here is that dma_buf_mmap() doesn't work
>> because you don't have a VMA.
>
> Right: the memory has no struct page and is deliberately not mapped in
> the host, so there is no VMA to hand to KVM.
>
> I'll post a new version of this series. It drops get_phys(), the ranged
> invalidation and the guest_memfd dma-buf import (patches 2-5), and it
> does not touch drivers/dma-buf, as you suggested in the PAL discussion:
>
> https://lore.kernel.org/all/c413710b-4c28-4ed8-88ec-aeb8c4482011@amd.com/
>
> KVM gets its frames through the KVM-private guest_memfd provider
> interface from David's series. iommufd gets them through a private
> interface with the exporter, as it already does for vfio-pci. The new
> version adds a small registry in iommufd for that, which replaces the
> symbol_get() of the sample in David's series. The dma-buf is then only
> the handle and the existing revoke.
Yeah that approach sounds totally sane to me.
We have drivers which stuff all kind of resources, not just memory, into a DMA-buf. That ranges from MMIO BARs to trigger FW operations (doorbells) over full HW blocks (ordered appends, global wave sync etc...) where two or more applications need to share which one is used.
That you then have a exporter private interface is for accessing this is perfectly ok.
The problem you are facing here is more that this is not limited to one driver/module but multiple ones and you don't want module inter dependencies because of the symbols.
So symbol_get() is probably the right thing to do as long as we don't have something like weak symbols or similar.
Regards,
Christian.
>
> Thanks,
> Fred