mm/kvm/vfio/ppc64: Migrate compound pages out of CMA region
Subsystems (6)
v8 cover mm/kvm/vfio/ppc64: Migrate compound pages out of CMA region
ppc64 use CMA area for the allocation of guest page table (hash page table). We won't be able to start guest if we fail to allocate hash page table. We have observed hash table allocation failure because we failed to migrate pages out of CMA region because they were pinned. This happen when we are using VFIO. VFIO on ppc64 pins the entire guest RAM. If the guest RAM pages get allocated out of CMA region, we won't be able to migrate those pages. The pages are also pinned for the lifetime of the guest.
Currently we support migration of non-compound pages. With THP and with the addition of
hugetlb migration we can end up allocating compound pages from CMA region. This
patch series add support for migrating compound pages.
Changes from V7:
* update commit descrption for patch 3
* Address review feedback.
* Move PF_MEMALLOC_NOCMA to a different value.
Changes from V6:
* use get_user_pages_longterm instead of get_user_pages_cma_migrate()
Changes from V5:
* Add PF_MEMALLOC_NOCMA
* remote __GFP_THISNODE when allocating target page for migration
Changes from V4:
* use __GFP_NOWARN when allocating pages to avoid page allocation failure warnings.
Changes from V3:
* Move the hugetlb check before transhuge check
* Use compound head page when isolating hugetlb page
*** BLURB HERE ***
Aneesh Kumar K.V (4):
mm/cma: Add PF flag to force non cma alloc
mm: Update get_user_pages_longterm to migrate pages allocated from CMA
region
powerpc/mm/iommu: Allow migration of cma allocated pages during
mm_iommu_do_alloc
powerpc/mm/iommu: Allow large IOMMU page size only for hugetlb backing
arch/powerpc/mm/mmu_context_iommu.c | 145 ++++++-------------- include/linux/hugetlb.h | 2 + include/linux/mm.h | 3 +- include/linux/sched.h | 1 + include/linux/sched/mm.h | 48 +++++-- mm/gup.c | 200 ++++++++++++++++++++++++---- mm/hugetlb.c | 4 +- 7 files changed, 266 insertions(+), 137 deletions(-)
Signature · 1 line
2.20.1
PATCH v8 1/4 mm/cma: Add PF flag to force non cma alloc
This patch adds PF_MEMALLOC_NOCMA which make sure any allocation in that context is marked non-movable and hence cannot be satisfied by CMA region.
This is useful with get_user_pages_longterm where we want to take a page pin by migrating pages from CMA region. Marking the section PF_MEMALLOC_NOCMA ensures that we avoid unnecessary page migration later.
--- include/linux/sched.h | 1 + include/linux/sched/mm.h | 48 +++++++++++++++++++++++++++++++++------- 2 files changed, 41 insertions(+), 8 deletions(-)
include/linux/sched.h +1 -0
@@ -1403,6 +1403,7 @@ extern struct pid *cad_pid;#define PF_UMH 0x02000000/* I'm an Usermodehelper process */ #define PF_NO_SETAFFINITY 0x04000000/* Userland is not allowed to meddle with cpus_allowed */ #define PF_MCE_EARLY 0x08000000/* Early kill for mce process policy */ +#define PF_MEMALLOC_NOCMA 0x10000000/* All allocation request will have _GFP_MOVABLE cleared */ #define PF_MUTEX_TESTER 0x20000000/* Thread belongs to the rt mutex tester */ #define PF_FREEZER_SKIP 0x40000000/* Freezer should not count it as freezable */ #define PF_SUSPEND_TASK 0x80000000/* This thread called freeze_processes() and should not be frozen */
include/linux/sched/mm.h +40 -8
63 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v8 2/4 mm: Update get_user_pages_longterm to migrate pages allocated from CMA region
In reply to Aneesh Kumar K.VThis patch updates get_user_pages_longterm to migrate pages allocated out of CMA region. This makes sure that we don't keep non-movable pages (due to page reference count) in the CMA area.
This will be used by ppc64 in a later patch to avoid pinning pages in the CMA region. ppc64 uses CMA region for allocation of the hardware page table (hash page table) and not able to migrate pages out of CMA region results in page table allocation failures.
One case where we hit this easy is when a guest using a VFIO passthrough device. VFIO locks all the guest's memory and if the guest memory is backed by CMA region, it becomes unmovable resulting in fragmenting the CMA and possibly preventing other guests from allocation a large enough hash page table.
NOTE: We allocate the new page without using __GFP_THISNODE
--- include/linux/hugetlb.h | 2 + include/linux/mm.h | 3 +- mm/gup.c | 200 +++++++++++++++++++++++++++++++++++----- mm/hugetlb.c | 4 +- 4 files changed, 182 insertions(+), 27 deletions(-)
include/linux/hugetlb.h +2 -0
@@ -371,6 +371,8 @@ struct page *alloc_huge_page_nodemask(struct hstate *h, int preferred_nid, nodemask_t *nmask);struct page *alloc_huge_page_vma (struct hstate *h,struct vm_area_struct *vma,unsigned long address); +struct page *alloc_migrate_huge_page (struct hstate *h,gfp_t gfp_mask, +int nid,nodemask_t *nmask);int huge_add_to_page_cache (struct page *page,struct address_space *mapping,pgoff_t idx);
include/linux/mm.h +2 -1
@@ -1536,7 +1536,8 @@ long get_user_pages_locked(unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages, int *locked);long get_user_pages_unlocked (unsigned long start,unsigned long nr_pages,struct page **pages,unsigned int gup_flags); -#ifdef CONFIG_FS_DAX + +#if defined(CONFIG_FS_DAX ) || defined(CONFIG_CMA )long get_user_pages_longterm (unsigned long start,unsigned long nr_pages,unsigned int gup_flags,struct page **pages,struct vm_area_struct **vmas);
mm/gup.c +176 -24
231 lines not on this page · raw message
mm/hugetlb.c +2 -2
@@ -1586,8 +1586,8 @@ static struct page *alloc_surplus_huge_page(struct hstate *h, gfp_t gfp_mask,return page; } -static struct page *alloc_migrate_huge_page (struct hstate *h,gfp_t gfp_mask, -int nid,nodemask_t *nmask) +struct page *alloc_migrate_huge_page (struct hstate *h,gfp_t gfp_mask, +int nid,nodemask_t *nmask) {struct page *page;
Signature · 1 line
2.20.1
PATCH v8 4/4 powerpc/mm/iommu: Allow large IOMMU page size only for hugetlb backing
In reply to Aneesh Kumar K.VTHP pages can get split during different code paths. An incremented reference count does imply we will not split the compound page. But the pmd entry can be converted to level 4 pte entries. Keep the code simpler by allowing large IOMMU page size only if the guest ram is backed by hugetlb pages.
--- arch/powerpc/mm/mmu_context_iommu.c | 24 +++++++----------------- 1 file changed, 7 insertions(+), 17 deletions(-)
arch/powerpc/mm/mmu_context_iommu.c +7 -17
@@ -98,8 +98,6 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,struct mm_iommu_table_group_mem_t *mem;long i, ret, locked_entries =0 ;unsigned int pageshift; -unsigned long flags; -unsigned long cur_ua;mutex_lock (&mem_list_mutex);
@@ -167,22 +165,14 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,for (i =0 ; i < entries; ++i) {struct page *page = mem->hpages[i]; - cur_ua = ua + (i <<PAGE_SHIFT ); -if (mem->pageshift >PAGE_SHIFT &&PageCompound (page)) { -pte_t *pte; +/* +* Allow to use larger than 64k IOMMU pages. Only do that +* if we are backed by hugetlb. +*/ +if ((mem->pageshift >PAGE_SHIFT ) &&PageHuge (page)) {struct page *head =compound_head (page); -unsigned int compshift =compound_order (head); -unsigned int pteshift; - -local_irq_save (flags);/* disables as well */ - pte =find_linux_pte (mm->pgd, cur_ua,NULL , &pteshift); - -/* Double check it is still the same pinned page */ -if (pte &&pte_page (*pte) == head && - pteshift == compshift +PAGE_SHIFT ) - pageshift = max_t(unsigned int, pteshift, -PAGE_SHIFT ); -local_irq_restore (flags); + + pageshift =compound_order (head) +PAGE_SHIFT ; } mem->pageshift =min (mem->pageshift, pageshift);/*
Signature · 1 line
2.20.1
PATCH v8 3/4 powerpc/mm/iommu: Allow migration of cma allocated pages during mm_iommu_do_alloc
In reply to Aneesh Kumar K.VThe current code doesn't do page migration if the page allocated is a compound page. With HugeTLB migration support, we can end up allocating hugetlb pages from CMA region. Also, THP pages can be allocated from CMA region. This patch updates the code to handle compound pages correctly. The patch also switches to a single get_user_pages with the right count, instead of doing one get_user_pages per page. That avoids reading page table multiple times. This is done by using get_user_pages_longterm, because that also takes care of DAX backed pages.
DAX pages lifetime is dictated by file system rules and as such, we need to make sure that we free these pages on operations like truncate and punch hole. If we have long term pin on these pages, which are mostly return to userspace with elevated page count, the entity holding the long term pin may not be aware of the fact that file got truncated and the file system blocks possibly got reused. That can result in corruption.
The patch also converts the hpas member of mm_iommu_table_group_mem_t to a union. We use the same storage location to store pointers to struct page. We cannot update all the code path use struct page *, because we access hpas in real mode and we can't do that struct page * to pfn conversion in real mode.
--- arch/powerpc/mm/mmu_context_iommu.c | 125 +++++++++------------------- 1 file changed, 38 insertions(+), 87 deletions(-)
arch/powerpc/mm/mmu_context_iommu.c +38 -87
@@ -21,6 +21,7 @@#include <linux/sizes.h> #include <asm/mmu_context.h> #include <asm/pte-walk.h> +#include <linux/mm_inline.h> static DEFINE_MUTEX (mem_list_mutex);
@@ -34,8 +35,18 @@ struct mm_iommu_table_group_mem_t {atomic64_t mapped;unsigned int pageshift;u64 ua;/* userspace address */ -u64 entries;/* number of entries in hpas[] */ -u64 *hpas;/* vmalloc'ed */ +u64 entries;/* number of entries in hpas/hpages[] */ +/* +* in mm_iommu_get we temporarily use this to store +* struct page address. +* +* We need to convert ua to hpa in real mode. Make it +* simpler by storing physical address. +*/ +union { +struct page **hpages;/* vmalloc'ed */ +phys_addr_t *hpas; + };#define MM_IOMMU_TABLE_INVALID_HPA ((uint64_t)-1)u64 dev_hpa;/* Device memory base address */ };
@@ -80,64 +91,15 @@ bool mm_iommu_preregistered(struct mm_struct *mm) }EXPORT_SYMBOL_GPL (mm_iommu_preregistered); -/* -* Taken from alloc_migrate_target with changes to remove CMA allocations -*/ -struct page *new_iommu_non_cma_page (struct page *page,unsigned long private) -{ -gfp_t gfp_mask =GFP_USER ; -struct page *new_page; - -if (PageCompound (page)) -return NULL ; - -if (PageHighMem (page)) - gfp_mask |= __GFP_HIGHMEM; - -/* -* We don't want the allocation to force an OOM if possibe -*/ - new_page =alloc_page (gfp_mask | __GFP_NORETRY | __GFP_NOWARN); -return new_page; -} - -static int mm_iommu_move_page_from_cma (struct page *page) -{ -int ret =0 ; -LIST_HEAD (cma_migrate_pages); - -/* Ignore huge pages for now */ -if (PageCompound (page)) -return -EBUSY ; - -lru_add_drain (); - ret =isolate_lru_page (page); -if (ret) -return ret; - -list_add (&page->lru, &cma_migrate_pages); -put_page (page);/* Drop the gup reference */ - - ret =migrate_pages (&cma_migrate_pages, new_iommu_non_cma_page, -NULL ,0 ,MIGRATE_SYNC ,MR_CONTIG_RANGE ); -if (ret) { -if (!list_empty (&cma_migrate_pages)) -putback_movable_pages (&cma_migrate_pages); - } - -return 0 ; -} -static long mm_iommu_do_alloc (struct mm_struct *mm,unsigned long ua, -unsigned long entries,unsigned long dev_hpa, -struct mm_iommu_table_group_mem_t **pmem) +unsigned long entries,unsigned long dev_hpa, +struct mm_iommu_table_group_mem_t **pmem) {struct mm_iommu_table_group_mem_t *mem; -long i, j, ret =0 , locked_entries =0 ; +long i, ret, locked_entries =0 ;unsigned int pageshift;unsigned long flags;unsigned long cur_ua; -struct page *page =NULL ;mutex_lock (&mem_list_mutex);
@@ -187,41 +149,25 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua, goto unlock_exit; } +down_read (&mm->mmap_sem); + ret =get_user_pages_longterm (ua, entries,FOLL_WRITE , mem->hpages,NULL ); +up_read (&mm->mmap_sem); +if (ret != entries) { +/* free the reference taken */ +for (i =0 ; i < ret; i++) +put_page (mem->hpages[i]); + +vfree (mem->hpas); +kfree (mem); + ret = -EFAULT ; + goto unlock_exit; + } + + pageshift =PAGE_SHIFT ;for (i =0 ; i < entries; ++i) { +struct page *page = mem->hpages[i]; + cur_ua = ua + (i <<PAGE_SHIFT ); -if (1 !=get_user_pages_fast (cur_ua, -1 /* pages */ ,1 /* iswrite */ , &page)) { - ret = -EFAULT ; -for (j =0 ; j < i; ++j) -put_page (pfn_to_page (mem->hpas[j] >> -PAGE_SHIFT )); -vfree (mem->hpas); -kfree (mem); - goto unlock_exit; - } -/* -* If we get a page from the CMA zone, since we are going to -* be pinning these entries, we might as well move them out -* of the CMA zone if possible. NOTE: faulting in + migration -* can be expensive. Batching can be considered later -*/ -if (is_migrate_cma_page (page)) { -if (mm_iommu_move_page_from_cma (page)) - goto populate; -if (1 !=get_user_pages_fast (cur_ua, -1 /* pages */ ,1 /* iswrite */ , - &page)) { - ret = -EFAULT ; -for (j =0 ; j < i; ++j) -put_page (pfn_to_page (mem->hpas[j] >> -PAGE_SHIFT )); -vfree (mem->hpas); -kfree (mem); - goto unlock_exit; - } - } -populate: - pageshift =PAGE_SHIFT ;if (mem->pageshift >PAGE_SHIFT &&PageCompound (page)) {pte_t *pte;struct page *head =compound_head (page);
@@ -239,10 +185,15 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, unsigned long ua,local_irq_restore (flags); } mem->pageshift =min (mem->pageshift, pageshift); +/* +* We don't need struct page reference any more, switch +* to physical address. +*/ mem->hpas[i] =page_to_pfn (page) <<PAGE_SHIFT ; } good_exit: + ret =0 ;atomic64_set (&mem->mapped,1 ); mem->used =1 ; mem->ua = ua;
Signature · 1 line
2.20.1
Re: [PATCH v8 1/4] mm/cma: Add PF flag to force non cma alloc
In reply to Aneesh Kumar K.VQuoted 10 lines · Aneesh Kumar K.V
This patch adds
PF_MEMALLOC_NOCMAwhich make sure any allocation in that context is marked non-movable and hence cannot be satisfied by CMA region.This is useful with
get_user_pages_longtermwhere we want to take a page pin by migrating pages from CMA region. Marking the sectionPF_MEMALLOC_NOCMAensures that we avoid unnecessary page migration later.Suggested-by Andrea Arcangeli <[email protected]>Reviewed-by Andrea Arcangeli <[email protected]>Signed-off-by Aneesh Kumar K.V <[email protected]>
+CC scheduler guys
Do we really take the last available PF flag just so that "we avoid unnecessary page migration later"?
If yes, that's a third PF_MEMALLOC flag, should we get separate variable for gfp context at this point?
Also I don't like the name PF_MEMALLOC_NOCMA, as it's unnecessarily tied to CMA. If anything it should be e.g. PF_MEMALLOC_NOMOVABLE.
Thanks.
Quoted 87 lines
--- include/linux/sched.h | 1 + include/linux/sched/mm.h | 48 +++++++++++++++++++++++++++++++++------- 2 files changed, 41 insertions(+), 8 deletions(-)include/linux/sched.h +1
-0@@ -1403,6 +1403,7 @@ extern struct pid *cad_pid;#define PF_UMH 0x02000000/* I'm an Usermodehelper process */ #define PF_NO_SETAFFINITY 0x04000000/* Userland is not allowed to meddle with cpus_allowed */ #define PF_MCE_EARLY 0x08000000/* Early kill for mce process policy */ +#define PF_MEMALLOC_NOCMA 0x10000000/* All allocation request will have _GFP_MOVABLE cleared */ #define PF_MUTEX_TESTER 0x20000000/* Thread belongs to the rt mutex tester */ #define PF_FREEZER_SKIP 0x40000000/* Freezer should not count it as freezable */ #define PF_SUSPEND_TASK 0x80000000/* This thread called freeze_processes() and should not be frozen */ include/linux/sched/mm.h +40
-8@@ -148,17 +148,25 @@ static inline bool in_vfork(struct task_struct *tsk)* Applies per-task gfp context to the given allocation flags. * PF_MEMALLOC_NOIO implies GFP_NOIO * PF_MEMALLOC_NOFS implies GFP_NOFS +* PF_MEMALLOC_NOCMA implies no allocation from CMA region. */ static inline gfp_t current_gfp_context (gfp_t flags) { -/* -* NOIO implies both NOIO and NOFS and it is a weaker context -* so always make sure it makes precedence -*/ -if (unlikely (current->flags &PF_MEMALLOC_NOIO )) - flags &= ~(__GFP_IO | __GFP_FS); -else if (unlikely (current->flags &PF_MEMALLOC_NOFS )) - flags &= ~__GFP_FS; +if (unlikely (current->flags & + (PF_MEMALLOC_NOIO |PF_MEMALLOC_NOFS |PF_MEMALLOC_NOCMA ))) { +/* +* NOIO implies both NOIO and NOFS and it is a weaker context +* so always make sure it makes precedence +*/ +if (current->flags &PF_MEMALLOC_NOIO ) + flags &= ~(__GFP_IO | __GFP_FS); +else if (current->flags &PF_MEMALLOC_NOFS ) + flags &= ~__GFP_FS; +#ifdef CONFIG_CMA +if (current->flags &PF_MEMALLOC_NOCMA ) + flags &= ~__GFP_MOVABLE; +#endif + }return flags; }@@ -248,6 +256,30 @@ static inline void memalloc_noreclaim_restore(unsigned int flags) current->flags = (current->flags & ~PF_MEMALLOC ) | flags; } +#ifdef CONFIG_CMA +static inline unsigned int memalloc_nocma_save (void ) +{ +unsigned int flags = current->flags &PF_MEMALLOC_NOCMA ; + + current->flags |=PF_MEMALLOC_NOCMA ; +return flags; +} + +static inline void memalloc_nocma_restore (unsigned int flags) +{ + current->flags = (current->flags & ~PF_MEMALLOC_NOCMA ) | flags; +} +#else +static inline unsigned int memalloc_nocma_save (void ) +{ +return 0 ; +} + +static inline void memalloc_nocma_restore (unsigned int flags) +{ +} +#endif +#ifdef CONFIG_MEMCG /** * memalloc_use_memcg - Starts the remote memcg charging scope.
Re: [PATCH v8 1/4] mm/cma: Add PF flag to force non cma alloc
Quoted 12 lines · Vlastimil Babka
Quoted 10 lines · Aneesh Kumar K.V
This patch adds
PF_MEMALLOC_NOCMAwhich make sure any allocation in that context is marked non-movable and hence cannot be satisfied by CMA region.This is useful with
get_user_pages_longtermwhere we want to take a page pin by migrating pages from CMA region. Marking the sectionPF_MEMALLOC_NOCMAensures that we avoid unnecessary page migration later.Suggested-by Andrea Arcangeli <[email protected]>Reviewed-by Andrea Arcangeli <[email protected]>Signed-off-by Aneesh Kumar K.V <[email protected]>
Quoted 6 lines
+CC scheduler guys
Do we really take the last available PF flag just so that "we avoid unnecessary page migration later"?
If yes, that's a thirdPF_MEMALLOCflag, should we get separate variable for gfp context at this point?
Yes, that sounds like a reasonable thing to do. Just note that xfs still uses current_{set,restore}* api to handle PF_MEMALLOC_NOFS so that would have to be moved over to the memalloc_nofs_{save,restore} API.
Signature · 1 line
Michal Hocko