Commit f0548044 authored by Jiri Pirko's avatar Jiri Pirko Committed by Marek Szyprowski
Browse files

dma-mapping: introduce DMA_ATTR_CC_SHARED for shared memory 



Current CC designs don't place a vIOMMU in front of untrusted devices.
Instead, the DMA API forces all untrusted device DMA through swiotlb
bounce buffers (is_swiotlb_force_bounce()) which copies data into
shared memory on behalf of the device.

When a caller has already arranged for the memory to be shared
via set_memory_decrypted(), the DMA API needs to know so it can map
directly using the unencrypted physical address rather than bounce
buffering. Following the pattern of DMA_ATTR_MMIO, add
DMA_ATTR_CC_SHARED for this purpose. Like the MMIO case, only the
caller knows what kind of memory it has and must inform the DMA API
for it to work correctly.

Signed-off-by: default avatarJiri Pirko <jiri@nvidia.com>
Reviewed-by: default avatarJason Gunthorpe <jgg@nvidia.com>
Acked-by: default avatarSumit Semwal <sumit.semwal@linaro.org>
Signed-off-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Link: https://lore.kernel.org/r/20260325192352.437608-2-jiri@resnulli.us
parent 27e2e9b9

include/linux/dma-mapping.h

+10 −0
Original line number Diff line number Diff line
@@ -92,6 +92,16 @@ 
 * flushing.

 */

#define DMA_ATTR_REQUIRE_COHERENT	(1UL << 12)

/*

 * DMA_ATTR_CC_SHARED: Indicates the DMA mapping is shared (decrypted) for

 * confidential computing guests. For normal system memory the caller must have

 * called set_memory_decrypted(), and pgprot_decrypted must be used when

 * creating CPU PTEs for the mapping. The same shared semantic may be passed

 * to the vIOMMU when it sets up the IOPTE. For MMIO use together with

 * DMA_ATTR_MMIO to indicate shared MMIO. Unless DMA_ATTR_MMIO is provided

 * a struct page is required.

 */

#define DMA_ATTR_CC_SHARED	(1UL << 13)



/*

 * A dma_addr_t can hold any valid DMA or bus address for the platform.  It can

include/trace/events/dma.h

+2 −1
Original line number Diff line number Diff line
@@ -34,7 +34,8 @@ TRACE_DEFINE_ENUM(DMA_NONE); 
		{ DMA_ATTR_PRIVILEGED, "PRIVILEGED" }, \

		{ DMA_ATTR_MMIO, "MMIO" }, \

		{ DMA_ATTR_DEBUGGING_IGNORE_CACHELINES, "CACHELINES_OVERLAP" }, \

		{ DMA_ATTR_REQUIRE_COHERENT, "REQUIRE_COHERENT" })

		{ DMA_ATTR_REQUIRE_COHERENT, "REQUIRE_COHERENT" }, \

		{ DMA_ATTR_CC_SHARED, "CC_SHARED" })



DECLARE_EVENT_CLASS(dma_map,

	TP_PROTO(struct device *dev, phys_addr_t phys_addr, dma_addr_t dma_addr,

kernel/dma/direct.h

+11 −3
Original line number Diff line number Diff line
@@ -89,16 +89,24 @@ static inline dma_addr_t dma_direct_map_phys(struct device *dev, 
	dma_addr_t dma_addr;



	if (is_swiotlb_force_bounce(dev)) {

		if (!(attrs & DMA_ATTR_CC_SHARED)) {

			if (attrs & (DMA_ATTR_MMIO | DMA_ATTR_REQUIRE_COHERENT))

				return DMA_MAPPING_ERROR;



			return swiotlb_map(dev, phys, size, dir, attrs);

		}

	} else if (attrs & DMA_ATTR_CC_SHARED) {

		return DMA_MAPPING_ERROR;

	}



	if (attrs & DMA_ATTR_MMIO) {

		dma_addr = phys;

		if (unlikely(!dma_capable(dev, dma_addr, size, false)))

			goto err_overflow;

	} else if (attrs & DMA_ATTR_CC_SHARED) {

		dma_addr = phys_to_dma_unencrypted(dev, phys);

		if (unlikely(!dma_capable(dev, dma_addr, size, false)))

			goto err_overflow;

	} else {

		dma_addr = phys_to_dma(dev, phys);

		if (unlikely(!dma_capable(dev, dma_addr, size, true)) ||

kernel/dma/mapping.c

+11 −2
Original line number Diff line number Diff line
@@ -157,6 +157,7 @@ dma_addr_t dma_map_phys(struct device *dev, phys_addr_t phys, size_t size, 
{

	const struct dma_map_ops *ops = get_dma_ops(dev);

	bool is_mmio = attrs & DMA_ATTR_MMIO;

	bool is_cc_shared = attrs & DMA_ATTR_CC_SHARED;

	dma_addr_t addr = DMA_MAPPING_ERROR;



	BUG_ON(!valid_dma_direction(dir));
@@ -168,8 +169,11 @@ dma_addr_t dma_map_phys(struct device *dev, phys_addr_t phys, size_t size, 
		return DMA_MAPPING_ERROR;



	if (dma_map_direct(dev, ops) ||

	    (!is_mmio && arch_dma_map_phys_direct(dev, phys + size)))

	    (!is_mmio && !is_cc_shared &&

	     arch_dma_map_phys_direct(dev, phys + size)))

		addr = dma_direct_map_phys(dev, phys, size, dir, attrs, true);

	else if (is_cc_shared)

		return DMA_MAPPING_ERROR;

	else if (use_dma_iommu(dev))

		addr = iommu_dma_map_phys(dev, phys, size, dir, attrs);

	else if (ops->map_phys)
@@ -206,11 +210,16 @@ void dma_unmap_phys(struct device *dev, dma_addr_t addr, size_t size, 
{

	const struct dma_map_ops *ops = get_dma_ops(dev);

	bool is_mmio = attrs & DMA_ATTR_MMIO;

	bool is_cc_shared = attrs & DMA_ATTR_CC_SHARED;



	BUG_ON(!valid_dma_direction(dir));



	if (dma_map_direct(dev, ops) ||

	    (!is_mmio && arch_dma_unmap_phys_direct(dev, addr + size)))

	    (!is_mmio && !is_cc_shared &&

	     arch_dma_unmap_phys_direct(dev, addr + size)))

		dma_direct_unmap_phys(dev, addr, size, dir, attrs, true);

	else if (is_cc_shared)

		return;

	else if (use_dma_iommu(dev))

		iommu_dma_unmap_phys(dev, addr, size, dir, attrs);

	else if (ops->unmap_phys)