alloc_tag: introduce pgtag_ref_handle to abstract page tag references

To simplify later changes to page tag references, introduce new
pgtag_ref_handle type.  This allows easy replacement of page_ext as a
storage of page allocation tags.

Link: https://lkml.kernel.org/r/20241023170759.999909-6-surenb@google.com
Signed-off-by: Suren Baghdasaryan <surenb@google.com>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Cc: Ard Biesheuvel <ardb@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Borislav Petkov (AMD) <bp@alien8.de>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Daniel Gomez <da.gomez@samsung.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: David Rientjes <rientjes@google.com>
Cc: Dennis Zhou <dennis@kernel.org>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: John Hubbard <jhubbard@nvidia.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Kalesh Singh <kaleshsingh@google.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Kent Overstreet <kent.overstreet@linux.dev>
Cc: Liam R. Howlett <Liam.Howlett@Oracle.com>
Cc: Luis Chamberlain <mcgrof@kernel.org>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport (Microsoft) <rppt@kernel.org>
Cc: Minchan Kim <minchan@google.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Petr Pavlu <petr.pavlu@suse.com>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Sami Tolvanen <samitolvanen@google.com>
Cc: Sourav Panda <souravpanda@google.com>
Cc: Steven Rostedt (Google) <rostedt@goodmis.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Thomas Huth <thuth@redhat.com>
Cc: Uladzislau Rezki (Sony) <urezki@gmail.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Xiongwei Song <xiongwei.song@windriver.com>
Cc: Yu Zhao <yuzhao@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/mm.h b/include/linux/mm.h
index c4ea7ca0c227825db82cdb97dcb15925f35c02be..063175d4f60ef46e335b3518c37c5395b772d23c 100644 (file)
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -4181,37 +4181,38 @@ static inline void pgalloc_tag_split(struct folio *folio, int old_order, int new
                return;
 
        for (i = nr_pages; i < (1 << old_order); i += nr_pages) {
-               union codetag_ref *ref = get_page_tag_ref(folio_page(folio, i));
+               union pgtag_ref_handle handle;
+               union codetag_ref ref;
 
-               if (ref) {
+               if (get_page_tag_ref(folio_page(folio, i), &ref, &handle)) {
                        /* Set new reference to point to the original tag */
-                       alloc_tag_ref_set(ref, tag);
-                       put_page_tag_ref(ref);
+                       alloc_tag_ref_set(&ref, tag);
+                       update_page_tag_ref(handle, &ref);
+                       put_page_tag_ref(handle);
                }
        }
 }
 
 static inline void pgalloc_tag_copy(struct folio *new, struct folio *old)
 {
+       union pgtag_ref_handle handle;
+       union codetag_ref ref;
        struct alloc_tag *tag;
-       union codetag_ref *ref;
 
        tag = pgalloc_tag_get(&old->page);
        if (!tag)
                return;
 
-       ref = get_page_tag_ref(&new->page);
-       if (!ref)
+       if (!get_page_tag_ref(&new->page, &ref, &handle))
                return;
 
        /* Clear the old ref to the original allocation tag. */
        clear_page_tag_ref(&old->page);
        /* Decrement the counters of the tag on get_new_folio. */
-       alloc_tag_sub(ref, folio_size(new));
-
-       __alloc_tag_ref_set(ref, tag);
-
-       put_page_tag_ref(ref);
+       alloc_tag_sub(&ref, folio_size(new));
+       __alloc_tag_ref_set(&ref, tag);
+       update_page_tag_ref(handle, &ref);
+       put_page_tag_ref(handle);
 }
 #else /* !CONFIG_MEM_ALLOC_PROFILING */
 static inline void pgalloc_tag_split(struct folio *folio, int old_order, int new_order)

diff --git a/include/linux/pgalloc_tag.h b/include/linux/pgalloc_tag.h
index 59a3deb792a8dbeafd4eb65cec6b8823e93df94e..b13cd3313a8829c46a0c24b56ff8345e7fa0ac78 100644 (file)
--- a/include/linux/pgalloc_tag.h
+++ b/include/linux/pgalloc_tag.h
@@ -11,46 +11,59 @@
 
 #include <linux/page_ext.h>
 
+union pgtag_ref_handle {
+       union codetag_ref *ref; /* reference in page extension */
+};
+
 extern struct page_ext_operations page_alloc_tagging_ops;
 
-static inline union codetag_ref *codetag_ref_from_page_ext(struct page_ext *page_ext)
+/* Should be called only if mem_alloc_profiling_enabled() */
+static inline bool get_page_tag_ref(struct page *page, union codetag_ref *ref,
+                                   union pgtag_ref_handle *handle)
 {
-       return (union codetag_ref *)page_ext_data(page_ext, &page_alloc_tagging_ops);
-}
+       struct page_ext *page_ext;
+       union codetag_ref *tmp;
 
-static inline struct page_ext *page_ext_from_codetag_ref(union codetag_ref *ref)
-{
-       return (void *)ref - page_alloc_tagging_ops.offset;
+       if (!page)
+               return false;
+
+       page_ext = page_ext_get(page);
+       if (!page_ext)
+               return false;
+
+       tmp = (union codetag_ref *)page_ext_data(page_ext, &page_alloc_tagging_ops);
+       ref->ct = tmp->ct;
+       handle->ref = tmp;
+       return true;
 }
 
-/* Should be called only if mem_alloc_profiling_enabled() */
-static inline union codetag_ref *get_page_tag_ref(struct page *page)
+static inline void put_page_tag_ref(union pgtag_ref_handle handle)
 {
-       if (page) {
-               struct page_ext *page_ext = page_ext_get(page);
+       if (WARN_ON(!handle.ref))
+               return;
 
-               if (page_ext)
-                       return codetag_ref_from_page_ext(page_ext);
-       }
-       return NULL;
+       page_ext_put((void *)handle.ref - page_alloc_tagging_ops.offset);
 }
 
-static inline void put_page_tag_ref(union codetag_ref *ref)
+static inline void update_page_tag_ref(union pgtag_ref_handle handle,
+                                      union codetag_ref *ref)
 {
-       if (WARN_ON(!ref))
+       if (WARN_ON(!handle.ref || !ref))
                return;
 
-       page_ext_put(page_ext_from_codetag_ref(ref));
+       handle.ref->ct = ref->ct;
 }
 
 static inline void clear_page_tag_ref(struct page *page)
 {
        if (mem_alloc_profiling_enabled()) {
-               union codetag_ref *ref = get_page_tag_ref(page);
+               union pgtag_ref_handle handle;
+               union codetag_ref ref;
 
-               if (ref) {
-                       set_codetag_empty(ref);
-                       put_page_tag_ref(ref);
+               if (get_page_tag_ref(page, &ref, &handle)) {
+                       set_codetag_empty(&ref);
+                       update_page_tag_ref(handle, &ref);
+                       put_page_tag_ref(handle);
                }
        }
 }
@@ -59,11 +72,13 @@ static inline void pgalloc_tag_add(struct page *page, struct task_struct *task,
                                   unsigned int nr)
 {
        if (mem_alloc_profiling_enabled()) {
-               union codetag_ref *ref = get_page_tag_ref(page);
+               union pgtag_ref_handle handle;
+               union codetag_ref ref;
 
-               if (ref) {
-                       alloc_tag_add(ref, task->alloc_tag, PAGE_SIZE * nr);
-                       put_page_tag_ref(ref);
+               if (get_page_tag_ref(page, &ref, &handle)) {
+                       alloc_tag_add(&ref, task->alloc_tag, PAGE_SIZE * nr);
+                       update_page_tag_ref(handle, &ref);
+                       put_page_tag_ref(handle);
                }
        }
 }
@@ -71,11 +86,13 @@ static inline void pgalloc_tag_add(struct page *page, struct task_struct *task,
 static inline void pgalloc_tag_sub(struct page *page, unsigned int nr)
 {
        if (mem_alloc_profiling_enabled()) {
-               union codetag_ref *ref = get_page_tag_ref(page);
+               union pgtag_ref_handle handle;
+               union codetag_ref ref;
 
-               if (ref) {
-                       alloc_tag_sub(ref, PAGE_SIZE * nr);
-                       put_page_tag_ref(ref);
+               if (get_page_tag_ref(page, &ref, &handle)) {
+                       alloc_tag_sub(&ref, PAGE_SIZE * nr);
+                       update_page_tag_ref(handle, &ref);
+                       put_page_tag_ref(handle);
                }
        }
 }
@@ -85,13 +102,14 @@ 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) {
-                       if (ref->ct)
-                               tag = ct_to_alloc_tag(ref->ct);
-                       put_page_tag_ref(ref);
+               union pgtag_ref_handle handle;
+               union codetag_ref ref;
+
+               if (get_page_tag_ref(page, &ref, &handle)) {
+                       alloc_tag_sub_check(&ref);
+                       if (ref.ct)
+                               tag = ct_to_alloc_tag(ref.ct);
+                       put_page_tag_ref(handle);
                }
        }
 
@@ -106,8 +124,6 @@ static inline void pgalloc_tag_sub_pages(struct alloc_tag *tag, unsigned int nr)
 
 #else /* CONFIG_MEM_ALLOC_PROFILING */
 
-static inline union codetag_ref *get_page_tag_ref(struct page *page) { return NULL; }
-static inline void put_page_tag_ref(union codetag_ref *ref) {}
 static inline void clear_page_tag_ref(struct page *page) {}
 static inline void pgalloc_tag_add(struct page *page, struct task_struct *task,
                                   unsigned int nr) {}