thp: introduce deferred_split_huge_page()

Currently we don't split huge page on partial unmap.  It's not an ideal
situation.  It can lead to memory overhead.

Furtunately, we can detect partial unmap on page_remove_rmap().  But we
cannot call split_huge_page() from there due to locking context.

It's also counterproductive to do directly from munmap() codepath: in
many cases we will hit this from exit(2) and splitting the huge page
just to free it up in small pages is not what we really want.

The patch introduce deferred_split_huge_page() which put the huge page
into queue for splitting.  The splitting itself will happen when we get
memory pressure via shrinker interface.  The page will be dropped from
list on freeing through compound page destructor.

Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Tested-by: Sasha Levin <sasha.levin@oracle.com>
Tested-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Jerome Marchand <jmarchan@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Cc: Steve Capper <steve.capper@linaro.org>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Christoph Lameter <cl@linux.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 20 insertions, 7 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 3221091da513..25409714160e 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -222,13 +222,15 @@ static char * const zone_names[MAX_NR_ZONES] = {
 #endif
 };
 
-static void free_compound_page(struct page *page);
 compound_page_dtor * const compound_page_dtors[] = {
         NULL,
         free_compound_page,
 #ifdef CONFIG_HUGETLB_PAGE
         free_huge_page,
 #endif
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+        free_transhuge_page,
+#endif
 };
 
 int min_free_kbytes = 1024;
@@ -450,7 +452,7 @@ out:
  * This usage means that zero-order pages may not be compound.
  */
 
-static void free_compound_page(struct page *page)
+void free_compound_page(struct page *page)
 {
         __free_pages_ok(page, compound_order(page));
 }
@@ -858,15 +860,26 @@ static int free_tail_pages_check(struct page *head_page, struct page *page)
                 ret = 0;
                 goto out;
         }
-        /* mapping in first tail page is used for compound_mapcount() */
-        if (page - head_page == 1) {
+        switch (page - head_page) {
+        case 1:
+                /* the first tail page: ->mapping is compound_mapcount() */
                 if (unlikely(compound_mapcount(page))) {
                         bad_page(page, "nonzero compound_mapcount", 0);
                         goto out;
                 }
-        } else if (page->mapping != TAIL_MAPPING) {
-                bad_page(page, "corrupted mapping in tail page", 0);
-                goto out;
+                break;
+        case 2:
+                /*
+                 * the second tail page: ->mapping is
+                 * page_deferred_list().next -- ignore value.
+                 */
+                break;
+        default:
+                if (page->mapping != TAIL_MAPPING) {
+                        bad_page(page, "corrupted mapping in tail page", 0);
+                        goto out;
+                }
+                break;
         }
         if (unlikely(!PageTail(page))) {
                 bad_page(page, "PageTail not set", 0);