[PATCH v5 20/37] mm: fix non-compound multi-order memory accounting in __free_pages

[Suren Baghdasaryan]

When a non-compound multi-order page is freed, it is possible that a
speculative reference keeps the page pinned. In this case we free all
pages except for the first page, which will be freed later by the last
put_page(). However put_page() ignores the order of the page being freed,
treating it as a 0-order page. This creates a memory accounting imbalance
because the pages freed in __free_pages() do not have their own alloc_tag
and their memory was accounted to the first page. To fix this the first
page should adjust its allocation size counter when "tail" pages are freed.

Reported-by: Vlastimil Babka <vba...@suse.cz>
Signed-off-by: Suren Baghdasaryan <sur...@google.com>
---
 include/linux/pgalloc_tag.h | 24 ++++++++++++++++++++++++
 mm/page_alloc.c             | 11 ++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/include/linux/pgalloc_tag.h b/include/linux/pgalloc_tag.h
index 9e6ad8e0e4aa..59de43172cc2 100644
--- a/include/linux/pgalloc_tag.h
+++ b/include/linux/pgalloc_tag.h
@@ -96,12 +96,36 @@ static inline void pgalloc_tag_split(struct page *page, 
unsigned int nr)
        page_ext_put(page_ext);
 }
 
+static inline struct alloc_tag *pgalloc_tag_get(struct page *page)
+{
+       struct alloc_tag *tag = NULL;
+
+       if (mem_alloc_profiling_enabled()) {
+               union codetag_ref *ref = get_page_tag_ref(page);
+
+               alloc_tag_sub_check(ref);
+               if (ref && ref->ct)
+                       tag = ct_to_alloc_tag(ref->ct);
+               put_page_tag_ref(ref);
+       }
+
+       return tag;
+}
+
+static inline void pgalloc_tag_sub_bytes(struct alloc_tag *tag, unsigned int 
order)
+{
+       if (mem_alloc_profiling_enabled() && tag)
+               this_cpu_sub(tag->counters->bytes, PAGE_SIZE << order);
+}
+
 #else /* CONFIG_MEM_ALLOC_PROFILING */
 
 static inline void pgalloc_tag_add(struct page *page, struct task_struct *task,
                                   unsigned int order) {}
 static inline void pgalloc_tag_sub(struct page *page, unsigned int order) {}
 static inline void pgalloc_tag_split(struct page *page, unsigned int nr) {}
+static inline struct alloc_tag *pgalloc_tag_get(struct page *page) { return 
NULL; }
+static inline void pgalloc_tag_sub_bytes(struct alloc_tag *tag, unsigned int 
order) {}
 
 #endif /* CONFIG_MEM_ALLOC_PROFILING */
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 39dc4dcf14f5..b402149a795f 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -4697,12 +4697,21 @@ void __free_pages(struct page *page, unsigned int order)
 {
        /* get PageHead before we drop reference */
        int head = PageHead(page);
+       struct alloc_tag *tag = pgalloc_tag_get(page);
 
        if (put_page_testzero(page))
                free_the_page(page, order);
        else if (!head)
-               while (order-- > 0)
+               while (order-- > 0) {
                        free_the_page(page + (1 << order), order);
+                       /*
+                        * non-compound multi-order page accounts all 
allocations
+                        * to the first page (just like compound one), therefore
+                        * we need to adjust the allocation size of the first
+                        * page as its order is ignored when put_page() frees 
it.
+                        */
+                       pgalloc_tag_sub_bytes(tag, order);
+               }
 }
 EXPORT_SYMBOL(__free_pages);
 
-- 
2.44.0.278.ge034bb2e1d-goog