lkml.org 
[lkml]   [2022]   [Sep]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH v3] hugetlb: freeze allocated pages before creating hugetlb pages
    On Wed, Sep 21, 2022 at 01:27:02PM -0700, Mike Kravetz wrote:
    > When creating hugetlb pages, the hugetlb code must first allocate
    > contiguous pages from a low level allocator such as buddy, cma or
    > memblock. The pages returned from these low level allocators are
    > ref counted. This creates potential issues with other code taking
    > speculative references on these pages before they can be transformed to
    > a hugetlb page. This issue has been addressed with methods and code
    > such as that provided in [1].
    >
    > Recent discussions about vmemmap freeing [2] have indicated that it
    > would be beneficial to freeze all sub pages, including the head page
    > of pages returned from low level allocators before converting to a
    > hugetlb page. This helps avoid races if we want to replace the page
    > containing vmemmap for the head page.
    >
    > There have been proposals to change at least the buddy allocator to
    > return frozen pages as described at [3]. If such a change is made, it
    > can be employed by the hugetlb code. However, as mentioned above
    > hugetlb uses several low level allocators so each would need to be
    > modified to return frozen pages. For now, we can manually freeze the
    > returned pages. This is done in two places:
    > 1) alloc_buddy_huge_page, only the returned head page is ref counted.
    > We freeze the head page, retrying once in the VERY rare case where
    > there may be an inflated ref count.
    > 2) prep_compound_gigantic_page, for gigantic pages the current code
    > freezes all pages except the head page. New code will simply freeze
    > the head page as well.
    >
    > In a few other places, code checks for inflated ref counts on newly
    > allocated hugetlb pages. With the modifications to freeze after
    > allocating, this code can be removed.
    >
    > After hugetlb pages are freshly allocated, they are often added to the
    > hugetlb free lists. Since these pages were previously ref counted, this
    > was done via put_page() which would end up calling the hugetlb
    > destructor: free_huge_page. With changes to freeze pages, we simply
    > call free_huge_page directly to add the pages to the free list.
    >
    > In a few other places, freshly allocated hugetlb pages were immediately
    > put into use, and the expectation was they were already ref counted. In
    > these cases, we must manually ref count the page.
    >
    > [1] https://lore.kernel.org/linux-mm/20210622021423.154662-3-mike.kravetz@oracle.com/
    > [2] https://lore.kernel.org/linux-mm/20220802180309.19340-1-joao.m.martins@oracle.com/
    > [3] https://lore.kernel.org/linux-mm/20220809171854.3725722-1-willy@infradead.org/
    >
    > Signed-off-by: Mike Kravetz <mike.kravetz@oracle.com>

    Looks good to me, and it makes the code much more simple:

    Reviewed-by: Oscar Salvador <osalvador@suse.de>


    --
    Oscar Salvador
    SUSE Labs

    \
     
     \ /
      Last update: 2022-09-22 06:16    [W:4.219 / U:0.116 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site