| Message ID | 20210319224209.150047-4-mike.kravetz@oracle.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | make hugetlb put_page safe for all calling contexts | expand |
On Fri 19-03-21 15:42:04, Mike Kravetz wrote: > The new remove_hugetlb_page() routine is designed to remove a hugetlb > page from hugetlbfs processing. It will remove the page from the active > or free list, update global counters and set the compound page > destructor to NULL so that PageHuge() will return false for the 'page'. > After this call, the 'page' can be treated as a normal compound page or > a collection of base size pages. > > remove_hugetlb_page is to be called with the hugetlb_lock held. > > Creating this routine and separating functionality is in preparation for > restructuring code to reduce lock hold times. I like this! Counters handling both in __free_huge_page and update_and_free_page is really confusing. > Signed-off-by: Mike Kravetz <mike.kravetz@oracle.com> > --- > mm/hugetlb.c | 70 ++++++++++++++++++++++++++++++++++------------------ > 1 file changed, 46 insertions(+), 24 deletions(-) > > diff --git a/mm/hugetlb.c b/mm/hugetlb.c > index c537274c2a38..ae185d3315e0 100644 > --- a/mm/hugetlb.c > +++ b/mm/hugetlb.c > @@ -1306,6 +1306,46 @@ static inline void destroy_compound_gigantic_page(struct page *page, > unsigned int order) { } > #endif > > +/* > + * Remove hugetlb page from lists, and update dtor so that page appears > + * as just a compound page. A reference is held on the page. > + * NOTE: hugetlb specific page flags stored in page->private are not > + * automatically cleared. These flags may be used in routines > + * which operate on the resulting compound page. > + * > + * Must be called with hugetlb lock held. > + */ > +static void remove_hugetlb_page(struct hstate *h, struct page *page, > + bool adjust_surplus) > +{ > + int nid = page_to_nid(page); > + I think we want lockdep_assert_held here. Lockdep asserts are not used in this code but now that you are touching it then it is probably better to start adding them. What do you think? > + if (hstate_is_gigantic(h) && !gigantic_page_runtime_supported()) > + return; > + > + list_del(&page->lru); > + > + if (HPageFreed(page)) { > + h->free_huge_pages--; > + h->free_huge_pages_node[nid]--; > + ClearHPageFreed(page); > + } > + if (adjust_surplus) { > + h->surplus_huge_pages--; > + h->surplus_huge_pages_node[nid]--; > + } > + > + VM_BUG_ON_PAGE(hugetlb_cgroup_from_page(page), page); > + VM_BUG_ON_PAGE(hugetlb_cgroup_from_page_rsvd(page), page); > + > + ClearHPageTemporary(page); > + set_page_refcounted(page); > + set_compound_page_dtor(page, NULL_COMPOUND_DTOR); > + > + h->nr_huge_pages--; > + h->nr_huge_pages_node[nid]--; > +}
On 3/22/21 7:15 AM, Michal Hocko wrote: > On Fri 19-03-21 15:42:04, Mike Kravetz wrote: >> The new remove_hugetlb_page() routine is designed to remove a hugetlb >> page from hugetlbfs processing. It will remove the page from the active >> or free list, update global counters and set the compound page >> destructor to NULL so that PageHuge() will return false for the 'page'. >> After this call, the 'page' can be treated as a normal compound page or >> a collection of base size pages. >> >> remove_hugetlb_page is to be called with the hugetlb_lock held. >> >> Creating this routine and separating functionality is in preparation for >> restructuring code to reduce lock hold times. > > I like this! Counters handling both in __free_huge_page and > update_and_free_page is really confusing. > > >> Signed-off-by: Mike Kravetz <mike.kravetz@oracle.com> >> --- >> mm/hugetlb.c | 70 ++++++++++++++++++++++++++++++++++------------------ >> 1 file changed, 46 insertions(+), 24 deletions(-) >> >> diff --git a/mm/hugetlb.c b/mm/hugetlb.c >> index c537274c2a38..ae185d3315e0 100644 >> --- a/mm/hugetlb.c >> +++ b/mm/hugetlb.c >> @@ -1306,6 +1306,46 @@ static inline void destroy_compound_gigantic_page(struct page *page, >> unsigned int order) { } >> #endif >> >> +/* >> + * Remove hugetlb page from lists, and update dtor so that page appears >> + * as just a compound page. A reference is held on the page. >> + * NOTE: hugetlb specific page flags stored in page->private are not >> + * automatically cleared. These flags may be used in routines >> + * which operate on the resulting compound page. >> + * >> + * Must be called with hugetlb lock held. >> + */ >> +static void remove_hugetlb_page(struct hstate *h, struct page *page, >> + bool adjust_surplus) >> +{ >> + int nid = page_to_nid(page); >> + > > I think we want lockdep_assert_held here. Lockdep asserts are not used > in this code but now that you are touching it then it is probably better > to start adding them. What do you think? > Yes, with this type of change we add lockdep tests/qualifiers. They are lacking in the code, and would be helpful. I will add them.
diff --git a/mm/hugetlb.c b/mm/hugetlb.c index c537274c2a38..ae185d3315e0 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -1306,6 +1306,46 @@ static inline void destroy_compound_gigantic_page(struct page *page, unsigned int order) { } #endif +/* + * Remove hugetlb page from lists, and update dtor so that page appears + * as just a compound page. A reference is held on the page. + * NOTE: hugetlb specific page flags stored in page->private are not + * automatically cleared. These flags may be used in routines + * which operate on the resulting compound page. + * + * Must be called with hugetlb lock held. + */ +static void remove_hugetlb_page(struct hstate *h, struct page *page, + bool adjust_surplus) +{ + int nid = page_to_nid(page); + + if (hstate_is_gigantic(h) && !gigantic_page_runtime_supported()) + return; + + list_del(&page->lru); + + if (HPageFreed(page)) { + h->free_huge_pages--; + h->free_huge_pages_node[nid]--; + ClearHPageFreed(page); + } + if (adjust_surplus) { + h->surplus_huge_pages--; + h->surplus_huge_pages_node[nid]--; + } + + VM_BUG_ON_PAGE(hugetlb_cgroup_from_page(page), page); + VM_BUG_ON_PAGE(hugetlb_cgroup_from_page_rsvd(page), page); + + ClearHPageTemporary(page); + set_page_refcounted(page); + set_compound_page_dtor(page, NULL_COMPOUND_DTOR); + + h->nr_huge_pages--; + h->nr_huge_pages_node[nid]--; +} + static void update_and_free_page(struct hstate *h, struct page *page) { int i; @@ -1314,8 +1354,6 @@ static void update_and_free_page(struct hstate *h, struct page *page) if (hstate_is_gigantic(h) && !gigantic_page_runtime_supported()) return; - h->nr_huge_pages--; - h->nr_huge_pages_node[page_to_nid(page)]--; for (i = 0; i < pages_per_huge_page(h); i++, subpage = mem_map_next(subpage, page, i)) { subpage->flags &= ~(1 << PG_locked | 1 << PG_error | @@ -1323,10 +1361,6 @@ static void update_and_free_page(struct hstate *h, struct page *page) 1 << PG_active | 1 << PG_private | 1 << PG_writeback); } - VM_BUG_ON_PAGE(hugetlb_cgroup_from_page(page), page); - VM_BUG_ON_PAGE(hugetlb_cgroup_from_page_rsvd(page), page); - set_compound_page_dtor(page, NULL_COMPOUND_DTOR); - set_page_refcounted(page); if (hstate_is_gigantic(h)) { /* * Temporarily drop the hugetlb_lock, because @@ -1400,15 +1434,12 @@ static void __free_huge_page(struct page *page) h->resv_huge_pages++; if (HPageTemporary(page)) { - list_del(&page->lru); - ClearHPageTemporary(page); + remove_hugetlb_page(h, page, false); update_and_free_page(h, page); } else if (h->surplus_huge_pages_node[nid]) { /* remove the page from active list */ - list_del(&page->lru); + remove_hugetlb_page(h, page, true); update_and_free_page(h, page); - h->surplus_huge_pages--; - h->surplus_huge_pages_node[nid]--; } else { arch_clear_hugepage_flags(page); enqueue_huge_page(h, page); @@ -1693,13 +1724,7 @@ static int free_pool_huge_page(struct hstate *h, nodemask_t *nodes_allowed, struct page *page = list_entry(h->hugepage_freelists[node].next, struct page, lru); - list_del(&page->lru); - h->free_huge_pages--; - h->free_huge_pages_node[node]--; - if (acct_surplus) { - h->surplus_huge_pages--; - h->surplus_huge_pages_node[node]--; - } + remove_hugetlb_page(h, page, acct_surplus); update_and_free_page(h, page); ret = 1; break; @@ -1737,7 +1762,6 @@ int dissolve_free_huge_page(struct page *page) if (!page_count(page)) { struct page *head = compound_head(page); struct hstate *h = page_hstate(head); - int nid = page_to_nid(head); if (h->free_huge_pages - h->resv_huge_pages == 0) goto out; @@ -1768,9 +1792,7 @@ int dissolve_free_huge_page(struct page *page) SetPageHWPoison(page); ClearPageHWPoison(head); } - list_del(&head->lru); - h->free_huge_pages--; - h->free_huge_pages_node[nid]--; + remove_hugetlb_page(h, page, false); h->max_huge_pages--; update_and_free_page(h, head); rc = 0; @@ -2547,10 +2569,10 @@ static void try_to_free_low(struct hstate *h, unsigned long count, return; if (PageHighMem(page)) continue; - list_del(&page->lru); - update_and_free_page(h, page); + remove_hugetlb_page(h, page, false); h->free_huge_pages--; h->free_huge_pages_node[page_to_nid(page)]--; + update_and_free_page(h, page); /* * update_and_free_page could have dropped lock so
The new remove_hugetlb_page() routine is designed to remove a hugetlb page from hugetlbfs processing. It will remove the page from the active or free list, update global counters and set the compound page destructor to NULL so that PageHuge() will return false for the 'page'. After this call, the 'page' can be treated as a normal compound page or a collection of base size pages. remove_hugetlb_page is to be called with the hugetlb_lock held. Creating this routine and separating functionality is in preparation for restructuring code to reduce lock hold times. Signed-off-by: Mike Kravetz <mike.kravetz@oracle.com> --- mm/hugetlb.c | 70 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 46 insertions(+), 24 deletions(-)