]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - mm/memcontrol.c
b9afa060b8d62feb4da918cc84987f0a91f5f56f
[~shefty/rdma-dev.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  * Memory thresholds
10  * Copyright (C) 2009 Nokia Corporation
11  * Author: Kirill A. Shutemov
12  *
13  * Kernel Memory Controller
14  * Copyright (C) 2012 Parallels Inc. and Google Inc.
15  * Authors: Glauber Costa and Suleiman Souhlal
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation; either version 2 of the License, or
20  * (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  */
27
28 #include <linux/res_counter.h>
29 #include <linux/memcontrol.h>
30 #include <linux/cgroup.h>
31 #include <linux/mm.h>
32 #include <linux/hugetlb.h>
33 #include <linux/pagemap.h>
34 #include <linux/smp.h>
35 #include <linux/page-flags.h>
36 #include <linux/backing-dev.h>
37 #include <linux/bit_spinlock.h>
38 #include <linux/rcupdate.h>
39 #include <linux/limits.h>
40 #include <linux/export.h>
41 #include <linux/mutex.h>
42 #include <linux/rbtree.h>
43 #include <linux/slab.h>
44 #include <linux/swap.h>
45 #include <linux/swapops.h>
46 #include <linux/spinlock.h>
47 #include <linux/eventfd.h>
48 #include <linux/sort.h>
49 #include <linux/fs.h>
50 #include <linux/seq_file.h>
51 #include <linux/vmalloc.h>
52 #include <linux/mm_inline.h>
53 #include <linux/page_cgroup.h>
54 #include <linux/cpu.h>
55 #include <linux/oom.h>
56 #include "internal.h"
57 #include <net/sock.h>
58 #include <net/ip.h>
59 #include <net/tcp_memcontrol.h>
60
61 #include <asm/uaccess.h>
62
63 #include <trace/events/vmscan.h>
64
65 struct cgroup_subsys mem_cgroup_subsys __read_mostly;
66 EXPORT_SYMBOL(mem_cgroup_subsys);
67
68 #define MEM_CGROUP_RECLAIM_RETRIES      5
69 static struct mem_cgroup *root_mem_cgroup __read_mostly;
70
71 #ifdef CONFIG_MEMCG_SWAP
72 /* Turned on only when memory cgroup is enabled && really_do_swap_account = 1 */
73 int do_swap_account __read_mostly;
74
75 /* for remember boot option*/
76 #ifdef CONFIG_MEMCG_SWAP_ENABLED
77 static int really_do_swap_account __initdata = 1;
78 #else
79 static int really_do_swap_account __initdata = 0;
80 #endif
81
82 #else
83 #define do_swap_account         0
84 #endif
85
86
87 /*
88  * Statistics for memory cgroup.
89  */
90 enum mem_cgroup_stat_index {
91         /*
92          * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
93          */
94         MEM_CGROUP_STAT_CACHE,     /* # of pages charged as cache */
95         MEM_CGROUP_STAT_RSS,       /* # of pages charged as anon rss */
96         MEM_CGROUP_STAT_FILE_MAPPED,  /* # of pages charged as file rss */
97         MEM_CGROUP_STAT_SWAP, /* # of pages, swapped out */
98         MEM_CGROUP_STAT_NSTATS,
99 };
100
101 static const char * const mem_cgroup_stat_names[] = {
102         "cache",
103         "rss",
104         "mapped_file",
105         "swap",
106 };
107
108 enum mem_cgroup_events_index {
109         MEM_CGROUP_EVENTS_PGPGIN,       /* # of pages paged in */
110         MEM_CGROUP_EVENTS_PGPGOUT,      /* # of pages paged out */
111         MEM_CGROUP_EVENTS_PGFAULT,      /* # of page-faults */
112         MEM_CGROUP_EVENTS_PGMAJFAULT,   /* # of major page-faults */
113         MEM_CGROUP_EVENTS_NSTATS,
114 };
115
116 static const char * const mem_cgroup_events_names[] = {
117         "pgpgin",
118         "pgpgout",
119         "pgfault",
120         "pgmajfault",
121 };
122
123 /*
124  * Per memcg event counter is incremented at every pagein/pageout. With THP,
125  * it will be incremated by the number of pages. This counter is used for
126  * for trigger some periodic events. This is straightforward and better
127  * than using jiffies etc. to handle periodic memcg event.
128  */
129 enum mem_cgroup_events_target {
130         MEM_CGROUP_TARGET_THRESH,
131         MEM_CGROUP_TARGET_SOFTLIMIT,
132         MEM_CGROUP_TARGET_NUMAINFO,
133         MEM_CGROUP_NTARGETS,
134 };
135 #define THRESHOLDS_EVENTS_TARGET 128
136 #define SOFTLIMIT_EVENTS_TARGET 1024
137 #define NUMAINFO_EVENTS_TARGET  1024
138
139 struct mem_cgroup_stat_cpu {
140         long count[MEM_CGROUP_STAT_NSTATS];
141         unsigned long events[MEM_CGROUP_EVENTS_NSTATS];
142         unsigned long nr_page_events;
143         unsigned long targets[MEM_CGROUP_NTARGETS];
144 };
145
146 struct mem_cgroup_reclaim_iter {
147         /* css_id of the last scanned hierarchy member */
148         int position;
149         /* scan generation, increased every round-trip */
150         unsigned int generation;
151 };
152
153 /*
154  * per-zone information in memory controller.
155  */
156 struct mem_cgroup_per_zone {
157         struct lruvec           lruvec;
158         unsigned long           lru_size[NR_LRU_LISTS];
159
160         struct mem_cgroup_reclaim_iter reclaim_iter[DEF_PRIORITY + 1];
161
162         struct rb_node          tree_node;      /* RB tree node */
163         unsigned long long      usage_in_excess;/* Set to the value by which */
164                                                 /* the soft limit is exceeded*/
165         bool                    on_tree;
166         struct mem_cgroup       *memcg;         /* Back pointer, we cannot */
167                                                 /* use container_of        */
168 };
169
170 struct mem_cgroup_per_node {
171         struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
172 };
173
174 struct mem_cgroup_lru_info {
175         struct mem_cgroup_per_node *nodeinfo[MAX_NUMNODES];
176 };
177
178 /*
179  * Cgroups above their limits are maintained in a RB-Tree, independent of
180  * their hierarchy representation
181  */
182
183 struct mem_cgroup_tree_per_zone {
184         struct rb_root rb_root;
185         spinlock_t lock;
186 };
187
188 struct mem_cgroup_tree_per_node {
189         struct mem_cgroup_tree_per_zone rb_tree_per_zone[MAX_NR_ZONES];
190 };
191
192 struct mem_cgroup_tree {
193         struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
194 };
195
196 static struct mem_cgroup_tree soft_limit_tree __read_mostly;
197
198 struct mem_cgroup_threshold {
199         struct eventfd_ctx *eventfd;
200         u64 threshold;
201 };
202
203 /* For threshold */
204 struct mem_cgroup_threshold_ary {
205         /* An array index points to threshold just below or equal to usage. */
206         int current_threshold;
207         /* Size of entries[] */
208         unsigned int size;
209         /* Array of thresholds */
210         struct mem_cgroup_threshold entries[0];
211 };
212
213 struct mem_cgroup_thresholds {
214         /* Primary thresholds array */
215         struct mem_cgroup_threshold_ary *primary;
216         /*
217          * Spare threshold array.
218          * This is needed to make mem_cgroup_unregister_event() "never fail".
219          * It must be able to store at least primary->size - 1 entries.
220          */
221         struct mem_cgroup_threshold_ary *spare;
222 };
223
224 /* for OOM */
225 struct mem_cgroup_eventfd_list {
226         struct list_head list;
227         struct eventfd_ctx *eventfd;
228 };
229
230 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
231 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
232
233 /*
234  * The memory controller data structure. The memory controller controls both
235  * page cache and RSS per cgroup. We would eventually like to provide
236  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
237  * to help the administrator determine what knobs to tune.
238  *
239  * TODO: Add a water mark for the memory controller. Reclaim will begin when
240  * we hit the water mark. May be even add a low water mark, such that
241  * no reclaim occurs from a cgroup at it's low water mark, this is
242  * a feature that will be implemented much later in the future.
243  */
244 struct mem_cgroup {
245         struct cgroup_subsys_state css;
246         /*
247          * the counter to account for memory usage
248          */
249         struct res_counter res;
250
251         union {
252                 /*
253                  * the counter to account for mem+swap usage.
254                  */
255                 struct res_counter memsw;
256
257                 /*
258                  * rcu_freeing is used only when freeing struct mem_cgroup,
259                  * so put it into a union to avoid wasting more memory.
260                  * It must be disjoint from the css field.  It could be
261                  * in a union with the res field, but res plays a much
262                  * larger part in mem_cgroup life than memsw, and might
263                  * be of interest, even at time of free, when debugging.
264                  * So share rcu_head with the less interesting memsw.
265                  */
266                 struct rcu_head rcu_freeing;
267                 /*
268                  * We also need some space for a worker in deferred freeing.
269                  * By the time we call it, rcu_freeing is no longer in use.
270                  */
271                 struct work_struct work_freeing;
272         };
273
274         /*
275          * the counter to account for kernel memory usage.
276          */
277         struct res_counter kmem;
278         /*
279          * Per cgroup active and inactive list, similar to the
280          * per zone LRU lists.
281          */
282         struct mem_cgroup_lru_info info;
283         int last_scanned_node;
284 #if MAX_NUMNODES > 1
285         nodemask_t      scan_nodes;
286         atomic_t        numainfo_events;
287         atomic_t        numainfo_updating;
288 #endif
289         /*
290          * Should the accounting and control be hierarchical, per subtree?
291          */
292         bool use_hierarchy;
293         unsigned long kmem_account_flags; /* See KMEM_ACCOUNTED_*, below */
294
295         bool            oom_lock;
296         atomic_t        under_oom;
297
298         atomic_t        refcnt;
299
300         int     swappiness;
301         /* OOM-Killer disable */
302         int             oom_kill_disable;
303
304         /* set when res.limit == memsw.limit */
305         bool            memsw_is_minimum;
306
307         /* protect arrays of thresholds */
308         struct mutex thresholds_lock;
309
310         /* thresholds for memory usage. RCU-protected */
311         struct mem_cgroup_thresholds thresholds;
312
313         /* thresholds for mem+swap usage. RCU-protected */
314         struct mem_cgroup_thresholds memsw_thresholds;
315
316         /* For oom notifier event fd */
317         struct list_head oom_notify;
318
319         /*
320          * Should we move charges of a task when a task is moved into this
321          * mem_cgroup ? And what type of charges should we move ?
322          */
323         unsigned long   move_charge_at_immigrate;
324         /*
325          * set > 0 if pages under this cgroup are moving to other cgroup.
326          */
327         atomic_t        moving_account;
328         /* taken only while moving_account > 0 */
329         spinlock_t      move_lock;
330         /*
331          * percpu counter.
332          */
333         struct mem_cgroup_stat_cpu __percpu *stat;
334         /*
335          * used when a cpu is offlined or other synchronizations
336          * See mem_cgroup_read_stat().
337          */
338         struct mem_cgroup_stat_cpu nocpu_base;
339         spinlock_t pcp_counter_lock;
340
341 #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
342         struct tcp_memcontrol tcp_mem;
343 #endif
344 };
345
346 /* internal only representation about the status of kmem accounting. */
347 enum {
348         KMEM_ACCOUNTED_ACTIVE = 0, /* accounted by this cgroup itself */
349 };
350
351 #define KMEM_ACCOUNTED_MASK (1 << KMEM_ACCOUNTED_ACTIVE)
352
353 #ifdef CONFIG_MEMCG_KMEM
354 static inline void memcg_kmem_set_active(struct mem_cgroup *memcg)
355 {
356         set_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
357 }
358 #endif
359
360 /* Stuffs for move charges at task migration. */
361 /*
362  * Types of charges to be moved. "move_charge_at_immitgrate" is treated as a
363  * left-shifted bitmap of these types.
364  */
365 enum move_type {
366         MOVE_CHARGE_TYPE_ANON,  /* private anonymous page and swap of it */
367         MOVE_CHARGE_TYPE_FILE,  /* file page(including tmpfs) and swap of it */
368         NR_MOVE_TYPE,
369 };
370
371 /* "mc" and its members are protected by cgroup_mutex */
372 static struct move_charge_struct {
373         spinlock_t        lock; /* for from, to */
374         struct mem_cgroup *from;
375         struct mem_cgroup *to;
376         unsigned long precharge;
377         unsigned long moved_charge;
378         unsigned long moved_swap;
379         struct task_struct *moving_task;        /* a task moving charges */
380         wait_queue_head_t waitq;                /* a waitq for other context */
381 } mc = {
382         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
383         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
384 };
385
386 static bool move_anon(void)
387 {
388         return test_bit(MOVE_CHARGE_TYPE_ANON,
389                                         &mc.to->move_charge_at_immigrate);
390 }
391
392 static bool move_file(void)
393 {
394         return test_bit(MOVE_CHARGE_TYPE_FILE,
395                                         &mc.to->move_charge_at_immigrate);
396 }
397
398 /*
399  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
400  * limit reclaim to prevent infinite loops, if they ever occur.
401  */
402 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
403 #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
404
405 enum charge_type {
406         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
407         MEM_CGROUP_CHARGE_TYPE_ANON,
408         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
409         MEM_CGROUP_CHARGE_TYPE_DROP,    /* a page was unused swap cache */
410         NR_CHARGE_TYPE,
411 };
412
413 /* for encoding cft->private value on file */
414 enum res_type {
415         _MEM,
416         _MEMSWAP,
417         _OOM_TYPE,
418         _KMEM,
419 };
420
421 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
422 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
423 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
424 /* Used for OOM nofiier */
425 #define OOM_CONTROL             (0)
426
427 /*
428  * Reclaim flags for mem_cgroup_hierarchical_reclaim
429  */
430 #define MEM_CGROUP_RECLAIM_NOSWAP_BIT   0x0
431 #define MEM_CGROUP_RECLAIM_NOSWAP       (1 << MEM_CGROUP_RECLAIM_NOSWAP_BIT)
432 #define MEM_CGROUP_RECLAIM_SHRINK_BIT   0x1
433 #define MEM_CGROUP_RECLAIM_SHRINK       (1 << MEM_CGROUP_RECLAIM_SHRINK_BIT)
434
435 static void mem_cgroup_get(struct mem_cgroup *memcg);
436 static void mem_cgroup_put(struct mem_cgroup *memcg);
437
438 static inline
439 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
440 {
441         return container_of(s, struct mem_cgroup, css);
442 }
443
444 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
445 {
446         return (memcg == root_mem_cgroup);
447 }
448
449 /* Writing them here to avoid exposing memcg's inner layout */
450 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
451
452 void sock_update_memcg(struct sock *sk)
453 {
454         if (mem_cgroup_sockets_enabled) {
455                 struct mem_cgroup *memcg;
456                 struct cg_proto *cg_proto;
457
458                 BUG_ON(!sk->sk_prot->proto_cgroup);
459
460                 /* Socket cloning can throw us here with sk_cgrp already
461                  * filled. It won't however, necessarily happen from
462                  * process context. So the test for root memcg given
463                  * the current task's memcg won't help us in this case.
464                  *
465                  * Respecting the original socket's memcg is a better
466                  * decision in this case.
467                  */
468                 if (sk->sk_cgrp) {
469                         BUG_ON(mem_cgroup_is_root(sk->sk_cgrp->memcg));
470                         mem_cgroup_get(sk->sk_cgrp->memcg);
471                         return;
472                 }
473
474                 rcu_read_lock();
475                 memcg = mem_cgroup_from_task(current);
476                 cg_proto = sk->sk_prot->proto_cgroup(memcg);
477                 if (!mem_cgroup_is_root(memcg) && memcg_proto_active(cg_proto)) {
478                         mem_cgroup_get(memcg);
479                         sk->sk_cgrp = cg_proto;
480                 }
481                 rcu_read_unlock();
482         }
483 }
484 EXPORT_SYMBOL(sock_update_memcg);
485
486 void sock_release_memcg(struct sock *sk)
487 {
488         if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
489                 struct mem_cgroup *memcg;
490                 WARN_ON(!sk->sk_cgrp->memcg);
491                 memcg = sk->sk_cgrp->memcg;
492                 mem_cgroup_put(memcg);
493         }
494 }
495
496 struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
497 {
498         if (!memcg || mem_cgroup_is_root(memcg))
499                 return NULL;
500
501         return &memcg->tcp_mem.cg_proto;
502 }
503 EXPORT_SYMBOL(tcp_proto_cgroup);
504
505 static void disarm_sock_keys(struct mem_cgroup *memcg)
506 {
507         if (!memcg_proto_activated(&memcg->tcp_mem.cg_proto))
508                 return;
509         static_key_slow_dec(&memcg_socket_limit_enabled);
510 }
511 #else
512 static void disarm_sock_keys(struct mem_cgroup *memcg)
513 {
514 }
515 #endif
516
517 static void drain_all_stock_async(struct mem_cgroup *memcg);
518
519 static struct mem_cgroup_per_zone *
520 mem_cgroup_zoneinfo(struct mem_cgroup *memcg, int nid, int zid)
521 {
522         return &memcg->info.nodeinfo[nid]->zoneinfo[zid];
523 }
524
525 struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)
526 {
527         return &memcg->css;
528 }
529
530 static struct mem_cgroup_per_zone *
531 page_cgroup_zoneinfo(struct mem_cgroup *memcg, struct page *page)
532 {
533         int nid = page_to_nid(page);
534         int zid = page_zonenum(page);
535
536         return mem_cgroup_zoneinfo(memcg, nid, zid);
537 }
538
539 static struct mem_cgroup_tree_per_zone *
540 soft_limit_tree_node_zone(int nid, int zid)
541 {
542         return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
543 }
544
545 static struct mem_cgroup_tree_per_zone *
546 soft_limit_tree_from_page(struct page *page)
547 {
548         int nid = page_to_nid(page);
549         int zid = page_zonenum(page);
550
551         return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
552 }
553
554 static void
555 __mem_cgroup_insert_exceeded(struct mem_cgroup *memcg,
556                                 struct mem_cgroup_per_zone *mz,
557                                 struct mem_cgroup_tree_per_zone *mctz,
558                                 unsigned long long new_usage_in_excess)
559 {
560         struct rb_node **p = &mctz->rb_root.rb_node;
561         struct rb_node *parent = NULL;
562         struct mem_cgroup_per_zone *mz_node;
563
564         if (mz->on_tree)
565                 return;
566
567         mz->usage_in_excess = new_usage_in_excess;
568         if (!mz->usage_in_excess)
569                 return;
570         while (*p) {
571                 parent = *p;
572                 mz_node = rb_entry(parent, struct mem_cgroup_per_zone,
573                                         tree_node);
574                 if (mz->usage_in_excess < mz_node->usage_in_excess)
575                         p = &(*p)->rb_left;
576                 /*
577                  * We can't avoid mem cgroups that are over their soft
578                  * limit by the same amount
579                  */
580                 else if (mz->usage_in_excess >= mz_node->usage_in_excess)
581                         p = &(*p)->rb_right;
582         }
583         rb_link_node(&mz->tree_node, parent, p);
584         rb_insert_color(&mz->tree_node, &mctz->rb_root);
585         mz->on_tree = true;
586 }
587
588 static void
589 __mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
590                                 struct mem_cgroup_per_zone *mz,
591                                 struct mem_cgroup_tree_per_zone *mctz)
592 {
593         if (!mz->on_tree)
594                 return;
595         rb_erase(&mz->tree_node, &mctz->rb_root);
596         mz->on_tree = false;
597 }
598
599 static void
600 mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
601                                 struct mem_cgroup_per_zone *mz,
602                                 struct mem_cgroup_tree_per_zone *mctz)
603 {
604         spin_lock(&mctz->lock);
605         __mem_cgroup_remove_exceeded(memcg, mz, mctz);
606         spin_unlock(&mctz->lock);
607 }
608
609
610 static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
611 {
612         unsigned long long excess;
613         struct mem_cgroup_per_zone *mz;
614         struct mem_cgroup_tree_per_zone *mctz;
615         int nid = page_to_nid(page);
616         int zid = page_zonenum(page);
617         mctz = soft_limit_tree_from_page(page);
618
619         /*
620          * Necessary to update all ancestors when hierarchy is used.
621          * because their event counter is not touched.
622          */
623         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
624                 mz = mem_cgroup_zoneinfo(memcg, nid, zid);
625                 excess = res_counter_soft_limit_excess(&memcg->res);
626                 /*
627                  * We have to update the tree if mz is on RB-tree or
628                  * mem is over its softlimit.
629                  */
630                 if (excess || mz->on_tree) {
631                         spin_lock(&mctz->lock);
632                         /* if on-tree, remove it */
633                         if (mz->on_tree)
634                                 __mem_cgroup_remove_exceeded(memcg, mz, mctz);
635                         /*
636                          * Insert again. mz->usage_in_excess will be updated.
637                          * If excess is 0, no tree ops.
638                          */
639                         __mem_cgroup_insert_exceeded(memcg, mz, mctz, excess);
640                         spin_unlock(&mctz->lock);
641                 }
642         }
643 }
644
645 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
646 {
647         int node, zone;
648         struct mem_cgroup_per_zone *mz;
649         struct mem_cgroup_tree_per_zone *mctz;
650
651         for_each_node(node) {
652                 for (zone = 0; zone < MAX_NR_ZONES; zone++) {
653                         mz = mem_cgroup_zoneinfo(memcg, node, zone);
654                         mctz = soft_limit_tree_node_zone(node, zone);
655                         mem_cgroup_remove_exceeded(memcg, mz, mctz);
656                 }
657         }
658 }
659
660 static struct mem_cgroup_per_zone *
661 __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
662 {
663         struct rb_node *rightmost = NULL;
664         struct mem_cgroup_per_zone *mz;
665
666 retry:
667         mz = NULL;
668         rightmost = rb_last(&mctz->rb_root);
669         if (!rightmost)
670                 goto done;              /* Nothing to reclaim from */
671
672         mz = rb_entry(rightmost, struct mem_cgroup_per_zone, tree_node);
673         /*
674          * Remove the node now but someone else can add it back,
675          * we will to add it back at the end of reclaim to its correct
676          * position in the tree.
677          */
678         __mem_cgroup_remove_exceeded(mz->memcg, mz, mctz);
679         if (!res_counter_soft_limit_excess(&mz->memcg->res) ||
680                 !css_tryget(&mz->memcg->css))
681                 goto retry;
682 done:
683         return mz;
684 }
685
686 static struct mem_cgroup_per_zone *
687 mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
688 {
689         struct mem_cgroup_per_zone *mz;
690
691         spin_lock(&mctz->lock);
692         mz = __mem_cgroup_largest_soft_limit_node(mctz);
693         spin_unlock(&mctz->lock);
694         return mz;
695 }
696
697 /*
698  * Implementation Note: reading percpu statistics for memcg.
699  *
700  * Both of vmstat[] and percpu_counter has threshold and do periodic
701  * synchronization to implement "quick" read. There are trade-off between
702  * reading cost and precision of value. Then, we may have a chance to implement
703  * a periodic synchronizion of counter in memcg's counter.
704  *
705  * But this _read() function is used for user interface now. The user accounts
706  * memory usage by memory cgroup and he _always_ requires exact value because
707  * he accounts memory. Even if we provide quick-and-fuzzy read, we always
708  * have to visit all online cpus and make sum. So, for now, unnecessary
709  * synchronization is not implemented. (just implemented for cpu hotplug)
710  *
711  * If there are kernel internal actions which can make use of some not-exact
712  * value, and reading all cpu value can be performance bottleneck in some
713  * common workload, threashold and synchonization as vmstat[] should be
714  * implemented.
715  */
716 static long mem_cgroup_read_stat(struct mem_cgroup *memcg,
717                                  enum mem_cgroup_stat_index idx)
718 {
719         long val = 0;
720         int cpu;
721
722         get_online_cpus();
723         for_each_online_cpu(cpu)
724                 val += per_cpu(memcg->stat->count[idx], cpu);
725 #ifdef CONFIG_HOTPLUG_CPU
726         spin_lock(&memcg->pcp_counter_lock);
727         val += memcg->nocpu_base.count[idx];
728         spin_unlock(&memcg->pcp_counter_lock);
729 #endif
730         put_online_cpus();
731         return val;
732 }
733
734 static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,
735                                          bool charge)
736 {
737         int val = (charge) ? 1 : -1;
738         this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_SWAP], val);
739 }
740
741 static unsigned long mem_cgroup_read_events(struct mem_cgroup *memcg,
742                                             enum mem_cgroup_events_index idx)
743 {
744         unsigned long val = 0;
745         int cpu;
746
747         for_each_online_cpu(cpu)
748                 val += per_cpu(memcg->stat->events[idx], cpu);
749 #ifdef CONFIG_HOTPLUG_CPU
750         spin_lock(&memcg->pcp_counter_lock);
751         val += memcg->nocpu_base.events[idx];
752         spin_unlock(&memcg->pcp_counter_lock);
753 #endif
754         return val;
755 }
756
757 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
758                                          bool anon, int nr_pages)
759 {
760         preempt_disable();
761
762         /*
763          * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
764          * counted as CACHE even if it's on ANON LRU.
765          */
766         if (anon)
767                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],
768                                 nr_pages);
769         else
770                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_CACHE],
771                                 nr_pages);
772
773         /* pagein of a big page is an event. So, ignore page size */
774         if (nr_pages > 0)
775                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGIN]);
776         else {
777                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT]);
778                 nr_pages = -nr_pages; /* for event */
779         }
780
781         __this_cpu_add(memcg->stat->nr_page_events, nr_pages);
782
783         preempt_enable();
784 }
785
786 unsigned long
787 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
788 {
789         struct mem_cgroup_per_zone *mz;
790
791         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
792         return mz->lru_size[lru];
793 }
794
795 static unsigned long
796 mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
797                         unsigned int lru_mask)
798 {
799         struct mem_cgroup_per_zone *mz;
800         enum lru_list lru;
801         unsigned long ret = 0;
802
803         mz = mem_cgroup_zoneinfo(memcg, nid, zid);
804
805         for_each_lru(lru) {
806                 if (BIT(lru) & lru_mask)
807                         ret += mz->lru_size[lru];
808         }
809         return ret;
810 }
811
812 static unsigned long
813 mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
814                         int nid, unsigned int lru_mask)
815 {
816         u64 total = 0;
817         int zid;
818
819         for (zid = 0; zid < MAX_NR_ZONES; zid++)
820                 total += mem_cgroup_zone_nr_lru_pages(memcg,
821                                                 nid, zid, lru_mask);
822
823         return total;
824 }
825
826 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
827                         unsigned int lru_mask)
828 {
829         int nid;
830         u64 total = 0;
831
832         for_each_node_state(nid, N_MEMORY)
833                 total += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
834         return total;
835 }
836
837 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
838                                        enum mem_cgroup_events_target target)
839 {
840         unsigned long val, next;
841
842         val = __this_cpu_read(memcg->stat->nr_page_events);
843         next = __this_cpu_read(memcg->stat->targets[target]);
844         /* from time_after() in jiffies.h */
845         if ((long)next - (long)val < 0) {
846                 switch (target) {
847                 case MEM_CGROUP_TARGET_THRESH:
848                         next = val + THRESHOLDS_EVENTS_TARGET;
849                         break;
850                 case MEM_CGROUP_TARGET_SOFTLIMIT:
851                         next = val + SOFTLIMIT_EVENTS_TARGET;
852                         break;
853                 case MEM_CGROUP_TARGET_NUMAINFO:
854                         next = val + NUMAINFO_EVENTS_TARGET;
855                         break;
856                 default:
857                         break;
858                 }
859                 __this_cpu_write(memcg->stat->targets[target], next);
860                 return true;
861         }
862         return false;
863 }
864
865 /*
866  * Check events in order.
867  *
868  */
869 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
870 {
871         preempt_disable();
872         /* threshold event is triggered in finer grain than soft limit */
873         if (unlikely(mem_cgroup_event_ratelimit(memcg,
874                                                 MEM_CGROUP_TARGET_THRESH))) {
875                 bool do_softlimit;
876                 bool do_numainfo __maybe_unused;
877
878                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
879                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
880 #if MAX_NUMNODES > 1
881                 do_numainfo = mem_cgroup_event_ratelimit(memcg,
882                                                 MEM_CGROUP_TARGET_NUMAINFO);
883 #endif
884                 preempt_enable();
885
886                 mem_cgroup_threshold(memcg);
887                 if (unlikely(do_softlimit))
888                         mem_cgroup_update_tree(memcg, page);
889 #if MAX_NUMNODES > 1
890                 if (unlikely(do_numainfo))
891                         atomic_inc(&memcg->numainfo_events);
892 #endif
893         } else
894                 preempt_enable();
895 }
896
897 struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont)
898 {
899         return mem_cgroup_from_css(
900                 cgroup_subsys_state(cont, mem_cgroup_subsys_id));
901 }
902
903 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
904 {
905         /*
906          * mm_update_next_owner() may clear mm->owner to NULL
907          * if it races with swapoff, page migration, etc.
908          * So this can be called with p == NULL.
909          */
910         if (unlikely(!p))
911                 return NULL;
912
913         return mem_cgroup_from_css(task_subsys_state(p, mem_cgroup_subsys_id));
914 }
915
916 struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
917 {
918         struct mem_cgroup *memcg = NULL;
919
920         if (!mm)
921                 return NULL;
922         /*
923          * Because we have no locks, mm->owner's may be being moved to other
924          * cgroup. We use css_tryget() here even if this looks
925          * pessimistic (rather than adding locks here).
926          */
927         rcu_read_lock();
928         do {
929                 memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
930                 if (unlikely(!memcg))
931                         break;
932         } while (!css_tryget(&memcg->css));
933         rcu_read_unlock();
934         return memcg;
935 }
936
937 /**
938  * mem_cgroup_iter - iterate over memory cgroup hierarchy
939  * @root: hierarchy root
940  * @prev: previously returned memcg, NULL on first invocation
941  * @reclaim: cookie for shared reclaim walks, NULL for full walks
942  *
943  * Returns references to children of the hierarchy below @root, or
944  * @root itself, or %NULL after a full round-trip.
945  *
946  * Caller must pass the return value in @prev on subsequent
947  * invocations for reference counting, or use mem_cgroup_iter_break()
948  * to cancel a hierarchy walk before the round-trip is complete.
949  *
950  * Reclaimers can specify a zone and a priority level in @reclaim to
951  * divide up the memcgs in the hierarchy among all concurrent
952  * reclaimers operating on the same zone and priority.
953  */
954 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
955                                    struct mem_cgroup *prev,
956                                    struct mem_cgroup_reclaim_cookie *reclaim)
957 {
958         struct mem_cgroup *memcg = NULL;
959         int id = 0;
960
961         if (mem_cgroup_disabled())
962                 return NULL;
963
964         if (!root)
965                 root = root_mem_cgroup;
966
967         if (prev && !reclaim)
968                 id = css_id(&prev->css);
969
970         if (prev && prev != root)
971                 css_put(&prev->css);
972
973         if (!root->use_hierarchy && root != root_mem_cgroup) {
974                 if (prev)
975                         return NULL;
976                 return root;
977         }
978
979         while (!memcg) {
980                 struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
981                 struct cgroup_subsys_state *css;
982
983                 if (reclaim) {
984                         int nid = zone_to_nid(reclaim->zone);
985                         int zid = zone_idx(reclaim->zone);
986                         struct mem_cgroup_per_zone *mz;
987
988                         mz = mem_cgroup_zoneinfo(root, nid, zid);
989                         iter = &mz->reclaim_iter[reclaim->priority];
990                         if (prev && reclaim->generation != iter->generation)
991                                 return NULL;
992                         id = iter->position;
993                 }
994
995                 rcu_read_lock();
996                 css = css_get_next(&mem_cgroup_subsys, id + 1, &root->css, &id);
997                 if (css) {
998                         if (css == &root->css || css_tryget(css))
999                                 memcg = mem_cgroup_from_css(css);
1000                 } else
1001                         id = 0;
1002                 rcu_read_unlock();
1003
1004                 if (reclaim) {
1005                         iter->position = id;
1006                         if (!css)
1007                                 iter->generation++;
1008                         else if (!prev && memcg)
1009                                 reclaim->generation = iter->generation;
1010                 }
1011
1012                 if (prev && !css)
1013                         return NULL;
1014         }
1015         return memcg;
1016 }
1017
1018 /**
1019  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1020  * @root: hierarchy root
1021  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1022  */
1023 void mem_cgroup_iter_break(struct mem_cgroup *root,
1024                            struct mem_cgroup *prev)
1025 {
1026         if (!root)
1027                 root = root_mem_cgroup;
1028         if (prev && prev != root)
1029                 css_put(&prev->css);
1030 }
1031
1032 /*
1033  * Iteration constructs for visiting all cgroups (under a tree).  If
1034  * loops are exited prematurely (break), mem_cgroup_iter_break() must
1035  * be used for reference counting.
1036  */
1037 #define for_each_mem_cgroup_tree(iter, root)            \
1038         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
1039              iter != NULL;                              \
1040              iter = mem_cgroup_iter(root, iter, NULL))
1041
1042 #define for_each_mem_cgroup(iter)                       \
1043         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
1044              iter != NULL;                              \
1045              iter = mem_cgroup_iter(NULL, iter, NULL))
1046
1047 void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
1048 {
1049         struct mem_cgroup *memcg;
1050
1051         rcu_read_lock();
1052         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
1053         if (unlikely(!memcg))
1054                 goto out;
1055
1056         switch (idx) {
1057         case PGFAULT:
1058                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT]);
1059                 break;
1060         case PGMAJFAULT:
1061                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT]);
1062                 break;
1063         default:
1064                 BUG();
1065         }
1066 out:
1067         rcu_read_unlock();
1068 }
1069 EXPORT_SYMBOL(__mem_cgroup_count_vm_event);
1070
1071 /**
1072  * mem_cgroup_zone_lruvec - get the lru list vector for a zone and memcg
1073  * @zone: zone of the wanted lruvec
1074  * @memcg: memcg of the wanted lruvec
1075  *
1076  * Returns the lru list vector holding pages for the given @zone and
1077  * @mem.  This can be the global zone lruvec, if the memory controller
1078  * is disabled.
1079  */
1080 struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
1081                                       struct mem_cgroup *memcg)
1082 {
1083         struct mem_cgroup_per_zone *mz;
1084         struct lruvec *lruvec;
1085
1086         if (mem_cgroup_disabled()) {
1087                 lruvec = &zone->lruvec;
1088                 goto out;
1089         }
1090
1091         mz = mem_cgroup_zoneinfo(memcg, zone_to_nid(zone), zone_idx(zone));
1092         lruvec = &mz->lruvec;
1093 out:
1094         /*
1095          * Since a node can be onlined after the mem_cgroup was created,
1096          * we have to be prepared to initialize lruvec->zone here;
1097          * and if offlined then reonlined, we need to reinitialize it.
1098          */
1099         if (unlikely(lruvec->zone != zone))
1100                 lruvec->zone = zone;
1101         return lruvec;
1102 }
1103
1104 /*
1105  * Following LRU functions are allowed to be used without PCG_LOCK.
1106  * Operations are called by routine of global LRU independently from memcg.
1107  * What we have to take care of here is validness of pc->mem_cgroup.
1108  *
1109  * Changes to pc->mem_cgroup happens when
1110  * 1. charge
1111  * 2. moving account
1112  * In typical case, "charge" is done before add-to-lru. Exception is SwapCache.
1113  * It is added to LRU before charge.
1114  * If PCG_USED bit is not set, page_cgroup is not added to this private LRU.
1115  * When moving account, the page is not on LRU. It's isolated.
1116  */
1117
1118 /**
1119  * mem_cgroup_page_lruvec - return lruvec for adding an lru page
1120  * @page: the page
1121  * @zone: zone of the page
1122  */
1123 struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)
1124 {
1125         struct mem_cgroup_per_zone *mz;
1126         struct mem_cgroup *memcg;
1127         struct page_cgroup *pc;
1128         struct lruvec *lruvec;
1129
1130         if (mem_cgroup_disabled()) {
1131                 lruvec = &zone->lruvec;
1132                 goto out;
1133         }
1134
1135         pc = lookup_page_cgroup(page);
1136         memcg = pc->mem_cgroup;
1137
1138         /*
1139          * Surreptitiously switch any uncharged offlist page to root:
1140          * an uncharged page off lru does nothing to secure
1141          * its former mem_cgroup from sudden removal.
1142          *
1143          * Our caller holds lru_lock, and PageCgroupUsed is updated
1144          * under page_cgroup lock: between them, they make all uses
1145          * of pc->mem_cgroup safe.
1146          */
1147         if (!PageLRU(page) && !PageCgroupUsed(pc) && memcg != root_mem_cgroup)
1148                 pc->mem_cgroup = memcg = root_mem_cgroup;
1149
1150         mz = page_cgroup_zoneinfo(memcg, page);
1151         lruvec = &mz->lruvec;
1152 out:
1153         /*
1154          * Since a node can be onlined after the mem_cgroup was created,
1155          * we have to be prepared to initialize lruvec->zone here;
1156          * and if offlined then reonlined, we need to reinitialize it.
1157          */
1158         if (unlikely(lruvec->zone != zone))
1159                 lruvec->zone = zone;
1160         return lruvec;
1161 }
1162
1163 /**
1164  * mem_cgroup_update_lru_size - account for adding or removing an lru page
1165  * @lruvec: mem_cgroup per zone lru vector
1166  * @lru: index of lru list the page is sitting on
1167  * @nr_pages: positive when adding or negative when removing
1168  *
1169  * This function must be called when a page is added to or removed from an
1170  * lru list.
1171  */
1172 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1173                                 int nr_pages)
1174 {
1175         struct mem_cgroup_per_zone *mz;
1176         unsigned long *lru_size;
1177
1178         if (mem_cgroup_disabled())
1179                 return;
1180
1181         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
1182         lru_size = mz->lru_size + lru;
1183         *lru_size += nr_pages;
1184         VM_BUG_ON((long)(*lru_size) < 0);
1185 }
1186
1187 /*
1188  * Checks whether given mem is same or in the root_mem_cgroup's
1189  * hierarchy subtree
1190  */
1191 bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1192                                   struct mem_cgroup *memcg)
1193 {
1194         if (root_memcg == memcg)
1195                 return true;
1196         if (!root_memcg->use_hierarchy || !memcg)
1197                 return false;
1198         return css_is_ancestor(&memcg->css, &root_memcg->css);
1199 }
1200
1201 static bool mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1202                                        struct mem_cgroup *memcg)
1203 {
1204         bool ret;
1205
1206         rcu_read_lock();
1207         ret = __mem_cgroup_same_or_subtree(root_memcg, memcg);
1208         rcu_read_unlock();
1209         return ret;
1210 }
1211
1212 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *memcg)
1213 {
1214         int ret;
1215         struct mem_cgroup *curr = NULL;
1216         struct task_struct *p;
1217
1218         p = find_lock_task_mm(task);
1219         if (p) {
1220                 curr = try_get_mem_cgroup_from_mm(p->mm);
1221                 task_unlock(p);
1222         } else {
1223                 /*
1224                  * All threads may have already detached their mm's, but the oom
1225                  * killer still needs to detect if they have already been oom
1226                  * killed to prevent needlessly killing additional tasks.
1227                  */
1228                 task_lock(task);
1229                 curr = mem_cgroup_from_task(task);
1230                 if (curr)
1231                         css_get(&curr->css);
1232                 task_unlock(task);
1233         }
1234         if (!curr)
1235                 return 0;
1236         /*
1237          * We should check use_hierarchy of "memcg" not "curr". Because checking
1238          * use_hierarchy of "curr" here make this function true if hierarchy is
1239          * enabled in "curr" and "curr" is a child of "memcg" in *cgroup*
1240          * hierarchy(even if use_hierarchy is disabled in "memcg").
1241          */
1242         ret = mem_cgroup_same_or_subtree(memcg, curr);
1243         css_put(&curr->css);
1244         return ret;
1245 }
1246
1247 int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
1248 {
1249         unsigned long inactive_ratio;
1250         unsigned long inactive;
1251         unsigned long active;
1252         unsigned long gb;
1253
1254         inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_ANON);
1255         active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_ANON);
1256
1257         gb = (inactive + active) >> (30 - PAGE_SHIFT);
1258         if (gb)
1259                 inactive_ratio = int_sqrt(10 * gb);
1260         else
1261                 inactive_ratio = 1;
1262
1263         return inactive * inactive_ratio < active;
1264 }
1265
1266 int mem_cgroup_inactive_file_is_low(struct lruvec *lruvec)
1267 {
1268         unsigned long active;
1269         unsigned long inactive;
1270
1271         inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_FILE);
1272         active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_FILE);
1273
1274         return (active > inactive);
1275 }
1276
1277 #define mem_cgroup_from_res_counter(counter, member)    \
1278         container_of(counter, struct mem_cgroup, member)
1279
1280 /**
1281  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1282  * @memcg: the memory cgroup
1283  *
1284  * Returns the maximum amount of memory @mem can be charged with, in
1285  * pages.
1286  */
1287 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1288 {
1289         unsigned long long margin;
1290
1291         margin = res_counter_margin(&memcg->res);
1292         if (do_swap_account)
1293                 margin = min(margin, res_counter_margin(&memcg->memsw));
1294         return margin >> PAGE_SHIFT;
1295 }
1296
1297 int mem_cgroup_swappiness(struct mem_cgroup *memcg)
1298 {
1299         struct cgroup *cgrp = memcg->css.cgroup;
1300
1301         /* root ? */
1302         if (cgrp->parent == NULL)
1303                 return vm_swappiness;
1304
1305         return memcg->swappiness;
1306 }
1307
1308 /*
1309  * memcg->moving_account is used for checking possibility that some thread is
1310  * calling move_account(). When a thread on CPU-A starts moving pages under
1311  * a memcg, other threads should check memcg->moving_account under
1312  * rcu_read_lock(), like this:
1313  *
1314  *         CPU-A                                    CPU-B
1315  *                                              rcu_read_lock()
1316  *         memcg->moving_account+1              if (memcg->mocing_account)
1317  *                                                   take heavy locks.
1318  *         synchronize_rcu()                    update something.
1319  *                                              rcu_read_unlock()
1320  *         start move here.
1321  */
1322
1323 /* for quick checking without looking up memcg */
1324 atomic_t memcg_moving __read_mostly;
1325
1326 static void mem_cgroup_start_move(struct mem_cgroup *memcg)
1327 {
1328         atomic_inc(&memcg_moving);
1329         atomic_inc(&memcg->moving_account);
1330         synchronize_rcu();
1331 }
1332
1333 static void mem_cgroup_end_move(struct mem_cgroup *memcg)
1334 {
1335         /*
1336          * Now, mem_cgroup_clear_mc() may call this function with NULL.
1337          * We check NULL in callee rather than caller.
1338          */
1339         if (memcg) {
1340                 atomic_dec(&memcg_moving);
1341                 atomic_dec(&memcg->moving_account);
1342         }
1343 }
1344
1345 /*
1346  * 2 routines for checking "mem" is under move_account() or not.
1347  *
1348  * mem_cgroup_stolen() -  checking whether a cgroup is mc.from or not. This
1349  *                        is used for avoiding races in accounting.  If true,
1350  *                        pc->mem_cgroup may be overwritten.
1351  *
1352  * mem_cgroup_under_move() - checking a cgroup is mc.from or mc.to or
1353  *                        under hierarchy of moving cgroups. This is for
1354  *                        waiting at hith-memory prressure caused by "move".
1355  */
1356
1357 static bool mem_cgroup_stolen(struct mem_cgroup *memcg)
1358 {
1359         VM_BUG_ON(!rcu_read_lock_held());
1360         return atomic_read(&memcg->moving_account) > 0;
1361 }
1362
1363 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1364 {
1365         struct mem_cgroup *from;
1366         struct mem_cgroup *to;
1367         bool ret = false;
1368         /*
1369          * Unlike task_move routines, we access mc.to, mc.from not under
1370          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1371          */
1372         spin_lock(&mc.lock);
1373         from = mc.from;
1374         to = mc.to;
1375         if (!from)
1376                 goto unlock;
1377
1378         ret = mem_cgroup_same_or_subtree(memcg, from)
1379                 || mem_cgroup_same_or_subtree(memcg, to);
1380 unlock:
1381         spin_unlock(&mc.lock);
1382         return ret;
1383 }
1384
1385 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1386 {
1387         if (mc.moving_task && current != mc.moving_task) {
1388                 if (mem_cgroup_under_move(memcg)) {
1389                         DEFINE_WAIT(wait);
1390                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1391                         /* moving charge context might have finished. */
1392                         if (mc.moving_task)
1393                                 schedule();
1394                         finish_wait(&mc.waitq, &wait);
1395                         return true;
1396                 }
1397         }
1398         return false;
1399 }
1400
1401 /*
1402  * Take this lock when
1403  * - a code tries to modify page's memcg while it's USED.
1404  * - a code tries to modify page state accounting in a memcg.
1405  * see mem_cgroup_stolen(), too.
1406  */
1407 static void move_lock_mem_cgroup(struct mem_cgroup *memcg,
1408                                   unsigned long *flags)
1409 {
1410         spin_lock_irqsave(&memcg->move_lock, *flags);
1411 }
1412
1413 static void move_unlock_mem_cgroup(struct mem_cgroup *memcg,
1414                                 unsigned long *flags)
1415 {
1416         spin_unlock_irqrestore(&memcg->move_lock, *flags);
1417 }
1418
1419 /**
1420  * mem_cgroup_print_oom_info: Called from OOM with tasklist_lock held in read mode.
1421  * @memcg: The memory cgroup that went over limit
1422  * @p: Task that is going to be killed
1423  *
1424  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1425  * enabled
1426  */
1427 void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
1428 {
1429         struct cgroup *task_cgrp;
1430         struct cgroup *mem_cgrp;
1431         /*
1432          * Need a buffer in BSS, can't rely on allocations. The code relies
1433          * on the assumption that OOM is serialized for memory controller.
1434          * If this assumption is broken, revisit this code.
1435          */
1436         static char memcg_name[PATH_MAX];
1437         int ret;
1438
1439         if (!memcg || !p)
1440                 return;
1441
1442         rcu_read_lock();
1443
1444         mem_cgrp = memcg->css.cgroup;
1445         task_cgrp = task_cgroup(p, mem_cgroup_subsys_id);
1446
1447         ret = cgroup_path(task_cgrp, memcg_name, PATH_MAX);
1448         if (ret < 0) {
1449                 /*
1450                  * Unfortunately, we are unable to convert to a useful name
1451                  * But we'll still print out the usage information
1452                  */
1453                 rcu_read_unlock();
1454                 goto done;
1455         }
1456         rcu_read_unlock();
1457
1458         printk(KERN_INFO "Task in %s killed", memcg_name);
1459
1460         rcu_read_lock();
1461         ret = cgroup_path(mem_cgrp, memcg_name, PATH_MAX);
1462         if (ret < 0) {
1463                 rcu_read_unlock();
1464                 goto done;
1465         }
1466         rcu_read_unlock();
1467
1468         /*
1469          * Continues from above, so we don't need an KERN_ level
1470          */
1471         printk(KERN_CONT " as a result of limit of %s\n", memcg_name);
1472 done:
1473
1474         printk(KERN_INFO "memory: usage %llukB, limit %llukB, failcnt %llu\n",
1475                 res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
1476                 res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,
1477                 res_counter_read_u64(&memcg->res, RES_FAILCNT));
1478         printk(KERN_INFO "memory+swap: usage %llukB, limit %llukB, "
1479                 "failcnt %llu\n",
1480                 res_counter_read_u64(&memcg->memsw, RES_USAGE) >> 10,
1481                 res_counter_read_u64(&memcg->memsw, RES_LIMIT) >> 10,
1482                 res_counter_read_u64(&memcg->memsw, RES_FAILCNT));
1483         printk(KERN_INFO "kmem: usage %llukB, limit %llukB, failcnt %llu\n",
1484                 res_counter_read_u64(&memcg->kmem, RES_USAGE) >> 10,
1485                 res_counter_read_u64(&memcg->kmem, RES_LIMIT) >> 10,
1486                 res_counter_read_u64(&memcg->kmem, RES_FAILCNT));
1487 }
1488
1489 /*
1490  * This function returns the number of memcg under hierarchy tree. Returns
1491  * 1(self count) if no children.
1492  */
1493 static int mem_cgroup_count_children(struct mem_cgroup *memcg)
1494 {
1495         int num = 0;
1496         struct mem_cgroup *iter;
1497
1498         for_each_mem_cgroup_tree(iter, memcg)
1499                 num++;
1500         return num;
1501 }
1502
1503 /*
1504  * Return the memory (and swap, if configured) limit for a memcg.
1505  */
1506 static u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)
1507 {
1508         u64 limit;
1509
1510         limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
1511
1512         /*
1513          * Do not consider swap space if we cannot swap due to swappiness
1514          */
1515         if (mem_cgroup_swappiness(memcg)) {
1516                 u64 memsw;
1517
1518                 limit += total_swap_pages << PAGE_SHIFT;
1519                 memsw = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1520
1521                 /*
1522                  * If memsw is finite and limits the amount of swap space
1523                  * available to this memcg, return that limit.
1524                  */
1525                 limit = min(limit, memsw);
1526         }
1527
1528         return limit;
1529 }
1530
1531 static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1532                                      int order)
1533 {
1534         struct mem_cgroup *iter;
1535         unsigned long chosen_points = 0;
1536         unsigned long totalpages;
1537         unsigned int points = 0;
1538         struct task_struct *chosen = NULL;
1539
1540         /*
1541          * If current has a pending SIGKILL, then automatically select it.  The
1542          * goal is to allow it to allocate so that it may quickly exit and free
1543          * its memory.
1544          */
1545         if (fatal_signal_pending(current)) {
1546                 set_thread_flag(TIF_MEMDIE);
1547                 return;
1548         }
1549
1550         check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
1551         totalpages = mem_cgroup_get_limit(memcg) >> PAGE_SHIFT ? : 1;
1552         for_each_mem_cgroup_tree(iter, memcg) {
1553                 struct cgroup *cgroup = iter->css.cgroup;
1554                 struct cgroup_iter it;
1555                 struct task_struct *task;
1556
1557                 cgroup_iter_start(cgroup, &it);
1558                 while ((task = cgroup_iter_next(cgroup, &it))) {
1559                         switch (oom_scan_process_thread(task, totalpages, NULL,
1560                                                         false)) {
1561                         case OOM_SCAN_SELECT:
1562                                 if (chosen)
1563                                         put_task_struct(chosen);
1564                                 chosen = task;
1565                                 chosen_points = ULONG_MAX;
1566                                 get_task_struct(chosen);
1567                                 /* fall through */
1568                         case OOM_SCAN_CONTINUE:
1569                                 continue;
1570                         case OOM_SCAN_ABORT:
1571                                 cgroup_iter_end(cgroup, &it);
1572                                 mem_cgroup_iter_break(memcg, iter);
1573                                 if (chosen)
1574                                         put_task_struct(chosen);
1575                                 return;
1576                         case OOM_SCAN_OK:
1577                                 break;
1578                         };
1579                         points = oom_badness(task, memcg, NULL, totalpages);
1580                         if (points > chosen_points) {
1581                                 if (chosen)
1582                                         put_task_struct(chosen);
1583                                 chosen = task;
1584                                 chosen_points = points;
1585                                 get_task_struct(chosen);
1586                         }
1587                 }
1588                 cgroup_iter_end(cgroup, &it);
1589         }
1590
1591         if (!chosen)
1592                 return;
1593         points = chosen_points * 1000 / totalpages;
1594         oom_kill_process(chosen, gfp_mask, order, points, totalpages, memcg,
1595                          NULL, "Memory cgroup out of memory");
1596 }
1597
1598 static unsigned long mem_cgroup_reclaim(struct mem_cgroup *memcg,
1599                                         gfp_t gfp_mask,
1600                                         unsigned long flags)
1601 {
1602         unsigned long total = 0;
1603         bool noswap = false;
1604         int loop;
1605
1606         if (flags & MEM_CGROUP_RECLAIM_NOSWAP)
1607                 noswap = true;
1608         if (!(flags & MEM_CGROUP_RECLAIM_SHRINK) && memcg->memsw_is_minimum)
1609                 noswap = true;
1610
1611         for (loop = 0; loop < MEM_CGROUP_MAX_RECLAIM_LOOPS; loop++) {
1612                 if (loop)
1613                         drain_all_stock_async(memcg);
1614                 total += try_to_free_mem_cgroup_pages(memcg, gfp_mask, noswap);
1615                 /*
1616                  * Allow limit shrinkers, which are triggered directly
1617                  * by userspace, to catch signals and stop reclaim
1618                  * after minimal progress, regardless of the margin.
1619                  */
1620                 if (total && (flags & MEM_CGROUP_RECLAIM_SHRINK))
1621                         break;
1622                 if (mem_cgroup_margin(memcg))
1623                         break;
1624                 /*
1625                  * If nothing was reclaimed after two attempts, there
1626                  * may be no reclaimable pages in this hierarchy.
1627                  */
1628                 if (loop && !total)
1629                         break;
1630         }
1631         return total;
1632 }
1633
1634 /**
1635  * test_mem_cgroup_node_reclaimable
1636  * @memcg: the target memcg
1637  * @nid: the node ID to be checked.
1638  * @noswap : specify true here if the user wants flle only information.
1639  *
1640  * This function returns whether the specified memcg contains any
1641  * reclaimable pages on a node. Returns true if there are any reclaimable
1642  * pages in the node.
1643  */
1644 static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
1645                 int nid, bool noswap)
1646 {
1647         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))
1648                 return true;
1649         if (noswap || !total_swap_pages)
1650                 return false;
1651         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))
1652                 return true;
1653         return false;
1654
1655 }
1656 #if MAX_NUMNODES > 1
1657
1658 /*
1659  * Always updating the nodemask is not very good - even if we have an empty
1660  * list or the wrong list here, we can start from some node and traverse all
1661  * nodes based on the zonelist. So update the list loosely once per 10 secs.
1662  *
1663  */
1664 static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
1665 {
1666         int nid;
1667         /*
1668          * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
1669          * pagein/pageout changes since the last update.
1670          */
1671         if (!atomic_read(&memcg->numainfo_events))
1672                 return;
1673         if (atomic_inc_return(&memcg->numainfo_updating) > 1)
1674                 return;
1675
1676         /* make a nodemask where this memcg uses memory from */
1677         memcg->scan_nodes = node_states[N_MEMORY];
1678
1679         for_each_node_mask(nid, node_states[N_MEMORY]) {
1680
1681                 if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
1682                         node_clear(nid, memcg->scan_nodes);
1683         }
1684
1685         atomic_set(&memcg->numainfo_events, 0);
1686         atomic_set(&memcg->numainfo_updating, 0);
1687 }
1688
1689 /*
1690  * Selecting a node where we start reclaim from. Because what we need is just
1691  * reducing usage counter, start from anywhere is O,K. Considering
1692  * memory reclaim from current node, there are pros. and cons.
1693  *
1694  * Freeing memory from current node means freeing memory from a node which
1695  * we'll use or we've used. So, it may make LRU bad. And if several threads
1696  * hit limits, it will see a contention on a node. But freeing from remote
1697  * node means more costs for memory reclaim because of memory latency.
1698  *
1699  * Now, we use round-robin. Better algorithm is welcomed.
1700  */
1701 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1702 {
1703         int node;
1704
1705         mem_cgroup_may_update_nodemask(memcg);
1706         node = memcg->last_scanned_node;
1707
1708         node = next_node(node, memcg->scan_nodes);
1709         if (node == MAX_NUMNODES)
1710                 node = first_node(memcg->scan_nodes);
1711         /*
1712          * We call this when we hit limit, not when pages are added to LRU.
1713          * No LRU may hold pages because all pages are UNEVICTABLE or
1714          * memcg is too small and all pages are not on LRU. In that case,
1715          * we use curret node.
1716          */
1717         if (unlikely(node == MAX_NUMNODES))
1718                 node = numa_node_id();
1719
1720         memcg->last_scanned_node = node;
1721         return node;
1722 }
1723
1724 /*
1725  * Check all nodes whether it contains reclaimable pages or not.
1726  * For quick scan, we make use of scan_nodes. This will allow us to skip
1727  * unused nodes. But scan_nodes is lazily updated and may not cotain
1728  * enough new information. We need to do double check.
1729  */
1730 static bool mem_cgroup_reclaimable(struct mem_cgroup *memcg, bool noswap)
1731 {
1732         int nid;
1733
1734         /*
1735          * quick check...making use of scan_node.
1736          * We can skip unused nodes.
1737          */
1738         if (!nodes_empty(memcg->scan_nodes)) {
1739                 for (nid = first_node(memcg->scan_nodes);
1740                      nid < MAX_NUMNODES;
1741                      nid = next_node(nid, memcg->scan_nodes)) {
1742
1743                         if (test_mem_cgroup_node_reclaimable(memcg, nid, noswap))
1744                                 return true;
1745                 }
1746         }
1747         /*
1748          * Check rest of nodes.
1749          */
1750         for_each_node_state(nid, N_MEMORY) {
1751                 if (node_isset(nid, memcg->scan_nodes))
1752                         continue;
1753                 if (test_mem_cgroup_node_reclaimable(memcg, nid, noswap))
1754                         return true;
1755         }
1756         return false;
1757 }
1758
1759 #else
1760 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1761 {
1762         return 0;
1763 }
1764
1765 static bool mem_cgroup_reclaimable(struct mem_cgroup *memcg, bool noswap)
1766 {
1767         return test_mem_cgroup_node_reclaimable(memcg, 0, noswap);
1768 }
1769 #endif
1770
1771 static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1772                                    struct zone *zone,
1773                                    gfp_t gfp_mask,
1774                                    unsigned long *total_scanned)
1775 {
1776         struct mem_cgroup *victim = NULL;
1777         int total = 0;
1778         int loop = 0;
1779         unsigned long excess;
1780         unsigned long nr_scanned;
1781         struct mem_cgroup_reclaim_cookie reclaim = {
1782                 .zone = zone,
1783                 .priority = 0,
1784         };
1785
1786         excess = res_counter_soft_limit_excess(&root_memcg->res) >> PAGE_SHIFT;
1787
1788         while (1) {
1789                 victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
1790                 if (!victim) {
1791                         loop++;
1792                         if (loop >= 2) {
1793                                 /*
1794                                  * If we have not been able to reclaim
1795                                  * anything, it might because there are
1796                                  * no reclaimable pages under this hierarchy
1797                                  */
1798                                 if (!total)
1799                                         break;
1800                                 /*
1801                                  * We want to do more targeted reclaim.
1802                                  * excess >> 2 is not to excessive so as to
1803                                  * reclaim too much, nor too less that we keep
1804                                  * coming back to reclaim from this cgroup
1805                                  */
1806                                 if (total >= (excess >> 2) ||
1807                                         (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
1808                                         break;
1809                         }
1810                         continue;
1811                 }
1812                 if (!mem_cgroup_reclaimable(victim, false))
1813                         continue;
1814                 total += mem_cgroup_shrink_node_zone(victim, gfp_mask, false,
1815                                                      zone, &nr_scanned);
1816                 *total_scanned += nr_scanned;
1817                 if (!res_counter_soft_limit_excess(&root_memcg->res))
1818                         break;
1819         }
1820         mem_cgroup_iter_break(root_memcg, victim);
1821         return total;
1822 }
1823
1824 /*
1825  * Check OOM-Killer is already running under our hierarchy.
1826  * If someone is running, return false.
1827  * Has to be called with memcg_oom_lock
1828  */
1829 static bool mem_cgroup_oom_lock(struct mem_cgroup *memcg)
1830 {
1831         struct mem_cgroup *iter, *failed = NULL;
1832
1833         for_each_mem_cgroup_tree(iter, memcg) {
1834                 if (iter->oom_lock) {
1835                         /*
1836                          * this subtree of our hierarchy is already locked
1837                          * so we cannot give a lock.
1838                          */
1839                         failed = iter;
1840                         mem_cgroup_iter_break(memcg, iter);
1841                         break;
1842                 } else
1843                         iter->oom_lock = true;
1844         }
1845
1846         if (!failed)
1847                 return true;
1848
1849         /*
1850          * OK, we failed to lock the whole subtree so we have to clean up
1851          * what we set up to the failing subtree
1852          */
1853         for_each_mem_cgroup_tree(iter, memcg) {
1854                 if (iter == failed) {
1855                         mem_cgroup_iter_break(memcg, iter);
1856                         break;
1857                 }
1858                 iter->oom_lock = false;
1859         }
1860         return false;
1861 }
1862
1863 /*
1864  * Has to be called with memcg_oom_lock
1865  */
1866 static int mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1867 {
1868         struct mem_cgroup *iter;
1869
1870         for_each_mem_cgroup_tree(iter, memcg)
1871                 iter->oom_lock = false;
1872         return 0;
1873 }
1874
1875 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1876 {
1877         struct mem_cgroup *iter;
1878
1879         for_each_mem_cgroup_tree(iter, memcg)
1880                 atomic_inc(&iter->under_oom);
1881 }
1882
1883 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1884 {
1885         struct mem_cgroup *iter;
1886
1887         /*
1888          * When a new child is created while the hierarchy is under oom,
1889          * mem_cgroup_oom_lock() may not be called. We have to use
1890          * atomic_add_unless() here.
1891          */
1892         for_each_mem_cgroup_tree(iter, memcg)
1893                 atomic_add_unless(&iter->under_oom, -1, 0);
1894 }
1895
1896 static DEFINE_SPINLOCK(memcg_oom_lock);
1897 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1898
1899 struct oom_wait_info {
1900         struct mem_cgroup *memcg;
1901         wait_queue_t    wait;
1902 };
1903
1904 static int memcg_oom_wake_function(wait_queue_t *wait,
1905         unsigned mode, int sync, void *arg)
1906 {
1907         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1908         struct mem_cgroup *oom_wait_memcg;
1909         struct oom_wait_info *oom_wait_info;
1910
1911         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1912         oom_wait_memcg = oom_wait_info->memcg;
1913
1914         /*
1915          * Both of oom_wait_info->memcg and wake_memcg are stable under us.
1916          * Then we can use css_is_ancestor without taking care of RCU.
1917          */
1918         if (!mem_cgroup_same_or_subtree(oom_wait_memcg, wake_memcg)
1919                 && !mem_cgroup_same_or_subtree(wake_memcg, oom_wait_memcg))
1920                 return 0;
1921         return autoremove_wake_function(wait, mode, sync, arg);
1922 }
1923
1924 static void memcg_wakeup_oom(struct mem_cgroup *memcg)
1925 {
1926         /* for filtering, pass "memcg" as argument. */
1927         __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
1928 }
1929
1930 static void memcg_oom_recover(struct mem_cgroup *memcg)
1931 {
1932         if (memcg && atomic_read(&memcg->under_oom))
1933                 memcg_wakeup_oom(memcg);
1934 }
1935
1936 /*
1937  * try to call OOM killer. returns false if we should exit memory-reclaim loop.
1938  */
1939 static bool mem_cgroup_handle_oom(struct mem_cgroup *memcg, gfp_t mask,
1940                                   int order)
1941 {
1942         struct oom_wait_info owait;
1943         bool locked, need_to_kill;
1944
1945         owait.memcg = memcg;
1946         owait.wait.flags = 0;
1947         owait.wait.func = memcg_oom_wake_function;
1948         owait.wait.private = current;
1949         INIT_LIST_HEAD(&owait.wait.task_list);
1950         need_to_kill = true;
1951         mem_cgroup_mark_under_oom(memcg);
1952
1953         /* At first, try to OOM lock hierarchy under memcg.*/
1954         spin_lock(&memcg_oom_lock);
1955         locked = mem_cgroup_oom_lock(memcg);
1956         /*
1957          * Even if signal_pending(), we can't quit charge() loop without
1958          * accounting. So, UNINTERRUPTIBLE is appropriate. But SIGKILL
1959          * under OOM is always welcomed, use TASK_KILLABLE here.
1960          */
1961         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
1962         if (!locked || memcg->oom_kill_disable)
1963                 need_to_kill = false;
1964         if (locked)
1965                 mem_cgroup_oom_notify(memcg);
1966         spin_unlock(&memcg_oom_lock);
1967
1968         if (need_to_kill) {
1969                 finish_wait(&memcg_oom_waitq, &owait.wait);
1970                 mem_cgroup_out_of_memory(memcg, mask, order);
1971         } else {
1972                 schedule();
1973                 finish_wait(&memcg_oom_waitq, &owait.wait);
1974         }
1975         spin_lock(&memcg_oom_lock);
1976         if (locked)
1977                 mem_cgroup_oom_unlock(memcg);
1978         memcg_wakeup_oom(memcg);
1979         spin_unlock(&memcg_oom_lock);
1980
1981         mem_cgroup_unmark_under_oom(memcg);
1982
1983         if (test_thread_flag(TIF_MEMDIE) || fatal_signal_pending(current))
1984                 return false;
1985         /* Give chance to dying process */
1986         schedule_timeout_uninterruptible(1);
1987         return true;
1988 }
1989
1990 /*
1991  * Currently used to update mapped file statistics, but the routine can be
1992  * generalized to update other statistics as well.
1993  *
1994  * Notes: Race condition
1995  *
1996  * We usually use page_cgroup_lock() for accessing page_cgroup member but
1997  * it tends to be costly. But considering some conditions, we doesn't need
1998  * to do so _always_.
1999  *
2000  * Considering "charge", lock_page_cgroup() is not required because all
2001  * file-stat operations happen after a page is attached to radix-tree. There
2002  * are no race with "charge".
2003  *
2004  * Considering "uncharge", we know that memcg doesn't clear pc->mem_cgroup
2005  * at "uncharge" intentionally. So, we always see valid pc->mem_cgroup even
2006  * if there are race with "uncharge". Statistics itself is properly handled
2007  * by flags.
2008  *
2009  * Considering "move", this is an only case we see a race. To make the race
2010  * small, we check mm->moving_account and detect there are possibility of race
2011  * If there is, we take a lock.
2012  */
2013
2014 void __mem_cgroup_begin_update_page_stat(struct page *page,
2015                                 bool *locked, unsigned long *flags)
2016 {
2017         struct mem_cgroup *memcg;
2018         struct page_cgroup *pc;
2019
2020         pc = lookup_page_cgroup(page);
2021 again:
2022         memcg = pc->mem_cgroup;
2023         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2024                 return;
2025         /*
2026          * If this memory cgroup is not under account moving, we don't
2027          * need to take move_lock_mem_cgroup(). Because we already hold
2028          * rcu_read_lock(), any calls to move_account will be delayed until
2029          * rcu_read_unlock() if mem_cgroup_stolen() == true.
2030          */
2031         if (!mem_cgroup_stolen(memcg))
2032                 return;
2033
2034         move_lock_mem_cgroup(memcg, flags);
2035         if (memcg != pc->mem_cgroup || !PageCgroupUsed(pc)) {
2036                 move_unlock_mem_cgroup(memcg, flags);
2037                 goto again;
2038         }
2039         *locked = true;
2040 }
2041
2042 void __mem_cgroup_end_update_page_stat(struct page *page, unsigned long *flags)
2043 {
2044         struct page_cgroup *pc = lookup_page_cgroup(page);
2045
2046         /*
2047          * It's guaranteed that pc->mem_cgroup never changes while
2048          * lock is held because a routine modifies pc->mem_cgroup
2049          * should take move_lock_mem_cgroup().
2050          */
2051         move_unlock_mem_cgroup(pc->mem_cgroup, flags);
2052 }
2053
2054 void mem_cgroup_update_page_stat(struct page *page,
2055                                  enum mem_cgroup_page_stat_item idx, int val)
2056 {
2057         struct mem_cgroup *memcg;
2058         struct page_cgroup *pc = lookup_page_cgroup(page);
2059         unsigned long uninitialized_var(flags);
2060
2061         if (mem_cgroup_disabled())
2062                 return;
2063
2064         memcg = pc->mem_cgroup;
2065         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2066                 return;
2067
2068         switch (idx) {
2069         case MEMCG_NR_FILE_MAPPED:
2070                 idx = MEM_CGROUP_STAT_FILE_MAPPED;
2071                 break;
2072         default:
2073                 BUG();
2074         }
2075
2076         this_cpu_add(memcg->stat->count[idx], val);
2077 }
2078
2079 /*
2080  * size of first charge trial. "32" comes from vmscan.c's magic value.
2081  * TODO: maybe necessary to use big numbers in big irons.
2082  */
2083 #define CHARGE_BATCH    32U
2084 struct memcg_stock_pcp {
2085         struct mem_cgroup *cached; /* this never be root cgroup */
2086         unsigned int nr_pages;
2087         struct work_struct work;
2088         unsigned long flags;
2089 #define FLUSHING_CACHED_CHARGE  0
2090 };
2091 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
2092 static DEFINE_MUTEX(percpu_charge_mutex);
2093
2094 /**
2095  * consume_stock: Try to consume stocked charge on this cpu.
2096  * @memcg: memcg to consume from.
2097  * @nr_pages: how many pages to charge.
2098  *
2099  * The charges will only happen if @memcg matches the current cpu's memcg
2100  * stock, and at least @nr_pages are available in that stock.  Failure to
2101  * service an allocation will refill the stock.
2102  *
2103  * returns true if successful, false otherwise.
2104  */
2105 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2106 {
2107         struct memcg_stock_pcp *stock;
2108         bool ret = true;
2109
2110         if (nr_pages > CHARGE_BATCH)
2111                 return false;
2112
2113         stock = &get_cpu_var(memcg_stock);
2114         if (memcg == stock->cached && stock->nr_pages >= nr_pages)
2115                 stock->nr_pages -= nr_pages;
2116         else /* need to call res_counter_charge */
2117                 ret = false;
2118         put_cpu_var(memcg_stock);
2119         return ret;
2120 }
2121
2122 /*
2123  * Returns stocks cached in percpu to res_counter and reset cached information.
2124  */
2125 static void drain_stock(struct memcg_stock_pcp *stock)
2126 {
2127         struct mem_cgroup *old = stock->cached;
2128
2129         if (stock->nr_pages) {
2130                 unsigned long bytes = stock->nr_pages * PAGE_SIZE;
2131
2132                 res_counter_uncharge(&old->res, bytes);
2133                 if (do_swap_account)
2134                         res_counter_uncharge(&old->memsw, bytes);
2135                 stock->nr_pages = 0;
2136         }
2137         stock->cached = NULL;
2138 }
2139
2140 /*
2141  * This must be called under preempt disabled or must be called by
2142  * a thread which is pinned to local cpu.
2143  */
2144 static void drain_local_stock(struct work_struct *dummy)
2145 {
2146         struct memcg_stock_pcp *stock = &__get_cpu_var(memcg_stock);
2147         drain_stock(stock);
2148         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2149 }
2150
2151 /*
2152  * Cache charges(val) which is from res_counter, to local per_cpu area.
2153  * This will be consumed by consume_stock() function, later.
2154  */
2155 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2156 {
2157         struct memcg_stock_pcp *stock = &get_cpu_var(memcg_stock);
2158
2159         if (stock->cached != memcg) { /* reset if necessary */
2160                 drain_stock(stock);
2161                 stock->cached = memcg;
2162         }
2163         stock->nr_pages += nr_pages;
2164         put_cpu_var(memcg_stock);
2165 }
2166
2167 /*
2168  * Drains all per-CPU charge caches for given root_memcg resp. subtree
2169  * of the hierarchy under it. sync flag says whether we should block
2170  * until the work is done.
2171  */
2172 static void drain_all_stock(struct mem_cgroup *root_memcg, bool sync)
2173 {
2174         int cpu, curcpu;
2175
2176         /* Notify other cpus that system-wide "drain" is running */
2177         get_online_cpus();
2178         curcpu = get_cpu();
2179         for_each_online_cpu(cpu) {
2180                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2181                 struct mem_cgroup *memcg;
2182
2183                 memcg = stock->cached;
2184                 if (!memcg || !stock->nr_pages)
2185                         continue;
2186                 if (!mem_cgroup_same_or_subtree(root_memcg, memcg))
2187                         continue;
2188                 if (!test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2189                         if (cpu == curcpu)
2190                                 drain_local_stock(&stock->work);
2191                         else
2192                                 schedule_work_on(cpu, &stock->work);
2193                 }
2194         }
2195         put_cpu();
2196
2197         if (!sync)
2198                 goto out;
2199
2200         for_each_online_cpu(cpu) {
2201                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2202                 if (test_bit(FLUSHING_CACHED_CHARGE, &stock->flags))
2203                         flush_work(&stock->work);
2204         }
2205 out:
2206         put_online_cpus();
2207 }
2208
2209 /*
2210  * Tries to drain stocked charges in other cpus. This function is asynchronous
2211  * and just put a work per cpu for draining localy on each cpu. Caller can
2212  * expects some charges will be back to res_counter later but cannot wait for
2213  * it.
2214  */
2215 static void drain_all_stock_async(struct mem_cgroup *root_memcg)
2216 {
2217         /*
2218          * If someone calls draining, avoid adding more kworker runs.
2219          */
2220         if (!mutex_trylock(&percpu_charge_mutex))
2221                 return;
2222         drain_all_stock(root_memcg, false);
2223         mutex_unlock(&percpu_charge_mutex);
2224 }
2225
2226 /* This is a synchronous drain interface. */
2227 static void drain_all_stock_sync(struct mem_cgroup *root_memcg)
2228 {
2229         /* called when force_empty is called */
2230         mutex_lock(&percpu_charge_mutex);
2231         drain_all_stock(root_memcg, true);
2232         mutex_unlock(&percpu_charge_mutex);
2233 }
2234
2235 /*
2236  * This function drains percpu counter value from DEAD cpu and
2237  * move it to local cpu. Note that this function can be preempted.
2238  */
2239 static void mem_cgroup_drain_pcp_counter(struct mem_cgroup *memcg, int cpu)
2240 {
2241         int i;
2242
2243         spin_lock(&memcg->pcp_counter_lock);
2244         for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
2245                 long x = per_cpu(memcg->stat->count[i], cpu);
2246
2247                 per_cpu(memcg->stat->count[i], cpu) = 0;
2248                 memcg->nocpu_base.count[i] += x;
2249         }
2250         for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
2251                 unsigned long x = per_cpu(memcg->stat->events[i], cpu);
2252
2253                 per_cpu(memcg->stat->events[i], cpu) = 0;
2254                 memcg->nocpu_base.events[i] += x;
2255         }
2256         spin_unlock(&memcg->pcp_counter_lock);
2257 }
2258
2259 static int __cpuinit memcg_cpu_hotplug_callback(struct notifier_block *nb,
2260                                         unsigned long action,
2261                                         void *hcpu)
2262 {
2263         int cpu = (unsigned long)hcpu;
2264         struct memcg_stock_pcp *stock;
2265         struct mem_cgroup *iter;
2266
2267         if (action == CPU_ONLINE)
2268                 return NOTIFY_OK;
2269
2270         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
2271                 return NOTIFY_OK;
2272
2273         for_each_mem_cgroup(iter)
2274                 mem_cgroup_drain_pcp_counter(iter, cpu);
2275
2276         stock = &per_cpu(memcg_stock, cpu);
2277         drain_stock(stock);
2278         return NOTIFY_OK;
2279 }
2280
2281
2282 /* See __mem_cgroup_try_charge() for details */
2283 enum {
2284         CHARGE_OK,              /* success */
2285         CHARGE_RETRY,           /* need to retry but retry is not bad */
2286         CHARGE_NOMEM,           /* we can't do more. return -ENOMEM */
2287         CHARGE_WOULDBLOCK,      /* GFP_WAIT wasn't set and no enough res. */
2288         CHARGE_OOM_DIE,         /* the current is killed because of OOM */
2289 };
2290
2291 static int mem_cgroup_do_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2292                                 unsigned int nr_pages, unsigned int min_pages,
2293                                 bool oom_check)
2294 {
2295         unsigned long csize = nr_pages * PAGE_SIZE;
2296         struct mem_cgroup *mem_over_limit;
2297         struct res_counter *fail_res;
2298         unsigned long flags = 0;
2299         int ret;
2300
2301         ret = res_counter_charge(&memcg->res, csize, &fail_res);
2302
2303         if (likely(!ret)) {
2304                 if (!do_swap_account)
2305                         return CHARGE_OK;
2306                 ret = res_counter_charge(&memcg->memsw, csize, &fail_res);
2307                 if (likely(!ret))
2308                         return CHARGE_OK;
2309
2310                 res_counter_uncharge(&memcg->res, csize);
2311                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, memsw);
2312                 flags |= MEM_CGROUP_RECLAIM_NOSWAP;
2313         } else
2314                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, res);
2315         /*
2316          * Never reclaim on behalf of optional batching, retry with a
2317          * single page instead.
2318          */
2319         if (nr_pages > min_pages)
2320                 return CHARGE_RETRY;
2321
2322         if (!(gfp_mask & __GFP_WAIT))
2323                 return CHARGE_WOULDBLOCK;
2324
2325         if (gfp_mask & __GFP_NORETRY)
2326                 return CHARGE_NOMEM;
2327
2328         ret = mem_cgroup_reclaim(mem_over_limit, gfp_mask, flags);
2329         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2330                 return CHARGE_RETRY;
2331         /*
2332          * Even though the limit is exceeded at this point, reclaim
2333          * may have been able to free some pages.  Retry the charge
2334          * before killing the task.
2335          *
2336          * Only for regular pages, though: huge pages are rather
2337          * unlikely to succeed so close to the limit, and we fall back
2338          * to regular pages anyway in case of failure.
2339          */
2340         if (nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER) && ret)
2341                 return CHARGE_RETRY;
2342
2343         /*
2344          * At task move, charge accounts can be doubly counted. So, it's
2345          * better to wait until the end of task_move if something is going on.
2346          */
2347         if (mem_cgroup_wait_acct_move(mem_over_limit))
2348                 return CHARGE_RETRY;
2349
2350         /* If we don't need to call oom-killer at el, return immediately */
2351         if (!oom_check)
2352                 return CHARGE_NOMEM;
2353         /* check OOM */
2354         if (!mem_cgroup_handle_oom(mem_over_limit, gfp_mask, get_order(csize)))
2355                 return CHARGE_OOM_DIE;
2356
2357         return CHARGE_RETRY;
2358 }
2359
2360 /*
2361  * __mem_cgroup_try_charge() does
2362  * 1. detect memcg to be charged against from passed *mm and *ptr,
2363  * 2. update res_counter
2364  * 3. call memory reclaim if necessary.
2365  *
2366  * In some special case, if the task is fatal, fatal_signal_pending() or
2367  * has TIF_MEMDIE, this function returns -EINTR while writing root_mem_cgroup
2368  * to *ptr. There are two reasons for this. 1: fatal threads should quit as soon
2369  * as possible without any hazards. 2: all pages should have a valid
2370  * pc->mem_cgroup. If mm is NULL and the caller doesn't pass a valid memcg
2371  * pointer, that is treated as a charge to root_mem_cgroup.
2372  *
2373  * So __mem_cgroup_try_charge() will return
2374  *  0       ...  on success, filling *ptr with a valid memcg pointer.
2375  *  -ENOMEM ...  charge failure because of resource limits.
2376  *  -EINTR  ...  if thread is fatal. *ptr is filled with root_mem_cgroup.
2377  *
2378  * Unlike the exported interface, an "oom" parameter is added. if oom==true,
2379  * the oom-killer can be invoked.
2380  */
2381 static int __mem_cgroup_try_charge(struct mm_struct *mm,
2382                                    gfp_t gfp_mask,
2383                                    unsigned int nr_pages,
2384                                    struct mem_cgroup **ptr,
2385                                    bool oom)
2386 {
2387         unsigned int batch = max(CHARGE_BATCH, nr_pages);
2388         int nr_oom_retries = MEM_CGROUP_RECLAIM_RETRIES;
2389         struct mem_cgroup *memcg = NULL;
2390         int ret;
2391
2392         /*
2393          * Unlike gloval-vm's OOM-kill, we're not in memory shortage
2394          * in system level. So, allow to go ahead dying process in addition to
2395          * MEMDIE process.
2396          */
2397         if (unlikely(test_thread_flag(TIF_MEMDIE)
2398                      || fatal_signal_pending(current)))
2399                 goto bypass;
2400
2401         /*
2402          * We always charge the cgroup the mm_struct belongs to.
2403          * The mm_struct's mem_cgroup changes on task migration if the
2404          * thread group leader migrates. It's possible that mm is not
2405          * set, if so charge the root memcg (happens for pagecache usage).
2406          */
2407         if (!*ptr && !mm)
2408                 *ptr = root_mem_cgroup;
2409 again:
2410         if (*ptr) { /* css should be a valid one */
2411                 memcg = *ptr;
2412                 if (mem_cgroup_is_root(memcg))
2413                         goto done;
2414                 if (consume_stock(memcg, nr_pages))
2415                         goto done;
2416                 css_get(&memcg->css);
2417         } else {
2418                 struct task_struct *p;
2419
2420                 rcu_read_lock();
2421                 p = rcu_dereference(mm->owner);
2422                 /*
2423                  * Because we don't have task_lock(), "p" can exit.
2424                  * In that case, "memcg" can point to root or p can be NULL with
2425                  * race with swapoff. Then, we have small risk of mis-accouning.
2426                  * But such kind of mis-account by race always happens because
2427                  * we don't have cgroup_mutex(). It's overkill and we allo that
2428                  * small race, here.
2429                  * (*) swapoff at el will charge against mm-struct not against
2430                  * task-struct. So, mm->owner can be NULL.
2431                  */
2432                 memcg = mem_cgroup_from_task(p);
2433                 if (!memcg)
2434                         memcg = root_mem_cgroup;
2435                 if (mem_cgroup_is_root(memcg)) {
2436                         rcu_read_unlock();
2437                         goto done;
2438                 }
2439                 if (consume_stock(memcg, nr_pages)) {
2440                         /*
2441                          * It seems dagerous to access memcg without css_get().
2442                          * But considering how consume_stok works, it's not
2443                          * necessary. If consume_stock success, some charges
2444                          * from this memcg are cached on this cpu. So, we
2445                          * don't need to call css_get()/css_tryget() before
2446                          * calling consume_stock().
2447                          */
2448                         rcu_read_unlock();
2449                         goto done;
2450                 }
2451                 /* after here, we may be blocked. we need to get refcnt */
2452                 if (!css_tryget(&memcg->css)) {
2453                         rcu_read_unlock();
2454                         goto again;
2455                 }
2456                 rcu_read_unlock();
2457         }
2458
2459         do {
2460                 bool oom_check;
2461
2462                 /* If killed, bypass charge */
2463                 if (fatal_signal_pending(current)) {
2464                         css_put(&memcg->css);
2465                         goto bypass;
2466                 }
2467
2468                 oom_check = false;
2469                 if (oom && !nr_oom_retries) {
2470                         oom_check = true;
2471                         nr_oom_retries = MEM_CGROUP_RECLAIM_RETRIES;
2472                 }
2473
2474                 ret = mem_cgroup_do_charge(memcg, gfp_mask, batch, nr_pages,
2475                     oom_check);
2476                 switch (ret) {
2477                 case CHARGE_OK:
2478                         break;
2479                 case CHARGE_RETRY: /* not in OOM situation but retry */
2480                         batch = nr_pages;
2481                         css_put(&memcg->css);
2482                         memcg = NULL;
2483                         goto again;
2484                 case CHARGE_WOULDBLOCK: /* !__GFP_WAIT */
2485                         css_put(&memcg->css);
2486                         goto nomem;
2487                 case CHARGE_NOMEM: /* OOM routine works */
2488                         if (!oom) {
2489                                 css_put(&memcg->css);
2490                                 goto nomem;
2491                         }
2492                         /* If oom, we never return -ENOMEM */
2493                         nr_oom_retries--;
2494                         break;
2495                 case CHARGE_OOM_DIE: /* Killed by OOM Killer */
2496                         css_put(&memcg->css);
2497                         goto bypass;
2498                 }
2499         } while (ret != CHARGE_OK);
2500
2501         if (batch > nr_pages)
2502                 refill_stock(memcg, batch - nr_pages);
2503         css_put(&memcg->css);
2504 done:
2505         *ptr = memcg;
2506         return 0;
2507 nomem:
2508         *ptr = NULL;
2509         return -ENOMEM;
2510 bypass:
2511         *ptr = root_mem_cgroup;
2512         return -EINTR;
2513 }
2514
2515 /*
2516  * Somemtimes we have to undo a charge we got by try_charge().
2517  * This function is for that and do uncharge, put css's refcnt.
2518  * gotten by try_charge().
2519  */
2520 static void __mem_cgroup_cancel_charge(struct mem_cgroup *memcg,
2521                                        unsigned int nr_pages)
2522 {
2523         if (!mem_cgroup_is_root(memcg)) {
2524                 unsigned long bytes = nr_pages * PAGE_SIZE;
2525
2526                 res_counter_uncharge(&memcg->res, bytes);
2527                 if (do_swap_account)
2528                         res_counter_uncharge(&memcg->memsw, bytes);
2529         }
2530 }
2531
2532 /*
2533  * Cancel chrages in this cgroup....doesn't propagate to parent cgroup.
2534  * This is useful when moving usage to parent cgroup.
2535  */
2536 static void __mem_cgroup_cancel_local_charge(struct mem_cgroup *memcg,
2537                                         unsigned int nr_pages)
2538 {
2539         unsigned long bytes = nr_pages * PAGE_SIZE;
2540
2541         if (mem_cgroup_is_root(memcg))
2542                 return;
2543
2544         res_counter_uncharge_until(&memcg->res, memcg->res.parent, bytes);
2545         if (do_swap_account)
2546                 res_counter_uncharge_until(&memcg->memsw,
2547                                                 memcg->memsw.parent, bytes);
2548 }
2549
2550 /*
2551  * A helper function to get mem_cgroup from ID. must be called under
2552  * rcu_read_lock().  The caller is responsible for calling css_tryget if
2553  * the mem_cgroup is used for charging. (dropping refcnt from swap can be
2554  * called against removed memcg.)
2555  */
2556 static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
2557 {
2558         struct cgroup_subsys_state *css;
2559
2560         /* ID 0 is unused ID */
2561         if (!id)
2562                 return NULL;
2563         css = css_lookup(&mem_cgroup_subsys, id);
2564         if (!css)
2565                 return NULL;
2566         return mem_cgroup_from_css(css);
2567 }
2568
2569 struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
2570 {
2571         struct mem_cgroup *memcg = NULL;
2572         struct page_cgroup *pc;
2573         unsigned short id;
2574         swp_entry_t ent;
2575
2576         VM_BUG_ON(!PageLocked(page));
2577
2578         pc = lookup_page_cgroup(page);
2579         lock_page_cgroup(pc);
2580         if (PageCgroupUsed(pc)) {
2581                 memcg = pc->mem_cgroup;
2582                 if (memcg && !css_tryget(&memcg->css))
2583                         memcg = NULL;
2584         } else if (PageSwapCache(page)) {
2585                 ent.val = page_private(page);
2586                 id = lookup_swap_cgroup_id(ent);
2587                 rcu_read_lock();
2588                 memcg = mem_cgroup_lookup(id);
2589                 if (memcg && !css_tryget(&memcg->css))
2590                         memcg = NULL;
2591                 rcu_read_unlock();
2592         }
2593         unlock_page_cgroup(pc);
2594         return memcg;
2595 }
2596
2597 static void __mem_cgroup_commit_charge(struct mem_cgroup *memcg,
2598                                        struct page *page,
2599                                        unsigned int nr_pages,
2600                                        enum charge_type ctype,
2601                                        bool lrucare)
2602 {
2603         struct page_cgroup *pc = lookup_page_cgroup(page);
2604         struct zone *uninitialized_var(zone);
2605         struct lruvec *lruvec;
2606         bool was_on_lru = false;
2607         bool anon;
2608
2609         lock_page_cgroup(pc);
2610         VM_BUG_ON(PageCgroupUsed(pc));
2611         /*
2612          * we don't need page_cgroup_lock about tail pages, becase they are not
2613          * accessed by any other context at this point.
2614          */
2615
2616         /*
2617          * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2618          * may already be on some other mem_cgroup's LRU.  Take care of it.
2619          */
2620         if (lrucare) {
2621                 zone = page_zone(page);
2622                 spin_lock_irq(&zone->lru_lock);
2623                 if (PageLRU(page)) {
2624                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2625                         ClearPageLRU(page);
2626                         del_page_from_lru_list(page, lruvec, page_lru(page));
2627                         was_on_lru = true;
2628                 }
2629         }
2630
2631         pc->mem_cgroup = memcg;
2632         /*
2633          * We access a page_cgroup asynchronously without lock_page_cgroup().
2634          * Especially when a page_cgroup is taken from a page, pc->mem_cgroup
2635          * is accessed after testing USED bit. To make pc->mem_cgroup visible
2636          * before USED bit, we need memory barrier here.
2637          * See mem_cgroup_add_lru_list(), etc.
2638          */
2639         smp_wmb();
2640         SetPageCgroupUsed(pc);
2641
2642         if (lrucare) {
2643                 if (was_on_lru) {
2644                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2645                         VM_BUG_ON(PageLRU(page));
2646                         SetPageLRU(page);
2647                         add_page_to_lru_list(page, lruvec, page_lru(page));
2648                 }
2649                 spin_unlock_irq(&zone->lru_lock);
2650         }
2651
2652         if (ctype == MEM_CGROUP_CHARGE_TYPE_ANON)
2653                 anon = true;
2654         else
2655                 anon = false;
2656
2657         mem_cgroup_charge_statistics(memcg, anon, nr_pages);
2658         unlock_page_cgroup(pc);
2659
2660         /*
2661          * "charge_statistics" updated event counter. Then, check it.
2662          * Insert ancestor (and ancestor's ancestors), to softlimit RB-tree.
2663          * if they exceeds softlimit.
2664          */
2665         memcg_check_events(memcg, page);
2666 }
2667
2668 #ifdef CONFIG_MEMCG_KMEM
2669 static inline bool memcg_can_account_kmem(struct mem_cgroup *memcg)
2670 {
2671         return !mem_cgroup_disabled() && !mem_cgroup_is_root(memcg) &&
2672                 (memcg->kmem_account_flags & KMEM_ACCOUNTED_MASK);
2673 }
2674
2675 static int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp, u64 size)
2676 {
2677         struct res_counter *fail_res;
2678         struct mem_cgroup *_memcg;
2679         int ret = 0;
2680         bool may_oom;
2681
2682         ret = res_counter_charge(&memcg->kmem, size, &fail_res);
2683         if (ret)
2684                 return ret;
2685
2686         /*
2687          * Conditions under which we can wait for the oom_killer. Those are
2688          * the same conditions tested by the core page allocator
2689          */
2690         may_oom = (gfp & __GFP_FS) && !(gfp & __GFP_NORETRY);
2691
2692         _memcg = memcg;
2693         ret = __mem_cgroup_try_charge(NULL, gfp, size >> PAGE_SHIFT,
2694                                       &_memcg, may_oom);
2695
2696         if (ret == -EINTR)  {
2697                 /*
2698                  * __mem_cgroup_try_charge() chosed to bypass to root due to
2699                  * OOM kill or fatal signal.  Since our only options are to
2700                  * either fail the allocation or charge it to this cgroup, do
2701                  * it as a temporary condition. But we can't fail. From a
2702                  * kmem/slab perspective, the cache has already been selected,
2703                  * by mem_cgroup_kmem_get_cache(), so it is too late to change
2704                  * our minds.
2705                  *
2706                  * This condition will only trigger if the task entered
2707                  * memcg_charge_kmem in a sane state, but was OOM-killed during
2708                  * __mem_cgroup_try_charge() above. Tasks that were already
2709                  * dying when the allocation triggers should have been already
2710                  * directed to the root cgroup in memcontrol.h
2711                  */
2712                 res_counter_charge_nofail(&memcg->res, size, &fail_res);
2713                 if (do_swap_account)
2714                         res_counter_charge_nofail(&memcg->memsw, size,
2715                                                   &fail_res);
2716                 ret = 0;
2717         } else if (ret)
2718                 res_counter_uncharge(&memcg->kmem, size);
2719
2720         return ret;
2721 }
2722
2723 static void memcg_uncharge_kmem(struct mem_cgroup *memcg, u64 size)
2724 {
2725         res_counter_uncharge(&memcg->kmem, size);
2726         res_counter_uncharge(&memcg->res, size);
2727         if (do_swap_account)
2728                 res_counter_uncharge(&memcg->memsw, size);
2729 }
2730
2731 /*
2732  * We need to verify if the allocation against current->mm->owner's memcg is
2733  * possible for the given order. But the page is not allocated yet, so we'll
2734  * need a further commit step to do the final arrangements.
2735  *
2736  * It is possible for the task to switch cgroups in this mean time, so at
2737  * commit time, we can't rely on task conversion any longer.  We'll then use
2738  * the handle argument to return to the caller which cgroup we should commit
2739  * against. We could also return the memcg directly and avoid the pointer
2740  * passing, but a boolean return value gives better semantics considering
2741  * the compiled-out case as well.
2742  *
2743  * Returning true means the allocation is possible.
2744  */
2745 bool
2746 __memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **_memcg, int order)
2747 {
2748         struct mem_cgroup *memcg;
2749         int ret;
2750
2751         *_memcg = NULL;
2752         memcg = try_get_mem_cgroup_from_mm(current->mm);
2753
2754         /*
2755          * very rare case described in mem_cgroup_from_task. Unfortunately there
2756          * isn't much we can do without complicating this too much, and it would
2757          * be gfp-dependent anyway. Just let it go
2758          */
2759         if (unlikely(!memcg))
2760                 return true;
2761
2762         if (!memcg_can_account_kmem(memcg)) {
2763                 css_put(&memcg->css);
2764                 return true;
2765         }
2766
2767         mem_cgroup_get(memcg);
2768
2769         ret = memcg_charge_kmem(memcg, gfp, PAGE_SIZE << order);
2770         if (!ret)
2771                 *_memcg = memcg;
2772         else
2773                 mem_cgroup_put(memcg);
2774
2775         css_put(&memcg->css);
2776         return (ret == 0);
2777 }
2778
2779 void __memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg,
2780                               int order)
2781 {
2782         struct page_cgroup *pc;
2783
2784         VM_BUG_ON(mem_cgroup_is_root(memcg));
2785
2786         /* The page allocation failed. Revert */
2787         if (!page) {
2788                 memcg_uncharge_kmem(memcg, PAGE_SIZE << order);
2789                 mem_cgroup_put(memcg);
2790                 return;
2791         }
2792
2793         pc = lookup_page_cgroup(page);
2794         lock_page_cgroup(pc);
2795         pc->mem_cgroup = memcg;
2796         SetPageCgroupUsed(pc);
2797         unlock_page_cgroup(pc);
2798 }
2799
2800 void __memcg_kmem_uncharge_pages(struct page *page, int order)
2801 {
2802         struct mem_cgroup *memcg = NULL;
2803         struct page_cgroup *pc;
2804
2805
2806         pc = lookup_page_cgroup(page);
2807         /*
2808          * Fast unlocked return. Theoretically might have changed, have to
2809          * check again after locking.
2810          */
2811         if (!PageCgroupUsed(pc))
2812                 return;
2813
2814         lock_page_cgroup(pc);
2815         if (PageCgroupUsed(pc)) {
2816                 memcg = pc->mem_cgroup;
2817                 ClearPageCgroupUsed(pc);
2818         }
2819         unlock_page_cgroup(pc);
2820
2821         /*
2822          * We trust that only if there is a memcg associated with the page, it
2823          * is a valid allocation
2824          */
2825         if (!memcg)
2826                 return;
2827
2828         VM_BUG_ON(mem_cgroup_is_root(memcg));
2829         memcg_uncharge_kmem(memcg, PAGE_SIZE << order);
2830         mem_cgroup_put(memcg);
2831 }
2832 #endif /* CONFIG_MEMCG_KMEM */
2833
2834 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
2835
2836 #define PCGF_NOCOPY_AT_SPLIT (1 << PCG_LOCK | 1 << PCG_MIGRATION)
2837 /*
2838  * Because tail pages are not marked as "used", set it. We're under
2839  * zone->lru_lock, 'splitting on pmd' and compound_lock.
2840  * charge/uncharge will be never happen and move_account() is done under
2841  * compound_lock(), so we don't have to take care of races.
2842  */
2843 void mem_cgroup_split_huge_fixup(struct page *head)
2844 {
2845         struct page_cgroup *head_pc = lookup_page_cgroup(head);
2846         struct page_cgroup *pc;
2847         int i;
2848
2849         if (mem_cgroup_disabled())
2850                 return;
2851         for (i = 1; i < HPAGE_PMD_NR; i++) {
2852                 pc = head_pc + i;
2853                 pc->mem_cgroup = head_pc->mem_cgroup;
2854                 smp_wmb();/* see __commit_charge() */
2855                 pc->flags = head_pc->flags & ~PCGF_NOCOPY_AT_SPLIT;
2856         }
2857 }
2858 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
2859
2860 /**
2861  * mem_cgroup_move_account - move account of the page
2862  * @page: the page
2863  * @nr_pages: number of regular pages (>1 for huge pages)
2864  * @pc: page_cgroup of the page.
2865  * @from: mem_cgroup which the page is moved from.
2866  * @to: mem_cgroup which the page is moved to. @from != @to.
2867  *
2868  * The caller must confirm following.
2869  * - page is not on LRU (isolate_page() is useful.)
2870  * - compound_lock is held when nr_pages > 1
2871  *
2872  * This function doesn't do "charge" to new cgroup and doesn't do "uncharge"
2873  * from old cgroup.
2874  */
2875 static int mem_cgroup_move_account(struct page *page,
2876                                    unsigned int nr_pages,
2877                                    struct page_cgroup *pc,
2878                                    struct mem_cgroup *from,
2879                                    struct mem_cgroup *to)
2880 {
2881         unsigned long flags;
2882         int ret;
2883         bool anon = PageAnon(page);
2884
2885         VM_BUG_ON(from == to);
2886         VM_BUG_ON(PageLRU(page));
2887         /*
2888          * The page is isolated from LRU. So, collapse function
2889          * will not handle this page. But page splitting can happen.
2890          * Do this check under compound_page_lock(). The caller should
2891          * hold it.
2892          */
2893         ret = -EBUSY;
2894         if (nr_pages > 1 && !PageTransHuge(page))
2895                 goto out;
2896
2897         lock_page_cgroup(pc);
2898
2899         ret = -EINVAL;
2900         if (!PageCgroupUsed(pc) || pc->mem_cgroup != from)
2901                 goto unlock;
2902
2903         move_lock_mem_cgroup(from, &flags);
2904
2905         if (!anon && page_mapped(page)) {
2906                 /* Update mapped_file data for mem_cgroup */
2907                 preempt_disable();
2908                 __this_cpu_dec(from->stat->count[MEM_CGROUP_STAT_FILE_MAPPED]);
2909                 __this_cpu_inc(to->stat->count[MEM_CGROUP_STAT_FILE_MAPPED]);
2910                 preempt_enable();
2911         }
2912         mem_cgroup_charge_statistics(from, anon, -nr_pages);
2913
2914         /* caller should have done css_get */
2915         pc->mem_cgroup = to;
2916         mem_cgroup_charge_statistics(to, anon, nr_pages);
2917         move_unlock_mem_cgroup(from, &flags);
2918         ret = 0;
2919 unlock:
2920         unlock_page_cgroup(pc);
2921         /*
2922          * check events
2923          */
2924         memcg_check_events(to, page);
2925         memcg_check_events(from, page);
2926 out:
2927         return ret;
2928 }
2929
2930 /**
2931  * mem_cgroup_move_parent - moves page to the parent group
2932  * @page: the page to move
2933  * @pc: page_cgroup of the page
2934  * @child: page's cgroup
2935  *
2936  * move charges to its parent or the root cgroup if the group has no
2937  * parent (aka use_hierarchy==0).
2938  * Although this might fail (get_page_unless_zero, isolate_lru_page or
2939  * mem_cgroup_move_account fails) the failure is always temporary and
2940  * it signals a race with a page removal/uncharge or migration. In the
2941  * first case the page is on the way out and it will vanish from the LRU
2942  * on the next attempt and the call should be retried later.
2943  * Isolation from the LRU fails only if page has been isolated from
2944  * the LRU since we looked at it and that usually means either global
2945  * reclaim or migration going on. The page will either get back to the
2946  * LRU or vanish.
2947  * Finaly mem_cgroup_move_account fails only if the page got uncharged
2948  * (!PageCgroupUsed) or moved to a different group. The page will
2949  * disappear in the next attempt.
2950  */
2951 static int mem_cgroup_move_parent(struct page *page,
2952                                   struct page_cgroup *pc,
2953                                   struct mem_cgroup *child)
2954 {
2955         struct mem_cgroup *parent;
2956         unsigned int nr_pages;
2957         unsigned long uninitialized_var(flags);
2958         int ret;
2959
2960         VM_BUG_ON(mem_cgroup_is_root(child));
2961
2962         ret = -EBUSY;
2963         if (!get_page_unless_zero(page))
2964                 goto out;
2965         if (isolate_lru_page(page))
2966                 goto put;
2967
2968         nr_pages = hpage_nr_pages(page);
2969
2970         parent = parent_mem_cgroup(child);
2971         /*
2972          * If no parent, move charges to root cgroup.
2973          */
2974         if (!parent)
2975                 parent = root_mem_cgroup;
2976
2977         if (nr_pages > 1) {
2978                 VM_BUG_ON(!PageTransHuge(page));
2979                 flags = compound_lock_irqsave(page);
2980         }
2981
2982         ret = mem_cgroup_move_account(page, nr_pages,
2983                                 pc, child, parent);
2984         if (!ret)
2985                 __mem_cgroup_cancel_local_charge(child, nr_pages);
2986
2987         if (nr_pages > 1)
2988                 compound_unlock_irqrestore(page, flags);
2989         putback_lru_page(page);
2990 put:
2991         put_page(page);
2992 out:
2993         return ret;
2994 }
2995
2996 /*
2997  * Charge the memory controller for page usage.
2998  * Return
2999  * 0 if the charge was successful
3000  * < 0 if the cgroup is over its limit
3001  */
3002 static int mem_cgroup_charge_common(struct page *page, struct mm_struct *mm,
3003                                 gfp_t gfp_mask, enum charge_type ctype)
3004 {
3005         struct mem_cgroup *memcg = NULL;
3006         unsigned int nr_pages = 1;
3007         bool oom = true;
3008         int ret;
3009
3010         if (PageTransHuge(page)) {
3011                 nr_pages <<= compound_order(page);
3012                 VM_BUG_ON(!PageTransHuge(page));
3013                 /*
3014                  * Never OOM-kill a process for a huge page.  The
3015                  * fault handler will fall back to regular pages.
3016                  */
3017                 oom = false;
3018         }
3019
3020         ret = __mem_cgroup_try_charge(mm, gfp_mask, nr_pages, &memcg, oom);
3021         if (ret == -ENOMEM)
3022                 return ret;
3023         __mem_cgroup_commit_charge(memcg, page, nr_pages, ctype, false);
3024         return 0;
3025 }
3026
3027 int mem_cgroup_newpage_charge(struct page *page,
3028                               struct mm_struct *mm, gfp_t gfp_mask)
3029 {
3030         if (mem_cgroup_disabled())
3031                 return 0;
3032         VM_BUG_ON(page_mapped(page));
3033         VM_BUG_ON(page->mapping && !PageAnon(page));
3034         VM_BUG_ON(!mm);
3035         return mem_cgroup_charge_common(page, mm, gfp_mask,
3036                                         MEM_CGROUP_CHARGE_TYPE_ANON);
3037 }
3038
3039 /*
3040  * While swap-in, try_charge -> commit or cancel, the page is locked.
3041  * And when try_charge() successfully returns, one refcnt to memcg without
3042  * struct page_cgroup is acquired. This refcnt will be consumed by
3043  * "commit()" or removed by "cancel()"
3044  */
3045 static int __mem_cgroup_try_charge_swapin(struct mm_struct *mm,
3046                                           struct page *page,
3047                                           gfp_t mask,
3048                                           struct mem_cgroup **memcgp)
3049 {
3050         struct mem_cgroup *memcg;
3051         struct page_cgroup *pc;
3052         int ret;
3053
3054         pc = lookup_page_cgroup(page);
3055         /*
3056          * Every swap fault against a single page tries to charge the
3057          * page, bail as early as possible.  shmem_unuse() encounters
3058          * already charged pages, too.  The USED bit is protected by
3059          * the page lock, which serializes swap cache removal, which
3060          * in turn serializes uncharging.
3061          */
3062         if (PageCgroupUsed(pc))
3063                 return 0;
3064         if (!do_swap_account)
3065                 goto charge_cur_mm;
3066         memcg = try_get_mem_cgroup_from_page(page);
3067         if (!memcg)
3068                 goto charge_cur_mm;
3069         *memcgp = memcg;
3070         ret = __mem_cgroup_try_charge(NULL, mask, 1, memcgp, true);
3071         css_put(&memcg->css);
3072         if (ret == -EINTR)
3073                 ret = 0;
3074         return ret;
3075 charge_cur_mm:
3076         ret = __mem_cgroup_try_charge(mm, mask, 1, memcgp, true);
3077         if (ret == -EINTR)
3078                 ret = 0;
3079         return ret;
3080 }
3081
3082 int mem_cgroup_try_charge_swapin(struct mm_struct *mm, struct page *page,
3083                                  gfp_t gfp_mask, struct mem_cgroup **memcgp)
3084 {
3085         *memcgp = NULL;
3086         if (mem_cgroup_disabled())
3087                 return 0;
3088         /*
3089          * A racing thread's fault, or swapoff, may have already
3090          * updated the pte, and even removed page from swap cache: in
3091          * those cases unuse_pte()'s pte_same() test will fail; but
3092          * there's also a KSM case which does need to charge the page.
3093          */
3094         if (!PageSwapCache(page)) {
3095                 int ret;
3096
3097                 ret = __mem_cgroup_try_charge(mm, gfp_mask, 1, memcgp, true);
3098                 if (ret == -EINTR)
3099                         ret = 0;
3100                 return ret;
3101         }
3102         return __mem_cgroup_try_charge_swapin(mm, page, gfp_mask, memcgp);
3103 }
3104
3105 void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg)
3106 {
3107         if (mem_cgroup_disabled())
3108                 return;
3109         if (!memcg)
3110                 return;
3111         __mem_cgroup_cancel_charge(memcg, 1);
3112 }
3113
3114 static void
3115 __mem_cgroup_commit_charge_swapin(struct page *page, struct mem_cgroup *memcg,
3116                                         enum charge_type ctype)
3117 {
3118         if (mem_cgroup_disabled())
3119                 return;
3120         if (!memcg)
3121                 return;
3122
3123         __mem_cgroup_commit_charge(memcg, page, 1, ctype, true);
3124         /*
3125          * Now swap is on-memory. This means this page may be
3126          * counted both as mem and swap....double count.
3127          * Fix it by uncharging from memsw. Basically, this SwapCache is stable
3128          * under lock_page(). But in do_swap_page()::memory.c, reuse_swap_page()
3129          * may call delete_from_swap_cache() before reach here.
3130          */
3131         if (do_swap_account && PageSwapCache(page)) {
3132                 swp_entry_t ent = {.val = page_private(page)};
3133                 mem_cgroup_uncharge_swap(ent);
3134         }
3135 }
3136
3137 void mem_cgroup_commit_charge_swapin(struct page *page,
3138                                      struct mem_cgroup *memcg)
3139 {
3140         __mem_cgroup_commit_charge_swapin(page, memcg,
3141                                           MEM_CGROUP_CHARGE_TYPE_ANON);
3142 }
3143
3144 int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm,
3145                                 gfp_t gfp_mask)
3146 {
3147         struct mem_cgroup *memcg = NULL;
3148         enum charge_type type = MEM_CGROUP_CHARGE_TYPE_CACHE;
3149         int ret;
3150
3151         if (mem_cgroup_disabled())
3152                 return 0;
3153         if (PageCompound(page))
3154                 return 0;
3155
3156         if (!PageSwapCache(page))
3157                 ret = mem_cgroup_charge_common(page, mm, gfp_mask, type);
3158         else { /* page is swapcache/shmem */
3159                 ret = __mem_cgroup_try_charge_swapin(mm, page,
3160                                                      gfp_mask, &memcg);
3161                 if (!ret)
3162                         __mem_cgroup_commit_charge_swapin(page, memcg, type);
3163         }
3164         return ret;
3165 }
3166
3167 static void mem_cgroup_do_uncharge(struct mem_cgroup *memcg,
3168                                    unsigned int nr_pages,
3169                                    const enum charge_type ctype)
3170 {
3171         struct memcg_batch_info *batch = NULL;
3172         bool uncharge_memsw = true;
3173
3174         /* If swapout, usage of swap doesn't decrease */
3175         if (!do_swap_account || ctype == MEM_CGROUP_CHARGE_TYPE_SWAPOUT)
3176                 uncharge_memsw = false;
3177
3178         batch = &current->memcg_batch;
3179         /*
3180          * In usual, we do css_get() when we remember memcg pointer.
3181          * But in this case, we keep res->usage until end of a series of
3182          * uncharges. Then, it's ok to ignore memcg's refcnt.
3183          */
3184         if (!batch->memcg)
3185                 batch->memcg = memcg;
3186         /*
3187          * do_batch > 0 when unmapping pages or inode invalidate/truncate.
3188          * In those cases, all pages freed continuously can be expected to be in
3189          * the same cgroup and we have chance to coalesce uncharges.
3190          * But we do uncharge one by one if this is killed by OOM(TIF_MEMDIE)
3191          * because we want to do uncharge as soon as possible.
3192          */
3193
3194         if (!batch->do_batch || test_thread_flag(TIF_MEMDIE))
3195                 goto direct_uncharge;
3196
3197         if (nr_pages > 1)
3198                 goto direct_uncharge;
3199
3200         /*
3201          * In typical case, batch->memcg == mem. This means we can
3202          * merge a series of uncharges to an uncharge of res_counter.
3203          * If not, we uncharge res_counter ony by one.
3204          */
3205         if (batch->memcg != memcg)
3206                 goto direct_uncharge;
3207         /* remember freed charge and uncharge it later */
3208         batch->nr_pages++;
3209         if (uncharge_memsw)
3210                 batch->memsw_nr_pages++;
3211         return;
3212 direct_uncharge:
3213         res_counter_uncharge(&memcg->res, nr_pages * PAGE_SIZE);
3214         if (uncharge_memsw)
3215                 res_counter_uncharge(&memcg->memsw, nr_pages * PAGE_SIZE);
3216         if (unlikely(batch->memcg != memcg))
3217                 memcg_oom_recover(memcg);
3218 }
3219
3220 /*
3221  * uncharge if !page_mapped(page)
3222  */
3223 static struct mem_cgroup *
3224 __mem_cgroup_uncharge_common(struct page *page, enum charge_type ctype,
3225                              bool end_migration)
3226 {
3227         struct mem_cgroup *memcg = NULL;
3228         unsigned int nr_pages = 1;
3229         struct page_cgroup *pc;
3230         bool anon;
3231
3232         if (mem_cgroup_disabled())
3233                 return NULL;
3234
3235         VM_BUG_ON(PageSwapCache(page));
3236
3237         if (PageTransHuge(page)) {
3238                 nr_pages <<= compound_order(page);
3239                 VM_BUG_ON(!PageTransHuge(page));
3240         }
3241         /*
3242          * Check if our page_cgroup is valid
3243          */
3244         pc = lookup_page_cgroup(page);
3245         if (unlikely(!PageCgroupUsed(pc)))
3246                 return NULL;
3247
3248         lock_page_cgroup(pc);
3249
3250         memcg = pc->mem_cgroup;
3251
3252         if (!PageCgroupUsed(pc))
3253                 goto unlock_out;
3254
3255         anon = PageAnon(page);
3256
3257         switch (ctype) {
3258         case MEM_CGROUP_CHARGE_TYPE_ANON:
3259                 /*
3260                  * Generally PageAnon tells if it's the anon statistics to be
3261                  * updated; but sometimes e.g. mem_cgroup_uncharge_page() is
3262                  * used before page reached the stage of being marked PageAnon.
3263                  */
3264                 anon = true;
3265                 /* fallthrough */
3266         case MEM_CGROUP_CHARGE_TYPE_DROP:
3267                 /* See mem_cgroup_prepare_migration() */
3268                 if (page_mapped(page))
3269                         goto unlock_out;
3270                 /*
3271                  * Pages under migration may not be uncharged.  But
3272                  * end_migration() /must/ be the one uncharging the
3273                  * unused post-migration page and so it has to call
3274                  * here with the migration bit still set.  See the
3275                  * res_counter handling below.
3276                  */
3277                 if (!end_migration && PageCgroupMigration(pc))
3278                         goto unlock_out;
3279                 break;
3280         case MEM_CGROUP_CHARGE_TYPE_SWAPOUT:
3281                 if (!PageAnon(page)) {  /* Shared memory */
3282                         if (page->mapping && !page_is_file_cache(page))
3283                                 goto unlock_out;
3284                 } else if (page_mapped(page)) /* Anon */
3285                                 goto unlock_out;
3286                 break;
3287         default:
3288                 break;
3289         }
3290
3291         mem_cgroup_charge_statistics(memcg, anon, -nr_pages);
3292
3293         ClearPageCgroupUsed(pc);
3294         /*
3295          * pc->mem_cgroup is not cleared here. It will be accessed when it's
3296          * freed from LRU. This is safe because uncharged page is expected not
3297          * to be reused (freed soon). Exception is SwapCache, it's handled by
3298          * special functions.
3299          */
3300
3301         unlock_page_cgroup(pc);
3302         /*
3303          * even after unlock, we have memcg->res.usage here and this memcg
3304          * will never be freed.
3305          */
3306         memcg_check_events(memcg, page);
3307         if (do_swap_account && ctype == MEM_CGROUP_CHARGE_TYPE_SWAPOUT) {
3308                 mem_cgroup_swap_statistics(memcg, true);
3309                 mem_cgroup_get(memcg);
3310         }
3311         /*
3312          * Migration does not charge the res_counter for the
3313          * replacement page, so leave it alone when phasing out the
3314          * page that is unused after the migration.
3315          */
3316         if (!end_migration && !mem_cgroup_is_root(memcg))
3317                 mem_cgroup_do_uncharge(memcg, nr_pages, ctype);
3318
3319         return memcg;
3320
3321 unlock_out:
3322         unlock_page_cgroup(pc);
3323         return NULL;
3324 }
3325
3326 void mem_cgroup_uncharge_page(struct page *page)
3327 {
3328         /* early check. */
3329         if (page_mapped(page))
3330                 return;
3331         VM_BUG_ON(page->mapping && !PageAnon(page));
3332         if (PageSwapCache(page))
3333                 return;
3334         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_ANON, false);
3335 }
3336
3337 void mem_cgroup_uncharge_cache_page(struct page *page)
3338 {
3339         VM_BUG_ON(page_mapped(page));
3340         VM_BUG_ON(page->mapping);
3341         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_CACHE, false);
3342 }
3343
3344 /*
3345  * Batch_start/batch_end is called in unmap_page_range/invlidate/trucate.
3346  * In that cases, pages are freed continuously and we can expect pages
3347  * are in the same memcg. All these calls itself limits the number of
3348  * pages freed at once, then uncharge_start/end() is called properly.
3349  * This may be called prural(2) times in a context,
3350  */
3351
3352 void mem_cgroup_uncharge_start(void)
3353 {
3354         current->memcg_batch.do_batch++;
3355         /* We can do nest. */
3356         if (current->memcg_batch.do_batch == 1) {
3357                 current->memcg_batch.memcg = NULL;
3358                 current->memcg_batch.nr_pages = 0;
3359                 current->memcg_batch.memsw_nr_pages = 0;
3360         }
3361 }
3362
3363 void mem_cgroup_uncharge_end(void)
3364 {
3365         struct memcg_batch_info *batch = &current->memcg_batch;
3366
3367         if (!batch->do_batch)
3368                 return;
3369
3370         batch->do_batch--;
3371         if (batch->do_batch) /* If stacked, do nothing. */
3372                 return;
3373
3374         if (!batch->memcg)
3375                 return;
3376         /*
3377          * This "batch->memcg" is valid without any css_get/put etc...
3378          * bacause we hide charges behind us.
3379          */
3380         if (batch->nr_pages)
3381                 res_counter_uncharge(&batch->memcg->res,
3382                                      batch->nr_pages * PAGE_SIZE);
3383         if (batch->memsw_nr_pages)
3384                 res_counter_uncharge(&batch->memcg->memsw,
3385                                      batch->memsw_nr_pages * PAGE_SIZE);
3386         memcg_oom_recover(batch->memcg);
3387         /* forget this pointer (for sanity check) */
3388         batch->memcg = NULL;
3389 }
3390
3391 #ifdef CONFIG_SWAP
3392 /*
3393  * called after __delete_from_swap_cache() and drop "page" account.
3394  * memcg information is recorded to swap_cgroup of "ent"
3395  */
3396 void
3397 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
3398 {
3399         struct mem_cgroup *memcg;
3400         int ctype = MEM_CGROUP_CHARGE_TYPE_SWAPOUT;
3401
3402         if (!swapout) /* this was a swap cache but the swap is unused ! */
3403                 ctype = MEM_CGROUP_CHARGE_TYPE_DROP;
3404
3405         memcg = __mem_cgroup_uncharge_common(page, ctype, false);
3406
3407         /*
3408          * record memcg information,  if swapout && memcg != NULL,
3409          * mem_cgroup_get() was called in uncharge().
3410          */
3411         if (do_swap_account && swapout && memcg)
3412                 swap_cgroup_record(ent, css_id(&memcg->css));
3413 }
3414 #endif
3415
3416 #ifdef CONFIG_MEMCG_SWAP
3417 /*
3418  * called from swap_entry_free(). remove record in swap_cgroup and
3419  * uncharge "memsw" account.
3420  */
3421 void mem_cgroup_uncharge_swap(swp_entry_t ent)
3422 {
3423         struct mem_cgroup *memcg;
3424         unsigned short id;
3425
3426         if (!do_swap_account)
3427                 return;
3428
3429         id = swap_cgroup_record(ent, 0);
3430         rcu_read_lock();
3431         memcg = mem_cgroup_lookup(id);
3432         if (memcg) {
3433                 /*
3434                  * We uncharge this because swap is freed.
3435                  * This memcg can be obsolete one. We avoid calling css_tryget
3436                  */
3437                 if (!mem_cgroup_is_root(memcg))
3438                         res_counter_uncharge(&memcg->memsw, PAGE_SIZE);
3439                 mem_cgroup_swap_statistics(memcg, false);
3440                 mem_cgroup_put(memcg);
3441         }
3442         rcu_read_unlock();
3443 }
3444
3445 /**
3446  * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
3447  * @entry: swap entry to be moved
3448  * @from:  mem_cgroup which the entry is moved from
3449  * @to:  mem_cgroup which the entry is moved to
3450  *
3451  * It succeeds only when the swap_cgroup's record for this entry is the same
3452  * as the mem_cgroup's id of @from.
3453  *
3454  * Returns 0 on success, -EINVAL on failure.
3455  *
3456  * The caller must have charged to @to, IOW, called res_counter_charge() about
3457  * both res and memsw, and called css_get().
3458  */
3459 static int mem_cgroup_move_swap_account(swp_entry_t entry,
3460                                 struct mem_cgroup *from, struct mem_cgroup *to)
3461 {
3462         unsigned short old_id, new_id;
3463
3464         old_id = css_id(&from->css);
3465         new_id = css_id(&to->css);
3466
3467         if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
3468                 mem_cgroup_swap_statistics(from, false);
3469                 mem_cgroup_swap_statistics(to, true);
3470                 /*
3471                  * This function is only called from task migration context now.
3472                  * It postpones res_counter and refcount handling till the end
3473                  * of task migration(mem_cgroup_clear_mc()) for performance
3474                  * improvement. But we cannot postpone mem_cgroup_get(to)
3475                  * because if the process that has been moved to @to does
3476                  * swap-in, the refcount of @to might be decreased to 0.
3477                  */
3478                 mem_cgroup_get(to);
3479                 return 0;
3480         }
3481         return -EINVAL;
3482 }
3483 #else
3484 static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
3485                                 struct mem_cgroup *from, struct mem_cgroup *to)
3486 {
3487         return -EINVAL;
3488 }
3489 #endif
3490
3491 /*
3492  * Before starting migration, account PAGE_SIZE to mem_cgroup that the old
3493  * page belongs to.
3494  */
3495 void mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
3496                                   struct mem_cgroup **memcgp)
3497 {
3498         struct mem_cgroup *memcg = NULL;
3499         unsigned int nr_pages = 1;
3500         struct page_cgroup *pc;
3501         enum charge_type ctype;
3502
3503         *memcgp = NULL;
3504
3505         if (mem_cgroup_disabled())
3506                 return;
3507
3508         if (PageTransHuge(page))
3509                 nr_pages <<= compound_order(page);
3510
3511         pc = lookup_page_cgroup(page);
3512         lock_page_cgroup(pc);
3513         if (PageCgroupUsed(pc)) {
3514                 memcg = pc->mem_cgroup;
3515                 css_get(&memcg->css);
3516                 /*
3517                  * At migrating an anonymous page, its mapcount goes down
3518                  * to 0 and uncharge() will be called. But, even if it's fully
3519                  * unmapped, migration may fail and this page has to be
3520                  * charged again. We set MIGRATION flag here and delay uncharge
3521                  * until end_migration() is called
3522                  *
3523                  * Corner Case Thinking
3524                  * A)
3525                  * When the old page was mapped as Anon and it's unmap-and-freed
3526                  * while migration was ongoing.
3527                  * If unmap finds the old page, uncharge() of it will be delayed
3528                  * until end_migration(). If unmap finds a new page, it's
3529                  * uncharged when it make mapcount to be 1->0. If unmap code
3530                  * finds swap_migration_entry, the new page will not be mapped
3531                  * and end_migration() will find it(mapcount==0).
3532                  *
3533                  * B)
3534                  * When the old page was mapped but migraion fails, the kernel
3535                  * remaps it. A charge for it is kept by MIGRATION flag even
3536                  * if mapcount goes down to 0. We can do remap successfully
3537                  * without charging it again.
3538                  *
3539                  * C)
3540                  * The "old" page is under lock_page() until the end of
3541                  * migration, so, the old page itself will not be swapped-out.
3542                  * If the new page is swapped out before end_migraton, our
3543                  * hook to usual swap-out path will catch the event.
3544                  */
3545                 if (PageAnon(page))
3546                         SetPageCgroupMigration(pc);
3547         }
3548         unlock_page_cgroup(pc);
3549         /*
3550          * If the page is not charged at this point,
3551          * we return here.
3552          */
3553         if (!memcg)
3554                 return;
3555
3556         *memcgp = memcg;
3557         /*
3558          * We charge new page before it's used/mapped. So, even if unlock_page()
3559          * is called before end_migration, we can catch all events on this new
3560          * page. In the case new page is migrated but not remapped, new page's
3561          * mapcount will be finally 0 and we call uncharge in end_migration().
3562          */
3563         if (PageAnon(page))
3564                 ctype = MEM_CGROUP_CHARGE_TYPE_ANON;
3565         else
3566                 ctype = MEM_CGROUP_CHARGE_TYPE_CACHE;
3567         /*
3568          * The page is committed to the memcg, but it's not actually
3569          * charged to the res_counter since we plan on replacing the
3570          * old one and only one page is going to be left afterwards.
3571          */
3572         __mem_cgroup_commit_charge(memcg, newpage, nr_pages, ctype, false);
3573 }
3574
3575 /* remove redundant charge if migration failed*/
3576 void mem_cgroup_end_migration(struct mem_cgroup *memcg,
3577         struct page *oldpage, struct page *newpage, bool migration_ok)
3578 {
3579         struct page *used, *unused;
3580         struct page_cgroup *pc;
3581         bool anon;
3582
3583         if (!memcg)
3584                 return;
3585
3586         if (!migration_ok) {
3587                 used = oldpage;
3588                 unused = newpage;
3589         } else {
3590                 used = newpage;
3591                 unused = oldpage;
3592         }
3593         anon = PageAnon(used);
3594         __mem_cgroup_uncharge_common(unused,
3595                                      anon ? MEM_CGROUP_CHARGE_TYPE_ANON
3596                                      : MEM_CGROUP_CHARGE_TYPE_CACHE,
3597                                      true);
3598         css_put(&memcg->css);
3599         /*
3600          * We disallowed uncharge of pages under migration because mapcount
3601          * of the page goes down to zero, temporarly.
3602          * Clear the flag and check the page should be charged.
3603          */
3604         pc = lookup_page_cgroup(oldpage);
3605         lock_page_cgroup(pc);
3606         ClearPageCgroupMigration(pc);
3607         unlock_page_cgroup(pc);
3608
3609         /*
3610          * If a page is a file cache, radix-tree replacement is very atomic
3611          * and we can skip this check. When it was an Anon page, its mapcount
3612          * goes down to 0. But because we added MIGRATION flage, it's not
3613          * uncharged yet. There are several case but page->mapcount check
3614          * and USED bit check in mem_cgroup_uncharge_page() will do enough
3615          * check. (see prepare_charge() also)
3616          */
3617         if (anon)
3618                 mem_cgroup_uncharge_page(used);
3619 }
3620
3621 /*
3622  * At replace page cache, newpage is not under any memcg but it's on
3623  * LRU. So, this function doesn't touch res_counter but handles LRU
3624  * in correct way. Both pages are locked so we cannot race with uncharge.
3625  */
3626 void mem_cgroup_replace_page_cache(struct page *oldpage,
3627                                   struct page *newpage)
3628 {
3629         struct mem_cgroup *memcg = NULL;
3630         struct page_cgroup *pc;
3631         enum charge_type type = MEM_CGROUP_CHARGE_TYPE_CACHE;
3632
3633         if (mem_cgroup_disabled())
3634                 return;
3635
3636         pc = lookup_page_cgroup(oldpage);
3637         /* fix accounting on old pages */
3638         lock_page_cgroup(pc);
3639         if (PageCgroupUsed(pc)) {
3640                 memcg = pc->mem_cgroup;
3641                 mem_cgroup_charge_statistics(memcg, false, -1);
3642                 ClearPageCgroupUsed(pc);
3643         }
3644         unlock_page_cgroup(pc);
3645
3646         /*
3647          * When called from shmem_replace_page(), in some cases the
3648          * oldpage has already been charged, and in some cases not.
3649          */
3650         if (!memcg)
3651                 return;
3652         /*
3653          * Even if newpage->mapping was NULL before starting replacement,
3654          * the newpage may be on LRU(or pagevec for LRU) already. We lock
3655          * LRU while we overwrite pc->mem_cgroup.
3656          */
3657         __mem_cgroup_commit_charge(memcg, newpage, 1, type, true);
3658 }
3659
3660 #ifdef CONFIG_DEBUG_VM
3661 static struct page_cgroup *lookup_page_cgroup_used(struct page *page)
3662 {
3663         struct page_cgroup *pc;
3664
3665         pc = lookup_page_cgroup(page);
3666         /*
3667          * Can be NULL while feeding pages into the page allocator for
3668          * the first time, i.e. during boot or memory hotplug;
3669          * or when mem_cgroup_disabled().
3670          */
3671         if (likely(pc) && PageCgroupUsed(pc))
3672                 return pc;
3673         return NULL;
3674 }
3675
3676 bool mem_cgroup_bad_page_check(struct page *page)
3677 {
3678         if (mem_cgroup_disabled())
3679                 return false;
3680
3681         return lookup_page_cgroup_used(page) != NULL;
3682 }
3683
3684 void mem_cgroup_print_bad_page(struct page *page)
3685 {
3686         struct page_cgroup *pc;
3687
3688         pc = lookup_page_cgroup_used(page);
3689         if (pc) {
3690                 printk(KERN_ALERT "pc:%p pc->flags:%lx pc->mem_cgroup:%p\n",
3691                        pc, pc->flags, pc->mem_cgroup);
3692         }
3693 }
3694 #endif
3695
3696 static DEFINE_MUTEX(set_limit_mutex);
3697
3698 static int mem_cgroup_resize_limit(struct mem_cgroup *memcg,
3699                                 unsigned long long val)
3700 {
3701         int retry_count;
3702         u64 memswlimit, memlimit;
3703         int ret = 0;
3704         int children = mem_cgroup_count_children(memcg);
3705         u64 curusage, oldusage;
3706         int enlarge;
3707
3708         /*
3709          * For keeping hierarchical_reclaim simple, how long we should retry
3710          * is depends on callers. We set our retry-count to be function
3711          * of # of children which we should visit in this loop.
3712          */
3713         retry_count = MEM_CGROUP_RECLAIM_RETRIES * children;
3714
3715         oldusage = res_counter_read_u64(&memcg->res, RES_USAGE);
3716
3717         enlarge = 0;
3718         while (retry_count) {
3719                 if (signal_pending(current)) {
3720                         ret = -EINTR;
3721                         break;
3722                 }
3723                 /*
3724                  * Rather than hide all in some function, I do this in
3725                  * open coded manner. You see what this really does.
3726                  * We have to guarantee memcg->res.limit <= memcg->memsw.limit.
3727                  */
3728                 mutex_lock(&set_limit_mutex);
3729                 memswlimit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
3730                 if (memswlimit < val) {
3731                         ret = -EINVAL;
3732                         mutex_unlock(&set_limit_mutex);
3733                         break;
3734                 }
3735
3736                 memlimit = res_counter_read_u64(&memcg->res, RES_LIMIT);
3737                 if (memlimit < val)
3738                         enlarge = 1;
3739
3740                 ret = res_counter_set_limit(&memcg->res, val);
3741                 if (!ret) {
3742                         if (memswlimit == val)
3743                                 memcg->memsw_is_minimum = true;
3744                         else
3745                                 memcg->memsw_is_minimum = false;
3746                 }
3747                 mutex_unlock(&set_limit_mutex);
3748
3749                 if (!ret)
3750                         break;
3751
3752                 mem_cgroup_reclaim(memcg, GFP_KERNEL,
3753                                    MEM_CGROUP_RECLAIM_SHRINK);
3754                 curusage = res_counter_read_u64(&memcg->res, RES_USAGE);
3755                 /* Usage is reduced ? */
3756                 if (curusage >= oldusage)
3757                         retry_count--;
3758                 else
3759                         oldusage = curusage;
3760         }
3761         if (!ret && enlarge)
3762                 memcg_oom_recover(memcg);
3763
3764         return ret;
3765 }
3766
3767 static int mem_cgroup_resize_memsw_limit(struct mem_cgroup *memcg,
3768                                         unsigned long long val)
3769 {
3770         int retry_count;
3771         u64 memlimit, memswlimit, oldusage, curusage;
3772         int children = mem_cgroup_count_children(memcg);
3773         int ret = -EBUSY;
3774         int enlarge = 0;
3775
3776         /* see mem_cgroup_resize_res_limit */
3777         retry_count = children * MEM_CGROUP_RECLAIM_RETRIES;
3778         oldusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
3779         while (retry_count) {
3780                 if (signal_pending(current)) {
3781                         ret = -EINTR;
3782                         break;
3783                 }
3784                 /*
3785                  * Rather than hide all in some function, I do this in
3786                  * open coded manner. You see what this really does.
3787                  * We have to guarantee memcg->res.limit <= memcg->memsw.limit.
3788                  */
3789                 mutex_lock(&set_limit_mutex);
3790                 memlimit = res_counter_read_u64(&memcg->res, RES_LIMIT);
3791                 if (memlimit > val) {
3792                         ret = -EINVAL;
3793                         mutex_unlock(&set_limit_mutex);
3794                         break;
3795                 }
3796                 memswlimit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
3797                 if (memswlimit < val)
3798                         enlarge = 1;
3799                 ret = res_counter_set_limit(&memcg->memsw, val);
3800                 if (!ret) {
3801                         if (memlimit == val)
3802                                 memcg->memsw_is_minimum = true;
3803                         else
3804                                 memcg->memsw_is_minimum = false;
3805                 }
3806                 mutex_unlock(&set_limit_mutex);
3807
3808                 if (!ret)
3809                         break;
3810
3811                 mem_cgroup_reclaim(memcg, GFP_KERNEL,
3812                                    MEM_CGROUP_RECLAIM_NOSWAP |
3813                                    MEM_CGROUP_RECLAIM_SHRINK);
3814                 curusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
3815                 /* Usage is reduced ? */
3816                 if (curusage >= oldusage)
3817                         retry_count--;
3818                 else
3819                         oldusage = curusage;
3820         }
3821         if (!ret && enlarge)
3822                 memcg_oom_recover(memcg);
3823         return ret;
3824 }
3825
3826 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
3827                                             gfp_t gfp_mask,
3828                                             unsigned long *total_scanned)
3829 {
3830         unsigned long nr_reclaimed = 0;
3831         struct mem_cgroup_per_zone *mz, *next_mz = NULL;
3832         unsigned long reclaimed;
3833         int loop = 0;
3834         struct mem_cgroup_tree_per_zone *mctz;
3835         unsigned long long excess;
3836         unsigned long nr_scanned;
3837
3838         if (order > 0)
3839                 return 0;
3840
3841         mctz = soft_limit_tree_node_zone(zone_to_nid(zone), zone_idx(zone));
3842         /*
3843          * This loop can run a while, specially if mem_cgroup's continuously
3844          * keep exceeding their soft limit and putting the system under
3845          * pressure
3846          */
3847         do {
3848                 if (next_mz)
3849                         mz = next_mz;
3850                 else
3851                         mz = mem_cgroup_largest_soft_limit_node(mctz);
3852                 if (!mz)
3853                         break;
3854
3855                 nr_scanned = 0;
3856                 reclaimed = mem_cgroup_soft_reclaim(mz->memcg, zone,
3857                                                     gfp_mask, &nr_scanned);
3858                 nr_reclaimed += reclaimed;
3859                 *total_scanned += nr_scanned;
3860                 spin_lock(&mctz->lock);
3861
3862                 /*
3863                  * If we failed to reclaim anything from this memory cgroup
3864                  * it is time to move on to the next cgroup
3865                  */
3866                 next_mz = NULL;
3867                 if (!reclaimed) {
3868                         do {
3869                                 /*
3870                                  * Loop until we find yet another one.
3871                                  *
3872                                  * By the time we get the soft_limit lock
3873                                  * again, someone might have aded the
3874                                  * group back on the RB tree. Iterate to
3875                                  * make sure we get a different mem.
3876                                  * mem_cgroup_largest_soft_limit_node returns
3877                                  * NULL if no other cgroup is present on
3878                                  * the tree
3879                                  */
3880                                 next_mz =
3881                                 __mem_cgroup_largest_soft_limit_node(mctz);
3882                                 if (next_mz == mz)
3883                                         css_put(&next_mz->memcg->css);
3884                                 else /* next_mz == NULL or other memcg */
3885                                         break;
3886                         } while (1);
3887                 }
3888                 __mem_cgroup_remove_exceeded(mz->memcg, mz, mctz);
3889                 excess = res_counter_soft_limit_excess(&mz->memcg->res);
3890                 /*
3891                  * One school of thought says that we should not add
3892                  * back the node to the tree if reclaim returns 0.
3893                  * But our reclaim could return 0, simply because due
3894                  * to priority we are exposing a smaller subset of
3895                  * memory to reclaim from. Consider this as a longer
3896                  * term TODO.
3897                  */
3898                 /* If excess == 0, no tree ops */
3899                 __mem_cgroup_insert_exceeded(mz->memcg, mz, mctz, excess);
3900                 spin_unlock(&mctz->lock);
3901                 css_put(&mz->memcg->css);
3902                 loop++;
3903                 /*
3904                  * Could not reclaim anything and there are no more
3905                  * mem cgroups to try or we seem to be looping without
3906                  * reclaiming anything.
3907                  */
3908                 if (!nr_reclaimed &&
3909                         (next_mz == NULL ||
3910                         loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
3911                         break;
3912         } while (!nr_reclaimed);
3913         if (next_mz)
3914                 css_put(&next_mz->memcg->css);
3915         return nr_reclaimed;
3916 }
3917
3918 /**
3919  * mem_cgroup_force_empty_list - clears LRU of a group
3920  * @memcg: group to clear
3921  * @node: NUMA node
3922  * @zid: zone id
3923  * @lru: lru to to clear
3924  *
3925  * Traverse a specified page_cgroup list and try to drop them all.  This doesn't
3926  * reclaim the pages page themselves - pages are moved to the parent (or root)
3927  * group.
3928  */
3929 static void mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
3930                                 int node, int zid, enum lru_list lru)
3931 {
3932         struct lruvec *lruvec;
3933         unsigned long flags;
3934         struct list_head *list;
3935         struct page *busy;
3936         struct zone *zone;
3937
3938         zone = &NODE_DATA(node)->node_zones[zid];
3939         lruvec = mem_cgroup_zone_lruvec(zone, memcg);
3940         list = &lruvec->lists[lru];
3941
3942         busy = NULL;
3943         do {
3944                 struct page_cgroup *pc;
3945                 struct page *page;
3946
3947                 spin_lock_irqsave(&zone->lru_lock, flags);
3948                 if (list_empty(list)) {
3949                         spin_unlock_irqrestore(&zone->lru_lock, flags);
3950                         break;
3951                 }
3952                 page = list_entry(list->prev, struct page, lru);
3953                 if (busy == page) {
3954                         list_move(&page->lru, list);
3955                         busy = NULL;
3956                         spin_unlock_irqrestore(&zone->lru_lock, flags);
3957                         continue;
3958                 }
3959                 spin_unlock_irqrestore(&zone->lru_lock, flags);
3960
3961                 pc = lookup_page_cgroup(page);
3962
3963                 if (mem_cgroup_move_parent(page, pc, memcg)) {
3964                         /* found lock contention or "pc" is obsolete. */
3965                         busy = page;
3966                         cond_resched();
3967                 } else
3968                         busy = NULL;
3969         } while (!list_empty(list));
3970 }
3971
3972 /*
3973  * make mem_cgroup's charge to be 0 if there is no task by moving
3974  * all the charges and pages to the parent.
3975  * This enables deleting this mem_cgroup.
3976  *
3977  * Caller is responsible for holding css reference on the memcg.
3978  */
3979 static void mem_cgroup_reparent_charges(struct mem_cgroup *memcg)
3980 {
3981         int node, zid;
3982
3983         do {
3984                 /* This is for making all *used* pages to be on LRU. */
3985                 lru_add_drain_all();
3986                 drain_all_stock_sync(memcg);
3987                 mem_cgroup_start_move(memcg);
3988                 for_each_node_state(node, N_MEMORY) {
3989                         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
3990                                 enum lru_list lru;
3991                                 for_each_lru(lru) {
3992                                         mem_cgroup_force_empty_list(memcg,
3993                                                         node, zid, lru);
3994                                 }
3995                         }
3996                 }
3997                 mem_cgroup_end_move(memcg);
3998                 memcg_oom_recover(memcg);
3999                 cond_resched();
4000
4001                 /*
4002                  * This is a safety check because mem_cgroup_force_empty_list
4003                  * could have raced with mem_cgroup_replace_page_cache callers
4004                  * so the lru seemed empty but the page could have been added
4005                  * right after the check. RES_USAGE should be safe as we always
4006                  * charge before adding to the LRU.
4007                  */
4008         } while (res_counter_read_u64(&memcg->res, RES_USAGE) > 0);
4009 }
4010
4011 /*
4012  * Reclaims as many pages from the given memcg as possible and moves
4013  * the rest to the parent.
4014  *
4015  * Caller is responsible for holding css reference for memcg.
4016  */
4017 static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
4018 {
4019         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
4020         struct cgroup *cgrp = memcg->css.cgroup;
4021
4022         /* returns EBUSY if there is a task or if we come here twice. */
4023         if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children))
4024                 return -EBUSY;
4025
4026         /* we call try-to-free pages for make this cgroup empty */
4027         lru_add_drain_all();
4028         /* try to free all pages in this cgroup */
4029         while (nr_retries && res_counter_read_u64(&memcg->res, RES_USAGE) > 0) {
4030                 int progress;
4031
4032                 if (signal_pending(current))
4033                         return -EINTR;
4034
4035                 progress = try_to_free_mem_cgroup_pages(memcg, GFP_KERNEL,
4036                                                 false);
4037                 if (!progress) {
4038                         nr_retries--;
4039                         /* maybe some writeback is necessary */
4040                         congestion_wait(BLK_RW_ASYNC, HZ/10);
4041                 }
4042
4043         }
4044         lru_add_drain();
4045         mem_cgroup_reparent_charges(memcg);
4046
4047         return 0;
4048 }
4049
4050 static int mem_cgroup_force_empty_write(struct cgroup *cont, unsigned int event)
4051 {
4052         struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
4053         int ret;
4054
4055         if (mem_cgroup_is_root(memcg))
4056                 return -EINVAL;
4057         css_get(&memcg->css);
4058         ret = mem_cgroup_force_empty(memcg);