/* memcontrol.c - Memory Controller
   *
   * Copyright IBM Corporation, 2007
   * Author Balbir Singh <balbir@linux.vnet.ibm.com>
   *

   * Copyright 2007 OpenVZ SWsoft Inc
   * Author: Pavel Emelianov <xemul@openvz.org>
   *

   * Memory thresholds
   * Copyright (C) 2009 Nokia Corporation
   * Author: Kirill A. Shutemov
   *

   * Kernel Memory Controller
   * Copyright (C) 2012 Parallels Inc. and Google Inc.
   * Authors: Glauber Costa and Suleiman Souhlal
   *

   * Native page reclaim
   * Charge lifetime sanitation
   * Lockless page tracking & accounting
   * Unified hierarchy configuration model
   * Copyright (C) 2015 Red Hat, Inc., Johannes Weiner
   *

   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   */

  #include <linux/page_counter.h>

  #include <linux/memcontrol.h>
  #include <linux/cgroup.h>

  #include <linux/mm.h>

  #include <linux/hugetlb.h>

  #include <linux/pagemap.h>

  #include <linux/smp.h>

  #include <linux/page-flags.h>

  #include <linux/backing-dev.h>

  #include <linux/bit_spinlock.h>
  #include <linux/rcupdate.h>

  #include <linux/limits.h>

  #include <linux/export.h>

  #include <linux/mutex.h>

  #include <linux/rbtree.h>

  #include <linux/slab.h>

  #include <linux/swap.h>

  #include <linux/swapops.h>

  #include <linux/spinlock.h>

  #include <linux/eventfd.h>

  #include <linux/poll.h>

  #include <linux/sort.h>

  #include <linux/fs.h>

  #include <linux/seq_file.h>

  #include <linux/vmpressure.h>

  #include <linux/mm_inline.h>

  #include <linux/swap_cgroup.h>

  #include <linux/cpu.h>

  #include <linux/oom.h>

  #include <linux/lockdep.h>

  #include <linux/file.h>

  #include <linux/tracehook.h>

  #include "internal.h"

  #include <net/sock.h>

  #include <net/ip.h>

  #include "slab.h"

  #include <asm/uaccess.h>

  #include <trace/events/vmscan.h>

  struct cgroup_subsys memory_cgrp_subsys __read_mostly;
  EXPORT_SYMBOL(memory_cgrp_subsys);

  struct mem_cgroup *root_mem_cgroup __read_mostly;

  #define MEM_CGROUP_RECLAIM_RETRIES	5

  /* Socket memory accounting disabled? */
  static bool cgroup_memory_nosocket;

  /* Kernel memory accounting disabled? */
  static bool cgroup_memory_nokmem;

  /* Whether the swap controller is active */

  #ifdef CONFIG_MEMCG_SWAP

  int do_swap_account __read_mostly;

  #else

  #define do_swap_account		0

  #endif

  /* Whether legacy memory+swap accounting is active */
  static bool do_memsw_account(void)
  {
  	return !cgroup_subsys_on_dfl(memory_cgrp_subsys) && do_swap_account;
  }

  static const char * const mem_cgroup_stat_names[] = {
  	"cache",
  	"rss",

  	"rss_huge",

  	"mapped_file",

  	"dirty",

  	"writeback",

  	"swap",
  };

  static const char * const mem_cgroup_events_names[] = {
  	"pgpgin",
  	"pgpgout",
  	"pgfault",
  	"pgmajfault",
  };

  static const char * const mem_cgroup_lru_names[] = {
  	"inactive_anon",
  	"active_anon",
  	"inactive_file",
  	"active_file",
  	"unevictable",
  };

  #define THRESHOLDS_EVENTS_TARGET 128
  #define SOFTLIMIT_EVENTS_TARGET 1024
  #define NUMAINFO_EVENTS_TARGET	1024

  /*
   * Cgroups above their limits are maintained in a RB-Tree, independent of
   * their hierarchy representation
   */
  
  struct mem_cgroup_tree_per_zone {
  	struct rb_root rb_root;
  	spinlock_t lock;
  };
  
  struct mem_cgroup_tree_per_node {
  	struct mem_cgroup_tree_per_zone rb_tree_per_zone[MAX_NR_ZONES];
  };
  
  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;
  	struct eventfd_ctx *eventfd;
  };

  /*
   * cgroup_event represents events which userspace want to receive.
   */

  struct mem_cgroup_event {

  	/*

  	 * memcg which the event belongs to.

  	 */

  	struct mem_cgroup *memcg;

  	/*

  	 * eventfd to signal userspace about the event.
  	 */
  	struct eventfd_ctx *eventfd;
  	/*
  	 * Each of these stored in a list by the cgroup.
  	 */
  	struct list_head list;
  	/*

  	 * register_event() callback will be used to add new userspace
  	 * waiter for changes related to this event.  Use eventfd_signal()
  	 * on eventfd to send notification to userspace.
  	 */

  	int (*register_event)(struct mem_cgroup *memcg,

  			      struct eventfd_ctx *eventfd, const char *args);

  	/*
  	 * unregister_event() callback will be called when userspace closes
  	 * the eventfd or on cgroup removing.  This callback must be set,
  	 * if you want provide notification functionality.
  	 */

  	void (*unregister_event)(struct mem_cgroup *memcg,

  				 struct eventfd_ctx *eventfd);
  	/*

  	 * All fields below needed to unregister event when
  	 * userspace closes eventfd.
  	 */
  	poll_table pt;
  	wait_queue_head_t *wqh;
  	wait_queue_t wait;
  	struct work_struct remove;
  };

  static void mem_cgroup_threshold(struct mem_cgroup *memcg);
  static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);

  /* Stuffs for move charges at task migration. */
  /*

   * Types of charges to be moved.

   */

  #define MOVE_ANON	0x1U
  #define MOVE_FILE	0x2U
  #define MOVE_MASK	(MOVE_ANON | MOVE_FILE)

  /* "mc" and its members are protected by cgroup_mutex */
  static struct move_charge_struct {

  	spinlock_t	  lock; /* for from, to */

  	struct mm_struct  *mm;

  	struct mem_cgroup *from;
  	struct mem_cgroup *to;

  	unsigned long flags;

  	unsigned long precharge;

  	unsigned long moved_charge;

  	unsigned long moved_swap;

  	struct task_struct *moving_task;	/* a task moving charges */
  	wait_queue_head_t waitq;		/* a waitq for other context */
  } mc = {

  	.lock = __SPIN_LOCK_UNLOCKED(mc.lock),

  	.waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
  };

  /*
   * Maximum loops in mem_cgroup_hierarchical_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

  enum charge_type {
  	MEM_CGROUP_CHARGE_TYPE_CACHE = 0,

  	MEM_CGROUP_CHARGE_TYPE_ANON,

  	MEM_CGROUP_CHARGE_TYPE_SWAPOUT,	/* for accounting swapcache */

  	MEM_CGROUP_CHARGE_TYPE_DROP,	/* a page was unused swap cache */

  	NR_CHARGE_TYPE,
  };

  /* for encoding cft->private value on file */

  enum res_type {
  	_MEM,
  	_MEMSWAP,
  	_OOM_TYPE,

  	_KMEM,

  	_TCP,

  };

  #define MEMFILE_PRIVATE(x, val)	((x) << 16 | (val))
  #define MEMFILE_TYPE(val)	((val) >> 16 & 0xffff)

  #define MEMFILE_ATTR(val)	((val) & 0xffff)

  /* Used for OOM nofiier */
  #define OOM_CONTROL		(0)

  /* Some nice accessors for the vmpressure. */
  struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
  {
  	if (!memcg)
  		memcg = root_mem_cgroup;
  	return &memcg->vmpressure;
  }
  
  struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
  {
  	return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
  }

  static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
  {
  	return (memcg == root_mem_cgroup);
  }

  #ifndef CONFIG_SLOB

  /*

   * This will be the memcg's index in each cache's ->memcg_params.memcg_caches.

   * The main reason for not using cgroup id for this:
   *  this works better in sparse environments, where we have a lot of memcgs,
   *  but only a few kmem-limited. Or also, if we have, for instance, 200
   *  memcgs, and none but the 200th is kmem-limited, we'd have to have a
   *  200 entry array for that.

   *

   * The current size of the caches array is stored in memcg_nr_cache_ids. It
   * will double each time we have to increase it.

   */

  static DEFINE_IDA(memcg_cache_ida);
  int memcg_nr_cache_ids;

  /* Protects memcg_nr_cache_ids */
  static DECLARE_RWSEM(memcg_cache_ids_sem);
  
  void memcg_get_cache_ids(void)
  {
  	down_read(&memcg_cache_ids_sem);
  }
  
  void memcg_put_cache_ids(void)
  {
  	up_read(&memcg_cache_ids_sem);
  }

  /*
   * MIN_SIZE is different than 1, because we would like to avoid going through
   * the alloc/free process all the time. In a small machine, 4 kmem-limited
   * cgroups is a reasonable guess. In the future, it could be a parameter or
   * tunable, but that is strictly not necessary.
   *

   * MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get

   * this constant directly from cgroup, but it is understandable that this is
   * better kept as an internal representation in cgroup.c. In any case, the

   * cgrp_id space is not getting any smaller, and we don't have to necessarily

   * increase ours as well if it increases.
   */
  #define MEMCG_CACHES_MIN_SIZE 4

  #define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX

  /*
   * A lot of the calls to the cache allocation functions are expected to be
   * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
   * conditional to this static branch, we'll have to allow modules that does
   * kmem_cache_alloc and the such to see this symbol as well
   */

  DEFINE_STATIC_KEY_FALSE(memcg_kmem_enabled_key);

  EXPORT_SYMBOL(memcg_kmem_enabled_key);

  #endif /* !CONFIG_SLOB */

  static struct mem_cgroup_per_zone *

  mem_cgroup_zone_zoneinfo(struct mem_cgroup *memcg, struct zone *zone)

  {

  	int nid = zone_to_nid(zone);
  	int zid = zone_idx(zone);

  	return &memcg->nodeinfo[nid]->zoneinfo[zid];

  }

  /**
   * mem_cgroup_css_from_page - css of the memcg associated with a page
   * @page: page of interest
   *
   * If memcg is bound to the default hierarchy, css of the memcg associated
   * with @page is returned.  The returned css remains associated with @page
   * until it is released.
   *
   * If memcg is bound to a traditional hierarchy, the css of root_mem_cgroup
   * is returned.

   */
  struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
  {
  	struct mem_cgroup *memcg;

  	memcg = page->mem_cgroup;

  	if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))

  		memcg = root_mem_cgroup;

  	return &memcg->css;
  }

  /**
   * page_cgroup_ino - return inode number of the memcg a page is charged to
   * @page: the page
   *
   * Look up the closest online ancestor of the memory cgroup @page is charged to
   * and return its inode number or 0 if @page is not charged to any cgroup. It
   * is safe to call this function without holding a reference to @page.
   *
   * Note, this function is inherently racy, because there is nothing to prevent
   * the cgroup inode from getting torn down and potentially reallocated a moment
   * after page_cgroup_ino() returns, so it only should be used by callers that
   * do not care (such as procfs interfaces).
   */
  ino_t page_cgroup_ino(struct page *page)
  {
  	struct mem_cgroup *memcg;
  	unsigned long ino = 0;
  
  	rcu_read_lock();
  	memcg = READ_ONCE(page->mem_cgroup);
  	while (memcg && !(memcg->css.flags & CSS_ONLINE))
  		memcg = parent_mem_cgroup(memcg);
  	if (memcg)
  		ino = cgroup_ino(memcg->css.cgroup);
  	rcu_read_unlock();
  	return ino;
  }

  static struct mem_cgroup_per_zone *

  mem_cgroup_page_zoneinfo(struct mem_cgroup *memcg, struct page *page)

  {

  	int nid = page_to_nid(page);
  	int zid = page_zonenum(page);

  	return &memcg->nodeinfo[nid]->zoneinfo[zid];

  }

  static struct mem_cgroup_tree_per_zone *
  soft_limit_tree_node_zone(int nid, int zid)
  {
  	return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
  }
  
  static struct mem_cgroup_tree_per_zone *
  soft_limit_tree_from_page(struct page *page)
  {
  	int nid = page_to_nid(page);
  	int zid = page_zonenum(page);
  
  	return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
  }

  static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_zone *mz,
  					 struct mem_cgroup_tree_per_zone *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_zone *mz_node;
  
  	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_zone,
  					tree_node);
  		if (mz->usage_in_excess < mz_node->usage_in_excess)
  			p = &(*p)->rb_left;
  		/*
  		 * We can't avoid mem cgroups that are over their soft
  		 * limit by the same amount
  		 */
  		else if (mz->usage_in_excess >= mz_node->usage_in_excess)
  			p = &(*p)->rb_right;
  	}
  	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_zone *mz,
  					 struct mem_cgroup_tree_per_zone *mctz)

  {
  	if (!mz->on_tree)
  		return;
  	rb_erase(&mz->tree_node, &mctz->rb_root);
  	mz->on_tree = false;
  }

  static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
  				       struct mem_cgroup_tree_per_zone *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, struct page *page)
  {

  	unsigned long excess;

  	struct mem_cgroup_per_zone *mz;
  	struct mem_cgroup_tree_per_zone *mctz;

  	mctz = soft_limit_tree_from_page(page);

  	/*
  	 * Necessary to update all ancestors when hierarchy is used.
  	 * because their event counter is not touched.
  	 */
  	for (; memcg; memcg = parent_mem_cgroup(memcg)) {

  		mz = mem_cgroup_page_zoneinfo(memcg, page);

  		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_zone *mctz;

  	struct mem_cgroup_per_zone *mz;
  	int nid, zid;

  	for_each_node(nid) {
  		for (zid = 0; zid < MAX_NR_ZONES; zid++) {
  			mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
  			mctz = soft_limit_tree_node_zone(nid, zid);

  			mem_cgroup_remove_exceeded(mz, mctz);

  		}
  	}
  }
  
  static struct mem_cgroup_per_zone *
  __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
  {
  	struct rb_node *rightmost = NULL;
  	struct mem_cgroup_per_zone *mz;
  
  retry:
  	mz = NULL;
  	rightmost = rb_last(&mctz->rb_root);
  	if (!rightmost)
  		goto done;		/* Nothing to reclaim from */
  
  	mz = rb_entry(rightmost, struct mem_cgroup_per_zone, 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_online(&mz->memcg->css))

  		goto retry;
  done:
  	return mz;
  }
  
  static struct mem_cgroup_per_zone *
  mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
  {
  	struct mem_cgroup_per_zone *mz;

  	spin_lock_irq(&mctz->lock);

  	mz = __mem_cgroup_largest_soft_limit_node(mctz);

  	spin_unlock_irq(&mctz->lock);

  	return mz;
  }

  /*

   * Return page count for single (non recursive) @memcg.
   *

   * Implementation Note: reading percpu statistics for memcg.
   *
   * Both of vmstat[] and percpu_counter has threshold and do periodic
   * synchronization to implement "quick" read. There are trade-off between
   * reading cost and precision of value. Then, we may have a chance to implement

   * a periodic synchronization of counter in memcg's counter.

   *
   * But this _read() function is used for user interface now. The user accounts
   * memory usage by memory cgroup and he _always_ requires exact value because
   * he accounts memory. Even if we provide quick-and-fuzzy read, we always
   * have to visit all online cpus and make sum. So, for now, unnecessary
   * synchronization is not implemented. (just implemented for cpu hotplug)
   *
   * If there are kernel internal actions which can make use of some not-exact
   * value, and reading all cpu value can be performance bottleneck in some

   * common workload, threshold and synchronization as vmstat[] should be

   * implemented.
   */

  static unsigned long
  mem_cgroup_read_stat(struct mem_cgroup *memcg, enum mem_cgroup_stat_index idx)

  {

  	long val = 0;

  	int cpu;

  	/* Per-cpu values can be negative, use a signed accumulator */

  	for_each_possible_cpu(cpu)

  		val += per_cpu(memcg->stat->count[idx], cpu);

  	/*
  	 * Summing races with updates, so val may be negative.  Avoid exposing
  	 * transient negative values.
  	 */
  	if (val < 0)
  		val = 0;

  	return val;
  }

  static unsigned long mem_cgroup_read_events(struct mem_cgroup *memcg,

  					    enum mem_cgroup_events_index idx)
  {
  	unsigned long val = 0;
  	int cpu;

  	for_each_possible_cpu(cpu)

  		val += per_cpu(memcg->stat->events[idx], cpu);

  	return val;
  }

  static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,

  					 struct page *page,

  					 bool compound, int nr_pages)

  {

  	/*
  	 * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
  	 * counted as CACHE even if it's on ANON LRU.
  	 */

  	if (PageAnon(page))

  		__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],

  				nr_pages);

  	else

  		__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_CACHE],

  				nr_pages);

  	if (compound) {
  		VM_BUG_ON_PAGE(!PageTransHuge(page), page);

  		__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
  				nr_pages);

  	}

  	/* pagein of a big page is an event. So, ignore page size */
  	if (nr_pages > 0)

  		__this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGIN]);

  	else {

  		__this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT]);

  		nr_pages = -nr_pages; /* for event */
  	}

  	__this_cpu_add(memcg->stat->nr_page_events, nr_pages);

  }

  unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
  					   int nid, unsigned int lru_mask)

  {

  	unsigned long nr = 0;

  	int zid;

  	VM_BUG_ON((unsigned)nid >= nr_node_ids);

  	for (zid = 0; zid < MAX_NR_ZONES; zid++) {
  		struct mem_cgroup_per_zone *mz;
  		enum lru_list lru;
  
  		for_each_lru(lru) {
  			if (!(BIT(lru) & lru_mask))
  				continue;
  			mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
  			nr += mz->lru_size[lru];
  		}
  	}
  	return nr;

  }

  static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,

  			unsigned int lru_mask)

  {

  	unsigned long nr = 0;

  	int nid;

  	for_each_node_state(nid, N_MEMORY)

  		nr += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
  	return nr;

  }

  static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
  				       enum mem_cgroup_events_target target)

  {
  	unsigned long val, next;

  	val = __this_cpu_read(memcg->stat->nr_page_events);

  	next = __this_cpu_read(memcg->stat->targets[target]);

  	/* from time_after() in jiffies.h */

  	if ((long)next - (long)val < 0) {
  		switch (target) {
  		case MEM_CGROUP_TARGET_THRESH:
  			next = val + THRESHOLDS_EVENTS_TARGET;
  			break;

  		case MEM_CGROUP_TARGET_SOFTLIMIT:
  			next = val + SOFTLIMIT_EVENTS_TARGET;
  			break;

  		case MEM_CGROUP_TARGET_NUMAINFO:
  			next = val + NUMAINFO_EVENTS_TARGET;
  			break;
  		default:
  			break;
  		}
  		__this_cpu_write(memcg->stat->targets[target], next);
  		return true;

  	}

  	return false;

  }
  
  /*
   * Check events in order.
   *
   */

  static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)

  {
  	/* threshold event is triggered in finer grain than soft limit */

  	if (unlikely(mem_cgroup_event_ratelimit(memcg,
  						MEM_CGROUP_TARGET_THRESH))) {

  		bool do_softlimit;

  		bool do_numainfo __maybe_unused;

  		do_softlimit = mem_cgroup_event_ratelimit(memcg,
  						MEM_CGROUP_TARGET_SOFTLIMIT);

  #if MAX_NUMNODES > 1
  		do_numainfo = mem_cgroup_event_ratelimit(memcg,
  						MEM_CGROUP_TARGET_NUMAINFO);
  #endif

  		mem_cgroup_threshold(memcg);

  		if (unlikely(do_softlimit))
  			mem_cgroup_update_tree(memcg, page);

  #if MAX_NUMNODES > 1

  		if (unlikely(do_numainfo))

  			atomic_inc(&memcg->numainfo_events);

  #endif

  	}

  }

  struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)

  {

  	/*
  	 * mm_update_next_owner() may clear mm->owner to NULL
  	 * if it races with swapoff, page migration, etc.
  	 * So this can be called with p == NULL.
  	 */
  	if (unlikely(!p))
  		return NULL;

  	return mem_cgroup_from_css(task_css(p, memory_cgrp_id));

  }

  EXPORT_SYMBOL(mem_cgroup_from_task);

  static struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)

  {

  	struct mem_cgroup *memcg = NULL;

  	rcu_read_lock();
  	do {

  		/*
  		 * Page cache insertions can happen withou an
  		 * actual mm context, e.g. during disk probing
  		 * on boot, loopback IO, acct() writes etc.
  		 */
  		if (unlikely(!mm))

  			memcg = root_mem_cgroup;

  		else {
  			memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
  			if (unlikely(!memcg))
  				memcg = root_mem_cgroup;
  		}

  	} while (!css_tryget_online(&memcg->css));

  	rcu_read_unlock();

  	return memcg;

  }

  /**
   * mem_cgroup_iter - iterate over memory cgroup hierarchy
   * @root: hierarchy root
   * @prev: previously returned memcg, NULL on first invocation
   * @reclaim: cookie for shared reclaim walks, NULL for full walks
   *
   * Returns references to children of the hierarchy below @root, or
   * @root itself, or %NULL after a full round-trip.
   *
   * Caller must pass the return value in @prev on subsequent
   * invocations for reference counting, or use mem_cgroup_iter_break()
   * to cancel a hierarchy walk before the round-trip is complete.
   *
   * Reclaimers can specify a zone and a priority level in @reclaim to
   * divide up the memcgs in the hierarchy among all concurrent
   * reclaimers operating on the same zone and priority.
   */

  struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,

  				   struct mem_cgroup *prev,

  				   struct mem_cgroup_reclaim_cookie *reclaim)

  {

  	struct mem_cgroup_reclaim_iter *uninitialized_var(iter);

  	struct cgroup_subsys_state *css = NULL;

  	struct mem_cgroup *memcg = NULL;

  	struct mem_cgroup *pos = NULL;

  	if (mem_cgroup_disabled())
  		return NULL;

  	if (!root)
  		root = root_mem_cgroup;

  	if (prev && !reclaim)

  		pos = prev;

  	if (!root->use_hierarchy && root != root_mem_cgroup) {
  		if (prev)

  			goto out;

  		return root;

  	}

  	rcu_read_lock();

  	if (reclaim) {
  		struct mem_cgroup_per_zone *mz;
  
  		mz = mem_cgroup_zone_zoneinfo(root, reclaim->zone);
  		iter = &mz->iter[reclaim->priority];
  
  		if (prev && reclaim->generation != iter->generation)
  			goto out_unlock;

  		while (1) {

  			pos = READ_ONCE(iter->position);

  			if (!pos || css_tryget(&pos->css))
  				break;

  			/*

  			 * css reference reached zero, so iter->position will
  			 * be cleared by ->css_released. However, we should not
  			 * rely on this happening soon, because ->css_released
  			 * is called from a work queue, and by busy-waiting we
  			 * might block it. So we clear iter->position right
  			 * away.

  			 */

  			(void)cmpxchg(&iter->position, pos, NULL);
  		}

  	}
  
  	if (pos)
  		css = &pos->css;
  
  	for (;;) {
  		css = css_next_descendant_pre(css, &root->css);
  		if (!css) {
  			/*
  			 * Reclaimers share the hierarchy walk, and a
  			 * new one might jump in right at the end of
  			 * the hierarchy - make sure they see at least
  			 * one group and restart from the beginning.
  			 */
  			if (!prev)
  				continue;
  			break;

  		}

  		/*
  		 * Verify the css and acquire a reference.  The root
  		 * is provided by the caller, so we know it's alive
  		 * and kicking, and don't take an extra reference.
  		 */
  		memcg = mem_cgroup_from_css(css);

  		if (css == &root->css)
  			break;

  		if (css_tryget(css))
  			break;

  		memcg = NULL;

  	}

  
  	if (reclaim) {

  		/*

  		 * The position could have already been updated by a competing
  		 * thread, so check that the value hasn't changed since we read
  		 * it to avoid reclaiming from the same cgroup twice.

  		 */

  		(void)cmpxchg(&iter->position, pos, memcg);

  		if (pos)
  			css_put(&pos->css);
  
  		if (!memcg)
  			iter->generation++;
  		else if (!prev)
  			reclaim->generation = iter->generation;

  	}

  out_unlock:
  	rcu_read_unlock();

  out:

  	if (prev && prev != root)
  		css_put(&prev->css);

  	return memcg;

  }

  /**
   * mem_cgroup_iter_break - abort a hierarchy walk prematurely
   * @root: hierarchy root
   * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
   */
  void mem_cgroup_iter_break(struct mem_cgroup *root,
  			   struct mem_cgroup *prev)

  {
  	if (!root)
  		root = root_mem_cgroup;
  	if (prev && prev != root)
  		css_put(&prev->css);
  }

  static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
  {
  	struct mem_cgroup *memcg = dead_memcg;
  	struct mem_cgroup_reclaim_iter *iter;
  	struct mem_cgroup_per_zone *mz;
  	int nid, zid;
  	int i;
  
  	while ((memcg = parent_mem_cgroup(memcg))) {
  		for_each_node(nid) {
  			for (zid = 0; zid < MAX_NR_ZONES; zid++) {
  				mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
  				for (i = 0; i <= DEF_PRIORITY; i++) {
  					iter = &mz->iter[i];
  					cmpxchg(&iter->position,
  						dead_memcg, NULL);
  				}
  			}
  		}
  	}
  }

  /*
   * Iteration constructs for visiting all cgroups (under a tree).  If
   * loops are exited prematurely (break), mem_cgroup_iter_break() must
   * be used for reference counting.
   */
  #define for_each_mem_cgroup_tree(iter, root)		\

  	for (iter = mem_cgroup_iter(root, NULL, NULL);	\

  	     iter != NULL;				\

  	     iter = mem_cgroup_iter(root, iter, NULL))

  #define for_each_mem_cgroup(iter)			\

  	for (iter = mem_cgroup_iter(NULL, NULL, NULL);	\

  	     iter != NULL;				\

  	     iter = mem_cgroup_iter(NULL, iter, NULL))

  /**
   * mem_cgroup_zone_lruvec - get the lru list vector for a zone and memcg
   * @zone: zone of the wanted lruvec

   * @memcg: memcg of the wanted lruvec

   *
   * Returns the lru list vector holding pages for the given @zone and
   * @mem.  This can be the global zone lruvec, if the memory controller
   * is disabled.
   */
  struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
  				      struct mem_cgroup *memcg)
  {
  	struct mem_cgroup_per_zone *mz;

  	struct lruvec *lruvec;

  	if (mem_cgroup_disabled()) {
  		lruvec = &zone->lruvec;
  		goto out;
  	}

  	mz = mem_cgroup_zone_zoneinfo(memcg, zone);

  	lruvec = &mz->lruvec;
  out:
  	/*
  	 * Since a node can be onlined after the mem_cgroup was created,
  	 * we have to be prepared to initialize lruvec->zone here;
  	 * and if offlined then reonlined, we need to reinitialize it.
  	 */
  	if (unlikely(lruvec->zone != zone))
  		lruvec->zone = zone;
  	return lruvec;

  }

  /**

   * mem_cgroup_page_lruvec - return lruvec for isolating/putting an LRU page

   * @page: the page

   * @zone: zone of the page

   *
   * This function is only safe when following the LRU page isolation
   * and putback protocol: the LRU lock must be held, and the page must
   * either be PageLRU() or the caller must have isolated/allocated it.

   */

  struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)

  {

  	struct mem_cgroup_per_zone *mz;

  	struct mem_cgroup *memcg;

  	struct lruvec *lruvec;

  	if (mem_cgroup_disabled()) {
  		lruvec = &zone->lruvec;
  		goto out;
  	}

  	memcg = page->mem_cgroup;

  	/*

  	 * Swapcache readahead pages are added to the LRU - and

  	 * possibly migrated - before they are charged.

  	 */

  	if (!memcg)
  		memcg = root_mem_cgroup;

  	mz = mem_cgroup_page_zoneinfo(memcg, page);

  	lruvec = &mz->lruvec;
  out:
  	/*
  	 * Since a node can be onlined after the mem_cgroup was created,
  	 * we have to be prepared to initialize lruvec->zone here;
  	 * and if offlined then reonlined, we need to reinitialize it.
  	 */
  	if (unlikely(lruvec->zone != zone))
  		lruvec->zone = zone;
  	return lruvec;

  }

  /**

   * mem_cgroup_update_lru_size - account for adding or removing an lru page
   * @lruvec: mem_cgroup per zone lru vector
   * @lru: index of lru list the page is sitting on
   * @nr_pages: positive when adding or negative when removing

   *

   * This function must be called under lru_lock, just before a page is added
   * to or just after a page is removed from an lru list (that ordering being
   * so as to allow it to check that lru_size 0 is consistent with list_empty).

   */

  void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
  				int nr_pages)

  {
  	struct mem_cgroup_per_zone *mz;

  	unsigned long *lru_size;

  	long size;
  	bool empty;

  	__update_lru_size(lruvec, lru, nr_pages);

  	if (mem_cgroup_disabled())
  		return;

  	mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
  	lru_size = mz->lru_size + lru;

  	empty = list_empty(lruvec->lists + lru);
  
  	if (nr_pages < 0)
  		*lru_size += nr_pages;
  
  	size = *lru_size;
  	if (WARN_ONCE(size < 0 || empty != !size,
  		"%s(%p, %d, %d): lru_size %ld but %sempty
  ",
  		__func__, lruvec, lru, nr_pages, size, empty ? "" : "not ")) {
  		VM_BUG_ON(1);
  		*lru_size = 0;
  	}
  
  	if (nr_pages > 0)
  		*lru_size += nr_pages;

  }

  bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg)

  {

  	struct mem_cgroup *task_memcg;

  	struct task_struct *p;

  	bool ret;

  	p = find_lock_task_mm(task);

  	if (p) {

  		task_memcg = get_mem_cgroup_from_mm(p->mm);

  		task_unlock(p);
  	} else {
  		/*
  		 * All threads may have already detached their mm's, but the oom
  		 * killer still needs to detect if they have already been oom
  		 * killed to prevent needlessly killing additional tasks.
  		 */

  		rcu_read_lock();

  		task_memcg = mem_cgroup_from_task(task);
  		css_get(&task_memcg->css);

  		rcu_read_unlock();

  	}

  	ret = mem_cgroup_is_descendant(task_memcg, memcg);
  	css_put(&task_memcg->css);

  	return ret;
  }

  /**

   * mem_cgroup_margin - calculate chargeable space of a memory cgroup

   * @memcg: the memory cgroup

   *

   * Returns the maximum amount of memory @mem can be charged with, in

   * pages.

   */

  static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)

  {

  	unsigned long margin = 0;
  	unsigned long count;
  	unsigned long limit;

  	count = page_counter_read(&memcg->memory);

  	limit = READ_ONCE(memcg->memory.limit);

  	if (count < limit)
  		margin = limit - count;

  	if (do_memsw_account()) {

  		count = page_counter_read(&memcg->memsw);

  		limit = READ_ONCE(memcg->memsw.limit);

  		if (count <= limit)
  			margin = min(margin, limit - count);
  	}
  
  	return margin;

  }

  /*

   * A routine for checking "mem" is under move_account() or not.

   *

   * Checking a cgroup is mc.from or mc.to or under hierarchy of
   * moving cgroups. This is for waiting at high-memory pressure
   * caused by "move".

   */

  static bool mem_cgroup_under_move(struct mem_cgroup *memcg)

  {

  	struct mem_cgroup *from;
  	struct mem_cgroup *to;

  	bool ret = false;

  	/*
  	 * Unlike task_move routines, we access mc.to, mc.from not under
  	 * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
  	 */
  	spin_lock(&mc.lock);
  	from = mc.from;
  	to = mc.to;
  	if (!from)
  		goto unlock;

  	ret = mem_cgroup_is_descendant(from, memcg) ||
  		mem_cgroup_is_descendant(to, memcg);

  unlock:
  	spin_unlock(&mc.lock);

  	return ret;
  }

  static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)

  {
  	if (mc.moving_task && current != mc.moving_task) {

  		if (mem_cgroup_under_move(memcg)) {

  			DEFINE_WAIT(wait);
  			prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
  			/* moving charge context might have finished. */
  			if (mc.moving_task)
  				schedule();
  			finish_wait(&mc.waitq, &wait);
  			return true;
  		}
  	}
  	return false;
  }

  #define K(x) ((x) << (PAGE_SHIFT-10))

  /**

   * mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.

   * @memcg: The memory cgroup that went over limit
   * @p: Task that is going to be killed
   *
   * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
   * enabled
   */
  void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
  {

  	struct mem_cgroup *iter;
  	unsigned int i;

  	rcu_read_lock();

  	if (p) {
  		pr_info("Task in ");
  		pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
  		pr_cont(" killed as a result of limit of ");
  	} else {
  		pr_info("Memory limit reached of cgroup ");
  	}

  	pr_cont_cgroup_path(memcg->css.cgroup);

  	pr_cont("
  ");

  	rcu_read_unlock();

  	pr_info("memory: usage %llukB, limit %llukB, failcnt %lu
  ",
  		K((u64)page_counter_read(&memcg->memory)),
  		K((u64)memcg->memory.limit), memcg->memory.failcnt);
  	pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu
  ",
  		K((u64)page_counter_read(&memcg->memsw)),
  		K((u64)memcg->memsw.limit), memcg->memsw.failcnt);
  	pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu
  ",
  		K((u64)page_counter_read(&memcg->kmem)),
  		K((u64)memcg->kmem.limit), memcg->kmem.failcnt);

  
  	for_each_mem_cgroup_tree(iter, memcg) {

  		pr_info("Memory cgroup stats for ");
  		pr_cont_cgroup_path(iter->css.cgroup);

  		pr_cont(":");
  
  		for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {

  			if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)

  				continue;

  			pr_cont(" %s:%luKB", mem_cgroup_stat_names[i],

  				K(mem_cgroup_read_stat(iter, i)));
  		}
  
  		for (i = 0; i < NR_LRU_LISTS; i++)
  			pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
  				K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
  
  		pr_cont("
  ");
  	}

  }

  /*
   * This function returns the number of memcg under hierarchy tree. Returns
   * 1(self count) if no children.
   */

  static int mem_cgroup_count_children(struct mem_cgroup *memcg)

  {
  	int num = 0;

  	struct mem_cgroup *iter;

  	for_each_mem_cgroup_tree(iter, memcg)

  		num++;

  	return num;
  }

  /*

   * Return the memory (and swap, if configured) limit for a memcg.
   */

  static unsigned long mem_cgroup_get_limit(struct mem_cgroup *memcg)

  {

  	unsigned long limit;

  	limit = memcg->memory.limit;

  	if (mem_cgroup_swappiness(memcg)) {

  		unsigned long memsw_limit;

  		unsigned long swap_limit;

  		memsw_limit = memcg->memsw.limit;

  		swap_limit = memcg->swap.limit;
  		swap_limit = min(swap_limit, (unsigned long)total_swap_pages);
  		limit = min(limit + swap_limit, memsw_limit);

  	}

  	return limit;

  }

  static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,

  				     int order)

  {

  	struct oom_control oc = {
  		.zonelist = NULL,
  		.nodemask = NULL,
  		.gfp_mask = gfp_mask,
  		.order = order,

  	};

  	struct mem_cgroup *iter;
  	unsigned long chosen_points = 0;
  	unsigned long totalpages;
  	unsigned int points = 0;
  	struct task_struct *chosen = NULL;

  	mutex_lock(&oom_lock);

  	/*

  	 * If current has a pending SIGKILL or is exiting, then automatically
  	 * select it.  The goal is to allow it to allocate so that it may
  	 * quickly exit and free its memory.

  	 */

  	if (fatal_signal_pending(current) || task_will_free_mem(current)) {

  		mark_oom_victim(current);

  		try_oom_reaper(current);

  		goto unlock;

  	}

  	check_panic_on_oom(&oc, CONSTRAINT_MEMCG, memcg);

  	totalpages = mem_cgroup_get_limit(memcg) ? : 1;

  	for_each_mem_cgroup_tree(iter, memcg) {

  		struct css_task_iter it;

  		struct task_struct *task;

  		css_task_iter_start(&iter->css, &it);
  		while ((task = css_task_iter_next(&it))) {

  			switch (oom_scan_process_thread(&oc, task, totalpages)) {

  			case OOM_SCAN_SELECT:
  				if (chosen)
  					put_task_struct(chosen);
  				chosen = task;
  				chosen_points = ULONG_MAX;
  				get_task_struct(chosen);
  				/* fall through */
  			case OOM_SCAN_CONTINUE:
  				continue;
  			case OOM_SCAN_ABORT:

  				css_task_iter_end(&it);

  				mem_cgroup_iter_break(memcg, iter);
  				if (chosen)
  					put_task_struct(chosen);

  				goto unlock;

  			case OOM_SCAN_OK:
  				break;
  			};
  			points = oom_badness(task, memcg, NULL, totalpages);

  			if (!points || points < chosen_points)
  				continue;
  			/* Prefer thread group leaders for display purposes */
  			if (points == chosen_points &&
  			    thread_group_leader(chosen))
  				continue;
  
  			if (chosen)
  				put_task_struct(chosen);
  			chosen = task;
  			chosen_points = points;
  			get_task_struct(chosen);

  		}

  		css_task_iter_end(&it);

  	}

  	if (chosen) {
  		points = chosen_points * 1000 / totalpages;

  		oom_kill_process(&oc, chosen, points, totalpages, memcg,
  				 "Memory cgroup out of memory");

  	}
  unlock:
  	mutex_unlock(&oom_lock);

  	return chosen;

  }

  #if MAX_NUMNODES > 1

  /**
   * test_mem_cgroup_node_reclaimable

   * @memcg: the target memcg

   * @nid: the node ID to be checked.
   * @noswap : specify true here if the user wants flle only information.
   *
   * This function returns whether the specified memcg contains any
   * reclaimable pages on a node. Returns true if there are any reclaimable
   * pages in the node.
   */

  static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,

  		int nid, bool noswap)
  {

  	if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))

  		return true;
  	if (noswap || !total_swap_pages)
  		return false;

  	if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))

  		return true;
  	return false;
  
  }

  
  /*
   * Always updating the nodemask is not very good - even if we have an empty
   * list or the wrong list here, we can start from some node and traverse all
   * nodes based on the zonelist. So update the list loosely once per 10 secs.
   *
   */

  static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)

  {
  	int nid;

  	/*
  	 * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
  	 * pagein/pageout changes since the last update.
  	 */

  	if (!atomic_read(&memcg->numainfo_events))

  		return;

  	if (atomic_inc_return(&memcg->numainfo_updating) > 1)

  		return;

  	/* make a nodemask where this memcg uses memory from */

  	memcg->scan_nodes = node_states[N_MEMORY];

  	for_each_node_mask(nid, node_states[N_MEMORY]) {

  		if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
  			node_clear(nid, memcg->scan_nodes);

  	}

  	atomic_set(&memcg->numainfo_events, 0);
  	atomic_set(&memcg->numainfo_updating, 0);

  }
  
  /*
   * Selecting a node where we start reclaim from. Because what we need is just
   * reducing usage counter, start from anywhere is O,K. Considering
   * memory reclaim from current node, there are pros. and cons.
   *
   * Freeing memory from current node means freeing memory from a node which
   * we'll use or we've used. So, it may make LRU bad. And if several threads
   * hit limits, it will see a contention on a node. But freeing from remote
   * node means more costs for memory reclaim because of memory latency.
   *
   * Now, we use round-robin. Better algorithm is welcomed.
   */

  int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)

  {
  	int node;

  	mem_cgroup_may_update_nodemask(memcg);
  	node = memcg->last_scanned_node;

  	node = next_node_in(node, memcg->scan_nodes);

  	/*

  	 * mem_cgroup_may_update_nodemask might have seen no reclaimmable pages
  	 * last time it really checked all the LRUs due to rate limiting.
  	 * Fallback to the current node in that case for simplicity.

  	 */
  	if (unlikely(node == MAX_NUMNODES))
  		node = numa_node_id();

  	memcg->last_scanned_node = node;

  	return node;
  }

  #else

  int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)

  {
  	return 0;
  }
  #endif

  static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
  				   struct zone *zone,
  				   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 = {
  		.zone = zone,
  		.priority = 0,
  	};

  	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_zone(victim, gfp_mask, false,
  						     zone, &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",
  };
  #endif

  static DEFINE_SPINLOCK(memcg_oom_lock);

  /*
   * Check OOM-Killer is already running under our hierarchy.
   * If someone is running, return false.
   */

  static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)

  {

  	struct mem_cgroup *iter, *failed = NULL;

  	spin_lock(&memcg_oom_lock);

  	for_each_mem_cgroup_tree(iter, memcg) {

  		if (iter->oom_lock) {

  			/*
  			 * this subtree of our hierarchy is already locked
  			 * so we cannot give a lock.
  			 */

  			failed = iter;

  			mem_cgroup_iter_break(memcg, iter);
  			break;

  		} else
  			iter->oom_lock = true;

  	}

  	if (failed) {
  		/*
  		 * OK, we failed to lock the whole subtree so we have
  		 * to clean up what we set up to the failing subtree
  		 */
  		for_each_mem_cgroup_tree(iter, memcg) {
  			if (iter == failed) {
  				mem_cgroup_iter_break(memcg, iter);
  				break;
  			}
  			iter->oom_lock = false;

  		}

  	} else
  		mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);

  
  	spin_unlock(&memcg_oom_lock);
  
  	return !failed;

  }

  static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)

  {

  	struct mem_cgroup *iter;

  	spin_lock(&memcg_oom_lock);

  	mutex_release(&memcg_oom_lock_dep_map, 1, _RET_IP_);

  	for_each_mem_cgroup_tree(iter, memcg)

  		iter->oom_lock = false;

  	spin_unlock(&memcg_oom_lock);

  }

  static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)

  {
  	struct mem_cgroup *iter;

  	spin_lock(&memcg_oom_lock);

  	for_each_mem_cgroup_tree(iter, memcg)

  		iter->under_oom++;
  	spin_unlock(&memcg_oom_lock);