| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <66a3f340-ff44-efad-48ad-a95554938a29@linux.vnet.ibm.com>
Date: Tue, 17 Oct 2017 13:38:07 +0530
From: Anshuman Khandual <khandual@...ux.vnet.ibm.com>
To: changbin.du@...el.com, akpm@...ux-foundation.org, corbet@....net,
hughd@...gle.com
Cc: linux-doc@...r.kernel.org, linux-kernel@...r.kernel.org,
linux-mm@...ck.org
Subject: Re: [PATCH 1/2] mm, thp: introduce dedicated transparent huge page
allocation interfaces
On 10/16/2017 02:49 PM, changbin.du@...el.com wrote:
> From: Changbin Du <changbin.du@...el.com>
>
> This patch introduced 4 new interfaces to allocate a prepared
> transparent huge page.
> - alloc_transhuge_page_vma
> - alloc_transhuge_page_nodemask
> - alloc_transhuge_page_node
> - alloc_transhuge_page
>
If we are trying to match HugeTLB helpers, then it should have
format something like alloc_transhugepage_xxx instead of
alloc_transhuge_page_XXX. But I think its okay.
> The aim is to remove duplicated code and simplify transparent
> huge page allocation. These are similar to alloc_hugepage_xxx
> which are for hugetlbfs pages. This patch does below changes:
> - define alloc_transhuge_page_xxx interfaces
> - apply them to all existing code
> - declare prep_transhuge_page as static since no others use it
> - remove alloc_hugepage_vma definition since it no longer has users
>
> Signed-off-by: Changbin Du <changbin.du@...el.com>
> ---
> include/linux/gfp.h | 4 ----
> include/linux/huge_mm.h | 13 ++++++++++++-
> include/linux/migrate.h | 14 +++++---------
> mm/huge_memory.c | 50 ++++++++++++++++++++++++++++++++++++++++++-------
> mm/khugepaged.c | 11 ++---------
> mm/mempolicy.c | 10 +++-------
> mm/migrate.c | 12 ++++--------
> mm/shmem.c | 6 ++----
> 8 files changed, 71 insertions(+), 49 deletions(-)
>
> diff --git a/include/linux/gfp.h b/include/linux/gfp.h
> index f780718..855c72e 100644
> --- a/include/linux/gfp.h
> +++ b/include/linux/gfp.h
> @@ -507,15 +507,11 @@ alloc_pages(gfp_t gfp_mask, unsigned int order)
> extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
> struct vm_area_struct *vma, unsigned long addr,
> int node, bool hugepage);
> -#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
> - alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
> #else
> #define alloc_pages(gfp_mask, order) \
> alloc_pages_node(numa_node_id(), gfp_mask, order)
> #define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\
> alloc_pages(gfp_mask, order)
> -#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
> - alloc_pages(gfp_mask, order)
> #endif
> #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
> #define alloc_page_vma(gfp_mask, vma, addr) \
> diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
> index 14bc21c..1dd2c33 100644
> --- a/include/linux/huge_mm.h
> +++ b/include/linux/huge_mm.h
> @@ -130,9 +130,20 @@ extern unsigned long thp_get_unmapped_area(struct file *filp,
> unsigned long addr, unsigned long len, unsigned long pgoff,
> unsigned long flags);
>
> -extern void prep_transhuge_page(struct page *page);
> extern void free_transhuge_page(struct page *page);
>
> +struct page *alloc_transhuge_page_vma(gfp_t gfp_mask,
> + struct vm_area_struct *vma, unsigned long addr);
> +struct page *alloc_transhuge_page_nodemask(gfp_t gfp_mask,
> + int preferred_nid, nodemask_t *nmask);
Would not they require 'extern' here ?
> +
> +static inline struct page *alloc_transhuge_page_node(int nid, gfp_t gfp_mask)
> +{
> + return alloc_transhuge_page_nodemask(gfp_mask, nid, NULL);
> +}
> +
> +struct page *alloc_transhuge_page(gfp_t gfp_mask);
> +
> bool can_split_huge_page(struct page *page, int *pextra_pins);
> int split_huge_page_to_list(struct page *page, struct list_head *list);
> static inline int split_huge_page(struct page *page)
> diff --git a/include/linux/migrate.h b/include/linux/migrate.h
> index 643c7ae..70a00f3 100644
> --- a/include/linux/migrate.h
> +++ b/include/linux/migrate.h
> @@ -42,19 +42,15 @@ static inline struct page *new_page_nodemask(struct page *page,
> return alloc_huge_page_nodemask(page_hstate(compound_head(page)),
> preferred_nid, nodemask);
>
> - if (thp_migration_supported() && PageTransHuge(page)) {
> - order = HPAGE_PMD_ORDER;
> - gfp_mask |= GFP_TRANSHUGE;
> - }
> -
> if (PageHighMem(page) || (zone_idx(page_zone(page)) == ZONE_MOVABLE))
> gfp_mask |= __GFP_HIGHMEM;
>
> - new_page = __alloc_pages_nodemask(gfp_mask, order,
> + if (thp_migration_supported() && PageTransHuge(page))
> + return alloc_transhuge_page_nodemask(gfp_mask | GFP_TRANSHUGE,
> + preferred_nid, nodemask);
> + else
> + return __alloc_pages_nodemask(gfp_mask, order,
> preferred_nid, nodemask);
> -
> - if (new_page && PageTransHuge(page))
> - prep_transhuge_page(new_page);
This makes sense, calling prep_transhuge_page() inside the
function alloc_transhuge_page_nodemask() is better I guess.
>
> return new_page;
> }
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index 269b5df..e267488 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -490,7 +490,7 @@ static inline struct list_head *page_deferred_list(struct page *page)
> return (struct list_head *)&page[2].mapping;
> }
>
> -void prep_transhuge_page(struct page *page)
> +static void prep_transhuge_page(struct page *page)
Right. It wont be used outside huge page allocation context and
you have already mentioned about it.
> {
> /*
> * we use page->mapping and page->indexlru in second tail page
> @@ -501,6 +501,45 @@ void prep_transhuge_page(struct page *page)
> set_compound_page_dtor(page, TRANSHUGE_PAGE_DTOR);
> }
>
> +struct page *alloc_transhuge_page_vma(gfp_t gfp_mask,
> + struct vm_area_struct *vma, unsigned long addr)
> +{
> + struct page *page;
> +
> + page = alloc_pages_vma(gfp_mask | __GFP_COMP, HPAGE_PMD_ORDER,
> + vma, addr, numa_node_id(), true);
> + if (unlikely(!page))
> + return NULL;
> + prep_transhuge_page(page);
> + return page;
> +}
__GFP_COMP and HPAGE_PMD_ORDER are the minimum flags which will be used
for huge page allocation and preparation. Any thing else depending upon
the context will be passed by the caller. Makes sense.
> +
> +struct page *alloc_transhuge_page_nodemask(gfp_t gfp_mask,
> + int preferred_nid, nodemask_t *nmask)
> +{
> + struct page *page;
> +
> + page = __alloc_pages_nodemask(gfp_mask | __GFP_COMP, HPAGE_PMD_ORDER,
> + preferred_nid, nmask);
> + if (unlikely(!page))
> + return NULL;
> + prep_transhuge_page(page);
> + return page;
> +}
> +
Same here.
> +struct page *alloc_transhuge_page(gfp_t gfp_mask)
> +{
> + struct page *page;
> +
> + VM_BUG_ON(!(gfp_mask & __GFP_COMP));
You expect the caller to provide __GFP_COMP, why ? You are
anyways providing it later.
Powered by blists - more mailing lists