* [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT [not found] <1645425519-9034-1-git-send-email-anshuman.khandual@arm.com> @ 2022-02-21 6:38 ` Anshuman Khandual 2022-02-21 11:54 ` Geert Uytterhoeven 2022-04-22 6:55 ` kernel test robot 0 siblings, 2 replies; 6+ messages in thread From: Anshuman Khandual @ 2022-02-21 6:38 UTC (permalink / raw) To: linux-mm, akpm Cc: linux-kernel, Anshuman Khandual, Christoph Hellwig, linux-arch, Thomas Bogendoerfer, linux-m68k This defines and exports a platform specific custom vm_get_page_prot() via subscribing ARCH_HAS_VM_GET_PAGE_PROT. Subsequently all __SXXX and __PXXX macros can be dropped which are no longer needed. Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> Cc: linux-m68k@lists.linux-m68k.org Cc: linux-kernel@vger.kernel.org Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com> --- arch/m68k/Kconfig | 1 + arch/m68k/include/asm/mcf_pgtable.h | 59 ------------- arch/m68k/include/asm/motorola_pgtable.h | 22 ----- arch/m68k/include/asm/sun3_pgtable.h | 22 ----- arch/m68k/mm/init.c | 104 +++++++++++++++++++++++ arch/m68k/mm/motorola.c | 48 ++++++++++- 6 files changed, 150 insertions(+), 106 deletions(-) diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig index 936e1803c7c7..114e65164692 100644 --- a/arch/m68k/Kconfig +++ b/arch/m68k/Kconfig @@ -11,6 +11,7 @@ config M68K select ARCH_NO_PREEMPT if !COLDFIRE select ARCH_USE_MEMTEST if MMU_MOTOROLA select ARCH_WANT_IPC_PARSE_VERSION + select ARCH_HAS_VM_GET_PAGE_PROT select BINFMT_FLAT_ARGVP_ENVP_ON_STACK select DMA_DIRECT_REMAP if HAS_DMA && MMU && !COLDFIRE select GENERIC_ATOMIC64 diff --git a/arch/m68k/include/asm/mcf_pgtable.h b/arch/m68k/include/asm/mcf_pgtable.h index 6f2b87d7a50d..dc5c8ab6aa57 100644 --- a/arch/m68k/include/asm/mcf_pgtable.h +++ b/arch/m68k/include/asm/mcf_pgtable.h @@ -86,65 +86,6 @@ | CF_PAGE_READABLE \ | CF_PAGE_DIRTY) -/* - * Page protections for initialising protection_map. See mm/mmap.c - * for use. In general, the bit positions are xwr, and P-items are - * private, the S-items are shared. - */ -#define __P000 PAGE_NONE -#define __P001 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE) -#define __P010 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_WRITABLE) -#define __P011 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE \ - | CF_PAGE_WRITABLE) -#define __P100 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_EXEC) -#define __P101 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE \ - | CF_PAGE_EXEC) -#define __P110 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_WRITABLE \ - | CF_PAGE_EXEC) -#define __P111 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE \ - | CF_PAGE_WRITABLE \ - | CF_PAGE_EXEC) - -#define __S000 PAGE_NONE -#define __S001 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE) -#define __S010 PAGE_SHARED -#define __S011 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_SHARED \ - | CF_PAGE_READABLE) -#define __S100 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_EXEC) -#define __S101 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_READABLE \ - | CF_PAGE_EXEC) -#define __S110 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_SHARED \ - | CF_PAGE_EXEC) -#define __S111 __pgprot(CF_PAGE_VALID \ - | CF_PAGE_ACCESSED \ - | CF_PAGE_SHARED \ - | CF_PAGE_READABLE \ - | CF_PAGE_EXEC) - #define PTE_MASK PAGE_MASK #define CF_PAGE_CHG_MASK (PTE_MASK | CF_PAGE_ACCESSED | CF_PAGE_DIRTY) diff --git a/arch/m68k/include/asm/motorola_pgtable.h b/arch/m68k/include/asm/motorola_pgtable.h index 022c3abc280d..4ea1bb57deee 100644 --- a/arch/m68k/include/asm/motorola_pgtable.h +++ b/arch/m68k/include/asm/motorola_pgtable.h @@ -83,28 +83,6 @@ extern unsigned long mm_cachebits; #define PAGE_COPY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED) #define PAGE_READONLY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED) -/* - * The m68k can't do page protection for execute, and considers that the same are read. - * Also, write permissions imply read permissions. This is the closest we can get.. - */ -#define __P000 PAGE_NONE_C -#define __P001 PAGE_READONLY_C -#define __P010 PAGE_COPY_C -#define __P011 PAGE_COPY_C -#define __P100 PAGE_READONLY_C -#define __P101 PAGE_READONLY_C -#define __P110 PAGE_COPY_C -#define __P111 PAGE_COPY_C - -#define __S000 PAGE_NONE_C -#define __S001 PAGE_READONLY_C -#define __S010 PAGE_SHARED_C -#define __S011 PAGE_SHARED_C -#define __S100 PAGE_READONLY_C -#define __S101 PAGE_READONLY_C -#define __S110 PAGE_SHARED_C -#define __S111 PAGE_SHARED_C - #define pmd_pgtable(pmd) ((pgtable_t)pmd_page_vaddr(pmd)) /* diff --git a/arch/m68k/include/asm/sun3_pgtable.h b/arch/m68k/include/asm/sun3_pgtable.h index 5b24283a0a42..086fabdd8d4c 100644 --- a/arch/m68k/include/asm/sun3_pgtable.h +++ b/arch/m68k/include/asm/sun3_pgtable.h @@ -66,28 +66,6 @@ | SUN3_PAGE_SYSTEM \ | SUN3_PAGE_NOCACHE) -/* - * Page protections for initialising protection_map. The sun3 has only two - * protection settings, valid (implying read and execute) and writeable. These - * are as close as we can get... - */ -#define __P000 PAGE_NONE -#define __P001 PAGE_READONLY -#define __P010 PAGE_COPY -#define __P011 PAGE_COPY -#define __P100 PAGE_READONLY -#define __P101 PAGE_READONLY -#define __P110 PAGE_COPY -#define __P111 PAGE_COPY - -#define __S000 PAGE_NONE -#define __S001 PAGE_READONLY -#define __S010 PAGE_SHARED -#define __S011 PAGE_SHARED -#define __S100 PAGE_READONLY -#define __S101 PAGE_READONLY -#define __S110 PAGE_SHARED -#define __S111 PAGE_SHARED /* Use these fake page-protections on PMDs. */ #define SUN3_PMD_VALID (0x00000001) diff --git a/arch/m68k/mm/init.c b/arch/m68k/mm/init.c index 1b47bec15832..b6ef2c6f4e85 100644 --- a/arch/m68k/mm/init.c +++ b/arch/m68k/mm/init.c @@ -128,3 +128,107 @@ void __init mem_init(void) memblock_free_all(); init_pointer_tables(); } + +#ifdef CONFIG_COLDFIRE +/* + * Page protections for initialising protection_map. See mm/mmap.c + * for use. In general, the bit positions are xwr, and P-items are + * private, the S-items are shared. + */ +pgprot_t vm_get_page_prot(unsigned long vm_flags) +{ + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { + case VM_NONE: + return PAGE_NONE; + case VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE); + case VM_WRITE: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_WRITABLE); + case VM_WRITE | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_WRITABLE); + case VM_EXEC: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_EXEC); + case VM_EXEC | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_EXEC); + case VM_EXEC | VM_WRITE: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_WRITABLE | CF_PAGE_EXEC); + case VM_EXEC | VM_WRITE | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_WRITABLE | + CF_PAGE_EXEC); + case VM_SHARED: + return PAGE_NONE; + case VM_SHARED | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE); + case VM_SHARED | VM_WRITE: + return PAGE_SHARED; + case VM_SHARED | VM_WRITE | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_SHARED); + case VM_SHARED | VM_EXEC: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_EXEC); + case VM_SHARED | VM_EXEC | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_EXEC); + case VM_SHARED | VM_EXEC | VM_WRITE: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_SHARED | CF_PAGE_EXEC); + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | + CF_PAGE_READABLE | CF_PAGE_SHARED | + CF_PAGE_EXEC); + default: + BUILD_BUG(); + } +} +#endif + +#ifdef CONFIG_SUN3 +/* + * Page protections for initialising protection_map. The sun3 has only two + * protection settings, valid (implying read and execute) and writeable. These + * are as close as we can get... + */ +pgprot_t vm_get_page_prot(unsigned long vm_flags) +{ + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { + case VM_NONE: + return PAGE_NONE; + case VM_READ: + return PAGE_READONLY; + case VM_WRITE: + case VM_WRITE | VM_READ: + return PAGE_COPY; + case VM_EXEC: + case VM_EXEC | VM_READ: + return PAGE_READONLY; + case VM_EXEC | VM_WRITE: + case VM_EXEC | VM_WRITE | VM_READ: + return PAGE_COPY; + case VM_SHARED: + return PAGE_NONE; + case VM_SHARED | VM_READ: + return PAGE_READONLY; + case VM_SHARED | VM_WRITE: + case VM_SHARED | VM_WRITE | VM_READ: + return PAGE_SHARED; + case VM_SHARED | VM_EXEC: + case VM_SHARED | VM_EXEC | VM_READ: + return PAGE_READONLY; + case VM_SHARED | VM_EXEC | VM_WRITE: + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: + return PAGE_SHARED; + default: + BUILD_BUG(); + } +} +#endif +EXPORT_SYMBOL(vm_get_page_prot); diff --git a/arch/m68k/mm/motorola.c b/arch/m68k/mm/motorola.c index ecbe948f4c1a..495ba0ea083c 100644 --- a/arch/m68k/mm/motorola.c +++ b/arch/m68k/mm/motorola.c @@ -400,12 +400,9 @@ void __init paging_init(void) /* Fix the cache mode in the page descriptors for the 680[46]0. */ if (CPU_IS_040_OR_060) { - int i; #ifndef mm_cachebits mm_cachebits = _PAGE_CACHE040; #endif - for (i = 0; i < 16; i++) - pgprot_val(protection_map[i]) |= _PAGE_CACHE040; } min_addr = m68k_memory[0].addr; @@ -483,3 +480,48 @@ void __init paging_init(void) max_zone_pfn[ZONE_DMA] = memblock_end_of_DRAM(); free_area_init(max_zone_pfn); } + +/* + * The m68k can't do page protection for execute, and considers that + * the same are read. Also, write permissions imply read permissions. + * This is the closest we can get.. + */ +pgprot_t vm_get_page_prot(unsigned long vm_flags) +{ + unsigned long cachebits = 0; + + if (CPU_IS_040_OR_060) + cachebits = _PAGE_CACHE040; + + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { + case VM_NONE: + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); + case VM_READ: + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); + case VM_WRITE: + case VM_WRITE | VM_READ: + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); + case VM_EXEC: + case VM_EXEC | VM_READ: + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); + case VM_EXEC | VM_WRITE: + case VM_EXEC | VM_WRITE | VM_READ: + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); + case VM_SHARED: + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); + case VM_SHARED | VM_READ: + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); + case VM_SHARED | VM_WRITE: + case VM_SHARED | VM_WRITE | VM_READ: + return __pgprot(pgprot_val(PAGE_SHARED_C) | cachebits); + case VM_SHARED | VM_EXEC: + case VM_SHARED | VM_EXEC | VM_READ: + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); + case VM_SHARED | VM_EXEC | VM_WRITE: + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: + return __pgprot(pgprot_val(PAGE_SHARED_C) | cachebits); + default: + BUILD_BUG(); + } +} +EXPORT_SYMBOL(vm_get_page_prot); -- 2.25.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT 2022-02-21 6:38 ` [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT Anshuman Khandual @ 2022-02-21 11:54 ` Geert Uytterhoeven 2022-02-22 5:44 ` Anshuman Khandual 2022-02-25 9:02 ` Geert Uytterhoeven 2022-04-22 6:55 ` kernel test robot 1 sibling, 2 replies; 6+ messages in thread From: Geert Uytterhoeven @ 2022-02-21 11:54 UTC (permalink / raw) To: Anshuman Khandual Cc: Linux MM, Andrew Morton, Linux Kernel Mailing List, Christoph Hellwig, Linux-Arch, Thomas Bogendoerfer, linux-m68k Hi Anshuman, On Mon, Feb 21, 2022 at 9:45 AM Anshuman Khandual <anshuman.khandual@arm.com> wrote: > This defines and exports a platform specific custom vm_get_page_prot() via > subscribing ARCH_HAS_VM_GET_PAGE_PROT. Subsequently all __SXXX and __PXXX > macros can be dropped which are no longer needed. > > Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> > Cc: linux-m68k@lists.linux-m68k.org > Cc: linux-kernel@vger.kernel.org > Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com> Thanks for your patch! > --- a/arch/m68k/mm/init.c > +++ b/arch/m68k/mm/init.c > @@ -128,3 +128,107 @@ void __init mem_init(void) > memblock_free_all(); > init_pointer_tables(); > } > + > +#ifdef CONFIG_COLDFIRE > +/* > + * Page protections for initialising protection_map. See mm/mmap.c > + * for use. In general, the bit positions are xwr, and P-items are > + * private, the S-items are shared. > + */ > +pgprot_t vm_get_page_prot(unsigned long vm_flags) Wouldn't it make more sense to add this to arch/m68k/mm/mcfmmu.c? > +{ > + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { > + case VM_NONE: > + return PAGE_NONE; > + case VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE); > + case VM_WRITE: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_WRITABLE); > + case VM_WRITE | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_WRITABLE); > + case VM_EXEC: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_EXEC); > + case VM_EXEC | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_EXEC); > + case VM_EXEC | VM_WRITE: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_WRITABLE | CF_PAGE_EXEC); > + case VM_EXEC | VM_WRITE | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_WRITABLE | > + CF_PAGE_EXEC); > + case VM_SHARED: > + return PAGE_NONE; > + case VM_SHARED | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE); This is the same as the plain VM_READ case. Perhaps they can be merged? > + case VM_SHARED | VM_WRITE: > + return PAGE_SHARED; > + case VM_SHARED | VM_WRITE | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_SHARED); > + case VM_SHARED | VM_EXEC: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_EXEC); Same as plain VM_EXEC. > + case VM_SHARED | VM_EXEC | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_EXEC); Same as plain VM_EXEC | VM_READ. > + case VM_SHARED | VM_EXEC | VM_WRITE: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_SHARED | CF_PAGE_EXEC); > + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > + CF_PAGE_READABLE | CF_PAGE_SHARED | > + CF_PAGE_EXEC); > + default: > + BUILD_BUG(); > + } > +} > +#endif > + > +#ifdef CONFIG_SUN3 > +/* > + * Page protections for initialising protection_map. The sun3 has only two > + * protection settings, valid (implying read and execute) and writeable. These > + * are as close as we can get... > + */ > +pgprot_t vm_get_page_prot(unsigned long vm_flags) Wouldn't it make more sense to add this to arch/m68k/mm/sun3mmu.c? > +{ > + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { > + case VM_NONE: > + return PAGE_NONE; > + case VM_READ: > + return PAGE_READONLY; > + case VM_WRITE: > + case VM_WRITE | VM_READ: So you did merge some of them... > + return PAGE_COPY; > + case VM_EXEC: > + case VM_EXEC | VM_READ: > + return PAGE_READONLY; But not all? More below... > + case VM_EXEC | VM_WRITE: > + case VM_EXEC | VM_WRITE | VM_READ: > + return PAGE_COPY; > + case VM_SHARED: > + return PAGE_NONE; > + case VM_SHARED | VM_READ: > + return PAGE_READONLY; > + case VM_SHARED | VM_WRITE: > + case VM_SHARED | VM_WRITE | VM_READ: > + return PAGE_SHARED; > + case VM_SHARED | VM_EXEC: > + case VM_SHARED | VM_EXEC | VM_READ: > + return PAGE_READONLY; > + case VM_SHARED | VM_EXEC | VM_WRITE: > + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: > + return PAGE_SHARED; > + default: > + BUILD_BUG(); > + } > +} > +#endif > +EXPORT_SYMBOL(vm_get_page_prot); > diff --git a/arch/m68k/mm/motorola.c b/arch/m68k/mm/motorola.c > index ecbe948f4c1a..495ba0ea083c 100644 > --- a/arch/m68k/mm/motorola.c > +++ b/arch/m68k/mm/motorola.c > @@ -400,12 +400,9 @@ void __init paging_init(void) > > /* Fix the cache mode in the page descriptors for the 680[46]0. */ > if (CPU_IS_040_OR_060) { > - int i; > #ifndef mm_cachebits > mm_cachebits = _PAGE_CACHE040; > #endif > - for (i = 0; i < 16; i++) > - pgprot_val(protection_map[i]) |= _PAGE_CACHE040; > } > > min_addr = m68k_memory[0].addr; > @@ -483,3 +480,48 @@ void __init paging_init(void) > max_zone_pfn[ZONE_DMA] = memblock_end_of_DRAM(); > free_area_init(max_zone_pfn); > } > + > +/* > + * The m68k can't do page protection for execute, and considers that > + * the same are read. Also, write permissions imply read permissions. > + * This is the closest we can get.. > + */ > +pgprot_t vm_get_page_prot(unsigned long vm_flags) Good, this one is in arch/m68k/mm/motorola.c :-) > +{ > + unsigned long cachebits = 0; > + > + if (CPU_IS_040_OR_060) > + cachebits = _PAGE_CACHE040; If you would use the non-"_C"-variants (e.g. PAGE_NONE instead of PAGE_NONE_C) below, you would get the cachebits handling for free! After that, the "_C" variants are no longer used, and can be removed. Cfr. arch/m68k/include/asm/motorola_pgtable.h: #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED | mm_cachebits) #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | mm_cachebits) #define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED | mm_cachebits) #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED | mm_cachebits) #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | _PAGE_ACCESSED | mm_cachebits) /* Alternate definitions that are compile time constants, for initializing protection_map. The cachebits are fixed later. */ #define PAGE_NONE_C __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED) #define PAGE_SHARED_C __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED) #define PAGE_COPY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED) #define PAGE_READONLY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | _PAGE_ACCESSED) BTW, this shows you left a reference in a comment to the now-gone "protection_map". There are several more across the tree. > + > + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { > + case VM_NONE: > + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); > + case VM_READ: > + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); > + case VM_WRITE: > + case VM_WRITE | VM_READ: > + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); > + case VM_EXEC: > + case VM_EXEC | VM_READ: > + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); > + case VM_EXEC | VM_WRITE: > + case VM_EXEC | VM_WRITE | VM_READ: > + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); > + case VM_SHARED: > + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); Same as the VM_NONE case. More to be merged below... > + case VM_SHARED | VM_READ: > + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); > + case VM_SHARED | VM_WRITE: > + case VM_SHARED | VM_WRITE | VM_READ: > + return __pgprot(pgprot_val(PAGE_SHARED_C) | cachebits); > + case VM_SHARED | VM_EXEC: > + case VM_SHARED | VM_EXEC | VM_READ: > + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); > + case VM_SHARED | VM_EXEC | VM_WRITE: > + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: > + return __pgprot(pgprot_val(PAGE_SHARED_C) | cachebits); > + default: > + BUILD_BUG(); > + } > +} > +EXPORT_SYMBOL(vm_get_page_prot); Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- geert@linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT 2022-02-21 11:54 ` Geert Uytterhoeven @ 2022-02-22 5:44 ` Anshuman Khandual 2022-02-25 9:02 ` Geert Uytterhoeven 1 sibling, 0 replies; 6+ messages in thread From: Anshuman Khandual @ 2022-02-22 5:44 UTC (permalink / raw) To: Geert Uytterhoeven Cc: Linux MM, Andrew Morton, Linux Kernel Mailing List, Christoph Hellwig, Linux-Arch, Thomas Bogendoerfer, linux-m68k On 2/21/22 5:24 PM, Geert Uytterhoeven wrote: > Hi Anshuman, > > On Mon, Feb 21, 2022 at 9:45 AM Anshuman Khandual > <anshuman.khandual@arm.com> wrote: >> This defines and exports a platform specific custom vm_get_page_prot() via >> subscribing ARCH_HAS_VM_GET_PAGE_PROT. Subsequently all __SXXX and __PXXX >> macros can be dropped which are no longer needed. >> >> Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> >> Cc: linux-m68k@lists.linux-m68k.org >> Cc: linux-kernel@vger.kernel.org >> Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com> > > Thanks for your patch! > >> --- a/arch/m68k/mm/init.c >> +++ b/arch/m68k/mm/init.c >> @@ -128,3 +128,107 @@ void __init mem_init(void) >> memblock_free_all(); >> init_pointer_tables(); >> } >> + >> +#ifdef CONFIG_COLDFIRE >> +/* >> + * Page protections for initialising protection_map. See mm/mmap.c >> + * for use. In general, the bit positions are xwr, and P-items are >> + * private, the S-items are shared. >> + */ >> +pgprot_t vm_get_page_prot(unsigned long vm_flags) > > Wouldn't it make more sense to add this to arch/m68k/mm/mcfmmu.c? Sure, will move (#ifdef CONFIG_COLDFIRE will not be required anymore). > >> +{ >> + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { >> + case VM_NONE: >> + return PAGE_NONE; >> + case VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE); >> + case VM_WRITE: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_WRITABLE); >> + case VM_WRITE | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_WRITABLE); >> + case VM_EXEC: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_EXEC); >> + case VM_EXEC | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_EXEC); >> + case VM_EXEC | VM_WRITE: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_WRITABLE | CF_PAGE_EXEC); >> + case VM_EXEC | VM_WRITE | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_WRITABLE | >> + CF_PAGE_EXEC); >> + case VM_SHARED: >> + return PAGE_NONE; >> + case VM_SHARED | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE); > > This is the same as the plain VM_READ case. > Perhaps they can be merged? IMHO, it is worth preserving the existing switch case sequence as vm_flags moves linearly from VM_NONE to (VM_SHARED|VM_EXEC|VM_WRITE|VM_READ). This proposal did not attempt to further optimize any common page prot values for various vm_flags combinations even on other platforms. > >> + case VM_SHARED | VM_WRITE: >> + return PAGE_SHARED; >> + case VM_SHARED | VM_WRITE | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_SHARED); >> + case VM_SHARED | VM_EXEC: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_EXEC); > > Same as plain VM_EXEC. > >> + case VM_SHARED | VM_EXEC | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_EXEC); > > Same as plain VM_EXEC | VM_READ. > >> + case VM_SHARED | VM_EXEC | VM_WRITE: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_SHARED | CF_PAGE_EXEC); >> + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: >> + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | >> + CF_PAGE_READABLE | CF_PAGE_SHARED | >> + CF_PAGE_EXEC); >> + default: >> + BUILD_BUG(); >> + } >> +} >> +#endif >> + >> +#ifdef CONFIG_SUN3 >> +/* >> + * Page protections for initialising protection_map. The sun3 has only two >> + * protection settings, valid (implying read and execute) and writeable. These >> + * are as close as we can get... >> + */ >> +pgprot_t vm_get_page_prot(unsigned long vm_flags) > > Wouldn't it make more sense to add this to arch/m68k/mm/sun3mmu.c? Sure, will move (#ifdef CONFIG_SUN3 will not be required anymore). > >> +{ >> + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { >> + case VM_NONE: >> + return PAGE_NONE; >> + case VM_READ: >> + return PAGE_READONLY; >> + case VM_WRITE: >> + case VM_WRITE | VM_READ: > > So you did merge some of them... Only when they follow vm_flags linear sequence. > >> + return PAGE_COPY; >> + case VM_EXEC: >> + case VM_EXEC | VM_READ: >> + return PAGE_READONLY; > > But not all? More below... Right, because did not want to shuffle up vm_flags linear sequence. > >> + case VM_EXEC | VM_WRITE: >> + case VM_EXEC | VM_WRITE | VM_READ: >> + return PAGE_COPY; >> + case VM_SHARED: >> + return PAGE_NONE; >> + case VM_SHARED | VM_READ: >> + return PAGE_READONLY; >> + case VM_SHARED | VM_WRITE: >> + case VM_SHARED | VM_WRITE | VM_READ: >> + return PAGE_SHARED; >> + case VM_SHARED | VM_EXEC: >> + case VM_SHARED | VM_EXEC | VM_READ: >> + return PAGE_READONLY; >> + case VM_SHARED | VM_EXEC | VM_WRITE: >> + case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: >> + return PAGE_SHARED; >> + default: >> + BUILD_BUG(); >> + } >> +} >> +#endif >> +EXPORT_SYMBOL(vm_get_page_prot); >> diff --git a/arch/m68k/mm/motorola.c b/arch/m68k/mm/motorola.c >> index ecbe948f4c1a..495ba0ea083c 100644 >> --- a/arch/m68k/mm/motorola.c >> +++ b/arch/m68k/mm/motorola.c >> @@ -400,12 +400,9 @@ void __init paging_init(void) >> >> /* Fix the cache mode in the page descriptors for the 680[46]0. */ >> if (CPU_IS_040_OR_060) { >> - int i; >> #ifndef mm_cachebits >> mm_cachebits = _PAGE_CACHE040; >> #endif >> - for (i = 0; i < 16; i++) >> - pgprot_val(protection_map[i]) |= _PAGE_CACHE040; >> } >> >> min_addr = m68k_memory[0].addr; >> @@ -483,3 +480,48 @@ void __init paging_init(void) >> max_zone_pfn[ZONE_DMA] = memblock_end_of_DRAM(); >> free_area_init(max_zone_pfn); >> } >> + >> +/* >> + * The m68k can't do page protection for execute, and considers that >> + * the same are read. Also, write permissions imply read permissions. >> + * This is the closest we can get.. >> + */ >> +pgprot_t vm_get_page_prot(unsigned long vm_flags) > > Good, this one is in arch/m68k/mm/motorola.c :-) > >> +{ >> + unsigned long cachebits = 0; >> + >> + if (CPU_IS_040_OR_060) >> + cachebits = _PAGE_CACHE040; > > If you would use the non-"_C"-variants (e.g. PAGE_NONE instead of > PAGE_NONE_C) below, you would get the cachebits handling for free! > After that, the "_C" variants are no longer used, and can be removed. > Cfr. arch/m68k/include/asm/motorola_pgtable.h: Right. > > #define PAGE_NONE __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED | > mm_cachebits) > #define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | > mm_cachebits) > #define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | > _PAGE_ACCESSED | mm_cachebits) > #define PAGE_READONLY __pgprot(_PAGE_PRESENT | _PAGE_RONLY | > _PAGE_ACCESSED | mm_cachebits) > #define PAGE_KERNEL __pgprot(_PAGE_PRESENT | _PAGE_DIRTY | > _PAGE_ACCESSED | mm_cachebits) > > /* Alternate definitions that are compile time constants, for > initializing protection_map. The cachebits are fixed later. */ > #define PAGE_NONE_C __pgprot(_PAGE_PROTNONE | _PAGE_ACCESSED) > #define PAGE_SHARED_C __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED) > #define PAGE_COPY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | > _PAGE_ACCESSED) > #define PAGE_READONLY_C __pgprot(_PAGE_PRESENT | _PAGE_RONLY | > _PAGE_ACCESSED) Will drop all _C definitions and change switch case as mentioned above. > > BTW, this shows you left a reference in a comment to the now-gone > "protection_map". There are several more across the tree. Right, will remove them all. > >> + >> + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { >> + case VM_NONE: >> + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); >> + case VM_READ: >> + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); >> + case VM_WRITE: >> + case VM_WRITE | VM_READ: >> + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); >> + case VM_EXEC: >> + case VM_EXEC | VM_READ: >> + return __pgprot(pgprot_val(PAGE_READONLY_C) | cachebits); >> + case VM_EXEC | VM_WRITE: >> + case VM_EXEC | VM_WRITE | VM_READ: >> + return __pgprot(pgprot_val(PAGE_COPY_C) | cachebits); >> + case VM_SHARED: >> + return __pgprot(pgprot_val(PAGE_NONE_C) | cachebits); > > Same as the VM_NONE case. More to be merged below... As explained earlier. ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT 2022-02-21 11:54 ` Geert Uytterhoeven 2022-02-22 5:44 ` Anshuman Khandual @ 2022-02-25 9:02 ` Geert Uytterhoeven 2022-02-25 9:35 ` Anshuman Khandual 1 sibling, 1 reply; 6+ messages in thread From: Geert Uytterhoeven @ 2022-02-25 9:02 UTC (permalink / raw) To: Anshuman Khandual, Andrew Morton Cc: Linux MM, Linux Kernel Mailing List, Christoph Hellwig, Linux-Arch, Thomas Bogendoerfer, linux-m68k Hi Anshuman, Andrew, On Mon, Feb 21, 2022 at 12:54 PM Geert Uytterhoeven <geert@linux-m68k.org> wrote: > On Mon, Feb 21, 2022 at 9:45 AM Anshuman Khandual > <anshuman.khandual@arm.com> wrote: > > This defines and exports a platform specific custom vm_get_page_prot() via > > subscribing ARCH_HAS_VM_GET_PAGE_PROT. Subsequently all __SXXX and __PXXX > > macros can be dropped which are no longer needed. > > > > Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> > > Cc: linux-m68k@lists.linux-m68k.org > > Cc: linux-kernel@vger.kernel.org > > Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com> > > Thanks for your patch! > > > --- a/arch/m68k/mm/init.c > > +++ b/arch/m68k/mm/init.c > > @@ -128,3 +128,107 @@ void __init mem_init(void) > > memblock_free_all(); > > init_pointer_tables(); > > } > > + > > +#ifdef CONFIG_COLDFIRE > > +/* > > + * Page protections for initialising protection_map. See mm/mmap.c > > + * for use. In general, the bit positions are xwr, and P-items are > > + * private, the S-items are shared. > > + */ > > +pgprot_t vm_get_page_prot(unsigned long vm_flags) > > Wouldn't it make more sense to add this to arch/m68k/mm/mcfmmu.c? It's not just about sense, but also about correctness. The CF_PAGE_* definitions below exist only if CONFIG_MMU=y, thus causing breakage for cfnommu in today's linux-next. http://kisskb.ellerman.id.au/kisskb/buildresult/14701640/ > > > +{ > > + switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { > > + case VM_NONE: > > + return PAGE_NONE; > > + case VM_READ: > > + return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > > + CF_PAGE_READABLE); > > + BUILD_BUG(); > > + } > > +} > > +#endif > > +EXPORT_SYMBOL(vm_get_page_prot); Having this outside the #ifdef means we now get ... > > --- a/arch/m68k/mm/motorola.c > > +++ b/arch/m68k/mm/motorola.c > > +} > > +EXPORT_SYMBOL(vm_get_page_prot); ... two of them in normal m68k builds. Gr{oetje,eeting}s, Geert -- Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- geert@linux-m68k.org In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that. -- Linus Torvalds ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT 2022-02-25 9:02 ` Geert Uytterhoeven @ 2022-02-25 9:35 ` Anshuman Khandual 0 siblings, 0 replies; 6+ messages in thread From: Anshuman Khandual @ 2022-02-25 9:35 UTC (permalink / raw) To: Geert Uytterhoeven, Andrew Morton Cc: Linux MM, Linux Kernel Mailing List, Christoph Hellwig, Linux-Arch, Thomas Bogendoerfer, linux-m68k On 2/25/22 2:32 PM, Geert Uytterhoeven wrote: > Hi Anshuman, Andrew, > > On Mon, Feb 21, 2022 at 12:54 PM Geert Uytterhoeven > <geert@linux-m68k.org> wrote: >> On Mon, Feb 21, 2022 at 9:45 AM Anshuman Khandual >> <anshuman.khandual@arm.com> wrote: >>> This defines and exports a platform specific custom vm_get_page_prot() via >>> subscribing ARCH_HAS_VM_GET_PAGE_PROT. Subsequently all __SXXX and __PXXX >>> macros can be dropped which are no longer needed. >>> >>> Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> >>> Cc: linux-m68k@lists.linux-m68k.org >>> Cc: linux-kernel@vger.kernel.org >>> Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com> >> >> Thanks for your patch! >> >>> --- a/arch/m68k/mm/init.c >>> +++ b/arch/m68k/mm/init.c >>> @@ -128,3 +128,107 @@ void __init mem_init(void) >>> memblock_free_all(); >>> init_pointer_tables(); >>> } >>> + >>> +#ifdef CONFIG_COLDFIRE >>> +/* >>> + * Page protections for initialising protection_map. See mm/mmap.c >>> + * for use. In general, the bit positions are xwr, and P-items are >>> + * private, the S-items are shared. >>> + */ >>> +pgprot_t vm_get_page_prot(unsigned long vm_flags) >> >> Wouldn't it make more sense to add this to arch/m68k/mm/mcfmmu.c? > > It's not just about sense, but also about correctness. > The CF_PAGE_* definitions below exist only if CONFIG_MMU=y, > thus causing breakage for cfnommu in today's linux-next. > http://kisskb.ellerman.id.au/kisskb/buildresult/14701640/ As mentioned before, will do all these necessary changes in the next version probably sometime earlier next week. I was waiting for other reviews (if any) till now. ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT 2022-02-21 6:38 ` [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT Anshuman Khandual 2022-02-21 11:54 ` Geert Uytterhoeven @ 2022-04-22 6:55 ` kernel test robot 1 sibling, 0 replies; 6+ messages in thread From: kernel test robot @ 2022-04-22 6:55 UTC (permalink / raw) To: Anshuman Khandual, linux-mm, akpm Cc: kbuild-all, linux-kernel, Anshuman Khandual, Christoph Hellwig, linux-arch, Thomas Bogendoerfer, linux-m68k Hi Anshuman, Thank you for the patch! Yet something to improve: [auto build test ERROR on hnaz-mm/master] url: https://github.com/0day-ci/linux/commits/Anshuman-Khandual/mm-mmap-Drop-protection_map-and-platform-s-__SXXX-__PXXX-requirements/20220221-144133 base: https://github.com/hnaz/linux-mm master config: m68k-randconfig-r033-20220221 (https://download.01.org/0day-ci/archive/20220221/202202211826.rxBv4dl1-lkp@intel.com/config) compiler: m68k-linux-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/e75c29d8b212cfab904914acdd5a027fb15d2f16 git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Anshuman-Khandual/mm-mmap-Drop-protection_map-and-platform-s-__SXXX-__PXXX-requirements/20220221-144133 git checkout e75c29d8b212cfab904914acdd5a027fb15d2f16 # save the config file to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=m68k SHELL=/bin/bash arch/m68k/mm/ If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp@intel.com> All errors (new ones prefixed by >>): >> arch/m68k/mm/init.c:138:10: error: redefinition of 'vm_get_page_prot' 138 | pgprot_t vm_get_page_prot(unsigned long vm_flags) | ^~~~~~~~~~~~~~~~ In file included from arch/m68k/mm/init.c:14: include/linux/mm.h:2801:24: note: previous definition of 'vm_get_page_prot' with type 'pgprot_t(long unsigned int)' 2801 | static inline pgprot_t vm_get_page_prot(unsigned long vm_flags) | ^~~~~~~~~~~~~~~~ In file included from arch/m68k/include/asm/thread_info.h:6, from include/linux/thread_info.h:60, from include/asm-generic/preempt.h:5, from ./arch/m68k/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from arch/m68k/include/asm/irqflags.h:6, from include/linux/irqflags.h:16, from arch/m68k/include/asm/atomic.h:6, from include/linux/atomic.h:7, from include/linux/mm_types_task.h:13, from include/linux/mm_types.h:5, from include/linux/buildid.h:5, from include/linux/module.h:14, from arch/m68k/mm/init.c:11: arch/m68k/mm/init.c: In function 'vm_get_page_prot': >> arch/m68k/mm/init.c:144:33: error: 'CF_PAGE_VALID' undeclared (first use in this function) 144 | return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | | ^~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ arch/m68k/mm/init.c:144:33: note: each undeclared identifier is reported only once for each function it appears in 144 | return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | | ^~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ >> arch/m68k/mm/init.c:144:49: error: 'CF_PAGE_ACCESSED' undeclared (first use in this function); did you mean 'FGP_ACCESSED'? 144 | return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | | ^~~~~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ >> arch/m68k/mm/init.c:145:33: error: 'CF_PAGE_READABLE' undeclared (first use in this function); did you mean 'PAGE_READONLY'? 145 | CF_PAGE_READABLE); | ^~~~~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ >> arch/m68k/mm/init.c:148:33: error: 'CF_PAGE_WRITABLE' undeclared (first use in this function); did you mean 'NR_PAGETABLE'? 148 | CF_PAGE_WRITABLE); | ^~~~~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ >> arch/m68k/mm/init.c:154:33: error: 'CF_PAGE_EXEC' undeclared (first use in this function) 154 | CF_PAGE_EXEC); | ^~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ >> arch/m68k/mm/init.c:174:52: error: 'CF_PAGE_SHARED' undeclared (first use in this function); did you mean 'PAGE_SHARED'? 174 | CF_PAGE_READABLE | CF_PAGE_SHARED); | ^~~~~~~~~~~~~~ arch/m68k/include/asm/page.h:51:40: note: in definition of macro '__pgprot' 51 | #define __pgprot(x) ((pgprot_t) { (x) } ) | ^ vim +/vm_get_page_prot +138 arch/m68k/mm/init.c > 11 #include <linux/module.h> 12 #include <linux/signal.h> 13 #include <linux/sched.h> 14 #include <linux/mm.h> 15 #include <linux/swap.h> 16 #include <linux/kernel.h> 17 #include <linux/string.h> 18 #include <linux/types.h> 19 #include <linux/init.h> 20 #include <linux/memblock.h> 21 #include <linux/gfp.h> 22 23 #include <asm/setup.h> 24 #include <linux/uaccess.h> 25 #include <asm/page.h> 26 #include <asm/pgalloc.h> 27 #include <asm/traps.h> 28 #include <asm/machdep.h> 29 #include <asm/io.h> 30 #ifdef CONFIG_ATARI 31 #include <asm/atari_stram.h> 32 #endif 33 #include <asm/sections.h> 34 #include <asm/tlb.h> 35 36 /* 37 * ZERO_PAGE is a special page that is used for zero-initialized 38 * data and COW. 39 */ 40 void *empty_zero_page; 41 EXPORT_SYMBOL(empty_zero_page); 42 43 #ifdef CONFIG_MMU 44 45 int m68k_virt_to_node_shift; 46 47 void __init m68k_setup_node(int node) 48 { 49 node_set_online(node); 50 } 51 52 #else /* CONFIG_MMU */ 53 54 /* 55 * paging_init() continues the virtual memory environment setup which 56 * was begun by the code in arch/head.S. 57 * The parameters are pointers to where to stick the starting and ending 58 * addresses of available kernel virtual memory. 59 */ 60 void __init paging_init(void) 61 { 62 /* 63 * Make sure start_mem is page aligned, otherwise bootmem and 64 * page_alloc get different views of the world. 65 */ 66 unsigned long end_mem = memory_end & PAGE_MASK; 67 unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0, }; 68 69 high_memory = (void *) end_mem; 70 71 empty_zero_page = memblock_alloc(PAGE_SIZE, PAGE_SIZE); 72 if (!empty_zero_page) 73 panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 74 __func__, PAGE_SIZE, PAGE_SIZE); 75 max_zone_pfn[ZONE_DMA] = end_mem >> PAGE_SHIFT; 76 free_area_init(max_zone_pfn); 77 } 78 79 #endif /* CONFIG_MMU */ 80 81 void free_initmem(void) 82 { 83 #ifndef CONFIG_MMU_SUN3 84 free_initmem_default(-1); 85 #endif /* CONFIG_MMU_SUN3 */ 86 } 87 88 #if defined(CONFIG_MMU) && !defined(CONFIG_COLDFIRE) 89 #define VECTORS &vectors[0] 90 #else 91 #define VECTORS _ramvec 92 #endif 93 94 static inline void init_pointer_tables(void) 95 { 96 #if defined(CONFIG_MMU) && !defined(CONFIG_SUN3) && !defined(CONFIG_COLDFIRE) 97 int i, j; 98 99 /* insert pointer tables allocated so far into the tablelist */ 100 init_pointer_table(kernel_pg_dir, TABLE_PGD); 101 for (i = 0; i < PTRS_PER_PGD; i++) { 102 pud_t *pud = (pud_t *)&kernel_pg_dir[i]; 103 pmd_t *pmd_dir; 104 105 if (!pud_present(*pud)) 106 continue; 107 108 pmd_dir = (pmd_t *)pgd_page_vaddr(kernel_pg_dir[i]); 109 init_pointer_table(pmd_dir, TABLE_PMD); 110 111 for (j = 0; j < PTRS_PER_PMD; j++) { 112 pmd_t *pmd = &pmd_dir[j]; 113 pte_t *pte_dir; 114 115 if (!pmd_present(*pmd)) 116 continue; 117 118 pte_dir = (pte_t *)pmd_page_vaddr(*pmd); 119 init_pointer_table(pte_dir, TABLE_PTE); 120 } 121 } 122 #endif 123 } 124 125 void __init mem_init(void) 126 { 127 /* this will put all memory onto the freelists */ 128 memblock_free_all(); 129 init_pointer_tables(); 130 } 131 132 #ifdef CONFIG_COLDFIRE 133 /* 134 * Page protections for initialising protection_map. See mm/mmap.c 135 * for use. In general, the bit positions are xwr, and P-items are 136 * private, the S-items are shared. 137 */ > 138 pgprot_t vm_get_page_prot(unsigned long vm_flags) 139 { 140 switch (vm_flags & (VM_READ | VM_WRITE | VM_EXEC | VM_SHARED)) { 141 case VM_NONE: 142 return PAGE_NONE; 143 case VM_READ: > 144 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > 145 CF_PAGE_READABLE); 146 case VM_WRITE: 147 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > 148 CF_PAGE_WRITABLE); 149 case VM_WRITE | VM_READ: 150 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 151 CF_PAGE_READABLE | CF_PAGE_WRITABLE); 152 case VM_EXEC: 153 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > 154 CF_PAGE_EXEC); 155 case VM_EXEC | VM_READ: 156 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 157 CF_PAGE_READABLE | CF_PAGE_EXEC); 158 case VM_EXEC | VM_WRITE: 159 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 160 CF_PAGE_WRITABLE | CF_PAGE_EXEC); 161 case VM_EXEC | VM_WRITE | VM_READ: 162 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 163 CF_PAGE_READABLE | CF_PAGE_WRITABLE | 164 CF_PAGE_EXEC); 165 case VM_SHARED: 166 return PAGE_NONE; 167 case VM_SHARED | VM_READ: 168 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 169 CF_PAGE_READABLE); 170 case VM_SHARED | VM_WRITE: 171 return PAGE_SHARED; 172 case VM_SHARED | VM_WRITE | VM_READ: 173 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | > 174 CF_PAGE_READABLE | CF_PAGE_SHARED); 175 case VM_SHARED | VM_EXEC: 176 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 177 CF_PAGE_EXEC); 178 case VM_SHARED | VM_EXEC | VM_READ: 179 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 180 CF_PAGE_READABLE | CF_PAGE_EXEC); 181 case VM_SHARED | VM_EXEC | VM_WRITE: 182 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 183 CF_PAGE_SHARED | CF_PAGE_EXEC); 184 case VM_SHARED | VM_EXEC | VM_WRITE | VM_READ: 185 return __pgprot(CF_PAGE_VALID | CF_PAGE_ACCESSED | 186 CF_PAGE_READABLE | CF_PAGE_SHARED | 187 CF_PAGE_EXEC); 188 default: 189 BUILD_BUG(); 190 } 191 } 192 #endif 193 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2022-04-22 6:56 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <1645425519-9034-1-git-send-email-anshuman.khandual@arm.com>
2022-02-21 6:38 ` [PATCH V2 08/30] m68k/mm: Enable ARCH_HAS_VM_GET_PAGE_PROT Anshuman Khandual
2022-02-21 11:54 ` Geert Uytterhoeven
2022-02-22 5:44 ` Anshuman Khandual
2022-02-25 9:02 ` Geert Uytterhoeven
2022-02-25 9:35 ` Anshuman Khandual
2022-04-22 6:55 ` kernel test robot
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox