Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Thu, Apr 18, 2019 at 01:38:44PM +, Christopher Lameter wrote:
> On Wed, 17 Apr 2019, Roman Gushchin wrote:
>
> > static __always_inline int memcg_charge_slab(struct page *page,
> > gfp_t gfp, int order,
> > struct kmem_cache *s)
> > {
> > - if (is_root_cache(s))
> > + int idx = (s->flags & SLAB_RECLAIM_ACCOUNT) ?
> > + NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE;
> > + struct mem_cgroup *memcg;
> > + struct lruvec *lruvec;
> > + int ret;
> > +
> > + if (is_root_cache(s)) {
> > + mod_node_page_state(page_pgdat(page), idx, 1 << order);
>
> Hmmm... This is functionality that is not memcg specific being moved into
> a memcg function??? Maybe rename the function to indicate that it is not
> memcg specific and add the proper #ifdefs?
>
> > static __always_inline void memcg_uncharge_slab(struct page *page, int
> > order,
> > struct kmem_cache *s)
> > {
> > - memcg_kmem_uncharge(page, order);
> > + int idx = (s->flags & SLAB_RECLAIM_ACCOUNT) ?
> > + NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE;
> > + struct mem_cgroup *memcg;
> > + struct lruvec *lruvec;
> > +
> > + if (is_root_cache(s)) {
> > + mod_node_page_state(page_pgdat(page), idx, -(1 << order));
> > + return;
> > + }
>
> And again.
>
Good point! Will do in v2.
Thanks!
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Thu, Apr 18, 2019 at 07:05:24AM -0700, Shakeel Butt wrote: > On Wed, Apr 17, 2019 at 8:07 PM Roman Gushchin wrote: > > > > On Wed, Apr 17, 2019 at 06:55:12PM -0700, Shakeel Butt wrote: > > > On Wed, Apr 17, 2019 at 5:39 PM Roman Gushchin wrote: > > > > > > > > On Wed, Apr 17, 2019 at 04:41:01PM -0700, Shakeel Butt wrote: > > > > > On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin > > > > > wrote: > > > > > > > > > > > > This commit makes several important changes in the lifecycle > > > > > > of a non-root kmem_cache, which also affect the lifecycle > > > > > > of a memory cgroup. > > > > > > > > > > > > Currently each charged slab page has a page->mem_cgroup pointer > > > > > > to the memory cgroup and holds a reference to it. > > > > > > Kmem_caches are held by the cgroup. On offlining empty kmem_caches > > > > > > are freed, all other are freed on cgroup release. > > > > > > > > > > No, they are not freed (i.e. destroyed) on offlining, only > > > > > deactivated. All memcg kmem_caches are freed/destroyed on memcg's > > > > > css_free. > > > > > > > > You're right, my bad. I was thinking about the corresponding sysfs entry > > > > when was writing it. We try to free it from the deactivation path too. > > > > > > > > > > > > > > > > > > > > > So the current scheme can be illustrated as: > > > > > > page->mem_cgroup->kmem_cache. > > > > > > > > > > > > To implement the slab memory reparenting we need to invert the > > > > > > scheme > > > > > > into: page->kmem_cache->mem_cgroup. > > > > > > > > > > > > Let's make every page to hold a reference to the kmem_cache (we > > > > > > already have a stable pointer), and make kmem_caches to hold a > > > > > > single > > > > > > reference to the memory cgroup. > > > > > > > > > > What about memcg_kmem_get_cache()? That function assumes that by > > > > > taking reference on memcg, it's kmem_caches will stay. I think you > > > > > need to get reference on the kmem_cache in memcg_kmem_get_cache() > > > > > within the rcu lock where you get the memcg through css_tryget_online. > > > > > > > > Yeah, a very good question. > > > > > > > > I believe it's safe because css_tryget_online() guarantees that > > > > the cgroup is online and won't go offline before css_free() in > > > > slab_post_alloc_hook(). I do initialize kmem_cache's refcount to 1 > > > > and drop it on offlining, so it protects the online kmem_cache. > > > > > > > > > > Let's suppose a thread doing a remote charging calls > > > memcg_kmem_get_cache() and gets an empty kmem_cache of the remote > > > memcg having refcnt equal to 1. That thread got a reference on the > > > remote memcg but no reference on the kmem_cache. Let's suppose that > > > thread got stuck in the reclaim and scheduled away. In the meantime > > > that remote memcg got offlined and decremented the refcnt of all of > > > its kmem_caches. The empty kmem_cache which the thread stuck in > > > reclaim have pointer to can get deleted and may be using an already > > > destroyed kmem_cache after coming back from reclaim. > > > > > > I think the above situation is possible unless the thread gets the > > > reference on the kmem_cache in memcg_kmem_get_cache(). > > > > Yes, you're right and I'm writing a nonsense: css_tryget_online() > > can't prevent the cgroup from being offlined. > > > > The reason I knew about that race is because I tried something similar > but for different use-case: > > https://lkml.org/lkml/2018/3/26/472 > > > So, the problem with getting a reference in memcg_kmem_get_cache() > > is that it's an atomic operation on the hot path, something I'd like > > to avoid. > > > > I can make the refcounter percpu, but it'll add some complexity and size > > to the kmem_cache object. Still an option, of course. > > > > I kind of prefer this option. > > > I wonder if we can use rcu_read_lock() instead, and bump the refcounter > > only if we're going into reclaim. > > > > What do you think? > > Should it be just reclaim or anything that can reschedule the current thread? > > I can tell how we resolve the similar issue for our > eager-kmem_cache-deletion use-case. Our solution (hack) works only for > CONFIG_SLAB (we only use SLAB) and non-preemptible kernel. The > underlying motivation was to reduce the overhead of slab reaper of > traversing thousands of empty offlined kmem caches. CONFIG_SLAB > disables interrupts before accessing the per-cpu caches and reenables > the interrupts if it has to fallback to the page allocation. We use > this window to call memcg_kmem_get_cache() and only increment the > refcnt of kmem_cache if going to the fallback. Thus no need to do > atomic operation on the hot path. > > Anyways, I think having percpu refcounter for each memcg kmem_cache is > not that costy for CONFIG_MEMCG_KMEM users and to me that seems like > the most simple solution. > > Shakeel Ok, sounds like a percpu refcounter is the best option. I'll try this approach in v2. Thanks!
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Thu, Apr 18, 2019 at 01:34:52PM +, Christopher Lameter wrote: > On Wed, 17 Apr 2019, Roman Gushchin wrote: > > > Let's make every page to hold a reference to the kmem_cache (we > > already have a stable pointer), and make kmem_caches to hold a single > > reference to the memory cgroup. > > Ok you are freeing one word in the page struct that can be used for other > purposes now? > Looks so!
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, Apr 17, 2019 at 8:07 PM Roman Gushchin wrote: > > On Wed, Apr 17, 2019 at 06:55:12PM -0700, Shakeel Butt wrote: > > On Wed, Apr 17, 2019 at 5:39 PM Roman Gushchin wrote: > > > > > > On Wed, Apr 17, 2019 at 04:41:01PM -0700, Shakeel Butt wrote: > > > > On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin wrote: > > > > > > > > > > This commit makes several important changes in the lifecycle > > > > > of a non-root kmem_cache, which also affect the lifecycle > > > > > of a memory cgroup. > > > > > > > > > > Currently each charged slab page has a page->mem_cgroup pointer > > > > > to the memory cgroup and holds a reference to it. > > > > > Kmem_caches are held by the cgroup. On offlining empty kmem_caches > > > > > are freed, all other are freed on cgroup release. > > > > > > > > No, they are not freed (i.e. destroyed) on offlining, only > > > > deactivated. All memcg kmem_caches are freed/destroyed on memcg's > > > > css_free. > > > > > > You're right, my bad. I was thinking about the corresponding sysfs entry > > > when was writing it. We try to free it from the deactivation path too. > > > > > > > > > > > > > > > > > So the current scheme can be illustrated as: > > > > > page->mem_cgroup->kmem_cache. > > > > > > > > > > To implement the slab memory reparenting we need to invert the scheme > > > > > into: page->kmem_cache->mem_cgroup. > > > > > > > > > > Let's make every page to hold a reference to the kmem_cache (we > > > > > already have a stable pointer), and make kmem_caches to hold a single > > > > > reference to the memory cgroup. > > > > > > > > What about memcg_kmem_get_cache()? That function assumes that by > > > > taking reference on memcg, it's kmem_caches will stay. I think you > > > > need to get reference on the kmem_cache in memcg_kmem_get_cache() > > > > within the rcu lock where you get the memcg through css_tryget_online. > > > > > > Yeah, a very good question. > > > > > > I believe it's safe because css_tryget_online() guarantees that > > > the cgroup is online and won't go offline before css_free() in > > > slab_post_alloc_hook(). I do initialize kmem_cache's refcount to 1 > > > and drop it on offlining, so it protects the online kmem_cache. > > > > > > > Let's suppose a thread doing a remote charging calls > > memcg_kmem_get_cache() and gets an empty kmem_cache of the remote > > memcg having refcnt equal to 1. That thread got a reference on the > > remote memcg but no reference on the kmem_cache. Let's suppose that > > thread got stuck in the reclaim and scheduled away. In the meantime > > that remote memcg got offlined and decremented the refcnt of all of > > its kmem_caches. The empty kmem_cache which the thread stuck in > > reclaim have pointer to can get deleted and may be using an already > > destroyed kmem_cache after coming back from reclaim. > > > > I think the above situation is possible unless the thread gets the > > reference on the kmem_cache in memcg_kmem_get_cache(). > > Yes, you're right and I'm writing a nonsense: css_tryget_online() > can't prevent the cgroup from being offlined. > The reason I knew about that race is because I tried something similar but for different use-case: https://lkml.org/lkml/2018/3/26/472 > So, the problem with getting a reference in memcg_kmem_get_cache() > is that it's an atomic operation on the hot path, something I'd like > to avoid. > > I can make the refcounter percpu, but it'll add some complexity and size > to the kmem_cache object. Still an option, of course. > I kind of prefer this option. > I wonder if we can use rcu_read_lock() instead, and bump the refcounter > only if we're going into reclaim. > > What do you think? Should it be just reclaim or anything that can reschedule the current thread? I can tell how we resolve the similar issue for our eager-kmem_cache-deletion use-case. Our solution (hack) works only for CONFIG_SLAB (we only use SLAB) and non-preemptible kernel. The underlying motivation was to reduce the overhead of slab reaper of traversing thousands of empty offlined kmem caches. CONFIG_SLAB disables interrupts before accessing the per-cpu caches and reenables the interrupts if it has to fallback to the page allocation. We use this window to call memcg_kmem_get_cache() and only increment the refcnt of kmem_cache if going to the fallback. Thus no need to do atomic operation on the hot path. Anyways, I think having percpu refcounter for each memcg kmem_cache is not that costy for CONFIG_MEMCG_KMEM users and to me that seems like the most simple solution. Shakeel
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, 17 Apr 2019, Roman Gushchin wrote:
> static __always_inline int memcg_charge_slab(struct page *page,
>gfp_t gfp, int order,
>struct kmem_cache *s)
> {
> - if (is_root_cache(s))
> + int idx = (s->flags & SLAB_RECLAIM_ACCOUNT) ?
> + NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE;
> + struct mem_cgroup *memcg;
> + struct lruvec *lruvec;
> + int ret;
> +
> + if (is_root_cache(s)) {
> + mod_node_page_state(page_pgdat(page), idx, 1 << order);
Hmmm... This is functionality that is not memcg specific being moved into
a memcg function??? Maybe rename the function to indicate that it is not
memcg specific and add the proper #ifdefs?
> static __always_inline void memcg_uncharge_slab(struct page *page, int order,
> struct kmem_cache *s)
> {
> - memcg_kmem_uncharge(page, order);
> + int idx = (s->flags & SLAB_RECLAIM_ACCOUNT) ?
> + NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE;
> + struct mem_cgroup *memcg;
> + struct lruvec *lruvec;
> +
> + if (is_root_cache(s)) {
> + mod_node_page_state(page_pgdat(page), idx, -(1 << order));
> + return;
> + }
And again.
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, 17 Apr 2019, Roman Gushchin wrote: > Let's make every page to hold a reference to the kmem_cache (we > already have a stable pointer), and make kmem_caches to hold a single > reference to the memory cgroup. Ok you are freeing one word in the page struct that can be used for other purposes now?
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, Apr 17, 2019 at 06:55:12PM -0700, Shakeel Butt wrote: > On Wed, Apr 17, 2019 at 5:39 PM Roman Gushchin wrote: > > > > On Wed, Apr 17, 2019 at 04:41:01PM -0700, Shakeel Butt wrote: > > > On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin wrote: > > > > > > > > This commit makes several important changes in the lifecycle > > > > of a non-root kmem_cache, which also affect the lifecycle > > > > of a memory cgroup. > > > > > > > > Currently each charged slab page has a page->mem_cgroup pointer > > > > to the memory cgroup and holds a reference to it. > > > > Kmem_caches are held by the cgroup. On offlining empty kmem_caches > > > > are freed, all other are freed on cgroup release. > > > > > > No, they are not freed (i.e. destroyed) on offlining, only > > > deactivated. All memcg kmem_caches are freed/destroyed on memcg's > > > css_free. > > > > You're right, my bad. I was thinking about the corresponding sysfs entry > > when was writing it. We try to free it from the deactivation path too. > > > > > > > > > > > > > So the current scheme can be illustrated as: > > > > page->mem_cgroup->kmem_cache. > > > > > > > > To implement the slab memory reparenting we need to invert the scheme > > > > into: page->kmem_cache->mem_cgroup. > > > > > > > > Let's make every page to hold a reference to the kmem_cache (we > > > > already have a stable pointer), and make kmem_caches to hold a single > > > > reference to the memory cgroup. > > > > > > What about memcg_kmem_get_cache()? That function assumes that by > > > taking reference on memcg, it's kmem_caches will stay. I think you > > > need to get reference on the kmem_cache in memcg_kmem_get_cache() > > > within the rcu lock where you get the memcg through css_tryget_online. > > > > Yeah, a very good question. > > > > I believe it's safe because css_tryget_online() guarantees that > > the cgroup is online and won't go offline before css_free() in > > slab_post_alloc_hook(). I do initialize kmem_cache's refcount to 1 > > and drop it on offlining, so it protects the online kmem_cache. > > > > Let's suppose a thread doing a remote charging calls > memcg_kmem_get_cache() and gets an empty kmem_cache of the remote > memcg having refcnt equal to 1. That thread got a reference on the > remote memcg but no reference on the kmem_cache. Let's suppose that > thread got stuck in the reclaim and scheduled away. In the meantime > that remote memcg got offlined and decremented the refcnt of all of > its kmem_caches. The empty kmem_cache which the thread stuck in > reclaim have pointer to can get deleted and may be using an already > destroyed kmem_cache after coming back from reclaim. > > I think the above situation is possible unless the thread gets the > reference on the kmem_cache in memcg_kmem_get_cache(). Yes, you're right and I'm writing a nonsense: css_tryget_online() can't prevent the cgroup from being offlined. So, the problem with getting a reference in memcg_kmem_get_cache() is that it's an atomic operation on the hot path, something I'd like to avoid. I can make the refcounter percpu, but it'll add some complexity and size to the kmem_cache object. Still an option, of course. I wonder if we can use rcu_read_lock() instead, and bump the refcounter only if we're going into reclaim. What do you think? Thanks!
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, Apr 17, 2019 at 5:39 PM Roman Gushchin wrote: > > On Wed, Apr 17, 2019 at 04:41:01PM -0700, Shakeel Butt wrote: > > On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin wrote: > > > > > > This commit makes several important changes in the lifecycle > > > of a non-root kmem_cache, which also affect the lifecycle > > > of a memory cgroup. > > > > > > Currently each charged slab page has a page->mem_cgroup pointer > > > to the memory cgroup and holds a reference to it. > > > Kmem_caches are held by the cgroup. On offlining empty kmem_caches > > > are freed, all other are freed on cgroup release. > > > > No, they are not freed (i.e. destroyed) on offlining, only > > deactivated. All memcg kmem_caches are freed/destroyed on memcg's > > css_free. > > You're right, my bad. I was thinking about the corresponding sysfs entry > when was writing it. We try to free it from the deactivation path too. > > > > > > > > > So the current scheme can be illustrated as: > > > page->mem_cgroup->kmem_cache. > > > > > > To implement the slab memory reparenting we need to invert the scheme > > > into: page->kmem_cache->mem_cgroup. > > > > > > Let's make every page to hold a reference to the kmem_cache (we > > > already have a stable pointer), and make kmem_caches to hold a single > > > reference to the memory cgroup. > > > > What about memcg_kmem_get_cache()? That function assumes that by > > taking reference on memcg, it's kmem_caches will stay. I think you > > need to get reference on the kmem_cache in memcg_kmem_get_cache() > > within the rcu lock where you get the memcg through css_tryget_online. > > Yeah, a very good question. > > I believe it's safe because css_tryget_online() guarantees that > the cgroup is online and won't go offline before css_free() in > slab_post_alloc_hook(). I do initialize kmem_cache's refcount to 1 > and drop it on offlining, so it protects the online kmem_cache. > Let's suppose a thread doing a remote charging calls memcg_kmem_get_cache() and gets an empty kmem_cache of the remote memcg having refcnt equal to 1. That thread got a reference on the remote memcg but no reference on the kmem_cache. Let's suppose that thread got stuck in the reclaim and scheduled away. In the meantime that remote memcg got offlined and decremented the refcnt of all of its kmem_caches. The empty kmem_cache which the thread stuck in reclaim have pointer to can get deleted and may be using an already destroyed kmem_cache after coming back from reclaim. I think the above situation is possible unless the thread gets the reference on the kmem_cache in memcg_kmem_get_cache(). Shakeel
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, Apr 17, 2019 at 04:41:01PM -0700, Shakeel Butt wrote: > On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin wrote: > > > > This commit makes several important changes in the lifecycle > > of a non-root kmem_cache, which also affect the lifecycle > > of a memory cgroup. > > > > Currently each charged slab page has a page->mem_cgroup pointer > > to the memory cgroup and holds a reference to it. > > Kmem_caches are held by the cgroup. On offlining empty kmem_caches > > are freed, all other are freed on cgroup release. > > No, they are not freed (i.e. destroyed) on offlining, only > deactivated. All memcg kmem_caches are freed/destroyed on memcg's > css_free. You're right, my bad. I was thinking about the corresponding sysfs entry when was writing it. We try to free it from the deactivation path too. > > > > > So the current scheme can be illustrated as: > > page->mem_cgroup->kmem_cache. > > > > To implement the slab memory reparenting we need to invert the scheme > > into: page->kmem_cache->mem_cgroup. > > > > Let's make every page to hold a reference to the kmem_cache (we > > already have a stable pointer), and make kmem_caches to hold a single > > reference to the memory cgroup. > > What about memcg_kmem_get_cache()? That function assumes that by > taking reference on memcg, it's kmem_caches will stay. I think you > need to get reference on the kmem_cache in memcg_kmem_get_cache() > within the rcu lock where you get the memcg through css_tryget_online. Yeah, a very good question. I believe it's safe because css_tryget_online() guarantees that the cgroup is online and won't go offline before css_free() in slab_post_alloc_hook(). I do initialize kmem_cache's refcount to 1 and drop it on offlining, so it protects the online kmem_cache. Thank you for looking into the patchset!
Re: [PATCH 4/5] mm: rework non-root kmem_cache lifecycle management
On Wed, Apr 17, 2019 at 2:55 PM Roman Gushchin wrote:
>
> This commit makes several important changes in the lifecycle
> of a non-root kmem_cache, which also affect the lifecycle
> of a memory cgroup.
>
> Currently each charged slab page has a page->mem_cgroup pointer
> to the memory cgroup and holds a reference to it.
> Kmem_caches are held by the cgroup. On offlining empty kmem_caches
> are freed, all other are freed on cgroup release.
No, they are not freed (i.e. destroyed) on offlining, only
deactivated. All memcg kmem_caches are freed/destroyed on memcg's
css_free.
>
> So the current scheme can be illustrated as:
> page->mem_cgroup->kmem_cache.
>
> To implement the slab memory reparenting we need to invert the scheme
> into: page->kmem_cache->mem_cgroup.
>
> Let's make every page to hold a reference to the kmem_cache (we
> already have a stable pointer), and make kmem_caches to hold a single
> reference to the memory cgroup.
What about memcg_kmem_get_cache()? That function assumes that by
taking reference on memcg, it's kmem_caches will stay. I think you
need to get reference on the kmem_cache in memcg_kmem_get_cache()
within the rcu lock where you get the memcg through css_tryget_online.
>
> To make this possible we need to introduce a new refcounter
> for non-root kmem_caches. It's atomic for now, but can be easily
> converted to a percpu counter, had we any performance penalty*.
> The initial value is set to 1, and it's decremented on deactivation,
> so we never shutdown an active cache.
>
> To shutdown non-active empty kmem_caches, let's reuse the
> infrastructure of the RCU-delayed work queue, used previously for
> the deactivation. After the generalization, it's perfectly suited
> for our needs.
>
> Since now we can release a kmem_cache at any moment after the
> deactivation, let's call sysfs_slab_remove() only from the shutdown
> path. It makes deactivation path simpler.
>
> Because we don't set the page->mem_cgroup pointer, we need to change
> the way how memcg-level stats is working for slab pages. We can't use
> mod_lruvec_page_state() helpers anymore, so switch over to
> mod_lruvec_state().
>
> * I used the following simple approach to test the performance
> (stolen from another patchset by T. Harding):
>
> time find / -name fname-no-exist
> echo 2 > /proc/sys/vm/drop_caches
> repeat several times
>
> Results (I've chosen best results in several runs):
>
> orig patched
>
> real0m0.712s 0m0.690s
> user0m0.104s 0m0.101s
> sys 0m0.346s 0m0.340s
>
> real0m0.728s 0m0.723s
> user0m0.114s 0m0.115s
> sys 0m0.342s 0m0.338s
>
> real0m0.685s 0m0.767s
> user0m0.118s 0m0.114s
> sys 0m0.343s 0m0.336s
>
> So it looks like the difference is not noticeable in this test.
>
> Signed-off-by: Roman Gushchin
> ---
> include/linux/slab.h | 2 +-
> mm/memcontrol.c | 9
> mm/slab.c| 15 +---
> mm/slab.h| 54 +---
> mm/slab_common.c | 51 +
> mm/slub.c| 22 +-
> 6 files changed, 79 insertions(+), 74 deletions(-)
>
> diff --git a/include/linux/slab.h b/include/linux/slab.h
> index 47923c173f30..4daaade76c63 100644
> --- a/include/linux/slab.h
> +++ b/include/linux/slab.h
> @@ -152,7 +152,6 @@ int kmem_cache_shrink(struct kmem_cache *);
>
> void memcg_create_kmem_cache(struct mem_cgroup *, struct kmem_cache *);
> void memcg_deactivate_kmem_caches(struct mem_cgroup *);
> -void memcg_destroy_kmem_caches(struct mem_cgroup *);
>
> /*
> * Please use this macro to create slab caches. Simply specify the
> @@ -641,6 +640,7 @@ struct memcg_cache_params {
> struct mem_cgroup *memcg;
> struct list_head children_node;
> struct list_head kmem_caches_node;
> + atomic_long_t refcnt;
>
> void (*work_fn)(struct kmem_cache *);
> union {
> diff --git a/mm/memcontrol.c b/mm/memcontrol.c
> index b2c39f187cbb..87c06e342e05 100644
> --- a/mm/memcontrol.c
> +++ b/mm/memcontrol.c
> @@ -2719,9 +2719,6 @@ int __memcg_kmem_charge_memcg(struct page *page, gfp_t
> gfp, int order,
> cancel_charge(memcg, nr_pages);
> return -ENOMEM;
> }
> -
> - page->mem_cgroup = memcg;
> -
> return 0;
> }
>
> @@ -2744,8 +2741,10 @@ int __memcg_kmem_charge(struct page *page, gfp_t gfp,
> int order)
> memcg = get_mem_cgroup_from_current();
> if (!mem_cgroup_is_root(memcg)) {
> ret = __memcg_kmem_charge_memcg(page, gfp, order, memcg);
> - if (!ret)
> + if (!ret) {
> + page->mem_cgroup = memcg;
> __SetPageKmemcg(page);
> + }
> }
> css_put(>css);
> return ret;
> @@ -3238,7 +3237,7 @@
