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

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

  #include <linux/fs.h>

  #include <linux/seq_file.h>

  #include <linux/vmalloc.h>

  #include <linux/mm_inline.h>

  #include <linux/page_cgroup.h>

  #include <linux/cpu.h>

  #include <linux/oom.h>

  #include "internal.h"

  #include <asm/uaccess.h>

  #include <trace/events/vmscan.h>

  struct cgroup_subsys mem_cgroup_subsys __read_mostly;

  #define MEM_CGROUP_RECLAIM_RETRIES	5

  struct mem_cgroup *root_mem_cgroup __read_mostly;

  #ifdef CONFIG_CGROUP_MEM_RES_CTLR_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_CGROUP_MEM_RES_CTLR_SWAP_ENABLED
  static int really_do_swap_account __initdata = 1;
  #else
  static int really_do_swap_account __initdata = 0;
  #endif

  #else
  #define do_swap_account		(0)
  #endif

  /*

   * Statistics for memory cgroup.
   */
  enum mem_cgroup_stat_index {
  	/*
  	 * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
  	 */
  	MEM_CGROUP_STAT_CACHE, 	   /* # of pages charged as cache */

  	MEM_CGROUP_STAT_RSS,	   /* # of pages charged as anon rss */

  	MEM_CGROUP_STAT_FILE_MAPPED,  /* # of pages charged as file rss */

  	MEM_CGROUP_STAT_SWAPOUT, /* # of pages, swapped out */

  	MEM_CGROUP_STAT_DATA, /* end of data requires synchronization */

  	MEM_CGROUP_ON_MOVE,	/* someone is moving account between groups */

  	MEM_CGROUP_STAT_NSTATS,
  };

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

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

  	MEM_CGROUP_EVENTS_NSTATS,
  };

  /*
   * 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 targets[MEM_CGROUP_NTARGETS];

  };

  /*

   * per-zone information in memory controller.
   */

  struct mem_cgroup_per_zone {

  	/*
  	 * spin_lock to protect the per cgroup LRU
  	 */

  	struct list_head	lists[NR_LRU_LISTS];
  	unsigned long		count[NR_LRU_LISTS];

  
  	struct zone_reclaim_stat reclaim_stat;

  	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	*mem;		/* Back pointer, we cannot */
  						/* use container_of	   */

  };
  /* Macro for accessing counter */
  #define MEM_CGROUP_ZSTAT(mz, idx)	((mz)->count[(idx)])
  
  struct mem_cgroup_per_node {
  	struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
  };
  
  struct mem_cgroup_lru_info {
  	struct mem_cgroup_per_node *nodeinfo[MAX_NUMNODES];
  };
  
  /*

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

  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;

  	/*

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

  	 * Per cgroup active and inactive list, similar to the
  	 * per zone LRU lists.

  	 */

  	struct mem_cgroup_lru_info info;

  	/*

  	 * While reclaiming in a hierarchy, we cache the last child we

  	 * reclaimed from.

  	 */

  	int last_scanned_child;

  	int last_scanned_node;
  #if MAX_NUMNODES > 1
  	nodemask_t	scan_nodes;

  	atomic_t	numainfo_events;
  	atomic_t	numainfo_updating;

  #endif

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

  
  	bool		oom_lock;
  	atomic_t	under_oom;

  	atomic_t	refcnt;

  	int	swappiness;

  	/* OOM-Killer disable */
  	int		oom_kill_disable;

  	/* set when res.limit == memsw.limit */
  	bool		memsw_is_minimum;

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

  	/*

  	 * percpu counter.

  	 */

  	struct mem_cgroup_stat_cpu *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;

  };

  /* Stuffs for move charges at task migration. */
  /*
   * Types of charges to be moved. "move_charge_at_immitgrate" is 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 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.to->move_charge_at_immigrate);
  }

  static bool move_file(void)
  {
  	return test_bit(MOVE_CHARGE_TYPE_FILE,
  					&mc.to->move_charge_at_immigrate);
  }

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

  	MEM_CGROUP_CHARGE_TYPE_SHMEM,	/* used by page migration of shmem */

  	MEM_CGROUP_CHARGE_TYPE_FORCE,	/* used by force_empty */

  	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 */
  #define _MEM			(0)
  #define _MEMSWAP		(1)

  #define _OOM_TYPE		(2)

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

  /*
   * Reclaim flags for mem_cgroup_hierarchical_reclaim
   */
  #define MEM_CGROUP_RECLAIM_NOSWAP_BIT	0x0
  #define MEM_CGROUP_RECLAIM_NOSWAP	(1 << MEM_CGROUP_RECLAIM_NOSWAP_BIT)
  #define MEM_CGROUP_RECLAIM_SHRINK_BIT	0x1
  #define MEM_CGROUP_RECLAIM_SHRINK	(1 << MEM_CGROUP_RECLAIM_SHRINK_BIT)

  #define MEM_CGROUP_RECLAIM_SOFT_BIT	0x2
  #define MEM_CGROUP_RECLAIM_SOFT		(1 << MEM_CGROUP_RECLAIM_SOFT_BIT)

  static void mem_cgroup_get(struct mem_cgroup *memcg);
  static void mem_cgroup_put(struct mem_cgroup *memcg);
  static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
  static void drain_all_stock_async(struct mem_cgroup *memcg);

  static struct mem_cgroup_per_zone *

  mem_cgroup_zoneinfo(struct mem_cgroup *memcg, int nid, int zid)

  {

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

  }

  struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)

  {

  	return &memcg->css;

  }

  static struct mem_cgroup_per_zone *

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

  {

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

  	return mem_cgroup_zoneinfo(memcg, nid, 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 *memcg,

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

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

  				struct mem_cgroup_per_zone *mz,
  				struct mem_cgroup_tree_per_zone *mctz)
  {
  	spin_lock(&mctz->lock);

  	__mem_cgroup_remove_exceeded(memcg, mz, mctz);

  	spin_unlock(&mctz->lock);
  }

  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;

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

  	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_zoneinfo(memcg, nid, zid);
  		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) {

  			spin_lock(&mctz->lock);
  			/* if on-tree, remove it */
  			if (mz->on_tree)

  				__mem_cgroup_remove_exceeded(memcg, mz, mctz);

  			/*

  			 * Insert again. mz->usage_in_excess will be updated.
  			 * If excess is 0, no tree ops.

  			 */

  			__mem_cgroup_insert_exceeded(memcg, mz, mctz, excess);

  			spin_unlock(&mctz->lock);
  		}

  	}
  }

  static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)

  {
  	int node, zone;
  	struct mem_cgroup_per_zone *mz;
  	struct mem_cgroup_tree_per_zone *mctz;
  
  	for_each_node_state(node, N_POSSIBLE) {
  		for (zone = 0; zone < MAX_NR_ZONES; zone++) {

  			mz = mem_cgroup_zoneinfo(memcg, node, zone);

  			mctz = soft_limit_tree_node_zone(node, zone);

  			mem_cgroup_remove_exceeded(memcg, 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->mem, mz, mctz);
  	if (!res_counter_soft_limit_excess(&mz->mem->res) ||
  		!css_tryget(&mz->mem->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(&mctz->lock);
  	mz = __mem_cgroup_largest_soft_limit_node(mctz);
  	spin_unlock(&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 void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,

  					 bool charge)
  {
  	int val = (charge) ? 1 : -1;

  	this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_SWAPOUT], val);

  }

  void mem_cgroup_pgfault(struct mem_cgroup *memcg, int val)

  {

  	this_cpu_add(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT], val);

  }

  void mem_cgroup_pgmajfault(struct mem_cgroup *memcg, int val)

  {

  	this_cpu_add(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT], 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_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
  	return val;
  }

  static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,

  					 bool file, int nr_pages)

  {

  	preempt_disable();

  	if (file)

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

  	else

  		__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],
  				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->events[MEM_CGROUP_EVENTS_COUNT], nr_pages);

  	preempt_enable();

  }

  unsigned long

  mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,

  			unsigned int lru_mask)

  {
  	struct mem_cgroup_per_zone *mz;

  	enum lru_list l;
  	unsigned long ret = 0;

  	mz = mem_cgroup_zoneinfo(memcg, nid, zid);

  
  	for_each_lru(l) {
  		if (BIT(l) & lru_mask)
  			ret += MEM_CGROUP_ZSTAT(mz, l);
  	}
  	return ret;
  }
  
  static unsigned long

  mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,

  			int nid, unsigned int lru_mask)
  {

  	u64 total = 0;
  	int zid;

  	for (zid = 0; zid < MAX_NR_ZONES; zid++)

  		total += mem_cgroup_zone_nr_lru_pages(memcg,
  						nid, zid, lru_mask);

  	return total;
  }

  static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,

  			unsigned int lru_mask)

  {

  	int nid;

  	u64 total = 0;

  	for_each_node_state(nid, N_HIGH_MEMORY)

  		total += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);

  	return total;

  }

  static bool __memcg_event_check(struct mem_cgroup *memcg, int target)

  {
  	unsigned long val, next;

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

  	/* from time_after() in jiffies.h */
  	return ((long)next - (long)val < 0);
  }

  static void __mem_cgroup_target_update(struct mem_cgroup *memcg, int target)

  {

  	unsigned long val, next;

  	val = __this_cpu_read(memcg->stat->events[MEM_CGROUP_EVENTS_COUNT]);

  	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:
  		return;
  	}

  	__this_cpu_write(memcg->stat->targets[target], next);

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

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

  {

  	preempt_disable();

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

  	if (unlikely(__memcg_event_check(memcg, MEM_CGROUP_TARGET_THRESH))) {
  		mem_cgroup_threshold(memcg);
  		__mem_cgroup_target_update(memcg, MEM_CGROUP_TARGET_THRESH);
  		if (unlikely(__memcg_event_check(memcg,

  			     MEM_CGROUP_TARGET_SOFTLIMIT))) {

  			mem_cgroup_update_tree(memcg, page);
  			__mem_cgroup_target_update(memcg,

  						   MEM_CGROUP_TARGET_SOFTLIMIT);
  		}
  #if MAX_NUMNODES > 1

  		if (unlikely(__memcg_event_check(memcg,

  			MEM_CGROUP_TARGET_NUMAINFO))) {

  			atomic_inc(&memcg->numainfo_events);
  			__mem_cgroup_target_update(memcg,

  				MEM_CGROUP_TARGET_NUMAINFO);

  		}

  #endif

  	}

  	preempt_enable();

  }

  static struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont)

  {
  	return container_of(cgroup_subsys_state(cont,
  				mem_cgroup_subsys_id), struct mem_cgroup,
  				css);
  }

  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 container_of(task_subsys_state(p, mem_cgroup_subsys_id),
  				struct mem_cgroup, css);
  }

  struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)

  {

  	struct mem_cgroup *memcg = NULL;

  
  	if (!mm)
  		return NULL;

  	/*
  	 * Because we have no locks, mm->owner's may be being moved to other
  	 * cgroup. We use css_tryget() here even if this looks
  	 * pessimistic (rather than adding locks here).
  	 */
  	rcu_read_lock();
  	do {

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

  			break;

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

  	rcu_read_unlock();

  	return memcg;

  }

  /* The caller has to guarantee "mem" exists before calling this */

  static struct mem_cgroup *mem_cgroup_start_loop(struct mem_cgroup *memcg)

  {

  	struct cgroup_subsys_state *css;
  	int found;

  	if (!memcg) /* ROOT cgroup has the smallest ID */

  		return root_mem_cgroup; /*css_put/get against root is ignored*/

  	if (!memcg->use_hierarchy) {
  		if (css_tryget(&memcg->css))
  			return memcg;

  		return NULL;
  	}
  	rcu_read_lock();
  	/*
  	 * searching a memory cgroup which has the smallest ID under given
  	 * ROOT cgroup. (ID >= 1)
  	 */

  	css = css_get_next(&mem_cgroup_subsys, 1, &memcg->css, &found);

  	if (css && css_tryget(css))

  		memcg = container_of(css, struct mem_cgroup, css);

  	else

  		memcg = NULL;

  	rcu_read_unlock();

  	return memcg;

  }
  
  static struct mem_cgroup *mem_cgroup_get_next(struct mem_cgroup *iter,
  					struct mem_cgroup *root,
  					bool cond)
  {
  	int nextid = css_id(&iter->css) + 1;
  	int found;
  	int hierarchy_used;

  	struct cgroup_subsys_state *css;

  	hierarchy_used = iter->use_hierarchy;

  	css_put(&iter->css);

  	/* If no ROOT, walk all, ignore hierarchy */
  	if (!cond || (root && !hierarchy_used))

  		return NULL;

  	if (!root)
  		root = root_mem_cgroup;

  	do {
  		iter = NULL;

  		rcu_read_lock();

  
  		css = css_get_next(&mem_cgroup_subsys, nextid,
  				&root->css, &found);

  		if (css && css_tryget(css))

  			iter = container_of(css, struct mem_cgroup, css);

  		rcu_read_unlock();

  		/* If css is NULL, no more cgroups will be found */

  		nextid = found + 1;

  	} while (css && !iter);

  	return iter;

  }

  /*
   * for_eacn_mem_cgroup_tree() for visiting all cgroup under tree. Please
   * be careful that "break" loop is not allowed. We have reference count.
   * Instead of that modify "cond" to be false and "continue" to exit the loop.
   */
  #define for_each_mem_cgroup_tree_cond(iter, root, cond)	\
  	for (iter = mem_cgroup_start_loop(root);\
  	     iter != NULL;\
  	     iter = mem_cgroup_get_next(iter, root, cond))
  
  #define for_each_mem_cgroup_tree(iter, root) \
  	for_each_mem_cgroup_tree_cond(iter, root, true)

  #define for_each_mem_cgroup_all(iter) \
  	for_each_mem_cgroup_tree_cond(iter, NULL, true)

  static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)

  {

  	return (memcg == root_mem_cgroup);

  }

  void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
  {

  	struct mem_cgroup *memcg;

  
  	if (!mm)
  		return;
  
  	rcu_read_lock();

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

  		goto out;
  
  	switch (idx) {
  	case PGMAJFAULT:

  		mem_cgroup_pgmajfault(memcg, 1);

  		break;
  	case PGFAULT:

  		mem_cgroup_pgfault(memcg, 1);

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

  /*
   * Following LRU functions are allowed to be used without PCG_LOCK.
   * Operations are called by routine of global LRU independently from memcg.
   * What we have to take care of here is validness of pc->mem_cgroup.
   *
   * Changes to pc->mem_cgroup happens when
   * 1. charge
   * 2. moving account
   * In typical case, "charge" is done before add-to-lru. Exception is SwapCache.
   * It is added to LRU before charge.
   * If PCG_USED bit is not set, page_cgroup is not added to this private LRU.
   * When moving account, the page is not on LRU. It's isolated.
   */

  void mem_cgroup_del_lru_list(struct page *page, enum lru_list lru)
  {
  	struct page_cgroup *pc;

  	struct mem_cgroup_per_zone *mz;

  	if (mem_cgroup_disabled())

  		return;
  	pc = lookup_page_cgroup(page);
  	/* can happen while we handle swapcache. */

  	if (!TestClearPageCgroupAcctLRU(pc))

  		return;

  	VM_BUG_ON(!pc->mem_cgroup);

  	/*
  	 * We don't check PCG_USED bit. It's cleared when the "page" is finally
  	 * removed from global LRU.
  	 */

  	mz = page_cgroup_zoneinfo(pc->mem_cgroup, page);

  	/* huge page split is done under lru_lock. so, we have no races. */
  	MEM_CGROUP_ZSTAT(mz, lru) -= 1 << compound_order(page);

  	if (mem_cgroup_is_root(pc->mem_cgroup))
  		return;
  	VM_BUG_ON(list_empty(&pc->lru));

  	list_del_init(&pc->lru);

  }

  void mem_cgroup_del_lru(struct page *page)

  {

  	mem_cgroup_del_lru_list(page, page_lru(page));
  }

  /*
   * Writeback is about to end against a page which has been marked for immediate
   * reclaim.  If it still appears to be reclaimable, move it to the tail of the
   * inactive list.
   */
  void mem_cgroup_rotate_reclaimable_page(struct page *page)
  {
  	struct mem_cgroup_per_zone *mz;
  	struct page_cgroup *pc;
  	enum lru_list lru = page_lru(page);
  
  	if (mem_cgroup_disabled())
  		return;
  
  	pc = lookup_page_cgroup(page);
  	/* unused or root page is not rotated. */
  	if (!PageCgroupUsed(pc))
  		return;
  	/* Ensure pc->mem_cgroup is visible after reading PCG_USED. */
  	smp_rmb();
  	if (mem_cgroup_is_root(pc->mem_cgroup))
  		return;

  	mz = page_cgroup_zoneinfo(pc->mem_cgroup, page);

  	list_move_tail(&pc->lru, &mz->lists[lru]);
  }

  void mem_cgroup_rotate_lru_list(struct page *page, enum lru_list lru)
  {
  	struct mem_cgroup_per_zone *mz;
  	struct page_cgroup *pc;

  	if (mem_cgroup_disabled())

  		return;

  	pc = lookup_page_cgroup(page);

  	/* unused or root page is not rotated. */

  	if (!PageCgroupUsed(pc))
  		return;
  	/* Ensure pc->mem_cgroup is visible after reading PCG_USED. */
  	smp_rmb();
  	if (mem_cgroup_is_root(pc->mem_cgroup))

  		return;

  	mz = page_cgroup_zoneinfo(pc->mem_cgroup, page);

  	list_move(&pc->lru, &mz->lists[lru]);

  }

  void mem_cgroup_add_lru_list(struct page *page, enum lru_list lru)

  {

  	struct page_cgroup *pc;
  	struct mem_cgroup_per_zone *mz;

  	if (mem_cgroup_disabled())

  		return;
  	pc = lookup_page_cgroup(page);

  	VM_BUG_ON(PageCgroupAcctLRU(pc));

  	/*
  	 * putback:				charge:
  	 * SetPageLRU				SetPageCgroupUsed
  	 * smp_mb				smp_mb
  	 * PageCgroupUsed && add to memcg LRU	PageLRU && add to memcg LRU
  	 *
  	 * Ensure that one of the two sides adds the page to the memcg
  	 * LRU during a race.
  	 */
  	smp_mb();

  	if (!PageCgroupUsed(pc))

  		return;

  	/* Ensure pc->mem_cgroup is visible after reading PCG_USED. */
  	smp_rmb();

  	mz = page_cgroup_zoneinfo(pc->mem_cgroup, page);

  	/* huge page split is done under lru_lock. so, we have no races. */
  	MEM_CGROUP_ZSTAT(mz, lru) += 1 << compound_order(page);

  	SetPageCgroupAcctLRU(pc);
  	if (mem_cgroup_is_root(pc->mem_cgroup))
  		return;

  	list_add(&pc->lru, &mz->lists[lru]);
  }

  /*

   * At handling SwapCache and other FUSE stuff, pc->mem_cgroup may be changed
   * while it's linked to lru because the page may be reused after it's fully
   * uncharged. To handle that, unlink page_cgroup from LRU when charge it again.
   * It's done under lock_page and expected that zone->lru_lock isnever held.

   */

  static void mem_cgroup_lru_del_before_commit(struct page *page)

  {

  	unsigned long flags;
  	struct zone *zone = page_zone(page);
  	struct page_cgroup *pc = lookup_page_cgroup(page);

  	/*
  	 * Doing this check without taking ->lru_lock seems wrong but this
  	 * is safe. Because if page_cgroup's USED bit is unset, the page
  	 * will not be added to any memcg's LRU. If page_cgroup's USED bit is
  	 * set, the commit after this will fail, anyway.
  	 * This all charge/uncharge is done under some mutual execustion.
  	 * So, we don't need to taking care of changes in USED bit.
  	 */
  	if (likely(!PageLRU(page)))
  		return;

  	spin_lock_irqsave(&zone->lru_lock, flags);
  	/*
  	 * Forget old LRU when this page_cgroup is *not* used. This Used bit
  	 * is guarded by lock_page() because the page is SwapCache.
  	 */
  	if (!PageCgroupUsed(pc))
  		mem_cgroup_del_lru_list(page, page_lru(page));
  	spin_unlock_irqrestore(&zone->lru_lock, flags);

  }

  static void mem_cgroup_lru_add_after_commit(struct page *page)

  {
  	unsigned long flags;
  	struct zone *zone = page_zone(page);
  	struct page_cgroup *pc = lookup_page_cgroup(page);

  	/*
  	 * putback:				charge:
  	 * SetPageLRU				SetPageCgroupUsed
  	 * smp_mb				smp_mb
  	 * PageCgroupUsed && add to memcg LRU	PageLRU && add to memcg LRU
  	 *
  	 * Ensure that one of the two sides adds the page to the memcg
  	 * LRU during a race.
  	 */
  	smp_mb();

  	/* taking care of that the page is added to LRU while we commit it */
  	if (likely(!PageLRU(page)))
  		return;

  	spin_lock_irqsave(&zone->lru_lock, flags);
  	/* link when the page is linked to LRU but page_cgroup isn't */

  	if (PageLRU(page) && !PageCgroupAcctLRU(pc))

  		mem_cgroup_add_lru_list(page, page_lru(page));
  	spin_unlock_irqrestore(&zone->lru_lock, flags);
  }

  void mem_cgroup_move_lists(struct page *page,
  			   enum lru_list from, enum lru_list to)
  {

  	if (mem_cgroup_disabled())

  		return;
  	mem_cgroup_del_lru_list(page, from);
  	mem_cgroup_add_lru_list(page, to);

  }

  /*

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

   * hierarchy subtree
   */

  static bool mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
  		struct mem_cgroup *memcg)

  {

  	if (root_memcg != memcg) {
  		return (root_memcg->use_hierarchy &&
  			css_is_ancestor(&memcg->css, &root_memcg->css));

  	}
  
  	return true;
  }

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

  {
  	int ret;

  	struct mem_cgroup *curr = NULL;

  	struct task_struct *p;

  	p = find_lock_task_mm(task);
  	if (!p)
  		return 0;
  	curr = try_get_mem_cgroup_from_mm(p->mm);
  	task_unlock(p);

  	if (!curr)
  		return 0;

  	/*

  	 * 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 mem_cgroup *memcg, struct zone *zone)

  {

  	unsigned long inactive_ratio;
  	int nid = zone_to_nid(zone);
  	int zid = zone_idx(zone);

  	unsigned long inactive;

  	unsigned long active;

  	unsigned long gb;

  	inactive = mem_cgroup_zone_nr_lru_pages(memcg, nid, zid,
  						BIT(LRU_INACTIVE_ANON));
  	active = mem_cgroup_zone_nr_lru_pages(memcg, nid, zid,
  					      BIT(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;

  }

  int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg, struct zone *zone)

  {
  	unsigned long active;
  	unsigned long inactive;

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

  	inactive = mem_cgroup_zone_nr_lru_pages(memcg, nid, zid,
  						BIT(LRU_INACTIVE_FILE));
  	active = mem_cgroup_zone_nr_lru_pages(memcg, nid, zid,
  					      BIT(LRU_ACTIVE_FILE));

  
  	return (active > inactive);
  }

  struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,
  						      struct zone *zone)
  {

  	int nid = zone_to_nid(zone);

  	int zid = zone_idx(zone);
  	struct mem_cgroup_per_zone *mz = mem_cgroup_zoneinfo(memcg, nid, zid);
  
  	return &mz->reclaim_stat;
  }
  
  struct zone_reclaim_stat *
  mem_cgroup_get_reclaim_stat_from_page(struct page *page)
  {
  	struct page_cgroup *pc;
  	struct mem_cgroup_per_zone *mz;
  
  	if (mem_cgroup_disabled())
  		return NULL;
  
  	pc = lookup_page_cgroup(page);

  	if (!PageCgroupUsed(pc))
  		return NULL;

  	/* Ensure pc->mem_cgroup is visible after reading PCG_USED. */
  	smp_rmb();

  	mz = page_cgroup_zoneinfo(pc->mem_cgroup, page);

  	return &mz->reclaim_stat;
  }

  unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
  					struct list_head *dst,
  					unsigned long *scanned, int order,

  					isolate_mode_t mode,
  					struct zone *z,

  					struct mem_cgroup *mem_cont,

  					int active, int file)

  {
  	unsigned long nr_taken = 0;
  	struct page *page;
  	unsigned long scan;
  	LIST_HEAD(pc_list);
  	struct list_head *src;

  	struct page_cgroup *pc, *tmp;

  	int nid = zone_to_nid(z);

  	int zid = zone_idx(z);
  	struct mem_cgroup_per_zone *mz;

  	int lru = LRU_FILE * file + active;

  	int ret;

  	BUG_ON(!mem_cont);

  	mz = mem_cgroup_zoneinfo(mem_cont, nid, zid);

  	src = &mz->lists[lru];

  	scan = 0;
  	list_for_each_entry_safe_reverse(pc, tmp, src, lru) {

  		if (scan >= nr_to_scan)

  			break;

  		if (unlikely(!PageCgroupUsed(pc)))
  			continue;

  		page = lookup_cgroup_page(pc);

  		if (unlikely(!PageLRU(page)))

  			continue;

  		scan++;

  		ret = __isolate_lru_page(page, mode, file);
  		switch (ret) {
  		case 0:

  			list_move(&page->lru, dst);

  			mem_cgroup_del_lru(page);

  			nr_taken += hpage_nr_pages(page);

  			break;
  		case -EBUSY:
  			/* we don't affect global LRU but rotate in our LRU */
  			mem_cgroup_rotate_lru_list(page, page_lru(page));
  			break;
  		default:
  			break;

  		}
  	}

  	*scanned = scan;

  
  	trace_mm_vmscan_memcg_isolate(0, nr_to_scan, scan, nr_taken,
  				      0, 0, 0, mode);

  	return nr_taken;
  }

  #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
   * @mem: 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;

  }

  int mem_cgroup_swappiness(struct mem_cgroup *memcg)

  {
  	struct cgroup *cgrp = memcg->css.cgroup;

  
  	/* root ? */
  	if (cgrp->parent == NULL)
  		return vm_swappiness;

  	return memcg->swappiness;

  }

  static void mem_cgroup_start_move(struct mem_cgroup *memcg)

  {
  	int cpu;

  
  	get_online_cpus();

  	spin_lock(&memcg->pcp_counter_lock);

  	for_each_online_cpu(cpu)

  		per_cpu(memcg->stat->count[MEM_CGROUP_ON_MOVE], cpu) += 1;
  	memcg->nocpu_base.count[MEM_CGROUP_ON_MOVE] += 1;
  	spin_unlock(&memcg->pcp_counter_lock);

  	put_online_cpus();

  
  	synchronize_rcu();
  }

  static void mem_cgroup_end_move(struct mem_cgroup *memcg)

  {
  	int cpu;

  	if (!memcg)

  		return;

  	get_online_cpus();

  	spin_lock(&memcg->pcp_counter_lock);

  	for_each_online_cpu(cpu)

  		per_cpu(memcg->stat->count[MEM_CGROUP_ON_MOVE], cpu) -= 1;
  	memcg->nocpu_base.count[MEM_CGROUP_ON_MOVE] -= 1;
  	spin_unlock(&memcg->pcp_counter_lock);

  	put_online_cpus();

  }
  /*
   * 2 routines for checking "mem" is under move_account() or not.
   *
   * mem_cgroup_stealed() - checking a cgroup is mc.from or not. This is used
   *			  for avoiding race in accounting. If true,
   *			  pc->mem_cgroup may be overwritten.
   *
   * mem_cgroup_under_move() - checking a cgroup is mc.from or mc.to or
   *			  under hierarchy of moving cgroups. This is for
   *			  waiting at hith-memory prressure caused by "move".
   */

  static bool mem_cgroup_stealed(struct mem_cgroup *memcg)

  {
  	VM_BUG_ON(!rcu_read_lock_held());

  	return this_cpu_read(memcg->stat->count[MEM_CGROUP_ON_MOVE]) > 0;

  }

  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_same_or_subtree(memcg, from)
  		|| mem_cgroup_same_or_subtree(memcg, to);

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

  /**

   * mem_cgroup_print_oom_info: Called from OOM with tasklist_lock held in read mode.

   * @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 cgroup *task_cgrp;
  	struct cgroup *mem_cgrp;
  	/*
  	 * Need a buffer in BSS, can't rely on allocations. The code relies
  	 * on the assumption that OOM is serialized for memory controller.
  	 * If this assumption is broken, revisit this code.
  	 */
  	static char memcg_name[PATH_MAX];
  	int ret;

  	if (!memcg || !p)

  		return;
  
  
  	rcu_read_lock();
  
  	mem_cgrp = memcg->css.cgroup;
  	task_cgrp = task_cgroup(p, mem_cgroup_subsys_id);
  
  	ret = cgroup_path(task_cgrp, memcg_name, PATH_MAX);
  	if (ret < 0) {
  		/*
  		 * Unfortunately, we are unable to convert to a useful name
  		 * But we'll still print out the usage information
  		 */
  		rcu_read_unlock();
  		goto done;
  	}
  	rcu_read_unlock();
  
  	printk(KERN_INFO "Task in %s killed", memcg_name);
  
  	rcu_read_lock();
  	ret = cgroup_path(mem_cgrp, memcg_name, PATH_MAX);
  	if (ret < 0) {
  		rcu_read_unlock();
  		goto done;
  	}
  	rcu_read_unlock();
  
  	/*
  	 * Continues from above, so we don't need an KERN_ level
  	 */
  	printk(KERN_CONT " as a result of limit of %s
  ", memcg_name);
  done:
  
  	printk(KERN_INFO "memory: usage %llukB, limit %llukB, failcnt %llu
  ",
  		res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
  		res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,
  		res_counter_read_u64(&memcg->res, RES_FAILCNT));
  	printk(KERN_INFO "memory+swap: usage %llukB, limit %llukB, "
  		"failcnt %llu
  ",
  		res_counter_read_u64(&memcg->memsw, RES_USAGE) >> 10,
  		res_counter_read_u64(&memcg->memsw, RES_LIMIT) >> 10,
  		res_counter_read_u64(&memcg->memsw, RES_FAILCNT));
  }

  /*
   * 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.
   */
  u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)
  {
  	u64 limit;
  	u64 memsw;

  	limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
  	limit += total_swap_pages << PAGE_SHIFT;

  	memsw = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
  	/*
  	 * If memsw is finite and limits the amount of swap space available
  	 * to this memcg, return that limit.
  	 */
  	return min(limit, memsw);
  }
  
  /*

   * Visit the first child (need not be the first child as per the ordering
   * of the cgroup list, since we track last_scanned_child) of @mem and use
   * that to reclaim free pages from.
   */
  static struct mem_cgroup *

  mem_cgroup_select_victim(struct mem_cgroup *root_memcg)

  {
  	struct mem_cgroup *ret = NULL;
  	struct cgroup_subsys_state *css;
  	int nextid, found;

  	if (!root_memcg->use_hierarchy) {
  		css_get(&root_memcg->css);
  		ret = root_memcg;

  	}
  
  	while (!ret) {
  		rcu_read_lock();

  		nextid = root_memcg->last_scanned_child + 1;
  		css = css_get_next(&mem_cgroup_subsys, nextid, &root_memcg->css,

  				   &found);
  		if (css && css_tryget(css))
  			ret = container_of(css, struct mem_cgroup, css);
  
  		rcu_read_unlock();
  		/* Updates scanning parameter */

  		if (!css) {
  			/* this means start scan from ID:1 */

  			root_memcg->last_scanned_child = 0;

  		} else

  			root_memcg->last_scanned_child = found;

  	}
  
  	return ret;
  }

  /**
   * test_mem_cgroup_node_reclaimable
   * @mem: 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;
  
  }

  #if MAX_NUMNODES > 1
  
  /*
   * 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_HIGH_MEMORY];

  
  	for_each_node_mask(nid, node_states[N_HIGH_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(node, memcg->scan_nodes);

  	if (node == MAX_NUMNODES)

  		node = first_node(memcg->scan_nodes);

  	/*
  	 * We call this when we hit limit, not when pages are added to LRU.
  	 * No LRU may hold pages because all pages are UNEVICTABLE or
  	 * memcg is too small and all pages are not on LRU. In that case,
  	 * we use curret node.
  	 */
  	if (unlikely(node == MAX_NUMNODES))
  		node = numa_node_id();

  	memcg->last_scanned_node = node;

  	return node;
  }

  /*
   * Check all nodes whether it contains reclaimable pages or not.
   * For quick scan, we make use of scan_nodes. This will allow us to skip
   * unused nodes. But scan_nodes is lazily updated and may not cotain
   * enough new information. We need to do double check.
   */

  bool mem_cgroup_reclaimable(struct mem_cgroup *memcg, bool noswap)