iommu: Refactor flush queues into iommu-dma
Subsystems (7)
Robin Murphy
maintainercover iommu: Refactor flush queues into iommu-dma
Hi all,
As promised, this series cleans up the flush queue code and streamlines it directly into iommu-dma. Since we no longer have per-driver DMA ops implementations, a lot of the abstraction is now no longer necessary, so there's a nice degree of simplification in the process. Un-abstracting the queued page freeing mechanism is also the perfect opportunity to revise which struct page fields we use so we can be better-behaved from the MM point of view, thanks to Matthew.
These changes should also make it viable to start using the gather freelist in io-pgtable-arm, and eliminate some more synchronous invalidations from the normal flow there, but that is proving to need a bit more careful thought than I have time for in this cycle, so I've parked that again for now and will revisit it in the new year.
For convenience, branch at:
https://gitlab.arm.com/linux-arm/linux-rm/-/tree/iommu/iova
I've build-tested for x86_64, and boot-tested arm64 to the point of confirming that put_pages_list() gets passed a valid empty list when flushing, while everything else still works.
Cheers,
Robin.
Matthew Wilcox (Oracle) (2):
iommu/amd: Use put_pages_list
iommu/vt-d: Use put_pages_list
Robin Murphy (7):
gpu: host1x: Add missing DMA API include iommu/iova: Squash entry_dtor abstraction iommu/iova: Squash flush_cb abstraction iommu/amd: Simplify pagetable freeing iommu/iova: Consolidate flush queue code iommu/iova: Move flush queue code to iommu-dma
iommu: Move flush queue data into iommu_dma_cookie
drivers/gpu/host1x/bus.c | 1 + drivers/iommu/amd/io_pgtable.c | 116 ++++++-------- drivers/iommu/dma-iommu.c | 266 +++++++++++++++++++++++++++------ drivers/iommu/intel/iommu.c | 89 ++++------- drivers/iommu/iova.c | 200 ------------------------- include/linux/iommu.h | 3 +- include/linux/iova.h | 69 +-------- 7 files changed, 295 insertions(+), 449 deletions(-)
Signature · 1 line
2.28.0.dirty
Robin Murphy
maintainerPATCH 1/9 gpu: host1x: Add missing DMA API include
Host1x seems to be relying on picking up dma-mapping.h transitively from iova.h, which has no reason to include it in the first place. Fix the former issue before we totally break things by fixing the latter one.
---
Feel free to pick this into drm-misc-next or drm-misc-fixes straight away if that suits - it's only to avoid a build breakage once the rest of the series gets queued.
Robin.
drivers/gpu/host1x/bus.c | 1 + 1 file changed, 1 insertion(+)
drivers/gpu/host1x/bus.c +1 -0
@@ -5,6 +5,7 @@*/ #include <linux/debugfs.h> +#include <linux/dma-mapping.h> #include <linux/host1x.h> #include <linux/of.h> #include <linux/seq_file.h>
Signature · 1 line
2.28.0.dirty
Robin Murphy
maintainerRe: [PATCH 1/9] gpu: host1x: Add missing DMA API include
Quoted 9 lines · Robin Murphy
Host1x seems to be relying on picking up
dma-mapping.htransitively fromiova.h, which has no reason to include it in the first place. Fix the former issue before we totally break things by fixing the latter one.CC Thierry Reding <[email protected]>CC Mikko Perttunen <[email protected]>Signed-off-by Robin Murphy <[email protected]>
Quoted 5 lines
---
Feel free to pick this into drm-misc-next or drm-misc-fixes straight away if that suits - it's only to avoid a build breakage once the rest of the series gets queued.
Bah, seems like tegra-vic needs the same treatment too, but wasn't in my local config. Should I squash that into a respin of this patch on the grounds of being vaguely related, or would you prefer it separate?
(Either way I'll wait a little while to see if the buildbots uncover any more...)
Cheers,
Robin.
Quoted 16 lines
drivers/gpu/host1x/bus.c | 1 + 1 file changed, 1 insertion(+)drivers/gpu/host1x/bus.c +1
-0@@ -5,6 +5,7 @@*/ #include <linux/debugfs.h> +#include <linux/dma-mapping.h> #include <linux/host1x.h> #include <linux/of.h> #include <linux/seq_file.h>
Joerg Roedel
maintainerRe: [PATCH 1/9] gpu: host1x: Add missing DMA API include
Hi Robin,
Quoted 3 lines · Robin Murphy
Bah, seems like tegra-vic needs the same treatment too, but wasn't in my local config. Should I squash that into a respin of this patch on the grounds of being vaguely related, or would you prefer it separate?
In case this fix gets queued in the iommu-tree too, please put it all in one patch.
Thanks,
Joerg
Robin Murphy
maintainerPATCH 2/9 iommu/iova: Squash entry_dtor abstraction
In reply to Robin MurphyAll flush queues are driven by iommu-dma now, so there is no need to abstract entry_dtor or its data any more. Squash the now-canonical implementation directly into the IOVA code to get it out of the way.
--- drivers/iommu/dma-iommu.c | 17 ++--------------- drivers/iommu/iova.c | 28 +++++++++++++++------------- include/linux/iova.h | 26 +++----------------------- 3 files changed, 20 insertions(+), 51 deletions(-)
drivers/iommu/dma-iommu.c +2 -15
@@ -64,18 +64,6 @@ static int __init iommu_dma_forcedac_setup(char *str) }early_param ("iommu.forcedac" , iommu_dma_forcedac_setup); -static void iommu_dma_entry_dtor (unsigned long data) -{ -struct page *freelist = (struct page *)data; - -while (freelist) { -unsigned long p = (unsigned long )page_address (freelist); - - freelist = freelist->freelist; -free_page (p); - } -} -static inline size_t cookie_msi_granule (struct iommu_dma_cookie *cookie) {if (cookie->type ==IOMMU_DMA_IOVA_COOKIE )
@@ -324,8 +312,7 @@ int iommu_dma_init_fq(struct iommu_domain *domain)if (cookie->fq_domain)return 0 ; - ret =init_iova_flush_queue (&cookie->iovad, iommu_dma_flush_iotlb_all, - iommu_dma_entry_dtor); + ret =init_iova_flush_queue (&cookie->iovad, iommu_dma_flush_iotlb_all);if (ret) {pr_warn ("iova flush queue initialization failed\n" );return ret;
@@ -479,7 +466,7 @@ static void iommu_dma_free_iova(struct iommu_dma_cookie *cookie,else if (gather && gather->queued)queue_iova (iovad,iova_pfn (iovad, iova), size >>iova_shift (iovad), - (unsigned long )gather->freelist); + gather->freelist);else free_iova_fast (iovad,iova_pfn (iovad, iova), size >>iova_shift (iovad));
drivers/iommu/iova.c +15 -13
@@ -92,11 +92,9 @@ static void free_iova_flush_queue(struct iova_domain *iovad) iovad->fq =NULL ; iovad->flush_cb =NULL ; - iovad->entry_dtor =NULL ; } -int init_iova_flush_queue (struct iova_domain *iovad, -iova_flush_cb flush_cb,iova_entry_dtor entry_dtor) +int init_iova_flush_queue (struct iova_domain *iovad,iova_flush_cb flush_cb) {struct iova_fq __percpu *queue;int cpu;
@@ -109,7 +107,6 @@ int init_iova_flush_queue(struct iova_domain *iovad,return -ENOMEM ; iovad->flush_cb = flush_cb; - iovad->entry_dtor = entry_dtor;for_each_possible_cpu (cpu) {struct iova_fq *fq;
@@ -539,6 +536,16 @@ free_iova_fast(struct iova_domain *iovad, unsigned long pfn, unsigned long size) }EXPORT_SYMBOL_GPL (free_iova_fast); +static void fq_entry_dtor (struct page *freelist) +{ +while (freelist) { +unsigned long p = (unsigned long )page_address (freelist); + + freelist = freelist->freelist; +free_page (p); + } +} +#define fq_ring_for_each (i, fq) \ for ((i) = (fq)->head; (i) != (fq)->tail; (i) = ((i) + 1) % IOVA_FQ_SIZE)
@@ -571,9 +578,7 @@ static void fq_ring_free(struct iova_domain *iovad, struct iova_fq *fq)if (fq->entries[idx].counter >= counter)break ; -if (iovad->entry_dtor) - iovad->entry_dtor (fq->entries[idx].data); - +fq_entry_dtor (fq->entries[idx].freelist);free_iova_fast (iovad, fq->entries[idx].iova_pfn, fq->entries[idx].pages);
@@ -598,15 +603,12 @@ static void fq_destroy_all_entries(struct iova_domain *iovad)* bother to free iovas, just call the entry_dtor on all remaining * entries. */ -if (!iovad->entry_dtor) -return ; -for_each_possible_cpu (cpu) {struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu);int idx;fq_ring_for_each (idx, fq) - iovad->entry_dtor (fq->entries[idx].data); +fq_entry_dtor (fq->entries[idx].freelist); } }
@@ -631,7 +633,7 @@ static void fq_flush_timeout(struct timer_list *t)void queue_iova (struct iova_domain *iovad,unsigned long pfn,unsigned long pages, -unsigned long data) +struct page *freelist) {struct iova_fq *fq;unsigned long flags;
@@ -665,7 +667,7 @@ void queue_iova(struct iova_domain *iovad, fq->entries[idx].iova_pfn = pfn; fq->entries[idx].pages = pages; - fq->entries[idx].data = data; + fq->entries[idx].freelist = freelist; fq->entries[idx].counter =atomic64_read (&iovad->fq_flush_start_cnt);spin_unlock_irqrestore (&fq->lock, flags);
include/linux/iova.h +3 -23
@@ -40,9 +40,6 @@ struct iova_domain;/* Call-Back from IOVA code into IOMMU drivers */ typedef void (*iova_flush_cb )(struct iova_domain *domain); -/* Destructor for per-entry data */ -typedef void (*iova_entry_dtor )(unsigned long data); -/* Number of entries per Flush Queue */ #define IOVA_FQ_SIZE 256
@@ -53,7 +50,7 @@ typedef void (* iova_entry_dtor)(unsigned long data);struct iova_fq_entry {unsigned long iova_pfn;unsigned long pages; -unsigned long data; +struct page *freelist;u64 counter;/* Flush counter when this entrie was added */ };
@@ -88,9 +85,6 @@ struct iova_domain {iova_flush_cb flush_cb;/* Call-Back function to flush IOMMU TLBs */ -iova_entry_dtor entry_dtor;/* IOMMU driver specific destructor for -iova entry */ -struct timer_list fq_timer;/* Timer to regularily empty the flush-queues */ atomic_t fq_timer_on;/* 1 when timer is active, 0
@@ -146,15 +140,14 @@ void free_iova_fast(struct iova_domain *iovad, unsigned long pfn, unsigned long size);void queue_iova (struct iova_domain *iovad,unsigned long pfn,unsigned long pages, -unsigned long data); +struct page *freelist);unsigned long alloc_iova_fast (struct iova_domain *iovad,unsigned long size,unsigned long limit_pfn,bool flush_rcache);struct iova *reserve_iova (struct iova_domain *iovad,unsigned long pfn_lo,unsigned long pfn_hi);void init_iova_domain (struct iova_domain *iovad,unsigned long granule,unsigned long start_pfn); -int init_iova_flush_queue (struct iova_domain *iovad, -iova_flush_cb flush_cb,iova_entry_dtor entry_dtor); +int init_iova_flush_queue (struct iova_domain *iovad,iova_flush_cb flush_cb);struct iova *find_iova (struct iova_domain *iovad,unsigned long pfn);void put_iova_domain (struct iova_domain *iovad);#else
@@ -189,12 +182,6 @@ static inline void free_iova_fast(struct iova_domain *iovad, { } -static inline void queue_iova (struct iova_domain *iovad, -unsigned long pfn,unsigned long pages, -unsigned long data) -{ -} - static inline unsigned long alloc_iova_fast(struct iova_domain *iovad, unsigned long size, unsigned long limit_pfn,
@@ -216,13 +203,6 @@ static inline void init_iova_domain(struct iova_domain *iovad, { } -static inline int init_iova_flush_queue (struct iova_domain *iovad, -iova_flush_cb flush_cb, -iova_entry_dtor entry_dtor) -{ -return -ENODEV ; -} -static inline struct iova *find_iova (struct iova_domain *iovad,unsigned long pfn) {
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 3/9 iommu/iova: Squash flush_cb abstraction
In reply to Robin MurphyOnce again, with iommu-dma now being the only flush queue user, we no longer need the extra level of indirection through flush_cb. Squash that and let the flush queue code call the domain method directly.
--- drivers/iommu/dma-iommu.c | 13 +------------ drivers/iommu/iova.c | 11 +++++------ include/linux/iova.h | 11 +++-------- 3 files changed, 9 insertions(+), 26 deletions(-)
drivers/iommu/dma-iommu.c +1 -12
@@ -282,17 +282,6 @@ static int iova_reserve_iommu_regions(struct device *dev,return ret; } -static void iommu_dma_flush_iotlb_all (struct iova_domain *iovad) -{ -struct iommu_dma_cookie *cookie; -struct iommu_domain *domain; - - cookie = container_of(iovad, struct iommu_dma_cookie, iovad); - domain = cookie->fq_domain; - - domain->ops->flush_iotlb_all (domain); -} -static bool dev_is_untrusted (struct device *dev) {return dev_is_pci (dev) &&to_pci_dev (dev)->untrusted;
@@ -312,7 +301,7 @@ int iommu_dma_init_fq(struct iommu_domain *domain)if (cookie->fq_domain)return 0 ; - ret =init_iova_flush_queue (&cookie->iovad, iommu_dma_flush_iotlb_all); + ret =init_iova_flush_queue (&cookie->iovad, domain);if (ret) {pr_warn ("iova flush queue initialization failed\n" );return ret;
drivers/iommu/iova.c +5 -6
@@ -63,7 +63,7 @@ init_iova_domain(struct iova_domain *iovad, unsigned long granule, iovad->start_pfn = start_pfn; iovad->dma_32bit_pfn =1UL << (32 -iova_shift (iovad)); iovad->max32_alloc_size = iovad->dma_32bit_pfn; - iovad->flush_cb =NULL ; + iovad->fq_domain =NULL ; iovad->fq =NULL ; iovad->anchor.pfn_lo = iovad->anchor.pfn_hi =IOVA_ANCHOR ;rb_link_node (&iovad->anchor.node,NULL , &iovad->rbroot.rb_node);
@@ -91,10 +91,10 @@ static void free_iova_flush_queue(struct iova_domain *iovad)free_percpu (iovad->fq); iovad->fq =NULL ; - iovad->flush_cb =NULL ; + iovad->fq_domain =NULL ; } -int init_iova_flush_queue (struct iova_domain *iovad,iova_flush_cb flush_cb) +int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) {struct iova_fq __percpu *queue;int cpu;
@@ -106,8 +106,6 @@ int init_iova_flush_queue(struct iova_domain *iovad, iova_flush_cb flush_cb)if (!queue)return -ENOMEM ; - iovad->flush_cb = flush_cb; -for_each_possible_cpu (cpu) {struct iova_fq *fq;
@@ -118,6 +116,7 @@ int init_iova_flush_queue(struct iova_domain *iovad, iova_flush_cb flush_cb)spin_lock_init (&fq->lock); } + iovad->fq_domain = fq_domain; iovad->fq = queue;timer_setup (&iovad->fq_timer, fq_flush_timeout,0 );
@@ -590,7 +589,7 @@ static void fq_ring_free(struct iova_domain *iovad, struct iova_fq *fq)static void iova_domain_flush (struct iova_domain *iovad) {atomic64_inc (&iovad->fq_flush_start_cnt); - iovad->flush_cb (iovad); + iovad->fq_domain->ops->flush_iotlb_all (iovad->fq_domain);atomic64_inc (&iovad->fq_flush_finish_cnt); }
include/linux/iova.h +3 -8
@@ -14,6 +14,7 @@#include <linux/rbtree.h> #include <linux/atomic.h> #include <linux/dma-mapping.h> +#include <linux/iommu.h> /* iova structure */ struct iova {
@@ -35,11 +36,6 @@ struct iova_rcache {struct iova_cpu_rcache __percpu *cpu_rcaches; }; -struct iova_domain ; - -/* Call-Back from IOVA code into IOMMU drivers */ -typedef void (*iova_flush_cb )(struct iova_domain *domain); -/* Number of entries per Flush Queue */ #define IOVA_FQ_SIZE 256
@@ -82,8 +78,7 @@ struct iova_domain {struct iova anchor;/* rbtree lookup anchor */ struct iova_rcache rcaches[IOVA_RANGE_CACHE_MAX_SIZE ];/* IOVA range caches */ -iova_flush_cb flush_cb;/* Call-Back function to flush IOMMU -TLBs */ +struct iommu_domain *fq_domain;struct timer_list fq_timer;/* Timer to regularily empty the flush-queues */
@@ -147,7 +142,7 @@ struct iova *reserve_iova(struct iova_domain *iovad, unsigned long pfn_lo, unsigned long pfn_hi);void init_iova_domain (struct iova_domain *iovad,unsigned long granule,unsigned long start_pfn); -int init_iova_flush_queue (struct iova_domain *iovad,iova_flush_cb flush_cb); +int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain);struct iova *find_iova (struct iova_domain *iovad,unsigned long pfn);void put_iova_domain (struct iova_domain *iovad);#else
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 4/9 iommu/amd: Simplify pagetable freeing
In reply to Robin MurphyFor reasons unclear, pagetable freeing is an effectively recursive method implemented via an elaborate system of templated functions that turns out to account for 25% of the object file size. Implementing it using regular straightforward recursion makes the code simpler, and seems like a good thing to do before we work on it further. As part of that, also fix the types to avoid all the needless casting back and forth which just gets in the way.
--- drivers/iommu/amd/io_pgtable.c | 78 +++++++++++++--------------------- 1 file changed, 30 insertions(+), 48 deletions(-)
drivers/iommu/amd/io_pgtable.c +30 -48
@@ -84,49 +84,41 @@ static void free_page_list(struct page *freelist) } } -static struct page *free_pt_page (unsigned long pt,struct page *freelist) +static struct page *free_pt_page (u64 *pt,struct page *freelist) { -struct page *p =virt_to_page ((void *)pt); +struct page *p =virt_to_page (pt); p->freelist = freelist;return p; } -#define DEFINE_FREE_PT_FN (LVL ,FN ) \ -static struct page *free_pt_##LVL (unsigned long __pt, struct page *freelist) \ -{ \ - unsigned long p; \ - u64 *pt; \ - int i; \ - \ - pt = (u64 *)__pt; \ - \ - for (i = 0; i < 512; ++i) { \ -/* PTE present? */ \ -if (!IOMMU_PTE_PRESENT (pt[i])) \ -continue ; \ - \ -/* Large PTE? */ \ -if (PM_PTE_LEVEL (pt[i]) ==0 || \ -PM_PTE_LEVEL (pt[i]) ==7 ) \ -continue ; \ - \ - p = (unsigned long )IOMMU_PTE_PAGE (pt[i]); \ - freelist =FN (p, freelist); \ - } \ - \ -return free_pt_page ((unsigned long )pt, freelist); \ +static struct page *free_pt_lvl (u64 *pt,struct page *freelist,int lvl) +{ +u64 *p; +int i; + +for (i =0 ; i <512 ; ++i) { +/* PTE present? */ +if (!IOMMU_PTE_PRESENT (pt[i])) +continue ; + +/* Large PTE? */ +if (PM_PTE_LEVEL (pt[i]) ==0 || +PM_PTE_LEVEL (pt[i]) ==7 ) +continue ; + + p =IOMMU_PTE_PAGE (pt[i]); +if (lvl >2 ) + freelist =free_pt_lvl (p, freelist, lvl -1 ); +else + freelist =free_pt_page (p, freelist); + } + +return free_pt_page (pt, freelist); } -DEFINE_FREE_PT_FN(l2, free_pt_page) -DEFINE_FREE_PT_FN(l3, free_pt_l2) -DEFINE_FREE_PT_FN(l4, free_pt_l3) -DEFINE_FREE_PT_FN(l5, free_pt_l4) -DEFINE_FREE_PT_FN(l6, free_pt_l5) - -static struct page *free_sub_pt (unsigned long root,int mode, -struct page *freelist) +static struct page *free_sub_pt (u64 *root,int mode,struct page *freelist) {switch (mode) {case PAGE_MODE_NONE :
@@ -136,19 +128,11 @@ static struct page *free_sub_pt(unsigned long root, int mode, freelist =free_pt_page (root, freelist);break ;case PAGE_MODE_2_LEVEL : - freelist =free_pt_l2 (root, freelist); -break ;case PAGE_MODE_3_LEVEL : - freelist =free_pt_l3 (root, freelist); -break ;case PAGE_MODE_4_LEVEL : - freelist =free_pt_l4 (root, freelist); -break ;case PAGE_MODE_5_LEVEL : - freelist =free_pt_l5 (root, freelist); -break ;case PAGE_MODE_6_LEVEL : - freelist =free_pt_l6 (root, freelist); +free_pt_lvl (root, freelist, mode);break ;default :BUG ();
@@ -364,7 +348,7 @@ static u64 *fetch_pte(struct amd_io_pgtable *pgtable,static struct page *free_clear_pte (u64 *pte,u64 pteval,struct page *freelist) { -unsigned long pt; +u64 *pt;int mode;while (cmpxchg64 (pte, pteval,0 ) != pteval) {
@@ -375,7 +359,7 @@ static struct page *free_clear_pte(u64 *pte, u64 pteval, struct page *freelist)if (!IOMMU_PTE_PRESENT (pteval))return freelist; - pt = (unsigned long )IOMMU_PTE_PAGE (pteval); + pt =IOMMU_PTE_PAGE (pteval); mode =IOMMU_PTE_MODE (pteval);return free_sub_pt (pt, mode, freelist);
@@ -512,7 +496,6 @@ static void v1_free_pgtable(struct io_pgtable *iop) struct amd_io_pgtable *pgtable = container_of(iop, struct amd_io_pgtable, iop);struct protection_domain *dom;struct page *freelist =NULL ; -unsigned long root;if (pgtable->mode ==PAGE_MODE_NONE )return ;
@@ -529,8 +512,7 @@ static void v1_free_pgtable(struct io_pgtable *iop)BUG_ON (pgtable->mode <PAGE_MODE_NONE || pgtable->mode >PAGE_MODE_6_LEVEL ); - root = (unsigned long )pgtable->root; - freelist =free_sub_pt (root, pgtable->mode, freelist); + freelist =free_sub_pt (pgtable->root, pgtable->mode, freelist);free_page_list (freelist); }
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Joerg Roedel
maintainerRe: [PATCH 4/9] iommu/amd: Simplify pagetable freeing
Quoted 7 lines · Robin Murphy
For reasons unclear, pagetable freeing is an effectively recursive method implemented via an elaborate system of templated functions that turns out to account for 25% of the object file size. Implementing it using regular straightforward recursion makes the code simpler, and seems like a good thing to do before we work on it further. As part of that, also fix the types to avoid all the needless casting back and forth which just gets in the way.
Nice cleanup! The stack of functions came from the fact that recursion was pretty much discouraged in the kernel. But in this case it looks well bounded and should be fine.
Quoted 7 lines
drivers/iommu/amd/io_pgtable.c +7
-0+static struct page *free_pt_lvl (u64 *pt,struct page *freelist,int lvl) +{ +u64 *p; +int i; + +for (i =0 ; i <512 ; ++i) { +/* PTE present? */
drivers/iommu/amd/io_pgtable.c static void free_page_list(struct page *freelist) · line 112
Quoted 10 lines
drivers/iommu/amd/io_pgtable.c +10
-0+if (!IOMMU_PTE_PRESENT (pt[i])) +continue ; + +/* Large PTE? */ +if (PM_PTE_LEVEL (pt[i]) ==0 || +PM_PTE_LEVEL (pt[i]) ==7 ) +continue ; + + p =IOMMU_PTE_PAGE (pt[i]); +if (lvl >2 )
I thinkt this function deserves a couple of comments. It took me a while to make sense of the 'lvl > 2' comparision. I think it is right, but if I have think again I'd appreciate a comment :)
Regards,
Joerg
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerRe: [PATCH 4/9] iommu/amd: Simplify pagetable freeing
Quoted 9 lines · Joerg Roedel
Quoted 7 lines · Robin Murphy
For reasons unclear, pagetable freeing is an effectively recursive method implemented via an elaborate system of templated functions that turns out to account for 25% of the object file size. Implementing it using regular straightforward recursion makes the code simpler, and seems like a good thing to do before we work on it further. As part of that, also fix the types to avoid all the needless casting back and forth which just gets in the way.
Quoted 3 lines
Nice cleanup! The stack of functions came from the fact that recursion was pretty much discouraged in the kernel. But in this case it looks well bounded and should be fine.
I did wonder about explicitly clamping lvl to ensure that it couldn't possibly recurse any further than the multi-function version, but given that you'd need to craft a suitable bogus pagetable in addition to corrupting the arguments to be able to exploit it at all, that seemed perhaps a little too paranoid. Happy to add something like:
if (WARN_ON(lvl > PAGE_MODE_7_LEVEL)) return NULL;
if you like, though.
Quoted 13 lines
Quoted 13 lines
drivers/iommu/amd/io_pgtable.c +13
-0+static struct page *free_pt_lvl (u64 *pt,struct page *freelist,int lvl) +{ +u64 *p; +int i; + +for (i =0 ; i <512 ; ++i) { +/* PTE present? */ +if (!IOMMU_PTE_PRESENT (pt[i])) +continue ; + +/* Large PTE? */ +if (PM_PTE_LEVEL (pt[i]) ==0 || +PM_PTE_LEVEL (pt[i]) ==7 )
Quoted 8 lines
drivers/iommu/amd/io_pgtable.c static void free_page_list(struct page *freelist) · line 112
Quoted 4 lines
drivers/iommu/amd/io_pgtable.c +4
-0+continue ; + + p =IOMMU_PTE_PAGE (pt[i]); +if (lvl >2 )I thinkt this function deserves a couple of comments. It took me a while to make sense of the 'lvl > 2' comparision. I think it is right, but if I have think again I'd appreciate a comment :)
Heh, it's merely a direct transformation of the logic encoded in the existing "DEFINE_FREE_PT_FN(...)" cases - I assume that's just an optimisation, so I'll add a comment to that effect.
Thanks,
Robin.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 5/9 iommu/amd: Use put_pages_list
In reply to Robin MurphyFrom: "Matthew Wilcox (Oracle)" <[email protected]>
page->freelist is for the use of slab. We already have the ability to free a list of pages in the core mm, but it requires the use of a list_head and for the pages to be chained together through page->lru. Switch the AMD IOMMU code over to using free_pages_list().
--- drivers/iommu/amd/io_pgtable.c | 50 ++++++++++++---------------------- 1 file changed, 18 insertions(+), 32 deletions(-)
drivers/iommu/amd/io_pgtable.c +18 -32
@@ -74,26 +74,14 @@ static u64 *first_pte_l7(u64 *pte, unsigned long *page_size,* ****************************************************************************/ -static void free_page_list (struct page *freelist) -{ -while (freelist !=NULL ) { -unsigned long p = (unsigned long )page_address (freelist); - - freelist = freelist->freelist; -free_page (p); - } -} - -static struct page *free_pt_page (u64 *pt,struct page *freelist) +static void free_pt_page (u64 *pt,struct list_head *freelist) {struct page *p =virt_to_page (pt); - p->freelist = freelist; - -return p; +list_add_tail (&p->lru, freelist); } -static struct page *free_pt_lvl (u64 *pt,struct page *freelist,int lvl) +static void free_pt_lvl (u64 *pt,struct list_head *freelist,int lvl) {u64 *p;int i;
@@ -110,22 +98,22 @@ static struct page *free_pt_lvl(u64 *pt, struct page *freelist, int lvl) p =IOMMU_PTE_PAGE (pt[i]);if (lvl >2 ) - freelist =free_pt_lvl (p, freelist, lvl -1 ); +free_pt_lvl (p, freelist, lvl -1 );else - freelist =free_pt_page (p, freelist); +free_pt_page (p, freelist); } -return free_pt_page (pt, freelist); +free_pt_page (pt, freelist); } -static struct page *free_sub_pt (u64 *root,int mode,struct page *freelist) +static void free_sub_pt (u64 *root,int mode,struct list_head *freelist) {switch (mode) {case PAGE_MODE_NONE :case PAGE_MODE_7_LEVEL :break ;case PAGE_MODE_1_LEVEL : - freelist =free_pt_page (root, freelist); +free_pt_page (root, freelist);break ;case PAGE_MODE_2_LEVEL :case PAGE_MODE_3_LEVEL :
@@ -137,8 +125,6 @@ static struct page *free_sub_pt(u64 *root, int mode, struct page *freelist)default :BUG (); } - -return freelist; } void amd_iommu_domain_set_pgtable(struct protection_domain *domain,
@@ -346,7 +332,7 @@ static u64 *fetch_pte(struct amd_io_pgtable *pgtable,return pte; } -static struct page *free_clear_pte (u64 *pte,u64 pteval,struct page *freelist) +static void free_clear_pte (u64 *pte,u64 pteval,struct list_head *freelist) {u64 *pt;int mode;
@@ -357,12 +343,12 @@ static struct page *free_clear_pte(u64 *pte, u64 pteval, struct page *freelist) }if (!IOMMU_PTE_PRESENT (pteval)) -return freelist; +return ; pt =IOMMU_PTE_PAGE (pteval); mode =IOMMU_PTE_MODE (pteval); -return free_sub_pt (pt, mode, freelist); +free_sub_pt (pt, mode, freelist); }/*
@@ -376,7 +362,7 @@ static int iommu_v1_map_page(struct io_pgtable_ops *ops, unsigned long iova, phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct protection_domain *dom = io_pgtable_ops_to_domain(ops); -struct page *freelist =NULL ; +LIST_HEAD (freelist);bool updated = false;u64 __pte, *pte;int ret, i, count;
@@ -396,9 +382,9 @@ static int iommu_v1_map_page(struct io_pgtable_ops *ops, unsigned long iova, goto out;for (i =0 ; i < count; ++i) - freelist =free_clear_pte (&pte[i], pte[i], freelist); +free_clear_pte (&pte[i], pte[i], &freelist); -if (freelist !=NULL ) +if (!list_empty (&freelist)) updated = true;if (count >1 ) {
@@ -433,7 +419,7 @@ static int iommu_v1_map_page(struct io_pgtable_ops *ops, unsigned long iova, }/* Everything flushed out, free pages now */ -free_page_list (freelist); +put_pages_list (&freelist);return ret; }
@@ -495,7 +481,7 @@ static void v1_free_pgtable(struct io_pgtable *iop) { struct amd_io_pgtable *pgtable = container_of(iop, struct amd_io_pgtable, iop);struct protection_domain *dom; -struct page *freelist =NULL ; +LIST_HEAD (freelist);if (pgtable->mode ==PAGE_MODE_NONE )return ;
@@ -512,9 +498,9 @@ static void v1_free_pgtable(struct io_pgtable *iop)BUG_ON (pgtable->mode <PAGE_MODE_NONE || pgtable->mode >PAGE_MODE_6_LEVEL ); - freelist =free_sub_pt (pgtable->root, pgtable->mode, freelist); +free_sub_pt (pgtable->root, pgtable->mode, &freelist); -free_page_list (freelist); +put_pages_list (&freelist); }static struct io_pgtable *v1_alloc_pgtable (struct io_pgtable_cfg *cfg,void *cookie)
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 6/9 iommu/vt-d: Use put_pages_list
In reply to Robin MurphyFrom: "Matthew Wilcox (Oracle)" <[email protected]>
page->freelist is for the use of slab. We already have the ability to free a list of pages in the core mm, but it requires the use of a list_head and for the pages to be chained together through page->lru. Switch the Intel IOMMU and IOVA code over to using free_pages_list().
--- drivers/iommu/dma-iommu.c | 2 +- drivers/iommu/intel/iommu.c | 89 +++++++++++++------------------------ drivers/iommu/iova.c | 26 ++++------- include/linux/iommu.h | 3 +- include/linux/iova.h | 4 +- 5 files changed, 45 insertions(+), 79 deletions(-)
drivers/iommu/dma-iommu.c +1 -1
@@ -455,7 +455,7 @@ static void iommu_dma_free_iova(struct iommu_dma_cookie *cookie,else if (gather && gather->queued)queue_iova (iovad,iova_pfn (iovad, iova), size >>iova_shift (iovad), - gather->freelist); + &gather->freelist);else free_iova_fast (iovad,iova_pfn (iovad, iova), size >>iova_shift (iovad));
drivers/iommu/intel/iommu.c +31 -58
177 lines not on this page · raw message
drivers/iommu/iova.c +9 -17
@@ -97,7 +97,7 @@ static void free_iova_flush_queue(struct iova_domain *iovad)int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) {struct iova_fq __percpu *queue; -int cpu; +int i, cpu;atomic64_set (&iovad->fq_flush_start_cnt,0 );atomic64_set (&iovad->fq_flush_finish_cnt,0 );
@@ -114,6 +114,9 @@ int init_iova_flush_queue(struct iova_domain *iovad, struct iommu_domain *fq_dom fq->tail =0 ;spin_lock_init (&fq->lock); + +for (i =0 ; i <IOVA_FQ_SIZE ; i++) +INIT_LIST_HEAD (&fq->entries[i].freelist); } iovad->fq_domain = fq_domain;
@@ -535,16 +538,6 @@ free_iova_fast(struct iova_domain *iovad, unsigned long pfn, unsigned long size) }EXPORT_SYMBOL_GPL (free_iova_fast); -static void fq_entry_dtor (struct page *freelist) -{ -while (freelist) { -unsigned long p = (unsigned long )page_address (freelist); - - freelist = freelist->freelist; -free_page (p); - } -} -#define fq_ring_for_each (i, fq) \ for ((i) = (fq)->head; (i) != (fq)->tail; (i) = ((i) + 1) % IOVA_FQ_SIZE)
@@ -577,7 +570,7 @@ static void fq_ring_free(struct iova_domain *iovad, struct iova_fq *fq)if (fq->entries[idx].counter >= counter)break ; -fq_entry_dtor (fq->entries[idx].freelist); +put_pages_list (&fq->entries[idx].freelist);free_iova_fast (iovad, fq->entries[idx].iova_pfn, fq->entries[idx].pages);
@@ -599,15 +592,14 @@ static void fq_destroy_all_entries(struct iova_domain *iovad)/* * This code runs when the iova_domain is being detroyed, so don't -* bother to free iovas, just call the entry_dtor on all remaining -* entries. +* bother to free iovas, just free any remaining pagetable pages. */ for_each_possible_cpu (cpu) {struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu);int idx;fq_ring_for_each (idx, fq) -fq_entry_dtor (fq->entries[idx].freelist); +put_pages_list (&fq->entries[idx].freelist); } }
@@ -632,7 +624,7 @@ static void fq_flush_timeout(struct timer_list *t)void queue_iova (struct iova_domain *iovad,unsigned long pfn,unsigned long pages, -struct page *freelist) +struct list_head *freelist) {struct iova_fq *fq;unsigned long flags;
@@ -666,8 +658,8 @@ void queue_iova(struct iova_domain *iovad, fq->entries[idx].iova_pfn = pfn; fq->entries[idx].pages = pages; - fq->entries[idx].freelist = freelist; fq->entries[idx].counter =atomic64_read (&iovad->fq_flush_start_cnt); +list_splice (freelist, &fq->entries[idx].freelist);spin_unlock_irqrestore (&fq->lock, flags);
include/linux/iommu.h +2 -1
@@ -186,7 +186,7 @@ struct iommu_iotlb_gather {unsigned long start;unsigned long end;size_t pgsize; -struct page *freelist; +struct list_head freelist;bool queued; };
@@ -399,6 +399,7 @@ static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather) { *gather = (struct iommu_iotlb_gather ) { .start =ULONG_MAX , + .freelist =LIST_HEAD_INIT (gather->freelist), }; }
include/linux/iova.h +2 -2
@@ -46,7 +46,7 @@ struct iova_rcache {struct iova_fq_entry {unsigned long iova_pfn;unsigned long pages; -struct page *freelist; +struct list_head freelist;u64 counter;/* Flush counter when this entrie was added */ };
@@ -135,7 +135,7 @@ void free_iova_fast(struct iova_domain *iovad, unsigned long pfn, unsigned long size);void queue_iova (struct iova_domain *iovad,unsigned long pfn,unsigned long pages, -struct page *freelist); +struct list_head *freelist);unsigned long alloc_iova_fast (struct iova_domain *iovad,unsigned long size,unsigned long limit_pfn,bool flush_rcache); struct iova *reserve_iova(struct iova_domain *iovad, unsigned long pfn_lo,
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 7/9 iommu/iova: Consolidate flush queue code
In reply to Robin MurphySquash and simplify some of the freeing code, and move the init and free routines down into the rest of the flush queue code to obviate the forward declarations.
--- drivers/iommu/iova.c | 132 +++++++++++++++++++------------------------ 1 file changed, 58 insertions(+), 74 deletions(-)
drivers/iommu/iova.c +58 -74
@@ -24,8 +24,6 @@ static unsigned long iova_rcache_get(struct iova_domain *iovad,static void init_iova_rcaches (struct iova_domain *iovad);static void free_cpu_cached_iovas (unsigned int cpu,struct iova_domain *iovad);static void free_iova_rcaches (struct iova_domain *iovad); -static void fq_destroy_all_entries (struct iova_domain *iovad); -static void fq_flush_timeout (struct timer_list *t);static int iova_cpuhp_dead (unsigned int cpu,struct hlist_node *node) {
@@ -73,61 +71,6 @@ init_iova_domain(struct iova_domain *iovad, unsigned long granule, }EXPORT_SYMBOL_GPL (init_iova_domain); -static bool has_iova_flush_queue (struct iova_domain *iovad) -{ -return !!iovad->fq; -} - -static void free_iova_flush_queue (struct iova_domain *iovad) -{ -if (!has_iova_flush_queue (iovad)) -return ; - -if (timer_pending (&iovad->fq_timer)) -del_timer (&iovad->fq_timer); - -fq_destroy_all_entries (iovad); - -free_percpu (iovad->fq); - - iovad->fq =NULL ; - iovad->fq_domain =NULL ; -} - -int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) -{ -struct iova_fq __percpu *queue; -int i, cpu; - -atomic64_set (&iovad->fq_flush_start_cnt,0 ); -atomic64_set (&iovad->fq_flush_finish_cnt,0 ); - - queue = alloc_percpu(struct iova_fq); -if (!queue) -return -ENOMEM ; - -for_each_possible_cpu (cpu) { -struct iova_fq *fq; - - fq =per_cpu_ptr (queue, cpu); - fq->head =0 ; - fq->tail =0 ; - -spin_lock_init (&fq->lock); - -for (i =0 ; i <IOVA_FQ_SIZE ; i++) -INIT_LIST_HEAD (&fq->entries[i].freelist); - } - - iovad->fq_domain = fq_domain; - iovad->fq = queue; - -timer_setup (&iovad->fq_timer, fq_flush_timeout,0 ); -atomic_set (&iovad->fq_timer_on,0 ); - -return 0 ; -} -static struct rb_node *__get_cached_rbnode (struct iova_domain *iovad,unsigned long limit_pfn) {
@@ -586,23 +529,6 @@ static void iova_domain_flush(struct iova_domain *iovad)atomic64_inc (&iovad->fq_flush_finish_cnt); } -static void fq_destroy_all_entries (struct iova_domain *iovad) -{ -int cpu; - -/* -* This code runs when the iova_domain is being detroyed, so don't -* bother to free iovas, just free any remaining pagetable pages. -*/ -for_each_possible_cpu (cpu) { -struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu); -int idx; - -fq_ring_for_each (idx, fq) -put_pages_list (&fq->entries[idx].freelist); - } -} -static void fq_flush_timeout (struct timer_list *t) {struct iova_domain *iovad =from_timer (iovad, t, fq_timer);
@@ -670,6 +596,64 @@ void queue_iova(struct iova_domain *iovad, jiffies + msecs_to_jiffies(IOVA_FQ_TIMEOUT)); } +static void free_iova_flush_queue (struct iova_domain *iovad) +{ +int cpu, idx; + +if (!iovad->fq) +return ; + +del_timer (&iovad->fq_timer); +/* +* This code runs when the iova_domain is being detroyed, so don't +* bother to free iovas, just free any remaining pagetable pages. +*/ +for_each_possible_cpu (cpu) { +struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu); + +fq_ring_for_each (idx, fq) +put_pages_list (&fq->entries[idx].freelist); + } + +free_percpu (iovad->fq); + + iovad->fq =NULL ; + iovad->fq_domain =NULL ; +} + +int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) +{ +struct iova_fq __percpu *queue; +int i, cpu; + +atomic64_set (&iovad->fq_flush_start_cnt,0 ); +atomic64_set (&iovad->fq_flush_finish_cnt,0 ); + + queue = alloc_percpu(struct iova_fq); +if (!queue) +return -ENOMEM ; + +for_each_possible_cpu (cpu) { +struct iova_fq *fq =per_cpu_ptr (queue, cpu); + + fq->head =0 ; + fq->tail =0 ; + +spin_lock_init (&fq->lock); + +for (i =0 ; i <IOVA_FQ_SIZE ; i++) +INIT_LIST_HEAD (&fq->entries[i].freelist); + } + + iovad->fq_domain = fq_domain; + iovad->fq = queue; + +timer_setup (&iovad->fq_timer, fq_flush_timeout,0 ); +atomic_set (&iovad->fq_timer_on,0 ); + +return 0 ; +} +/** * put_iova_domain - destroys the iova domain * @iovad: - iova domain in question.
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 8/9 iommu/iova: Move flush queue code to iommu-dma
In reply to Robin MurphyFlush queues are specific to DMA ops, which are now handled exclusively by iommu-dma. As such, now that the historical artefacts from being shared directly with drivers have been cleaned up, move the flush queue code into iommu-dma itself to get it out of the way of other IOVA users.
This is pure code movement with no functional change; refactoring to clean up the headers and definitions will follow.
--- drivers/iommu/dma-iommu.c | 179 +++++++++++++++++++++++++++++++++++++- drivers/iommu/iova.c | 175 ------------------------------------- 2 files changed, 178 insertions(+), 176 deletions(-)
drivers/iommu/dma-iommu.c +178 -1
@@ -64,6 +64,181 @@ static int __init iommu_dma_forcedac_setup(char *str) }early_param ("iommu.forcedac" , iommu_dma_forcedac_setup); + +#define fq_ring_for_each (i, fq) \ + for ((i) = (fq)->head; (i) != (fq)->tail; (i) = ((i) + 1) % IOVA_FQ_SIZE) + +static inline bool fq_full (struct iova_fq *fq) +{ +assert_spin_locked (&fq->lock); +return (((fq->tail +1 ) %IOVA_FQ_SIZE ) == fq->head); +} + +static inline unsigned fq_ring_add (struct iova_fq *fq) +{ +unsigned idx = fq->tail; + +assert_spin_locked (&fq->lock); + + fq->tail = (idx +1 ) %IOVA_FQ_SIZE ; + +return idx; +} + +static void fq_ring_free (struct iova_domain *iovad,struct iova_fq *fq) +{ +u64 counter =atomic64_read (&iovad->fq_flush_finish_cnt); +unsigned idx; + +assert_spin_locked (&fq->lock); + +fq_ring_for_each (idx, fq) { + +if (fq->entries[idx].counter >= counter) +break ; + +put_pages_list (&fq->entries[idx].freelist); +free_iova_fast (iovad, + fq->entries[idx].iova_pfn, + fq->entries[idx].pages); + + fq->head = (fq->head +1 ) %IOVA_FQ_SIZE ; + } +} + +static void iova_domain_flush (struct iova_domain *iovad) +{ +atomic64_inc (&iovad->fq_flush_start_cnt); + iovad->fq_domain->ops->flush_iotlb_all (iovad->fq_domain); +atomic64_inc (&iovad->fq_flush_finish_cnt); +} + +static void fq_flush_timeout (struct timer_list *t) +{ +struct iova_domain *iovad =from_timer (iovad, t, fq_timer); +int cpu; + +atomic_set (&iovad->fq_timer_on,0 ); +iova_domain_flush (iovad); + +for_each_possible_cpu (cpu) { +unsigned long flags; +struct iova_fq *fq; + + fq =per_cpu_ptr (iovad->fq, cpu); +spin_lock_irqsave (&fq->lock, flags); +fq_ring_free (iovad, fq); +spin_unlock_irqrestore (&fq->lock, flags); + } +} + +void queue_iova (struct iova_domain *iovad, +unsigned long pfn,unsigned long pages, +struct list_head *freelist) +{ +struct iova_fq *fq; +unsigned long flags; +unsigned idx; + +/* +* Order against the IOMMU driver's pagetable update from unmapping +* @pte, to guarantee that iova_domain_flush() observes that if called +* from a different CPU before we release the lock below. Full barrier +* so it also pairs with iommu_dma_init_fq() to avoid seeing partially +* written fq state here. +*/ +smp_mb (); + + fq =raw_cpu_ptr (iovad->fq); +spin_lock_irqsave (&fq->lock, flags); + +/* +* First remove all entries from the flush queue that have already been +* flushed out on another CPU. This makes the fq_full() check below less +* likely to be true. +*/ +fq_ring_free (iovad, fq); + +if (fq_full (fq)) { +iova_domain_flush (iovad); +fq_ring_free (iovad, fq); + } + + idx =fq_ring_add (fq); + + fq->entries[idx].iova_pfn = pfn; + fq->entries[idx].pages = pages; + fq->entries[idx].counter =atomic64_read (&iovad->fq_flush_start_cnt); +list_splice (freelist, &fq->entries[idx].freelist); + +spin_unlock_irqrestore (&fq->lock, flags); + +/* Avoid false sharing as much as possible. */ +if (!atomic_read (&iovad->fq_timer_on) && + !atomic_xchg (&iovad->fq_timer_on,1 )) +mod_timer (&iovad->fq_timer, + jiffies +msecs_to_jiffies (IOVA_FQ_TIMEOUT )); +} + +static void free_iova_flush_queue (struct iova_domain *iovad) +{ +int cpu, idx; + +if (!iovad->fq) +return ; + +del_timer (&iovad->fq_timer); +/* +* This code runs when the iova_domain is being detroyed, so don't +* bother to free iovas, just free any remaining pagetable pages. +*/ +for_each_possible_cpu (cpu) { +struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu); + +fq_ring_for_each (idx, fq) +put_pages_list (&fq->entries[idx].freelist); + } + +free_percpu (iovad->fq); + + iovad->fq =NULL ; + iovad->fq_domain =NULL ; +} + +int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) +{ +struct iova_fq __percpu *queue; +int i, cpu; + +atomic64_set (&iovad->fq_flush_start_cnt,0 ); +atomic64_set (&iovad->fq_flush_finish_cnt,0 ); + + queue = alloc_percpu(struct iova_fq); +if (!queue) +return -ENOMEM ; + +for_each_possible_cpu (cpu) { +struct iova_fq *fq =per_cpu_ptr (queue, cpu); + + fq->head =0 ; + fq->tail =0 ; + +spin_lock_init (&fq->lock); + +for (i =0 ; i <IOVA_FQ_SIZE ; i++) +INIT_LIST_HEAD (&fq->entries[i].freelist); + } + + iovad->fq_domain = fq_domain; + iovad->fq = queue; + +timer_setup (&iovad->fq_timer, fq_flush_timeout,0 ); +atomic_set (&iovad->fq_timer_on,0 ); + +return 0 ; +} + +static inline size_t cookie_msi_granule (struct iommu_dma_cookie *cookie) {if (cookie->type ==IOMMU_DMA_IOVA_COOKIE )
@@ -144,8 +319,10 @@ void iommu_put_dma_cookie(struct iommu_domain *domain)if (!cookie)return ; -if (cookie->type ==IOMMU_DMA_IOVA_COOKIE && cookie->iovad.granule) +if (cookie->type ==IOMMU_DMA_IOVA_COOKIE && cookie->iovad.granule) { +free_iova_flush_queue (&cookie->iovad);put_iova_domain (&cookie->iovad); + }list_for_each_entry_safe (msi, tmp, &cookie->msi_page_list, list) {list_del (&msi->list);
drivers/iommu/iova.c +0 -175
187 lines not on this page · raw message
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Robin Murphy
maintainerPATCH 9/9 iommu: Move flush queue data into iommu_dma_cookie
In reply to Robin MurphyComplete the move into iommu-dma by refactoring the flush queues themselves to belong to the DMA cookie rather than the IOVA domain.
The refactoring may as well extend to some minor cosmetic aspects too, to help us stay one step ahead of the style police.
--- drivers/iommu/dma-iommu.c | 171 +++++++++++++++++++++----------------- drivers/iommu/iova.c | 2 - include/linux/iova.h | 44 +--------- 3 files changed, 95 insertions(+), 122 deletions(-)
drivers/iommu/dma-iommu.c +94 -77
@@ -9,9 +9,12 @@*/ #include <linux/acpi_iort.h> +#include <linux/atomic.h> +#include <linux/crash_dump.h> #include <linux/device.h> -#include <linux/dma-map-ops.h> +#include <linux/dma-direct.h> #include <linux/dma-iommu.h> +#include <linux/dma-map-ops.h> #include <linux/gfp.h> #include <linux/huge_mm.h> #include <linux/iommu.h>
@@ -20,11 +23,10 @@#include <linux/mm.h> #include <linux/mutex.h> #include <linux/pci.h> -#include <linux/swiotlb.h> #include <linux/scatterlist.h> +#include <linux/spinlock.h> +#include <linux/swiotlb.h> #include <linux/vmalloc.h> -#include <linux/crash_dump.h> -#include <linux/dma-direct.h> struct iommu_dma_msi_page {struct list_head list;
@@ -41,7 +43,19 @@ struct iommu_dma_cookie {enum iommu_dma_cookie_type type;union {/* Full allocator for IOMMU_DMA_IOVA_COOKIE */ -struct iova_domain iovad; +struct { +struct iova_domain iovad; + +struct iova_fq __percpu *fq;/* Flush queue */ +/* Number of TLB flushes that have been started */ +atomic64_t fq_flush_start_cnt; +/* Number of TLB flushes that have been finished */ +atomic64_t fq_flush_finish_cnt; +/* Timer to regularily empty the flush queues */ +struct timer_list fq_timer; +/* 1 when timer is active, 0 when not */ +atomic_t fq_timer_on; + };/* Trivial linear page allocator for IOMMU_DMA_MSI_COOKIE */ dma_addr_t msi_iova; };
@@ -65,6 +79,27 @@ static int __init iommu_dma_forcedac_setup(char *str)early_param ("iommu.forcedac" , iommu_dma_forcedac_setup); +/* Number of entries per flush queue */ +#define IOVA_FQ_SIZE 256 + +/* Timeout (in ms) after which entries are flushed from the queue */ +#define IOVA_FQ_TIMEOUT 10 + +/* Flush queue entry for deferred flushing */ +struct iova_fq_entry { +unsigned long iova_pfn; +unsigned long pages; +struct list_head freelist; +u64 counter;/* Flush counter when this entry was added */ +}; + +/* Per-CPU flush queue structure */ +struct iova_fq { +struct iova_fq_entry entries[IOVA_FQ_SIZE ]; +unsigned int head, tail; +spinlock_t lock; +}; +#define fq_ring_for_each (i, fq) \ for ((i) = (fq)->head; (i) != (fq)->tail; (i) = ((i) + 1) % IOVA_FQ_SIZE)
@@ -74,9 +109,9 @@ static inline bool fq_full(struct iova_fq *fq)return (((fq->tail +1 ) %IOVA_FQ_SIZE ) == fq->head); } -static inline unsigned fq_ring_add (struct iova_fq *fq) +static inline unsigned int fq_ring_add (struct iova_fq *fq) { -unsigned idx = fq->tail; +unsigned int idx = fq->tail;assert_spin_locked (&fq->lock);
@@ -85,10 +120,10 @@ static inline unsigned fq_ring_add(struct iova_fq *fq)return idx; } -static void fq_ring_free (struct iova_domain *iovad,struct iova_fq *fq) +static void fq_ring_free (struct iommu_dma_cookie *cookie,struct iova_fq *fq) { -u64 counter =atomic64_read (&iovad->fq_flush_finish_cnt); -unsigned idx; +u64 counter =atomic64_read (&cookie->fq_flush_finish_cnt); +unsigned int idx;assert_spin_locked (&fq->lock);
@@ -98,7 +133,7 @@ static void fq_ring_free(struct iova_domain *iovad, struct iova_fq *fq)break ;put_pages_list (&fq->entries[idx].freelist); -free_iova_fast (iovad, +free_iova_fast (&cookie->iovad, fq->entries[idx].iova_pfn, fq->entries[idx].pages);
@@ -106,50 +141,50 @@ static void fq_ring_free(struct iova_domain *iovad, struct iova_fq *fq) } } -static void iova_domain_flush (struct iova_domain *iovad) +static void fq_flush_iotlb (struct iommu_dma_cookie *cookie) { -atomic64_inc (&iovad->fq_flush_start_cnt); - iovad->fq_domain->ops->flush_iotlb_all (iovad->fq_domain); -atomic64_inc (&iovad->fq_flush_finish_cnt); +atomic64_inc (&cookie->fq_flush_start_cnt); + cookie->fq_domain->ops->flush_iotlb_all (cookie->fq_domain); +atomic64_inc (&cookie->fq_flush_finish_cnt); }static void fq_flush_timeout (struct timer_list *t) { -struct iova_domain *iovad =from_timer (iovad, t, fq_timer); +struct iommu_dma_cookie *cookie =from_timer (cookie, t, fq_timer);int cpu; -atomic_set (&iovad->fq_timer_on,0 ); -iova_domain_flush (iovad); +atomic_set (&cookie->fq_timer_on,0 ); +fq_flush_iotlb (cookie);for_each_possible_cpu (cpu) {unsigned long flags;struct iova_fq *fq; - fq =per_cpu_ptr (iovad->fq, cpu); + fq =per_cpu_ptr (cookie->fq, cpu);spin_lock_irqsave (&fq->lock, flags); -fq_ring_free (iovad, fq); +fq_ring_free (cookie, fq);spin_unlock_irqrestore (&fq->lock, flags); } } -void queue_iova (struct iova_domain *iovad, +static void queue_iova (struct iommu_dma_cookie *cookie,unsigned long pfn,unsigned long pages,struct list_head *freelist) {struct iova_fq *fq;unsigned long flags; -unsigned idx; +unsigned int idx;/* * Order against the IOMMU driver's pagetable update from unmapping -* @pte, to guarantee that iova_domain_flush() observes that if called +* @pte, to guarantee that fq_flush_iotlb() observes that if called * from a different CPU before we release the lock below. Full barrier * so it also pairs with iommu_dma_init_fq() to avoid seeing partially * written fq state here. */ smp_mb (); - fq =raw_cpu_ptr (iovad->fq); + fq =raw_cpu_ptr (cookie->fq);spin_lock_irqsave (&fq->lock, flags);/*
@@ -157,65 +192,66 @@ void queue_iova(struct iova_domain *iovad,* flushed out on another CPU. This makes the fq_full() check below less * likely to be true. */ -fq_ring_free (iovad, fq); +fq_ring_free (cookie, fq);if (fq_full (fq)) { -iova_domain_flush (iovad); -fq_ring_free (iovad, fq); +fq_flush_iotlb (cookie); +fq_ring_free (cookie, fq); } idx =fq_ring_add (fq); fq->entries[idx].iova_pfn = pfn; fq->entries[idx].pages = pages; - fq->entries[idx].counter =atomic64_read (&iovad->fq_flush_start_cnt); + fq->entries[idx].counter =atomic64_read (&cookie->fq_flush_start_cnt);list_splice (freelist, &fq->entries[idx].freelist);spin_unlock_irqrestore (&fq->lock, flags);/* Avoid false sharing as much as possible. */ -if (!atomic_read (&iovad->fq_timer_on) && - !atomic_xchg (&iovad->fq_timer_on,1 )) -mod_timer (&iovad->fq_timer, +if (!atomic_read (&cookie->fq_timer_on) && + !atomic_xchg (&cookie->fq_timer_on,1 )) +mod_timer (&cookie->fq_timer, jiffies +msecs_to_jiffies (IOVA_FQ_TIMEOUT )); } -static void free_iova_flush_queue (struct iova_domain *iovad) +static void iommu_dma_free_fq (struct iommu_dma_cookie *cookie) {int cpu, idx; -if (!iovad->fq) +if (!cookie->fq)return ; -del_timer (&iovad->fq_timer); -/* -* This code runs when the iova_domain is being detroyed, so don't -* bother to free iovas, just free any remaining pagetable pages. -*/ +del_timer (&cookie->fq_timer); +/* The IOVAs will be torn down separately, so just free our queued pages */ for_each_possible_cpu (cpu) { -struct iova_fq *fq =per_cpu_ptr (iovad->fq, cpu); +struct iova_fq *fq =per_cpu_ptr (cookie->fq, cpu);fq_ring_for_each (idx, fq)put_pages_list (&fq->entries[idx].freelist); } -free_percpu (iovad->fq); - - iovad->fq =NULL ; - iovad->fq_domain =NULL ; +free_percpu (cookie->fq); } -int init_iova_flush_queue (struct iova_domain *iovad,struct iommu_domain *fq_domain) +/* sysfs updates are serialised by the mutex of the group owning @domain */ +int iommu_dma_init_fq (struct iommu_domain *domain) { +struct iommu_dma_cookie *cookie = domain->iova_cookie;struct iova_fq __percpu *queue;int i, cpu; -atomic64_set (&iovad->fq_flush_start_cnt,0 ); -atomic64_set (&iovad->fq_flush_finish_cnt,0 ); +if (cookie->fq_domain) +return 0 ; + +atomic64_set (&cookie->fq_flush_start_cnt,0 ); +atomic64_set (&cookie->fq_flush_finish_cnt,0 ); queue = alloc_percpu(struct iova_fq); -if (!queue) +if (!queue) { +pr_warn ("iova flush queue initialization failed\n" );return -ENOMEM ; + }for_each_possible_cpu (cpu) {struct iova_fq *fq =per_cpu_ptr (queue, cpu);
@@ -229,12 +265,16 @@ int init_iova_flush_queue(struct iova_domain *iovad, struct iommu_domain *fq_domINIT_LIST_HEAD (&fq->entries[i].freelist); } - iovad->fq_domain = fq_domain; - iovad->fq = queue; - -timer_setup (&iovad->fq_timer, fq_flush_timeout,0 ); -atomic_set (&iovad->fq_timer_on,0 ); + cookie->fq = queue; +timer_setup (&cookie->fq_timer, fq_flush_timeout,0 ); +atomic_set (&cookie->fq_timer_on,0 ); +/* +* Prevent incomplete fq state being observable. Pairs with path from +* __iommu_dma_unmap() through iommu_dma_free_iova() to queue_iova() +*/ +smp_wmb (); +WRITE_ONCE (cookie->fq_domain, domain);return 0 ; }
@@ -320,7 +360,7 @@ void iommu_put_dma_cookie(struct iommu_domain *domain)return ;if (cookie->type ==IOMMU_DMA_IOVA_COOKIE && cookie->iovad.granule) { -free_iova_flush_queue (&cookie->iovad); +iommu_dma_free_fq (cookie);put_iova_domain (&cookie->iovad); }
@@ -469,29 +509,6 @@ static bool dev_use_swiotlb(struct device *dev)return IS_ENABLED (CONFIG_SWIOTLB ) &&dev_is_untrusted (dev); } -/* sysfs updates are serialised by the mutex of the group owning @domain */ -int iommu_dma_init_fq (struct iommu_domain *domain) -{ -struct iommu_dma_cookie *cookie = domain->iova_cookie; -int ret; - -if (cookie->fq_domain) -return 0 ; - - ret =init_iova_flush_queue (&cookie->iovad, domain); -if (ret) { -pr_warn ("iova flush queue initialization failed\n" ); -return ret; - } -/* -* Prevent incomplete iovad->fq being observable. Pairs with path from -* __iommu_dma_unmap() through iommu_dma_free_iova() to queue_iova() -*/ -smp_wmb (); -WRITE_ONCE (cookie->fq_domain, domain); -return 0 ; -} -/** * iommu_dma_init_domain - Initialise a DMA mapping domain * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie()
@@ -630,7 +647,7 @@ static void iommu_dma_free_iova(struct iommu_dma_cookie *cookie,if (cookie->type ==IOMMU_DMA_MSI_COOKIE ) cookie->msi_iova -= size;else if (gather && gather->queued) -queue_iova (iovad,iova_pfn (iovad, iova), +queue_iova (cookie,iova_pfn (iovad, iova), size >>iova_shift (iovad), &gather->freelist);else
drivers/iommu/iova.c +0 -2
@@ -61,8 +61,6 @@ init_iova_domain(struct iova_domain *iovad, unsigned long granule, iovad->start_pfn = start_pfn; iovad->dma_32bit_pfn =1UL << (32 -iova_shift (iovad)); iovad->max32_alloc_size = iovad->dma_32bit_pfn; - iovad->fq_domain =NULL ; - iovad->fq =NULL ; iovad->anchor.pfn_lo = iovad->anchor.pfn_hi =IOVA_ANCHOR ;rb_link_node (&iovad->anchor.node,NULL , &iovad->rbroot.rb_node);rb_insert_color (&iovad->anchor.node, &iovad->rbroot);
include/linux/iova.h +1 -43
76 lines not on this page · raw message
Signature · 6 lines
2.28.0.dirty _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
kernel test robot
build botRe: [PATCH 9/9] iommu: Move flush queue data into iommu_dma_cookie
I love your patch! Perhaps something to improve:
Hi Robin,
I love your patch! Perhaps something to improve:
[auto build test WARNING on joro-iommu/next]
[also build test WARNING on v5.16-rc2 next-20211123]
[cannot apply to tegra-drm/drm/tegra/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Robin-Murphy/iommu-Refactor-flush-queues-into-iommu-dma/20211123-221220 base: https://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git next config: arm-defconfig (https://download.01.org/0day-ci/archive/20211124/202111240645.30neUyaq-lkp(a)intel.com/config.gz) compiler: arm-linux-gnueabi-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/d4623bb02366503fa7c3805228fa9534c9490d20
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Robin-Murphy/iommu-Refactor-flush-queues-into-iommu-dma/20211123-221220 git checkout d4623bb02366503fa7c3805228fa9534c9490d20
# save the config file to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross ARCH=arm
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
drivers/gpu/drm/tegra/vic.c: In function 'vic_exit':
drivers/gpu/drm/tegra/vic.c:196:17: error: implicit declaration of function 'dma_unmap_single'; did you mean 'mount_single'? [-Werror=implicit-function-declaration]
196 | dma_unmap_single(vic->dev, vic->falcon.firmware.phys,
| ^~~~~~~~~~~~~~~~
| mount_single
drivers/gpu/drm/tegra/vic.c:197:61: error: 'DMA_TO_DEVICE' undeclared (first use in this function); did you mean 'MT_DEVICE'?
197 | vic->falcon.firmware.size, DMA_TO_DEVICE);
| ^~~~~~~~~~~~~
| MT_DEVICE
drivers/gpu/drm/tegra/vic.c:197:61: note: each undeclared identifier is reported only once for each function it appears in
drivers/gpu/drm/tegra/vic.c:202:17: error: implicit declaration of function 'dma_free_coherent' [-Werror=implicit-function-declaration]
202 | dma_free_coherent(vic->dev, vic->falcon.firmware.size,
| ^~~~~~~~~~~~~~~~~
drivers/gpu/drm/tegra/vic.c: In function 'vic_load_firmware':
drivers/gpu/drm/tegra/vic.c:234:24: error: implicit declaration of function 'dma_alloc_coherent' [-Werror=implicit-function-declaration]
234 | virt = dma_alloc_coherent(vic->dev, size, &iova, GFP_KERNEL);
| ^~~~~~~~~~~~~~~~~~
>> drivers/gpu/drm/tegra/vic.c:234:22: warning: assignment to 'void *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
234 | virt = dma_alloc_coherent(vic->dev, size, &iova, GFP_KERNEL);
| ^
drivers/gpu/drm/tegra/vic.c:236:23: error: implicit declaration of function 'dma_mapping_error' [-Werror=implicit-function-declaration]
236 | err = dma_mapping_error(vic->dev, iova);
| ^~~~~~~~~~~~~~~~~
drivers/gpu/drm/tegra/vic.c:258:24: error: implicit declaration of function 'dma_map_single' [-Werror=implicit-function-declaration]
258 | phys = dma_map_single(vic->dev, virt, size, DMA_TO_DEVICE);
| ^~~~~~~~~~~~~~
drivers/gpu/drm/tegra/vic.c:258:61: error: 'DMA_TO_DEVICE' undeclared (first use in this function); did you mean 'MT_DEVICE'?
258 | phys = dma_map_single(vic->dev, virt, size, DMA_TO_DEVICE);
| ^~~~~~~~~~~~~
| MT_DEVICE
drivers/gpu/drm/tegra/vic.c: In function 'vic_probe':
drivers/gpu/drm/tegra/vic.c:412:15: error: implicit declaration of function 'dma_coerce_mask_and_coherent' [-Werror=implicit-function-declaration]
412 | err = dma_coerce_mask_and_coherent(dev, *dev->parent->dma_mask);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~cc1: some warnings being treated as errors
vim +234 drivers/gpu/drm/tegra/vic.c
0ae797a8ba05a2 Arto Merilainen 2016-12-14 214
77a0b09dd993c8 Thierry Reding 2019-02-01 215 static int vic_load_firmware(struct vic *vic)
77a0b09dd993c8 Thierry Reding 2019-02-01 216 {
20e7dce255e96a Thierry Reding 2019-10-28 217 struct host1x_client *client = &vic->client.base;
20e7dce255e96a Thierry Reding 2019-10-28 218 struct tegra_drm *tegra = vic->client.drm;
d972d624762805 Thierry Reding 2019-10-28 219 dma_addr_t iova;
20e7dce255e96a Thierry Reding 2019-10-28 220 size_t size;
20e7dce255e96a Thierry Reding 2019-10-28 221 void *virt;
77a0b09dd993c8 Thierry Reding 2019-02-01 222 int err;
77a0b09dd993c8 Thierry Reding 2019-02-01 223
d972d624762805 Thierry Reding 2019-10-28 224 if (vic->falcon.firmware.virt)
77a0b09dd993c8 Thierry Reding 2019-02-01 225 return 0;
77a0b09dd993c8 Thierry Reding 2019-02-01 226
77a0b09dd993c8 Thierry Reding 2019-02-01 227 err = falcon_read_firmware(&vic->falcon, vic->config->firmware);
77a0b09dd993c8 Thierry Reding 2019-02-01 228 if (err < 0)
20e7dce255e96a Thierry Reding 2019-10-28 229 return err;
20e7dce255e96a Thierry Reding 2019-10-28 230
20e7dce255e96a Thierry Reding 2019-10-28 231 size = vic->falcon.firmware.size;
20e7dce255e96a Thierry Reding 2019-10-28 232
20e7dce255e96a Thierry Reding 2019-10-28 233 if (!client->group) {
d972d624762805 Thierry Reding 2019-10-28 @234 virt = dma_alloc_coherent(vic->dev, size, &iova, GFP_KERNEL);
20e7dce255e96a Thierry Reding 2019-10-28 235
d972d624762805 Thierry Reding 2019-10-28 236 err = dma_mapping_error(vic->dev, iova);
20e7dce255e96a Thierry Reding 2019-10-28 237 if (err < 0)
20e7dce255e96a Thierry Reding 2019-10-28 238 return err;
20e7dce255e96a Thierry Reding 2019-10-28 239 } else {
d972d624762805 Thierry Reding 2019-10-28 240 virt = tegra_drm_alloc(tegra, size, &iova);
20e7dce255e96a Thierry Reding 2019-10-28 241 }
20e7dce255e96a Thierry Reding 2019-10-28 242
d972d624762805 Thierry Reding 2019-10-28 243 vic->falcon.firmware.virt = virt;
d972d624762805 Thierry Reding 2019-10-28 244 vic->falcon.firmware.iova = iova;
77a0b09dd993c8 Thierry Reding 2019-02-01 245
77a0b09dd993c8 Thierry Reding 2019-02-01 246 err = falcon_load_firmware(&vic->falcon);
77a0b09dd993c8 Thierry Reding 2019-02-01 247 if (err < 0)
77a0b09dd993c8 Thierry Reding 2019-02-01 248 goto cleanup;
77a0b09dd993c8 Thierry Reding 2019-02-01 249
20e7dce255e96a Thierry Reding 2019-10-28 250 /*
20e7dce255e96a Thierry Reding 2019-10-28 251 * In this case we have received an IOVA from the shared domain, so we
20e7dce255e96a Thierry Reding 2019-10-28 252 * need to make sure to get the physical address so that the DMA API
20e7dce255e96a Thierry Reding 2019-10-28 253 * knows what memory pages to flush the cache for.
20e7dce255e96a Thierry Reding 2019-10-28 254 */
20e7dce255e96a Thierry Reding 2019-10-28 255 if (client->group) {
d972d624762805 Thierry Reding 2019-10-28 256 dma_addr_t phys;
d972d624762805 Thierry Reding 2019-10-28 257
20e7dce255e96a Thierry Reding 2019-10-28 258 phys = dma_map_single(vic->dev, virt, size, DMA_TO_DEVICE);
20e7dce255e96a Thierry Reding 2019-10-28 259
20e7dce255e96a Thierry Reding 2019-10-28 260 err = dma_mapping_error(vic->dev, phys);
20e7dce255e96a Thierry Reding 2019-10-28 261 if (err < 0)
20e7dce255e96a Thierry Reding 2019-10-28 262 goto cleanup;
20e7dce255e96a Thierry Reding 2019-10-28 263
d972d624762805 Thierry Reding 2019-10-28 264 vic->falcon.firmware.phys = phys;
20e7dce255e96a Thierry Reding 2019-10-28 265 }
20e7dce255e96a Thierry Reding 2019-10-28 266
77a0b09dd993c8 Thierry Reding 2019-02-01 267 return 0;
77a0b09dd993c8 Thierry Reding 2019-02-01 268
77a0b09dd993c8 Thierry Reding 2019-02-01 269 cleanup:
20e7dce255e96a Thierry Reding 2019-10-28 270 if (!client->group)
d972d624762805 Thierry Reding 2019-10-28 271 dma_free_coherent(vic->dev, size, virt, iova);
20e7dce255e96a Thierry Reding 2019-10-28 272 else
d972d624762805 Thierry Reding 2019-10-28 273 tegra_drm_free(tegra, size, virt, iova);
20e7dce255e96a Thierry Reding 2019-10-28 274
77a0b09dd993c8 Thierry Reding 2019-02-01 275 return err;
77a0b09dd993c8 Thierry Reding 2019-02-01 276 }
77a0b09dd993c8 Thierry Reding 2019-02-01 277 ---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH 9/9] iommu: Move flush queue data into iommu_dma_cookie
In reply to Robin MurphyQuoted 9 lines · Robin Murphy
ruct
iommu_dma_msi_page{
structlist_headlist;drivers/iommu/dma-iommu.c +2
-1@@ -41,7 +43,19 @@ struct iommu_dma_cookie {enum iommu_dma_cookie_type type; union { /* Full allocator for IOMMU_DMA_IOVA_COOKIE */ -struct iova_domain iovad; + struct { + struct iova_domain iovad;
drivers/iommu/dma-iommu.c struct iommu_dma_cookie { · line 57
Quoted 10 lines
drivers/iommu/dma-iommu.c +10
-0+ +struct iova_fq __percpu *fq;/* Flush queue */ +/* Number of TLB flushes that have been started */ +atomic64_t fq_flush_start_cnt; +/* Number of TLB flushes that have been finished */ +atomic64_t fq_flush_finish_cnt; +/* Timer to regularily empty the flush queues */ +struct timer_list fq_timer; +/* 1 when timer is active, 0 when not */ +atomic_t fq_timer_on;
I thought that putting all the FQ stuff in its own structure would be neater, but that's just personal preference.
Thanks,
John
Robin Murphy
maintainerRe: [PATCH 9/9] iommu: Move flush queue data into iommu_dma_cookie
Quoted 14 lines · John Garry
Quoted 13 lines · Robin Murphy
ruct
iommu_dma_msi_page{
struct list_head list;drivers/iommu/dma-iommu.c +6
-1@@ -41,7 +43,19 @@ struct iommu_dma_cookie { enum iommu_dma_cookie_type type; union { /* Full allocator for IOMMU_DMA_IOVA_COOKIE */ - struct iova_domain iovad; + struct { + struct iova_domain iovad; + + struct iova_fq __percpu *fq; /* Flush queue */ + /* Number of TLB flushes that have been started */ + atomic64_t fq_flush_start_cnt;
Quoted 8 lines
drivers/iommu/dma-iommu.c struct iommu_dma_cookie { · line 57
Quoted 6 lines
drivers/iommu/dma-iommu.c +6
-0+ /* Number of TLB flushes that have been finished */ + atomic64_t fq_flush_finish_cnt; + /* Timer to regularily empty the flush queues */ + struct timer_list fq_timer; + /* 1 when timer is active, 0 when not */ + atomic_t fq_timer_on;I thought that putting all the FQ stuff in its own structure would be neater, but that's just personal preference.
But look, it is! ;)
The iova_domain is still a fundamental part of the flush queue built around it; the rest of the machinery can't stand in isolation. It's just an anonymous structure because I don't feel like needlessly cluttering up the code with "cookie->fq.fq" silliness.
Cheers,
Robin.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Quoted 14 lines · Robin Murphy
As promised, this series cleans up the flush queue code and streamlines it directly into iommu-dma. Since we no longer have per-driver DMA ops implementations, a lot of the abstraction is now no longer necessary, so there's a nice degree of simplification in the process. Un-abstracting the queued page freeing mechanism is also the perfect opportunity to revise which struct page fields we use so we can be better-behaved from the MM point of view, thanks to Matthew.
These changes should also make it viable to start using the gather freelist in io-pgtable-arm, and eliminate some more synchronous invalidations from the normal flow there, but that is proving to need a bit more careful thought than I have time for in this cycle, so I've parked that again for now and will revisit it in the new year.
Quoted 6 lines
For convenience, branch at:
https://gitlab.arm.com/linux-arm/linux-rm/-/tree/iommu/iovaI've build-tested for
x86_64, and boot-tested arm64 to the point of confirming thatput_pages_list()gets passed a valid empty list when flushing, while everything else still works.
My interest is in patches 2, 3, 7, 8, 9, and they look ok. I did a bit of testing for strict and non-strict mode on my arm64 system and no problems.
Apart from this, I noticed that one possible optimization could be to avoid so many reads of fq_flush_finish_cnt, as we seem to have a pattern of fq_flush_iotlb()->atomic64_inc(fq_flush_finish_cnt) followed by a read of fq_flush_finish_cnt in fq_ring_free(), so we could use atomic64_inc_return(fq_flush_finish_cnt) and reuse the value. I think that any racing in fq_flush_finish_cnt accesses are latent, but maybe there is a flaw in this. However I tried something along these lines and got a 2.4% throughput gain for my storage scenario.
Thanks,
John
Robin Murphy
maintainerQuoted 18 lines · John Garry
Quoted 17 lines · Robin Murphy
As promised, this series cleans up the flush queue code and streamlines it directly into iommu-dma. Since we no longer have per-driver DMA ops implementations, a lot of the abstraction is now no longer necessary, so there's a nice degree of simplification in the process. Un-abstracting the queued page freeing mechanism is also the perfect opportunity to revise which struct page fields we use so we can be better-behaved from the MM point of view, thanks to Matthew.
These changes should also make it viable to start using the gather freelist in io-pgtable-arm, and eliminate some more synchronous invalidations from the normal flow there, but that is proving to need a bit more careful thought than I have time for in this cycle, so I've parked that again for now and will revisit it in the new year.
For convenience, branch at:
https://gitlab.arm.com/linux-arm/linux-rm/-/tree/iommu/iova
Quoted 6 lines
Quoted 3 lines
I've build-tested for
x86_64, and boot-tested arm64 to the point of confirming thatput_pages_list()gets passed a valid empty list when flushing, while everything else still works.My interest is in patches 2, 3, 7, 8, 9, and they look ok. I did a bit of testing for strict and non-strict mode on my arm64 system and no problems.
Apart from this, I noticed that one possible optimization could be to avoid so many reads of
fq_flush_finish_cnt, as we seem to have a pattern of fq_flush_iotlb()->atomic64_inc(fq_flush_finish_cnt) followed by a read offq_flush_finish_cntinfq_ring_free(), so we could useatomic64_inc_return(fq_flush_finish_cnt)and reuse the value. I think that any racing infq_flush_finish_cntaccesses are latent, but maybe there is a flaw in this. However I tried something along these lines and got a 2.4% throughput gain for my storage scenario.
Yes, that sounds reasonable - off-hand I can't see that there's any more potential for harmful races either. All that jumps out is the case where the flush count gets bumped via queue_iova() while another CPU is already running fq_flush_timeout(), where freeing newer IOVAs added since the timeout is then more likely to be left to the local CPU, or postponed until the next flush cycle entirely, rather than being piled on to the guy already processing the for_each_possible_cpu() loop. And I can't help thinking that could only be a *good* thing, given how the FQ timeout seems to be a smoking gun in your "performance never recovers after falling off the cliff" scenario :)
Robin.
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu