lkml.org 
[lkml]   [2020]   [Oct]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH v5 1/4] mm: memcontrol: use helpers to read page's memcg data
Sorry for being late.

On Fri 02-10-20 10:25:56, Roman Gushchin wrote:
> Currently there are many open-coded reads of the page->mem_cgroup
> pointer, as well as a couple of read helpers, which are barely used.
>
> It creates an obstacle on a way to reuse some bits of the pointer
> for storing additional bits of information. In fact, we already do
> this for slab pages, where the last bit indicates that a pointer has
> an attached vector of objcg pointers instead of a regular memcg
> pointer.
>
> This commits uses 2 existing helpers and introduces a new helper to
> converts all read sides to calls of these helpers:
> struct mem_cgroup *page_memcg(struct page *page);
> struct mem_cgroup *page_memcg_rcu(struct page *page);
> struct mem_cgroup *page_memcg_check(struct page *page);
>
> page_memcg_check() is intended to be used in cases when the page
> can be a slab page and have a memcg pointer pointing at objcg vector.
> It does check the lowest bit, and if set, returns NULL.
> page_memcg() contains a VM_BUG_ON_PAGE() check for the page not
> being a slab page.
>
> To make sure nobody uses a direct access, struct page's
> mem_cgroup/obj_cgroups is converted to unsigned long memcg_data.
>
> Signed-off-by: Roman Gushchin <guro@fb.com>
> Acked-by: Johannes Weiner <hannes@cmpxchg.org>

Acked-by: Michal Hocko <mhocko@suse.com>

> ---
> fs/buffer.c | 2 +-
> fs/iomap/buffered-io.c | 2 +-
> include/linux/memcontrol.h | 114 ++++++++++++++++++++++++++---
> include/linux/mm.h | 22 ------
> include/linux/mm_types.h | 5 +-
> include/trace/events/writeback.h | 2 +-
> kernel/fork.c | 7 +-
> mm/debug.c | 4 +-
> mm/huge_memory.c | 4 +-
> mm/memcontrol.c | 121 ++++++++++++++-----------------
> mm/page_alloc.c | 4 +-
> mm/page_io.c | 6 +-
> mm/slab.h | 9 +--
> mm/workingset.c | 2 +-
> 14 files changed, 184 insertions(+), 120 deletions(-)
>
> diff --git a/fs/buffer.c b/fs/buffer.c
> index bf4d8037f91b..64564ac7dcc5 100644
> --- a/fs/buffer.c
> +++ b/fs/buffer.c
> @@ -657,7 +657,7 @@ int __set_page_dirty_buffers(struct page *page)
> } while (bh != head);
> }
> /*
> - * Lock out page->mem_cgroup migration to keep PageDirty
> + * Lock out page's memcg migration to keep PageDirty
> * synchronized with per-memcg dirty page counters.
> */
> lock_page_memcg(page);
> diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
> index 8180061b9e16..f96094a32851 100644
> --- a/fs/iomap/buffered-io.c
> +++ b/fs/iomap/buffered-io.c
> @@ -650,7 +650,7 @@ iomap_set_page_dirty(struct page *page)
> return !TestSetPageDirty(page);
>
> /*
> - * Lock out page->mem_cgroup migration to keep PageDirty
> + * Lock out page's memcg migration to keep PageDirty
> * synchronized with per-memcg dirty page counters.
> */
> lock_page_memcg(page);
> diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
> index e391e3c56de5..f95c1433461c 100644
> --- a/include/linux/memcontrol.h
> +++ b/include/linux/memcontrol.h
> @@ -343,6 +343,79 @@ struct mem_cgroup {
>
> extern struct mem_cgroup *root_mem_cgroup;
>
> +/*
> + * page_memcg - get the memory cgroup associated with a page
> + * @page: a pointer to the page struct
> + *
> + * Returns a pointer to the memory cgroup associated with the page,
> + * or NULL. This function assumes that the page is known to have a
> + * proper memory cgroup pointer. It's not safe to call this function
> + * against some type of pages, e.g. slab pages or ex-slab pages.
> + *
> + * Any of the following ensures page and memcg binding stability:
> + * - the page lock
> + * - LRU isolation
> + * - lock_page_memcg()
> + * - exclusive reference
> + */
> +static inline struct mem_cgroup *page_memcg(struct page *page)
> +{
> + VM_BUG_ON_PAGE(PageSlab(page), page);
> + return (struct mem_cgroup *)page->memcg_data;
> +}
> +
> +/*
> + * page_memcg_rcu - locklessly get the memory cgroup associated with a page
> + * @page: a pointer to the page struct
> + *
> + * Returns a pointer to the memory cgroup associated with the page,
> + * or NULL. This function assumes that the page is known to have a
> + * proper memory cgroup pointer. It's not safe to call this function
> + * against some type of pages, e.g. slab pages or ex-slab pages.
> + */
> +static inline struct mem_cgroup *page_memcg_rcu(struct page *page)
> +{
> + VM_BUG_ON_PAGE(PageSlab(page), page);
> + WARN_ON_ONCE(!rcu_read_lock_held());
> +
> + return (struct mem_cgroup *)READ_ONCE(page->memcg_data);
> +}
> +
> +/*
> + * page_memcg_check - get the memory cgroup associated with a page
> + * @page: a pointer to the page struct
> + *
> + * Returns a pointer to the memory cgroup associated with the page,
> + * or NULL. This function unlike page_memcg() can take any page
> + * as an argument. It has to be used in cases when it's not known if a page
> + * has an associated memory cgroup pointer or an object cgroups vector.
> + *
> + * Any of the following ensures page and memcg binding stability:
> + * - the page lock
> + * - LRU isolation
> + * - lock_page_memcg()
> + * - exclusive reference
> + */
> +static inline struct mem_cgroup *page_memcg_check(struct page *page)
> +{
> + /*
> + * Because page->memcg_data might be changed asynchronously
> + * for slab pages, READ_ONCE() should be used here.
> + */
> + unsigned long memcg_data = READ_ONCE(page->memcg_data);
> +
> + /*
> + * The lowest bit set means that memcg isn't a valid
> + * memcg pointer, but a obj_cgroups pointer.
> + * In this case the page is shared and doesn't belong
> + * to any specific memory cgroup.
> + */
> + if (memcg_data & 0x1UL)
> + return NULL;
> +
> + return (struct mem_cgroup *)memcg_data;
> +}
> +
> static __always_inline bool memcg_stat_item_in_bytes(int idx)
> {
> if (idx == MEMCG_PERCPU_B)
> @@ -743,15 +816,19 @@ static inline void mod_memcg_state(struct mem_cgroup *memcg,
> static inline void __mod_memcg_page_state(struct page *page,
> int idx, int val)
> {
> - if (page->mem_cgroup)
> - __mod_memcg_state(page->mem_cgroup, idx, val);
> + struct mem_cgroup *memcg = page_memcg(page);
> +
> + if (memcg)
> + __mod_memcg_state(memcg, idx, val);
> }
>
> static inline void mod_memcg_page_state(struct page *page,
> int idx, int val)
> {
> - if (page->mem_cgroup)
> - mod_memcg_state(page->mem_cgroup, idx, val);
> + struct mem_cgroup *memcg = page_memcg(page);
> +
> + if (memcg)
> + mod_memcg_state(memcg, idx, val);
> }
>
> static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
> @@ -834,16 +911,17 @@ static inline void __mod_lruvec_page_state(struct page *page,
> enum node_stat_item idx, int val)
> {
> struct page *head = compound_head(page); /* rmap on tail pages */
> + struct mem_cgroup *memcg = page_memcg(head);
> pg_data_t *pgdat = page_pgdat(page);
> struct lruvec *lruvec;
>
> /* Untracked pages have no memcg, no lruvec. Update only the node */
> - if (!head->mem_cgroup) {
> + if (!memcg) {
> __mod_node_page_state(pgdat, idx, val);
> return;
> }
>
> - lruvec = mem_cgroup_lruvec(head->mem_cgroup, pgdat);
> + lruvec = mem_cgroup_lruvec(memcg, pgdat);
> __mod_lruvec_state(lruvec, idx, val);
> }
>
> @@ -878,8 +956,10 @@ static inline void count_memcg_events(struct mem_cgroup *memcg,
> static inline void count_memcg_page_event(struct page *page,
> enum vm_event_item idx)
> {
> - if (page->mem_cgroup)
> - count_memcg_events(page->mem_cgroup, idx, 1);
> + struct mem_cgroup *memcg = page_memcg(page);
> +
> + if (memcg)
> + count_memcg_events(memcg, idx, 1);
> }
>
> static inline void count_memcg_event_mm(struct mm_struct *mm,
> @@ -941,6 +1021,22 @@ void mem_cgroup_split_huge_fixup(struct page *head);
>
> struct mem_cgroup;
>
> +static inline struct mem_cgroup *page_memcg(struct page *page)
> +{
> + return NULL;
> +}
> +
> +static inline struct mem_cgroup *page_memcg_rcu(struct page *page)
> +{
> + WARN_ON_ONCE(!rcu_read_lock_held());
> + return NULL;
> +}
> +
> +static inline struct mem_cgroup *page_memcg_check(struct page *page)
> +{
> + return NULL;
> +}
> +
> static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
> {
> return true;
> @@ -1430,7 +1526,7 @@ static inline void mem_cgroup_track_foreign_dirty(struct page *page,
> if (mem_cgroup_disabled())
> return;
>
> - if (unlikely(&page->mem_cgroup->css != wb->memcg_css))
> + if (unlikely(&page_memcg(page)->css != wb->memcg_css))
> mem_cgroup_track_foreign_dirty_slowpath(page, wb);
> }
>
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index 27c64d0d7520..6707801b014d 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -1484,28 +1484,6 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
> #endif
> }
>
> -#ifdef CONFIG_MEMCG
> -static inline struct mem_cgroup *page_memcg(struct page *page)
> -{
> - return page->mem_cgroup;
> -}
> -static inline struct mem_cgroup *page_memcg_rcu(struct page *page)
> -{
> - WARN_ON_ONCE(!rcu_read_lock_held());
> - return READ_ONCE(page->mem_cgroup);
> -}
> -#else
> -static inline struct mem_cgroup *page_memcg(struct page *page)
> -{
> - return NULL;
> -}
> -static inline struct mem_cgroup *page_memcg_rcu(struct page *page)
> -{
> - WARN_ON_ONCE(!rcu_read_lock_held());
> - return NULL;
> -}
> -#endif
> -
> /*
> * Some inline functions in vmstat.h depend on page_zone()
> */
> diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
> index 5a9238f6caad..80f5d755c037 100644
> --- a/include/linux/mm_types.h
> +++ b/include/linux/mm_types.h
> @@ -199,10 +199,7 @@ struct page {
> atomic_t _refcount;
>
> #ifdef CONFIG_MEMCG
> - union {
> - struct mem_cgroup *mem_cgroup;
> - struct obj_cgroup **obj_cgroups;
> - };
> + unsigned long memcg_data;
> #endif
>
> /*
> diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
> index e7cbccc7c14c..39a40dfb578a 100644
> --- a/include/trace/events/writeback.h
> +++ b/include/trace/events/writeback.h
> @@ -257,7 +257,7 @@ TRACE_EVENT(track_foreign_dirty,
> __entry->ino = inode ? inode->i_ino : 0;
> __entry->memcg_id = wb->memcg_css->id;
> __entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
> - __entry->page_cgroup_ino = cgroup_ino(page->mem_cgroup->css.cgroup);
> + __entry->page_cgroup_ino = cgroup_ino(page_memcg(page)->css.cgroup);
> ),
>
> TP_printk("bdi %s[%llu]: ino=%lu memcg_id=%u cgroup_ino=%lu page_cgroup_ino=%lu",
> diff --git a/kernel/fork.c b/kernel/fork.c
> index 9be04e54de7f..74e5776f2cea 100644
> --- a/kernel/fork.c
> +++ b/kernel/fork.c
> @@ -403,9 +403,10 @@ static int memcg_charge_kernel_stack(struct task_struct *tsk)
>
> for (i = 0; i < THREAD_SIZE / PAGE_SIZE; i++) {
> /*
> - * If memcg_kmem_charge_page() fails, page->mem_cgroup
> - * pointer is NULL, and memcg_kmem_uncharge_page() in
> - * free_thread_stack() will ignore this page.
> + * If memcg_kmem_charge_page() fails, page's
> + * memory cgroup pointer is NULL, and
> + * memcg_kmem_uncharge_page() in free_thread_stack()
> + * will ignore this page.
> */
> ret = memcg_kmem_charge_page(vm->pages[i], GFP_KERNEL,
> 0);
> diff --git a/mm/debug.c b/mm/debug.c
> index ccca576b2899..8a40b3fefbeb 100644
> --- a/mm/debug.c
> +++ b/mm/debug.c
> @@ -182,8 +182,8 @@ void __dump_page(struct page *page, const char *reason)
> pr_warn("page dumped because: %s\n", reason);
>
> #ifdef CONFIG_MEMCG
> - if (!page_poisoned && page->mem_cgroup)
> - pr_warn("page->mem_cgroup:%px\n", page->mem_cgroup);
> + if (!page_poisoned && page->memcg_data)
> + pr_warn("pages's memcg:%lx\n", page->memcg_data);
> #endif
> }
>
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index cba3812a5c3e..999f8a4dcb56 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -470,7 +470,7 @@ pmd_t maybe_pmd_mkwrite(pmd_t pmd, struct vm_area_struct *vma)
> #ifdef CONFIG_MEMCG
> static inline struct deferred_split *get_deferred_split_queue(struct page *page)
> {
> - struct mem_cgroup *memcg = compound_head(page)->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(compound_head(page));
> struct pglist_data *pgdat = NODE_DATA(page_to_nid(page));
>
> if (memcg)
> @@ -2766,7 +2766,7 @@ void deferred_split_huge_page(struct page *page)
> {
> struct deferred_split *ds_queue = get_deferred_split_queue(page);
> #ifdef CONFIG_MEMCG
> - struct mem_cgroup *memcg = compound_head(page)->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(compound_head(page));
> #endif
> unsigned long flags;
>
> diff --git a/mm/memcontrol.c b/mm/memcontrol.c
> index 888cbc48311f..c2e6c75ed988 100644
> --- a/mm/memcontrol.c
> +++ b/mm/memcontrol.c
> @@ -533,7 +533,7 @@ struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
> {
> struct mem_cgroup *memcg;
>
> - memcg = page->mem_cgroup;
> + memcg = page_memcg(page);
>
> if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
> memcg = root_mem_cgroup;
> @@ -560,16 +560,7 @@ ino_t page_cgroup_ino(struct page *page)
> unsigned long ino = 0;
>
> rcu_read_lock();
> - memcg = page->mem_cgroup;
> -
> - /*
> - * The lowest bit set means that memcg isn't a valid
> - * memcg pointer, but a obj_cgroups pointer.
> - * In this case the page is shared and doesn't belong
> - * to any specific memory cgroup.
> - */
> - if ((unsigned long) memcg & 0x1UL)
> - memcg = NULL;
> + memcg = page_memcg_check(page);
>
> while (memcg && !(memcg->css.flags & CSS_ONLINE))
> memcg = parent_mem_cgroup(memcg);
> @@ -1050,7 +1041,7 @@ EXPORT_SYMBOL(get_mem_cgroup_from_mm);
> */
> struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
> {
> - struct mem_cgroup *memcg = page->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(page);
>
> if (mem_cgroup_disabled())
> return NULL;
> @@ -1349,7 +1340,7 @@ struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct pglist_data *pgd
> goto out;
> }
>
> - memcg = page->mem_cgroup;
> + memcg = page_memcg(page);
> /*
> * Swapcache readahead pages are added to the LRU - and
> * possibly migrated - before they are charged.
> @@ -2109,7 +2100,7 @@ void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
> }
>
> /**
> - * lock_page_memcg - lock a page->mem_cgroup binding
> + * lock_page_memcg - lock a page and memcg binding
> * @page: the page
> *
> * This function protects unlocked LRU pages from being moved to
> @@ -2141,7 +2132,7 @@ struct mem_cgroup *lock_page_memcg(struct page *page)
> if (mem_cgroup_disabled())
> return NULL;
> again:
> - memcg = head->mem_cgroup;
> + memcg = page_memcg(head);
> if (unlikely(!memcg))
> return NULL;
>
> @@ -2149,7 +2140,7 @@ struct mem_cgroup *lock_page_memcg(struct page *page)
> return memcg;
>
> spin_lock_irqsave(&memcg->move_lock, flags);
> - if (memcg != head->mem_cgroup) {
> + if (memcg != page_memcg(head)) {
> spin_unlock_irqrestore(&memcg->move_lock, flags);
> goto again;
> }
> @@ -2187,14 +2178,14 @@ void __unlock_page_memcg(struct mem_cgroup *memcg)
> }
>
> /**
> - * unlock_page_memcg - unlock a page->mem_cgroup binding
> + * unlock_page_memcg - unlock a page and memcg binding
> * @page: the page
> */
> void unlock_page_memcg(struct page *page)
> {
> struct page *head = compound_head(page);
>
> - __unlock_page_memcg(head->mem_cgroup);
> + __unlock_page_memcg(page_memcg(head));
> }
> EXPORT_SYMBOL(unlock_page_memcg);
>
> @@ -2884,7 +2875,7 @@ static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
>
> static void commit_charge(struct page *page, struct mem_cgroup *memcg)
> {
> - VM_BUG_ON_PAGE(page->mem_cgroup, page);
> + VM_BUG_ON_PAGE(page_memcg(page), page);
> /*
> * Any of the following ensures page->mem_cgroup stability:
> *
> @@ -2893,7 +2884,7 @@ static void commit_charge(struct page *page, struct mem_cgroup *memcg)
> * - lock_page_memcg()
> * - exclusive reference
> */
> - page->mem_cgroup = memcg;
> + page->memcg_data = (unsigned long)memcg;
> }
>
> #ifdef CONFIG_MEMCG_KMEM
> @@ -2908,8 +2899,7 @@ int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
> if (!vec)
> return -ENOMEM;
>
> - if (cmpxchg(&page->obj_cgroups, NULL,
> - (struct obj_cgroup **) ((unsigned long)vec | 0x1UL)))
> + if (cmpxchg(&page->memcg_data, 0, (unsigned long)vec | 0x1UL))
> kfree(vec);
> else
> kmemleak_not_leak(vec);
> @@ -2920,6 +2910,12 @@ int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
> /*
> * Returns a pointer to the memory cgroup to which the kernel object is charged.
> *
> + * A passed kernel object can be a slab object or a generic kernel page, so
> + * different mechanisms for getting the memory cgroup pointer should be used.
> + * In certain cases (e.g. kernel stacks or large kmallocs with SLUB) the caller
> + * can not know for sure how the kernel object is implemented.
> + * mem_cgroup_from_obj() can be safely used in such cases.
> + *
> * The caller must ensure the memcg lifetime, e.g. by taking rcu_read_lock(),
> * cgroup_mutex, etc.
> */
> @@ -2932,17 +2928,6 @@ struct mem_cgroup *mem_cgroup_from_obj(void *p)
>
> page = virt_to_head_page(p);
>
> - /*
> - * If page->mem_cgroup is set, it's either a simple mem_cgroup pointer
> - * or a pointer to obj_cgroup vector. In the latter case the lowest
> - * bit of the pointer is set.
> - * The page->mem_cgroup pointer can be asynchronously changed
> - * from NULL to (obj_cgroup_vec | 0x1UL), but can't be changed
> - * from a valid memcg pointer to objcg vector or back.
> - */
> - if (!page->mem_cgroup)
> - return NULL;
> -
> /*
> * Slab objects are accounted individually, not per-page.
> * Memcg membership data for each individual object is saved in
> @@ -2960,8 +2945,14 @@ struct mem_cgroup *mem_cgroup_from_obj(void *p)
> return NULL;
> }
>
> - /* All other pages use page->mem_cgroup */
> - return page->mem_cgroup;
> + /*
> + * page_memcg_check() is used here, because page_has_obj_cgroups()
> + * check above could fail because the object cgroups vector wasn't set
> + * at that moment, but it can be set concurrently.
> + * page_memcg_check(page) will guarantee that a proper memory
> + * cgroup pointer or NULL will be returned.
> + */
> + return page_memcg_check(page);
> }
>
> __always_inline struct obj_cgroup *get_obj_cgroup_from_current(void)
> @@ -3099,7 +3090,7 @@ int __memcg_kmem_charge_page(struct page *page, gfp_t gfp, int order)
> if (memcg && !mem_cgroup_is_root(memcg)) {
> ret = __memcg_kmem_charge(memcg, gfp, 1 << order);
> if (!ret) {
> - page->mem_cgroup = memcg;
> + page->memcg_data = (unsigned long)memcg;
> __SetPageKmemcg(page);
> return 0;
> }
> @@ -3115,7 +3106,7 @@ int __memcg_kmem_charge_page(struct page *page, gfp_t gfp, int order)
> */
> void __memcg_kmem_uncharge_page(struct page *page, int order)
> {
> - struct mem_cgroup *memcg = page->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(page);
> unsigned int nr_pages = 1 << order;
>
> if (!memcg)
> @@ -3123,7 +3114,7 @@ void __memcg_kmem_uncharge_page(struct page *page, int order)
>
> VM_BUG_ON_PAGE(mem_cgroup_is_root(memcg), page);
> __memcg_kmem_uncharge(memcg, nr_pages);
> - page->mem_cgroup = NULL;
> + page->memcg_data = 0;
> css_put(&memcg->css);
>
> /* slab pages do not have PageKmemcg flag set */
> @@ -3274,7 +3265,7 @@ void obj_cgroup_uncharge(struct obj_cgroup *objcg, size_t size)
> */
> void mem_cgroup_split_huge_fixup(struct page *head)
> {
> - struct mem_cgroup *memcg = head->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(head);
> int i;
>
> if (mem_cgroup_disabled())
> @@ -3282,7 +3273,7 @@ void mem_cgroup_split_huge_fixup(struct page *head)
>
> for (i = 1; i < HPAGE_PMD_NR; i++) {
> css_get(&memcg->css);
> - head[i].mem_cgroup = memcg;
> + head[i].memcg_data = (unsigned long)memcg;
> }
> }
> #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
> @@ -4658,7 +4649,7 @@ void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
> void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
> struct bdi_writeback *wb)
> {
> - struct mem_cgroup *memcg = page->mem_cgroup;
> + struct mem_cgroup *memcg = page_memcg(page);
> struct memcg_cgwb_frn *frn;
> u64 now = get_jiffies_64();
> u64 oldest_at = now;
> @@ -5627,14 +5618,14 @@ static int mem_cgroup_move_account(struct page *page,
>
> /*
> * Prevent mem_cgroup_migrate() from looking at
> - * page->mem_cgroup of its source page while we change it.
> + * page's memory cgroup of its source page while we change it.
> */
> ret = -EBUSY;
> if (!trylock_page(page))
> goto out;
>
> ret = -EINVAL;
> - if (page->mem_cgroup != from)
> + if (page_memcg(page) != from)
> goto out_unlock;
>
> pgdat = page_pgdat(page);
> @@ -5689,13 +5680,13 @@ static int mem_cgroup_move_account(struct page *page,
> /*
> * All state has been migrated, let's switch to the new memcg.
> *
> - * It is safe to change page->mem_cgroup here because the page
> + * It is safe to change page's memcg here because the page
> * is referenced, charged, isolated, and locked: we can't race
> * with (un)charging, migration, LRU putback, or anything else
> - * that would rely on a stable page->mem_cgroup.
> + * that would rely on a stable page's memory cgroup.
> *
> * Note that lock_page_memcg is a memcg lock, not a page lock,
> - * to save space. As soon as we switch page->mem_cgroup to a
> + * to save space. As soon as we switch page's memory cgroup to a
> * new memcg that isn't locked, the above state can change
> * concurrently again. Make sure we're truly done with it.
> */
> @@ -5704,7 +5695,7 @@ static int mem_cgroup_move_account(struct page *page,
> css_get(&to->css);
> css_put(&from->css);
>
> - page->mem_cgroup = to;
> + page->memcg_data = (unsigned long)to;
>
> __unlock_page_memcg(from);
>
> @@ -5770,7 +5761,7 @@ static enum mc_target_type get_mctgt_type(struct vm_area_struct *vma,
> * mem_cgroup_move_account() checks the page is valid or
> * not under LRU exclusion.
> */
> - if (page->mem_cgroup == mc.from) {
> + if (page_memcg(page) == mc.from) {
> ret = MC_TARGET_PAGE;
> if (is_device_private_page(page))
> ret = MC_TARGET_DEVICE;
> @@ -5814,7 +5805,7 @@ static enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
> VM_BUG_ON_PAGE(!page || !PageHead(page), page);
> if (!(mc.flags & MOVE_ANON))
> return ret;
> - if (page->mem_cgroup == mc.from) {
> + if (page_memcg(page) == mc.from) {
> ret = MC_TARGET_PAGE;
> if (target) {
> get_page(page);
> @@ -6760,12 +6751,12 @@ int mem_cgroup_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask)
> /*
> * Every swap fault against a single page tries to charge the
> * page, bail as early as possible. shmem_unuse() encounters
> - * already charged pages, too. page->mem_cgroup is protected
> - * by the page lock, which serializes swap cache removal, which
> - * in turn serializes uncharging.
> + * already charged pages, too. page and memcg binding is
> + * protected by the page lock, which serializes swap cache
> + * removal, which in turn serializes uncharging.
> */
> VM_BUG_ON_PAGE(!PageLocked(page), page);
> - if (compound_head(page)->mem_cgroup)
> + if (page_memcg(compound_head(page)))
> goto out;
>
> id = lookup_swap_cgroup_id(ent);
> @@ -6849,21 +6840,21 @@ static void uncharge_page(struct page *page, struct uncharge_gather *ug)
>
> VM_BUG_ON_PAGE(PageLRU(page), page);
>
> - if (!page->mem_cgroup)
> + if (!page_memcg(page))
> return;
>
> /*
> * Nobody should be changing or seriously looking at
> - * page->mem_cgroup at this point, we have fully
> + * page_memcg(page) at this point, we have fully
> * exclusive access to the page.
> */
>
> - if (ug->memcg != page->mem_cgroup) {
> + if (ug->memcg != page_memcg(page)) {
> if (ug->memcg) {
> uncharge_batch(ug);
> uncharge_gather_clear(ug);
> }
> - ug->memcg = page->mem_cgroup;
> + ug->memcg = page_memcg(page);
>
> /* pairs with css_put in uncharge_batch */
> css_get(&ug->memcg->css);
> @@ -6880,7 +6871,7 @@ static void uncharge_page(struct page *page, struct uncharge_gather *ug)
> }
>
> ug->dummy_page = page;
> - page->mem_cgroup = NULL;
> + page->memcg_data = 0;
> css_put(&ug->memcg->css);
> }
>
> @@ -6923,7 +6914,7 @@ void mem_cgroup_uncharge(struct page *page)
> return;
>
> /* Don't touch page->lru of any random page, pre-check: */
> - if (!page->mem_cgroup)
> + if (!page_memcg(page))
> return;
>
> uncharge_gather_clear(&ug);
> @@ -6973,11 +6964,11 @@ void mem_cgroup_migrate(struct page *oldpage, struct page *newpage)
> return;
>
> /* Page cache replacement: new page already charged? */
> - if (newpage->mem_cgroup)
> + if (page_memcg(newpage))
> return;
>
> /* Swapcache readahead pages can get replaced before being charged */
> - memcg = oldpage->mem_cgroup;
> + memcg = page_memcg(oldpage);
> if (!memcg)
> return;
>
> @@ -7172,7 +7163,7 @@ void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
> if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
> return;
>
> - memcg = page->mem_cgroup;
> + memcg = page_memcg(page);
>
> /* Readahead page, never charged */
> if (!memcg)
> @@ -7193,7 +7184,7 @@ void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
> VM_BUG_ON_PAGE(oldid, page);
> mod_memcg_state(swap_memcg, MEMCG_SWAP, nr_entries);
>
> - page->mem_cgroup = NULL;
> + page->memcg_data = 0;
>
> if (!mem_cgroup_is_root(memcg))
> page_counter_uncharge(&memcg->memory, nr_entries);
> @@ -7236,7 +7227,7 @@ int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry)
> if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
> return 0;
>
> - memcg = page->mem_cgroup;
> + memcg = page_memcg(page);
>
> /* Readahead page, never charged */
> if (!memcg)
> @@ -7317,7 +7308,7 @@ bool mem_cgroup_swap_full(struct page *page)
> if (cgroup_memory_noswap || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
> return false;
>
> - memcg = page->mem_cgroup;
> + memcg = page_memcg(page);
> if (!memcg)
> return false;
>
> diff --git a/mm/page_alloc.c b/mm/page_alloc.c
> index eb0962976a0e..e9f0fe4a143e 100644
> --- a/mm/page_alloc.c
> +++ b/mm/page_alloc.c
> @@ -1057,7 +1057,7 @@ static inline bool page_expected_state(struct page *page,
> if (unlikely((unsigned long)page->mapping |
> page_ref_count(page) |
> #ifdef CONFIG_MEMCG
> - (unsigned long)page->mem_cgroup |
> + (unsigned long)page_memcg(page) |
> #endif
> (page->flags & check_flags)))
> return false;
> @@ -1082,7 +1082,7 @@ static const char *page_bad_reason(struct page *page, unsigned long flags)
> bad_reason = "PAGE_FLAGS_CHECK_AT_FREE flag(s) set";
> }
> #ifdef CONFIG_MEMCG
> - if (unlikely(page->mem_cgroup))
> + if (unlikely(page_memcg(page)))
> bad_reason = "page still charged to cgroup";
> #endif
> return bad_reason;
> diff --git a/mm/page_io.c b/mm/page_io.c
> index 433df1263349..9bca17ecc4df 100644
> --- a/mm/page_io.c
> +++ b/mm/page_io.c
> @@ -291,12 +291,14 @@ static inline void count_swpout_vm_event(struct page *page)
> static void bio_associate_blkg_from_page(struct bio *bio, struct page *page)
> {
> struct cgroup_subsys_state *css;
> + struct mem_cgroup *memcg;
>
> - if (!page->mem_cgroup)
> + memcg = page_memcg(page);
> + if (!memcg)
> return;
>
> rcu_read_lock();
> - css = cgroup_e_css(page->mem_cgroup->css.cgroup, &io_cgrp_subsys);
> + css = cgroup_e_css(memcg->css.cgroup, &io_cgrp_subsys);
> bio_associate_blkg_from_css(bio, css);
> rcu_read_unlock();
> }
> diff --git a/mm/slab.h b/mm/slab.h
> index 4a24e1702923..5ac89260f329 100644
> --- a/mm/slab.h
> +++ b/mm/slab.h
> @@ -242,18 +242,17 @@ static inline bool kmem_cache_debug_flags(struct kmem_cache *s, slab_flags_t fla
> static inline struct obj_cgroup **page_obj_cgroups(struct page *page)
> {
> /*
> - * page->mem_cgroup and page->obj_cgroups are sharing the same
> + * Page's memory cgroup and obj_cgroups vector are sharing the same
> * space. To distinguish between them in case we don't know for sure
> * that the page is a slab page (e.g. page_cgroup_ino()), let's
> * always set the lowest bit of obj_cgroups.
> */
> - return (struct obj_cgroup **)
> - ((unsigned long)page->obj_cgroups & ~0x1UL);
> + return (struct obj_cgroup **)(page->memcg_data & ~0x1UL);
> }
>
> static inline bool page_has_obj_cgroups(struct page *page)
> {
> - return ((unsigned long)page->obj_cgroups & 0x1UL);
> + return page->memcg_data & 0x1UL;
> }
>
> int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
> @@ -262,7 +261,7 @@ int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
> static inline void memcg_free_page_obj_cgroups(struct page *page)
> {
> kfree(page_obj_cgroups(page));
> - page->obj_cgroups = NULL;
> + page->memcg_data = 0;
> }
>
> static inline size_t obj_full_size(struct kmem_cache *s)
> diff --git a/mm/workingset.c b/mm/workingset.c
> index 8ed8e6296d8c..ef563f94a0e3 100644
> --- a/mm/workingset.c
> +++ b/mm/workingset.c
> @@ -257,7 +257,7 @@ void *workingset_eviction(struct page *page, struct mem_cgroup *target_memcg)
> struct lruvec *lruvec;
> int memcgid;
>
> - /* Page is fully exclusive and pins page->mem_cgroup */
> + /* Page is fully exclusive and pins page's memory cgroup pointer */
> VM_BUG_ON_PAGE(PageLRU(page), page);
> VM_BUG_ON_PAGE(page_count(page), page);
> VM_BUG_ON_PAGE(!PageLocked(page), page);
> --
> 2.26.2

--
Michal Hocko
SUSE Labs

\
 
 \ /
  Last update: 2020-10-14 16:38    [W:0.149 / U:2.780 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site