memcg: fix shrinking memory to return -EBUSY by fixing retry algorithm
[linux-2.6.git] / mm / memcontrol.c
1 /* memcontrol.c - Memory Controller
2  *
3  * Copyright IBM Corporation, 2007
4  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
5  *
6  * Copyright 2007 OpenVZ SWsoft Inc
7  * Author: Pavel Emelianov <xemul@openvz.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  */
19
20 #include <linux/res_counter.h>
21 #include <linux/memcontrol.h>
22 #include <linux/cgroup.h>
23 #include <linux/mm.h>
24 #include <linux/pagemap.h>
25 #include <linux/smp.h>
26 #include <linux/page-flags.h>
27 #include <linux/backing-dev.h>
28 #include <linux/bit_spinlock.h>
29 #include <linux/rcupdate.h>
30 #include <linux/mutex.h>
31 #include <linux/slab.h>
32 #include <linux/swap.h>
33 #include <linux/spinlock.h>
34 #include <linux/fs.h>
35 #include <linux/seq_file.h>
36 #include <linux/vmalloc.h>
37 #include <linux/mm_inline.h>
38 #include <linux/page_cgroup.h>
39 #include "internal.h"
40
41 #include <asm/uaccess.h>
42
43 struct cgroup_subsys mem_cgroup_subsys __read_mostly;
44 #define MEM_CGROUP_RECLAIM_RETRIES      5
45
46 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
47 /* Turned on only when memory cgroup is enabled && really_do_swap_account = 0 */
48 int do_swap_account __read_mostly;
49 static int really_do_swap_account __initdata = 1; /* for remember boot option*/
50 #else
51 #define do_swap_account         (0)
52 #endif
53
54 static DEFINE_MUTEX(memcg_tasklist);    /* can be hold under cgroup_mutex */
55
56 /*
57  * Statistics for memory cgroup.
58  */
59 enum mem_cgroup_stat_index {
60         /*
61          * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
62          */
63         MEM_CGROUP_STAT_CACHE,     /* # of pages charged as cache */
64         MEM_CGROUP_STAT_RSS,       /* # of pages charged as rss */
65         MEM_CGROUP_STAT_PGPGIN_COUNT,   /* # of pages paged in */
66         MEM_CGROUP_STAT_PGPGOUT_COUNT,  /* # of pages paged out */
67
68         MEM_CGROUP_STAT_NSTATS,
69 };
70
71 struct mem_cgroup_stat_cpu {
72         s64 count[MEM_CGROUP_STAT_NSTATS];
73 } ____cacheline_aligned_in_smp;
74
75 struct mem_cgroup_stat {
76         struct mem_cgroup_stat_cpu cpustat[0];
77 };
78
79 /*
80  * For accounting under irq disable, no need for increment preempt count.
81  */
82 static inline void __mem_cgroup_stat_add_safe(struct mem_cgroup_stat_cpu *stat,
83                 enum mem_cgroup_stat_index idx, int val)
84 {
85         stat->count[idx] += val;
86 }
87
88 static s64 mem_cgroup_read_stat(struct mem_cgroup_stat *stat,
89                 enum mem_cgroup_stat_index idx)
90 {
91         int cpu;
92         s64 ret = 0;
93         for_each_possible_cpu(cpu)
94                 ret += stat->cpustat[cpu].count[idx];
95         return ret;
96 }
97
98 static s64 mem_cgroup_local_usage(struct mem_cgroup_stat *stat)
99 {
100         s64 ret;
101
102         ret = mem_cgroup_read_stat(stat, MEM_CGROUP_STAT_CACHE);
103         ret += mem_cgroup_read_stat(stat, MEM_CGROUP_STAT_RSS);
104         return ret;
105 }
106
107 /*
108  * per-zone information in memory controller.
109  */
110 struct mem_cgroup_per_zone {
111         /*
112          * spin_lock to protect the per cgroup LRU
113          */
114         struct list_head        lists[NR_LRU_LISTS];
115         unsigned long           count[NR_LRU_LISTS];
116
117         struct zone_reclaim_stat reclaim_stat;
118 };
119 /* Macro for accessing counter */
120 #define MEM_CGROUP_ZSTAT(mz, idx)       ((mz)->count[(idx)])
121
122 struct mem_cgroup_per_node {
123         struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
124 };
125
126 struct mem_cgroup_lru_info {
127         struct mem_cgroup_per_node *nodeinfo[MAX_NUMNODES];
128 };
129
130 /*
131  * The memory controller data structure. The memory controller controls both
132  * page cache and RSS per cgroup. We would eventually like to provide
133  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
134  * to help the administrator determine what knobs to tune.
135  *
136  * TODO: Add a water mark for the memory controller. Reclaim will begin when
137  * we hit the water mark. May be even add a low water mark, such that
138  * no reclaim occurs from a cgroup at it's low water mark, this is
139  * a feature that will be implemented much later in the future.
140  */
141 struct mem_cgroup {
142         struct cgroup_subsys_state css;
143         /*
144          * the counter to account for memory usage
145          */
146         struct res_counter res;
147         /*
148          * the counter to account for mem+swap usage.
149          */
150         struct res_counter memsw;
151         /*
152          * Per cgroup active and inactive list, similar to the
153          * per zone LRU lists.
154          */
155         struct mem_cgroup_lru_info info;
156
157         /*
158           protect against reclaim related member.
159         */
160         spinlock_t reclaim_param_lock;
161
162         int     prev_priority;  /* for recording reclaim priority */
163
164         /*
165          * While reclaiming in a hiearchy, we cache the last child we
166          * reclaimed from.
167          */
168         int last_scanned_child;
169         /*
170          * Should the accounting and control be hierarchical, per subtree?
171          */
172         bool use_hierarchy;
173         unsigned long   last_oom_jiffies;
174         atomic_t        refcnt;
175
176         unsigned int    swappiness;
177
178         /*
179          * statistics. This must be placed at the end of memcg.
180          */
181         struct mem_cgroup_stat stat;
182 };
183
184 enum charge_type {
185         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
186         MEM_CGROUP_CHARGE_TYPE_MAPPED,
187         MEM_CGROUP_CHARGE_TYPE_SHMEM,   /* used by page migration of shmem */
188         MEM_CGROUP_CHARGE_TYPE_FORCE,   /* used by force_empty */
189         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
190         NR_CHARGE_TYPE,
191 };
192
193 /* only for here (for easy reading.) */
194 #define PCGF_CACHE      (1UL << PCG_CACHE)
195 #define PCGF_USED       (1UL << PCG_USED)
196 #define PCGF_LOCK       (1UL << PCG_LOCK)
197 static const unsigned long
198 pcg_default_flags[NR_CHARGE_TYPE] = {
199         PCGF_CACHE | PCGF_USED | PCGF_LOCK, /* File Cache */
200         PCGF_USED | PCGF_LOCK, /* Anon */
201         PCGF_CACHE | PCGF_USED | PCGF_LOCK, /* Shmem */
202         0, /* FORCE */
203 };
204
205 /* for encoding cft->private value on file */
206 #define _MEM                    (0)
207 #define _MEMSWAP                (1)
208 #define MEMFILE_PRIVATE(x, val) (((x) << 16) | (val))
209 #define MEMFILE_TYPE(val)       (((val) >> 16) & 0xffff)
210 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
211
212 static void mem_cgroup_get(struct mem_cgroup *mem);
213 static void mem_cgroup_put(struct mem_cgroup *mem);
214 static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *mem);
215
216 static void mem_cgroup_charge_statistics(struct mem_cgroup *mem,
217                                          struct page_cgroup *pc,
218                                          bool charge)
219 {
220         int val = (charge)? 1 : -1;
221         struct mem_cgroup_stat *stat = &mem->stat;
222         struct mem_cgroup_stat_cpu *cpustat;
223         int cpu = get_cpu();
224
225         cpustat = &stat->cpustat[cpu];
226         if (PageCgroupCache(pc))
227                 __mem_cgroup_stat_add_safe(cpustat, MEM_CGROUP_STAT_CACHE, val);
228         else
229                 __mem_cgroup_stat_add_safe(cpustat, MEM_CGROUP_STAT_RSS, val);
230
231         if (charge)
232                 __mem_cgroup_stat_add_safe(cpustat,
233                                 MEM_CGROUP_STAT_PGPGIN_COUNT, 1);
234         else
235                 __mem_cgroup_stat_add_safe(cpustat,
236                                 MEM_CGROUP_STAT_PGPGOUT_COUNT, 1);
237         put_cpu();
238 }
239
240 static struct mem_cgroup_per_zone *
241 mem_cgroup_zoneinfo(struct mem_cgroup *mem, int nid, int zid)
242 {
243         return &mem->info.nodeinfo[nid]->zoneinfo[zid];
244 }
245
246 static struct mem_cgroup_per_zone *
247 page_cgroup_zoneinfo(struct page_cgroup *pc)
248 {
249         struct mem_cgroup *mem = pc->mem_cgroup;
250         int nid = page_cgroup_nid(pc);
251         int zid = page_cgroup_zid(pc);
252
253         if (!mem)
254                 return NULL;
255
256         return mem_cgroup_zoneinfo(mem, nid, zid);
257 }
258
259 static unsigned long mem_cgroup_get_local_zonestat(struct mem_cgroup *mem,
260                                         enum lru_list idx)
261 {
262         int nid, zid;
263         struct mem_cgroup_per_zone *mz;
264         u64 total = 0;
265
266         for_each_online_node(nid)
267                 for (zid = 0; zid < MAX_NR_ZONES; zid++) {
268                         mz = mem_cgroup_zoneinfo(mem, nid, zid);
269                         total += MEM_CGROUP_ZSTAT(mz, idx);
270                 }
271         return total;
272 }
273
274 static struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont)
275 {
276         return container_of(cgroup_subsys_state(cont,
277                                 mem_cgroup_subsys_id), struct mem_cgroup,
278                                 css);
279 }
280
281 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
282 {
283         /*
284          * mm_update_next_owner() may clear mm->owner to NULL
285          * if it races with swapoff, page migration, etc.
286          * So this can be called with p == NULL.
287          */
288         if (unlikely(!p))
289                 return NULL;
290
291         return container_of(task_subsys_state(p, mem_cgroup_subsys_id),
292                                 struct mem_cgroup, css);
293 }
294
295 static struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
296 {
297         struct mem_cgroup *mem = NULL;
298         /*
299          * Because we have no locks, mm->owner's may be being moved to other
300          * cgroup. We use css_tryget() here even if this looks
301          * pessimistic (rather than adding locks here).
302          */
303         rcu_read_lock();
304         do {
305                 mem = mem_cgroup_from_task(rcu_dereference(mm->owner));
306                 if (unlikely(!mem))
307                         break;
308         } while (!css_tryget(&mem->css));
309         rcu_read_unlock();
310         return mem;
311 }
312
313 static bool mem_cgroup_is_obsolete(struct mem_cgroup *mem)
314 {
315         if (!mem)
316                 return true;
317         return css_is_removed(&mem->css);
318 }
319
320
321 /*
322  * Call callback function against all cgroup under hierarchy tree.
323  */
324 static int mem_cgroup_walk_tree(struct mem_cgroup *root, void *data,
325                           int (*func)(struct mem_cgroup *, void *))
326 {
327         int found, ret, nextid;
328         struct cgroup_subsys_state *css;
329         struct mem_cgroup *mem;
330
331         if (!root->use_hierarchy)
332                 return (*func)(root, data);
333
334         nextid = 1;
335         do {
336                 ret = 0;
337                 mem = NULL;
338
339                 rcu_read_lock();
340                 css = css_get_next(&mem_cgroup_subsys, nextid, &root->css,
341                                    &found);
342                 if (css && css_tryget(css))
343                         mem = container_of(css, struct mem_cgroup, css);
344                 rcu_read_unlock();
345
346                 if (mem) {
347                         ret = (*func)(mem, data);
348                         css_put(&mem->css);
349                 }
350                 nextid = found + 1;
351         } while (!ret && css);
352
353         return ret;
354 }
355
356 /*
357  * Following LRU functions are allowed to be used without PCG_LOCK.
358  * Operations are called by routine of global LRU independently from memcg.
359  * What we have to take care of here is validness of pc->mem_cgroup.
360  *
361  * Changes to pc->mem_cgroup happens when
362  * 1. charge
363  * 2. moving account
364  * In typical case, "charge" is done before add-to-lru. Exception is SwapCache.
365  * It is added to LRU before charge.
366  * If PCG_USED bit is not set, page_cgroup is not added to this private LRU.
367  * When moving account, the page is not on LRU. It's isolated.
368  */
369
370 void mem_cgroup_del_lru_list(struct page *page, enum lru_list lru)
371 {
372         struct page_cgroup *pc;
373         struct mem_cgroup *mem;
374         struct mem_cgroup_per_zone *mz;
375
376         if (mem_cgroup_disabled())
377                 return;
378         pc = lookup_page_cgroup(page);
379         /* can happen while we handle swapcache. */
380         if (list_empty(&pc->lru) || !pc->mem_cgroup)
381                 return;
382         /*
383          * We don't check PCG_USED bit. It's cleared when the "page" is finally
384          * removed from global LRU.
385          */
386         mz = page_cgroup_zoneinfo(pc);
387         mem = pc->mem_cgroup;
388         MEM_CGROUP_ZSTAT(mz, lru) -= 1;
389         list_del_init(&pc->lru);
390         return;
391 }
392
393 void mem_cgroup_del_lru(struct page *page)
394 {
395         mem_cgroup_del_lru_list(page, page_lru(page));
396 }
397
398 void mem_cgroup_rotate_lru_list(struct page *page, enum lru_list lru)
399 {
400         struct mem_cgroup_per_zone *mz;
401         struct page_cgroup *pc;
402
403         if (mem_cgroup_disabled())
404                 return;
405
406         pc = lookup_page_cgroup(page);
407         /*
408          * Used bit is set without atomic ops but after smp_wmb().
409          * For making pc->mem_cgroup visible, insert smp_rmb() here.
410          */
411         smp_rmb();
412         /* unused page is not rotated. */
413         if (!PageCgroupUsed(pc))
414                 return;
415         mz = page_cgroup_zoneinfo(pc);
416         list_move(&pc->lru, &mz->lists[lru]);
417 }
418
419 void mem_cgroup_add_lru_list(struct page *page, enum lru_list lru)
420 {
421         struct page_cgroup *pc;
422         struct mem_cgroup_per_zone *mz;
423
424         if (mem_cgroup_disabled())
425                 return;
426         pc = lookup_page_cgroup(page);
427         /*
428          * Used bit is set without atomic ops but after smp_wmb().
429          * For making pc->mem_cgroup visible, insert smp_rmb() here.
430          */
431         smp_rmb();
432         if (!PageCgroupUsed(pc))
433                 return;
434
435         mz = page_cgroup_zoneinfo(pc);
436         MEM_CGROUP_ZSTAT(mz, lru) += 1;
437         list_add(&pc->lru, &mz->lists[lru]);
438 }
439
440 /*
441  * At handling SwapCache, pc->mem_cgroup may be changed while it's linked to
442  * lru because the page may.be reused after it's fully uncharged (because of
443  * SwapCache behavior).To handle that, unlink page_cgroup from LRU when charge
444  * it again. This function is only used to charge SwapCache. It's done under
445  * lock_page and expected that zone->lru_lock is never held.
446  */
447 static void mem_cgroup_lru_del_before_commit_swapcache(struct page *page)
448 {
449         unsigned long flags;
450         struct zone *zone = page_zone(page);
451         struct page_cgroup *pc = lookup_page_cgroup(page);
452
453         spin_lock_irqsave(&zone->lru_lock, flags);
454         /*
455          * Forget old LRU when this page_cgroup is *not* used. This Used bit
456          * is guarded by lock_page() because the page is SwapCache.
457          */
458         if (!PageCgroupUsed(pc))
459                 mem_cgroup_del_lru_list(page, page_lru(page));
460         spin_unlock_irqrestore(&zone->lru_lock, flags);
461 }
462
463 static void mem_cgroup_lru_add_after_commit_swapcache(struct page *page)
464 {
465         unsigned long flags;
466         struct zone *zone = page_zone(page);
467         struct page_cgroup *pc = lookup_page_cgroup(page);
468
469         spin_lock_irqsave(&zone->lru_lock, flags);
470         /* link when the page is linked to LRU but page_cgroup isn't */
471         if (PageLRU(page) && list_empty(&pc->lru))
472                 mem_cgroup_add_lru_list(page, page_lru(page));
473         spin_unlock_irqrestore(&zone->lru_lock, flags);
474 }
475
476
477 void mem_cgroup_move_lists(struct page *page,
478                            enum lru_list from, enum lru_list to)
479 {
480         if (mem_cgroup_disabled())
481                 return;
482         mem_cgroup_del_lru_list(page, from);
483         mem_cgroup_add_lru_list(page, to);
484 }
485
486 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem)
487 {
488         int ret;
489
490         task_lock(task);
491         ret = task->mm && mm_match_cgroup(task->mm, mem);
492         task_unlock(task);
493         return ret;
494 }
495
496 /*
497  * Calculate mapped_ratio under memory controller. This will be used in
498  * vmscan.c for deteremining we have to reclaim mapped pages.
499  */
500 int mem_cgroup_calc_mapped_ratio(struct mem_cgroup *mem)
501 {
502         long total, rss;
503
504         /*
505          * usage is recorded in bytes. But, here, we assume the number of
506          * physical pages can be represented by "long" on any arch.
507          */
508         total = (long) (mem->res.usage >> PAGE_SHIFT) + 1L;
509         rss = (long)mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_RSS);
510         return (int)((rss * 100L) / total);
511 }
512
513 /*
514  * prev_priority control...this will be used in memory reclaim path.
515  */
516 int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem)
517 {
518         int prev_priority;
519
520         spin_lock(&mem->reclaim_param_lock);
521         prev_priority = mem->prev_priority;
522         spin_unlock(&mem->reclaim_param_lock);
523
524         return prev_priority;
525 }
526
527 void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem, int priority)
528 {
529         spin_lock(&mem->reclaim_param_lock);
530         if (priority < mem->prev_priority)
531                 mem->prev_priority = priority;
532         spin_unlock(&mem->reclaim_param_lock);
533 }
534
535 void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem, int priority)
536 {
537         spin_lock(&mem->reclaim_param_lock);
538         mem->prev_priority = priority;
539         spin_unlock(&mem->reclaim_param_lock);
540 }
541
542 static int calc_inactive_ratio(struct mem_cgroup *memcg, unsigned long *present_pages)
543 {
544         unsigned long active;
545         unsigned long inactive;
546         unsigned long gb;
547         unsigned long inactive_ratio;
548
549         inactive = mem_cgroup_get_local_zonestat(memcg, LRU_INACTIVE_ANON);
550         active = mem_cgroup_get_local_zonestat(memcg, LRU_ACTIVE_ANON);
551
552         gb = (inactive + active) >> (30 - PAGE_SHIFT);
553         if (gb)
554                 inactive_ratio = int_sqrt(10 * gb);
555         else
556                 inactive_ratio = 1;
557
558         if (present_pages) {
559                 present_pages[0] = inactive;
560                 present_pages[1] = active;
561         }
562
563         return inactive_ratio;
564 }
565
566 int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg)
567 {
568         unsigned long active;
569         unsigned long inactive;
570         unsigned long present_pages[2];
571         unsigned long inactive_ratio;
572
573         inactive_ratio = calc_inactive_ratio(memcg, present_pages);
574
575         inactive = present_pages[0];
576         active = present_pages[1];
577
578         if (inactive * inactive_ratio < active)
579                 return 1;
580
581         return 0;
582 }
583
584 unsigned long mem_cgroup_zone_nr_pages(struct mem_cgroup *memcg,
585                                        struct zone *zone,
586                                        enum lru_list lru)
587 {
588         int nid = zone->zone_pgdat->node_id;
589         int zid = zone_idx(zone);
590         struct mem_cgroup_per_zone *mz = mem_cgroup_zoneinfo(memcg, nid, zid);
591
592         return MEM_CGROUP_ZSTAT(mz, lru);
593 }
594
595 struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,
596                                                       struct zone *zone)
597 {
598         int nid = zone->zone_pgdat->node_id;
599         int zid = zone_idx(zone);
600         struct mem_cgroup_per_zone *mz = mem_cgroup_zoneinfo(memcg, nid, zid);
601
602         return &mz->reclaim_stat;
603 }
604
605 struct zone_reclaim_stat *
606 mem_cgroup_get_reclaim_stat_from_page(struct page *page)
607 {
608         struct page_cgroup *pc;
609         struct mem_cgroup_per_zone *mz;
610
611         if (mem_cgroup_disabled())
612                 return NULL;
613
614         pc = lookup_page_cgroup(page);
615         /*
616          * Used bit is set without atomic ops but after smp_wmb().
617          * For making pc->mem_cgroup visible, insert smp_rmb() here.
618          */
619         smp_rmb();
620         if (!PageCgroupUsed(pc))
621                 return NULL;
622
623         mz = page_cgroup_zoneinfo(pc);
624         if (!mz)
625                 return NULL;
626
627         return &mz->reclaim_stat;
628 }
629
630 unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
631                                         struct list_head *dst,
632                                         unsigned long *scanned, int order,
633                                         int mode, struct zone *z,
634                                         struct mem_cgroup *mem_cont,
635                                         int active, int file)
636 {
637         unsigned long nr_taken = 0;
638         struct page *page;
639         unsigned long scan;
640         LIST_HEAD(pc_list);
641         struct list_head *src;
642         struct page_cgroup *pc, *tmp;
643         int nid = z->zone_pgdat->node_id;
644         int zid = zone_idx(z);
645         struct mem_cgroup_per_zone *mz;
646         int lru = LRU_FILE * !!file + !!active;
647
648         BUG_ON(!mem_cont);
649         mz = mem_cgroup_zoneinfo(mem_cont, nid, zid);
650         src = &mz->lists[lru];
651
652         scan = 0;
653         list_for_each_entry_safe_reverse(pc, tmp, src, lru) {
654                 if (scan >= nr_to_scan)
655                         break;
656
657                 page = pc->page;
658                 if (unlikely(!PageCgroupUsed(pc)))
659                         continue;
660                 if (unlikely(!PageLRU(page)))
661                         continue;
662
663                 scan++;
664                 if (__isolate_lru_page(page, mode, file) == 0) {
665                         list_move(&page->lru, dst);
666                         nr_taken++;
667                 }
668         }
669
670         *scanned = scan;
671         return nr_taken;
672 }
673
674 #define mem_cgroup_from_res_counter(counter, member)    \
675         container_of(counter, struct mem_cgroup, member)
676
677 static bool mem_cgroup_check_under_limit(struct mem_cgroup *mem)
678 {
679         if (do_swap_account) {
680                 if (res_counter_check_under_limit(&mem->res) &&
681                         res_counter_check_under_limit(&mem->memsw))
682                         return true;
683         } else
684                 if (res_counter_check_under_limit(&mem->res))
685                         return true;
686         return false;
687 }
688
689 static unsigned int get_swappiness(struct mem_cgroup *memcg)
690 {
691         struct cgroup *cgrp = memcg->css.cgroup;
692         unsigned int swappiness;
693
694         /* root ? */
695         if (cgrp->parent == NULL)
696                 return vm_swappiness;
697
698         spin_lock(&memcg->reclaim_param_lock);
699         swappiness = memcg->swappiness;
700         spin_unlock(&memcg->reclaim_param_lock);
701
702         return swappiness;
703 }
704
705 static int mem_cgroup_count_children_cb(struct mem_cgroup *mem, void *data)
706 {
707         int *val = data;
708         (*val)++;
709         return 0;
710 }
711 /*
712  * This function returns the number of memcg under hierarchy tree. Returns
713  * 1(self count) if no children.
714  */
715 static int mem_cgroup_count_children(struct mem_cgroup *mem)
716 {
717         int num = 0;
718         mem_cgroup_walk_tree(mem, &num, mem_cgroup_count_children_cb);
719         return num;
720 }
721
722 /*
723  * Visit the first child (need not be the first child as per the ordering
724  * of the cgroup list, since we track last_scanned_child) of @mem and use
725  * that to reclaim free pages from.
726  */
727 static struct mem_cgroup *
728 mem_cgroup_select_victim(struct mem_cgroup *root_mem)
729 {
730         struct mem_cgroup *ret = NULL;
731         struct cgroup_subsys_state *css;
732         int nextid, found;
733
734         if (!root_mem->use_hierarchy) {
735                 css_get(&root_mem->css);
736                 ret = root_mem;
737         }
738
739         while (!ret) {
740                 rcu_read_lock();
741                 nextid = root_mem->last_scanned_child + 1;
742                 css = css_get_next(&mem_cgroup_subsys, nextid, &root_mem->css,
743                                    &found);
744                 if (css && css_tryget(css))
745                         ret = container_of(css, struct mem_cgroup, css);
746
747                 rcu_read_unlock();
748                 /* Updates scanning parameter */
749                 spin_lock(&root_mem->reclaim_param_lock);
750                 if (!css) {
751                         /* this means start scan from ID:1 */
752                         root_mem->last_scanned_child = 0;
753                 } else
754                         root_mem->last_scanned_child = found;
755                 spin_unlock(&root_mem->reclaim_param_lock);
756         }
757
758         return ret;
759 }
760
761 /*
762  * Scan the hierarchy if needed to reclaim memory. We remember the last child
763  * we reclaimed from, so that we don't end up penalizing one child extensively
764  * based on its position in the children list.
765  *
766  * root_mem is the original ancestor that we've been reclaim from.
767  *
768  * We give up and return to the caller when we visit root_mem twice.
769  * (other groups can be removed while we're walking....)
770  *
771  * If shrink==true, for avoiding to free too much, this returns immedieately.
772  */
773 static int mem_cgroup_hierarchical_reclaim(struct mem_cgroup *root_mem,
774                                    gfp_t gfp_mask, bool noswap, bool shrink)
775 {
776         struct mem_cgroup *victim;
777         int ret, total = 0;
778         int loop = 0;
779
780         while (loop < 2) {
781                 victim = mem_cgroup_select_victim(root_mem);
782                 if (victim == root_mem)
783                         loop++;
784                 if (!mem_cgroup_local_usage(&victim->stat)) {
785                         /* this cgroup's local usage == 0 */
786                         css_put(&victim->css);
787                         continue;
788                 }
789                 /* we use swappiness of local cgroup */
790                 ret = try_to_free_mem_cgroup_pages(victim, gfp_mask, noswap,
791                                                    get_swappiness(victim));
792                 css_put(&victim->css);
793                 /*
794                  * At shrinking usage, we can't check we should stop here or
795                  * reclaim more. It's depends on callers. last_scanned_child
796                  * will work enough for keeping fairness under tree.
797                  */
798                 if (shrink)
799                         return ret;
800                 total += ret;
801                 if (mem_cgroup_check_under_limit(root_mem))
802                         return 1 + total;
803         }
804         return total;
805 }
806
807 bool mem_cgroup_oom_called(struct task_struct *task)
808 {
809         bool ret = false;
810         struct mem_cgroup *mem;
811         struct mm_struct *mm;
812
813         rcu_read_lock();
814         mm = task->mm;
815         if (!mm)
816                 mm = &init_mm;
817         mem = mem_cgroup_from_task(rcu_dereference(mm->owner));
818         if (mem && time_before(jiffies, mem->last_oom_jiffies + HZ/10))
819                 ret = true;
820         rcu_read_unlock();
821         return ret;
822 }
823 /*
824  * Unlike exported interface, "oom" parameter is added. if oom==true,
825  * oom-killer can be invoked.
826  */
827 static int __mem_cgroup_try_charge(struct mm_struct *mm,
828                         gfp_t gfp_mask, struct mem_cgroup **memcg,
829                         bool oom)
830 {
831         struct mem_cgroup *mem, *mem_over_limit;
832         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
833         struct res_counter *fail_res;
834
835         if (unlikely(test_thread_flag(TIF_MEMDIE))) {
836                 /* Don't account this! */
837                 *memcg = NULL;
838                 return 0;
839         }
840
841         /*
842          * We always charge the cgroup the mm_struct belongs to.
843          * The mm_struct's mem_cgroup changes on task migration if the
844          * thread group leader migrates. It's possible that mm is not
845          * set, if so charge the init_mm (happens for pagecache usage).
846          */
847         mem = *memcg;
848         if (likely(!mem)) {
849                 mem = try_get_mem_cgroup_from_mm(mm);
850                 *memcg = mem;
851         } else {
852                 css_get(&mem->css);
853         }
854         if (unlikely(!mem))
855                 return 0;
856
857         VM_BUG_ON(mem_cgroup_is_obsolete(mem));
858
859         while (1) {
860                 int ret;
861                 bool noswap = false;
862
863                 ret = res_counter_charge(&mem->res, PAGE_SIZE, &fail_res);
864                 if (likely(!ret)) {
865                         if (!do_swap_account)
866                                 break;
867                         ret = res_counter_charge(&mem->memsw, PAGE_SIZE,
868                                                         &fail_res);
869                         if (likely(!ret))
870                                 break;
871                         /* mem+swap counter fails */
872                         res_counter_uncharge(&mem->res, PAGE_SIZE);
873                         noswap = true;
874                         mem_over_limit = mem_cgroup_from_res_counter(fail_res,
875                                                                         memsw);
876                 } else
877                         /* mem counter fails */
878                         mem_over_limit = mem_cgroup_from_res_counter(fail_res,
879                                                                         res);
880
881                 if (!(gfp_mask & __GFP_WAIT))
882                         goto nomem;
883
884                 ret = mem_cgroup_hierarchical_reclaim(mem_over_limit, gfp_mask,
885                                                         noswap, false);
886                 if (ret)
887                         continue;
888
889                 /*
890                  * try_to_free_mem_cgroup_pages() might not give us a full
891                  * picture of reclaim. Some pages are reclaimed and might be
892                  * moved to swap cache or just unmapped from the cgroup.
893                  * Check the limit again to see if the reclaim reduced the
894                  * current usage of the cgroup before giving up
895                  *
896                  */
897                 if (mem_cgroup_check_under_limit(mem_over_limit))
898                         continue;
899
900                 if (!nr_retries--) {
901                         if (oom) {
902                                 mutex_lock(&memcg_tasklist);
903                                 mem_cgroup_out_of_memory(mem_over_limit, gfp_mask);
904                                 mutex_unlock(&memcg_tasklist);
905                                 mem_over_limit->last_oom_jiffies = jiffies;
906                         }
907                         goto nomem;
908                 }
909         }
910         return 0;
911 nomem:
912         css_put(&mem->css);
913         return -ENOMEM;
914 }
915
916 static struct mem_cgroup *try_get_mem_cgroup_from_swapcache(struct page *page)
917 {
918         struct mem_cgroup *mem;
919         swp_entry_t ent;
920
921         if (!PageSwapCache(page))
922                 return NULL;
923
924         ent.val = page_private(page);
925         mem = lookup_swap_cgroup(ent);
926         if (!mem)
927                 return NULL;
928         if (!css_tryget(&mem->css))
929                 return NULL;
930         return mem;
931 }
932
933 /*
934  * commit a charge got by __mem_cgroup_try_charge() and makes page_cgroup to be
935  * USED state. If already USED, uncharge and return.
936  */
937
938 static void __mem_cgroup_commit_charge(struct mem_cgroup *mem,
939                                      struct page_cgroup *pc,
940                                      enum charge_type ctype)
941 {
942         /* try_charge() can return NULL to *memcg, taking care of it. */
943         if (!mem)
944                 return;
945
946         lock_page_cgroup(pc);
947         if (unlikely(PageCgroupUsed(pc))) {
948                 unlock_page_cgroup(pc);
949                 res_counter_uncharge(&mem->res, PAGE_SIZE);
950                 if (do_swap_account)
951                         res_counter_uncharge(&mem->memsw, PAGE_SIZE);
952                 css_put(&mem->css);
953                 return;
954         }
955         pc->mem_cgroup = mem;
956         smp_wmb();
957         pc->flags = pcg_default_flags[ctype];
958
959         mem_cgroup_charge_statistics(mem, pc, true);
960
961         unlock_page_cgroup(pc);
962 }
963
964 /**
965  * mem_cgroup_move_account - move account of the page
966  * @pc: page_cgroup of the page.
967  * @from: mem_cgroup which the page is moved from.
968  * @to: mem_cgroup which the page is moved to. @from != @to.
969  *
970  * The caller must confirm following.
971  * - page is not on LRU (isolate_page() is useful.)
972  *
973  * returns 0 at success,
974  * returns -EBUSY when lock is busy or "pc" is unstable.
975  *
976  * This function does "uncharge" from old cgroup but doesn't do "charge" to
977  * new cgroup. It should be done by a caller.
978  */
979
980 static int mem_cgroup_move_account(struct page_cgroup *pc,
981         struct mem_cgroup *from, struct mem_cgroup *to)
982 {
983         struct mem_cgroup_per_zone *from_mz, *to_mz;
984         int nid, zid;
985         int ret = -EBUSY;
986
987         VM_BUG_ON(from == to);
988         VM_BUG_ON(PageLRU(pc->page));
989
990         nid = page_cgroup_nid(pc);
991         zid = page_cgroup_zid(pc);
992         from_mz =  mem_cgroup_zoneinfo(from, nid, zid);
993         to_mz =  mem_cgroup_zoneinfo(to, nid, zid);
994
995         if (!trylock_page_cgroup(pc))
996                 return ret;
997
998         if (!PageCgroupUsed(pc))
999                 goto out;
1000
1001         if (pc->mem_cgroup != from)
1002                 goto out;
1003
1004         res_counter_uncharge(&from->res, PAGE_SIZE);
1005         mem_cgroup_charge_statistics(from, pc, false);
1006         if (do_swap_account)
1007                 res_counter_uncharge(&from->memsw, PAGE_SIZE);
1008         css_put(&from->css);
1009
1010         css_get(&to->css);
1011         pc->mem_cgroup = to;
1012         mem_cgroup_charge_statistics(to, pc, true);
1013         ret = 0;
1014 out:
1015         unlock_page_cgroup(pc);
1016         return ret;
1017 }
1018
1019 /*
1020  * move charges to its parent.
1021  */
1022
1023 static int mem_cgroup_move_parent(struct page_cgroup *pc,
1024                                   struct mem_cgroup *child,
1025                                   gfp_t gfp_mask)
1026 {
1027         struct page *page = pc->page;
1028         struct cgroup *cg = child->css.cgroup;
1029         struct cgroup *pcg = cg->parent;
1030         struct mem_cgroup *parent;
1031         int ret;
1032
1033         /* Is ROOT ? */
1034         if (!pcg)
1035                 return -EINVAL;
1036
1037
1038         parent = mem_cgroup_from_cont(pcg);
1039
1040
1041         ret = __mem_cgroup_try_charge(NULL, gfp_mask, &parent, false);
1042         if (ret || !parent)
1043                 return ret;
1044
1045         if (!get_page_unless_zero(page)) {
1046                 ret = -EBUSY;
1047                 goto uncharge;
1048         }
1049
1050         ret = isolate_lru_page(page);
1051
1052         if (ret)
1053                 goto cancel;
1054
1055         ret = mem_cgroup_move_account(pc, child, parent);
1056
1057         putback_lru_page(page);
1058         if (!ret) {
1059                 put_page(page);
1060                 /* drop extra refcnt by try_charge() */
1061                 css_put(&parent->css);
1062                 return 0;
1063         }
1064
1065 cancel:
1066         put_page(page);
1067 uncharge:
1068         /* drop extra refcnt by try_charge() */
1069         css_put(&parent->css);
1070         /* uncharge if move fails */
1071         res_counter_uncharge(&parent->res, PAGE_SIZE);
1072         if (do_swap_account)
1073                 res_counter_uncharge(&parent->memsw, PAGE_SIZE);
1074         return ret;
1075 }
1076
1077 /*
1078  * Charge the memory controller for page usage.
1079  * Return
1080  * 0 if the charge was successful
1081  * < 0 if the cgroup is over its limit
1082  */
1083 static int mem_cgroup_charge_common(struct page *page, struct mm_struct *mm,
1084                                 gfp_t gfp_mask, enum charge_type ctype,
1085                                 struct mem_cgroup *memcg)
1086 {
1087         struct mem_cgroup *mem;
1088         struct page_cgroup *pc;
1089         int ret;
1090
1091         pc = lookup_page_cgroup(page);
1092         /* can happen at boot */
1093         if (unlikely(!pc))
1094                 return 0;
1095         prefetchw(pc);
1096
1097         mem = memcg;
1098         ret = __mem_cgroup_try_charge(mm, gfp_mask, &mem, true);
1099         if (ret || !mem)
1100                 return ret;
1101
1102         __mem_cgroup_commit_charge(mem, pc, ctype);
1103         return 0;
1104 }
1105
1106 int mem_cgroup_newpage_charge(struct page *page,
1107                               struct mm_struct *mm, gfp_t gfp_mask)
1108 {
1109         if (mem_cgroup_disabled())
1110                 return 0;
1111         if (PageCompound(page))
1112                 return 0;
1113         /*
1114          * If already mapped, we don't have to account.
1115          * If page cache, page->mapping has address_space.
1116          * But page->mapping may have out-of-use anon_vma pointer,
1117          * detecit it by PageAnon() check. newly-mapped-anon's page->mapping
1118          * is NULL.
1119          */
1120         if (page_mapped(page) || (page->mapping && !PageAnon(page)))
1121                 return 0;
1122         if (unlikely(!mm))
1123                 mm = &init_mm;
1124         return mem_cgroup_charge_common(page, mm, gfp_mask,
1125                                 MEM_CGROUP_CHARGE_TYPE_MAPPED, NULL);
1126 }
1127
1128 int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm,
1129                                 gfp_t gfp_mask)
1130 {
1131         struct mem_cgroup *mem = NULL;
1132         int ret;
1133
1134         if (mem_cgroup_disabled())
1135                 return 0;
1136         if (PageCompound(page))
1137                 return 0;
1138         /*
1139          * Corner case handling. This is called from add_to_page_cache()
1140          * in usual. But some FS (shmem) precharges this page before calling it
1141          * and call add_to_page_cache() with GFP_NOWAIT.
1142          *
1143          * For GFP_NOWAIT case, the page may be pre-charged before calling
1144          * add_to_page_cache(). (See shmem.c) check it here and avoid to call
1145          * charge twice. (It works but has to pay a bit larger cost.)
1146          * And when the page is SwapCache, it should take swap information
1147          * into account. This is under lock_page() now.
1148          */
1149         if (!(gfp_mask & __GFP_WAIT)) {
1150                 struct page_cgroup *pc;
1151
1152
1153                 pc = lookup_page_cgroup(page);
1154                 if (!pc)
1155                         return 0;
1156                 lock_page_cgroup(pc);
1157                 if (PageCgroupUsed(pc)) {
1158                         unlock_page_cgroup(pc);
1159                         return 0;
1160                 }
1161                 unlock_page_cgroup(pc);
1162         }
1163
1164         if (do_swap_account && PageSwapCache(page)) {
1165                 mem = try_get_mem_cgroup_from_swapcache(page);
1166                 if (mem)
1167                         mm = NULL;
1168                   else
1169                         mem = NULL;
1170                 /* SwapCache may be still linked to LRU now. */
1171                 mem_cgroup_lru_del_before_commit_swapcache(page);
1172         }
1173
1174         if (unlikely(!mm && !mem))
1175                 mm = &init_mm;
1176
1177         if (page_is_file_cache(page))
1178                 return mem_cgroup_charge_common(page, mm, gfp_mask,
1179                                 MEM_CGROUP_CHARGE_TYPE_CACHE, NULL);
1180
1181         ret = mem_cgroup_charge_common(page, mm, gfp_mask,
1182                                 MEM_CGROUP_CHARGE_TYPE_SHMEM, mem);
1183         if (mem)
1184                 css_put(&mem->css);
1185         if (PageSwapCache(page))
1186                 mem_cgroup_lru_add_after_commit_swapcache(page);
1187
1188         if (do_swap_account && !ret && PageSwapCache(page)) {
1189                 swp_entry_t ent = {.val = page_private(page)};
1190                 /* avoid double counting */
1191                 mem = swap_cgroup_record(ent, NULL);
1192                 if (mem) {
1193                         res_counter_uncharge(&mem->memsw, PAGE_SIZE);
1194                         mem_cgroup_put(mem);
1195                 }
1196         }
1197         return ret;
1198 }
1199
1200 /*
1201  * While swap-in, try_charge -> commit or cancel, the page is locked.
1202  * And when try_charge() successfully returns, one refcnt to memcg without
1203  * struct page_cgroup is aquired. This refcnt will be cumsumed by
1204  * "commit()" or removed by "cancel()"
1205  */
1206 int mem_cgroup_try_charge_swapin(struct mm_struct *mm,
1207                                  struct page *page,
1208                                  gfp_t mask, struct mem_cgroup **ptr)
1209 {
1210         struct mem_cgroup *mem;
1211         int ret;
1212
1213         if (mem_cgroup_disabled())
1214                 return 0;
1215
1216         if (!do_swap_account)
1217                 goto charge_cur_mm;
1218         /*
1219          * A racing thread's fault, or swapoff, may have already updated
1220          * the pte, and even removed page from swap cache: return success
1221          * to go on to do_swap_page()'s pte_same() test, which should fail.
1222          */
1223         if (!PageSwapCache(page))
1224                 return 0;
1225         mem = try_get_mem_cgroup_from_swapcache(page);
1226         if (!mem)
1227                 goto charge_cur_mm;
1228         *ptr = mem;
1229         ret = __mem_cgroup_try_charge(NULL, mask, ptr, true);
1230         /* drop extra refcnt from tryget */
1231         css_put(&mem->css);
1232         return ret;
1233 charge_cur_mm:
1234         if (unlikely(!mm))
1235                 mm = &init_mm;
1236         return __mem_cgroup_try_charge(mm, mask, ptr, true);
1237 }
1238
1239 void mem_cgroup_commit_charge_swapin(struct page *page, struct mem_cgroup *ptr)
1240 {
1241         struct page_cgroup *pc;
1242
1243         if (mem_cgroup_disabled())
1244                 return;
1245         if (!ptr)
1246                 return;
1247         pc = lookup_page_cgroup(page);
1248         mem_cgroup_lru_del_before_commit_swapcache(page);
1249         __mem_cgroup_commit_charge(ptr, pc, MEM_CGROUP_CHARGE_TYPE_MAPPED);
1250         mem_cgroup_lru_add_after_commit_swapcache(page);
1251         /*
1252          * Now swap is on-memory. This means this page may be
1253          * counted both as mem and swap....double count.
1254          * Fix it by uncharging from memsw. Basically, this SwapCache is stable
1255          * under lock_page(). But in do_swap_page()::memory.c, reuse_swap_page()
1256          * may call delete_from_swap_cache() before reach here.
1257          */
1258         if (do_swap_account && PageSwapCache(page)) {
1259                 swp_entry_t ent = {.val = page_private(page)};
1260                 struct mem_cgroup *memcg;
1261                 memcg = swap_cgroup_record(ent, NULL);
1262                 if (memcg) {
1263                         res_counter_uncharge(&memcg->memsw, PAGE_SIZE);
1264                         mem_cgroup_put(memcg);
1265                 }
1266
1267         }
1268         /* add this page(page_cgroup) to the LRU we want. */
1269
1270 }
1271
1272 void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *mem)
1273 {
1274         if (mem_cgroup_disabled())
1275                 return;
1276         if (!mem)
1277                 return;
1278         res_counter_uncharge(&mem->res, PAGE_SIZE);
1279         if (do_swap_account)
1280                 res_counter_uncharge(&mem->memsw, PAGE_SIZE);
1281         css_put(&mem->css);
1282 }
1283
1284
1285 /*
1286  * uncharge if !page_mapped(page)
1287  */
1288 static struct mem_cgroup *
1289 __mem_cgroup_uncharge_common(struct page *page, enum charge_type ctype)
1290 {
1291         struct page_cgroup *pc;
1292         struct mem_cgroup *mem = NULL;
1293         struct mem_cgroup_per_zone *mz;
1294
1295         if (mem_cgroup_disabled())
1296                 return NULL;
1297
1298         if (PageSwapCache(page))
1299                 return NULL;
1300
1301         /*
1302          * Check if our page_cgroup is valid
1303          */
1304         pc = lookup_page_cgroup(page);
1305         if (unlikely(!pc || !PageCgroupUsed(pc)))
1306                 return NULL;
1307
1308         lock_page_cgroup(pc);
1309
1310         mem = pc->mem_cgroup;
1311
1312         if (!PageCgroupUsed(pc))
1313                 goto unlock_out;
1314
1315         switch (ctype) {
1316         case MEM_CGROUP_CHARGE_TYPE_MAPPED:
1317                 if (page_mapped(page))
1318                         goto unlock_out;
1319                 break;
1320         case MEM_CGROUP_CHARGE_TYPE_SWAPOUT:
1321                 if (!PageAnon(page)) {  /* Shared memory */
1322                         if (page->mapping && !page_is_file_cache(page))
1323                                 goto unlock_out;
1324                 } else if (page_mapped(page)) /* Anon */
1325                                 goto unlock_out;
1326                 break;
1327         default:
1328                 break;
1329         }
1330
1331         res_counter_uncharge(&mem->res, PAGE_SIZE);
1332         if (do_swap_account && (ctype != MEM_CGROUP_CHARGE_TYPE_SWAPOUT))
1333                 res_counter_uncharge(&mem->memsw, PAGE_SIZE);
1334         mem_cgroup_charge_statistics(mem, pc, false);
1335
1336         ClearPageCgroupUsed(pc);
1337         /*
1338          * pc->mem_cgroup is not cleared here. It will be accessed when it's
1339          * freed from LRU. This is safe because uncharged page is expected not
1340          * to be reused (freed soon). Exception is SwapCache, it's handled by
1341          * special functions.
1342          */
1343
1344         mz = page_cgroup_zoneinfo(pc);
1345         unlock_page_cgroup(pc);
1346
1347         /* at swapout, this memcg will be accessed to record to swap */
1348         if (ctype != MEM_CGROUP_CHARGE_TYPE_SWAPOUT)
1349                 css_put(&mem->css);
1350
1351         return mem;
1352
1353 unlock_out:
1354         unlock_page_cgroup(pc);
1355         return NULL;
1356 }
1357
1358 void mem_cgroup_uncharge_page(struct page *page)
1359 {
1360         /* early check. */
1361         if (page_mapped(page))
1362                 return;
1363         if (page->mapping && !PageAnon(page))
1364                 return;
1365         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_MAPPED);
1366 }
1367
1368 void mem_cgroup_uncharge_cache_page(struct page *page)
1369 {
1370         VM_BUG_ON(page_mapped(page));
1371         VM_BUG_ON(page->mapping);
1372         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_CACHE);
1373 }
1374
1375 /*
1376  * called from __delete_from_swap_cache() and drop "page" account.
1377  * memcg information is recorded to swap_cgroup of "ent"
1378  */
1379 void mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
1380 {
1381         struct mem_cgroup *memcg;
1382
1383         memcg = __mem_cgroup_uncharge_common(page,
1384                                         MEM_CGROUP_CHARGE_TYPE_SWAPOUT);
1385         /* record memcg information */
1386         if (do_swap_account && memcg) {
1387                 swap_cgroup_record(ent, memcg);
1388                 mem_cgroup_get(memcg);
1389         }
1390         if (memcg)
1391                 css_put(&memcg->css);
1392 }
1393
1394 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
1395 /*
1396  * called from swap_entry_free(). remove record in swap_cgroup and
1397  * uncharge "memsw" account.
1398  */
1399 void mem_cgroup_uncharge_swap(swp_entry_t ent)
1400 {
1401         struct mem_cgroup *memcg;
1402
1403         if (!do_swap_account)
1404                 return;
1405
1406         memcg = swap_cgroup_record(ent, NULL);
1407         if (memcg) {
1408                 res_counter_uncharge(&memcg->memsw, PAGE_SIZE);
1409                 mem_cgroup_put(memcg);
1410         }
1411 }
1412 #endif
1413
1414 /*
1415  * Before starting migration, account PAGE_SIZE to mem_cgroup that the old
1416  * page belongs to.
1417  */
1418 int mem_cgroup_prepare_migration(struct page *page, struct mem_cgroup **ptr)
1419 {
1420         struct page_cgroup *pc;
1421         struct mem_cgroup *mem = NULL;
1422         int ret = 0;
1423
1424         if (mem_cgroup_disabled())
1425                 return 0;
1426
1427         pc = lookup_page_cgroup(page);
1428         lock_page_cgroup(pc);
1429         if (PageCgroupUsed(pc)) {
1430                 mem = pc->mem_cgroup;
1431                 css_get(&mem->css);
1432         }
1433         unlock_page_cgroup(pc);
1434
1435         if (mem) {
1436                 ret = __mem_cgroup_try_charge(NULL, GFP_KERNEL, &mem, false);
1437                 css_put(&mem->css);
1438         }
1439         *ptr = mem;
1440         return ret;
1441 }
1442
1443 /* remove redundant charge if migration failed*/
1444 void mem_cgroup_end_migration(struct mem_cgroup *mem,
1445                 struct page *oldpage, struct page *newpage)
1446 {
1447         struct page *target, *unused;
1448         struct page_cgroup *pc;
1449         enum charge_type ctype;
1450
1451         if (!mem)
1452                 return;
1453
1454         /* at migration success, oldpage->mapping is NULL. */
1455         if (oldpage->mapping) {
1456                 target = oldpage;
1457                 unused = NULL;
1458         } else {
1459                 target = newpage;
1460                 unused = oldpage;
1461         }
1462
1463         if (PageAnon(target))
1464                 ctype = MEM_CGROUP_CHARGE_TYPE_MAPPED;
1465         else if (page_is_file_cache(target))
1466                 ctype = MEM_CGROUP_CHARGE_TYPE_CACHE;
1467         else
1468                 ctype = MEM_CGROUP_CHARGE_TYPE_SHMEM;
1469
1470         /* unused page is not on radix-tree now. */
1471         if (unused)
1472                 __mem_cgroup_uncharge_common(unused, ctype);
1473
1474         pc = lookup_page_cgroup(target);
1475         /*
1476          * __mem_cgroup_commit_charge() check PCG_USED bit of page_cgroup.
1477          * So, double-counting is effectively avoided.
1478          */
1479         __mem_cgroup_commit_charge(mem, pc, ctype);
1480
1481         /*
1482          * Both of oldpage and newpage are still under lock_page().
1483          * Then, we don't have to care about race in radix-tree.
1484          * But we have to be careful that this page is unmapped or not.
1485          *
1486          * There is a case for !page_mapped(). At the start of
1487          * migration, oldpage was mapped. But now, it's zapped.
1488          * But we know *target* page is not freed/reused under us.
1489          * mem_cgroup_uncharge_page() does all necessary checks.
1490          */
1491         if (ctype == MEM_CGROUP_CHARGE_TYPE_MAPPED)
1492                 mem_cgroup_uncharge_page(target);
1493 }
1494
1495 /*
1496  * A call to try to shrink memory usage under specified resource controller.
1497  * This is typically used for page reclaiming for shmem for reducing side
1498  * effect of page allocation from shmem, which is used by some mem_cgroup.
1499  */
1500 int mem_cgroup_shrink_usage(struct page *page,
1501                             struct mm_struct *mm,
1502                             gfp_t gfp_mask)
1503 {
1504         struct mem_cgroup *mem = NULL;
1505         int progress = 0;
1506         int retry = MEM_CGROUP_RECLAIM_RETRIES;
1507
1508         if (mem_cgroup_disabled())
1509                 return 0;
1510         if (page)
1511                 mem = try_get_mem_cgroup_from_swapcache(page);
1512         if (!mem && mm)
1513                 mem = try_get_mem_cgroup_from_mm(mm);
1514         if (unlikely(!mem))
1515                 return 0;
1516
1517         do {
1518                 progress = mem_cgroup_hierarchical_reclaim(mem,
1519                                         gfp_mask, true, false);
1520                 progress += mem_cgroup_check_under_limit(mem);
1521         } while (!progress && --retry);
1522
1523         css_put(&mem->css);
1524         if (!retry)
1525                 return -ENOMEM;
1526         return 0;
1527 }
1528
1529 static DEFINE_MUTEX(set_limit_mutex);
1530
1531 static int mem_cgroup_resize_limit(struct mem_cgroup *memcg,
1532                                 unsigned long long val)
1533 {
1534         int retry_count;
1535         int progress;
1536         u64 memswlimit;
1537         int ret = 0;
1538         int children = mem_cgroup_count_children(memcg);
1539         u64 curusage, oldusage;
1540
1541         /*
1542          * For keeping hierarchical_reclaim simple, how long we should retry
1543          * is depends on callers. We set our retry-count to be function
1544          * of # of children which we should visit in this loop.
1545          */
1546         retry_count = MEM_CGROUP_RECLAIM_RETRIES * children;
1547
1548         oldusage = res_counter_read_u64(&memcg->res, RES_USAGE);
1549
1550         while (retry_count) {
1551                 if (signal_pending(current)) {
1552                         ret = -EINTR;
1553                         break;
1554                 }
1555                 /*
1556                  * Rather than hide all in some function, I do this in
1557                  * open coded manner. You see what this really does.
1558                  * We have to guarantee mem->res.limit < mem->memsw.limit.
1559                  */
1560                 mutex_lock(&set_limit_mutex);
1561                 memswlimit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1562                 if (memswlimit < val) {
1563                         ret = -EINVAL;
1564                         mutex_unlock(&set_limit_mutex);
1565                         break;
1566                 }
1567                 ret = res_counter_set_limit(&memcg->res, val);
1568                 mutex_unlock(&set_limit_mutex);
1569
1570                 if (!ret)
1571                         break;
1572
1573                 progress = mem_cgroup_hierarchical_reclaim(memcg, GFP_KERNEL,
1574                                                    false, true);
1575                 curusage = res_counter_read_u64(&memcg->res, RES_USAGE);
1576                 /* Usage is reduced ? */
1577                 if (curusage >= oldusage)
1578                         retry_count--;
1579                 else
1580                         oldusage = curusage;
1581         }
1582
1583         return ret;
1584 }
1585
1586 int mem_cgroup_resize_memsw_limit(struct mem_cgroup *memcg,
1587                                 unsigned long long val)
1588 {
1589         int retry_count;
1590         u64 memlimit, oldusage, curusage;
1591         int children = mem_cgroup_count_children(memcg);
1592         int ret = -EBUSY;
1593
1594         if (!do_swap_account)
1595                 return -EINVAL;
1596         /* see mem_cgroup_resize_res_limit */
1597         retry_count = children * MEM_CGROUP_RECLAIM_RETRIES;
1598         oldusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
1599         while (retry_count) {
1600                 if (signal_pending(current)) {
1601                         ret = -EINTR;
1602                         break;
1603                 }
1604                 /*
1605                  * Rather than hide all in some function, I do this in
1606                  * open coded manner. You see what this really does.
1607                  * We have to guarantee mem->res.limit < mem->memsw.limit.
1608                  */
1609                 mutex_lock(&set_limit_mutex);
1610                 memlimit = res_counter_read_u64(&memcg->res, RES_LIMIT);
1611                 if (memlimit > val) {
1612                         ret = -EINVAL;
1613                         mutex_unlock(&set_limit_mutex);
1614                         break;
1615                 }
1616                 ret = res_counter_set_limit(&memcg->memsw, val);
1617                 mutex_unlock(&set_limit_mutex);
1618
1619                 if (!ret)
1620                         break;
1621
1622                 mem_cgroup_hierarchical_reclaim(memcg, GFP_KERNEL, true, true);
1623                 curusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
1624                 /* Usage is reduced ? */
1625                 if (curusage >= oldusage)
1626                         retry_count--;
1627                 else
1628                         oldusage = curusage;
1629         }
1630         return ret;
1631 }
1632
1633 /*
1634  * This routine traverse page_cgroup in given list and drop them all.
1635  * *And* this routine doesn't reclaim page itself, just removes page_cgroup.
1636  */
1637 static int mem_cgroup_force_empty_list(struct mem_cgroup *mem,
1638                                 int node, int zid, enum lru_list lru)
1639 {
1640         struct zone *zone;
1641         struct mem_cgroup_per_zone *mz;
1642         struct page_cgroup *pc, *busy;
1643         unsigned long flags, loop;
1644         struct list_head *list;
1645         int ret = 0;
1646
1647         zone = &NODE_DATA(node)->node_zones[zid];
1648         mz = mem_cgroup_zoneinfo(mem, node, zid);
1649         list = &mz->lists[lru];
1650
1651         loop = MEM_CGROUP_ZSTAT(mz, lru);
1652         /* give some margin against EBUSY etc...*/
1653         loop += 256;
1654         busy = NULL;
1655         while (loop--) {
1656                 ret = 0;
1657                 spin_lock_irqsave(&zone->lru_lock, flags);
1658                 if (list_empty(list)) {
1659                         spin_unlock_irqrestore(&zone->lru_lock, flags);
1660                         break;
1661                 }
1662                 pc = list_entry(list->prev, struct page_cgroup, lru);
1663                 if (busy == pc) {
1664                         list_move(&pc->lru, list);
1665                         busy = 0;
1666                         spin_unlock_irqrestore(&zone->lru_lock, flags);
1667                         continue;
1668                 }
1669                 spin_unlock_irqrestore(&zone->lru_lock, flags);
1670
1671                 ret = mem_cgroup_move_parent(pc, mem, GFP_KERNEL);
1672                 if (ret == -ENOMEM)
1673                         break;
1674
1675                 if (ret == -EBUSY || ret == -EINVAL) {
1676                         /* found lock contention or "pc" is obsolete. */
1677                         busy = pc;
1678                         cond_resched();
1679                 } else
1680                         busy = NULL;
1681         }
1682
1683         if (!ret && !list_empty(list))
1684                 return -EBUSY;
1685         return ret;
1686 }
1687
1688 /*
1689  * make mem_cgroup's charge to be 0 if there is no task.
1690  * This enables deleting this mem_cgroup.
1691  */
1692 static int mem_cgroup_force_empty(struct mem_cgroup *mem, bool free_all)
1693 {
1694         int ret;
1695         int node, zid, shrink;
1696         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
1697         struct cgroup *cgrp = mem->css.cgroup;
1698
1699         css_get(&mem->css);
1700
1701         shrink = 0;
1702         /* should free all ? */
1703         if (free_all)
1704                 goto try_to_free;
1705 move_account:
1706         while (mem->res.usage > 0) {
1707                 ret = -EBUSY;
1708                 if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children))
1709                         goto out;
1710                 ret = -EINTR;
1711                 if (signal_pending(current))
1712                         goto out;
1713                 /* This is for making all *used* pages to be on LRU. */
1714                 lru_add_drain_all();
1715                 ret = 0;
1716                 for_each_node_state(node, N_HIGH_MEMORY) {
1717                         for (zid = 0; !ret && zid < MAX_NR_ZONES; zid++) {
1718                                 enum lru_list l;
1719                                 for_each_lru(l) {
1720                                         ret = mem_cgroup_force_empty_list(mem,
1721                                                         node, zid, l);
1722                                         if (ret)
1723                                                 break;
1724                                 }
1725                         }
1726                         if (ret)
1727                                 break;
1728                 }
1729                 /* it seems parent cgroup doesn't have enough mem */
1730                 if (ret == -ENOMEM)
1731                         goto try_to_free;
1732                 cond_resched();
1733         }
1734         ret = 0;
1735 out:
1736         css_put(&mem->css);
1737         return ret;
1738
1739 try_to_free:
1740         /* returns EBUSY if there is a task or if we come here twice. */
1741         if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children) || shrink) {
1742                 ret = -EBUSY;
1743                 goto out;
1744         }
1745         /* we call try-to-free pages for make this cgroup empty */
1746         lru_add_drain_all();
1747         /* try to free all pages in this cgroup */
1748         shrink = 1;
1749         while (nr_retries && mem->res.usage > 0) {
1750                 int progress;
1751
1752                 if (signal_pending(current)) {
1753                         ret = -EINTR;
1754                         goto out;
1755                 }
1756                 progress = try_to_free_mem_cgroup_pages(mem, GFP_KERNEL,
1757                                                 false, get_swappiness(mem));
1758                 if (!progress) {
1759                         nr_retries--;
1760                         /* maybe some writeback is necessary */
1761                         congestion_wait(WRITE, HZ/10);
1762                 }
1763
1764         }
1765         lru_add_drain();
1766         /* try move_account...there may be some *locked* pages. */
1767         if (mem->res.usage)
1768                 goto move_account;
1769         ret = 0;
1770         goto out;
1771 }
1772
1773 int mem_cgroup_force_empty_write(struct cgroup *cont, unsigned int event)
1774 {
1775         return mem_cgroup_force_empty(mem_cgroup_from_cont(cont), true);
1776 }
1777
1778
1779 static u64 mem_cgroup_hierarchy_read(struct cgroup *cont, struct cftype *cft)
1780 {
1781         return mem_cgroup_from_cont(cont)->use_hierarchy;
1782 }
1783
1784 static int mem_cgroup_hierarchy_write(struct cgroup *cont, struct cftype *cft,
1785                                         u64 val)
1786 {
1787         int retval = 0;
1788         struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
1789         struct cgroup *parent = cont->parent;
1790         struct mem_cgroup *parent_mem = NULL;
1791
1792         if (parent)
1793                 parent_mem = mem_cgroup_from_cont(parent);
1794
1795         cgroup_lock();
1796         /*
1797          * If parent's use_hiearchy is set, we can't make any modifications
1798          * in the child subtrees. If it is unset, then the change can
1799          * occur, provided the current cgroup has no children.
1800          *
1801          * For the root cgroup, parent_mem is NULL, we allow value to be
1802          * set if there are no children.
1803          */
1804         if ((!parent_mem || !parent_mem->use_hierarchy) &&
1805                                 (val == 1 || val == 0)) {
1806                 if (list_empty(&cont->children))
1807                         mem->use_hierarchy = val;
1808                 else
1809                         retval = -EBUSY;
1810         } else
1811                 retval = -EINVAL;
1812         cgroup_unlock();
1813
1814         return retval;
1815 }
1816
1817 static u64 mem_cgroup_read(struct cgroup *cont, struct cftype *cft)
1818 {
1819         struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
1820         u64 val = 0;
1821         int type, name;
1822
1823         type = MEMFILE_TYPE(cft->private);
1824         name = MEMFILE_ATTR(cft->private);
1825         switch (type) {
1826         case _MEM:
1827                 val = res_counter_read_u64(&mem->res, name);
1828                 break;
1829         case _MEMSWAP:
1830                 if (do_swap_account)
1831                         val = res_counter_read_u64(&mem->memsw, name);
1832                 break;
1833         default:
1834                 BUG();
1835                 break;
1836         }
1837         return val;
1838 }
1839 /*
1840  * The user of this function is...
1841  * RES_LIMIT.
1842  */
1843 static int mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
1844                             const char *buffer)
1845 {
1846         struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
1847         int type, name;
1848         unsigned long long val;
1849         int ret;
1850
1851         type = MEMFILE_TYPE(cft->private);
1852         name = MEMFILE_ATTR(cft->private);
1853         switch (name) {
1854         case RES_LIMIT:
1855                 /* This function does all necessary parse...reuse it */
1856                 ret = res_counter_memparse_write_strategy(buffer, &val);
1857                 if (ret)
1858                         break;
1859                 if (type == _MEM)
1860                         ret = mem_cgroup_resize_limit(memcg, val);
1861                 else
1862                         ret = mem_cgroup_resize_memsw_limit(memcg, val);
1863                 break;
1864         default:
1865                 ret = -EINVAL; /* should be BUG() ? */
1866                 break;
1867         }
1868         return ret;
1869 }
1870
1871 static void memcg_get_hierarchical_limit(struct mem_cgroup *memcg,
1872                 unsigned long long *mem_limit, unsigned long long *memsw_limit)
1873 {
1874         struct cgroup *cgroup;
1875         unsigned long long min_limit, min_memsw_limit, tmp;
1876
1877         min_limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
1878         min_memsw_limit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1879         cgroup = memcg->css.cgroup;
1880         if (!memcg->use_hierarchy)
1881                 goto out;
1882
1883         while (cgroup->parent) {
1884                 cgroup = cgroup->parent;
1885                 memcg = mem_cgroup_from_cont(cgroup);
1886                 if (!memcg->use_hierarchy)
1887                         break;
1888                 tmp = res_counter_read_u64(&memcg->res, RES_LIMIT);
1889                 min_limit = min(min_limit, tmp);
1890                 tmp = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1891                 min_memsw_limit = min(min_memsw_limit, tmp);
1892         }
1893 out:
1894         *mem_limit = min_limit;
1895         *memsw_limit = min_memsw_limit;
1896         return;
1897 }
1898
1899 static int mem_cgroup_reset(struct cgroup *cont, unsigned int event)
1900 {
1901         struct mem_cgroup *mem;
1902         int type, name;
1903
1904         mem = mem_cgroup_from_cont(cont);
1905         type = MEMFILE_TYPE(event);
1906         name = MEMFILE_ATTR(event);
1907         switch (name) {
1908         case RES_MAX_USAGE:
1909                 if (type == _MEM)
1910                         res_counter_reset_max(&mem->res);
1911                 else
1912                         res_counter_reset_max(&mem->memsw);
1913                 break;
1914         case RES_FAILCNT:
1915                 if (type == _MEM)
1916                         res_counter_reset_failcnt(&mem->res);
1917                 else
1918                         res_counter_reset_failcnt(&mem->memsw);
1919                 break;
1920         }
1921         return 0;
1922 }
1923
1924
1925 /* For read statistics */
1926 enum {
1927         MCS_CACHE,
1928         MCS_RSS,
1929         MCS_PGPGIN,
1930         MCS_PGPGOUT,
1931         MCS_INACTIVE_ANON,
1932         MCS_ACTIVE_ANON,
1933         MCS_INACTIVE_FILE,
1934         MCS_ACTIVE_FILE,
1935         MCS_UNEVICTABLE,
1936         NR_MCS_STAT,
1937 };
1938
1939 struct mcs_total_stat {
1940         s64 stat[NR_MCS_STAT];
1941 };
1942
1943 struct {
1944         char *local_name;
1945         char *total_name;
1946 } memcg_stat_strings[NR_MCS_STAT] = {
1947         {"cache", "total_cache"},
1948         {"rss", "total_rss"},
1949         {"pgpgin", "total_pgpgin"},
1950         {"pgpgout", "total_pgpgout"},
1951         {"inactive_anon", "total_inactive_anon"},
1952         {"active_anon", "total_active_anon"},
1953         {"inactive_file", "total_inactive_file"},
1954         {"active_file", "total_active_file"},
1955         {"unevictable", "total_unevictable"}
1956 };
1957
1958
1959 static int mem_cgroup_get_local_stat(struct mem_cgroup *mem, void *data)
1960 {
1961         struct mcs_total_stat *s = data;
1962         s64 val;
1963
1964         /* per cpu stat */
1965         val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_CACHE);
1966         s->stat[MCS_CACHE] += val * PAGE_SIZE;
1967         val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_RSS);
1968         s->stat[MCS_RSS] += val * PAGE_SIZE;
1969         val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_PGPGIN_COUNT);
1970         s->stat[MCS_PGPGIN] += val;
1971         val = mem_cgroup_read_stat(&mem->stat, MEM_CGROUP_STAT_PGPGOUT_COUNT);
1972         s->stat[MCS_PGPGOUT] += val;
1973
1974         /* per zone stat */
1975         val = mem_cgroup_get_local_zonestat(mem, LRU_INACTIVE_ANON);
1976         s->stat[MCS_INACTIVE_ANON] += val * PAGE_SIZE;
1977         val = mem_cgroup_get_local_zonestat(mem, LRU_ACTIVE_ANON);
1978         s->stat[MCS_ACTIVE_ANON] += val * PAGE_SIZE;
1979         val = mem_cgroup_get_local_zonestat(mem, LRU_INACTIVE_FILE);
1980         s->stat[MCS_INACTIVE_FILE] += val * PAGE_SIZE;
1981         val = mem_cgroup_get_local_zonestat(mem, LRU_ACTIVE_FILE);
1982         s->stat[MCS_ACTIVE_FILE] += val * PAGE_SIZE;
1983         val = mem_cgroup_get_local_zonestat(mem, LRU_UNEVICTABLE);
1984         s->stat[MCS_UNEVICTABLE] += val * PAGE_SIZE;
1985         return 0;
1986 }
1987
1988 static void
1989 mem_cgroup_get_total_stat(struct mem_cgroup *mem, struct mcs_total_stat *s)
1990 {
1991         mem_cgroup_walk_tree(mem, s, mem_cgroup_get_local_stat);
1992 }
1993
1994 static int mem_control_stat_show(struct cgroup *cont, struct cftype *cft,
1995                                  struct cgroup_map_cb *cb)
1996 {
1997         struct mem_cgroup *mem_cont = mem_cgroup_from_cont(cont);
1998         struct mcs_total_stat mystat;
1999         int i;
2000
2001         memset(&mystat, 0, sizeof(mystat));
2002         mem_cgroup_get_local_stat(mem_cont, &mystat);
2003
2004         for (i = 0; i < NR_MCS_STAT; i++)
2005                 cb->fill(cb, memcg_stat_strings[i].local_name, mystat.stat[i]);
2006
2007         /* Hierarchical information */
2008         {
2009                 unsigned long long limit, memsw_limit;
2010                 memcg_get_hierarchical_limit(mem_cont, &limit, &memsw_limit);
2011                 cb->fill(cb, "hierarchical_memory_limit", limit);
2012                 if (do_swap_account)
2013                         cb->fill(cb, "hierarchical_memsw_limit", memsw_limit);
2014         }
2015
2016         memset(&mystat, 0, sizeof(mystat));
2017         mem_cgroup_get_total_stat(mem_cont, &mystat);
2018         for (i = 0; i < NR_MCS_STAT; i++)
2019                 cb->fill(cb, memcg_stat_strings[i].total_name, mystat.stat[i]);
2020
2021
2022 #ifdef CONFIG_DEBUG_VM
2023         cb->fill(cb, "inactive_ratio", calc_inactive_ratio(mem_cont, NULL));
2024
2025         {
2026                 int nid, zid;
2027                 struct mem_cgroup_per_zone *mz;
2028                 unsigned long recent_rotated[2] = {0, 0};
2029                 unsigned long recent_scanned[2] = {0, 0};
2030
2031                 for_each_online_node(nid)
2032                         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
2033                                 mz = mem_cgroup_zoneinfo(mem_cont, nid, zid);
2034
2035                                 recent_rotated[0] +=
2036                                         mz->reclaim_stat.recent_rotated[0];
2037                                 recent_rotated[1] +=
2038                                         mz->reclaim_stat.recent_rotated[1];
2039                                 recent_scanned[0] +=
2040                                         mz->reclaim_stat.recent_scanned[0];
2041                                 recent_scanned[1] +=
2042                                         mz->reclaim_stat.recent_scanned[1];
2043                         }
2044                 cb->fill(cb, "recent_rotated_anon", recent_rotated[0]);
2045                 cb->fill(cb, "recent_rotated_file", recent_rotated[1]);
2046                 cb->fill(cb, "recent_scanned_anon", recent_scanned[0]);
2047                 cb->fill(cb, "recent_scanned_file", recent_scanned[1]);
2048         }
2049 #endif
2050
2051         return 0;
2052 }
2053
2054 static u64 mem_cgroup_swappiness_read(struct cgroup *cgrp, struct cftype *cft)
2055 {
2056         struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
2057
2058         return get_swappiness(memcg);
2059 }
2060
2061 static int mem_cgroup_swappiness_write(struct cgroup *cgrp, struct cftype *cft,
2062                                        u64 val)
2063 {
2064         struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
2065         struct mem_cgroup *parent;
2066
2067         if (val > 100)
2068                 return -EINVAL;
2069
2070         if (cgrp->parent == NULL)
2071                 return -EINVAL;
2072
2073         parent = mem_cgroup_from_cont(cgrp->parent);
2074
2075         cgroup_lock();
2076
2077         /* If under hierarchy, only empty-root can set this value */
2078         if ((parent->use_hierarchy) ||
2079             (memcg->use_hierarchy && !list_empty(&cgrp->children))) {
2080                 cgroup_unlock();
2081                 return -EINVAL;
2082         }
2083
2084         spin_lock(&memcg->reclaim_param_lock);
2085         memcg->swappiness = val;
2086         spin_unlock(&memcg->reclaim_param_lock);
2087
2088         cgroup_unlock();
2089
2090         return 0;
2091 }
2092
2093
2094 static struct cftype mem_cgroup_files[] = {
2095         {
2096                 .name = "usage_in_bytes",
2097                 .private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
2098                 .read_u64 = mem_cgroup_read,
2099         },
2100         {
2101                 .name = "max_usage_in_bytes",
2102                 .private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
2103                 .trigger = mem_cgroup_reset,
2104                 .read_u64 = mem_cgroup_read,
2105         },
2106         {
2107                 .name = "limit_in_bytes",
2108                 .private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
2109                 .write_string = mem_cgroup_write,
2110                 .read_u64 = mem_cgroup_read,
2111         },
2112         {
2113                 .name = "failcnt",
2114                 .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
2115                 .trigger = mem_cgroup_reset,
2116                 .read_u64 = mem_cgroup_read,
2117         },
2118         {
2119                 .name = "stat",
2120                 .read_map = mem_control_stat_show,
2121         },
2122         {
2123                 .name = "force_empty",
2124                 .trigger = mem_cgroup_force_empty_write,
2125         },
2126         {
2127                 .name = "use_hierarchy",
2128                 .write_u64 = mem_cgroup_hierarchy_write,
2129                 .read_u64 = mem_cgroup_hierarchy_read,
2130         },
2131         {
2132                 .name = "swappiness",
2133                 .read_u64 = mem_cgroup_swappiness_read,
2134                 .write_u64 = mem_cgroup_swappiness_write,
2135         },
2136 };
2137
2138 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
2139 static struct cftype memsw_cgroup_files[] = {
2140         {
2141                 .name = "memsw.usage_in_bytes",
2142                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_USAGE),
2143                 .read_u64 = mem_cgroup_read,
2144         },
2145         {
2146                 .name = "memsw.max_usage_in_bytes",
2147                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_MAX_USAGE),
2148                 .trigger = mem_cgroup_reset,
2149                 .read_u64 = mem_cgroup_read,
2150         },
2151         {
2152                 .name = "memsw.limit_in_bytes",
2153                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_LIMIT),
2154                 .write_string = mem_cgroup_write,
2155                 .read_u64 = mem_cgroup_read,
2156         },
2157         {
2158                 .name = "memsw.failcnt",
2159                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_FAILCNT),
2160                 .trigger = mem_cgroup_reset,
2161                 .read_u64 = mem_cgroup_read,
2162         },
2163 };
2164
2165 static int register_memsw_files(struct cgroup *cont, struct cgroup_subsys *ss)
2166 {
2167         if (!do_swap_account)
2168                 return 0;
2169         return cgroup_add_files(cont, ss, memsw_cgroup_files,
2170                                 ARRAY_SIZE(memsw_cgroup_files));
2171 };
2172 #else
2173 static int register_memsw_files(struct cgroup *cont, struct cgroup_subsys *ss)
2174 {
2175         return 0;
2176 }
2177 #endif
2178
2179 static int alloc_mem_cgroup_per_zone_info(struct mem_cgroup *mem, int node)
2180 {
2181         struct mem_cgroup_per_node *pn;
2182         struct mem_cgroup_per_zone *mz;
2183         enum lru_list l;
2184         int zone, tmp = node;
2185         /*
2186          * This routine is called against possible nodes.
2187          * But it's BUG to call kmalloc() against offline node.
2188          *
2189          * TODO: this routine can waste much memory for nodes which will
2190          *       never be onlined. It's better to use memory hotplug callback
2191          *       function.
2192          */
2193         if (!node_state(node, N_NORMAL_MEMORY))
2194                 tmp = -1;
2195         pn = kmalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
2196         if (!pn)
2197                 return 1;
2198
2199         mem->info.nodeinfo[node] = pn;
2200         memset(pn, 0, sizeof(*pn));
2201
2202         for (zone = 0; zone < MAX_NR_ZONES; zone++) {
2203                 mz = &pn->zoneinfo[zone];
2204                 for_each_lru(l)
2205                         INIT_LIST_HEAD(&mz->lists[l]);
2206         }
2207         return 0;
2208 }
2209
2210 static void free_mem_cgroup_per_zone_info(struct mem_cgroup *mem, int node)
2211 {
2212         kfree(mem->info.nodeinfo[node]);
2213 }
2214
2215 static int mem_cgroup_size(void)
2216 {
2217         int cpustat_size = nr_cpu_ids * sizeof(struct mem_cgroup_stat_cpu);
2218         return sizeof(struct mem_cgroup) + cpustat_size;
2219 }
2220
2221 static struct mem_cgroup *mem_cgroup_alloc(void)
2222 {
2223         struct mem_cgroup *mem;
2224         int size = mem_cgroup_size();
2225
2226         if (size < PAGE_SIZE)
2227                 mem = kmalloc(size, GFP_KERNEL);
2228         else
2229                 mem = vmalloc(size);
2230
2231         if (mem)
2232                 memset(mem, 0, size);
2233         return mem;
2234 }
2235
2236 /*
2237  * At destroying mem_cgroup, references from swap_cgroup can remain.
2238  * (scanning all at force_empty is too costly...)
2239  *
2240  * Instead of clearing all references at force_empty, we remember
2241  * the number of reference from swap_cgroup and free mem_cgroup when
2242  * it goes down to 0.
2243  *
2244  * Removal of cgroup itself succeeds regardless of refs from swap.
2245  */
2246
2247 static void __mem_cgroup_free(struct mem_cgroup *mem)
2248 {
2249         int node;
2250
2251         free_css_id(&mem_cgroup_subsys, &mem->css);
2252
2253         for_each_node_state(node, N_POSSIBLE)
2254                 free_mem_cgroup_per_zone_info(mem, node);
2255
2256         if (mem_cgroup_size() < PAGE_SIZE)
2257                 kfree(mem);
2258         else
2259                 vfree(mem);
2260 }
2261
2262 static void mem_cgroup_get(struct mem_cgroup *mem)
2263 {
2264         atomic_inc(&mem->refcnt);
2265 }
2266
2267 static void mem_cgroup_put(struct mem_cgroup *mem)
2268 {
2269         if (atomic_dec_and_test(&mem->refcnt)) {
2270                 struct mem_cgroup *parent = parent_mem_cgroup(mem);
2271                 __mem_cgroup_free(mem);
2272                 if (parent)
2273                         mem_cgroup_put(parent);
2274         }
2275 }
2276
2277 /*
2278  * Returns the parent mem_cgroup in memcgroup hierarchy with hierarchy enabled.
2279  */
2280 static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *mem)
2281 {
2282         if (!mem->res.parent)
2283                 return NULL;
2284         return mem_cgroup_from_res_counter(mem->res.parent, res);
2285 }
2286
2287 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
2288 static void __init enable_swap_cgroup(void)
2289 {
2290         if (!mem_cgroup_disabled() && really_do_swap_account)
2291                 do_swap_account = 1;
2292 }
2293 #else
2294 static void __init enable_swap_cgroup(void)
2295 {
2296 }
2297 #endif
2298
2299 static struct cgroup_subsys_state * __ref
2300 mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
2301 {
2302         struct mem_cgroup *mem, *parent;
2303         long error = -ENOMEM;
2304         int node;
2305
2306         mem = mem_cgroup_alloc();
2307         if (!mem)
2308                 return ERR_PTR(error);
2309
2310         for_each_node_state(node, N_POSSIBLE)
2311                 if (alloc_mem_cgroup_per_zone_info(mem, node))
2312                         goto free_out;
2313         /* root ? */
2314         if (cont->parent == NULL) {
2315                 enable_swap_cgroup();
2316                 parent = NULL;
2317         } else {
2318                 parent = mem_cgroup_from_cont(cont->parent);
2319                 mem->use_hierarchy = parent->use_hierarchy;
2320         }
2321
2322         if (parent && parent->use_hierarchy) {
2323                 res_counter_init(&mem->res, &parent->res);
2324                 res_counter_init(&mem->memsw, &parent->memsw);
2325                 /*
2326                  * We increment refcnt of the parent to ensure that we can
2327                  * safely access it on res_counter_charge/uncharge.
2328                  * This refcnt will be decremented when freeing this
2329                  * mem_cgroup(see mem_cgroup_put).
2330                  */
2331                 mem_cgroup_get(parent);
2332         } else {
2333                 res_counter_init(&mem->res, NULL);
2334                 res_counter_init(&mem->memsw, NULL);
2335         }
2336         mem->last_scanned_child = 0;
2337         spin_lock_init(&mem->reclaim_param_lock);
2338
2339         if (parent)
2340                 mem->swappiness = get_swappiness(parent);
2341         atomic_set(&mem->refcnt, 1);
2342         return &mem->css;
2343 free_out:
2344         __mem_cgroup_free(mem);
2345         return ERR_PTR(error);
2346 }
2347
2348 static int mem_cgroup_pre_destroy(struct cgroup_subsys *ss,
2349                                         struct cgroup *cont)
2350 {
2351         struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
2352
2353         return mem_cgroup_force_empty(mem, false);
2354 }
2355
2356 static void mem_cgroup_destroy(struct cgroup_subsys *ss,
2357                                 struct cgroup *cont)
2358 {
2359         struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
2360
2361         mem_cgroup_put(mem);
2362 }
2363
2364 static int mem_cgroup_populate(struct cgroup_subsys *ss,
2365                                 struct cgroup *cont)
2366 {
2367         int ret;
2368
2369         ret = cgroup_add_files(cont, ss, mem_cgroup_files,
2370                                 ARRAY_SIZE(mem_cgroup_files));
2371
2372         if (!ret)
2373                 ret = register_memsw_files(cont, ss);
2374         return ret;
2375 }
2376
2377 static void mem_cgroup_move_task(struct cgroup_subsys *ss,
2378                                 struct cgroup *cont,
2379                                 struct cgroup *old_cont,
2380                                 struct task_struct *p)
2381 {
2382         mutex_lock(&memcg_tasklist);
2383         /*
2384          * FIXME: It's better to move charges of this process from old
2385          * memcg to new memcg. But it's just on TODO-List now.
2386          */
2387         mutex_unlock(&memcg_tasklist);
2388 }
2389
2390 struct cgroup_subsys mem_cgroup_subsys = {
2391         .name = "memory",
2392         .subsys_id = mem_cgroup_subsys_id,
2393         .create = mem_cgroup_create,
2394         .pre_destroy = mem_cgroup_pre_destroy,
2395         .destroy = mem_cgroup_destroy,
2396         .populate = mem_cgroup_populate,
2397         .attach = mem_cgroup_move_task,
2398         .early_init = 0,
2399         .use_id = 1,
2400 };
2401
2402 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
2403
2404 static int __init disable_swap_account(char *s)
2405 {
2406         really_do_swap_account = 0;
2407         return 1;
2408 }
2409 __setup("noswapaccount", disable_swap_account);
2410 #endif