On Tue, 2026-02-17 at 20:11 -0400, Jason Gunthorpe wrote:
> DMA-buf mapping types allow the importer and exporter to negotiate
> the
> format of the map/unmap to be used during the attachment.
>
> Currently DMA-buf only supports struct scatterlist as the attachment
> map
> operation. This is not sufficient for all use cases as dma_addr_t is
> a
> very specific and limited type.
>
> With mapping types the importing driver can declare what it supports.
> For
> example:
>
> struct dma_buf_mapping_match imp_match[] = {
> DMA_BUF_IMAPPING_MY_DRIVER(dev, ...),
> DMA_BUF_IMAPPING_SGT(dev, false),
> };
> attach = dma_buf_mapping_attach(dmabuf, imp_match, ...)
>
> And the exporting driver can declare what it supports:
>
> int exporter_match_mapping(struct dma_buf_match_args *args)
> {
> struct dma_buf_mapping_match exp_match[] = {
> DMA_BUF_EMAPPING_MY_DRIVER(my_ops, dev, ...),
> DMA_BUF_EMAPPING_SGT(sgt_ops, dev, false),
> DMA_BUF_EMAPPING_PAL(PAL_ops),
> };
> return dma_buf_match_mapping(args, exp_match, ...);
> }
>
> During dma_buf_mapping_attach() the core code will select a mutual
> match
> between the importer and exporter and record it in the attach-
> >map_type.
>
> Add the basic types:
>
> struct dma_buf_mapping_type
> Type tag and ops for each mapping type.
>
> struct dma_buf_mapping_match
> Entry in a list of importer or exporter match specifications.
> The match specification can be extended by the mapping type with
> unique data.
>
> dma_buf_match_mapping() / struct dma_buf_match_args
> Helper to do the matching. Called by the exporting driver
> via a dma_buf_ops callback.
>
> struct dma_buf_mapping_exp_ops
> Base type for the per-mapping type exporter provided functions.
> This
> would be the map/unmap callbacks. Each mapping type can provide
> its own
> functions for map/unmap type operations with optimal type
> signatures.
Does it make sense to try to land this patch first, plus a conversion
of pcie_p2p so we could agree on what the contract should look like?
s/mapping/interconnect/? My gut feeling is that "interconnect" best
describes what's typically going on, but "mapping" perhaps better
describes all cases.
Location of common protocols which typically carry cross-subsystem
dependencies?
drivers/dma-buf/mapping_types? drivers/dma-buf/interconnects?
As discussed previously:
Agree on theoretically possible matches at attach time, Match at
mapping time and guarantee the match is valid until
invalidate_mappings().
>
> Signed-off-by: Jason Gunthorpe <[email protected]>
> ---
> drivers/dma-buf/dma-buf-mapping.c | 46 +++++++++++++++++++
> include/linux/dma-buf-mapping.h | 76
> +++++++++++++++++++++++++++++++
> include/linux/dma-buf.h | 18 ++++++++
> 3 files changed, 140 insertions(+)
>
> diff --git a/drivers/dma-buf/dma-buf-mapping.c b/drivers/dma-buf/dma-
> buf-mapping.c
> index b7352e609fbdfa..459c204cabb803 100644
> --- a/drivers/dma-buf/dma-buf-mapping.c
> +++ b/drivers/dma-buf/dma-buf-mapping.c
> @@ -5,6 +5,7 @@
> */
> #include <linux/dma-buf-mapping.h>
> #include <linux/dma-resv.h>
> +#include <linux/dma-buf.h>
>
> static struct scatterlist *fill_sg_entry(struct scatterlist *sgl,
> size_t length,
> dma_addr_t addr)
> @@ -246,3 +247,48 @@ void dma_buf_free_sgt(struct dma_buf_attachment
> *attach, struct sg_table *sgt,
>
> }
> EXPORT_SYMBOL_NS_GPL(dma_buf_free_sgt, "DMA_BUF");
> +
> +/**
> + * dma_buf_match_mapping - Select a mapping type agreed upon by
> exporter and
> + * importer
> + * @args: Match arguments from attach. On success this is updated
> with the
> + * matched exporter and importer entries.
> + * @exp: Array of mapping types supported by the exporter, in
> priority order
> + * @exp_len: Number of entries in @exp
> + *
> + * Iterate over the exporter's supported mapping types and for each
> one search
> + * the importer's list for a compatible matching type. args and
> args->attach are
> + * populated with the resulting match.
> + *
> + * Because the exporter list is walked in order, the exporter
> controls the
> + * priority of mapping types.
> + */
> +int dma_buf_match_mapping(struct dma_buf_match_args *args,
> + const struct dma_buf_mapping_match *exp,
> + size_t exp_len)
> +{
> + const struct dma_buf_mapping_match *exp_end = exp + exp_len;
> + const struct dma_buf_mapping_match *imp_end =
> + args->imp_matches + args->imp_len;
> + int ret;
> +
> + for (; exp != exp_end; exp++) {
> + const struct dma_buf_mapping_match *imp = args-
> >imp_matches;
> +
> + for (; imp != imp_end; imp++) {
> + if (exp->type != imp->type)
> + continue;
> + if (exp->type->match) {
> + ret = exp->type->match(args->dmabuf,
> exp, imp);
> + if (ret == -EOPNOTSUPP)
> + continue;
> + if (ret != 0)
> + return ret;
> + }
> + exp->type->finish_match(args, exp, imp);
> + return 0;
> + }
> + }
> + return -EINVAL;
> +}
> +EXPORT_SYMBOL_NS_GPL(dma_buf_match_mapping, "DMA_BUF");
> diff --git a/include/linux/dma-buf-mapping.h b/include/linux/dma-buf-
> mapping.h
> index a3c0ce2d3a42fe..080ccbf3a3f8b8 100644
> --- a/include/linux/dma-buf-mapping.h
> +++ b/include/linux/dma-buf-mapping.h
> @@ -7,6 +7,77 @@
> #define __DMA_BUF_MAPPING_H__
> #include <linux/dma-buf.h>
>
> +struct device;
> +struct dma_buf;
> +struct dma_buf_attachment;
> +struct dma_buf_mapping_exp_ops;
> +
> +/* Type tag for all mapping operations */
> +struct dma_buf_mapping_exp_ops {};
> +
> +/*
> + * Internal struct to pass arguments from the attach function to the
> matching
> + * function
> + */
> +struct dma_buf_match_args {
> + struct dma_buf *dmabuf;
> + struct dma_buf_attachment *attach;
> + const struct dma_buf_mapping_match *imp_matches;
> + size_t imp_len;
> +};
> +
> +/**
> + * struct dma_buf_mapping_type - Operations for a DMA-buf mapping
> type
> + *
> + * Each mapping type provides a singleton instance of this struct to
> describe
> + * the mapping type and its operations.
> + */
> +struct dma_buf_mapping_type {
> + /**
> + * @name: Human-readable name for this mapping type, used in
> debugfs
> + * output
> + */
> + const char *name;
> +
> + /**
> + * @match:
> + *
> + * Called during attach from dma_buf_match_mapping(). &exp
> and &imp are
> + * single items from the importer and exporter mapping match
> lists.
> + * Both will have the same instance of this struct as their
> type member.
> + *
> + * It determines if the exporter/importer are compatible.
> + *
> + * Returns: 0 on success
> + * -EOPNOTSUPP means ignore the failure and continue
> + * Everything else aborts the search and returns the -
> errno
> + */
> + int (*match)(struct dma_buf *dmabuf,
> + const struct dma_buf_mapping_match *exp,
> + const struct dma_buf_mapping_match *imp);
> +
> + /**
> + * @finish_match:
> + *
> + * Called by dma_buf_match_mapping() after a successful
> match to store
> + * the negotiated result in @args->attach. The matched @exp
> and @imp
> + * entries are provided so the callback can copy type-
> specific data into
> + * the attachment.
> + */
> + void (*finish_match)(struct dma_buf_match_args *args,
> + const struct dma_buf_mapping_match
> *exp,
> + const struct dma_buf_mapping_match
> *imp);
> +
> + /**
> + * @debugfs_dump:
> + *
> + * Optional callback to write mapping-type-specific
> diagnostic
> + * information about @attach to the debugfs seq_file @s.
> + */
> + void (*debugfs_dump)(struct seq_file *s,
> + struct dma_buf_attachment *attach);
> +};
> +
> struct sg_table *dma_buf_phys_vec_to_sgt(struct dma_buf_attachment
> *attach,
> struct p2pdma_provider
> *provider,
> struct dma_buf_phys_vec
> *phys_vec,
> @@ -14,4 +85,9 @@ struct sg_table *dma_buf_phys_vec_to_sgt(struct
> dma_buf_attachment *attach,
> enum dma_data_direction
> dir);
> void dma_buf_free_sgt(struct dma_buf_attachment *attach, struct
> sg_table *sgt,
> enum dma_data_direction dir);
> +
> +int dma_buf_match_mapping(struct dma_buf_match_args *args,
> + const struct dma_buf_mapping_match
> *exp_mappings,
> + size_t exp_len);
> +
> #endif
> diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
> index 0bc492090237ed..a2b01b13026810 100644
> --- a/include/linux/dma-buf.h
> +++ b/include/linux/dma-buf.h
> @@ -27,6 +27,21 @@
> struct device;
> struct dma_buf;
> struct dma_buf_attachment;
> +struct dma_buf_mapping_type;
> +struct dma_buf_mapping_exp_ops;
> +
> +/*
> + * Match items are generated by the importer using the
> DMA_BUF_IMAPPING_*() and
> + * the exporter using the DMA_BUF_EMAPPING_*() functions. Each
> mapping type
> + * defines its own signature with its own data to make the match and
> attachment.
> + */
> +struct dma_buf_mapping_match {
> + const struct dma_buf_mapping_type *type;
> + const struct dma_buf_mapping_exp_ops *exp_ops;
> + union {
> + /* Each mapping_type has unique match parameters
> here */
> + };
Do we really need to add all global mapping types here? Then we'd need
something for driver-private mapping types as well.
What about just defining a
struct dma_buf_mapping_priv {
};
And let the mapping type subclass from it, and add a pointer to such a
structure?
Thanks,
Thomas
