Commit 51ae62a1 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'dma-mapping-6.13-2024-11-19' of git://git.infradead.org/users/hch/dma-mapping 

Pull dma-mapping updates from Christoph Hellwig:

 - improve the DMA API tracing code (Sean Anderson)

 - misc cleanups (Christoph Hellwig, Sui Jingfeng)

 - fix pointer abuse when finding the shared DMA pool (Geert
   Uytterhoeven)

 - fix a deadlock in dma-debug (Levi Yun)

* tag 'dma-mapping-6.13-2024-11-19' of git://git.infradead.org/users/hch/dma-mapping:
  dma-mapping: save base/size instead of pointer to shared DMA pool
  dma-mapping: fix swapped dir/flags arguments to trace_dma_alloc_sgt_err
  dma-mapping: drop unneeded includes from dma-mapping.h
  dma-mapping: trace more error paths
  dma-mapping: use trace_dma_alloc for dma_alloc* instead of using trace_dma_map
  dma-mapping: trace dma_alloc/free direction
  dma-mapping: use macros to define events in a class
  dma-mapping: remove an outdated comment from dma-map-ops.h
  dma-debug: remove DMA_API_DEBUG_SG
  dma-debug: store a phys_addr_t in struct dma_debug_entry
  dma-debug: fix a possible deadlock on radix_lock
parents 40f48f82 22293c33

arch/powerpc/platforms/pseries/svm.c

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 


#include <linux/mm.h>

#include <linux/memblock.h>

#include <linux/mem_encrypt.h>

#include <linux/cc_platform.h>

#include <asm/machdep.h>

#include <asm/svm.h>

include/linux/dma-map-ops.h

+1 −1
Original line number Diff line number Diff line
@@ -242,7 +242,7 @@ static inline bool dev_is_dma_coherent(struct device *dev) 
{

	return true;

}

#endif /* CONFIG_ARCH_HAS_DMA_COHERENCE_H */

#endif



static inline void dma_reset_need_sync(struct device *dev)

{

include/linux/dma-mapping.h

+0 −4
Original line number Diff line number Diff line
@@ -2,15 +2,11 @@ 
#ifndef _LINUX_DMA_MAPPING_H

#define _LINUX_DMA_MAPPING_H



#include <linux/cache.h>

#include <linux/sizes.h>

#include <linux/string.h>

#include <linux/device.h>

#include <linux/err.h>

#include <linux/dma-direction.h>

#include <linux/scatterlist.h>

#include <linux/bug.h>

#include <linux/mem_encrypt.h>



/**

 * List of possible attributes associated with a DMA mapping. The semantics

include/trace/events/dma.h

+173 −40
Original line number Diff line number Diff line
@@ -65,15 +65,14 @@ DECLARE_EVENT_CLASS(dma_map, 
		decode_dma_attrs(__entry->attrs))

);



DEFINE_EVENT(dma_map, dma_map_page,

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

		 size_t size, enum dma_data_direction dir, unsigned long attrs),

	TP_ARGS(dev, phys_addr, dma_addr, size, dir, attrs));

#define DEFINE_MAP_EVENT(name) \

DEFINE_EVENT(dma_map, name, \

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

		 size_t size, enum dma_data_direction dir, unsigned long attrs), \

	TP_ARGS(dev, phys_addr, dma_addr, size, dir, attrs))



DEFINE_EVENT(dma_map, dma_map_resource,

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

		 size_t size, enum dma_data_direction dir, unsigned long attrs),

	TP_ARGS(dev, phys_addr, dma_addr, size, dir, attrs));

DEFINE_MAP_EVENT(dma_map_page);

DEFINE_MAP_EVENT(dma_map_resource);



DECLARE_EVENT_CLASS(dma_unmap,

	TP_PROTO(struct device *dev, dma_addr_t addr, size_t size,
@@ -104,20 +103,20 @@ DECLARE_EVENT_CLASS(dma_unmap, 
		decode_dma_attrs(__entry->attrs))

);



DEFINE_EVENT(dma_unmap, dma_unmap_page,

	TP_PROTO(struct device *dev, dma_addr_t addr, size_t size,

		 enum dma_data_direction dir, unsigned long attrs),

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

#define DEFINE_UNMAP_EVENT(name) \

DEFINE_EVENT(dma_unmap, name, \

	TP_PROTO(struct device *dev, dma_addr_t addr, size_t size, \

		 enum dma_data_direction dir, unsigned long attrs), \

	TP_ARGS(dev, addr, size, dir, attrs))



DEFINE_EVENT(dma_unmap, dma_unmap_resource,

	TP_PROTO(struct device *dev, dma_addr_t addr, size_t size,

		 enum dma_data_direction dir, unsigned long attrs),

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

DEFINE_UNMAP_EVENT(dma_unmap_page);

DEFINE_UNMAP_EVENT(dma_unmap_resource);



TRACE_EVENT(dma_alloc,

DECLARE_EVENT_CLASS(dma_alloc_class,

	TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr,

		 size_t size, gfp_t flags, unsigned long attrs),

	TP_ARGS(dev, virt_addr, dma_addr, size, flags, attrs),

		 size_t size, enum dma_data_direction dir, gfp_t flags,

		 unsigned long attrs),

	TP_ARGS(dev, virt_addr, dma_addr, size, dir, flags, attrs),



	TP_STRUCT__entry(

		__string(device, dev_name(dev))
@@ -125,6 +124,7 @@ TRACE_EVENT(dma_alloc, 
		__field(u64, dma_addr)

		__field(size_t, size)

		__field(gfp_t, flags)

		__field(enum dma_data_direction, dir)

		__field(unsigned long, attrs)

	),
@@ -137,8 +137,9 @@ TRACE_EVENT(dma_alloc, 
		__entry->attrs = attrs;

	),



	TP_printk("%s dma_addr=%llx size=%zu virt_addr=%p flags=%s attrs=%s",

	TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p flags=%s attrs=%s",

		__get_str(device),

		decode_dma_data_direction(__entry->dir),

		__entry->dma_addr,

		__entry->size,

		__entry->virt_addr,
@@ -146,16 +147,69 @@ TRACE_EVENT(dma_alloc, 
		decode_dma_attrs(__entry->attrs))

);



TRACE_EVENT(dma_free,

#define DEFINE_ALLOC_EVENT(name) \

DEFINE_EVENT(dma_alloc_class, name, \

	TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \

		 size_t size, enum dma_data_direction dir, gfp_t flags, \

		 unsigned long attrs), \

	TP_ARGS(dev, virt_addr, dma_addr, size, dir, flags, attrs))



DEFINE_ALLOC_EVENT(dma_alloc);

DEFINE_ALLOC_EVENT(dma_alloc_pages);

DEFINE_ALLOC_EVENT(dma_alloc_sgt_err);



TRACE_EVENT(dma_alloc_sgt,

	TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size,

		 enum dma_data_direction dir, gfp_t flags, unsigned long attrs),

	TP_ARGS(dev, sgt, size, dir, flags, attrs),



	TP_STRUCT__entry(

		__string(device, dev_name(dev))

		__dynamic_array(u64, phys_addrs, sgt->orig_nents)

		__field(u64, dma_addr)

		__field(size_t, size)

		__field(enum dma_data_direction, dir)

		__field(gfp_t, flags)

		__field(unsigned long, attrs)

	),



	TP_fast_assign(

		struct scatterlist *sg;

		int i;



		__assign_str(device);

		for_each_sg(sgt->sgl, sg, sgt->orig_nents, i)

			((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);

		__entry->dma_addr = sg_dma_address(sgt->sgl);

		__entry->size = size;

		__entry->dir = dir;

		__entry->flags = flags;

		__entry->attrs = attrs;

	),



	TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s flags=%s attrs=%s",

		__get_str(device),

		decode_dma_data_direction(__entry->dir),

		__entry->dma_addr,

		__entry->size,

		__print_array(__get_dynamic_array(phys_addrs),

			      __get_dynamic_array_len(phys_addrs) /

				sizeof(u64), sizeof(u64)),

		show_gfp_flags(__entry->flags),

		decode_dma_attrs(__entry->attrs))

);



DECLARE_EVENT_CLASS(dma_free_class,

	TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr,

		 size_t size, unsigned long attrs),

	TP_ARGS(dev, virt_addr, dma_addr, size, attrs),

		 size_t size, enum dma_data_direction dir, unsigned long attrs),

	TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs),



	TP_STRUCT__entry(

		__string(device, dev_name(dev))

		__field(void *, virt_addr)

		__field(u64, dma_addr)

		__field(size_t, size)

		__field(enum dma_data_direction, dir)

		__field(unsigned long, attrs)

	),
@@ -164,17 +218,63 @@ TRACE_EVENT(dma_free, 
		__entry->virt_addr = virt_addr;

		__entry->dma_addr = dma_addr;

		__entry->size = size;

		__entry->dir = dir;

		__entry->attrs = attrs;

	),



	TP_printk("%s dma_addr=%llx size=%zu virt_addr=%p attrs=%s",

	TP_printk("%s dir=%s dma_addr=%llx size=%zu virt_addr=%p attrs=%s",

		__get_str(device),

		decode_dma_data_direction(__entry->dir),

		__entry->dma_addr,

		__entry->size,

		__entry->virt_addr,

		decode_dma_attrs(__entry->attrs))

);



#define DEFINE_FREE_EVENT(name) \

DEFINE_EVENT(dma_free_class, name, \

	TP_PROTO(struct device *dev, void *virt_addr, dma_addr_t dma_addr, \

		 size_t size, enum dma_data_direction dir, unsigned long attrs), \

	TP_ARGS(dev, virt_addr, dma_addr, size, dir, attrs))



DEFINE_FREE_EVENT(dma_free);

DEFINE_FREE_EVENT(dma_free_pages);



TRACE_EVENT(dma_free_sgt,

	TP_PROTO(struct device *dev, struct sg_table *sgt, size_t size,

		 enum dma_data_direction dir),

	TP_ARGS(dev, sgt, size, dir),



	TP_STRUCT__entry(

		__string(device, dev_name(dev))

		__dynamic_array(u64, phys_addrs, sgt->orig_nents)

		__field(u64, dma_addr)

		__field(size_t, size)

		__field(enum dma_data_direction, dir)

	),



	TP_fast_assign(

		struct scatterlist *sg;

		int i;



		__assign_str(device);

		for_each_sg(sgt->sgl, sg, sgt->orig_nents, i)

			((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);

		__entry->dma_addr = sg_dma_address(sgt->sgl);

		__entry->size = size;

		__entry->dir = dir;

	),



	TP_printk("%s dir=%s dma_addr=%llx size=%zu phys_addrs=%s",

		__get_str(device),

		decode_dma_data_direction(__entry->dir),

		__entry->dma_addr,

		__entry->size,

		__print_array(__get_dynamic_array(phys_addrs),

			      __get_dynamic_array_len(phys_addrs) /

				sizeof(u64), sizeof(u64)))

);



TRACE_EVENT(dma_map_sg,

	TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,

		 int ents, enum dma_data_direction dir, unsigned long attrs),
@@ -221,6 +321,41 @@ TRACE_EVENT(dma_map_sg, 
		decode_dma_attrs(__entry->attrs))

);



TRACE_EVENT(dma_map_sg_err,

	TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,

		 int err, enum dma_data_direction dir, unsigned long attrs),

	TP_ARGS(dev, sgl, nents, err, dir, attrs),



	TP_STRUCT__entry(

		__string(device, dev_name(dev))

		__dynamic_array(u64, phys_addrs, nents)

		__field(int, err)

		__field(enum dma_data_direction, dir)

		__field(unsigned long, attrs)

	),



	TP_fast_assign(

		struct scatterlist *sg;

		int i;



		__assign_str(device);

		for_each_sg(sgl, sg, nents, i)

			((u64 *)__get_dynamic_array(phys_addrs))[i] = sg_phys(sg);

		__entry->err = err;

		__entry->dir = dir;

		__entry->attrs = attrs;

	),



	TP_printk("%s dir=%s dma_addrs=%s err=%d attrs=%s",

		__get_str(device),

		decode_dma_data_direction(__entry->dir),

		__print_array(__get_dynamic_array(phys_addrs),

			      __get_dynamic_array_len(phys_addrs) /

				sizeof(u64), sizeof(u64)),

		__entry->err,

		decode_dma_attrs(__entry->attrs))

);



TRACE_EVENT(dma_unmap_sg,

	TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,

		 enum dma_data_direction dir, unsigned long attrs),
@@ -279,15 +414,14 @@ DECLARE_EVENT_CLASS(dma_sync_single, 
		__entry->size)

);



DEFINE_EVENT(dma_sync_single, dma_sync_single_for_cpu,

	TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size,

		 enum dma_data_direction dir),

	TP_ARGS(dev, dma_addr, size, dir));

#define DEFINE_SYNC_SINGLE_EVENT(name) \

DEFINE_EVENT(dma_sync_single, name, \

	TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size, \

		 enum dma_data_direction dir), \

	TP_ARGS(dev, dma_addr, size, dir))



DEFINE_EVENT(dma_sync_single, dma_sync_single_for_device,

	TP_PROTO(struct device *dev, dma_addr_t dma_addr, size_t size,

		 enum dma_data_direction dir),

	TP_ARGS(dev, dma_addr, size, dir));

DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_cpu);

DEFINE_SYNC_SINGLE_EVENT(dma_sync_single_for_device);



DECLARE_EVENT_CLASS(dma_sync_sg,

	TP_PROTO(struct device *dev, struct scatterlist *sgl, int nents,
@@ -326,15 +460,14 @@ DECLARE_EVENT_CLASS(dma_sync_sg, 
				sizeof(unsigned int), sizeof(unsigned int)))

);



DEFINE_EVENT(dma_sync_sg, dma_sync_sg_for_cpu,

	TP_PROTO(struct device *dev, struct scatterlist *sg, int nents,

		 enum dma_data_direction dir),

	TP_ARGS(dev, sg, nents, dir));

#define DEFINE_SYNC_SG_EVENT(name) \

DEFINE_EVENT(dma_sync_sg, name, \

	TP_PROTO(struct device *dev, struct scatterlist *sg, int nents, \

		 enum dma_data_direction dir), \

	TP_ARGS(dev, sg, nents, dir))



DEFINE_EVENT(dma_sync_sg, dma_sync_sg_for_device,

	TP_PROTO(struct device *dev, struct scatterlist *sg, int nents,

		 enum dma_data_direction dir),

	TP_ARGS(dev, sg, nents, dir));

DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_cpu);

DEFINE_SYNC_SG_EVENT(dma_sync_sg_for_device);



#endif /*  _TRACE_DMA_H */

kernel/dma/Kconfig

+0 −17
Original line number Diff line number Diff line
@@ -260,23 +260,6 @@ config DMA_API_DEBUG 


	  If unsure, say N.



config DMA_API_DEBUG_SG

	bool "Debug DMA scatter-gather usage"

	default y

	depends on DMA_API_DEBUG

	help

	  Perform extra checking that callers of dma_map_sg() have respected the

	  appropriate segment length/boundary limits for the given device when

	  preparing DMA scatterlists.



	  This is particularly likely to have been overlooked in cases where the

	  dma_map_sg() API is used for general bulk mapping of pages rather than

	  preparing literal scatter-gather descriptors, where there is a risk of

	  unexpected behaviour from DMA API implementations if the scatterlist

	  is technically out-of-spec.



	  If unsure, say N.



config DMA_MAP_BENCHMARK

	bool "Enable benchmarking of streaming DMA mapping"

	depends on DEBUG_FS