/* 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
   *

   * 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/res_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/page_cgroup.h>

  #include <linux/cpu.h>

  #include <linux/oom.h>

  #include <linux/lockdep.h>

  #include <linux/file.h>

  #include "internal.h"

  #include <net/sock.h>

  #include <net/ip.h>

  #include <net/tcp_memcontrol.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);

  #define MEM_CGROUP_RECLAIM_RETRIES	5

  static struct mem_cgroup *root_mem_cgroup __read_mostly;

  #ifdef CONFIG_MEMCG_SWAP

  /* Turned on only when memory cgroup is enabled && really_do_swap_account = 1 */

  int do_swap_account __read_mostly;

  
  /* for remember boot option*/

  #ifdef CONFIG_MEMCG_SWAP_ENABLED

  static int really_do_swap_account __initdata = 1;
  #else

  static int really_do_swap_account __initdata;

  #endif

  #else

  #define do_swap_account		0

  #endif

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

  	"rss_huge",

  	"mapped_file",

  	"writeback",

  	"swap",
  };

  enum mem_cgroup_events_index {
  	MEM_CGROUP_EVENTS_PGPGIN,	/* # of pages paged in */
  	MEM_CGROUP_EVENTS_PGPGOUT,	/* # of pages paged out */

  	MEM_CGROUP_EVENTS_PGFAULT,	/* # of page-faults */
  	MEM_CGROUP_EVENTS_PGMAJFAULT,	/* # of major page-faults */

  	MEM_CGROUP_EVENTS_NSTATS,
  };

  
  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",
  };

  /*
   * Per memcg event counter is incremented at every pagein/pageout. With THP,
   * it will be incremated by the number of pages. This counter is used for
   * for trigger some periodic events. This is straightforward and better
   * than using jiffies etc. to handle periodic memcg event.
   */
  enum mem_cgroup_events_target {
  	MEM_CGROUP_TARGET_THRESH,

  	MEM_CGROUP_TARGET_SOFTLIMIT,

  	MEM_CGROUP_TARGET_NUMAINFO,

  	MEM_CGROUP_NTARGETS,
  };

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

  struct mem_cgroup_stat_cpu {

  	long count[MEM_CGROUP_STAT_NSTATS];

  	unsigned long events[MEM_CGROUP_EVENTS_NSTATS];

  	unsigned long nr_page_events;

  	unsigned long targets[MEM_CGROUP_NTARGETS];

  };

  struct mem_cgroup_reclaim_iter {

  	/*
  	 * last scanned hierarchy member. Valid only if last_dead_count
  	 * matches memcg->dead_count of the hierarchy root group.
  	 */

  	struct mem_cgroup *last_visited;

  	int last_dead_count;

  	/* scan generation, increased every round-trip */
  	unsigned int generation;
  };

  /*

   * per-zone information in memory controller.
   */

  struct mem_cgroup_per_zone {

  	struct lruvec		lruvec;

  	unsigned long		lru_size[NR_LRU_LISTS];

  	struct mem_cgroup_reclaim_iter reclaim_iter[DEF_PRIORITY + 1];

  	struct rb_node		tree_node;	/* RB tree node */
  	unsigned long long	usage_in_excess;/* Set to the value by which */
  						/* the soft limit is exceeded*/
  	bool			on_tree;

  	struct mem_cgroup	*memcg;		/* Back pointer, we cannot */

  						/* use container_of	   */

  };

  
  struct mem_cgroup_per_node {
  	struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
  };

  /*
   * 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;

  struct mem_cgroup_threshold {
  	struct eventfd_ctx *eventfd;
  	u64 threshold;
  };

  /* For threshold */

  struct mem_cgroup_threshold_ary {

  	/* An array index points to threshold just below or equal to usage. */

  	int current_threshold;

  	/* Size of entries[] */
  	unsigned int size;
  	/* Array of thresholds */
  	struct mem_cgroup_threshold entries[0];
  };

  
  struct mem_cgroup_thresholds {
  	/* Primary thresholds array */
  	struct mem_cgroup_threshold_ary *primary;
  	/*
  	 * Spare threshold array.
  	 * This is needed to make mem_cgroup_unregister_event() "never fail".
  	 * It must be able to store at least primary->size - 1 entries.
  	 */
  	struct mem_cgroup_threshold_ary *spare;
  };

  /* 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);

  /*

   * The memory controller data structure. The memory controller controls both
   * page cache and RSS per cgroup. We would eventually like to provide
   * statistics based on the statistics developed by Rik Van Riel for clock-pro,
   * to help the administrator determine what knobs to tune.
   *
   * TODO: Add a water mark for the memory controller. Reclaim will begin when

   * we hit the water mark. May be even add a low water mark, such that
   * no reclaim occurs from a cgroup at it's low water mark, this is
   * a feature that will be implemented much later in the future.

   */
  struct mem_cgroup {
  	struct cgroup_subsys_state css;
  	/*
  	 * the counter to account for memory usage
  	 */
  	struct res_counter res;

  	/* vmpressure notifications */
  	struct vmpressure vmpressure;

  	/* css_online() has been completed */
  	int initialized;

  	/*
  	 * the counter to account for mem+swap usage.
  	 */
  	struct res_counter memsw;

  	/*

  	 * the counter to account for kernel memory usage.
  	 */
  	struct res_counter kmem;
  	/*

  	 * Should the accounting and control be hierarchical, per subtree?
  	 */
  	bool use_hierarchy;

  	unsigned long kmem_account_flags; /* See KMEM_ACCOUNTED_*, below */

  
  	bool		oom_lock;
  	atomic_t	under_oom;

  	atomic_t	oom_wakeups;

  	int	swappiness;

  	/* OOM-Killer disable */
  	int		oom_kill_disable;

  	/* protect arrays of thresholds */
  	struct mutex thresholds_lock;
  
  	/* thresholds for memory usage. RCU-protected */

  	struct mem_cgroup_thresholds thresholds;

  	/* thresholds for mem+swap usage. RCU-protected */

  	struct mem_cgroup_thresholds memsw_thresholds;

  	/* For oom notifier event fd */
  	struct list_head oom_notify;

  	/*

  	 * Should we move charges of a task when a task is moved into this
  	 * mem_cgroup ? And what type of charges should we move ?
  	 */

  	unsigned long move_charge_at_immigrate;

  	/*

  	 * set > 0 if pages under this cgroup are moving to other cgroup.
  	 */
  	atomic_t	moving_account;

  	/* taken only while moving_account > 0 */
  	spinlock_t	move_lock;

  	/*

  	 * percpu counter.

  	 */

  	struct mem_cgroup_stat_cpu __percpu *stat;

  	/*
  	 * used when a cpu is offlined or other synchronizations
  	 * See mem_cgroup_read_stat().
  	 */
  	struct mem_cgroup_stat_cpu nocpu_base;
  	spinlock_t pcp_counter_lock;

  	atomic_t	dead_count;

  #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)

  	struct cg_proto tcp_mem;

  #endif

  #if defined(CONFIG_MEMCG_KMEM)

  	/* analogous to slab_common's slab_caches list, but per-memcg;
  	 * protected by memcg_slab_mutex */

  	struct list_head memcg_slab_caches;

          /* Index in the kmem_cache->memcg_params->memcg_caches array */
  	int kmemcg_id;
  #endif

  
  	int last_scanned_node;
  #if MAX_NUMNODES > 1
  	nodemask_t	scan_nodes;
  	atomic_t	numainfo_events;
  	atomic_t	numainfo_updating;
  #endif

  	/* List of events which userspace want to receive */
  	struct list_head event_list;
  	spinlock_t event_list_lock;

  	struct mem_cgroup_per_node *nodeinfo[0];
  	/* WARNING: nodeinfo must be the last member here */

  };

  /* internal only representation about the status of kmem accounting. */
  enum {

  	KMEM_ACCOUNTED_ACTIVE, /* accounted by this cgroup itself */

  	KMEM_ACCOUNTED_DEAD, /* dead memcg with pending kmem charges */

  };

  #ifdef CONFIG_MEMCG_KMEM
  static inline void memcg_kmem_set_active(struct mem_cgroup *memcg)
  {
  	set_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
  }

  
  static bool memcg_kmem_is_active(struct mem_cgroup *memcg)
  {
  	return test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
  }
  
  static void memcg_kmem_mark_dead(struct mem_cgroup *memcg)
  {

  	/*
  	 * Our caller must use css_get() first, because memcg_uncharge_kmem()
  	 * will call css_put() if it sees the memcg is dead.
  	 */
  	smp_wmb();

  	if (test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags))
  		set_bit(KMEM_ACCOUNTED_DEAD, &memcg->kmem_account_flags);
  }
  
  static bool memcg_kmem_test_and_clear_dead(struct mem_cgroup *memcg)
  {
  	return test_and_clear_bit(KMEM_ACCOUNTED_DEAD,
  				  &memcg->kmem_account_flags);
  }

  #endif

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

   * Types of charges to be moved. "move_charge_at_immitgrate" and
   * "immigrate_flags" are treated as a left-shifted bitmap of these types.

   */
  enum move_type {

  	MOVE_CHARGE_TYPE_ANON,	/* private anonymous page and swap of it */

  	MOVE_CHARGE_TYPE_FILE,	/* file page(including tmpfs) and swap of it */

  	NR_MOVE_TYPE,
  };

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

  	spinlock_t	  lock; /* for from, to */

  	struct mem_cgroup *from;
  	struct mem_cgroup *to;

  	unsigned long immigrate_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),
  };

  static bool move_anon(void)
  {

  	return test_bit(MOVE_CHARGE_TYPE_ANON, &mc.immigrate_flags);

  }

  static bool move_file(void)
  {

  	return test_bit(MOVE_CHARGE_TYPE_FILE, &mc.immigrate_flags);

  }

  /*
   * 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,

  };

  #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)

  /*

   * The memcg_create_mutex will be held whenever a new cgroup is created.
   * As a consequence, any change that needs to protect against new child cgroups
   * appearing has to hold it as well.
   */
  static DEFINE_MUTEX(memcg_create_mutex);

  struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
  {

  	return s ? container_of(s, struct mem_cgroup, css) : NULL;

  }

  /* 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);
  }

  /*
   * We restrict the id in the range of [1, 65535], so it can fit into
   * an unsigned short.
   */
  #define MEM_CGROUP_ID_MAX	USHRT_MAX

  static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
  {

  	return memcg->css.id;

  }
  
  static inline struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
  {
  	struct cgroup_subsys_state *css;

  	css = css_from_id(id, &memory_cgrp_subsys);

  	return mem_cgroup_from_css(css);
  }

  /* Writing them here to avoid exposing memcg's inner layout */

  #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)

  void sock_update_memcg(struct sock *sk)
  {

  	if (mem_cgroup_sockets_enabled) {

  		struct mem_cgroup *memcg;

  		struct cg_proto *cg_proto;

  
  		BUG_ON(!sk->sk_prot->proto_cgroup);

  		/* Socket cloning can throw us here with sk_cgrp already
  		 * filled. It won't however, necessarily happen from
  		 * process context. So the test for root memcg given
  		 * the current task's memcg won't help us in this case.
  		 *
  		 * Respecting the original socket's memcg is a better
  		 * decision in this case.
  		 */
  		if (sk->sk_cgrp) {
  			BUG_ON(mem_cgroup_is_root(sk->sk_cgrp->memcg));

  			css_get(&sk->sk_cgrp->memcg->css);

  			return;
  		}

  		rcu_read_lock();
  		memcg = mem_cgroup_from_task(current);

  		cg_proto = sk->sk_prot->proto_cgroup(memcg);

  		if (!mem_cgroup_is_root(memcg) &&

  		    memcg_proto_active(cg_proto) &&
  		    css_tryget_online(&memcg->css)) {

  			sk->sk_cgrp = cg_proto;

  		}
  		rcu_read_unlock();
  	}
  }
  EXPORT_SYMBOL(sock_update_memcg);
  
  void sock_release_memcg(struct sock *sk)
  {

  	if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {

  		struct mem_cgroup *memcg;
  		WARN_ON(!sk->sk_cgrp->memcg);
  		memcg = sk->sk_cgrp->memcg;

  		css_put(&sk->sk_cgrp->memcg->css);

  	}
  }

  
  struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
  {
  	if (!memcg || mem_cgroup_is_root(memcg))
  		return NULL;

  	return &memcg->tcp_mem;

  }
  EXPORT_SYMBOL(tcp_proto_cgroup);

  static void disarm_sock_keys(struct mem_cgroup *memcg)
  {

  	if (!memcg_proto_activated(&memcg->tcp_mem))

  		return;
  	static_key_slow_dec(&memcg_socket_limit_enabled);
  }
  #else
  static void disarm_sock_keys(struct mem_cgroup *memcg)
  {
  }
  #endif

  #ifdef CONFIG_MEMCG_KMEM

  /*
   * 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_limited_groups_array_size.  It will double each time we have to
   * increase it.
   */
  static DEFINE_IDA(kmem_limited_groups);

  int memcg_limited_groups_array_size;

  /*
   * 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
   */

  struct static_key memcg_kmem_enabled_key;

  EXPORT_SYMBOL(memcg_kmem_enabled_key);

  static void memcg_free_cache_id(int id);

  static void disarm_kmem_keys(struct mem_cgroup *memcg)
  {

  	if (memcg_kmem_is_active(memcg)) {

  		static_key_slow_dec(&memcg_kmem_enabled_key);

  		memcg_free_cache_id(memcg->kmemcg_id);

  	}

  	/*
  	 * This check can't live in kmem destruction function,
  	 * since the charges will outlive the cgroup
  	 */
  	WARN_ON(res_counter_read_u64(&memcg->kmem, RES_USAGE) != 0);

  }
  #else
  static void disarm_kmem_keys(struct mem_cgroup *memcg)
  {
  }
  #endif /* CONFIG_MEMCG_KMEM */
  
  static void disarm_static_keys(struct mem_cgroup *memcg)
  {
  	disarm_sock_keys(memcg);
  	disarm_kmem_keys(memcg);
  }

  static void drain_all_stock_async(struct mem_cgroup *memcg);

  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];

  }

  struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)

  {

  	return &memcg->css;

  }

  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 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 void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
  {
  	unsigned long 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 = res_counter_soft_limit_excess(&memcg->res);
  		/*
  		 * 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 (!res_counter_soft_limit_excess(&mz->memcg->res) ||

  	    !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;
  }

  /*
   * 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 synchronizion 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, threashold and synchonization as vmstat[] should be
   * implemented.
   */

  static long mem_cgroup_read_stat(struct mem_cgroup *memcg,

  				 enum mem_cgroup_stat_index idx)

  {

  	long val = 0;

  	int cpu;

  	get_online_cpus();
  	for_each_online_cpu(cpu)

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

  #ifdef CONFIG_HOTPLUG_CPU

  	spin_lock(&memcg->pcp_counter_lock);
  	val += memcg->nocpu_base.count[idx];
  	spin_unlock(&memcg->pcp_counter_lock);

  #endif
  	put_online_cpus();

  	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;

  	get_online_cpus();

  	for_each_online_cpu(cpu)

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

  #ifdef CONFIG_HOTPLUG_CPU

  	spin_lock(&memcg->pcp_counter_lock);
  	val += memcg->nocpu_base.events[idx];
  	spin_unlock(&memcg->pcp_counter_lock);

  #endif

  	put_online_cpus();

  	return val;
  }

  static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,

  					 struct page *page,

  					 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 (PageTransHuge(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_get_lru_size(struct lruvec *lruvec, enum lru_list lru)

  {
  	struct mem_cgroup_per_zone *mz;
  
  	mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
  	return mz->lru_size[lru];
  }

  static 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));

  }

  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;

  }

  /*
   * Returns a next (in a pre-order walk) alive memcg (with elevated css
   * ref. count) or NULL if the whole root's subtree has been visited.
   *
   * helper function to be used by mem_cgroup_iter
   */
  static struct mem_cgroup *__mem_cgroup_iter_next(struct mem_cgroup *root,

  		struct mem_cgroup *last_visited)

  {

  	struct cgroup_subsys_state *prev_css, *next_css;

  	prev_css = last_visited ? &last_visited->css : NULL;

  skip_node:

  	next_css = css_next_descendant_pre(prev_css, &root->css);

  
  	/*
  	 * Even if we found a group we have to make sure it is
  	 * alive. css && !memcg means that the groups should be
  	 * skipped and we should continue the tree walk.
  	 * last_visited css is safe to use because it is
  	 * protected by css_get and the tree walk is rcu safe.

  	 *
  	 * We do not take a reference on the root of the tree walk
  	 * because we might race with the root removal when it would
  	 * be the only node in the iterated hierarchy and mem_cgroup_iter
  	 * would end up in an endless loop because it expects that at
  	 * least one valid node will be returned. Root cannot disappear
  	 * because caller of the iterator should hold it already so
  	 * skipping css reference should be safe.

  	 */

  	if (next_css) {

  		struct mem_cgroup *memcg = mem_cgroup_from_css(next_css);
  
  		if (next_css == &root->css)
  			return memcg;
  
  		if (css_tryget_online(next_css)) {
  			/*
  			 * Make sure the memcg is initialized:
  			 * mem_cgroup_css_online() orders the the
  			 * initialization against setting the flag.
  			 */
  			if (smp_load_acquire(&memcg->initialized))
  				return memcg;
  			css_put(next_css);
  		}

  
  		prev_css = next_css;
  		goto skip_node;

  	}
  
  	return NULL;
  }

  static void mem_cgroup_iter_invalidate(struct mem_cgroup *root)
  {
  	/*
  	 * When a group in the hierarchy below root is destroyed, the
  	 * hierarchy iterator can no longer be trusted since it might
  	 * have pointed to the destroyed group.  Invalidate it.
  	 */
  	atomic_inc(&root->dead_count);
  }
  
  static struct mem_cgroup *
  mem_cgroup_iter_load(struct mem_cgroup_reclaim_iter *iter,
  		     struct mem_cgroup *root,
  		     int *sequence)
  {
  	struct mem_cgroup *position = NULL;
  	/*
  	 * A cgroup destruction happens in two stages: offlining and
  	 * release.  They are separated by a RCU grace period.
  	 *
  	 * If the iterator is valid, we may still race with an
  	 * offlining.  The RCU lock ensures the object won't be
  	 * released, tryget will fail if we lost the race.
  	 */
  	*sequence = atomic_read(&root->dead_count);
  	if (iter->last_dead_count == *sequence) {
  		smp_rmb();
  		position = iter->last_visited;

  
  		/*
  		 * We cannot take a reference to root because we might race
  		 * with root removal and returning NULL would end up in
  		 * an endless loop on the iterator user level when root
  		 * would be returned all the time.
  		 */
  		if (position && position != root &&

  		    !css_tryget_online(&position->css))

  			position = NULL;
  	}
  	return position;
  }
  
  static void mem_cgroup_iter_update(struct mem_cgroup_reclaim_iter *iter,
  				   struct mem_cgroup *last_visited,
  				   struct mem_cgroup *new_position,

  				   struct mem_cgroup *root,

  				   int sequence)
  {

  	/* root reference counting symmetric to mem_cgroup_iter_load */
  	if (last_visited && last_visited != root)

  		css_put(&last_visited->css);
  	/*
  	 * We store the sequence count from the time @last_visited was
  	 * loaded successfully instead of rereading it here so that we
  	 * don't lose destruction events in between.  We could have
  	 * raced with the destruction of @new_position after all.
  	 */
  	iter->last_visited = new_position;
  	smp_wmb();
  	iter->last_dead_count = sequence;
  }

  /**
   * 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 *memcg = NULL;

  	struct mem_cgroup *last_visited = NULL;

  	if (mem_cgroup_disabled())
  		return NULL;

  	if (!root)
  		root = root_mem_cgroup;

  	if (prev && !reclaim)

  		last_visited = prev;

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

  			goto out_css_put;

  		return root;

  	}

  	rcu_read_lock();

  	while (!memcg) {

  		struct mem_cgroup_reclaim_iter *uninitialized_var(iter);

  		int uninitialized_var(seq);

  		if (reclaim) {

  			struct mem_cgroup_per_zone *mz;

  			mz = mem_cgroup_zone_zoneinfo(root, reclaim->zone);

  			iter = &mz->reclaim_iter[reclaim->priority];

  			if (prev && reclaim->generation != iter->generation) {

  				iter->last_visited = NULL;

  				goto out_unlock;
  			}

  			last_visited = mem_cgroup_iter_load(iter, root, &seq);

  		}

  		memcg = __mem_cgroup_iter_next(root, last_visited);

  		if (reclaim) {

  			mem_cgroup_iter_update(iter, last_visited, memcg, root,
  					seq);

  			if (!memcg)

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

  		if (prev && !memcg)

  			goto out_unlock;

  	}

  out_unlock:
  	rcu_read_unlock();

  out_css_put:
  	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);
  }

  /*
   * 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))

  void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)

  {

  	struct mem_cgroup *memcg;

  	rcu_read_lock();

  	memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
  	if (unlikely(!memcg))

  		goto out;
  
  	switch (idx) {

  	case PGFAULT:

  		this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT]);
  		break;
  	case PGMAJFAULT:
  		this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT]);

  		break;
  	default:
  		BUG();
  	}
  out:
  	rcu_read_unlock();
  }

  EXPORT_SYMBOL(__mem_cgroup_count_vm_event);

  /**
   * 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 adding an lru page

   * @page: the page

   * @zone: zone of the page

   */

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

  {

  	struct mem_cgroup_per_zone *mz;

  	struct mem_cgroup *memcg;
  	struct page_cgroup *pc;

  	struct lruvec *lruvec;

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

  	pc = lookup_page_cgroup(page);

  	memcg = pc->mem_cgroup;

  
  	/*

  	 * Surreptitiously switch any uncharged offlist page to root:

  	 * an uncharged page off lru does nothing to secure
  	 * its former mem_cgroup from sudden removal.
  	 *
  	 * Our caller holds lru_lock, and PageCgroupUsed is updated
  	 * under page_cgroup lock: between them, they make all uses
  	 * of pc->mem_cgroup safe.
  	 */

  	if (!PageLRU(page) && !PageCgroupUsed(pc) && memcg != root_mem_cgroup)

  		pc->mem_cgroup = 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 when a page is added to or removed from an
   * lru list.

   */

  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;

  
  	if (mem_cgroup_disabled())
  		return;

  	mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
  	lru_size = mz->lru_size + lru;
  	*lru_size += nr_pages;
  	VM_BUG_ON((long)(*lru_size) < 0);

  }

  /*

   * Checks whether given mem is same or in the root_mem_cgroup's

   * hierarchy subtree
   */

  bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
  				  struct mem_cgroup *memcg)

  {

  	if (root_memcg == memcg)
  		return true;

  	if (!root_memcg->use_hierarchy || !memcg)

  		return false;

  	return cgroup_is_descendant(memcg->css.cgroup, root_memcg->css.cgroup);

  }
  
  static bool mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
  				       struct mem_cgroup *memcg)
  {
  	bool ret;

  	rcu_read_lock();

  	ret = __mem_cgroup_same_or_subtree(root_memcg, memcg);

  	rcu_read_unlock();
  	return ret;

  }

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

  {

  	struct mem_cgroup *curr = NULL;

  	struct task_struct *p;

  	bool ret;

  	p = find_lock_task_mm(task);

  	if (p) {

  		curr = 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();

  		curr = mem_cgroup_from_task(task);
  		if (curr)
  			css_get(&curr->css);

  		rcu_read_unlock();

  	}

  	/*

  	 * We should check use_hierarchy of "memcg" not "curr". Because checking

  	 * use_hierarchy of "curr" here make this function true if hierarchy is

  	 * enabled in "curr" and "curr" is a child of "memcg" in *cgroup*
  	 * hierarchy(even if use_hierarchy is disabled in "memcg").

  	 */

  	ret = mem_cgroup_same_or_subtree(memcg, curr);

  	css_put(&curr->css);

  	return ret;
  }

  int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)

  {

  	unsigned long inactive_ratio;

  	unsigned long inactive;

  	unsigned long active;

  	unsigned long gb;

  	inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_ANON);
  	active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_ANON);

  	gb = (inactive + active) >> (30 - PAGE_SHIFT);
  	if (gb)
  		inactive_ratio = int_sqrt(10 * gb);
  	else
  		inactive_ratio = 1;

  	return inactive * inactive_ratio < active;

  }

  #define mem_cgroup_from_res_counter(counter, member)	\
  	container_of(counter, struct mem_cgroup, member)

  /**

   * 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 long margin;

  	margin = res_counter_margin(&memcg->res);

  	if (do_swap_account)

  		margin = min(margin, res_counter_margin(&memcg->memsw));

  	return margin >> PAGE_SHIFT;

  }