From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A774AC2BB55 for ; Thu, 16 Apr 2020 16:00:54 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 6173F22244 for ; Thu, 16 Apr 2020 16:00:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6173F22244 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 13AD98E00CA; Thu, 16 Apr 2020 12:00:41 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 0EC348E00BC; Thu, 16 Apr 2020 12:00:41 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id F1C7A8E00CA; Thu, 16 Apr 2020 12:00:40 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0249.hostedemail.com [216.40.44.249]) by kanga.kvack.org (Postfix) with ESMTP id D5F3C8E00BC for ; Thu, 16 Apr 2020 12:00:40 -0400 (EDT) Received: from smtpin26.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with ESMTP id 904AE499615 for ; Thu, 16 Apr 2020 16:00:40 +0000 (UTC) X-FDA: 76714181040.26.force21_7a330ea3a7f13 X-HE-Tag: force21_7a330ea3a7f13 X-Filterd-Recvd-Size: 9194 Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by imf08.hostedemail.com (Postfix) with ESMTP for ; Thu, 16 Apr 2020 16:00:39 +0000 (UTC) IronPort-SDR: ukldaODi2nqWRqMv0477Dmp9uVQpBPnNJKpSj2JdhhfMIthqi9BVBYb/t5ZZcouseclM8v2Gmn PMqM7cxgbnHA== X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Apr 2020 09:00:38 -0700 IronPort-SDR: Iz+HxusaHoCu9M3fhROIO9pw+I+pOsZ3XAcfL3rUAROe30k3yaomTvbJLf8yoLd7hFLoLMSGvT wtd7ynBeWGIg== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.72,391,1580803200"; d="scan'208";a="364035072" Received: from black.fi.intel.com ([10.237.72.28]) by fmsmga001.fm.intel.com with ESMTP; 16 Apr 2020 09:00:35 -0700 Received: by black.fi.intel.com (Postfix, from userid 1000) id 8F00D76D; Thu, 16 Apr 2020 19:00:31 +0300 (EEST) From: "Kirill A. Shutemov" To: akpm@linux-foundation.org, Andrea Arcangeli Cc: Zi Yan , Yang Shi , Ralph Campbell , John Hubbard , William Kucharski , linux-mm@kvack.org, linux-kernel@vger.kernel.org, "Kirill A. Shutemov" Subject: [PATCHv4 6/8] khugepaged: Allow to collapse PTE-mapped compound pages Date: Thu, 16 Apr 2020 19:00:24 +0300 Message-Id: <20200416160026.16538-7-kirill.shutemov@linux.intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20200416160026.16538-1-kirill.shutemov@linux.intel.com> References: <20200416160026.16538-1-kirill.shutemov@linux.intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: We can collapse PTE-mapped compound pages. We only need to avoid handling them more than once: lock/unlock page only once if it's present in the PMD range multiple times as it handled on compound level. The same goes for LRU isolation and putback. Signed-off-by: Kirill A. Shutemov Reviewed-by: William Kucharski Reviewed-and-Tested-by: Zi Yan Acked-by: Yang Shi --- mm/khugepaged.c | 99 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 65 insertions(+), 34 deletions(-) diff --git a/mm/khugepaged.c b/mm/khugepaged.c index c3eb9d0d53f8..fb5bc5469e7f 100644 --- a/mm/khugepaged.c +++ b/mm/khugepaged.c @@ -512,17 +512,30 @@ void __khugepaged_exit(struct mm_struct *mm) =20 static void release_pte_page(struct page *page) { - dec_node_page_state(page, NR_ISOLATED_ANON + page_is_file_lru(page)); + mod_node_page_state(page_pgdat(page), + NR_ISOLATED_ANON + page_is_file_lru(page), + -compound_nr(page)); unlock_page(page); putback_lru_page(page); } =20 -static void release_pte_pages(pte_t *pte, pte_t *_pte) +static void release_pte_pages(pte_t *pte, pte_t *_pte, + struct list_head *compound_pagelist) { + struct page *page, *tmp; + while (--_pte >=3D pte) { pte_t pteval =3D *_pte; - if (!pte_none(pteval) && !is_zero_pfn(pte_pfn(pteval))) - release_pte_page(pte_page(pteval)); + + page =3D pte_page(pteval); + if (!pte_none(pteval) && !is_zero_pfn(pte_pfn(pteval)) && + !PageCompound(page)) + release_pte_page(page); + } + + list_for_each_entry_safe(page, tmp, compound_pagelist, lru) { + list_del(&page->lru); + release_pte_page(page); } } =20 @@ -546,7 +559,8 @@ static bool is_refcount_suitable(struct page *page) =20 static int __collapse_huge_page_isolate(struct vm_area_struct *vma, unsigned long address, - pte_t *pte) + pte_t *pte, + struct list_head *compound_pagelist) { struct page *page =3D NULL; pte_t *_pte; @@ -576,13 +590,21 @@ static int __collapse_huge_page_isolate(struct vm_a= rea_struct *vma, goto out; } =20 - /* TODO: teach khugepaged to collapse THP mapped with pte */ + VM_BUG_ON_PAGE(!PageAnon(page), page); + if (PageCompound(page)) { - result =3D SCAN_PAGE_COMPOUND; - goto out; - } + struct page *p; + page =3D compound_head(page); =20 - VM_BUG_ON_PAGE(!PageAnon(page), page); + /* + * Check if we have dealt with the compound page + * already + */ + list_for_each_entry(p, compound_pagelist, lru) { + if (page =3D=3D p) + goto next; + } + } =20 /* * We can do it before isolate_lru_page because the @@ -611,19 +633,15 @@ static int __collapse_huge_page_isolate(struct vm_a= rea_struct *vma, result =3D SCAN_PAGE_COUNT; goto out; } - if (pte_write(pteval)) { - writable =3D true; - } else { - if (PageSwapCache(page) && - !reuse_swap_page(page, NULL)) { - unlock_page(page); - result =3D SCAN_SWAP_CACHE_PAGE; - goto out; - } + if (!pte_write(pteval) && PageSwapCache(page) && + !reuse_swap_page(page, NULL)) { /* - * Page is not in the swap cache. It can be collapsed - * into a THP. + * Page is in the swap cache and cannot be re-used. + * It cannot be collapsed into a THP. */ + unlock_page(page); + result =3D SCAN_SWAP_CACHE_PAGE; + goto out; } =20 /* @@ -635,16 +653,23 @@ static int __collapse_huge_page_isolate(struct vm_a= rea_struct *vma, result =3D SCAN_DEL_PAGE_LRU; goto out; } - inc_node_page_state(page, - NR_ISOLATED_ANON + page_is_file_lru(page)); + mod_node_page_state(page_pgdat(page), + NR_ISOLATED_ANON + page_is_file_lru(page), + compound_nr(page)); VM_BUG_ON_PAGE(!PageLocked(page), page); VM_BUG_ON_PAGE(PageLRU(page), page); =20 + if (PageCompound(page)) + list_add_tail(&page->lru, compound_pagelist); +next: /* There should be enough young pte to collapse the page */ if (pte_young(pteval) || page_is_young(page) || PageReferenced(page) || mmu_notifier_test_young(vma->vm_mm, address)) referenced++; + + if (pte_write(pteval)) + writable =3D true; } if (likely(writable)) { if (likely(referenced)) { @@ -658,7 +683,7 @@ static int __collapse_huge_page_isolate(struct vm_are= a_struct *vma, } =20 out: - release_pte_pages(pte, _pte); + release_pte_pages(pte, _pte, compound_pagelist); trace_mm_collapse_huge_page_isolate(page, none_or_zero, referenced, writable, result); return 0; @@ -667,13 +692,14 @@ static int __collapse_huge_page_isolate(struct vm_a= rea_struct *vma, static void __collapse_huge_page_copy(pte_t *pte, struct page *page, struct vm_area_struct *vma, unsigned long address, - spinlock_t *ptl) + spinlock_t *ptl, + struct list_head *compound_pagelist) { + struct page *src_page, *tmp; pte_t *_pte; for (_pte =3D pte; _pte < pte + HPAGE_PMD_NR; _pte++, page++, address +=3D PAGE_SIZE) { pte_t pteval =3D *_pte; - struct page *src_page; =20 if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) { clear_user_highpage(page, address); @@ -693,7 +719,8 @@ static void __collapse_huge_page_copy(pte_t *pte, str= uct page *page, } else { src_page =3D pte_page(pteval); copy_user_highpage(page, src_page, address, vma); - release_pte_page(src_page); + if (!PageCompound(src_page)) + release_pte_page(src_page); /* * ptl mostly unnecessary, but preempt has to * be disabled to update the per-cpu stats @@ -710,6 +737,11 @@ static void __collapse_huge_page_copy(pte_t *pte, st= ruct page *page, free_page_and_swap_cache(src_page); } } + + list_for_each_entry_safe(src_page, tmp, compound_pagelist, lru) { + list_del(&src_page->lru); + release_pte_page(src_page); + } } =20 static void khugepaged_alloc_sleep(void) @@ -968,6 +1000,7 @@ static void collapse_huge_page(struct mm_struct *mm, struct page **hpage, int node, int referenced, int unmapped) { + LIST_HEAD(compound_pagelist); pmd_t *pmd, _pmd; pte_t *pte; pgtable_t pgtable; @@ -1068,7 +1101,8 @@ static void collapse_huge_page(struct mm_struct *mm= , mmu_notifier_invalidate_range_end(&range); =20 spin_lock(pte_ptl); - isolated =3D __collapse_huge_page_isolate(vma, address, pte); + isolated =3D __collapse_huge_page_isolate(vma, address, pte, + &compound_pagelist); spin_unlock(pte_ptl); =20 if (unlikely(!isolated)) { @@ -1093,7 +1127,8 @@ static void collapse_huge_page(struct mm_struct *mm= , */ anon_vma_unlock_write(vma->anon_vma); =20 - __collapse_huge_page_copy(pte, new_page, vma, address, pte_ptl); + __collapse_huge_page_copy(pte, new_page, vma, address, pte_ptl, + &compound_pagelist); pte_unmap(pte); __SetPageUptodate(new_page); pgtable =3D pmd_pgtable(_pmd); @@ -1212,11 +1247,7 @@ static int khugepaged_scan_pmd(struct mm_struct *m= m, goto out_unmap; } =20 - /* TODO: teach khugepaged to collapse THP mapped with pte */ - if (PageCompound(page)) { - result =3D SCAN_PAGE_COMPOUND; - goto out_unmap; - } + page =3D compound_head(page); =20 /* * Record which node the original page is from and save this --=20 2.26.1