On Mon 24-06-24 17:58:54, Roman Gushchin wrote: > Soft limits are cgroup v1-specific and are not supported by cgroup v2, > so let's move the corresponding code into memcontrol-v1.c. > > Aside from simple moving the code, this commits introduces a trivial > memcg1_soft_limit_reset() function to reset soft limits and also > moves the global soft limit tree initialization code into a new > memcg1_init() function. > > It also moves corresponding declarations shared between memcontrol.c > and memcontrol-v1.c into mm/memcontrol-v1.h. > > Signed-off-by: Roman Gushchin <roman.gushchin@xxxxxxxxx> I haven't done line for line check here and in other patches that move a lot of code. I like you have separated the renaming into its own patch because this makes review just easier. Acked-by: Michal Hocko <mhocko@xxxxxxxx> > --- > mm/memcontrol-v1.c | 342 +++++++++++++++++++++++++++++++++++++++++++++ > mm/memcontrol-v1.h | 7 + > mm/memcontrol.c | 337 +------------------------------------------- > 3 files changed, 353 insertions(+), 333 deletions(-) > > diff --git a/mm/memcontrol-v1.c b/mm/memcontrol-v1.c > index a941446ba575..2ccb8406fa84 100644 > --- a/mm/memcontrol-v1.c > +++ b/mm/memcontrol-v1.c > @@ -1,3 +1,345 @@ > // SPDX-License-Identifier: GPL-2.0-or-later > > +#include <linux/memcontrol.h> > +#include <linux/swap.h> > +#include <linux/mm_inline.h> > + > #include "memcontrol-v1.h" > + > +/* > + * Cgroups above their limits are maintained in a RB-Tree, independent of > + * their hierarchy representation > + */ > + > +struct mem_cgroup_tree_per_node { > + struct rb_root rb_root; > + struct rb_node *rb_rightmost; > + spinlock_t lock; > +}; > + > +struct mem_cgroup_tree { > + struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES]; > +}; > + > +static struct mem_cgroup_tree soft_limit_tree __read_mostly; > + > +/* > + * Maximum loops in mem_cgroup_soft_reclaim(), used for soft > + * limit reclaim to prevent infinite loops, if they ever occur. > + */ > +#define MEM_CGROUP_MAX_RECLAIM_LOOPS 100 > +#define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2 > + > +static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz, > + struct mem_cgroup_tree_per_node *mctz, > + unsigned long new_usage_in_excess) > +{ > + struct rb_node **p = &mctz->rb_root.rb_node; > + struct rb_node *parent = NULL; > + struct mem_cgroup_per_node *mz_node; > + bool rightmost = true; > + > + if (mz->on_tree) > + return; > + > + mz->usage_in_excess = new_usage_in_excess; > + if (!mz->usage_in_excess) > + return; > + while (*p) { > + parent = *p; > + mz_node = rb_entry(parent, struct mem_cgroup_per_node, > + tree_node); > + if (mz->usage_in_excess < mz_node->usage_in_excess) { > + p = &(*p)->rb_left; > + rightmost = false; > + } else { > + p = &(*p)->rb_right; > + } > + } > + > + if (rightmost) > + mctz->rb_rightmost = &mz->tree_node; > + > + rb_link_node(&mz->tree_node, parent, p); > + rb_insert_color(&mz->tree_node, &mctz->rb_root); > + mz->on_tree = true; > +} > + > +static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz, > + struct mem_cgroup_tree_per_node *mctz) > +{ > + if (!mz->on_tree) > + return; > + > + if (&mz->tree_node == mctz->rb_rightmost) > + mctz->rb_rightmost = rb_prev(&mz->tree_node); > + > + rb_erase(&mz->tree_node, &mctz->rb_root); > + mz->on_tree = false; > +} > + > +static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz, > + struct mem_cgroup_tree_per_node *mctz) > +{ > + unsigned long flags; > + > + spin_lock_irqsave(&mctz->lock, flags); > + __mem_cgroup_remove_exceeded(mz, mctz); > + spin_unlock_irqrestore(&mctz->lock, flags); > +} > + > +static unsigned long soft_limit_excess(struct mem_cgroup *memcg) > +{ > + unsigned long nr_pages = page_counter_read(&memcg->memory); > + unsigned long soft_limit = READ_ONCE(memcg->soft_limit); > + unsigned long excess = 0; > + > + if (nr_pages > soft_limit) > + excess = nr_pages - soft_limit; > + > + return excess; > +} > + > +void mem_cgroup_update_tree(struct mem_cgroup *memcg, int nid) > +{ > + unsigned long excess; > + struct mem_cgroup_per_node *mz; > + struct mem_cgroup_tree_per_node *mctz; > + > + if (lru_gen_enabled()) { > + if (soft_limit_excess(memcg)) > + lru_gen_soft_reclaim(memcg, nid); > + return; > + } > + > + mctz = soft_limit_tree.rb_tree_per_node[nid]; > + if (!mctz) > + return; > + /* > + * Necessary to update all ancestors when hierarchy is used. > + * because their event counter is not touched. > + */ > + for (; memcg; memcg = parent_mem_cgroup(memcg)) { > + mz = memcg->nodeinfo[nid]; > + excess = soft_limit_excess(memcg); > + /* > + * We have to update the tree if mz is on RB-tree or > + * mem is over its softlimit. > + */ > + if (excess || mz->on_tree) { > + unsigned long flags; > + > + spin_lock_irqsave(&mctz->lock, flags); > + /* if on-tree, remove it */ > + if (mz->on_tree) > + __mem_cgroup_remove_exceeded(mz, mctz); > + /* > + * Insert again. mz->usage_in_excess will be updated. > + * If excess is 0, no tree ops. > + */ > + __mem_cgroup_insert_exceeded(mz, mctz, excess); > + spin_unlock_irqrestore(&mctz->lock, flags); > + } > + } > +} > + > +void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg) > +{ > + struct mem_cgroup_tree_per_node *mctz; > + struct mem_cgroup_per_node *mz; > + int nid; > + > + for_each_node(nid) { > + mz = memcg->nodeinfo[nid]; > + mctz = soft_limit_tree.rb_tree_per_node[nid]; > + if (mctz) > + mem_cgroup_remove_exceeded(mz, mctz); > + } > +} > + > +static struct mem_cgroup_per_node * > +__mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz) > +{ > + struct mem_cgroup_per_node *mz; > + > +retry: > + mz = NULL; > + if (!mctz->rb_rightmost) > + goto done; /* Nothing to reclaim from */ > + > + mz = rb_entry(mctz->rb_rightmost, > + struct mem_cgroup_per_node, tree_node); > + /* > + * Remove the node now but someone else can add it back, > + * we will to add it back at the end of reclaim to its correct > + * position in the tree. > + */ > + __mem_cgroup_remove_exceeded(mz, mctz); > + if (!soft_limit_excess(mz->memcg) || > + !css_tryget(&mz->memcg->css)) > + goto retry; > +done: > + return mz; > +} > + > +static struct mem_cgroup_per_node * > +mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz) > +{ > + struct mem_cgroup_per_node *mz; > + > + spin_lock_irq(&mctz->lock); > + mz = __mem_cgroup_largest_soft_limit_node(mctz); > + spin_unlock_irq(&mctz->lock); > + return mz; > +} > + > +static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg, > + pg_data_t *pgdat, > + gfp_t gfp_mask, > + unsigned long *total_scanned) > +{ > + struct mem_cgroup *victim = NULL; > + int total = 0; > + int loop = 0; > + unsigned long excess; > + unsigned long nr_scanned; > + struct mem_cgroup_reclaim_cookie reclaim = { > + .pgdat = pgdat, > + }; > + > + excess = soft_limit_excess(root_memcg); > + > + while (1) { > + victim = mem_cgroup_iter(root_memcg, victim, &reclaim); > + if (!victim) { > + loop++; > + if (loop >= 2) { > + /* > + * If we have not been able to reclaim > + * anything, it might because there are > + * no reclaimable pages under this hierarchy > + */ > + if (!total) > + break; > + /* > + * We want to do more targeted reclaim. > + * excess >> 2 is not to excessive so as to > + * reclaim too much, nor too less that we keep > + * coming back to reclaim from this cgroup > + */ > + if (total >= (excess >> 2) || > + (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS)) > + break; > + } > + continue; > + } > + total += mem_cgroup_shrink_node(victim, gfp_mask, false, > + pgdat, &nr_scanned); > + *total_scanned += nr_scanned; > + if (!soft_limit_excess(root_memcg)) > + break; > + } > + mem_cgroup_iter_break(root_memcg, victim); > + return total; > +} > + > +unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, > + gfp_t gfp_mask, > + unsigned long *total_scanned) > +{ > + unsigned long nr_reclaimed = 0; > + struct mem_cgroup_per_node *mz, *next_mz = NULL; > + unsigned long reclaimed; > + int loop = 0; > + struct mem_cgroup_tree_per_node *mctz; > + unsigned long excess; > + > + if (lru_gen_enabled()) > + return 0; > + > + if (order > 0) > + return 0; > + > + mctz = soft_limit_tree.rb_tree_per_node[pgdat->node_id]; > + > + /* > + * Do not even bother to check the largest node if the root > + * is empty. Do it lockless to prevent lock bouncing. Races > + * are acceptable as soft limit is best effort anyway. > + */ > + if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root)) > + return 0; > + > + /* > + * This loop can run a while, specially if mem_cgroup's continuously > + * keep exceeding their soft limit and putting the system under > + * pressure > + */ > + do { > + if (next_mz) > + mz = next_mz; > + else > + mz = mem_cgroup_largest_soft_limit_node(mctz); > + if (!mz) > + break; > + > + reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat, > + gfp_mask, total_scanned); > + nr_reclaimed += reclaimed; > + spin_lock_irq(&mctz->lock); > + > + /* > + * If we failed to reclaim anything from this memory cgroup > + * it is time to move on to the next cgroup > + */ > + next_mz = NULL; > + if (!reclaimed) > + next_mz = __mem_cgroup_largest_soft_limit_node(mctz); > + > + excess = soft_limit_excess(mz->memcg); > + /* > + * One school of thought says that we should not add > + * back the node to the tree if reclaim returns 0. > + * But our reclaim could return 0, simply because due > + * to priority we are exposing a smaller subset of > + * memory to reclaim from. Consider this as a longer > + * term TODO. > + */ > + /* If excess == 0, no tree ops */ > + __mem_cgroup_insert_exceeded(mz, mctz, excess); > + spin_unlock_irq(&mctz->lock); > + css_put(&mz->memcg->css); > + loop++; > + /* > + * Could not reclaim anything and there are no more > + * mem cgroups to try or we seem to be looping without > + * reclaiming anything. > + */ > + if (!nr_reclaimed && > + (next_mz == NULL || > + loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS)) > + break; > + } while (!nr_reclaimed); > + if (next_mz) > + css_put(&next_mz->memcg->css); > + return nr_reclaimed; > +} > + > +static int __init memcg1_init(void) > +{ > + int node; > + > + for_each_node(node) { > + struct mem_cgroup_tree_per_node *rtpn; > + > + rtpn = kzalloc_node(sizeof(*rtpn), GFP_KERNEL, node); > + > + rtpn->rb_root = RB_ROOT; > + rtpn->rb_rightmost = NULL; > + spin_lock_init(&rtpn->lock); > + soft_limit_tree.rb_tree_per_node[node] = rtpn; > + } > + > + return 0; > +} > +subsys_initcall(memcg1_init); > diff --git a/mm/memcontrol-v1.h b/mm/memcontrol-v1.h > index 7c5f094755ff..4da6fa561c6d 100644 > --- a/mm/memcontrol-v1.h > +++ b/mm/memcontrol-v1.h > @@ -3,5 +3,12 @@ > #ifndef __MM_MEMCONTROL_V1_H > #define __MM_MEMCONTROL_V1_H > > +void mem_cgroup_update_tree(struct mem_cgroup *memcg, int nid); > +void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg); > + > +static inline void memcg1_soft_limit_reset(struct mem_cgroup *memcg) > +{ > + WRITE_ONCE(memcg->soft_limit, PAGE_COUNTER_MAX); > +} > > #endif /* __MM_MEMCONTROL_V1_H */ > diff --git a/mm/memcontrol.c b/mm/memcontrol.c > index 974bd160838c..003e944f34ea 100644 > --- a/mm/memcontrol.c > +++ b/mm/memcontrol.c > @@ -72,6 +72,7 @@ > #include <net/ip.h> > #include "slab.h" > #include "swap.h" > +#include "memcontrol-v1.h" > > #include <linux/uaccess.h> > > @@ -108,23 +109,6 @@ static bool do_memsw_account(void) > #define THRESHOLDS_EVENTS_TARGET 128 > #define SOFTLIMIT_EVENTS_TARGET 1024 > > -/* > - * Cgroups above their limits are maintained in a RB-Tree, independent of > - * their hierarchy representation > - */ > - > -struct mem_cgroup_tree_per_node { > - struct rb_root rb_root; > - struct rb_node *rb_rightmost; > - spinlock_t lock; > -}; > - > -struct mem_cgroup_tree { > - struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES]; > -}; > - > -static struct mem_cgroup_tree soft_limit_tree __read_mostly; > - > /* for OOM */ > struct mem_cgroup_eventfd_list { > struct list_head list; > @@ -199,13 +183,6 @@ static struct move_charge_struct { > .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq), > }; > > -/* > - * Maximum loops in mem_cgroup_soft_reclaim(), used for soft > - * limit reclaim to prevent infinite loops, if they ever occur. > - */ > -#define MEM_CGROUP_MAX_RECLAIM_LOOPS 100 > -#define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2 > - > /* for encoding cft->private value on file */ > enum res_type { > _MEM, > @@ -413,169 +390,6 @@ ino_t page_cgroup_ino(struct page *page) > return ino; > } > > -static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz, > - struct mem_cgroup_tree_per_node *mctz, > - unsigned long new_usage_in_excess) > -{ > - struct rb_node **p = &mctz->rb_root.rb_node; > - struct rb_node *parent = NULL; > - struct mem_cgroup_per_node *mz_node; > - bool rightmost = true; > - > - if (mz->on_tree) > - return; > - > - mz->usage_in_excess = new_usage_in_excess; > - if (!mz->usage_in_excess) > - return; > - while (*p) { > - parent = *p; > - mz_node = rb_entry(parent, struct mem_cgroup_per_node, > - tree_node); > - if (mz->usage_in_excess < mz_node->usage_in_excess) { > - p = &(*p)->rb_left; > - rightmost = false; > - } else { > - p = &(*p)->rb_right; > - } > - } > - > - if (rightmost) > - mctz->rb_rightmost = &mz->tree_node; > - > - rb_link_node(&mz->tree_node, parent, p); > - rb_insert_color(&mz->tree_node, &mctz->rb_root); > - mz->on_tree = true; > -} > - > -static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz, > - struct mem_cgroup_tree_per_node *mctz) > -{ > - if (!mz->on_tree) > - return; > - > - if (&mz->tree_node == mctz->rb_rightmost) > - mctz->rb_rightmost = rb_prev(&mz->tree_node); > - > - rb_erase(&mz->tree_node, &mctz->rb_root); > - mz->on_tree = false; > -} > - > -static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz, > - struct mem_cgroup_tree_per_node *mctz) > -{ > - unsigned long flags; > - > - spin_lock_irqsave(&mctz->lock, flags); > - __mem_cgroup_remove_exceeded(mz, mctz); > - spin_unlock_irqrestore(&mctz->lock, flags); > -} > - > -static unsigned long soft_limit_excess(struct mem_cgroup *memcg) > -{ > - unsigned long nr_pages = page_counter_read(&memcg->memory); > - unsigned long soft_limit = READ_ONCE(memcg->soft_limit); > - unsigned long excess = 0; > - > - if (nr_pages > soft_limit) > - excess = nr_pages - soft_limit; > - > - return excess; > -} > - > -static void mem_cgroup_update_tree(struct mem_cgroup *memcg, int nid) > -{ > - unsigned long excess; > - struct mem_cgroup_per_node *mz; > - struct mem_cgroup_tree_per_node *mctz; > - > - if (lru_gen_enabled()) { > - if (soft_limit_excess(memcg)) > - lru_gen_soft_reclaim(memcg, nid); > - return; > - } > - > - mctz = soft_limit_tree.rb_tree_per_node[nid]; > - if (!mctz) > - return; > - /* > - * Necessary to update all ancestors when hierarchy is used. > - * because their event counter is not touched. > - */ > - for (; memcg; memcg = parent_mem_cgroup(memcg)) { > - mz = memcg->nodeinfo[nid]; > - excess = soft_limit_excess(memcg); > - /* > - * We have to update the tree if mz is on RB-tree or > - * mem is over its softlimit. > - */ > - if (excess || mz->on_tree) { > - unsigned long flags; > - > - spin_lock_irqsave(&mctz->lock, flags); > - /* if on-tree, remove it */ > - if (mz->on_tree) > - __mem_cgroup_remove_exceeded(mz, mctz); > - /* > - * Insert again. mz->usage_in_excess will be updated. > - * If excess is 0, no tree ops. > - */ > - __mem_cgroup_insert_exceeded(mz, mctz, excess); > - spin_unlock_irqrestore(&mctz->lock, flags); > - } > - } > -} > - > -static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg) > -{ > - struct mem_cgroup_tree_per_node *mctz; > - struct mem_cgroup_per_node *mz; > - int nid; > - > - for_each_node(nid) { > - mz = memcg->nodeinfo[nid]; > - mctz = soft_limit_tree.rb_tree_per_node[nid]; > - if (mctz) > - mem_cgroup_remove_exceeded(mz, mctz); > - } > -} > - > -static struct mem_cgroup_per_node * > -__mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz) > -{ > - struct mem_cgroup_per_node *mz; > - > -retry: > - mz = NULL; > - if (!mctz->rb_rightmost) > - goto done; /* Nothing to reclaim from */ > - > - mz = rb_entry(mctz->rb_rightmost, > - struct mem_cgroup_per_node, tree_node); > - /* > - * Remove the node now but someone else can add it back, > - * we will to add it back at the end of reclaim to its correct > - * position in the tree. > - */ > - __mem_cgroup_remove_exceeded(mz, mctz); > - if (!soft_limit_excess(mz->memcg) || > - !css_tryget(&mz->memcg->css)) > - goto retry; > -done: > - return mz; > -} > - > -static struct mem_cgroup_per_node * > -mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz) > -{ > - struct mem_cgroup_per_node *mz; > - > - spin_lock_irq(&mctz->lock); > - mz = __mem_cgroup_largest_soft_limit_node(mctz); > - spin_unlock_irq(&mctz->lock); > - return mz; > -} > - > /* Subset of node_stat_item for memcg stats */ > static const unsigned int memcg_node_stat_items[] = { > NR_INACTIVE_ANON, > @@ -1980,56 +1794,6 @@ static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask, > return ret; > } > > -static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg, > - pg_data_t *pgdat, > - gfp_t gfp_mask, > - unsigned long *total_scanned) > -{ > - struct mem_cgroup *victim = NULL; > - int total = 0; > - int loop = 0; > - unsigned long excess; > - unsigned long nr_scanned; > - struct mem_cgroup_reclaim_cookie reclaim = { > - .pgdat = pgdat, > - }; > - > - excess = soft_limit_excess(root_memcg); > - > - while (1) { > - victim = mem_cgroup_iter(root_memcg, victim, &reclaim); > - if (!victim) { > - loop++; > - if (loop >= 2) { > - /* > - * If we have not been able to reclaim > - * anything, it might because there are > - * no reclaimable pages under this hierarchy > - */ > - if (!total) > - break; > - /* > - * We want to do more targeted reclaim. > - * excess >> 2 is not to excessive so as to > - * reclaim too much, nor too less that we keep > - * coming back to reclaim from this cgroup > - */ > - if (total >= (excess >> 2) || > - (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS)) > - break; > - } > - continue; > - } > - total += mem_cgroup_shrink_node(victim, gfp_mask, false, > - pgdat, &nr_scanned); > - *total_scanned += nr_scanned; > - if (!soft_limit_excess(root_memcg)) > - break; > - } > - mem_cgroup_iter_break(root_memcg, victim); > - return total; > -} > - > #ifdef CONFIG_LOCKDEP > static struct lockdep_map memcg_oom_lock_dep_map = { > .name = "memcg_oom_lock", > @@ -3925,88 +3689,6 @@ static int mem_cgroup_resize_max(struct mem_cgroup *memcg, > return ret; > } > > -unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order, > - gfp_t gfp_mask, > - unsigned long *total_scanned) > -{ > - unsigned long nr_reclaimed = 0; > - struct mem_cgroup_per_node *mz, *next_mz = NULL; > - unsigned long reclaimed; > - int loop = 0; > - struct mem_cgroup_tree_per_node *mctz; > - unsigned long excess; > - > - if (lru_gen_enabled()) > - return 0; > - > - if (order > 0) > - return 0; > - > - mctz = soft_limit_tree.rb_tree_per_node[pgdat->node_id]; > - > - /* > - * Do not even bother to check the largest node if the root > - * is empty. Do it lockless to prevent lock bouncing. Races > - * are acceptable as soft limit is best effort anyway. > - */ > - if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root)) > - return 0; > - > - /* > - * This loop can run a while, specially if mem_cgroup's continuously > - * keep exceeding their soft limit and putting the system under > - * pressure > - */ > - do { > - if (next_mz) > - mz = next_mz; > - else > - mz = mem_cgroup_largest_soft_limit_node(mctz); > - if (!mz) > - break; > - > - reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat, > - gfp_mask, total_scanned); > - nr_reclaimed += reclaimed; > - spin_lock_irq(&mctz->lock); > - > - /* > - * If we failed to reclaim anything from this memory cgroup > - * it is time to move on to the next cgroup > - */ > - next_mz = NULL; > - if (!reclaimed) > - next_mz = __mem_cgroup_largest_soft_limit_node(mctz); > - > - excess = soft_limit_excess(mz->memcg); > - /* > - * One school of thought says that we should not add > - * back the node to the tree if reclaim returns 0. > - * But our reclaim could return 0, simply because due > - * to priority we are exposing a smaller subset of > - * memory to reclaim from. Consider this as a longer > - * term TODO. > - */ > - /* If excess == 0, no tree ops */ > - __mem_cgroup_insert_exceeded(mz, mctz, excess); > - spin_unlock_irq(&mctz->lock); > - css_put(&mz->memcg->css); > - loop++; > - /* > - * Could not reclaim anything and there are no more > - * mem cgroups to try or we seem to be looping without > - * reclaiming anything. > - */ > - if (!nr_reclaimed && > - (next_mz == NULL || > - loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS)) > - break; > - } while (!nr_reclaimed); > - if (next_mz) > - css_put(&next_mz->memcg->css); > - return nr_reclaimed; > -} > - > /* > * Reclaims as many pages from the given memcg as possible. > * > @@ -5784,7 +5466,7 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css) > return ERR_CAST(memcg); > > page_counter_set_high(&memcg->memory, PAGE_COUNTER_MAX); > - WRITE_ONCE(memcg->soft_limit, PAGE_COUNTER_MAX); > + memcg1_soft_limit_reset(memcg); > #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_ZSWAP) > memcg->zswap_max = PAGE_COUNTER_MAX; > WRITE_ONCE(memcg->zswap_writeback, > @@ -5957,7 +5639,7 @@ static void mem_cgroup_css_reset(struct cgroup_subsys_state *css) > page_counter_set_min(&memcg->memory, 0); > page_counter_set_low(&memcg->memory, 0); > page_counter_set_high(&memcg->memory, PAGE_COUNTER_MAX); > - WRITE_ONCE(memcg->soft_limit, PAGE_COUNTER_MAX); > + memcg1_soft_limit_reset(memcg); > page_counter_set_high(&memcg->swap, PAGE_COUNTER_MAX); > memcg_wb_domain_size_changed(memcg); > } > @@ -7984,7 +7666,7 @@ __setup("cgroup.memory=", cgroup_memory); > */ > static int __init mem_cgroup_init(void) > { > - int cpu, node; > + int cpu; > > /* > * Currently s32 type (can refer to struct batched_lruvec_stat) is > @@ -8001,17 +7683,6 @@ static int __init mem_cgroup_init(void) > INIT_WORK(&per_cpu_ptr(&memcg_stock, cpu)->work, > drain_local_stock); > > - for_each_node(node) { > - struct mem_cgroup_tree_per_node *rtpn; > - > - rtpn = kzalloc_node(sizeof(*rtpn), GFP_KERNEL, node); > - > - rtpn->rb_root = RB_ROOT; > - rtpn->rb_rightmost = NULL; > - spin_lock_init(&rtpn->lock); > - soft_limit_tree.rb_tree_per_node[node] = rtpn; > - } > - > return 0; > } > subsys_initcall(mem_cgroup_init); > -- > 2.45.2 -- Michal Hocko SUSE Labs