linux-parisc.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel]
@ 2019-05-02 15:28 Mike Rapoport
  2019-05-02 15:28 ` [PATCH 01/15] asm-generic, x86: " Mike Rapoport
                   ` (14 more replies)
  0 siblings, 15 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

Hi,

I've tried to trim down the recipients list, but it's still quite long, so
sorry for the spam.

Many architectures have similar, if not identical implementation of
pte_alloc_one_kernel(), pte_alloc_one(), pte_free_kernel() and pte_free().

A while ago Anshuman suggested to introduce a common definition of
GFP_PGTABLE and during the discussion it was suggested to rather
consolidate the allocators.

These patches introduce generic version of PTE allocation and free and
enable their use on several architectures.

The conversion introduces some changes for some of the architectures.
Here's the executive summary and the details are described at each patch.

* Most architectures do not set __GFP_ACCOUNT for the user page tables.
Switch to the generic functions is "spreading that goodness to all other
architectures"
* arm, arm64 and unicore32 used to check if the pte is not NULL before
freeing its memory in pte_free_kernel(). It's dropped during the
conversion as it seems superfluous.
* x86 used to BUG_ON() is pte was not page aligned duirng
pte_free_kernel(), the generic version simply frees the memory without any
checks.

This set only performs the straightforward conversion, the architectures
with different logic in pte_alloc_one() and pte_alloc_one_kernel() are not
touched, as well as architectures that have custom page table allocators.

[1] https://lore.kernel.org/lkml/1547619692-7946-1-git-send-email-anshuman.khandual@arm.com

 asm-generic, x86: introduce generic pte_{alloc,free}_one[_kernel]

Mike Rapoport (15):
  asm-generic, x86: introduce generic pte_{alloc,free}_one[_kernel]
  alpha: switch to generic version of pte allocation
  arm: switch to generic version of pte allocation
  arm64: switch to generic version of pte allocation
  csky: switch to generic version of pte allocation
  hexagon: switch to generic version of pte allocation
  m68k: sun3: switch to generic version of pte allocation
  mips: switch to generic version of pte allocation
  nds32: switch to generic version of pte allocation
  nios2: switch to generic version of pte allocation
  parisc: switch to generic version of pte allocation
  powerpc/nohash/64: switch to generic version of pte allocation
  riscv: switch to generic version of pte allocation
  um: switch to generic version of pte allocation
  unicore32: switch to generic version of pte allocation

 arch/alpha/include/asm/pgalloc.h             |  40 +---------
 arch/arm/include/asm/pgalloc.h               |  41 ++++------
 arch/arm/mm/mmu.c                            |   2 +-
 arch/arm64/include/asm/pgalloc.h             |  43 +----------
 arch/arm64/mm/mmu.c                          |   2 +-
 arch/arm64/mm/pgd.c                          |   4 +-
 arch/csky/include/asm/pgalloc.h              |  30 +-------
 arch/hexagon/include/asm/pgalloc.h           |  34 +--------
 arch/m68k/include/asm/sun3_pgalloc.h         |  41 +---------
 arch/mips/include/asm/pgalloc.h              |  33 +--------
 arch/nds32/include/asm/pgalloc.h             |  31 +-------
 arch/nios2/include/asm/pgalloc.h             |  37 +--------
 arch/parisc/include/asm/pgalloc.h            |  33 +--------
 arch/powerpc/include/asm/nohash/64/pgalloc.h |  35 +--------
 arch/riscv/include/asm/pgalloc.h             |  29 +-------
 arch/um/include/asm/pgalloc.h                |  16 +---
 arch/um/kernel/mem.c                         |  22 ------
 arch/unicore32/include/asm/pgalloc.h         |  36 ++-------
 arch/x86/include/asm/pgalloc.h               |  19 +----
 arch/x86/mm/pgtable.c                        |  33 +++------
 include/asm-generic/pgalloc.h                | 107 ++++++++++++++++++++++++++-
 virt/kvm/arm/mmu.c                           |   2 +-
 22 files changed, 171 insertions(+), 499 deletions(-)

-- 
2.7.4


^ permalink raw reply	[flat|nested] 29+ messages in thread

* [PATCH 01/15] asm-generic, x86: introduce generic pte_{alloc,free}_one[_kernel]
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 19:03   ` Paul Burton
  2019-05-02 15:28 ` [PATCH 02/15] alpha: switch to generic version of pte allocation Mike Rapoport
                   ` (13 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

Most architectures have identical or very similar implementation of
pte_alloc_one_kernel(), pte_alloc_one(), pte_free_kernel() and pte_free().

Add a generic implementation that can be reused across architectures and
enable its use on x86.

The generic implementation uses

	GFP_KERNEL | __GFP_ZERO

for the kernel page tables and

	GFP_KERNEL | __GFP_ZERO | __GFP_ACCOUNT

for the user page tables.

The "base" functions for PTE allocation, namely __pte_alloc_one_kernel()
and __pte_alloc_one() are intended for the architectures that require
additional actions after actual memory allocation or must use non-default
GFP flags.

x86 is switched to use generic pte_alloc_one_kernel(), pte_free_kernel() and
pte_free().

x86 still implements pte_alloc_one() to allow run-time control of GFP flags
required for "userpte" command line option.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/x86/include/asm/pgalloc.h |  19 ++------
 arch/x86/mm/pgtable.c          |  33 ++++---------
 include/asm-generic/pgalloc.h  | 107 +++++++++++++++++++++++++++++++++++++++--
 3 files changed, 115 insertions(+), 44 deletions(-)

diff --git a/arch/x86/include/asm/pgalloc.h b/arch/x86/include/asm/pgalloc.h
index a281e61..29aa785 100644
--- a/arch/x86/include/asm/pgalloc.h
+++ b/arch/x86/include/asm/pgalloc.h
@@ -6,6 +6,9 @@
 #include <linux/mm.h>		/* for struct page */
 #include <linux/pagemap.h>
 
+#define __HAVE_ARCH_PTE_ALLOC_ONE
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 static inline int  __paravirt_pgd_alloc(struct mm_struct *mm) { return 0; }
 
 #ifdef CONFIG_PARAVIRT_XXL
@@ -47,24 +50,8 @@ extern gfp_t __userpte_alloc_gfp;
 extern pgd_t *pgd_alloc(struct mm_struct *);
 extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
 
-extern pte_t *pte_alloc_one_kernel(struct mm_struct *);
 extern pgtable_t pte_alloc_one(struct mm_struct *);
 
-/* Should really implement gc for free page table pages. This could be
-   done with a reference count in struct page. */
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	BUG_ON((unsigned long)pte & (PAGE_SIZE-1));
-	free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, struct page *pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 extern void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte);
 
 static inline void __pte_free_tlb(struct mmu_gather *tlb, struct page *pte,
diff --git a/arch/x86/mm/pgtable.c b/arch/x86/mm/pgtable.c
index 7bd0170..aaca89b 100644
--- a/arch/x86/mm/pgtable.c
+++ b/arch/x86/mm/pgtable.c
@@ -13,33 +13,17 @@ phys_addr_t physical_mask __ro_after_init = (1ULL << __PHYSICAL_MASK_SHIFT) - 1;
 EXPORT_SYMBOL(physical_mask);
 #endif
 
-#define PGALLOC_GFP (GFP_KERNEL_ACCOUNT | __GFP_ZERO)
-
 #ifdef CONFIG_HIGHPTE
-#define PGALLOC_USER_GFP __GFP_HIGHMEM
+#define PGTABLE_HIGHMEM __GFP_HIGHMEM
 #else
-#define PGALLOC_USER_GFP 0
+#define PGTABLE_HIGHMEM 0
 #endif
 
-gfp_t __userpte_alloc_gfp = PGALLOC_GFP | PGALLOC_USER_GFP;
-
-pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	return (pte_t *)__get_free_page(PGALLOC_GFP & ~__GFP_ACCOUNT);
-}
+gfp_t __userpte_alloc_gfp = GFP_PGTABLE_USER | PGTABLE_HIGHMEM;
 
 pgtable_t pte_alloc_one(struct mm_struct *mm)
 {
-	struct page *pte;
-
-	pte = alloc_pages(__userpte_alloc_gfp, 0);
-	if (!pte)
-		return NULL;
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-	return pte;
+	return __pte_alloc_one(mm, __userpte_alloc_gfp);
 }
 
 static int __init setup_userpte(char *arg)
@@ -235,7 +219,7 @@ static int preallocate_pmds(struct mm_struct *mm, pmd_t *pmds[], int count)
 {
 	int i;
 	bool failed = false;
-	gfp_t gfp = PGALLOC_GFP;
+	gfp_t gfp = GFP_PGTABLE_USER;
 
 	if (mm == &init_mm)
 		gfp &= ~__GFP_ACCOUNT;
@@ -401,14 +385,14 @@ static inline pgd_t *_pgd_alloc(void)
 	 * We allocate one page for pgd.
 	 */
 	if (!SHARED_KERNEL_PMD)
-		return (pgd_t *)__get_free_pages(PGALLOC_GFP,
+		return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
 						 PGD_ALLOCATION_ORDER);
 
 	/*
 	 * Now PAE kernel is not running as a Xen domain. We can allocate
 	 * a 32-byte slab for pgd to save memory space.
 	 */
-	return kmem_cache_alloc(pgd_cache, PGALLOC_GFP);
+	return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
 }
 
 static inline void _pgd_free(pgd_t *pgd)
@@ -422,7 +406,8 @@ static inline void _pgd_free(pgd_t *pgd)
 
 static inline pgd_t *_pgd_alloc(void)
 {
-	return (pgd_t *)__get_free_pages(PGALLOC_GFP, PGD_ALLOCATION_ORDER);
+	return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
+					 PGD_ALLOCATION_ORDER);
 }
 
 static inline void _pgd_free(pgd_t *pgd)
diff --git a/include/asm-generic/pgalloc.h b/include/asm-generic/pgalloc.h
index 948714c..efecfb3 100644
--- a/include/asm-generic/pgalloc.h
+++ b/include/asm-generic/pgalloc.h
@@ -1,13 +1,112 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #ifndef __ASM_GENERIC_PGALLOC_H
 #define __ASM_GENERIC_PGALLOC_H
-/*
- * an empty file is enough for a nommu architecture
- */
+
 #ifdef CONFIG_MMU
-#error need to implement an architecture specific asm/pgalloc.h
+
+#define GFP_PGTABLE_KERNEL	(GFP_KERNEL | __GFP_ZERO)
+#define GFP_PGTABLE_USER	(GFP_PGTABLE_KERNEL | __GFP_ACCOUNT)
+
+/**
+ * __pte_alloc_one_kernel - allocate a page for PTE-level kernel page table
+ * @mm: the mm_struct of the current context
+ *
+ * This function is intended for architectures that need
+ * anything beyond simple page allocation.
+ *
+ * Return: pointer to the allocated memory or %NULL on error
+ */
+static inline pte_t *__pte_alloc_one_kernel(struct mm_struct *mm)
+{
+	return (pte_t *)__get_free_page(GFP_PGTABLE_KERNEL);
+}
+
+#ifndef __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
+/**
+ * pte_alloc_one_kernel - allocate a page for PTE-level kernel page table
+ * @mm: the mm_struct of the current context
+ *
+ * Return: pointer to the allocated memory or %NULL on error
+ */
+static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
+{
+	return __pte_alloc_one_kernel(mm);
+}
+#endif
+
+/**
+ * pte_free_kernel - free PTE-level kernel page table page
+ * @mm: the mm_struct of the current context
+ * @pte: pointer to the memory containing the page table
+ */
+static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
+{
+	free_page((unsigned long)pte);
+}
+
+/**
+ * __pte_alloc_one - allocate a page for PTE-level user page table
+ * @mm: the mm_struct of the current context
+ * @gfp: GFP flags to use for the allocation
+ *
+ * Allocates a page and runs the pgtable_page_ctor().
+ *
+ * This function is intended for architectures that need
+ * anything beyond simple page allocation or must have custom GFP flags.
+ *
+ * Return: `struct page` initialized as page table or %NULL on error
+ */
+static inline pgtable_t __pte_alloc_one(struct mm_struct *mm, gfp_t gfp)
+{
+	struct page *pte;
+
+	pte = alloc_page(gfp);
+	if (!pte)
+		return NULL;
+	if (!pgtable_page_ctor(pte)) {
+		__free_page(pte);
+		return NULL;
+	}
+
+	return pte;
+}
+
+#ifndef __HAVE_ARCH_PTE_ALLOC_ONE
+/**
+ * pte_alloc_one - allocate a page for PTE-level user page table
+ * @mm: the mm_struct of the current context
+ *
+ * Allocates a page and runs the pgtable_page_ctor().
+ *
+ * Return: `struct page` initialized as page table or %NULL on error
+ */
+static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
+{
+	return __pte_alloc_one(mm, GFP_PGTABLE_USER);
+}
 #endif
 
+/*
+ * Should really implement gc for free page table pages. This could be
+ * done with a reference count in struct page.
+ */
+
+/**
+ * pte_free_kernel - free PTE-level user page table page
+ * @mm: the mm_struct of the current context
+ * @pte_page: the `struct page` representing the page table
+ */
+static inline void pte_free(struct mm_struct *mm, struct page *pte_page)
+{
+	pgtable_page_dtor(pte_page);
+	__free_page(pte_page);
+}
+
+#else /* CONFIG_MMU */
+
+/* This is enough for a nommu architecture */
 #define check_pgt_cache()          do { } while (0)
 
+#endif /* CONFIG_MMU */
+
 #endif /* __ASM_GENERIC_PGALLOC_H */
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 02/15] alpha: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
  2019-05-02 15:28 ` [PATCH 01/15] asm-generic, x86: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 03/15] arm: " Mike Rapoport
                   ` (12 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

alpha allocates PTE pages with __get_free_page() and uses
GFP_KERNEL | __GFP_ZERO for the allocations.

Switch it to the generic version that does exactly the same thing for the
kernel page tables and adds __GFP_ACCOUNT for the user PTEs.

The alpha pte_free() and pte_free_kernel() versions are identical to the
generic ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/alpha/include/asm/pgalloc.h | 40 +++-------------------------------------
 1 file changed, 3 insertions(+), 37 deletions(-)

diff --git a/arch/alpha/include/asm/pgalloc.h b/arch/alpha/include/asm/pgalloc.h
index 02f9f91..71ded3b 100644
--- a/arch/alpha/include/asm/pgalloc.h
+++ b/arch/alpha/include/asm/pgalloc.h
@@ -5,6 +5,8 @@
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 /*      
  * Allocate and free page tables. The xxx_kernel() versions are
  * used to allocate a kernel page table - this turns on ASN bits
@@ -41,7 +43,7 @@ pgd_free(struct mm_struct *mm, pgd_t *pgd)
 static inline pmd_t *
 pmd_alloc_one(struct mm_struct *mm, unsigned long address)
 {
-	pmd_t *ret = (pmd_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
+	pmd_t *ret = (pmd_t *)__get_free_page(GFP_PGTABLE_USER);
 	return ret;
 }
 
@@ -51,42 +53,6 @@ pmd_free(struct mm_struct *mm, pmd_t *pmd)
 	free_page((unsigned long)pmd);
 }
 
-static inline pte_t *
-pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
-	return pte;
-}
-
-static inline void
-pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long)pte);
-}
-
-static inline pgtable_t
-pte_alloc_one(struct mm_struct *mm)
-{
-	pte_t *pte = pte_alloc_one_kernel(mm);
-	struct page *page;
-
-	if (!pte)
-		return NULL;
-	page = virt_to_page(pte);
-	if (!pgtable_page_ctor(page)) {
-		__free_page(page);
-		return NULL;
-	}
-	return page;
-}
-
-static inline void
-pte_free(struct mm_struct *mm, pgtable_t page)
-{
-	pgtable_page_dtor(page);
-	__free_page(page);
-}
-
 #define check_pgt_cache()	do { } while (0)
 
 #endif /* _ALPHA_PGALLOC_H */
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 03/15] arm: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
  2019-05-02 15:28 ` [PATCH 01/15] asm-generic, x86: " Mike Rapoport
  2019-05-02 15:28 ` [PATCH 02/15] alpha: switch to generic version of pte allocation Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 04/15] arm64: " Mike Rapoport
                   ` (11 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

Replace __get_free_page() and alloc_pages() calls with the generic
__pte_alloc_one_kernel() and __pte_alloc_one().

There is no functional change for the kernel PTE allocation.

The difference for the user PTEs, is that the clear_pte_table() is now
called after pgtable_page_ctor() and the addition of __GFP_ACCOUNT to the
GFP flags.

The conversion to the generic version of pte_free_kernel() removes the NULL
check for pte.

The pte_free() version on arm is identical to the generic one and can be
simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/arm/include/asm/pgalloc.h | 41 +++++++++++++----------------------------
 arch/arm/mm/mmu.c              |  2 +-
 2 files changed, 14 insertions(+), 29 deletions(-)

diff --git a/arch/arm/include/asm/pgalloc.h b/arch/arm/include/asm/pgalloc.h
index 17ab72f..13c5a9d 100644
--- a/arch/arm/include/asm/pgalloc.h
+++ b/arch/arm/include/asm/pgalloc.h
@@ -57,8 +57,6 @@ static inline void pud_populate(struct mm_struct *mm, pud_t *pud, pmd_t *pmd)
 extern pgd_t *pgd_alloc(struct mm_struct *mm);
 extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
 
-#define PGALLOC_GFP	(GFP_KERNEL | __GFP_ZERO)
-
 static inline void clean_pte_table(pte_t *pte)
 {
 	clean_dcache_area(pte + PTE_HWTABLE_PTRS, PTE_HWTABLE_SIZE);
@@ -80,54 +78,41 @@ static inline void clean_pte_table(pte_t *pte)
  *  |  h/w pt 1  |
  *  +------------+
  */
+
+#define __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
+#define __HAVE_ARCH_PTE_ALLOC_ONE
+#include <asm-generic/pgalloc.h>
+
 static inline pte_t *
 pte_alloc_one_kernel(struct mm_struct *mm)
 {
-	pte_t *pte;
+	pte_t *pte = __pte_alloc_one_kernel(mm);
 
-	pte = (pte_t *)__get_free_page(PGALLOC_GFP);
 	if (pte)
 		clean_pte_table(pte);
 
 	return pte;
 }
 
+#ifdef CONFIG_HIGHPTE
+#define PGTABLE_HIGHMEM __GFP_HIGHMEM
+#else
+#define PGTABLE_HIGHMEM 0
+#endif
+
 static inline pgtable_t
 pte_alloc_one(struct mm_struct *mm)
 {
 	struct page *pte;
 
-#ifdef CONFIG_HIGHPTE
-	pte = alloc_pages(PGALLOC_GFP | __GFP_HIGHMEM, 0);
-#else
-	pte = alloc_pages(PGALLOC_GFP, 0);
-#endif
+	pte = __pte_alloc_one(mm, GFP_PGTABLE_USER | PGTABLE_HIGHMEM);
 	if (!pte)
 		return NULL;
 	if (!PageHighMem(pte))
 		clean_pte_table(page_address(pte));
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
 	return pte;
 }
 
-/*
- * Free one PTE table.
- */
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	if (pte)
-		free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 static inline void __pmd_populate(pmd_t *pmdp, phys_addr_t pte,
 				  pmdval_t prot)
 {
diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index f3ce341..e8e0382 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -732,7 +732,7 @@ static void __init *early_alloc(unsigned long sz)
 
 static void *__init late_alloc(unsigned long sz)
 {
-	void *ptr = (void *)__get_free_pages(PGALLOC_GFP, get_order(sz));
+	void *ptr = (void *)__get_free_pages(GFP_PGTABLE_KERNEL, get_order(sz));
 
 	if (!ptr || !pgtable_page_ctor(virt_to_page(ptr)))
 		BUG();
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 04/15] arm64: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (2 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 03/15] arm: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-03 10:05   ` Mark Rutland
  2019-05-02 15:28 ` [PATCH 05/15] csky: " Mike Rapoport
                   ` (10 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The PTE allocations in arm64 are identical to the generic ones modulo the
GFP flags.

Using the generic pte_alloc_one() functions ensures that the user page
tables are allocated with __GFP_ACCOUNT set.

The arm64 definition of PGALLOC_GFP is removed and replaced with
GFP_PGTABLE_USER for p[gum]d_alloc_one() and for KVM memory cache.

The mappings created with create_pgd_mapping() are now using
GFP_PGTABLE_KERNEL.

The conversion to the generic version of pte_free_kernel() removes the NULL
check for pte.

The pte_free() version on arm64 is identical to the generic one and
can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/arm64/include/asm/pgalloc.h | 43 ++++------------------------------------
 arch/arm64/mm/mmu.c              |  2 +-
 arch/arm64/mm/pgd.c              |  4 ++--
 virt/kvm/arm/mmu.c               |  2 +-
 4 files changed, 8 insertions(+), 43 deletions(-)

diff --git a/arch/arm64/include/asm/pgalloc.h b/arch/arm64/include/asm/pgalloc.h
index 52fa47c..3293b8b 100644
--- a/arch/arm64/include/asm/pgalloc.h
+++ b/arch/arm64/include/asm/pgalloc.h
@@ -24,16 +24,17 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 #define check_pgt_cache()		do { } while (0)
 
-#define PGALLOC_GFP	(GFP_KERNEL | __GFP_ZERO)
 #define PGD_SIZE	(PTRS_PER_PGD * sizeof(pgd_t))
 
 #if CONFIG_PGTABLE_LEVELS > 2
 
 static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long addr)
 {
-	return (pmd_t *)__get_free_page(PGALLOC_GFP);
+	return (pmd_t *)__get_free_page(GFP_PGTABLE_USER);
 }
 
 static inline void pmd_free(struct mm_struct *mm, pmd_t *pmdp)
@@ -62,7 +63,7 @@ static inline void __pud_populate(pud_t *pudp, phys_addr_t pmdp, pudval_t prot)
 
 static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
 {
-	return (pud_t *)__get_free_page(PGALLOC_GFP);
+	return (pud_t *)__get_free_page(GFP_PGTABLE_USER);
 }
 
 static inline void pud_free(struct mm_struct *mm, pud_t *pudp)
@@ -90,42 +91,6 @@ static inline void __pgd_populate(pgd_t *pgdp, phys_addr_t pudp, pgdval_t prot)
 extern pgd_t *pgd_alloc(struct mm_struct *mm);
 extern void pgd_free(struct mm_struct *mm, pgd_t *pgdp);
 
-static inline pte_t *
-pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	return (pte_t *)__get_free_page(PGALLOC_GFP);
-}
-
-static inline pgtable_t
-pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_pages(PGALLOC_GFP, 0);
-	if (!pte)
-		return NULL;
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-	return pte;
-}
-
-/*
- * Free a PTE table.
- */
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *ptep)
-{
-	if (ptep)
-		free_page((unsigned long)ptep);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 static inline void __pmd_populate(pmd_t *pmdp, phys_addr_t ptep,
 				  pmdval_t prot)
 {
diff --git a/arch/arm64/mm/mmu.c b/arch/arm64/mm/mmu.c
index e97f018..d5178c5 100644
--- a/arch/arm64/mm/mmu.c
+++ b/arch/arm64/mm/mmu.c
@@ -373,7 +373,7 @@ static void __create_pgd_mapping(pgd_t *pgdir, phys_addr_t phys,
 
 static phys_addr_t pgd_pgtable_alloc(void)
 {
-	void *ptr = (void *)__get_free_page(PGALLOC_GFP);
+	void *ptr = (void *)__get_free_page(GFP_PGTABLE_KERNEL);
 	if (!ptr || !pgtable_page_ctor(virt_to_page(ptr)))
 		BUG();
 
diff --git a/arch/arm64/mm/pgd.c b/arch/arm64/mm/pgd.c
index 289f911..2ef1a53 100644
--- a/arch/arm64/mm/pgd.c
+++ b/arch/arm64/mm/pgd.c
@@ -31,9 +31,9 @@ static struct kmem_cache *pgd_cache __ro_after_init;
 pgd_t *pgd_alloc(struct mm_struct *mm)
 {
 	if (PGD_SIZE == PAGE_SIZE)
-		return (pgd_t *)__get_free_page(PGALLOC_GFP);
+		return (pgd_t *)__get_free_page(GFP_PGTABLE_USER);
 	else
-		return kmem_cache_alloc(pgd_cache, PGALLOC_GFP);
+		return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
 }
 
 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
diff --git a/virt/kvm/arm/mmu.c b/virt/kvm/arm/mmu.c
index 27c9583..9f6f638 100644
--- a/virt/kvm/arm/mmu.c
+++ b/virt/kvm/arm/mmu.c
@@ -141,7 +141,7 @@ static int mmu_topup_memory_cache(struct kvm_mmu_memory_cache *cache,
 	if (cache->nobjs >= min)
 		return 0;
 	while (cache->nobjs < max) {
-		page = (void *)__get_free_page(PGALLOC_GFP);
+		page = (void *)__get_free_page(GFP_PGTABLE_USER);
 		if (!page)
 			return -ENOMEM;
 		cache->objects[cache->nobjs++] = page;
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 05/15] csky: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (3 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 04/15] arm64: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-03 16:03   ` Guo Ren
  2019-05-02 15:28 ` [PATCH 06/15] hexagon: " Mike Rapoport
                   ` (9 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The csky implementation pte_alloc_one(), pte_free_kernel() and pte_free()
is identical to the generic except of lack of __GFP_ACCOUNT for the user
PTEs allocation.

Switch csky to use generic version of these functions.

The csky implementation of pte_alloc_one_kernel() is not replaced because
it does not clear the allocated page but rather sets each PTE in it to a
non-zero value.

The pte_free_kernel() and pte_free() versions on csky are identical to the
generic ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/csky/include/asm/pgalloc.h | 30 +++---------------------------
 1 file changed, 3 insertions(+), 27 deletions(-)

diff --git a/arch/csky/include/asm/pgalloc.h b/arch/csky/include/asm/pgalloc.h
index d213bb4..98c571670 100644
--- a/arch/csky/include/asm/pgalloc.h
+++ b/arch/csky/include/asm/pgalloc.h
@@ -8,6 +8,9 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 
+#define __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd,
 					pte_t *pte)
 {
@@ -39,33 +42,6 @@ static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
 	return pte;
 }
 
-static inline struct page *pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_pages(GFP_KERNEL | __GFP_ZERO, 0);
-	if (!pte)
-		return NULL;
-
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-
-	return pte;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_pages((unsigned long)pte, PTE_ORDER);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_pages(pte, PTE_ORDER);
-}
-
 static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
 	free_pages((unsigned long)pgd, PGD_ORDER);
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 06/15] hexagon: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (4 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 05/15] csky: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 07/15] m68k: sun3: " Mike Rapoport
                   ` (8 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The hexagon implementation pte_alloc_one(), pte_alloc_one_kernel(),
pte_free_kernel() and pte_free() is identical to the generic except of
lack of __GFP_ACCOUNT for the user PTEs allocation.

Switch hexagon to use generic version of these functions.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/hexagon/include/asm/pgalloc.h | 34 ++--------------------------------
 1 file changed, 2 insertions(+), 32 deletions(-)

diff --git a/arch/hexagon/include/asm/pgalloc.h b/arch/hexagon/include/asm/pgalloc.h
index d361838..7661a26 100644
--- a/arch/hexagon/include/asm/pgalloc.h
+++ b/arch/hexagon/include/asm/pgalloc.h
@@ -24,6 +24,8 @@
 #include <asm/mem-layout.h>
 #include <asm/atomic.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 #define check_pgt_cache() do {} while (0)
 
 extern unsigned long long kmap_generation;
@@ -59,38 +61,6 @@ static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 	free_page((unsigned long) pgd);
 }
 
-static inline struct page *pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_page(GFP_KERNEL | __GFP_ZERO);
-	if (!pte)
-		return NULL;
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-	return pte;
-}
-
-/* _kernel variant gets to use a different allocator */
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	gfp_t flags =  GFP_KERNEL | __GFP_ZERO;
-	return (pte_t *) __get_free_page(flags);
-}
-
-static inline void pte_free(struct mm_struct *mm, struct page *pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long)pte);
-}
-
 static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd,
 				pgtable_t pte)
 {
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 07/15] m68k: sun3: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (5 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 06/15] hexagon: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 08/15] mips: " Mike Rapoport
                   ` (7 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The sun3 MMU variant of m68k uses GFP_KERNEL to allocate a PTE page and
then memset(0) or clear_highpage() to clear it.

This is equivalent to allocating the page with GFP_KERNEL | __GFP_ZERO,
which allows replacing sun3 implementation of pte_alloc_one() and
pte_alloc_one_kernel() with the generic ones.

The pte_free() and pte_free_kernel() versions are identical to the generic
ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/m68k/include/asm/sun3_pgalloc.h | 41 ++----------------------------------
 1 file changed, 2 insertions(+), 39 deletions(-)

diff --git a/arch/m68k/include/asm/sun3_pgalloc.h b/arch/m68k/include/asm/sun3_pgalloc.h
index 1456c5e..1a8ddbd 100644
--- a/arch/m68k/include/asm/sun3_pgalloc.h
+++ b/arch/m68k/include/asm/sun3_pgalloc.h
@@ -13,55 +13,18 @@
 
 #include <asm/tlb.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 extern const char bad_pmd_string[];
 
 #define pmd_alloc_one(mm,address)       ({ BUG(); ((pmd_t *)2); })
 
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-        free_page((unsigned long) pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t page)
-{
-	pgtable_page_dtor(page);
-        __free_page(page);
-}
-
 #define __pte_free_tlb(tlb,pte,addr)			\
 do {							\
 	pgtable_page_dtor(pte);				\
 	tlb_remove_page((tlb), pte);			\
 } while (0)
 
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	unsigned long page = __get_free_page(GFP_KERNEL);
-
-	if (!page)
-		return NULL;
-
-	memset((void *)page, 0, PAGE_SIZE);
-	return (pte_t *) (page);
-}
-
-static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
-{
-        struct page *page = alloc_pages(GFP_KERNEL, 0);
-
-	if (page == NULL)
-		return NULL;
-
-	clear_highpage(page);
-	if (!pgtable_page_ctor(page)) {
-		__free_page(page);
-		return NULL;
-	}
-	return page;
-
-}
-
 static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd, pte_t *pte)
 {
 	pmd_val(*pmd) = __pa((unsigned long)pte);
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 08/15] mips: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (6 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 07/15] m68k: sun3: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 19:09   ` Paul Burton
  2019-05-02 15:28 ` [PATCH 09/15] nds32: " Mike Rapoport
                   ` (6 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

MIPS allocates kernel PTE pages with

	__get_free_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)

and user PTE pages with

	alloc_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)

The PTE_ORDER is hardwired to zero, which makes MIPS implementation almost
identical to the generic one.

Switch MIPS to the generic version that does exactly the same thing for the
kernel page tables and adds __GFP_ACCOUNT for the user PTEs.

The pte_free_kernel() and pte_free() versions on mips are identical to the
generic ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/mips/include/asm/pgalloc.h | 33 ++-------------------------------
 1 file changed, 2 insertions(+), 31 deletions(-)

diff --git a/arch/mips/include/asm/pgalloc.h b/arch/mips/include/asm/pgalloc.h
index 27808d9..aa16b85 100644
--- a/arch/mips/include/asm/pgalloc.h
+++ b/arch/mips/include/asm/pgalloc.h
@@ -13,6 +13,8 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd,
 	pte_t *pte)
 {
@@ -50,37 +52,6 @@ static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 	free_pages((unsigned long)pgd, PGD_ORDER);
 }
 
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	return (pte_t *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER);
-}
-
-static inline struct page *pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
-	if (!pte)
-		return NULL;
-	clear_highpage(pte);
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-	return pte;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_pages((unsigned long)pte, PTE_ORDER);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_pages(pte, PTE_ORDER);
-}
-
 #define __pte_free_tlb(tlb,pte,address)			\
 do {							\
 	pgtable_page_dtor(pte);				\
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 09/15] nds32: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (7 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 08/15] mips: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-07  6:49   ` Greentime Hu
  2019-05-02 15:28 ` [PATCH 10/15] nios2: " Mike Rapoport
                   ` (5 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The nds32 implementation of pte_alloc_one_kernel() differs from the generic
in the use of __GFP_RETRY_MAYFAIL flag, which is removed after the
conversion.

The nds32 version of pte_alloc_one() missed the call to pgtable_page_ctor()
and also used __GFP_RETRY_MAYFAIL. Switching it to use generic
__pte_alloc_one() for the PTE page allocation ensures that page table
constructor is run and the user page tables are allocated with
__GFP_ACCOUNT.

The conversion to the generic version of pte_free_kernel() removes the NULL
check for pte.

The pte_free() version on nds32 is identical to the generic one and can be
simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/nds32/include/asm/pgalloc.h | 31 ++++---------------------------
 1 file changed, 4 insertions(+), 27 deletions(-)

diff --git a/arch/nds32/include/asm/pgalloc.h b/arch/nds32/include/asm/pgalloc.h
index 3c5fee5..954696c 100644
--- a/arch/nds32/include/asm/pgalloc.h
+++ b/arch/nds32/include/asm/pgalloc.h
@@ -9,6 +9,9 @@
 #include <asm/tlbflush.h>
 #include <asm/proc-fns.h>
 
+#define __HAVE_ARCH_PTE_ALLOC_ONE
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 /*
  * Since we have only two-level page tables, these are trivial
  */
@@ -22,22 +25,11 @@ extern void pgd_free(struct mm_struct *mm, pgd_t * pgd);
 
 #define check_pgt_cache()		do { } while (0)
 
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	pte_t *pte;
-
-	pte =
-	    (pte_t *) __get_free_page(GFP_KERNEL | __GFP_RETRY_MAYFAIL |
-				      __GFP_ZERO);
-
-	return pte;
-}
-
 static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
 {
 	pgtable_t pte;
 
-	pte = alloc_pages(GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_ZERO, 0);
+	pte = __pte_alloc_one(mm, GFP_PGTABLE_USER);
 	if (pte)
 		cpu_dcache_wb_page((unsigned long)page_address(pte));
 
@@ -45,21 +37,6 @@ static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
 }
 
 /*
- * Free one PTE table.
- */
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t * pte)
-{
-	if (pte) {
-		free_page((unsigned long)pte);
-	}
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	__free_page(pte);
-}
-
-/*
  * Populate the pmdp entry with a pointer to the pte.  This pmd is part
  * of the mm address space.
  *
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 10/15] nios2: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (8 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 09/15] nds32: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 11/15] parisc: " Mike Rapoport
                   ` (4 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

nios2 allocates kernel PTE pages with

        __get_free_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER);

and user page tables with

        pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
	if (pte)
		clear_highpage();

The PTE_ORDER is hardwired to zero, which makes nios2 implementation almost
identical to the generic one.

Switch nios2 to the generic version that does exactly the same thing for
the kernel page tables and adds __GFP_ACCOUNT for the user PTEs.

The pte_free_kernel() and pte_free() versions on nios2 are identical to the
generic ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/nios2/include/asm/pgalloc.h | 37 ++-----------------------------------
 1 file changed, 2 insertions(+), 35 deletions(-)

diff --git a/arch/nios2/include/asm/pgalloc.h b/arch/nios2/include/asm/pgalloc.h
index 3a149ea..4bc8cf7 100644
--- a/arch/nios2/include/asm/pgalloc.h
+++ b/arch/nios2/include/asm/pgalloc.h
@@ -12,6 +12,8 @@
 
 #include <linux/mm.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd,
 	pte_t *pte)
 {
@@ -37,41 +39,6 @@ static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 	free_pages((unsigned long)pgd, PGD_ORDER);
 }
 
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	pte_t *pte;
-
-	pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_ZERO, PTE_ORDER);
-
-	return pte;
-}
-
-static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
-	if (pte) {
-		if (!pgtable_page_ctor(pte)) {
-			__free_page(pte);
-			return NULL;
-		}
-		clear_highpage(pte);
-	}
-	return pte;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_pages((unsigned long)pte, PTE_ORDER);
-}
-
-static inline void pte_free(struct mm_struct *mm, struct page *pte)
-{
-	pgtable_page_dtor(pte);
-	__free_pages(pte, PTE_ORDER);
-}
-
 #define __pte_free_tlb(tlb, pte, addr)				\
 	do {							\
 		pgtable_page_dtor(pte);				\
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 11/15] parisc: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (9 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 10/15] nios2: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 15:28 ` [PATCH 12/15] powerpc/nohash/64: " Mike Rapoport
                   ` (3 subsequent siblings)
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

parisc allocates PTE pages with __get_free_page() and uses
GFP_KERNEL | __GFP_ZERO for the allocations.

Switch it to the generic version that does exactly the same thing for the
kernel page tables and adds __GFP_ACCOUNT for the user PTEs.

The pte_free_kernel() and pte_free() versions on are identical to the
generic ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/parisc/include/asm/pgalloc.h | 33 ++-------------------------------
 1 file changed, 2 insertions(+), 31 deletions(-)

diff --git a/arch/parisc/include/asm/pgalloc.h b/arch/parisc/include/asm/pgalloc.h
index d05c678c..265ec42 100644
--- a/arch/parisc/include/asm/pgalloc.h
+++ b/arch/parisc/include/asm/pgalloc.h
@@ -10,6 +10,8 @@
 
 #include <asm/cache.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 /* Allocate the top level pgd (page directory)
  *
  * Here (for 64 bit kernels) we implement a Hybrid L2/L3 scheme: we
@@ -121,37 +123,6 @@ pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd, pte_t *pte)
 	pmd_populate_kernel(mm, pmd, page_address(pte_page))
 #define pmd_pgtable(pmd) pmd_page(pmd)
 
-static inline pgtable_t
-pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *page = alloc_page(GFP_KERNEL|__GFP_ZERO);
-	if (!page)
-		return NULL;
-	if (!pgtable_page_ctor(page)) {
-		__free_page(page);
-		return NULL;
-	}
-	return page;
-}
-
-static inline pte_t *
-pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
-	return pte;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, struct page *pte)
-{
-	pgtable_page_dtor(pte);
-	pte_free_kernel(mm, page_address(pte));
-}
-
 #define check_pgt_cache()	do { } while (0)
 
 #endif
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 12/15] powerpc/nohash/64: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (10 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 11/15] parisc: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-02 16:56   ` Christophe Leroy
  2019-05-02 15:28 ` [PATCH 13/15] riscv: " Mike Rapoport
                   ` (2 subsequent siblings)
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The 64-bit book-E powerpc implements pte_alloc_one(),
pte_alloc_one_kernel(), pte_free_kernel() and pte_free() the same way as
the generic version.

Switch it to the generic version that does exactly the same thing.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/powerpc/include/asm/nohash/64/pgalloc.h | 35 ++--------------------------
 1 file changed, 2 insertions(+), 33 deletions(-)

diff --git a/arch/powerpc/include/asm/nohash/64/pgalloc.h b/arch/powerpc/include/asm/nohash/64/pgalloc.h
index 66d086f..bfb53a0 100644
--- a/arch/powerpc/include/asm/nohash/64/pgalloc.h
+++ b/arch/powerpc/include/asm/nohash/64/pgalloc.h
@@ -11,6 +11,8 @@
 #include <linux/cpumask.h>
 #include <linux/percpu.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 struct vmemmap_backing {
 	struct vmemmap_backing *list;
 	unsigned long phys;
@@ -92,39 +94,6 @@ static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
 	kmem_cache_free(PGT_CACHE(PMD_CACHE_INDEX), pmd);
 }
 
-
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
-}
-
-static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *page;
-	pte_t *pte;
-
-	pte = (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO | __GFP_ACCOUNT);
-	if (!pte)
-		return NULL;
-	page = virt_to_page(pte);
-	if (!pgtable_page_ctor(page)) {
-		__free_page(page);
-		return NULL;
-	}
-	return page;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t ptepage)
-{
-	pgtable_page_dtor(ptepage);
-	__free_page(ptepage);
-}
-
 static inline void pgtable_free(void *table, int shift)
 {
 	if (!shift) {
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 13/15] riscv: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (11 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 12/15] powerpc/nohash/64: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-06 18:25   ` Palmer Dabbelt
  2019-05-02 15:28 ` [PATCH 14/15] um: " Mike Rapoport
  2019-05-02 15:28 ` [PATCH 15/15] unicore32: " Mike Rapoport
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

The only difference between the generic and RISC-V implementation of PTE
allocation is the usage of __GFP_RETRY_MAYFAIL for both kernel and user
PTEs and the absence of __GFP_ACCOUNT for the user PTEs.

The conversion to the generic version removes the __GFP_RETRY_MAYFAIL and
ensures that GFP_ACCOUNT is used for the user PTE allocations.

The pte_free() and pte_free_kernel() versions are identical to the generic
ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/riscv/include/asm/pgalloc.h | 29 ++---------------------------
 1 file changed, 2 insertions(+), 27 deletions(-)

diff --git a/arch/riscv/include/asm/pgalloc.h b/arch/riscv/include/asm/pgalloc.h
index 94043cf..48f28bb 100644
--- a/arch/riscv/include/asm/pgalloc.h
+++ b/arch/riscv/include/asm/pgalloc.h
@@ -18,6 +18,8 @@
 #include <linux/mm.h>
 #include <asm/tlb.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 static inline void pmd_populate_kernel(struct mm_struct *mm,
 	pmd_t *pmd, pte_t *pte)
 {
@@ -82,33 +84,6 @@ static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
 
 #endif /* __PAGETABLE_PMD_FOLDED */
 
-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	return (pte_t *)__get_free_page(
-		GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_ZERO);
-}
-
-static inline struct page *pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_page(GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_ZERO);
-	if (likely(pte != NULL))
-		pgtable_page_ctor(pte);
-	return pte;
-}
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 #define __pte_free_tlb(tlb, pte, buf)   \
 do {                                    \
 	pgtable_page_dtor(pte);         \
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 14/15] um: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (12 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 13/15] riscv: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  2019-05-03 13:28   ` Anton Ivanov
  2019-05-02 15:28 ` [PATCH 15/15] unicore32: " Mike Rapoport
  14 siblings, 1 reply; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

um allocates PTE pages with __get_free_page() and uses
GFP_KERNEL | __GFP_ZERO for the allocations.

Switch it to the generic version that does exactly the same thing for the
kernel page tables and adds __GFP_ACCOUNT for the user PTEs.

The pte_free() and pte_free_kernel() versions are identical to the generic
ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/um/include/asm/pgalloc.h | 16 ++--------------
 arch/um/kernel/mem.c          | 22 ----------------------
 2 files changed, 2 insertions(+), 36 deletions(-)

diff --git a/arch/um/include/asm/pgalloc.h b/arch/um/include/asm/pgalloc.h
index 99eb568..d7b282e 100644
--- a/arch/um/include/asm/pgalloc.h
+++ b/arch/um/include/asm/pgalloc.h
@@ -10,6 +10,8 @@
 
 #include <linux/mm.h>
 
+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
+
 #define pmd_populate_kernel(mm, pmd, pte) \
 	set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
 
@@ -25,20 +27,6 @@
 extern pgd_t *pgd_alloc(struct mm_struct *);
 extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
 
-extern pte_t *pte_alloc_one_kernel(struct mm_struct *);
-extern pgtable_t pte_alloc_one(struct mm_struct *);
-
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	free_page((unsigned long) pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 #define __pte_free_tlb(tlb,pte, address)		\
 do {							\
 	pgtable_page_dtor(pte);				\
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
index 99aa11b..2280374 100644
--- a/arch/um/kernel/mem.c
+++ b/arch/um/kernel/mem.c
@@ -215,28 +215,6 @@ void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 	free_page((unsigned long) pgd);
 }
 
-pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
-{
-	pte_t *pte;
-
-	pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
-	return pte;
-}
-
-pgtable_t pte_alloc_one(struct mm_struct *mm)
-{
-	struct page *pte;
-
-	pte = alloc_page(GFP_KERNEL|__GFP_ZERO);
-	if (!pte)
-		return NULL;
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-		return NULL;
-	}
-	return pte;
-}
-
 #ifdef CONFIG_3_LEVEL_PGTABLES
 pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
 {
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* [PATCH 15/15] unicore32: switch to generic version of pte allocation
  2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
                   ` (13 preceding siblings ...)
  2019-05-02 15:28 ` [PATCH 14/15] um: " Mike Rapoport
@ 2019-05-02 15:28 ` Mike Rapoport
  14 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-02 15:28 UTC (permalink / raw)
  To: Andrew Morton
  Cc: Arnd Bergmann, Catalin Marinas, Geert Uytterhoeven, Greentime Hu,
	Guan Xuetao, Guo Ren, Helge Deller, Ley Foon Tan, Matthew Wilcox,
	Matt Turner, Michael Ellerman, Michal Hocko, Palmer Dabbelt,
	Paul Burton, Richard Kuo, Richard Weinberger, Russell King,
	Sam Creasey, x86, linux-alpha, linux-arch, linux-arm-kernel,
	linux-hexagon, linux-kernel, linux-m68k, linux-mips,
	linux-parisc, linuxppc-dev, linux-riscv, linux-um, nios2-dev,
	Mike Rapoport

Replace __get_free_page() and alloc_pages() calls with the generic
__pte_alloc_one_kernel() and __pte_alloc_one().

There is no functional change for the kernel PTE allocation.

The difference for the user PTEs, is that the clear_pte_table() is now
called after pgtable_page_ctor() and the addition of __GFP_ACCOUNT to the
GFP flags.

The pte_free() and pte_free_kernel() versions are identical to the generic
ones and can be simply dropped.

Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
---
 arch/unicore32/include/asm/pgalloc.h | 36 ++++++++----------------------------
 1 file changed, 8 insertions(+), 28 deletions(-)

diff --git a/arch/unicore32/include/asm/pgalloc.h b/arch/unicore32/include/asm/pgalloc.h
index 7cceabe..dd09af6 100644
--- a/arch/unicore32/include/asm/pgalloc.h
+++ b/arch/unicore32/include/asm/pgalloc.h
@@ -17,6 +17,10 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 
+#define __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
+#define __HAVE_ARCH_PTE_ALLOC_ONE
+#include <asm-generic/pgalloc.h>
+
 #define check_pgt_cache()		do { } while (0)
 
 #define _PAGE_USER_TABLE	(PMD_TYPE_TABLE | PMD_PRESENT)
@@ -28,17 +32,14 @@ extern void free_pgd_slow(struct mm_struct *mm, pgd_t *pgd);
 #define pgd_alloc(mm)			get_pgd_slow(mm)
 #define pgd_free(mm, pgd)		free_pgd_slow(mm, pgd)
 
-#define PGALLOC_GFP	(GFP_KERNEL | __GFP_ZERO)
-
 /*
  * Allocate one PTE table.
  */
 static inline pte_t *
 pte_alloc_one_kernel(struct mm_struct *mm)
 {
-	pte_t *pte;
+	pte_t *pte = __pte_alloc_one_kernel(mm);
 
-	pte = (pte_t *)__get_free_page(PGALLOC_GFP);
 	if (pte)
 		clean_dcache_area(pte, PTRS_PER_PTE * sizeof(pte_t));
 
@@ -50,35 +51,14 @@ pte_alloc_one(struct mm_struct *mm)
 {
 	struct page *pte;
 
-	pte = alloc_pages(PGALLOC_GFP, 0);
+	pte = __pte_alloc_one(mm, GFP_PGTABLE_USER);
 	if (!pte)
 		return NULL;
-	if (!PageHighMem(pte)) {
-		void *page = page_address(pte);
-		clean_dcache_area(page, PTRS_PER_PTE * sizeof(pte_t));
-	}
-	if (!pgtable_page_ctor(pte)) {
-		__free_page(pte);
-	}
-
+	if (!PageHighMem(pte))
+		clean_pte_table(page_address(pte));
 	return pte;
 }
 
-/*
- * Free one PTE table.
- */
-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
-{
-	if (pte)
-		free_page((unsigned long)pte);
-}
-
-static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
-{
-	pgtable_page_dtor(pte);
-	__free_page(pte);
-}
-
 static inline void __pmd_populate(pmd_t *pmdp, unsigned long pmdval)
 {
 	set_pmd(pmdp, __pmd(pmdval));
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 29+ messages in thread

* Re: [PATCH 12/15] powerpc/nohash/64: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 12/15] powerpc/nohash/64: " Mike Rapoport
@ 2019-05-02 16:56   ` Christophe Leroy
  2019-05-05  6:23     ` Mike Rapoport
  0 siblings, 1 reply; 29+ messages in thread
From: Christophe Leroy @ 2019-05-02 16:56 UTC (permalink / raw)
  To: Mike Rapoport, Andrew Morton
  Cc: Michal Hocko, Catalin Marinas, Palmer Dabbelt, linux-mips,
	Guo Ren, linux-hexagon, linux-riscv, linux-arch, Helge Deller,
	x86, Russell King, Matthew Wilcox, Geert Uytterhoeven,
	Matt Turner, Sam Creasey, Arnd Bergmann, linux-um,
	Richard Weinberger, linux-m68k, Greentime Hu, nios2-dev,
	Guan Xuetao, linux-arm-kernel, linux-parisc, linux-kernel,
	Richard Kuo, Paul Burton, linux-alpha, Ley Foon Tan,
	linuxppc-dev



Le 02/05/2019 à 17:28, Mike Rapoport a écrit :
> The 64-bit book-E powerpc implements pte_alloc_one(),
> pte_alloc_one_kernel(), pte_free_kernel() and pte_free() the same way as
> the generic version.

Will soon be converted to the same as the 3 other PPC subarches, see
https://patchwork.ozlabs.org/patch/1091590/

Christophe

> 
> Switch it to the generic version that does exactly the same thing.
> 
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>   arch/powerpc/include/asm/nohash/64/pgalloc.h | 35 ++--------------------------
>   1 file changed, 2 insertions(+), 33 deletions(-)
> 
> diff --git a/arch/powerpc/include/asm/nohash/64/pgalloc.h b/arch/powerpc/include/asm/nohash/64/pgalloc.h
> index 66d086f..bfb53a0 100644
> --- a/arch/powerpc/include/asm/nohash/64/pgalloc.h
> +++ b/arch/powerpc/include/asm/nohash/64/pgalloc.h
> @@ -11,6 +11,8 @@
>   #include <linux/cpumask.h>
>   #include <linux/percpu.h>
>   
> +#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> +
>   struct vmemmap_backing {
>   	struct vmemmap_backing *list;
>   	unsigned long phys;
> @@ -92,39 +94,6 @@ static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
>   	kmem_cache_free(PGT_CACHE(PMD_CACHE_INDEX), pmd);
>   }
>   
> -
> -static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
> -{
> -	return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
> -}
> -
> -static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
> -{
> -	struct page *page;
> -	pte_t *pte;
> -
> -	pte = (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO | __GFP_ACCOUNT);
> -	if (!pte)
> -		return NULL;
> -	page = virt_to_page(pte);
> -	if (!pgtable_page_ctor(page)) {
> -		__free_page(page);
> -		return NULL;
> -	}
> -	return page;
> -}
> -
> -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> -{
> -	free_page((unsigned long)pte);
> -}
> -
> -static inline void pte_free(struct mm_struct *mm, pgtable_t ptepage)
> -{
> -	pgtable_page_dtor(ptepage);
> -	__free_page(ptepage);
> -}
> -
>   static inline void pgtable_free(void *table, int shift)
>   {
>   	if (!shift) {
> 

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 01/15] asm-generic, x86: introduce generic pte_{alloc,free}_one[_kernel]
  2019-05-02 15:28 ` [PATCH 01/15] asm-generic, x86: " Mike Rapoport
@ 2019-05-02 19:03   ` Paul Burton
  2019-05-05  6:15     ` Mike Rapoport
  0 siblings, 1 reply; 29+ messages in thread
From: Paul Burton @ 2019-05-02 19:03 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon, linux-kernel,
	linux-m68k, linux-mips, linux-parisc, linuxppc-dev, linux-riscv,
	linux-um, nios2-dev

Hi Mike,

On Thu, May 02, 2019 at 06:28:28PM +0300, Mike Rapoport wrote:
> +/**
> + * pte_free_kernel - free PTE-level user page table page
> + * @mm: the mm_struct of the current context
> + * @pte_page: the `struct page` representing the page table
> + */
> +static inline void pte_free(struct mm_struct *mm, struct page *pte_page)
> +{
> +	pgtable_page_dtor(pte_page);
> +	__free_page(pte_page);
> +}

Nit: the comment names the wrong function (s/pte_free_kernel/pte_free/).

Thanks,
    Paul

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 08/15] mips: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 08/15] mips: " Mike Rapoport
@ 2019-05-02 19:09   ` Paul Burton
  2019-05-05  6:17     ` Mike Rapoport
  0 siblings, 1 reply; 29+ messages in thread
From: Paul Burton @ 2019-05-02 19:09 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon, linux-kernel,
	linux-m68k, linux-mips, linux-parisc, linuxppc-dev, linux-riscv,
	linux-um, nios2-dev

Hi Mike,

On Thu, May 02, 2019 at 06:28:35PM +0300, Mike Rapoport wrote:
> MIPS allocates kernel PTE pages with
> 
> 	__get_free_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)
> 
> and user PTE pages with
> 
> 	alloc_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)

That bit isn't quite true - we don't use __GFP_ZERO in pte_alloc_one() &
instead call clear_highpage() on the allocated page. Not that I have a
problem with using __GFP_ZERO - it seems like the more optimal choice.
It just might be worth mentioning the change & expected equivalent
behavior.

Otherwise:

    Acked-by: Paul Burton <paul.burton@mips.com>

Thanks,
    Paul

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 04/15] arm64: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 04/15] arm64: " Mike Rapoport
@ 2019-05-03 10:05   ` Mark Rutland
  2019-05-05  6:19     ` Mike Rapoport
  0 siblings, 1 reply; 29+ messages in thread
From: Mark Rutland @ 2019-05-03 10:05 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Paul Burton,
	Richard Kuo, Richard Weinberger, Russell King, Sam Creasey, x86,
	linux-alpha, linux-arch, linux-arm-kernel, linux-hexagon,
	linux-kernel, linux-m68k, linux-mips, linux-parisc, linuxppc-dev,
	linux-riscv, linux-um, nios2-dev

Hi,

On Thu, May 02, 2019 at 06:28:31PM +0300, Mike Rapoport wrote:
> The PTE allocations in arm64 are identical to the generic ones modulo the
> GFP flags.
> 
> Using the generic pte_alloc_one() functions ensures that the user page
> tables are allocated with __GFP_ACCOUNT set.
> 
> The arm64 definition of PGALLOC_GFP is removed and replaced with
> GFP_PGTABLE_USER for p[gum]d_alloc_one() and for KVM memory cache.
> 
> The mappings created with create_pgd_mapping() are now using
> GFP_PGTABLE_KERNEL.
> 
> The conversion to the generic version of pte_free_kernel() removes the NULL
> check for pte.
> 
> The pte_free() version on arm64 is identical to the generic one and
> can be simply dropped.
> 
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>  arch/arm64/include/asm/pgalloc.h | 43 ++++------------------------------------
>  arch/arm64/mm/mmu.c              |  2 +-
>  arch/arm64/mm/pgd.c              |  4 ++--
>  virt/kvm/arm/mmu.c               |  2 +-
>  4 files changed, 8 insertions(+), 43 deletions(-)

[...]

> diff --git a/arch/arm64/mm/pgd.c b/arch/arm64/mm/pgd.c
> index 289f911..2ef1a53 100644
> --- a/arch/arm64/mm/pgd.c
> +++ b/arch/arm64/mm/pgd.c
> @@ -31,9 +31,9 @@ static struct kmem_cache *pgd_cache __ro_after_init;
>  pgd_t *pgd_alloc(struct mm_struct *mm)
>  {
>  	if (PGD_SIZE == PAGE_SIZE)
> -		return (pgd_t *)__get_free_page(PGALLOC_GFP);
> +		return (pgd_t *)__get_free_page(GFP_PGTABLE_USER);
>  	else
> -		return kmem_cache_alloc(pgd_cache, PGALLOC_GFP);
> +		return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
>  }

In efi_virtmap_init() we use pgd_alloc() to allocate a pgd for EFI
runtime services, which we map with a special kernel page table.

I'm not sure if accounting that is problematic, as it's allocated in a
kernel thread off the back of an early_initcall.

Just to check, Is that sound, or do we need a pgd_alloc_kernel()?

Thanks,
Mark.

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 14/15] um: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 14/15] um: " Mike Rapoport
@ 2019-05-03 13:28   ` Anton Ivanov
  0 siblings, 0 replies; 29+ messages in thread
From: Anton Ivanov @ 2019-05-03 13:28 UTC (permalink / raw)
  To: Mike Rapoport, Andrew Morton
  Cc: Michal Hocko, Catalin Marinas, Palmer Dabbelt, linux-mips,
	Guo Ren, linux-hexagon, linux-riscv, linux-arch,
	Michael Ellerman, Helge Deller, x86, Russell King,
	Matthew Wilcox, Geert Uytterhoeven, Matt Turner, Sam Creasey,
	Arnd Bergmann, linux-um, Richard Weinberger, linux-m68k,
	Greentime Hu, nios2-dev, Guan Xuetao, linux-arm-kernel,
	linux-parisc, linux-kernel, Richard Kuo, Paul Burton,
	linux-alpha, Ley Foon Tan, linuxppc-dev



On 02/05/2019 16:28, Mike Rapoport wrote:
> um allocates PTE pages with __get_free_page() and uses
> GFP_KERNEL | __GFP_ZERO for the allocations.
> 
> Switch it to the generic version that does exactly the same thing for the
> kernel page tables and adds __GFP_ACCOUNT for the user PTEs.
> 
> The pte_free() and pte_free_kernel() versions are identical to the generic
> ones and can be simply dropped.
> 
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>   arch/um/include/asm/pgalloc.h | 16 ++--------------
>   arch/um/kernel/mem.c          | 22 ----------------------
>   2 files changed, 2 insertions(+), 36 deletions(-)
> 
> diff --git a/arch/um/include/asm/pgalloc.h b/arch/um/include/asm/pgalloc.h
> index 99eb568..d7b282e 100644
> --- a/arch/um/include/asm/pgalloc.h
> +++ b/arch/um/include/asm/pgalloc.h
> @@ -10,6 +10,8 @@
>   
>   #include <linux/mm.h>
>   
> +#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> +
>   #define pmd_populate_kernel(mm, pmd, pte) \
>   	set_pmd(pmd, __pmd(_PAGE_TABLE + (unsigned long) __pa(pte)))
>   
> @@ -25,20 +27,6 @@
>   extern pgd_t *pgd_alloc(struct mm_struct *);
>   extern void pgd_free(struct mm_struct *mm, pgd_t *pgd);
>   
> -extern pte_t *pte_alloc_one_kernel(struct mm_struct *);
> -extern pgtable_t pte_alloc_one(struct mm_struct *);
> -
> -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> -{
> -	free_page((unsigned long) pte);
> -}
> -
> -static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
> -{
> -	pgtable_page_dtor(pte);
> -	__free_page(pte);
> -}
> -
>   #define __pte_free_tlb(tlb,pte, address)		\
>   do {							\
>   	pgtable_page_dtor(pte);				\
> diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
> index 99aa11b..2280374 100644
> --- a/arch/um/kernel/mem.c
> +++ b/arch/um/kernel/mem.c
> @@ -215,28 +215,6 @@ void pgd_free(struct mm_struct *mm, pgd_t *pgd)
>   	free_page((unsigned long) pgd);
>   }
>   
> -pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
> -{
> -	pte_t *pte;
> -
> -	pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
> -	return pte;
> -}
> -
> -pgtable_t pte_alloc_one(struct mm_struct *mm)
> -{
> -	struct page *pte;
> -
> -	pte = alloc_page(GFP_KERNEL|__GFP_ZERO);
> -	if (!pte)
> -		return NULL;
> -	if (!pgtable_page_ctor(pte)) {
> -		__free_page(pte);
> -		return NULL;
> -	}
> -	return pte;
> -}
> -
>   #ifdef CONFIG_3_LEVEL_PGTABLES
>   pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
>   {
> 


Reviewed-by: Anton Ivanov <anton.ivanov@cambridgegreys.com>
Acked-by: Anton Ivanov <anton.ivanov@cambridgegreys.com>

-- 
Anton R. Ivanov
Cambridgegreys Limited. Registered in England. Company Number 10273661
https://www.cambridgegreys.com/

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 05/15] csky: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 05/15] csky: " Mike Rapoport
@ 2019-05-03 16:03   ` Guo Ren
  2019-05-03 16:18     ` Guo Ren
  0 siblings, 1 reply; 29+ messages in thread
From: Guo Ren @ 2019-05-03 16:03 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Helge Deller,
	Ley Foon Tan, Matthew Wilcox, Matt Turner, Michael Ellerman,
	Michal Hocko, Palmer Dabbelt, Paul Burton, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon, linux-kernel,
	linux-m68k, linux-mips, linux-parisc, linuxppc-dev, linux-riscv,
	linux-um, nios2-dev

Hi Mike,

Acked-by: Guo Ren <ren_guo@c-sky.com>

On Thu, May 02, 2019 at 06:28:32PM +0300, Mike Rapoport wrote:
> The csky implementation pte_alloc_one(), pte_free_kernel() and pte_free()
> is identical to the generic except of lack of __GFP_ACCOUNT for the user
> PTEs allocation.
> 
> Switch csky to use generic version of these functions.
Ok.

> 
> The csky implementation of pte_alloc_one_kernel() is not replaced because
> it does not clear the allocated page but rather sets each PTE in it to a
> non-zero value.
Yes, we must set each PTE to _PAGE_GLOBAL because hardware refill the
MMU TLB entry with two PTEs and it use the result of pte0.global | pte1.global.
If pte0 is valid and pte1 is invalid, we must set _PAGE_GLOBAL in
invalid pte entry. Fortunately, there is no performance issue.

> 
> The pte_free_kernel() and pte_free() versions on csky are identical to the
> generic ones and can be simply dropped.
Ok.

Best Regards
 Guo Ren

> 
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>  arch/csky/include/asm/pgalloc.h | 30 +++---------------------------
>  1 file changed, 3 insertions(+), 27 deletions(-)
> 
> diff --git a/arch/csky/include/asm/pgalloc.h b/arch/csky/include/asm/pgalloc.h
> index d213bb4..98c571670 100644
> --- a/arch/csky/include/asm/pgalloc.h
> +++ b/arch/csky/include/asm/pgalloc.h
> @@ -8,6 +8,9 @@
>  #include <linux/mm.h>
>  #include <linux/sched.h>
>  
> +#define __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
> +#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> +
>  static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd,
>  					pte_t *pte)
>  {
> @@ -39,33 +42,6 @@ static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
>  	return pte;
>  }
>  
> -static inline struct page *pte_alloc_one(struct mm_struct *mm)
> -{
> -	struct page *pte;
> -
> -	pte = alloc_pages(GFP_KERNEL | __GFP_ZERO, 0);
> -	if (!pte)
> -		return NULL;
> -
> -	if (!pgtable_page_ctor(pte)) {
> -		__free_page(pte);
> -		return NULL;
> -	}
> -
> -	return pte;
> -}
> -
> -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> -{
> -	free_pages((unsigned long)pte, PTE_ORDER);
> -}
> -
> -static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
> -{
> -	pgtable_page_dtor(pte);
> -	__free_pages(pte, PTE_ORDER);
> -}
> -
>  static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
>  {
>  	free_pages((unsigned long)pgd, PGD_ORDER);
> -- 
> 2.7.4
> 

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 05/15] csky: switch to generic version of pte allocation
  2019-05-03 16:03   ` Guo Ren
@ 2019-05-03 16:18     ` Guo Ren
  0 siblings, 0 replies; 29+ messages in thread
From: Guo Ren @ 2019-05-03 16:18 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Michal Hocko, Catalin Marinas, Palmer Dabbelt, linux-mips,
	Michael Ellerman, linux-hexagon, linux-riscv, linux-arch,
	Richard Weinberger, Helge Deller, x86, Russell King,
	Matthew Wilcox, Geert Uytterhoeven, Matt Turner, Sam Creasey,
	Arnd Bergmann, linux-um, linux-m68k, Greentime Hu, nios2-dev,
	Guan Xuetao, linux-arm-kernel, linux-parisc, linux-kernel,
	Richard Kuo, Paul Burton, linux-alpha, Ley Foon Tan,
	Andrew Morton, linuxppc-dev

On Sat, May 04, 2019 at 12:03:48AM +0800, Guo Ren wrote:
> Hi Mike,
> 
> Acked-by: Guo Ren <ren_guo@c-sky.com>
> 
> On Thu, May 02, 2019 at 06:28:32PM +0300, Mike Rapoport wrote:
> > The csky implementation pte_alloc_one(), pte_free_kernel() and pte_free()
> > is identical to the generic except of lack of __GFP_ACCOUNT for the user
> > PTEs allocation.
> > 
> > Switch csky to use generic version of these functions.
> Ok.
> 
> > 
> > The csky implementation of pte_alloc_one_kernel() is not replaced because
> > it does not clear the allocated page but rather sets each PTE in it to a
> > non-zero value.
> Yes, we must set each PTE to _PAGE_GLOBAL because hardware refill the
> MMU TLB entry with two PTEs and it use the result of pte0.global | pte1.global.
                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^
                                              correct: pte0.global & pte1.global
> If pte0 is valid and pte1 is invalid, we must set _PAGE_GLOBAL in
> invalid pte entry. Fortunately, there is no performance issue.
> 
> > 
> > The pte_free_kernel() and pte_free() versions on csky are identical to the
> > generic ones and can be simply dropped.
> Ok.
> 
> Best Regards
>  Guo Ren
> 
> > 
> > Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> > ---
> >  arch/csky/include/asm/pgalloc.h | 30 +++---------------------------
> >  1 file changed, 3 insertions(+), 27 deletions(-)
> > 
> > diff --git a/arch/csky/include/asm/pgalloc.h b/arch/csky/include/asm/pgalloc.h
> > index d213bb4..98c571670 100644
> > --- a/arch/csky/include/asm/pgalloc.h
> > +++ b/arch/csky/include/asm/pgalloc.h
> > @@ -8,6 +8,9 @@
> >  #include <linux/mm.h>
> >  #include <linux/sched.h>
> >  
> > +#define __HAVE_ARCH_PTE_ALLOC_ONE_KERNEL
> > +#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> > +
> >  static inline void pmd_populate_kernel(struct mm_struct *mm, pmd_t *pmd,
> >  					pte_t *pte)
> >  {
> > @@ -39,33 +42,6 @@ static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
> >  	return pte;
> >  }
> >  
> > -static inline struct page *pte_alloc_one(struct mm_struct *mm)
> > -{
> > -	struct page *pte;
> > -
> > -	pte = alloc_pages(GFP_KERNEL | __GFP_ZERO, 0);
> > -	if (!pte)
> > -		return NULL;
> > -
> > -	if (!pgtable_page_ctor(pte)) {
> > -		__free_page(pte);
> > -		return NULL;
> > -	}
> > -
> > -	return pte;
> > -}
> > -
> > -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> > -{
> > -	free_pages((unsigned long)pte, PTE_ORDER);
> > -}
> > -
> > -static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
> > -{
> > -	pgtable_page_dtor(pte);
> > -	__free_pages(pte, PTE_ORDER);
> > -}
> > -
> >  static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
> >  {
> >  	free_pages((unsigned long)pgd, PGD_ORDER);
> > -- 
> > 2.7.4
> > 
> 
> _______________________________________________
> linux-riscv mailing list
> linux-riscv@lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/linux-riscv

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 01/15] asm-generic, x86: introduce generic pte_{alloc,free}_one[_kernel]
  2019-05-02 19:03   ` Paul Burton
@ 2019-05-05  6:15     ` Mike Rapoport
  0 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-05  6:15 UTC (permalink / raw)
  To: Paul Burton
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon, linux-kernel,
	linux-m68k, linux-mips, linux-parisc, linuxppc-dev, linux-riscv,
	linux-um, nios2-dev

On Thu, May 02, 2019 at 07:03:11PM +0000, Paul Burton wrote:
> Hi Mike,
> 
> On Thu, May 02, 2019 at 06:28:28PM +0300, Mike Rapoport wrote:
> > +/**
> > + * pte_free_kernel - free PTE-level user page table page
> > + * @mm: the mm_struct of the current context
> > + * @pte_page: the `struct page` representing the page table
> > + */
> > +static inline void pte_free(struct mm_struct *mm, struct page *pte_page)
> > +{
> > +	pgtable_page_dtor(pte_page);
> > +	__free_page(pte_page);
> > +}
> 
> Nit: the comment names the wrong function (s/pte_free_kernel/pte_free/).

Argh, evil copy-paste :)
Thanks!
 
> Thanks,
>     Paul
> 

-- 
Sincerely yours,
Mike.


^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 08/15] mips: switch to generic version of pte allocation
  2019-05-02 19:09   ` Paul Burton
@ 2019-05-05  6:17     ` Mike Rapoport
  0 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-05  6:17 UTC (permalink / raw)
  To: Paul Burton
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon, linux-kernel,
	linux-m68k, linux-mips, linux-parisc, linuxppc-dev, linux-riscv,
	linux-um, nios2-dev

On Thu, May 02, 2019 at 07:09:47PM +0000, Paul Burton wrote:
> Hi Mike,
> 
> On Thu, May 02, 2019 at 06:28:35PM +0300, Mike Rapoport wrote:
> > MIPS allocates kernel PTE pages with
> > 
> > 	__get_free_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)
> > 
> > and user PTE pages with
> > 
> > 	alloc_pages(GFP_KERNEL | __GFP_ZERO, PTE_ORDER)
> 
> That bit isn't quite true - we don't use __GFP_ZERO in pte_alloc_one() &
> instead call clear_highpage() on the allocated page. Not that I have a
> problem with using __GFP_ZERO - it seems like the more optimal choice.
> It just might be worth mentioning the change & expected equivalent
> behavior.

You are right, I'll fix the changelog.
 
> Otherwise:
> 
>     Acked-by: Paul Burton <paul.burton@mips.com>

Thanks.

> Thanks,
>     Paul
> 

-- 
Sincerely yours,
Mike.


^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 04/15] arm64: switch to generic version of pte allocation
  2019-05-03 10:05   ` Mark Rutland
@ 2019-05-05  6:19     ` Mike Rapoport
  0 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-05  6:19 UTC (permalink / raw)
  To: Mark Rutland
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Greentime Hu, Guan Xuetao, Guo Ren,
	Helge Deller, Ley Foon Tan, Matthew Wilcox, Matt Turner,
	Michael Ellerman, Michal Hocko, Palmer Dabbelt, Paul Burton,
	Richard Kuo, Richard Weinberger, Russell King, Sam Creasey, x86,
	linux-alpha, linux-arch, linux-arm-kernel, linux-hexagon,
	linux-kernel, linux-m68k, linux-mips, linux-parisc, linuxppc-dev,
	linux-riscv, linux-um, nios2-dev

On Fri, May 03, 2019 at 11:05:09AM +0100, Mark Rutland wrote:
> Hi,
> 
> On Thu, May 02, 2019 at 06:28:31PM +0300, Mike Rapoport wrote:
> > The PTE allocations in arm64 are identical to the generic ones modulo the
> > GFP flags.
> > 
> > Using the generic pte_alloc_one() functions ensures that the user page
> > tables are allocated with __GFP_ACCOUNT set.
> > 
> > The arm64 definition of PGALLOC_GFP is removed and replaced with
> > GFP_PGTABLE_USER for p[gum]d_alloc_one() and for KVM memory cache.
> > 
> > The mappings created with create_pgd_mapping() are now using
> > GFP_PGTABLE_KERNEL.
> > 
> > The conversion to the generic version of pte_free_kernel() removes the NULL
> > check for pte.
> > 
> > The pte_free() version on arm64 is identical to the generic one and
> > can be simply dropped.
> > 
> > Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> > ---
> >  arch/arm64/include/asm/pgalloc.h | 43 ++++------------------------------------
> >  arch/arm64/mm/mmu.c              |  2 +-
> >  arch/arm64/mm/pgd.c              |  4 ++--
> >  virt/kvm/arm/mmu.c               |  2 +-
> >  4 files changed, 8 insertions(+), 43 deletions(-)
> 
> [...]
> 
> > diff --git a/arch/arm64/mm/pgd.c b/arch/arm64/mm/pgd.c
> > index 289f911..2ef1a53 100644
> > --- a/arch/arm64/mm/pgd.c
> > +++ b/arch/arm64/mm/pgd.c
> > @@ -31,9 +31,9 @@ static struct kmem_cache *pgd_cache __ro_after_init;
> >  pgd_t *pgd_alloc(struct mm_struct *mm)
> >  {
> >  	if (PGD_SIZE == PAGE_SIZE)
> > -		return (pgd_t *)__get_free_page(PGALLOC_GFP);
> > +		return (pgd_t *)__get_free_page(GFP_PGTABLE_USER);
> >  	else
> > -		return kmem_cache_alloc(pgd_cache, PGALLOC_GFP);
> > +		return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
> >  }
> 
> In efi_virtmap_init() we use pgd_alloc() to allocate a pgd for EFI
> runtime services, which we map with a special kernel page table.
> 
> I'm not sure if accounting that is problematic, as it's allocated in a
> kernel thread off the back of an early_initcall.

The accounting bypasses kernel threads so there should be no problem.
 
> Just to check, Is that sound, or do we need a pgd_alloc_kernel()?
> 
> Thanks,
> Mark.
> 

-- 
Sincerely yours,
Mike.


^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 12/15] powerpc/nohash/64: switch to generic version of pte allocation
  2019-05-02 16:56   ` Christophe Leroy
@ 2019-05-05  6:23     ` Mike Rapoport
  0 siblings, 0 replies; 29+ messages in thread
From: Mike Rapoport @ 2019-05-05  6:23 UTC (permalink / raw)
  To: Christophe Leroy
  Cc: Andrew Morton, Michal Hocko, Catalin Marinas, Palmer Dabbelt,
	linux-mips, Guo Ren, linux-hexagon, linux-riscv, linux-arch,
	Helge Deller, x86, Russell King, Matthew Wilcox,
	Geert Uytterhoeven, Matt Turner, Sam Creasey, Arnd Bergmann,
	linux-um, Richard Weinberger, linux-m68k, Greentime Hu,
	nios2-dev, Guan Xuetao, linux-arm-kernel, linux-parisc,
	linux-kernel, Richard Kuo, Paul Burton, linux-alpha,
	Ley Foon Tan, linuxppc-dev

On Thu, May 02, 2019 at 06:56:07PM +0200, Christophe Leroy wrote:
> 
> 
> Le 02/05/2019 à 17:28, Mike Rapoport a écrit :
> >The 64-bit book-E powerpc implements pte_alloc_one(),
> >pte_alloc_one_kernel(), pte_free_kernel() and pte_free() the same way as
> >the generic version.
> 
> Will soon be converted to the same as the 3 other PPC subarches, see
> https://patchwork.ozlabs.org/patch/1091590/
 
Thanks for the heads up. I'll drop this from the next re-spin.

> Christophe
> 
> >
> >Switch it to the generic version that does exactly the same thing.
> >
> >Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> >---
> >  arch/powerpc/include/asm/nohash/64/pgalloc.h | 35 ++--------------------------
> >  1 file changed, 2 insertions(+), 33 deletions(-)
> >
> >diff --git a/arch/powerpc/include/asm/nohash/64/pgalloc.h b/arch/powerpc/include/asm/nohash/64/pgalloc.h
> >index 66d086f..bfb53a0 100644
> >--- a/arch/powerpc/include/asm/nohash/64/pgalloc.h
> >+++ b/arch/powerpc/include/asm/nohash/64/pgalloc.h
> >@@ -11,6 +11,8 @@
> >  #include <linux/cpumask.h>
> >  #include <linux/percpu.h>
> >+#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> >+
> >  struct vmemmap_backing {
> >  	struct vmemmap_backing *list;
> >  	unsigned long phys;
> >@@ -92,39 +94,6 @@ static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
> >  	kmem_cache_free(PGT_CACHE(PMD_CACHE_INDEX), pmd);
> >  }
> >-
> >-static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
> >-{
> >-	return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
> >-}
> >-
> >-static inline pgtable_t pte_alloc_one(struct mm_struct *mm)
> >-{
> >-	struct page *page;
> >-	pte_t *pte;
> >-
> >-	pte = (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO | __GFP_ACCOUNT);
> >-	if (!pte)
> >-		return NULL;
> >-	page = virt_to_page(pte);
> >-	if (!pgtable_page_ctor(page)) {
> >-		__free_page(page);
> >-		return NULL;
> >-	}
> >-	return page;
> >-}
> >-
> >-static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> >-{
> >-	free_page((unsigned long)pte);
> >-}
> >-
> >-static inline void pte_free(struct mm_struct *mm, pgtable_t ptepage)
> >-{
> >-	pgtable_page_dtor(ptepage);
> >-	__free_page(ptepage);
> >-}
> >-
> >  static inline void pgtable_free(void *table, int shift)
> >  {
> >  	if (!shift) {
> >
> 

-- 
Sincerely yours,
Mike.


^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 13/15] riscv: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 13/15] riscv: " Mike Rapoport
@ 2019-05-06 18:25   ` Palmer Dabbelt
  0 siblings, 0 replies; 29+ messages in thread
From: Palmer Dabbelt @ 2019-05-06 18:25 UTC (permalink / raw)
  To: rppt
  Cc: akpm, Arnd Bergmann, catalin.marinas, geert, green.hu, gxt,
	guoren, deller, lftan, willy, mattst88, mpe, mhocko, paul.burton,
	rkuo, richard, linux, sammy, x86, linux-alpha, linux-arch,
	linux-arm-kernel, linux-hexagon, linux-kernel, linux-m68k,
	linux-mips, linux-parisc, linuxppc-dev, linux-riscv, linux-um,
	nios2-dev, rppt

On Thu, 02 May 2019 08:28:40 PDT (-0700), rppt@linux.ibm.com wrote:
> The only difference between the generic and RISC-V implementation of PTE
> allocation is the usage of __GFP_RETRY_MAYFAIL for both kernel and user
> PTEs and the absence of __GFP_ACCOUNT for the user PTEs.
>
> The conversion to the generic version removes the __GFP_RETRY_MAYFAIL and
> ensures that GFP_ACCOUNT is used for the user PTE allocations.

Reviewed-by: Palmer Dabbelt <palmer@sifive.com>

I'm assuming this is going in along with the rest of the patches, so I'm not
going to add it to my tree.

>
> The pte_free() and pte_free_kernel() versions are identical to the generic
> ones and can be simply dropped.
>
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>  arch/riscv/include/asm/pgalloc.h | 29 ++---------------------------
>  1 file changed, 2 insertions(+), 27 deletions(-)
>
> diff --git a/arch/riscv/include/asm/pgalloc.h b/arch/riscv/include/asm/pgalloc.h
> index 94043cf..48f28bb 100644
> --- a/arch/riscv/include/asm/pgalloc.h
> +++ b/arch/riscv/include/asm/pgalloc.h
> @@ -18,6 +18,8 @@
>  #include <linux/mm.h>
>  #include <asm/tlb.h>
>
> +#include <asm-generic/pgalloc.h>	/* for pte_{alloc,free}_one */
> +
>  static inline void pmd_populate_kernel(struct mm_struct *mm,
>  	pmd_t *pmd, pte_t *pte)
>  {
> @@ -82,33 +84,6 @@ static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
>
>  #endif /* __PAGETABLE_PMD_FOLDED */
>
> -static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm)
> -{
> -	return (pte_t *)__get_free_page(
> -		GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_ZERO);
> -}
> -
> -static inline struct page *pte_alloc_one(struct mm_struct *mm)
> -{
> -	struct page *pte;
> -
> -	pte = alloc_page(GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_ZERO);
> -	if (likely(pte != NULL))
> -		pgtable_page_ctor(pte);
> -	return pte;
> -}
> -
> -static inline void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
> -{
> -	free_page((unsigned long)pte);
> -}
> -
> -static inline void pte_free(struct mm_struct *mm, pgtable_t pte)
> -{
> -	pgtable_page_dtor(pte);
> -	__free_page(pte);
> -}
> -
>  #define __pte_free_tlb(tlb, pte, buf)   \
>  do {                                    \
>  	pgtable_page_dtor(pte);         \

^ permalink raw reply	[flat|nested] 29+ messages in thread

* Re: [PATCH 09/15] nds32: switch to generic version of pte allocation
  2019-05-02 15:28 ` [PATCH 09/15] nds32: " Mike Rapoport
@ 2019-05-07  6:49   ` Greentime Hu
  0 siblings, 0 replies; 29+ messages in thread
From: Greentime Hu @ 2019-05-07  6:49 UTC (permalink / raw)
  To: Mike Rapoport
  Cc: Andrew Morton, Arnd Bergmann, Catalin Marinas,
	Geert Uytterhoeven, Guan Xuetao, Guo Ren, Helge Deller,
	Ley Foon Tan, Matthew Wilcox, Matt Turner, Michael Ellerman,
	Michal Hocko, Palmer Dabbelt, Paul Burton, Richard Kuo,
	Richard Weinberger, Russell King, Sam Creasey, x86, linux-alpha,
	linux-arch, linux-arm-kernel, linux-hexagon,
	Linux Kernel Mailing List, linux-m68k, linux-mips, linux-parisc,
	linuxppc-dev, linux-riscv, linux-um, nios2-dev

Hi Mike,

Mike Rapoport <rppt@linux.ibm.com> 於 2019年5月2日 週四 下午11:30寫道:
>
> The nds32 implementation of pte_alloc_one_kernel() differs from the generic
> in the use of __GFP_RETRY_MAYFAIL flag, which is removed after the
> conversion.
>
> The nds32 version of pte_alloc_one() missed the call to pgtable_page_ctor()
> and also used __GFP_RETRY_MAYFAIL. Switching it to use generic
> __pte_alloc_one() for the PTE page allocation ensures that page table
> constructor is run and the user page tables are allocated with
> __GFP_ACCOUNT.
>
> The conversion to the generic version of pte_free_kernel() removes the NULL
> check for pte.
>
> The pte_free() version on nds32 is identical to the generic one and can be
> simply dropped.
>
> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
> ---
>  arch/nds32/include/asm/pgalloc.h | 31 ++++---------------------------
>  1 file changed, 4 insertions(+), 27 deletions(-)

Thanks for your patch.
I'm assuming this is going in along with the rest of the patches, so I'm not
going to add it to my tree.

Acked-by: Greentime Hu <greentime@andestech.com>

^ permalink raw reply	[flat|nested] 29+ messages in thread

end of thread, other threads:[~2019-05-07  6:49 UTC | newest]

Thread overview: 29+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-05-02 15:28 [PATCH 00/15] introduce generic pte_{alloc,free}_one[_kernel] Mike Rapoport
2019-05-02 15:28 ` [PATCH 01/15] asm-generic, x86: " Mike Rapoport
2019-05-02 19:03   ` Paul Burton
2019-05-05  6:15     ` Mike Rapoport
2019-05-02 15:28 ` [PATCH 02/15] alpha: switch to generic version of pte allocation Mike Rapoport
2019-05-02 15:28 ` [PATCH 03/15] arm: " Mike Rapoport
2019-05-02 15:28 ` [PATCH 04/15] arm64: " Mike Rapoport
2019-05-03 10:05   ` Mark Rutland
2019-05-05  6:19     ` Mike Rapoport
2019-05-02 15:28 ` [PATCH 05/15] csky: " Mike Rapoport
2019-05-03 16:03   ` Guo Ren
2019-05-03 16:18     ` Guo Ren
2019-05-02 15:28 ` [PATCH 06/15] hexagon: " Mike Rapoport
2019-05-02 15:28 ` [PATCH 07/15] m68k: sun3: " Mike Rapoport
2019-05-02 15:28 ` [PATCH 08/15] mips: " Mike Rapoport
2019-05-02 19:09   ` Paul Burton
2019-05-05  6:17     ` Mike Rapoport
2019-05-02 15:28 ` [PATCH 09/15] nds32: " Mike Rapoport
2019-05-07  6:49   ` Greentime Hu
2019-05-02 15:28 ` [PATCH 10/15] nios2: " Mike Rapoport
2019-05-02 15:28 ` [PATCH 11/15] parisc: " Mike Rapoport
2019-05-02 15:28 ` [PATCH 12/15] powerpc/nohash/64: " Mike Rapoport
2019-05-02 16:56   ` Christophe Leroy
2019-05-05  6:23     ` Mike Rapoport
2019-05-02 15:28 ` [PATCH 13/15] riscv: " Mike Rapoport
2019-05-06 18:25   ` Palmer Dabbelt
2019-05-02 15:28 ` [PATCH 14/15] um: " Mike Rapoport
2019-05-03 13:28   ` Anton Ivanov
2019-05-02 15:28 ` [PATCH 15/15] unicore32: " Mike Rapoport

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).