powerpc/64: __ioremap_at clean up in the error case
Subsystems (2)
Nicholas Piggin
reviewerPATCH 1/3 powerpc/64: __ioremap_at clean up in the error case
__ioremap_at error handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.
---
This series is a different approach to the problem, using the generic ioremap_page_range directly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.
arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)
arch/powerpc/mm/pgtable_64.c +20 -7
@@ -108,14 +108,30 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif +static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +} +/** * __ioremap_at - Low level function to establish the page tables * for an IO mapping */ void __iomem *__ioremap_at (phys_addr_t pa,void *ea,unsigned long size,pgprot_t prot) { -unsigned long i; -/* We don't support the 4K PFN hack with ioremap */ if (pgprot_val (prot) &H_PAGE_4K_PFN )return NULL ;
@@ -129,9 +145,8 @@ void __iomem *__ioremap_at(phys_addr_t pa, void *ea, unsigned long size, pgprot_WARN_ON (((unsigned long )ea) & ~PAGE_MASK );WARN_ON (size & ~PAGE_MASK ); -for (i =0 ; i < size; i +=PAGE_SIZE ) -if (map_kernel_page ((unsigned long )ea + i, pa + i, prot)) -return NULL ; +if (ioremap_range ((unsigned long )ea, pa, size, prot,NUMA_NO_NODE )) +return NULL ;return (void __iomem *)ea; }
@@ -182,8 +197,6 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size, area->phys_addr = paligned; ret =__ioremap_at (paligned, area->addr, size, prot); -if (!ret) -vunmap (area->addr); }else { ret =__ioremap_at (paligned, (void *)ioremap_bot, size, prot);if (ret)
Signature · 1 line
2.20.1
Nicholas Piggin
reviewerPATCH 2/3 powerpc/64s/radix: ioremap use ioremap_page_range
Radix can use ioremap_page_range for ioremap, after slab is available. This makes it possible to enable huge ioremap mapping support.
--- arch/powerpc/include/asm/book3s/64/radix.h | 3 +++ arch/powerpc/mm/book3s64/pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/book3s64/radix_pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/pgtable_64.c | 2 +- 4 files changed, 46 insertions(+), 1 deletion(-)
arch/powerpc/include/asm/book3s/64/radix.h +3 -0
@@ -266,6 +266,9 @@ extern void radix__vmemmap_remove_mapping(unsigned long start,extern int radix__map_kernel_page (unsigned long ea,unsigned long pa,pgprot_t flags,unsigned int psz); +extern int radix__ioremap_range (unsigned long ea,phys_addr_t pa, +unsigned long size,pgprot_t prot,int nid); +static inline unsigned long radix__get_tree_size (void ) {unsigned long rts_field;
arch/powerpc/mm/book3s64/pgtable.c +21 -0
@@ -450,3 +450,24 @@ int pmd_move_must_withdraw(struct spinlock *new_pmd_ptl,return true; } + +int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +if (radix_enabled ()) +return radix__ioremap_range (ea, pa, size, prot, nid); + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +}
arch/powerpc/mm/book3s64/radix_pgtable.c +21 -0
@@ -11,6 +11,7 @@#define pr_fmt (fmt) "radix-mmu: " fmt +#include <linux/io.h> #include <linux/kernel.h> #include <linux/sched/mm.h> #include <linux/memblock.h>
@@ -1122,3 +1123,23 @@ void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,set_pte_at (mm, addr, ptep, pte); } + +int radix__ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size, +pgprot_t prot,int nid) +{ +if (likely (slab_is_available ())) { +int err =ioremap_page_range (ea, ea + size, pa, prot); +if (err) +unmap_kernel_range (ea, size); +return err; + }else { +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (WARN_ON_ONCE (err))/* Should clean up */ +return err; + } +return 0 ; + } +}
arch/powerpc/mm/pgtable_64.c +1 -1
@@ -108,7 +108,7 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif -static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +int __weak ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) {unsigned long i;
Signature · 1 line
2.20.1
Nicholas Piggin
reviewerPATCH 3/3 powerpc/64s/radix: Enable HAVE_ARCH_HUGE_VMAP
In reply to Nicholas PigginThis sets the HAVE_ARCH_HUGE_VMAP option, and defines the required page table functions.
This enables huge (2MB and 1GB) ioremap mappings. I don't have a benchmark for this change, but huge vmap will be used by a later core kernel change to enable huge vmalloc memory mappings. This improves cached git diff performance by about 5% on a 2-node POWER9 with 32MB size dentry cache hash.
Profiling git diff dTLB misses with a vanilla kernel:
81.75% git [kernel.vmlinux] [k] __d_lookup_rcu 7.21% git [kernel.vmlinux] [k] strncpy_from_user 1.77% git [kernel.vmlinux] [k] find_get_entry 1.59% git [kernel.vmlinux] [k] kmem_cache_free
40,168 dTLB-miss
0.100342754 seconds time elapsedWith powerpc huge vmalloc:
2,987 dTLB-miss
0.095933138 seconds time elapsed--- .../admin-guide/kernel-parameters.txt | 2 +- arch/powerpc/Kconfig | 1 + arch/powerpc/include/asm/book3s/64/pgtable.h | 8 ++ arch/powerpc/mm/book3s64/radix_pgtable.c | 100 ++++++++++++++++++ 4 files changed, 110 insertions(+), 1 deletion(-)
Documentation/admin-guide/kernel-parameters.txt +1 -1
@@ -2927,7 +2927,7 @@ register save and restore. The kernel will only save legacy floating-point registers on task switch. - nohugeiomap [KNL,x86] Disable kernel huge I/O mappings. + nohugeiomap [KNL,x86,PPC] Disable kernel huge I/O mappings. nosmt [KNL,S390] Disable symmetric multithreading (SMT). Equivalent to smt=1.
arch/powerpc/Kconfig +1 -0
@@ -167,6 +167,7 @@ config PPC select GENERIC_STRNLEN_USER select GENERIC_TIME_VSYSCALL select HAVE_ARCH_AUDITSYSCALL + select HAVE_ARCH_HUGE_VMAP if PPC_BOOK3S_64 && PPC_RADIX_MMU select HAVE_ARCH_JUMP_LABEL select HAVE_ARCH_KASAN if PPC32 select HAVE_ARCH_KGDB
arch/powerpc/include/asm/book3s/64/pgtable.h +8 -0
@@ -274,6 +274,14 @@ extern unsigned long __vmalloc_end;#define VMALLOC_START __vmalloc_start#define VMALLOC_END __vmalloc_end +static inline unsigned int ioremap_max_order (void ) +{ +if (radix_enabled ()) +return PUD_SHIFT ; +return 7 +PAGE_SHIFT ;/* default from linux/vmalloc.h */ +} +#define IOREMAP_MAX_ORDER ioremap_max_order() +extern unsigned long __kernel_virt_start;extern unsigned long __kernel_virt_size;extern unsigned long __kernel_io_start;
arch/powerpc/mm/book3s64/radix_pgtable.c +100 -0
106 lines not on this page · raw message
Signature · 1 line
2.20.1
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 20 lines
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>---
This series is a different approach to the problem, using the generic
ioremap_page_rangedirectly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)arch/powerpc/mm/pgtable_64.c +0
-0
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 116
Quoted 9 lines
arch/powerpc/mm/pgtable_64.c +6
-0@@ -108,14 +108,30 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif +static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot);
Missing a blank line
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 117
Quoted 1 line
arch/powerpc/mm/pgtable_64.c +1
-0+if (err) {
I'd have done the following to reduce indentation depth
if (!err) continue
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 119
Quoted 2 lines
arch/powerpc/mm/pgtable_64.c +2
-0+if (slab_is_available ()) +unmap_kernel_range (ea, size);
Shouldn't it be unmap_kernel_range(ea, i) ?
Christophe
Quoted 42 lines
arch/powerpc/mm/pgtable_64.c +11
-7+else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +} +/** * __ioremap_at - Low level function to establish the page tables * for an IO mapping */ void __iomem *__ioremap_at (phys_addr_t pa,void *ea,unsigned long size,pgprot_t prot) { -unsigned long i; -/* We don't support the 4K PFN hack with ioremap */ if (pgprot_val (prot) &H_PAGE_4K_PFN )return NULL ;@@ -129,9 +145,8 @@ void __iomem *__ioremap_at(phys_addr_t pa, void *ea, unsigned long size, pgprot_WARN_ON (((unsigned long )ea) & ~PAGE_MASK );WARN_ON (size & ~PAGE_MASK ); -for (i =0 ; i < size; i +=PAGE_SIZE ) -if (map_kernel_page ((unsigned long )ea + i, pa + i, prot)) -return NULL ; +if (ioremap_range ((unsigned long )ea, pa, size, prot,NUMA_NO_NODE )) +return NULL ;return (void __iomem *)ea; }@@ -182,8 +197,6 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size, area->phys_addr = paligned; ret =__ioremap_at (paligned, area->addr, size, prot); -if (!ret) -vunmap (area->addr); }else { ret =__ioremap_at (paligned, (void *)ioremap_bot, size, prot);if (ret)
Re: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Nicholas PigginLe 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 16 lines
Radix can use
ioremap_page_rangefor ioremap, after slab is available. This makes it possible to enable huge ioremap mapping support.Signed-off-by Nicholas Piggin <[email protected]>--- arch/powerpc/include/asm/book3s/64/radix.h | 3 +++ arch/powerpc/mm/book3s64/pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/book3s64/radix_pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/pgtable_64.c | 2 +- 4 files changed, 46 insertions(+), 1 deletion(-)arch/powerpc/include/asm/book3s/64/radix.h +0
-0
arch/powerpc/include/asm/book3s/64/radix.h extern void radix__vmemmap_remove_mapping(unsigned long start, · line 271
Quoted 6 lines
arch/powerpc/include/asm/book3s/64/radix.h +3
-0@@ -266,6 +266,9 @@ extern void radix__vmemmap_remove_mapping(unsigned long start,extern int radix__map_kernel_page (unsigned long ea,unsigned long pa,pgprot_t flags,unsigned int psz); +extern int radix__ioremap_range (unsigned long ea,phys_addr_t pa, +unsigned long size,pgprot_t prot,int nid); +
'extern' is pointless here, and checkpatch will cry.
Quoted 8 lines
arch/powerpc/include/asm/book3s/64/radix.h +0
-0static inline unsigned long radix__get_tree_size (void ) {unsigned long rts_field;arch/powerpc/mm/book3s64/pgtable.c +0
-0
arch/powerpc/mm/book3s64/pgtable.c int pmd_move_must_withdraw(struct spinlock *new_pmd_ptl, · line 459
Quoted 10 lines
arch/powerpc/mm/book3s64/pgtable.c +7
-0@@ -450,3 +450,24 @@ int pmd_move_must_withdraw(struct spinlock *new_pmd_ptl,return true; } + +int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +if (radix_enabled ()) +return radix__ioremap_range (ea, pa, size, prot, nid);
This function looks pretty similar to the one in the previous patch.
Since radix_enabled() is available and return false for all other subarches, I think the above could go in the generic ioremap_range(), you'll only need to move the function declaration in a common file, for instance asm/io.h
Quoted 37 lines
arch/powerpc/mm/book3s64/pgtable.c +14
-0+ +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +}arch/powerpc/mm/book3s64/radix_pgtable.c +8
-0@@ -11,6 +11,7 @@#define pr_fmt (fmt) "radix-mmu: " fmt +#include <linux/io.h> #include <linux/kernel.h> #include <linux/sched/mm.h> #include <linux/memblock.h> @@ -1122,3 +1123,23 @@ void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,set_pte_at (mm, addr, ptep, pte); } + +int radix__ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size, +pgprot_t prot,int nid) +{ +if (likely (slab_is_available ())) { +int err =ioremap_page_range (ea, ea + size, pa, prot); +if (err)
arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma, · line 1142
Quoted 10 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +10
-0+unmap_kernel_range (ea, size); +return err; + }else { +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (WARN_ON_ONCE (err))/* Should clean up */ +return err; + }
Same loop again.
What about not doing a radix specific function and just putting something like below in the core ioremap_range() function ?
if (likely(slab_is_available()) && radix_enabled()) {
int err = ioremap_page_range(ea, ea + size, pa, prot);
if (err)
unmap_kernel_range(ea, size);
return err;
}Because I'm pretty sure will more and more use ioremap_page_range().
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 111
Quoted 13 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +3
-0+return 0 ; + } +}arch/powerpc/mm/pgtable_64.c +1
-1@@ -108,7 +108,7 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif -static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +int __weak ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid)
Hum. Weak functions remain in unused in vmlinux unless CONFIG_LD_DEAD_CODE_DATA_ELIMINATION is selected.
Also, they are some how dangerous because people might change them without seeing that it is overridden for some particular configuration.
Christophe
Quoted 4 lines
arch/powerpc/mm/pgtable_64.c +0
-0{unsigned long i;
Nicholas Piggin
reviewerRe: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 114 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 16 lines
Radix can use
ioremap_page_rangefor ioremap, after slab is available. This makes it possible to enable huge ioremap mapping support.Signed-off-by Nicholas Piggin <[email protected]>--- arch/powerpc/include/asm/book3s/64/radix.h | 3 +++ arch/powerpc/mm/book3s64/pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/book3s64/radix_pgtable.c | 21 +++++++++++++++++++++ arch/powerpc/mm/pgtable_64.c | 2 +- 4 files changed, 46 insertions(+), 1 deletion(-)arch/powerpc/include/asm/book3s/64/radix.h +0
-0arch/powerpc/include/asm/book3s/64/radix.h extern void radix__vmemmap_remove_mapping(unsigned long start, · line 271
Quoted 6 lines
arch/powerpc/include/asm/book3s/64/radix.h +3
-0@@ -266,6 +266,9 @@ extern void radix__vmemmap_remove_mapping(unsigned long start,extern int radix__map_kernel_page (unsigned long ea,unsigned long pa,pgprot_t flags,unsigned int psz); +extern int radix__ioremap_range (unsigned long ea,phys_addr_t pa, +unsigned long size,pgprot_t prot,int nid); +'extern' is pointless here, and checkpatch will cry.
Quoted 8 lines
arch/powerpc/include/asm/book3s/64/radix.h +0
-0static inline unsigned long radix__get_tree_size (void ) {unsigned long rts_field;arch/powerpc/mm/book3s64/pgtable.c +0
-0arch/powerpc/mm/book3s64/pgtable.c int pmd_move_must_withdraw(struct spinlock *new_pmd_ptl, · line 459
Quoted 10 lines
arch/powerpc/mm/book3s64/pgtable.c +7
-0@@ -450,3 +450,24 @@ int pmd_move_must_withdraw(struct spinlock *new_pmd_ptl,return true; } + +int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +if (radix_enabled ()) +return radix__ioremap_range (ea, pa, size, prot, nid);This function looks pretty similar to the one in the previous patch. Since
radix_enabled()is available and return false for all other subarches, I think the above could go in the genericioremap_range(), you'll only need to move the function declaration in a common file, for instanceasm/io.hQuoted 37 lines
arch/powerpc/mm/book3s64/pgtable.c +14
-0+ +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +}arch/powerpc/mm/book3s64/radix_pgtable.c +8
-0@@ -11,6 +11,7 @@#define pr_fmt (fmt) "radix-mmu: " fmt +#include <linux/io.h> #include <linux/kernel.h> #include <linux/sched/mm.h> #include <linux/memblock.h> @@ -1122,3 +1123,23 @@ void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,set_pte_at (mm, addr, ptep, pte); } + +int radix__ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size, +pgprot_t prot,int nid) +{ +if (likely (slab_is_available ())) { +int err =ioremap_page_range (ea, ea + size, pa, prot); +if (err)arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma, · line 1142
Quoted 10 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +10
-0+unmap_kernel_range (ea, size); +return err; + }else { +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (WARN_ON_ONCE (err))/* Should clean up */ +return err; + }Same loop again.
What about not doing a radix specific function and just putting something like below in the core
ioremap_range()function ?if (likely(slab_is_available()) && radix_enabled()) { int err = ioremap_page_range(ea, ea + size, pa, prot); if (err) unmap_kernel_range(ea, size); return err; }
Quoted 1 line
Because I'm pretty sure will more and more use
ioremap_page_range().
Well I agree the duplication is not so nice, but it's convenient to see what is going on for each MMU type.
There is a significant amount of churn that needs to be done in this layer so I prefer to make it a bit simpler despite duplication.
I would like to remove the early ioremap or make it into its own function. Re-implement map_kernel_page with ioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.
I just wanted to escape out the 64s and hash/radix implementations completely until that settles.
Quoted 8 lines
arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,
Quoted 2 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +1
-1-static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +int __weak ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid)Hum. Weak functions remain in unused in vmlinux unless
CONFIG_LD_DEAD_CODE_DATA_ELIMINATIONis selected.Also, they are some how dangerous because people might change them without seeing that it is overridden for some particular configuration.
Well you shouldn't assume that when you see a weak function, but what's the preferred alternative? A config option?
Thanks,
Nick
Nicholas Piggin
reviewerChristophe Leroy's on June 11, 2019 4:28 pm:
Quoted 35 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 20 lines
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>---
This series is a different approach to the problem, using the generic
ioremap_page_rangedirectly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)arch/powerpc/mm/pgtable_64.c +0
-0arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 116
Quoted 9 lines
arch/powerpc/mm/pgtable_64.c +6
-0@@ -108,14 +108,30 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif +static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot);Missing a blank line
Quoted 6 lines
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 117
Quoted 1 line
arch/powerpc/mm/pgtable_64.c +1
-0+if (err) {I'd have done the following to reduce indentation depth
if (!err) continue
I'll consider it, line lengths were not too bad.
Quoted 4 lines
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 119
Quoted 2 lines
arch/powerpc/mm/pgtable_64.c +2
-0+if (slab_is_available ()) +unmap_kernel_range (ea, size);Shouldn't it be
unmap_kernel_range(ea, i)?
I guess (i - PAGE_SIZE really), although the old code effectively did the full range. As a "clean up" it may be better to avoid subtle change in behaviour and do that in another patch?
Thanks,
Nick
Re: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Nicholas PigginLe 19/06/2019 à 05:59, Nicholas Piggin a écrit :
Quoted 4 lines
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 3 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
[snip]
Quoted 55 lines
Quoted 47 lines
Quoted 23 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +8
-0@@ -11,6 +11,7 @@#define pr_fmt (fmt) "radix-mmu: " fmt +#include <linux/io.h> #include <linux/kernel.h> #include <linux/sched/mm.h> #include <linux/memblock.h> @@ -1122,3 +1123,23 @@ void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,set_pte_at (mm, addr, ptep, pte); } + +int radix__ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size, +pgprot_t prot,int nid) +{ +if (likely (slab_is_available ())) { +int err =ioremap_page_range (ea, ea + size, pa, prot); +if (err)arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma, · line 1142
Quoted 10 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +10
-0+unmap_kernel_range (ea, size); +return err; + }else { +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (WARN_ON_ONCE (err))/* Should clean up */ +return err; + }Same loop again.
What about not doing a radix specific function and just putting something like below in the core
ioremap_range()function ?if (likely(slab_is_available()) && radix_enabled()) { int err = ioremap_page_range(ea, ea + size, pa, prot); if (err) unmap_kernel_range(ea, size); return err; }Quoted 1 line
Because I'm pretty sure will more and more use
ioremap_page_range().Well I agree the duplication is not so nice, but it's convenient to see what is going on for each MMU type.
There is a significant amount of churn that needs to be done in this layer so I prefer to make it a bit simpler despite duplication.
Quoted 7 lines
I would like to remove the early ioremap or make it into its own function. Re-implement
map_kernel_pagewithioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.I just wanted to escape out the 64s and hash/radix implementations completely until that settles.
I can understand the benefit in some situations but here I just can't. And code duplication should be avoided as much as possible as it makes code maintenance more difficult.
Here you have:
+static int ioremap_range(unsigned long ea, phys_addr_t pa, unsigned long size, pgprot_t prot, int nid) +{
+ unsigned long i;
+
+ for (i = 0; i < size; i += PAGE_SIZE) {
+ int err = map_kernel_page(ea + i, pa + i, prot);
+ if (err) {
+ if (slab_is_available())
+ unmap_kernel_range(ea, size);
+ else
+ WARN_ON_ONCE(1); /* Should clean up */
+ return err;
+ }
+ }
+
+ return 0;
+}
You now create a new one in another file, that is almost identical:
+int ioremap_range(unsigned long ea, phys_addr_t pa, unsigned long size, pgprot_t prot, int nid) +{
+ unsigned long i;
+
+ if (radix_enabled())
+ return radix__ioremap_range(ea, pa, size, prot, nid);
+
+ for (i = 0; i < size; i += PAGE_SIZE) {
+ int err = map_kernel_page(ea + i, pa + i, prot);
+ if (err) {
+ if (slab_is_available())
+ unmap_kernel_range(ea, size);
+ else
+ WARN_ON_ONCE(1); /* Should clean up */
+ return err;
+ }
+ }
+
+ return 0;
+}
Then you have to make the original one __weak.
Sorry I'm still having difficulties understanding what the benefit is.
radix_enabled() is defined for every platforms so could just add the following on top of the existing ioremap_range() and voila.
+ if (radix_enabled())
+ return radix__ioremap_range(ea, pa, size, prot, nid);
And with that you wouldn't have the __weak stuff to handle.
Quoted 7 lines
Quoted 7 lines
arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,
Quoted 3 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +1
-1-static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +int __weak ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid)Hum. Weak functions remain in unused in vmlinux unless
CONFIG_LD_DEAD_CODE_DATA_ELIMINATIONis selected.
Quoted 5 lines
Quoted 2 lines
Also, they are some how dangerous because people might change them without seeing that it is overridden for some particular configuration.
Well you shouldn't assume that when you see a weak function, but what's the preferred alternative? A config option?
Yes you are right, nobody should assume that, but ...
But I think if the fonctions were really different, the preferred alternative would be to move the original function into a file dedicated to nohash64.
Christophe
Le 19/06/2019 à 06:04, Nicholas Piggin a écrit :
Quoted 45 lines
Christophe Leroy's on June 11, 2019 4:28 pm:
Quoted 35 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 20 lines
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>---
This series is a different approach to the problem, using the generic
ioremap_page_rangedirectly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)arch/powerpc/mm/pgtable_64.c +0
-0arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 116
Quoted 9 lines
arch/powerpc/mm/pgtable_64.c +6
-0@@ -108,14 +108,30 @@ unsigned long ioremap_bot;unsigned long ioremap_bot =IOREMAP_BASE ;#endif +static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +{ +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot);Missing a blank line
Quoted 6 lines
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 117
Quoted 1 line
arch/powerpc/mm/pgtable_64.c +1
-0+if (err) {I'd have done the following to reduce indentation depth
if (!err) continueI'll consider it, line lengths were not too bad.
Quoted 8 lines
Quoted 4 lines
arch/powerpc/mm/pgtable_64.c unsigned long ioremap_bot; · line 119
Quoted 2 lines
arch/powerpc/mm/pgtable_64.c +2
-0+if (slab_is_available ()) +unmap_kernel_range (ea, size);Shouldn't it be
unmap_kernel_range(ea, i)?I guess (i -
PAGE_SIZEreally), although the old code effectively did the full range. As a "clean up" it may be better to avoid subtle change in behaviour and do that in another patch?
Not sure we have to do it in another patch.
Previous code was doing full range because it was done at upper level so it didn't know the boundaries. You are creating a nice brand new function that have all necessary information, so why not make it right from the start ?
Christophe
Quoted 4 lines
Thanks,
Nick
Re: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Nicholas PigginLe 19/06/2019 à 05:59, Nicholas Piggin a écrit :
Quoted 8 lines
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 3 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
I would like to remove the early ioremap or make it into its own function. Re-implement
map_kernel_pagewithioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.
Getting early ioremap out of the picture is a very good idea, it will help making things more common between all platform types. Today we face the fact that PPC32 allocates early io from the top of memory while PPC64 allocates it from the bottom of memory.
Any idea on how to proceed ?
Christophe
Nicholas Piggin
reviewerRe: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Christophe LeroyChristophe Leroy's on June 19, 2019 10:49 pm:
Quoted 133 lines
Le 19/06/2019 à 05:59, Nicholas Piggin a écrit :
Quoted 4 lines
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 3 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
[snip]
Quoted 55 lines
Quoted 47 lines
Quoted 23 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +8
-0@@ -11,6 +11,7 @@#define pr_fmt (fmt) "radix-mmu: " fmt +#include <linux/io.h> #include <linux/kernel.h> #include <linux/sched/mm.h> #include <linux/memblock.h> @@ -1122,3 +1123,23 @@ void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,set_pte_at (mm, addr, ptep, pte); } + +int radix__ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size, +pgprot_t prot,int nid) +{ +if (likely (slab_is_available ())) { +int err =ioremap_page_range (ea, ea + size, pa, prot); +if (err)arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma, · line 1142
Quoted 10 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +10
-0+unmap_kernel_range (ea, size); +return err; + }else { +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (WARN_ON_ONCE (err))/* Should clean up */ +return err; + }Same loop again.
What about not doing a radix specific function and just putting something like below in the core
ioremap_range()function ?if (likely(slab_is_available()) && radix_enabled()) { int err = ioremap_page_range(ea, ea + size, pa, prot); if (err) unmap_kernel_range(ea, size); return err; }Quoted 1 line
Because I'm pretty sure will more and more use
ioremap_page_range().Well I agree the duplication is not so nice, but it's convenient to see what is going on for each MMU type.
There is a significant amount of churn that needs to be done in this layer so I prefer to make it a bit simpler despite duplication.
Quoted 7 lines
I would like to remove the early ioremap or make it into its own function. Re-implement
map_kernel_pagewithioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.I just wanted to escape out the 64s and hash/radix implementations completely until that settles.
I can understand the benefit in some situations but here I just can't. And code duplication should be avoided as much as possible as it makes code maintenance more difficult.
Here you have:
+static int
ioremap_range(unsigned long ea, phys_addr_t pa, unsigned long size, pgprot_t prot, int nid)arch/powerpc/mm/book3s64/pgtable.c +16
-0+{ +unsigned long i; + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +}You now create a new one in another file, that is almost identical:
+int
ioremap_range(unsigned long ea, phys_addr_t pa, unsigned long size, pgprot_t prot, int nid)arch/powerpc/mm/book3s64/pgtable.c +19
-0+{ +unsigned long i; + +if (radix_enabled ()) +return radix__ioremap_range (ea, pa, size, prot, nid); + +for (i =0 ; i < size; i +=PAGE_SIZE ) { +int err =map_kernel_page (ea + i, pa + i, prot); +if (err) { +if (slab_is_available ()) +unmap_kernel_range (ea, size); +else +WARN_ON_ONCE (1 );/* Should clean up */ +return err; + } + } + +return 0 ; +}Then you have to make the original one
__weak.Sorry I'm still having difficulties understanding what the benefit is.
radix_enabled()is defined for every platforms so could just add the following on top of the existingioremap_range()and voila.arch/powerpc/mm/book3s64/pgtable.c +2
-0+if (radix_enabled ()) +return radix__ioremap_range (ea, pa, size, prot, nid);
Quoted 1 line
And with that you wouldn't have the
__weakstuff to handle.
I guess so. I don't really like radix_enabled escaping from 64s too much though. I'll try to improve the code in follow ups if possible.
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
arch/powerpc/mm/book3s64/radix_pgtable.c void radix__ptep_modify_prot_commit(struct vm_area_struct *vma,
Quoted 2 lines
arch/powerpc/mm/book3s64/radix_pgtable.c +1
-1-static int ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid) +int __weak ioremap_range (unsigned long ea,phys_addr_t pa,unsigned long size,pgprot_t prot,int nid)Hum. Weak functions remain in unused in vmlinux unless
CONFIG_LD_DEAD_CODE_DATA_ELIMINATIONis selected.Also, they are some how dangerous because people might change them without seeing that it is overridden for some particular configuration.
Quoted 8 lines
Quoted 2 lines
Well you shouldn't assume that when you see a weak function, but what's the preferred alternative? A config option?
Yes you are right, nobody should assume that, but ...
But I think if the fonctions were really different, the preferred alternative would be to move the original function into a file dedicated to nohash64.
Possibly we could do that, but we might be able to just collapse these back to using generic ioremap_page_range.
Thanks,
Nick
Nicholas Piggin
reviewerRe: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Christophe LeroyChristophe Leroy's on June 20, 2019 2:25 am:
Quoted 12 lines
Le 19/06/2019 à 05:59, Nicholas Piggin a écrit :
Quoted 8 lines
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 3 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
I would like to remove the early ioremap or make it into its own function. Re-implement
map_kernel_pagewithioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.
Quoted 6 lines
Getting early ioremap out of the picture is a very good idea, it will help making things more common between all platform types. Today we face the fact that PPC32 allocates early io from the top of memory while PPC64 allocates it from the bottom of memory.
Any idea on how to proceed ?
I have to have a bit better look at other arches and our platform code. Without having looked closely at all the details, I would hope we could use GENERIC_EARLY_IOREMAP without too much pain.
Thanks,
Nick
Quoted 5 lines · Nicholas Piggin
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>
Series applied to powerpc next, thanks.
https://git.kernel.org/powerpc/c/a72808a7ec5d340417a91a81e5cabdaa50650f2e
cheers
Re: [PATCH 2/3] powerpc/64s/radix: ioremap use ioremap_page_range
In reply to Nicholas PigginLe 24/06/2019 à 05:12, Nicholas Piggin a écrit :
Quoted 18 lines
Christophe Leroy's on June 20, 2019 2:25 am:
Quoted 17 lines
Le 19/06/2019 à 05:59, Nicholas Piggin a écrit :
Quoted 8 lines
Christophe Leroy's on June 11, 2019 4:46 pm:
Quoted 3 lines
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
I would like to remove the early ioremap or make it into its own function. Re-implement
map_kernel_pagewithioremap_page_range, allow page tables that don't use slab to avoid the early check, unbolt the hptes mapped in early boot, etc.Getting early ioremap out of the picture is a very good idea, it will help making things more common between all platform types. Today we face the fact that PPC32 allocates early io from the top of memory while PPC64 allocates it from the bottom of memory.
Quoted 6 lines
Quoted 1 line
Any idea on how to proceed ?
I have to have a bit better look at other arches and our platform code. Without having looked closely at all the details, I would hope we could use
GENERIC_EARLY_IOREMAPwithout too much pain.
Good idea.
I have looked at it and implemented it for PPC32. In its own it works well, now the challenge is to move all early call sites of ioremap() to early_ioremap().
I point however is that early_ioremap() expects all maps being released by the time we do paging_init(), whereas several of early PPC ioremap() users never release the mapped area. I think we have to dig into this in more details.
Christophe
Hi Nick,
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 19 lines
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>---
This series is a different approach to the problem, using the generic
ioremap_page_rangedirectly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)arch/powerpc/mm/pgtable_64.c +0
-0
[...]
arch/powerpc/mm/pgtable_64.c void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size, · line 186
Quoted 6 lines
arch/powerpc/mm/pgtable_64.c +0
-2@@ -182,8 +197,6 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size, area->phys_addr = paligned; ret =__ioremap_at (paligned, area->addr, size, prot); -if (!ret) -vunmap (area->addr);
AFAICS, ioremap_range() calls unmap_kernel_range() in the error case,
but I can't see that that function does the vunmap(), does it ?. If not, who frees the area allocated by __get_vm_area_caller() ?
Christophe
Nicholas Piggin
reviewerChristophe Leroy's on August 20, 2019 5:44 pm:
Quoted 27 lines
Hi Nick,
Le 10/06/2019 à 05:08, Nicholas Piggin a écrit :
Quoted 19 lines
__ioremap_aterror handling is wonky, it requires caller to clean up after it. Implement a helper that does the map and error cleanup and remove the requirement from the caller.Signed-off-by Nicholas Piggin <[email protected]>---
This series is a different approach to the problem, using the generic
ioremap_page_rangedirectly which reduces added code, and moves the radix specific code into radix files. Thanks to Christophe for pointing out various problems with the previous patch.arch/powerpc/mm/pgtable_64.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-)arch/powerpc/mm/pgtable_64.c +0
-0[...]
Quoted 2 lines
arch/powerpc/mm/pgtable_64.c +0
-0@@ -182,8 +197,6 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
Quoted 8 lines
arch/powerpc/mm/pgtable_64.c void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size, · line 186
Quoted 4 lines
arch/powerpc/mm/pgtable_64.c +0
-2area->phys_addr = paligned; ret =__ioremap_at (paligned, area->addr, size, prot); -if (!ret) -vunmap (area->addr);AFAICS,
ioremap_range()callsunmap_kernel_range()in the error case, but I can't see that that function does thevunmap(), does it ?. If not, who frees the area allocated by__get_vm_area_caller()?
Oh good catch, I guess we need to keep a free_vm_area here.
Thanks,
Nick