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