Commit 7ed2c31d authored Mar 05, 2019 by Anshuman Khandual Committed by Linus Torvalds Mar 05, 2019

mm/hugetlb: distinguish between migratability and movability

Patch series "arm64/mm: Enable HugeTLB migration", v4.

This patch series enables HugeTLB migration support for all supported
huge page sizes at all levels including contiguous bit implementation.
Following HugeTLB migration support matrix has been enabled with this
patch series.  All permutations have been tested except for the 16GB.

           CONT PTE    PMD    CONT PMD    PUD
           --------    ---    --------    ---
  4K:         64K     2M         32M     1G
  16K:         2M    32M          1G
  64K:         2M   512M         16G

First the series adds migration support for PUD based huge pages.  It
then adds a platform specific hook to query an architecture if a given
huge page size is supported for migration while also providing a default
fallback option preserving the existing semantics which just checks for
(PMD|PUD|PGDIR)_SHIFT macros.  The last two patches enables HugeTLB
migration on arm64 and subscribe to this new platform specific hook by
defining an override.

The second patch differentiates between movability and migratability
aspects of huge pages and implements hugepage_movable_supported() which
can then be used during allocation to decide whether to place the huge
page in movable zone or not.

This patch (of 5):

During huge page allocation it's migratability is checked to determine
if it should be placed under movable zones with GFP_HIGHUSER_MOVABLE.
But the movability aspect of the huge page could depend on other factors
than just migratability.  Movability in itself is a distinct property
which should not be tied with migratability alone.

This differentiates these two and implements an enhanced movability check
which also considers huge page size to determine if it is feasible to be
placed under a movable zone.  At present it just checks for gigantic pages
but going forward it can incorporate other enhanced checks.

Link: http://lkml.kernel.org/r/1545121450-1663-2-git-send-email-anshuman.khandual@arm.com


Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com>
Reviewed-by: Steve Capper <steve.capper@arm.com>
Reviewed-by: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Suggested-by: Michal Hocko <mhocko@kernel.org>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

parent 6b7e5cad

include/linux/hugetlb.h

+30 −0

Original line number	Diff line number	Diff line
		@@ -506,6 +506,31 @@ static inline bool hugepage_migration_supported(struct hstate *h)
		#endif
		}

		/*
		* Movability check is different as compared to migration check.
		* It determines whether or not a huge page should be placed on
		* movable zone or not. Movability of any huge page should be
		* required only if huge page size is supported for migration.
		* There wont be any reason for the huge page to be movable if
		* it is not migratable to start with. Also the size of the huge
		* page should be large enough to be placed under a movable zone
		* and still feasible enough to be migratable. Just the presence
		* in movable zone does not make the migration feasible.
		*
		* So even though large huge page sizes like the gigantic ones
		* are migratable they should not be movable because its not
		* feasible to migrate them from movable zone.
		*/
		static inline bool hugepage_movable_supported(struct hstate *h)
		{
		if (!hugepage_migration_supported(h))
		return false;

		if (hstate_is_gigantic(h))
		return false;
		return true;
		}

		static inline spinlock_t huge_pte_lockptr(struct hstate h,
		struct mm_struct mm, pte_t pte)
		{
		@@ -602,6 +627,11 @@ static inline bool hugepage_migration_supported(struct hstate *h)
		return false;
		}

		static inline bool hugepage_movable_supported(struct hstate *h)
		{
		return false;
		}

		static inline spinlock_t huge_pte_lockptr(struct hstate h,
		struct mm_struct mm, pte_t pte)
		{

mm/hugetlb.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -920,7 +920,7 @@ retry_cpuset:
		/* Movability of hugepages depends on migration support. */
		static inline gfp_t htlb_alloc_mask(struct hstate *h)
		{
		if (hugepage_migration_supported(h))
		if (hugepage_movable_supported(h))
		return GFP_HIGHUSER_MOVABLE;
		else
		return GFP_HIGHUSER;

mm/migrate.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -1287,7 +1287,7 @@ static int unmap_and_move_huge_page(new_page_t get_new_page,
		struct anon_vma *anon_vma = NULL;

		/*
		* Movability of hugepages depends on architectures and hugepage size.
		* Migratability of hugepages depends on architectures and their size.
		* This check is necessary because some callers of hugepage migration
		* like soft offline and memory hotremove don't walk through page
		* tables or check whether the hugepage is pmd-based or not before

Admin message