a18e228f140bf8ade69625a00686f58a57c6b043
[platform/adaptation/renesas_rcar/renesas_kernel.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/slab.h>
43 #include <linux/swap.h>
44 #include <linux/swapops.h>
45 #include <linux/spinlock.h>
46 #include <linux/eventfd.h>
47 #include <linux/sort.h>
48 #include <linux/fs.h>
49 #include <linux/seq_file.h>
50 #include <linux/vmalloc.h>
51 #include <linux/vmpressure.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_RSS_HUGE,       /* # of pages charged as anon huge */
97         MEM_CGROUP_STAT_FILE_MAPPED,    /* # of pages charged as file rss */
98         MEM_CGROUP_STAT_SWAP,           /* # of pages, swapped out */
99         MEM_CGROUP_STAT_NSTATS,
100 };
101
102 static const char * const mem_cgroup_stat_names[] = {
103         "cache",
104         "rss",
105         "rss_huge",
106         "mapped_file",
107         "swap",
108 };
109
110 enum mem_cgroup_events_index {
111         MEM_CGROUP_EVENTS_PGPGIN,       /* # of pages paged in */
112         MEM_CGROUP_EVENTS_PGPGOUT,      /* # of pages paged out */
113         MEM_CGROUP_EVENTS_PGFAULT,      /* # of page-faults */
114         MEM_CGROUP_EVENTS_PGMAJFAULT,   /* # of major page-faults */
115         MEM_CGROUP_EVENTS_NSTATS,
116 };
117
118 static const char * const mem_cgroup_events_names[] = {
119         "pgpgin",
120         "pgpgout",
121         "pgfault",
122         "pgmajfault",
123 };
124
125 static const char * const mem_cgroup_lru_names[] = {
126         "inactive_anon",
127         "active_anon",
128         "inactive_file",
129         "active_file",
130         "unevictable",
131 };
132
133 /*
134  * Per memcg event counter is incremented at every pagein/pageout. With THP,
135  * it will be incremated by the number of pages. This counter is used for
136  * for trigger some periodic events. This is straightforward and better
137  * than using jiffies etc. to handle periodic memcg event.
138  */
139 enum mem_cgroup_events_target {
140         MEM_CGROUP_TARGET_THRESH,
141         MEM_CGROUP_TARGET_SOFTLIMIT,
142         MEM_CGROUP_TARGET_NUMAINFO,
143         MEM_CGROUP_NTARGETS,
144 };
145 #define THRESHOLDS_EVENTS_TARGET 128
146 #define SOFTLIMIT_EVENTS_TARGET 1024
147 #define NUMAINFO_EVENTS_TARGET  1024
148
149 struct mem_cgroup_stat_cpu {
150         long count[MEM_CGROUP_STAT_NSTATS];
151         unsigned long events[MEM_CGROUP_EVENTS_NSTATS];
152         unsigned long nr_page_events;
153         unsigned long targets[MEM_CGROUP_NTARGETS];
154 };
155
156 struct mem_cgroup_reclaim_iter {
157         /*
158          * last scanned hierarchy member. Valid only if last_dead_count
159          * matches memcg->dead_count of the hierarchy root group.
160          */
161         struct mem_cgroup *last_visited;
162         unsigned long last_dead_count;
163
164         /* scan generation, increased every round-trip */
165         unsigned int generation;
166 };
167
168 /*
169  * per-zone information in memory controller.
170  */
171 struct mem_cgroup_per_zone {
172         struct lruvec           lruvec;
173         unsigned long           lru_size[NR_LRU_LISTS];
174
175         struct mem_cgroup_reclaim_iter reclaim_iter[DEF_PRIORITY + 1];
176
177         struct mem_cgroup       *memcg;         /* Back pointer, we cannot */
178                                                 /* use container_of        */
179 };
180
181 struct mem_cgroup_per_node {
182         struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
183 };
184
185 struct mem_cgroup_threshold {
186         struct eventfd_ctx *eventfd;
187         u64 threshold;
188 };
189
190 /* For threshold */
191 struct mem_cgroup_threshold_ary {
192         /* An array index points to threshold just below or equal to usage. */
193         int current_threshold;
194         /* Size of entries[] */
195         unsigned int size;
196         /* Array of thresholds */
197         struct mem_cgroup_threshold entries[0];
198 };
199
200 struct mem_cgroup_thresholds {
201         /* Primary thresholds array */
202         struct mem_cgroup_threshold_ary *primary;
203         /*
204          * Spare threshold array.
205          * This is needed to make mem_cgroup_unregister_event() "never fail".
206          * It must be able to store at least primary->size - 1 entries.
207          */
208         struct mem_cgroup_threshold_ary *spare;
209 };
210
211 /* for OOM */
212 struct mem_cgroup_eventfd_list {
213         struct list_head list;
214         struct eventfd_ctx *eventfd;
215 };
216
217 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
218 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
219
220 /*
221  * The memory controller data structure. The memory controller controls both
222  * page cache and RSS per cgroup. We would eventually like to provide
223  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
224  * to help the administrator determine what knobs to tune.
225  *
226  * TODO: Add a water mark for the memory controller. Reclaim will begin when
227  * we hit the water mark. May be even add a low water mark, such that
228  * no reclaim occurs from a cgroup at it's low water mark, this is
229  * a feature that will be implemented much later in the future.
230  */
231 struct mem_cgroup {
232         struct cgroup_subsys_state css;
233         /*
234          * the counter to account for memory usage
235          */
236         struct res_counter res;
237
238         /* vmpressure notifications */
239         struct vmpressure vmpressure;
240
241         /*
242          * the counter to account for mem+swap usage.
243          */
244         struct res_counter memsw;
245
246         /*
247          * the counter to account for kernel memory usage.
248          */
249         struct res_counter kmem;
250         /*
251          * Should the accounting and control be hierarchical, per subtree?
252          */
253         bool use_hierarchy;
254         unsigned long kmem_account_flags; /* See KMEM_ACCOUNTED_*, below */
255
256         bool            oom_lock;
257         atomic_t        under_oom;
258
259         int     swappiness;
260         /* OOM-Killer disable */
261         int             oom_kill_disable;
262
263         /* set when res.limit == memsw.limit */
264         bool            memsw_is_minimum;
265
266         /* protect arrays of thresholds */
267         struct mutex thresholds_lock;
268
269         /* thresholds for memory usage. RCU-protected */
270         struct mem_cgroup_thresholds thresholds;
271
272         /* thresholds for mem+swap usage. RCU-protected */
273         struct mem_cgroup_thresholds memsw_thresholds;
274
275         /* For oom notifier event fd */
276         struct list_head oom_notify;
277
278         /*
279          * Should we move charges of a task when a task is moved into this
280          * mem_cgroup ? And what type of charges should we move ?
281          */
282         unsigned long   move_charge_at_immigrate;
283         /*
284          * set > 0 if pages under this cgroup are moving to other cgroup.
285          */
286         atomic_t        moving_account;
287         /* taken only while moving_account > 0 */
288         spinlock_t      move_lock;
289         /*
290          * percpu counter.
291          */
292         struct mem_cgroup_stat_cpu __percpu *stat;
293         /*
294          * used when a cpu is offlined or other synchronizations
295          * See mem_cgroup_read_stat().
296          */
297         struct mem_cgroup_stat_cpu nocpu_base;
298         spinlock_t pcp_counter_lock;
299
300         atomic_t        dead_count;
301 #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
302         struct tcp_memcontrol tcp_mem;
303 #endif
304 #if defined(CONFIG_MEMCG_KMEM)
305         /* analogous to slab_common's slab_caches list. per-memcg */
306         struct list_head memcg_slab_caches;
307         /* Not a spinlock, we can take a lot of time walking the list */
308         struct mutex slab_caches_mutex;
309         /* Index in the kmem_cache->memcg_params->memcg_caches array */
310         int kmemcg_id;
311 #endif
312
313         int last_scanned_node;
314 #if MAX_NUMNODES > 1
315         nodemask_t      scan_nodes;
316         atomic_t        numainfo_events;
317         atomic_t        numainfo_updating;
318 #endif
319         /*
320          * Protects soft_contributed transitions.
321          * See mem_cgroup_update_soft_limit
322          */
323         spinlock_t soft_lock;
324
325         /*
326          * If true then this group has increased parents' children_in_excess
327          * when it got over the soft limit.
328          * When a group falls bellow the soft limit, parents' children_in_excess
329          * is decreased and soft_contributed changed to false.
330          */
331         bool soft_contributed;
332
333         /* Number of children that are in soft limit excess */
334         atomic_t children_in_excess;
335
336         struct mem_cgroup_per_node *nodeinfo[0];
337         /* WARNING: nodeinfo must be the last member here */
338 };
339
340 static size_t memcg_size(void)
341 {
342         return sizeof(struct mem_cgroup) +
343                 nr_node_ids * sizeof(struct mem_cgroup_per_node);
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         KMEM_ACCOUNTED_ACTIVATED, /* static key enabled. */
350         KMEM_ACCOUNTED_DEAD, /* dead memcg with pending kmem charges */
351 };
352
353 /* We account when limit is on, but only after call sites are patched */
354 #define KMEM_ACCOUNTED_MASK \
355                 ((1 << KMEM_ACCOUNTED_ACTIVE) | (1 << KMEM_ACCOUNTED_ACTIVATED))
356
357 #ifdef CONFIG_MEMCG_KMEM
358 static inline void memcg_kmem_set_active(struct mem_cgroup *memcg)
359 {
360         set_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
361 }
362
363 static bool memcg_kmem_is_active(struct mem_cgroup *memcg)
364 {
365         return test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
366 }
367
368 static void memcg_kmem_set_activated(struct mem_cgroup *memcg)
369 {
370         set_bit(KMEM_ACCOUNTED_ACTIVATED, &memcg->kmem_account_flags);
371 }
372
373 static void memcg_kmem_clear_activated(struct mem_cgroup *memcg)
374 {
375         clear_bit(KMEM_ACCOUNTED_ACTIVATED, &memcg->kmem_account_flags);
376 }
377
378 static void memcg_kmem_mark_dead(struct mem_cgroup *memcg)
379 {
380         /*
381          * Our caller must use css_get() first, because memcg_uncharge_kmem()
382          * will call css_put() if it sees the memcg is dead.
383          */
384         smp_wmb();
385         if (test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags))
386                 set_bit(KMEM_ACCOUNTED_DEAD, &memcg->kmem_account_flags);
387 }
388
389 static bool memcg_kmem_test_and_clear_dead(struct mem_cgroup *memcg)
390 {
391         return test_and_clear_bit(KMEM_ACCOUNTED_DEAD,
392                                   &memcg->kmem_account_flags);
393 }
394 #endif
395
396 /* Stuffs for move charges at task migration. */
397 /*
398  * Types of charges to be moved. "move_charge_at_immitgrate" and
399  * "immigrate_flags" are treated as a left-shifted bitmap of these types.
400  */
401 enum move_type {
402         MOVE_CHARGE_TYPE_ANON,  /* private anonymous page and swap of it */
403         MOVE_CHARGE_TYPE_FILE,  /* file page(including tmpfs) and swap of it */
404         NR_MOVE_TYPE,
405 };
406
407 /* "mc" and its members are protected by cgroup_mutex */
408 static struct move_charge_struct {
409         spinlock_t        lock; /* for from, to */
410         struct mem_cgroup *from;
411         struct mem_cgroup *to;
412         unsigned long immigrate_flags;
413         unsigned long precharge;
414         unsigned long moved_charge;
415         unsigned long moved_swap;
416         struct task_struct *moving_task;        /* a task moving charges */
417         wait_queue_head_t waitq;                /* a waitq for other context */
418 } mc = {
419         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
420         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
421 };
422
423 static bool move_anon(void)
424 {
425         return test_bit(MOVE_CHARGE_TYPE_ANON, &mc.immigrate_flags);
426 }
427
428 static bool move_file(void)
429 {
430         return test_bit(MOVE_CHARGE_TYPE_FILE, &mc.immigrate_flags);
431 }
432
433 /*
434  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
435  * limit reclaim to prevent infinite loops, if they ever occur.
436  */
437 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
438
439 enum charge_type {
440         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
441         MEM_CGROUP_CHARGE_TYPE_ANON,
442         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
443         MEM_CGROUP_CHARGE_TYPE_DROP,    /* a page was unused swap cache */
444         NR_CHARGE_TYPE,
445 };
446
447 /* for encoding cft->private value on file */
448 enum res_type {
449         _MEM,
450         _MEMSWAP,
451         _OOM_TYPE,
452         _KMEM,
453 };
454
455 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
456 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
457 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
458 /* Used for OOM nofiier */
459 #define OOM_CONTROL             (0)
460
461 /*
462  * Reclaim flags for mem_cgroup_hierarchical_reclaim
463  */
464 #define MEM_CGROUP_RECLAIM_NOSWAP_BIT   0x0
465 #define MEM_CGROUP_RECLAIM_NOSWAP       (1 << MEM_CGROUP_RECLAIM_NOSWAP_BIT)
466 #define MEM_CGROUP_RECLAIM_SHRINK_BIT   0x1
467 #define MEM_CGROUP_RECLAIM_SHRINK       (1 << MEM_CGROUP_RECLAIM_SHRINK_BIT)
468
469 /*
470  * The memcg_create_mutex will be held whenever a new cgroup is created.
471  * As a consequence, any change that needs to protect against new child cgroups
472  * appearing has to hold it as well.
473  */
474 static DEFINE_MUTEX(memcg_create_mutex);
475
476 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
477 {
478         return s ? container_of(s, struct mem_cgroup, css) : NULL;
479 }
480
481 /* Some nice accessors for the vmpressure. */
482 struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
483 {
484         if (!memcg)
485                 memcg = root_mem_cgroup;
486         return &memcg->vmpressure;
487 }
488
489 struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
490 {
491         return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
492 }
493
494 struct vmpressure *css_to_vmpressure(struct cgroup_subsys_state *css)
495 {
496         return &mem_cgroup_from_css(css)->vmpressure;
497 }
498
499 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
500 {
501         return (memcg == root_mem_cgroup);
502 }
503
504 /* Writing them here to avoid exposing memcg's inner layout */
505 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
506
507 void sock_update_memcg(struct sock *sk)
508 {
509         if (mem_cgroup_sockets_enabled) {
510                 struct mem_cgroup *memcg;
511                 struct cg_proto *cg_proto;
512
513                 BUG_ON(!sk->sk_prot->proto_cgroup);
514
515                 /* Socket cloning can throw us here with sk_cgrp already
516                  * filled. It won't however, necessarily happen from
517                  * process context. So the test for root memcg given
518                  * the current task's memcg won't help us in this case.
519                  *
520                  * Respecting the original socket's memcg is a better
521                  * decision in this case.
522                  */
523                 if (sk->sk_cgrp) {
524                         BUG_ON(mem_cgroup_is_root(sk->sk_cgrp->memcg));
525                         css_get(&sk->sk_cgrp->memcg->css);
526                         return;
527                 }
528
529                 rcu_read_lock();
530                 memcg = mem_cgroup_from_task(current);
531                 cg_proto = sk->sk_prot->proto_cgroup(memcg);
532                 if (!mem_cgroup_is_root(memcg) &&
533                     memcg_proto_active(cg_proto) && css_tryget(&memcg->css)) {
534                         sk->sk_cgrp = cg_proto;
535                 }
536                 rcu_read_unlock();
537         }
538 }
539 EXPORT_SYMBOL(sock_update_memcg);
540
541 void sock_release_memcg(struct sock *sk)
542 {
543         if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
544                 struct mem_cgroup *memcg;
545                 WARN_ON(!sk->sk_cgrp->memcg);
546                 memcg = sk->sk_cgrp->memcg;
547                 css_put(&sk->sk_cgrp->memcg->css);
548         }
549 }
550
551 struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
552 {
553         if (!memcg || mem_cgroup_is_root(memcg))
554                 return NULL;
555
556         return &memcg->tcp_mem.cg_proto;
557 }
558 EXPORT_SYMBOL(tcp_proto_cgroup);
559
560 static void disarm_sock_keys(struct mem_cgroup *memcg)
561 {
562         if (!memcg_proto_activated(&memcg->tcp_mem.cg_proto))
563                 return;
564         static_key_slow_dec(&memcg_socket_limit_enabled);
565 }
566 #else
567 static void disarm_sock_keys(struct mem_cgroup *memcg)
568 {
569 }
570 #endif
571
572 #ifdef CONFIG_MEMCG_KMEM
573 /*
574  * This will be the memcg's index in each cache's ->memcg_params->memcg_caches.
575  * There are two main reasons for not using the css_id for this:
576  *  1) this works better in sparse environments, where we have a lot of memcgs,
577  *     but only a few kmem-limited. Or also, if we have, for instance, 200
578  *     memcgs, and none but the 200th is kmem-limited, we'd have to have a
579  *     200 entry array for that.
580  *
581  *  2) In order not to violate the cgroup API, we would like to do all memory
582  *     allocation in ->create(). At that point, we haven't yet allocated the
583  *     css_id. Having a separate index prevents us from messing with the cgroup
584  *     core for this
585  *
586  * The current size of the caches array is stored in
587  * memcg_limited_groups_array_size.  It will double each time we have to
588  * increase it.
589  */
590 static DEFINE_IDA(kmem_limited_groups);
591 int memcg_limited_groups_array_size;
592
593 /*
594  * MIN_SIZE is different than 1, because we would like to avoid going through
595  * the alloc/free process all the time. In a small machine, 4 kmem-limited
596  * cgroups is a reasonable guess. In the future, it could be a parameter or
597  * tunable, but that is strictly not necessary.
598  *
599  * MAX_SIZE should be as large as the number of css_ids. Ideally, we could get
600  * this constant directly from cgroup, but it is understandable that this is
601  * better kept as an internal representation in cgroup.c. In any case, the
602  * css_id space is not getting any smaller, and we don't have to necessarily
603  * increase ours as well if it increases.
604  */
605 #define MEMCG_CACHES_MIN_SIZE 4
606 #define MEMCG_CACHES_MAX_SIZE 65535
607
608 /*
609  * A lot of the calls to the cache allocation functions are expected to be
610  * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
611  * conditional to this static branch, we'll have to allow modules that does
612  * kmem_cache_alloc and the such to see this symbol as well
613  */
614 struct static_key memcg_kmem_enabled_key;
615 EXPORT_SYMBOL(memcg_kmem_enabled_key);
616
617 static void disarm_kmem_keys(struct mem_cgroup *memcg)
618 {
619         if (memcg_kmem_is_active(memcg)) {
620                 static_key_slow_dec(&memcg_kmem_enabled_key);
621                 ida_simple_remove(&kmem_limited_groups, memcg->kmemcg_id);
622         }
623         /*
624          * This check can't live in kmem destruction function,
625          * since the charges will outlive the cgroup
626          */
627         WARN_ON(res_counter_read_u64(&memcg->kmem, RES_USAGE) != 0);
628 }
629 #else
630 static void disarm_kmem_keys(struct mem_cgroup *memcg)
631 {
632 }
633 #endif /* CONFIG_MEMCG_KMEM */
634
635 static void disarm_static_keys(struct mem_cgroup *memcg)
636 {
637         disarm_sock_keys(memcg);
638         disarm_kmem_keys(memcg);
639 }
640
641 static void drain_all_stock_async(struct mem_cgroup *memcg);
642
643 static struct mem_cgroup_per_zone *
644 mem_cgroup_zoneinfo(struct mem_cgroup *memcg, int nid, int zid)
645 {
646         VM_BUG_ON((unsigned)nid >= nr_node_ids);
647         return &memcg->nodeinfo[nid]->zoneinfo[zid];
648 }
649
650 struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)
651 {
652         return &memcg->css;
653 }
654
655 static struct mem_cgroup_per_zone *
656 page_cgroup_zoneinfo(struct mem_cgroup *memcg, struct page *page)
657 {
658         int nid = page_to_nid(page);
659         int zid = page_zonenum(page);
660
661         return mem_cgroup_zoneinfo(memcg, nid, zid);
662 }
663
664 /*
665  * Implementation Note: reading percpu statistics for memcg.
666  *
667  * Both of vmstat[] and percpu_counter has threshold and do periodic
668  * synchronization to implement "quick" read. There are trade-off between
669  * reading cost and precision of value. Then, we may have a chance to implement
670  * a periodic synchronizion of counter in memcg's counter.
671  *
672  * But this _read() function is used for user interface now. The user accounts
673  * memory usage by memory cgroup and he _always_ requires exact value because
674  * he accounts memory. Even if we provide quick-and-fuzzy read, we always
675  * have to visit all online cpus and make sum. So, for now, unnecessary
676  * synchronization is not implemented. (just implemented for cpu hotplug)
677  *
678  * If there are kernel internal actions which can make use of some not-exact
679  * value, and reading all cpu value can be performance bottleneck in some
680  * common workload, threashold and synchonization as vmstat[] should be
681  * implemented.
682  */
683 static long mem_cgroup_read_stat(struct mem_cgroup *memcg,
684                                  enum mem_cgroup_stat_index idx)
685 {
686         long val = 0;
687         int cpu;
688
689         get_online_cpus();
690         for_each_online_cpu(cpu)
691                 val += per_cpu(memcg->stat->count[idx], cpu);
692 #ifdef CONFIG_HOTPLUG_CPU
693         spin_lock(&memcg->pcp_counter_lock);
694         val += memcg->nocpu_base.count[idx];
695         spin_unlock(&memcg->pcp_counter_lock);
696 #endif
697         put_online_cpus();
698         return val;
699 }
700
701 static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,
702                                          bool charge)
703 {
704         int val = (charge) ? 1 : -1;
705         this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_SWAP], val);
706 }
707
708 static unsigned long mem_cgroup_read_events(struct mem_cgroup *memcg,
709                                             enum mem_cgroup_events_index idx)
710 {
711         unsigned long val = 0;
712         int cpu;
713
714         for_each_online_cpu(cpu)
715                 val += per_cpu(memcg->stat->events[idx], cpu);
716 #ifdef CONFIG_HOTPLUG_CPU
717         spin_lock(&memcg->pcp_counter_lock);
718         val += memcg->nocpu_base.events[idx];
719         spin_unlock(&memcg->pcp_counter_lock);
720 #endif
721         return val;
722 }
723
724 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
725                                          struct page *page,
726                                          bool anon, int nr_pages)
727 {
728         preempt_disable();
729
730         /*
731          * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
732          * counted as CACHE even if it's on ANON LRU.
733          */
734         if (anon)
735                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],
736                                 nr_pages);
737         else
738                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_CACHE],
739                                 nr_pages);
740
741         if (PageTransHuge(page))
742                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
743                                 nr_pages);
744
745         /* pagein of a big page is an event. So, ignore page size */
746         if (nr_pages > 0)
747                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGIN]);
748         else {
749                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT]);
750                 nr_pages = -nr_pages; /* for event */
751         }
752
753         __this_cpu_add(memcg->stat->nr_page_events, nr_pages);
754
755         preempt_enable();
756 }
757
758 unsigned long
759 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
760 {
761         struct mem_cgroup_per_zone *mz;
762
763         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
764         return mz->lru_size[lru];
765 }
766
767 static unsigned long
768 mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
769                         unsigned int lru_mask)
770 {
771         struct mem_cgroup_per_zone *mz;
772         enum lru_list lru;
773         unsigned long ret = 0;
774
775         mz = mem_cgroup_zoneinfo(memcg, nid, zid);
776
777         for_each_lru(lru) {
778                 if (BIT(lru) & lru_mask)
779                         ret += mz->lru_size[lru];
780         }
781         return ret;
782 }
783
784 static unsigned long
785 mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
786                         int nid, unsigned int lru_mask)
787 {
788         u64 total = 0;
789         int zid;
790
791         for (zid = 0; zid < MAX_NR_ZONES; zid++)
792                 total += mem_cgroup_zone_nr_lru_pages(memcg,
793                                                 nid, zid, lru_mask);
794
795         return total;
796 }
797
798 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
799                         unsigned int lru_mask)
800 {
801         int nid;
802         u64 total = 0;
803
804         for_each_node_state(nid, N_MEMORY)
805                 total += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
806         return total;
807 }
808
809 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
810                                        enum mem_cgroup_events_target target)
811 {
812         unsigned long val, next;
813
814         val = __this_cpu_read(memcg->stat->nr_page_events);
815         next = __this_cpu_read(memcg->stat->targets[target]);
816         /* from time_after() in jiffies.h */
817         if ((long)next - (long)val < 0) {
818                 switch (target) {
819                 case MEM_CGROUP_TARGET_THRESH:
820                         next = val + THRESHOLDS_EVENTS_TARGET;
821                         break;
822                 case MEM_CGROUP_TARGET_SOFTLIMIT:
823                         next = val + SOFTLIMIT_EVENTS_TARGET;
824                         break;
825                 case MEM_CGROUP_TARGET_NUMAINFO:
826                         next = val + NUMAINFO_EVENTS_TARGET;
827                         break;
828                 default:
829                         break;
830                 }
831                 __this_cpu_write(memcg->stat->targets[target], next);
832                 return true;
833         }
834         return false;
835 }
836
837 /*
838  * Called from rate-limitted memcg_check_events when enough
839  * MEM_CGROUP_TARGET_SOFTLIMIT events are accumulated and it makes sure
840  * that all the parents up the hierarchy will be noticed that this group
841  * is in excess or that it is not in excess anymore. mmecg->soft_contributed
842  * makes the transition a single action whenever the state flips from one to
843  * other.
844  */
845 static void mem_cgroup_update_soft_limit(struct mem_cgroup *memcg)
846 {
847         unsigned long long excess = res_counter_soft_limit_excess(&memcg->res);
848         struct mem_cgroup *parent = memcg;
849         int delta = 0;
850
851         spin_lock(&memcg->soft_lock);
852         if (excess) {
853                 if (!memcg->soft_contributed) {
854                         delta = 1;
855                         memcg->soft_contributed = true;
856                 }
857         } else {
858                 if (memcg->soft_contributed) {
859                         delta = -1;
860                         memcg->soft_contributed = false;
861                 }
862         }
863
864         /*
865          * Necessary to update all ancestors when hierarchy is used
866          * because their event counter is not touched.
867          */
868         while (delta && (parent = parent_mem_cgroup(parent)))
869                 atomic_add(delta, &parent->children_in_excess);
870         spin_unlock(&memcg->soft_lock);
871 }
872
873 /*
874  * Check events in order.
875  *
876  */
877 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
878 {
879         preempt_disable();
880         /* threshold event is triggered in finer grain than soft limit */
881         if (unlikely(mem_cgroup_event_ratelimit(memcg,
882                                                 MEM_CGROUP_TARGET_THRESH))) {
883                 bool do_softlimit;
884                 bool do_numainfo __maybe_unused;
885
886                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
887                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
888 #if MAX_NUMNODES > 1
889                 do_numainfo = mem_cgroup_event_ratelimit(memcg,
890                                                 MEM_CGROUP_TARGET_NUMAINFO);
891 #endif
892                 preempt_enable();
893
894                 mem_cgroup_threshold(memcg);
895                 if (unlikely(do_softlimit))
896                         mem_cgroup_update_soft_limit(memcg);
897 #if MAX_NUMNODES > 1
898                 if (unlikely(do_numainfo))
899                         atomic_inc(&memcg->numainfo_events);
900 #endif
901         } else
902                 preempt_enable();
903 }
904
905 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
906 {
907         /*
908          * mm_update_next_owner() may clear mm->owner to NULL
909          * if it races with swapoff, page migration, etc.
910          * So this can be called with p == NULL.
911          */
912         if (unlikely(!p))
913                 return NULL;
914
915         return mem_cgroup_from_css(task_css(p, mem_cgroup_subsys_id));
916 }
917
918 struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
919 {
920         struct mem_cgroup *memcg = NULL;
921
922         if (!mm)
923                 return NULL;
924         /*
925          * Because we have no locks, mm->owner's may be being moved to other
926          * cgroup. We use css_tryget() here even if this looks
927          * pessimistic (rather than adding locks here).
928          */
929         rcu_read_lock();
930         do {
931                 memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
932                 if (unlikely(!memcg))
933                         break;
934         } while (!css_tryget(&memcg->css));
935         rcu_read_unlock();
936         return memcg;
937 }
938
939 static enum mem_cgroup_filter_t
940 mem_cgroup_filter(struct mem_cgroup *memcg, struct mem_cgroup *root,
941                 mem_cgroup_iter_filter cond)
942 {
943         if (!cond)
944                 return VISIT;
945         return cond(memcg, root);
946 }
947
948 /*
949  * Returns a next (in a pre-order walk) alive memcg (with elevated css
950  * ref. count) or NULL if the whole root's subtree has been visited.
951  *
952  * helper function to be used by mem_cgroup_iter
953  */
954 static struct mem_cgroup *__mem_cgroup_iter_next(struct mem_cgroup *root,
955                 struct mem_cgroup *last_visited, mem_cgroup_iter_filter cond)
956 {
957         struct cgroup_subsys_state *prev_css, *next_css;
958
959         prev_css = last_visited ? &last_visited->css : NULL;
960 skip_node:
961         next_css = css_next_descendant_pre(prev_css, &root->css);
962
963         /*
964          * Even if we found a group we have to make sure it is
965          * alive. css && !memcg means that the groups should be
966          * skipped and we should continue the tree walk.
967          * last_visited css is safe to use because it is
968          * protected by css_get and the tree walk is rcu safe.
969          */
970         if (next_css) {
971                 struct mem_cgroup *mem = mem_cgroup_from_css(next_css);
972
973                 switch (mem_cgroup_filter(mem, root, cond)) {
974                 case SKIP:
975                         prev_css = next_css;
976                         goto skip_node;
977                 case SKIP_TREE:
978                         if (mem == root)
979                                 return NULL;
980                         /*
981                          * css_rightmost_descendant is not an optimal way to
982                          * skip through a subtree (especially for imbalanced
983                          * trees leaning to right) but that's what we have right
984                          * now. More effective solution would be traversing
985                          * right-up for first non-NULL without calling
986                          * css_next_descendant_pre afterwards.
987                          */
988                         prev_css = css_rightmost_descendant(next_css);
989                         goto skip_node;
990                 case VISIT:
991                         if (css_tryget(&mem->css))
992                                 return mem;
993                         else {
994                                 prev_css = next_css;
995                                 goto skip_node;
996                         }
997                         break;
998                 }
999         }
1000
1001         return NULL;
1002 }
1003
1004 static void mem_cgroup_iter_invalidate(struct mem_cgroup *root)
1005 {
1006         /*
1007          * When a group in the hierarchy below root is destroyed, the
1008          * hierarchy iterator can no longer be trusted since it might
1009          * have pointed to the destroyed group.  Invalidate it.
1010          */
1011         atomic_inc(&root->dead_count);
1012 }
1013
1014 static struct mem_cgroup *
1015 mem_cgroup_iter_load(struct mem_cgroup_reclaim_iter *iter,
1016                      struct mem_cgroup *root,
1017                      int *sequence)
1018 {
1019         struct mem_cgroup *position = NULL;
1020         /*
1021          * A cgroup destruction happens in two stages: offlining and
1022          * release.  They are separated by a RCU grace period.
1023          *
1024          * If the iterator is valid, we may still race with an
1025          * offlining.  The RCU lock ensures the object won't be
1026          * released, tryget will fail if we lost the race.
1027          */
1028         *sequence = atomic_read(&root->dead_count);
1029         if (iter->last_dead_count == *sequence) {
1030                 smp_rmb();
1031                 position = iter->last_visited;
1032                 if (position && !css_tryget(&position->css))
1033                         position = NULL;
1034         }
1035         return position;
1036 }
1037
1038 static void mem_cgroup_iter_update(struct mem_cgroup_reclaim_iter *iter,
1039                                    struct mem_cgroup *last_visited,
1040                                    struct mem_cgroup *new_position,
1041                                    int sequence)
1042 {
1043         if (last_visited)
1044                 css_put(&last_visited->css);
1045         /*
1046          * We store the sequence count from the time @last_visited was
1047          * loaded successfully instead of rereading it here so that we
1048          * don't lose destruction events in between.  We could have
1049          * raced with the destruction of @new_position after all.
1050          */
1051         iter->last_visited = new_position;
1052         smp_wmb();
1053         iter->last_dead_count = sequence;
1054 }
1055
1056 /**
1057  * mem_cgroup_iter - iterate over memory cgroup hierarchy
1058  * @root: hierarchy root
1059  * @prev: previously returned memcg, NULL on first invocation
1060  * @reclaim: cookie for shared reclaim walks, NULL for full walks
1061  * @cond: filter for visited nodes, NULL for no filter
1062  *
1063  * Returns references to children of the hierarchy below @root, or
1064  * @root itself, or %NULL after a full round-trip.
1065  *
1066  * Caller must pass the return value in @prev on subsequent
1067  * invocations for reference counting, or use mem_cgroup_iter_break()
1068  * to cancel a hierarchy walk before the round-trip is complete.
1069  *
1070  * Reclaimers can specify a zone and a priority level in @reclaim to
1071  * divide up the memcgs in the hierarchy among all concurrent
1072  * reclaimers operating on the same zone and priority.
1073  */
1074 struct mem_cgroup *mem_cgroup_iter_cond(struct mem_cgroup *root,
1075                                    struct mem_cgroup *prev,
1076                                    struct mem_cgroup_reclaim_cookie *reclaim,
1077                                    mem_cgroup_iter_filter cond)
1078 {
1079         struct mem_cgroup *memcg = NULL;
1080         struct mem_cgroup *last_visited = NULL;
1081
1082         if (mem_cgroup_disabled()) {
1083                 /* first call must return non-NULL, second return NULL */
1084                 return (struct mem_cgroup *)(unsigned long)!prev;
1085         }
1086
1087         if (!root)
1088                 root = root_mem_cgroup;
1089
1090         if (prev && !reclaim)
1091                 last_visited = prev;
1092
1093         if (!root->use_hierarchy && root != root_mem_cgroup) {
1094                 if (prev)
1095                         goto out_css_put;
1096                 if (mem_cgroup_filter(root, root, cond) == VISIT)
1097                         return root;
1098                 return NULL;
1099         }
1100
1101         rcu_read_lock();
1102         while (!memcg) {
1103                 struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
1104                 int uninitialized_var(seq);
1105
1106                 if (reclaim) {
1107                         int nid = zone_to_nid(reclaim->zone);
1108                         int zid = zone_idx(reclaim->zone);
1109                         struct mem_cgroup_per_zone *mz;
1110
1111                         mz = mem_cgroup_zoneinfo(root, nid, zid);
1112                         iter = &mz->reclaim_iter[reclaim->priority];
1113                         if (prev && reclaim->generation != iter->generation) {
1114                                 iter->last_visited = NULL;
1115                                 goto out_unlock;
1116                         }
1117
1118                         last_visited = mem_cgroup_iter_load(iter, root, &seq);
1119                 }
1120
1121                 memcg = __mem_cgroup_iter_next(root, last_visited, cond);
1122
1123                 if (reclaim) {
1124                         mem_cgroup_iter_update(iter, last_visited, memcg, seq);
1125
1126                         if (!memcg)
1127                                 iter->generation++;
1128                         else if (!prev && memcg)
1129                                 reclaim->generation = iter->generation;
1130                 }
1131
1132                 /*
1133                  * We have finished the whole tree walk or no group has been
1134                  * visited because filter told us to skip the root node.
1135                  */
1136                 if (!memcg && (prev || (cond && !last_visited)))
1137                         goto out_unlock;
1138         }
1139 out_unlock:
1140         rcu_read_unlock();
1141 out_css_put:
1142         if (prev && prev != root)
1143                 css_put(&prev->css);
1144
1145         return memcg;
1146 }
1147
1148 /**
1149  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1150  * @root: hierarchy root
1151  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1152  */
1153 void mem_cgroup_iter_break(struct mem_cgroup *root,
1154                            struct mem_cgroup *prev)
1155 {
1156         if (!root)
1157                 root = root_mem_cgroup;
1158         if (prev && prev != root)
1159                 css_put(&prev->css);
1160 }
1161
1162 /*
1163  * Iteration constructs for visiting all cgroups (under a tree).  If
1164  * loops are exited prematurely (break), mem_cgroup_iter_break() must
1165  * be used for reference counting.
1166  */
1167 #define for_each_mem_cgroup_tree(iter, root)            \
1168         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
1169              iter != NULL;                              \
1170              iter = mem_cgroup_iter(root, iter, NULL))
1171
1172 #define for_each_mem_cgroup(iter)                       \
1173         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
1174              iter != NULL;                              \
1175              iter = mem_cgroup_iter(NULL, iter, NULL))
1176
1177 void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
1178 {
1179         struct mem_cgroup *memcg;
1180
1181         rcu_read_lock();
1182         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
1183         if (unlikely(!memcg))
1184                 goto out;
1185
1186         switch (idx) {
1187         case PGFAULT:
1188                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT]);
1189                 break;
1190         case PGMAJFAULT:
1191                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT]);
1192                 break;
1193         default:
1194                 BUG();
1195         }
1196 out:
1197         rcu_read_unlock();
1198 }
1199 EXPORT_SYMBOL(__mem_cgroup_count_vm_event);
1200
1201 /**
1202  * mem_cgroup_zone_lruvec - get the lru list vector for a zone and memcg
1203  * @zone: zone of the wanted lruvec
1204  * @memcg: memcg of the wanted lruvec
1205  *
1206  * Returns the lru list vector holding pages for the given @zone and
1207  * @mem.  This can be the global zone lruvec, if the memory controller
1208  * is disabled.
1209  */
1210 struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
1211                                       struct mem_cgroup *memcg)
1212 {
1213         struct mem_cgroup_per_zone *mz;
1214         struct lruvec *lruvec;
1215
1216         if (mem_cgroup_disabled()) {
1217                 lruvec = &zone->lruvec;
1218                 goto out;
1219         }
1220
1221         mz = mem_cgroup_zoneinfo(memcg, zone_to_nid(zone), zone_idx(zone));
1222         lruvec = &mz->lruvec;
1223 out:
1224         /*
1225          * Since a node can be onlined after the mem_cgroup was created,
1226          * we have to be prepared to initialize lruvec->zone here;
1227          * and if offlined then reonlined, we need to reinitialize it.
1228          */
1229         if (unlikely(lruvec->zone != zone))
1230                 lruvec->zone = zone;
1231         return lruvec;
1232 }
1233
1234 /*
1235  * Following LRU functions are allowed to be used without PCG_LOCK.
1236  * Operations are called by routine of global LRU independently from memcg.
1237  * What we have to take care of here is validness of pc->mem_cgroup.
1238  *
1239  * Changes to pc->mem_cgroup happens when
1240  * 1. charge
1241  * 2. moving account
1242  * In typical case, "charge" is done before add-to-lru. Exception is SwapCache.
1243  * It is added to LRU before charge.
1244  * If PCG_USED bit is not set, page_cgroup is not added to this private LRU.
1245  * When moving account, the page is not on LRU. It's isolated.
1246  */
1247
1248 /**
1249  * mem_cgroup_page_lruvec - return lruvec for adding an lru page
1250  * @page: the page
1251  * @zone: zone of the page
1252  */
1253 struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)
1254 {
1255         struct mem_cgroup_per_zone *mz;
1256         struct mem_cgroup *memcg;
1257         struct page_cgroup *pc;
1258         struct lruvec *lruvec;
1259
1260         if (mem_cgroup_disabled()) {
1261                 lruvec = &zone->lruvec;
1262                 goto out;
1263         }
1264
1265         pc = lookup_page_cgroup(page);
1266         memcg = pc->mem_cgroup;
1267
1268         /*
1269          * Surreptitiously switch any uncharged offlist page to root:
1270          * an uncharged page off lru does nothing to secure
1271          * its former mem_cgroup from sudden removal.
1272          *
1273          * Our caller holds lru_lock, and PageCgroupUsed is updated
1274          * under page_cgroup lock: between them, they make all uses
1275          * of pc->mem_cgroup safe.
1276          */
1277         if (!PageLRU(page) && !PageCgroupUsed(pc) && memcg != root_mem_cgroup)
1278                 pc->mem_cgroup = memcg = root_mem_cgroup;
1279
1280         mz = page_cgroup_zoneinfo(memcg, page);
1281         lruvec = &mz->lruvec;
1282 out:
1283         /*
1284          * Since a node can be onlined after the mem_cgroup was created,
1285          * we have to be prepared to initialize lruvec->zone here;
1286          * and if offlined then reonlined, we need to reinitialize it.
1287          */
1288         if (unlikely(lruvec->zone != zone))
1289                 lruvec->zone = zone;
1290         return lruvec;
1291 }
1292
1293 /**
1294  * mem_cgroup_update_lru_size - account for adding or removing an lru page
1295  * @lruvec: mem_cgroup per zone lru vector
1296  * @lru: index of lru list the page is sitting on
1297  * @nr_pages: positive when adding or negative when removing
1298  *
1299  * This function must be called when a page is added to or removed from an
1300  * lru list.
1301  */
1302 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1303                                 int nr_pages)
1304 {
1305         struct mem_cgroup_per_zone *mz;
1306         unsigned long *lru_size;
1307
1308         if (mem_cgroup_disabled())
1309                 return;
1310
1311         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
1312         lru_size = mz->lru_size + lru;
1313         *lru_size += nr_pages;
1314         VM_BUG_ON((long)(*lru_size) < 0);
1315 }
1316
1317 /*
1318  * Checks whether given mem is same or in the root_mem_cgroup's
1319  * hierarchy subtree
1320  */
1321 bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1322                                   struct mem_cgroup *memcg)
1323 {
1324         if (root_memcg == memcg)
1325                 return true;
1326         if (!root_memcg->use_hierarchy || !memcg)
1327                 return false;
1328         return css_is_ancestor(&memcg->css, &root_memcg->css);
1329 }
1330
1331 static bool mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1332                                        struct mem_cgroup *memcg)
1333 {
1334         bool ret;
1335
1336         rcu_read_lock();
1337         ret = __mem_cgroup_same_or_subtree(root_memcg, memcg);
1338         rcu_read_unlock();
1339         return ret;
1340 }
1341
1342 bool task_in_mem_cgroup(struct task_struct *task,
1343                         const struct mem_cgroup *memcg)
1344 {
1345         struct mem_cgroup *curr = NULL;
1346         struct task_struct *p;
1347         bool ret;
1348
1349         p = find_lock_task_mm(task);
1350         if (p) {
1351                 curr = try_get_mem_cgroup_from_mm(p->mm);
1352                 task_unlock(p);
1353         } else {
1354                 /*
1355                  * All threads may have already detached their mm's, but the oom
1356                  * killer still needs to detect if they have already been oom
1357                  * killed to prevent needlessly killing additional tasks.
1358                  */
1359                 rcu_read_lock();
1360                 curr = mem_cgroup_from_task(task);
1361                 if (curr)
1362                         css_get(&curr->css);
1363                 rcu_read_unlock();
1364         }
1365         if (!curr)
1366                 return false;
1367         /*
1368          * We should check use_hierarchy of "memcg" not "curr". Because checking
1369          * use_hierarchy of "curr" here make this function true if hierarchy is
1370          * enabled in "curr" and "curr" is a child of "memcg" in *cgroup*
1371          * hierarchy(even if use_hierarchy is disabled in "memcg").
1372          */
1373         ret = mem_cgroup_same_or_subtree(memcg, curr);
1374         css_put(&curr->css);
1375         return ret;
1376 }
1377
1378 int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
1379 {
1380         unsigned long inactive_ratio;
1381         unsigned long inactive;
1382         unsigned long active;
1383         unsigned long gb;
1384
1385         inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_ANON);
1386         active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_ANON);
1387
1388         gb = (inactive + active) >> (30 - PAGE_SHIFT);
1389         if (gb)
1390                 inactive_ratio = int_sqrt(10 * gb);
1391         else
1392                 inactive_ratio = 1;
1393
1394         return inactive * inactive_ratio < active;
1395 }
1396
1397 #define mem_cgroup_from_res_counter(counter, member)    \
1398         container_of(counter, struct mem_cgroup, member)
1399
1400 /**
1401  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1402  * @memcg: the memory cgroup
1403  *
1404  * Returns the maximum amount of memory @mem can be charged with, in
1405  * pages.
1406  */
1407 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1408 {
1409         unsigned long long margin;
1410
1411         margin = res_counter_margin(&memcg->res);
1412         if (do_swap_account)
1413                 margin = min(margin, res_counter_margin(&memcg->memsw));
1414         return margin >> PAGE_SHIFT;
1415 }
1416
1417 int mem_cgroup_swappiness(struct mem_cgroup *memcg)
1418 {
1419         /* root ? */
1420         if (!css_parent(&memcg->css))
1421                 return vm_swappiness;
1422
1423         return memcg->swappiness;
1424 }
1425
1426 /*
1427  * memcg->moving_account is used for checking possibility that some thread is
1428  * calling move_account(). When a thread on CPU-A starts moving pages under
1429  * a memcg, other threads should check memcg->moving_account under
1430  * rcu_read_lock(), like this:
1431  *
1432  *         CPU-A                                    CPU-B
1433  *                                              rcu_read_lock()
1434  *         memcg->moving_account+1              if (memcg->mocing_account)
1435  *                                                   take heavy locks.
1436  *         synchronize_rcu()                    update something.
1437  *                                              rcu_read_unlock()
1438  *         start move here.
1439  */
1440
1441 /* for quick checking without looking up memcg */
1442 atomic_t memcg_moving __read_mostly;
1443
1444 static void mem_cgroup_start_move(struct mem_cgroup *memcg)
1445 {
1446         atomic_inc(&memcg_moving);
1447         atomic_inc(&memcg->moving_account);
1448         synchronize_rcu();
1449 }
1450
1451 static void mem_cgroup_end_move(struct mem_cgroup *memcg)
1452 {
1453         /*
1454          * Now, mem_cgroup_clear_mc() may call this function with NULL.
1455          * We check NULL in callee rather than caller.
1456          */
1457         if (memcg) {
1458                 atomic_dec(&memcg_moving);
1459                 atomic_dec(&memcg->moving_account);
1460         }
1461 }
1462
1463 /*
1464  * 2 routines for checking "mem" is under move_account() or not.
1465  *
1466  * mem_cgroup_stolen() -  checking whether a cgroup is mc.from or not. This
1467  *                        is used for avoiding races in accounting.  If true,
1468  *                        pc->mem_cgroup may be overwritten.
1469  *
1470  * mem_cgroup_under_move() - checking a cgroup is mc.from or mc.to or
1471  *                        under hierarchy of moving cgroups. This is for
1472  *                        waiting at hith-memory prressure caused by "move".
1473  */
1474
1475 static bool mem_cgroup_stolen(struct mem_cgroup *memcg)
1476 {
1477         VM_BUG_ON(!rcu_read_lock_held());
1478         return atomic_read(&memcg->moving_account) > 0;
1479 }
1480
1481 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1482 {
1483         struct mem_cgroup *from;
1484         struct mem_cgroup *to;
1485         bool ret = false;
1486         /*
1487          * Unlike task_move routines, we access mc.to, mc.from not under
1488          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1489          */
1490         spin_lock(&mc.lock);
1491         from = mc.from;
1492         to = mc.to;
1493         if (!from)
1494                 goto unlock;
1495
1496         ret = mem_cgroup_same_or_subtree(memcg, from)
1497                 || mem_cgroup_same_or_subtree(memcg, to);
1498 unlock:
1499         spin_unlock(&mc.lock);
1500         return ret;
1501 }
1502
1503 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1504 {
1505         if (mc.moving_task && current != mc.moving_task) {
1506                 if (mem_cgroup_under_move(memcg)) {
1507                         DEFINE_WAIT(wait);
1508                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1509                         /* moving charge context might have finished. */
1510                         if (mc.moving_task)
1511                                 schedule();
1512                         finish_wait(&mc.waitq, &wait);
1513                         return true;
1514                 }
1515         }
1516         return false;
1517 }
1518
1519 /*
1520  * Take this lock when
1521  * - a code tries to modify page's memcg while it's USED.
1522  * - a code tries to modify page state accounting in a memcg.
1523  * see mem_cgroup_stolen(), too.
1524  */
1525 static void move_lock_mem_cgroup(struct mem_cgroup *memcg,
1526                                   unsigned long *flags)
1527 {
1528         spin_lock_irqsave(&memcg->move_lock, *flags);
1529 }
1530
1531 static void move_unlock_mem_cgroup(struct mem_cgroup *memcg,
1532                                 unsigned long *flags)
1533 {
1534         spin_unlock_irqrestore(&memcg->move_lock, *flags);
1535 }
1536
1537 #define K(x) ((x) << (PAGE_SHIFT-10))
1538 /**
1539  * mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.
1540  * @memcg: The memory cgroup that went over limit
1541  * @p: Task that is going to be killed
1542  *
1543  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1544  * enabled
1545  */
1546 void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
1547 {
1548         struct cgroup *task_cgrp;
1549         struct cgroup *mem_cgrp;
1550         /*
1551          * Need a buffer in BSS, can't rely on allocations. The code relies
1552          * on the assumption that OOM is serialized for memory controller.
1553          * If this assumption is broken, revisit this code.
1554          */
1555         static char memcg_name[PATH_MAX];
1556         int ret;
1557         struct mem_cgroup *iter;
1558         unsigned int i;
1559
1560         if (!p)
1561                 return;
1562
1563         rcu_read_lock();
1564
1565         mem_cgrp = memcg->css.cgroup;
1566         task_cgrp = task_cgroup(p, mem_cgroup_subsys_id);
1567
1568         ret = cgroup_path(task_cgrp, memcg_name, PATH_MAX);
1569         if (ret < 0) {
1570                 /*
1571                  * Unfortunately, we are unable to convert to a useful name
1572                  * But we'll still print out the usage information
1573                  */
1574                 rcu_read_unlock();
1575                 goto done;
1576         }
1577         rcu_read_unlock();
1578
1579         pr_info("Task in %s killed", memcg_name);
1580
1581         rcu_read_lock();
1582         ret = cgroup_path(mem_cgrp, memcg_name, PATH_MAX);
1583         if (ret < 0) {
1584                 rcu_read_unlock();
1585                 goto done;
1586         }
1587         rcu_read_unlock();
1588
1589         /*
1590          * Continues from above, so we don't need an KERN_ level
1591          */
1592         pr_cont(" as a result of limit of %s\n", memcg_name);
1593 done:
1594
1595         pr_info("memory: usage %llukB, limit %llukB, failcnt %llu\n",
1596                 res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
1597                 res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,
1598                 res_counter_read_u64(&memcg->res, RES_FAILCNT));
1599         pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %llu\n",
1600                 res_counter_read_u64(&memcg->memsw, RES_USAGE) >> 10,
1601                 res_counter_read_u64(&memcg->memsw, RES_LIMIT) >> 10,
1602                 res_counter_read_u64(&memcg->memsw, RES_FAILCNT));
1603         pr_info("kmem: usage %llukB, limit %llukB, failcnt %llu\n",
1604                 res_counter_read_u64(&memcg->kmem, RES_USAGE) >> 10,
1605                 res_counter_read_u64(&memcg->kmem, RES_LIMIT) >> 10,
1606                 res_counter_read_u64(&memcg->kmem, RES_FAILCNT));
1607
1608         for_each_mem_cgroup_tree(iter, memcg) {
1609                 pr_info("Memory cgroup stats");
1610
1611                 rcu_read_lock();
1612                 ret = cgroup_path(iter->css.cgroup, memcg_name, PATH_MAX);
1613                 if (!ret)
1614                         pr_cont(" for %s", memcg_name);
1615                 rcu_read_unlock();
1616                 pr_cont(":");
1617
1618                 for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
1619                         if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
1620                                 continue;
1621                         pr_cont(" %s:%ldKB", mem_cgroup_stat_names[i],
1622                                 K(mem_cgroup_read_stat(iter, i)));
1623                 }
1624
1625                 for (i = 0; i < NR_LRU_LISTS; i++)
1626                         pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
1627                                 K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
1628
1629                 pr_cont("\n");
1630         }
1631 }
1632
1633 /*
1634  * This function returns the number of memcg under hierarchy tree. Returns
1635  * 1(self count) if no children.
1636  */
1637 static int mem_cgroup_count_children(struct mem_cgroup *memcg)
1638 {
1639         int num = 0;
1640         struct mem_cgroup *iter;
1641
1642         for_each_mem_cgroup_tree(iter, memcg)
1643                 num++;
1644         return num;
1645 }
1646
1647 /*
1648  * Return the memory (and swap, if configured) limit for a memcg.
1649  */
1650 static u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)
1651 {
1652         u64 limit;
1653
1654         limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
1655
1656         /*
1657          * Do not consider swap space if we cannot swap due to swappiness
1658          */
1659         if (mem_cgroup_swappiness(memcg)) {
1660                 u64 memsw;
1661
1662                 limit += total_swap_pages << PAGE_SHIFT;
1663                 memsw = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1664
1665                 /*
1666                  * If memsw is finite and limits the amount of swap space
1667                  * available to this memcg, return that limit.
1668                  */
1669                 limit = min(limit, memsw);
1670         }
1671
1672         return limit;
1673 }
1674
1675 static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1676                                      int order)
1677 {
1678         struct mem_cgroup *iter;
1679         unsigned long chosen_points = 0;
1680         unsigned long totalpages;
1681         unsigned int points = 0;
1682         struct task_struct *chosen = NULL;
1683
1684         /*
1685          * If current has a pending SIGKILL or is exiting, then automatically
1686          * select it.  The goal is to allow it to allocate so that it may
1687          * quickly exit and free its memory.
1688          */
1689         if (fatal_signal_pending(current) || current->flags & PF_EXITING) {
1690                 set_thread_flag(TIF_MEMDIE);
1691                 return;
1692         }
1693
1694         check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
1695         totalpages = mem_cgroup_get_limit(memcg) >> PAGE_SHIFT ? : 1;
1696         for_each_mem_cgroup_tree(iter, memcg) {
1697                 struct css_task_iter it;
1698                 struct task_struct *task;
1699
1700                 css_task_iter_start(&iter->css, &it);
1701                 while ((task = css_task_iter_next(&it))) {
1702                         switch (oom_scan_process_thread(task, totalpages, NULL,
1703                                                         false)) {
1704                         case OOM_SCAN_SELECT:
1705                                 if (chosen)
1706                                         put_task_struct(chosen);
1707                                 chosen = task;
1708                                 chosen_points = ULONG_MAX;
1709                                 get_task_struct(chosen);
1710                                 /* fall through */
1711                         case OOM_SCAN_CONTINUE:
1712                                 continue;
1713                         case OOM_SCAN_ABORT:
1714                                 css_task_iter_end(&it);
1715                                 mem_cgroup_iter_break(memcg, iter);
1716                                 if (chosen)
1717                                         put_task_struct(chosen);
1718                                 return;
1719                         case OOM_SCAN_OK:
1720                                 break;
1721                         };
1722                         points = oom_badness(task, memcg, NULL, totalpages);
1723                         if (points > chosen_points) {
1724                                 if (chosen)
1725                                         put_task_struct(chosen);
1726                                 chosen = task;
1727                                 chosen_points = points;
1728                                 get_task_struct(chosen);
1729                         }
1730                 }
1731                 css_task_iter_end(&it);
1732         }
1733
1734         if (!chosen)
1735                 return;
1736         points = chosen_points * 1000 / totalpages;
1737         oom_kill_process(chosen, gfp_mask, order, points, totalpages, memcg,
1738                          NULL, "Memory cgroup out of memory");
1739 }
1740
1741 static unsigned long mem_cgroup_reclaim(struct mem_cgroup *memcg,
1742                                         gfp_t gfp_mask,
1743                                         unsigned long flags)
1744 {
1745         unsigned long total = 0;
1746         bool noswap = false;
1747         int loop;
1748
1749         if (flags & MEM_CGROUP_RECLAIM_NOSWAP)
1750                 noswap = true;
1751         if (!(flags & MEM_CGROUP_RECLAIM_SHRINK) && memcg->memsw_is_minimum)
1752                 noswap = true;
1753
1754         for (loop = 0; loop < MEM_CGROUP_MAX_RECLAIM_LOOPS; loop++) {
1755                 if (loop)
1756                         drain_all_stock_async(memcg);
1757                 total += try_to_free_mem_cgroup_pages(memcg, gfp_mask, noswap);
1758                 /*
1759                  * Allow limit shrinkers, which are triggered directly
1760                  * by userspace, to catch signals and stop reclaim
1761                  * after minimal progress, regardless of the margin.
1762                  */
1763                 if (total && (flags & MEM_CGROUP_RECLAIM_SHRINK))
1764                         break;
1765                 if (mem_cgroup_margin(memcg))
1766                         break;
1767                 /*
1768                  * If nothing was reclaimed after two attempts, there
1769                  * may be no reclaimable pages in this hierarchy.
1770                  */
1771                 if (loop && !total)
1772                         break;
1773         }
1774         return total;
1775 }
1776
1777 #if MAX_NUMNODES > 1
1778 /**
1779  * test_mem_cgroup_node_reclaimable
1780  * @memcg: the target memcg
1781  * @nid: the node ID to be checked.
1782  * @noswap : specify true here if the user wants flle only information.
1783  *
1784  * This function returns whether the specified memcg contains any
1785  * reclaimable pages on a node. Returns true if there are any reclaimable
1786  * pages in the node.
1787  */
1788 static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
1789                 int nid, bool noswap)
1790 {
1791         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))
1792                 return true;
1793         if (noswap || !total_swap_pages)
1794                 return false;
1795         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))
1796                 return true;
1797         return false;
1798
1799 }
1800
1801 /*
1802  * Always updating the nodemask is not very good - even if we have an empty
1803  * list or the wrong list here, we can start from some node and traverse all
1804  * nodes based on the zonelist. So update the list loosely once per 10 secs.
1805  *
1806  */
1807 static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
1808 {
1809         int nid;
1810         /*
1811          * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
1812          * pagein/pageout changes since the last update.
1813          */
1814         if (!atomic_read(&memcg->numainfo_events))
1815                 return;
1816         if (atomic_inc_return(&memcg->numainfo_updating) > 1)
1817                 return;
1818
1819         /* make a nodemask where this memcg uses memory from */
1820         memcg->scan_nodes = node_states[N_MEMORY];
1821
1822         for_each_node_mask(nid, node_states[N_MEMORY]) {
1823
1824                 if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
1825                         node_clear(nid, memcg->scan_nodes);
1826         }
1827
1828         atomic_set(&memcg->numainfo_events, 0);
1829         atomic_set(&memcg->numainfo_updating, 0);
1830 }
1831
1832 /*
1833  * Selecting a node where we start reclaim from. Because what we need is just
1834  * reducing usage counter, start from anywhere is O,K. Considering
1835  * memory reclaim from current node, there are pros. and cons.
1836  *
1837  * Freeing memory from current node means freeing memory from a node which
1838  * we'll use or we've used. So, it may make LRU bad. And if several threads
1839  * hit limits, it will see a contention on a node. But freeing from remote
1840  * node means more costs for memory reclaim because of memory latency.
1841  *
1842  * Now, we use round-robin. Better algorithm is welcomed.
1843  */
1844 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1845 {
1846         int node;
1847
1848         mem_cgroup_may_update_nodemask(memcg);
1849         node = memcg->last_scanned_node;
1850
1851         node = next_node(node, memcg->scan_nodes);
1852         if (node == MAX_NUMNODES)
1853                 node = first_node(memcg->scan_nodes);
1854         /*
1855          * We call this when we hit limit, not when pages are added to LRU.
1856          * No LRU may hold pages because all pages are UNEVICTABLE or
1857          * memcg is too small and all pages are not on LRU. In that case,
1858          * we use curret node.
1859          */
1860         if (unlikely(node == MAX_NUMNODES))
1861                 node = numa_node_id();
1862
1863         memcg->last_scanned_node = node;
1864         return node;
1865 }
1866
1867 #else
1868 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1869 {
1870         return 0;
1871 }
1872
1873 #endif
1874
1875 /*
1876  * A group is eligible for the soft limit reclaim under the given root
1877  * hierarchy if
1878  *      a) it is over its soft limit
1879  *      b) any parent up the hierarchy is over its soft limit
1880  *
1881  * If the given group doesn't have any children over the limit then it
1882  * doesn't make any sense to iterate its subtree.
1883  */
1884 enum mem_cgroup_filter_t
1885 mem_cgroup_soft_reclaim_eligible(struct mem_cgroup *memcg,
1886                 struct mem_cgroup *root)
1887 {
1888         struct mem_cgroup *parent = memcg;
1889
1890         if (res_counter_soft_limit_excess(&memcg->res))
1891                 return VISIT;
1892
1893         /*
1894          * If any parent up to the root in the hierarchy is over its soft limit
1895          * then we have to obey and reclaim from this group as well.
1896          */
1897         while((parent = parent_mem_cgroup(parent))) {
1898                 if (res_counter_soft_limit_excess(&parent->res))
1899                         return VISIT;
1900                 if (parent == root)
1901                         break;
1902         }
1903
1904         if (!atomic_read(&memcg->children_in_excess))
1905                 return SKIP_TREE;
1906         return SKIP;
1907 }
1908
1909 /*
1910  * Check OOM-Killer is already running under our hierarchy.
1911  * If someone is running, return false.
1912  * Has to be called with memcg_oom_lock
1913  */
1914 static bool mem_cgroup_oom_lock(struct mem_cgroup *memcg)
1915 {
1916         struct mem_cgroup *iter, *failed = NULL;
1917
1918         for_each_mem_cgroup_tree(iter, memcg) {
1919                 if (iter->oom_lock) {
1920                         /*
1921                          * this subtree of our hierarchy is already locked
1922                          * so we cannot give a lock.
1923                          */
1924                         failed = iter;
1925                         mem_cgroup_iter_break(memcg, iter);
1926                         break;
1927                 } else
1928                         iter->oom_lock = true;
1929         }
1930
1931         if (!failed)
1932                 return true;
1933
1934         /*
1935          * OK, we failed to lock the whole subtree so we have to clean up
1936          * what we set up to the failing subtree
1937          */
1938         for_each_mem_cgroup_tree(iter, memcg) {
1939                 if (iter == failed) {
1940                         mem_cgroup_iter_break(memcg, iter);
1941                         break;
1942                 }
1943                 iter->oom_lock = false;
1944         }
1945         return false;
1946 }
1947
1948 /*
1949  * Has to be called with memcg_oom_lock
1950  */
1951 static int mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1952 {
1953         struct mem_cgroup *iter;
1954
1955         for_each_mem_cgroup_tree(iter, memcg)
1956                 iter->oom_lock = false;
1957         return 0;
1958 }
1959
1960 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1961 {
1962         struct mem_cgroup *iter;
1963
1964         for_each_mem_cgroup_tree(iter, memcg)
1965                 atomic_inc(&iter->under_oom);
1966 }
1967
1968 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1969 {
1970         struct mem_cgroup *iter;
1971
1972         /*
1973          * When a new child is created while the hierarchy is under oom,
1974          * mem_cgroup_oom_lock() may not be called. We have to use
1975          * atomic_add_unless() here.
1976          */
1977         for_each_mem_cgroup_tree(iter, memcg)
1978                 atomic_add_unless(&iter->under_oom, -1, 0);
1979 }
1980
1981 static DEFINE_SPINLOCK(memcg_oom_lock);
1982 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1983
1984 struct oom_wait_info {
1985         struct mem_cgroup *memcg;
1986         wait_queue_t    wait;
1987 };
1988
1989 static int memcg_oom_wake_function(wait_queue_t *wait,
1990         unsigned mode, int sync, void *arg)
1991 {
1992         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1993         struct mem_cgroup *oom_wait_memcg;
1994         struct oom_wait_info *oom_wait_info;
1995
1996         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1997         oom_wait_memcg = oom_wait_info->memcg;
1998
1999         /*
2000          * Both of oom_wait_info->memcg and wake_memcg are stable under us.
2001          * Then we can use css_is_ancestor without taking care of RCU.
2002          */
2003         if (!mem_cgroup_same_or_subtree(oom_wait_memcg, wake_memcg)
2004                 && !mem_cgroup_same_or_subtree(wake_memcg, oom_wait_memcg))
2005                 return 0;
2006         return autoremove_wake_function(wait, mode, sync, arg);
2007 }
2008
2009 static void memcg_wakeup_oom(struct mem_cgroup *memcg)
2010 {
2011         /* for filtering, pass "memcg" as argument. */
2012         __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
2013 }
2014
2015 static void memcg_oom_recover(struct mem_cgroup *memcg)
2016 {
2017         if (memcg && atomic_read(&memcg->under_oom))
2018                 memcg_wakeup_oom(memcg);
2019 }
2020
2021 /*
2022  * try to call OOM killer. returns false if we should exit memory-reclaim loop.
2023  */
2024 static bool mem_cgroup_handle_oom(struct mem_cgroup *memcg, gfp_t mask,
2025                                   int order)
2026 {
2027         struct oom_wait_info owait;
2028         bool locked, need_to_kill;
2029
2030         owait.memcg = memcg;
2031         owait.wait.flags = 0;
2032         owait.wait.func = memcg_oom_wake_function;
2033         owait.wait.private = current;
2034         INIT_LIST_HEAD(&owait.wait.task_list);
2035         need_to_kill = true;
2036         mem_cgroup_mark_under_oom(memcg);
2037
2038         /* At first, try to OOM lock hierarchy under memcg.*/
2039         spin_lock(&memcg_oom_lock);
2040         locked = mem_cgroup_oom_lock(memcg);
2041         /*
2042          * Even if signal_pending(), we can't quit charge() loop without
2043          * accounting. So, UNINTERRUPTIBLE is appropriate. But SIGKILL
2044          * under OOM is always welcomed, use TASK_KILLABLE here.
2045          */
2046         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
2047         if (!locked || memcg->oom_kill_disable)
2048                 need_to_kill = false;
2049         if (locked)
2050                 mem_cgroup_oom_notify(memcg);
2051         spin_unlock(&memcg_oom_lock);
2052
2053         if (need_to_kill) {
2054                 finish_wait(&memcg_oom_waitq, &owait.wait);
2055                 mem_cgroup_out_of_memory(memcg, mask, order);
2056         } else {
2057                 schedule();
2058                 finish_wait(&memcg_oom_waitq, &owait.wait);
2059         }
2060         spin_lock(&memcg_oom_lock);
2061         if (locked)
2062                 mem_cgroup_oom_unlock(memcg);
2063         memcg_wakeup_oom(memcg);
2064         spin_unlock(&memcg_oom_lock);
2065
2066         mem_cgroup_unmark_under_oom(memcg);
2067
2068         if (test_thread_flag(TIF_MEMDIE) || fatal_signal_pending(current))
2069                 return false;
2070         /* Give chance to dying process */
2071         schedule_timeout_uninterruptible(1);
2072         return true;
2073 }
2074
2075 /*
2076  * Currently used to update mapped file statistics, but the routine can be
2077  * generalized to update other statistics as well.
2078  *
2079  * Notes: Race condition
2080  *
2081  * We usually use page_cgroup_lock() for accessing page_cgroup member but
2082  * it tends to be costly. But considering some conditions, we doesn't need
2083  * to do so _always_.
2084  *
2085  * Considering "charge", lock_page_cgroup() is not required because all
2086  * file-stat operations happen after a page is attached to radix-tree. There
2087  * are no race with "charge".
2088  *
2089  * Considering "uncharge", we know that memcg doesn't clear pc->mem_cgroup
2090  * at "uncharge" intentionally. So, we always see valid pc->mem_cgroup even
2091  * if there are race with "uncharge". Statistics itself is properly handled
2092  * by flags.
2093  *
2094  * Considering "move", this is an only case we see a race. To make the race
2095  * small, we check mm->moving_account and detect there are possibility of race
2096  * If there is, we take a lock.
2097  */
2098
2099 void __mem_cgroup_begin_update_page_stat(struct page *page,
2100                                 bool *locked, unsigned long *flags)
2101 {
2102         struct mem_cgroup *memcg;
2103         struct page_cgroup *pc;
2104
2105         pc = lookup_page_cgroup(page);
2106 again:
2107         memcg = pc->mem_cgroup;
2108         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2109                 return;
2110         /*
2111          * If this memory cgroup is not under account moving, we don't
2112          * need to take move_lock_mem_cgroup(). Because we already hold
2113          * rcu_read_lock(), any calls to move_account will be delayed until
2114          * rcu_read_unlock() if mem_cgroup_stolen() == true.
2115          */
2116         if (!mem_cgroup_stolen(memcg))
2117                 return;
2118
2119         move_lock_mem_cgroup(memcg, flags);
2120         if (memcg != pc->mem_cgroup || !PageCgroupUsed(pc)) {
2121                 move_unlock_mem_cgroup(memcg, flags);
2122                 goto again;
2123         }
2124         *locked = true;
2125 }
2126
2127 void __mem_cgroup_end_update_page_stat(struct page *page, unsigned long *flags)
2128 {
2129         struct page_cgroup *pc = lookup_page_cgroup(page);
2130
2131         /*
2132          * It's guaranteed that pc->mem_cgroup never changes while
2133          * lock is held because a routine modifies pc->mem_cgroup
2134          * should take move_lock_mem_cgroup().
2135          */
2136         move_unlock_mem_cgroup(pc->mem_cgroup, flags);
2137 }
2138
2139 void mem_cgroup_update_page_stat(struct page *page,
2140                                  enum mem_cgroup_page_stat_item idx, int val)
2141 {
2142         struct mem_cgroup *memcg;
2143         struct page_cgroup *pc = lookup_page_cgroup(page);
2144         unsigned long uninitialized_var(flags);
2145
2146         if (mem_cgroup_disabled())
2147                 return;
2148
2149         memcg = pc->mem_cgroup;
2150         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2151                 return;
2152
2153         switch (idx) {
2154         case MEMCG_NR_FILE_MAPPED:
2155                 idx = MEM_CGROUP_STAT_FILE_MAPPED;
2156                 break;
2157         default:
2158                 BUG();
2159         }
2160
2161         this_cpu_add(memcg->stat->count[idx], val);
2162 }
2163
2164 /*
2165  * size of first charge trial. "32" comes from vmscan.c's magic value.
2166  * TODO: maybe necessary to use big numbers in big irons.
2167  */
2168 #define CHARGE_BATCH    32U
2169 struct memcg_stock_pcp {
2170         struct mem_cgroup *cached; /* this never be root cgroup */
2171         unsigned int nr_pages;
2172         struct work_struct work;
2173         unsigned long flags;
2174 #define FLUSHING_CACHED_CHARGE  0
2175 };
2176 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
2177 static DEFINE_MUTEX(percpu_charge_mutex);
2178
2179 /**
2180  * consume_stock: Try to consume stocked charge on this cpu.
2181  * @memcg: memcg to consume from.
2182  * @nr_pages: how many pages to charge.
2183  *
2184  * The charges will only happen if @memcg matches the current cpu's memcg
2185  * stock, and at least @nr_pages are available in that stock.  Failure to
2186  * service an allocation will refill the stock.
2187  *
2188  * returns true if successful, false otherwise.
2189  */
2190 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2191 {
2192         struct memcg_stock_pcp *stock;
2193         bool ret = true;
2194
2195         if (nr_pages > CHARGE_BATCH)
2196                 return false;
2197
2198         stock = &get_cpu_var(memcg_stock);
2199         if (memcg == stock->cached && stock->nr_pages >= nr_pages)
2200                 stock->nr_pages -= nr_pages;
2201         else /* need to call res_counter_charge */
2202                 ret = false;
2203         put_cpu_var(memcg_stock);
2204         return ret;
2205 }
2206
2207 /*
2208  * Returns stocks cached in percpu to res_counter and reset cached information.
2209  */
2210 static void drain_stock(struct memcg_stock_pcp *stock)
2211 {
2212         struct mem_cgroup *old = stock->cached;
2213
2214         if (stock->nr_pages) {
2215                 unsigned long bytes = stock->nr_pages * PAGE_SIZE;
2216
2217                 res_counter_uncharge(&old->res, bytes);
2218                 if (do_swap_account)
2219                         res_counter_uncharge(&old->memsw, bytes);
2220                 stock->nr_pages = 0;
2221         }
2222         stock->cached = NULL;
2223 }
2224
2225 /*
2226  * This must be called under preempt disabled or must be called by
2227  * a thread which is pinned to local cpu.
2228  */
2229 static void drain_local_stock(struct work_struct *dummy)
2230 {
2231         struct memcg_stock_pcp *stock = &__get_cpu_var(memcg_stock);
2232         drain_stock(stock);
2233         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2234 }
2235
2236 static void __init memcg_stock_init(void)
2237 {
2238         int cpu;
2239
2240         for_each_possible_cpu(cpu) {
2241                 struct memcg_stock_pcp *stock =
2242                                         &per_cpu(memcg_stock, cpu);
2243                 INIT_WORK(&stock->work, drain_local_stock);
2244         }
2245 }
2246
2247 /*
2248  * Cache charges(val) which is from res_counter, to local per_cpu area.
2249  * This will be consumed by consume_stock() function, later.
2250  */
2251 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2252 {
2253         struct memcg_stock_pcp *stock = &get_cpu_var(memcg_stock);
2254
2255         if (stock->cached != memcg) { /* reset if necessary */
2256                 drain_stock(stock);
2257                 stock->cached = memcg;
2258         }
2259         stock->nr_pages += nr_pages;
2260         put_cpu_var(memcg_stock);
2261 }
2262
2263 /*
2264  * Drains all per-CPU charge caches for given root_memcg resp. subtree
2265  * of the hierarchy under it. sync flag says whether we should block
2266  * until the work is done.
2267  */
2268 static void drain_all_stock(struct mem_cgroup *root_memcg, bool sync)
2269 {
2270         int cpu, curcpu;
2271
2272         /* Notify other cpus that system-wide "drain" is running */
2273         get_online_cpus();
2274         curcpu = get_cpu();
2275         for_each_online_cpu(cpu) {
2276                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2277                 struct mem_cgroup *memcg;
2278
2279                 memcg = stock->cached;
2280                 if (!memcg || !stock->nr_pages)
2281                         continue;
2282                 if (!mem_cgroup_same_or_subtree(root_memcg, memcg))
2283                         continue;
2284                 if (!test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2285                         if (cpu == curcpu)
2286                                 drain_local_stock(&stock->work);
2287                         else
2288                                 schedule_work_on(cpu, &stock->work);
2289                 }
2290         }
2291         put_cpu();
2292
2293         if (!sync)
2294                 goto out;
2295
2296         for_each_online_cpu(cpu) {
2297                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2298                 if (test_bit(FLUSHING_CACHED_CHARGE, &stock->flags))
2299                         flush_work(&stock->work);
2300         }
2301 out:
2302         put_online_cpus();
2303 }
2304
2305 /*
2306  * Tries to drain stocked charges in other cpus. This function is asynchronous
2307  * and just put a work per cpu for draining localy on each cpu. Caller can
2308  * expects some charges will be back to res_counter later but cannot wait for
2309  * it.
2310  */
2311 static void drain_all_stock_async(struct mem_cgroup *root_memcg)
2312 {
2313         /*
2314          * If someone calls draining, avoid adding more kworker runs.
2315          */
2316         if (!mutex_trylock(&percpu_charge_mutex))
2317                 return;
2318         drain_all_stock(root_memcg, false);
2319         mutex_unlock(&percpu_charge_mutex);
2320 }
2321
2322 /* This is a synchronous drain interface. */
2323 static void drain_all_stock_sync(struct mem_cgroup *root_memcg)
2324 {
2325         /* called when force_empty is called */
2326         mutex_lock(&percpu_charge_mutex);
2327         drain_all_stock(root_memcg, true);
2328         mutex_unlock(&percpu_charge_mutex);
2329 }
2330
2331 /*
2332  * This function drains percpu counter value from DEAD cpu and
2333  * move it to local cpu. Note that this function can be preempted.
2334  */
2335 static void mem_cgroup_drain_pcp_counter(struct mem_cgroup *memcg, int cpu)
2336 {
2337         int i;
2338
2339         spin_lock(&memcg->pcp_counter_lock);
2340         for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
2341                 long x = per_cpu(memcg->stat->count[i], cpu);
2342
2343                 per_cpu(memcg->stat->count[i], cpu) = 0;
2344                 memcg->nocpu_base.count[i] += x;
2345         }
2346         for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
2347                 unsigned long x = per_cpu(memcg->stat->events[i], cpu);
2348
2349                 per_cpu(memcg->stat->events[i], cpu) = 0;
2350                 memcg->nocpu_base.events[i] += x;
2351         }
2352         spin_unlock(&memcg->pcp_counter_lock);
2353 }
2354
2355 static int memcg_cpu_hotplug_callback(struct notifier_block *nb,
2356                                         unsigned long action,
2357                                         void *hcpu)
2358 {
2359         int cpu = (unsigned long)hcpu;
2360         struct memcg_stock_pcp *stock;
2361         struct mem_cgroup *iter;
2362
2363         if (action == CPU_ONLINE)
2364                 return NOTIFY_OK;
2365
2366         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
2367                 return NOTIFY_OK;
2368
2369         for_each_mem_cgroup(iter)
2370                 mem_cgroup_drain_pcp_counter(iter, cpu);
2371
2372         stock = &per_cpu(memcg_stock, cpu);
2373         drain_stock(stock);
2374         return NOTIFY_OK;
2375 }
2376
2377
2378 /* See __mem_cgroup_try_charge() for details */
2379 enum {
2380         CHARGE_OK,              /* success */
2381         CHARGE_RETRY,           /* need to retry but retry is not bad */
2382         CHARGE_NOMEM,           /* we can't do more. return -ENOMEM */
2383         CHARGE_WOULDBLOCK,      /* GFP_WAIT wasn't set and no enough res. */
2384         CHARGE_OOM_DIE,         /* the current is killed because of OOM */
2385 };
2386
2387 static int mem_cgroup_do_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2388                                 unsigned int nr_pages, unsigned int min_pages,
2389                                 bool oom_check)
2390 {
2391         unsigned long csize = nr_pages * PAGE_SIZE;
2392         struct mem_cgroup *mem_over_limit;
2393         struct res_counter *fail_res;
2394         unsigned long flags = 0;
2395         int ret;
2396
2397         ret = res_counter_charge(&memcg->res, csize, &fail_res);
2398
2399         if (likely(!ret)) {
2400                 if (!do_swap_account)
2401                         return CHARGE_OK;
2402                 ret = res_counter_charge(&memcg->memsw, csize, &fail_res);
2403                 if (likely(!ret))
2404                         return CHARGE_OK;
2405
2406                 res_counter_uncharge(&memcg->res, csize);
2407                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, memsw);
2408                 flags |= MEM_CGROUP_RECLAIM_NOSWAP;
2409         } else
2410                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, res);
2411         /*
2412          * Never reclaim on behalf of optional batching, retry with a
2413          * single page instead.
2414          */
2415         if (nr_pages > min_pages)
2416                 return CHARGE_RETRY;
2417
2418         if (!(gfp_mask & __GFP_WAIT))
2419                 return CHARGE_WOULDBLOCK;
2420
2421         if (gfp_mask & __GFP_NORETRY)
2422                 return CHARGE_NOMEM;
2423
2424         ret = mem_cgroup_reclaim(mem_over_limit, gfp_mask, flags);
2425         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2426                 return CHARGE_RETRY;
2427         /*
2428          * Even though the limit is exceeded at this point, reclaim
2429          * may have been able to free some pages.  Retry the charge
2430          * before killing the task.
2431          *
2432          * Only for regular pages, though: huge pages are rather
2433          * unlikely to succeed so close to the limit, and we fall back
2434          * to regular pages anyway in case of failure.
2435          */
2436         if (nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER) && ret)
2437                 return CHARGE_RETRY;
2438
2439         /*
2440          * At task move, charge accounts can be doubly counted. So, it's
2441          * better to wait until the end of task_move if something is going on.
2442          */
2443         if (mem_cgroup_wait_acct_move(mem_over_limit))
2444                 return CHARGE_RETRY;
2445
2446         /* If we don't need to call oom-killer at el, return immediately */
2447         if (!oom_check)
2448                 return CHARGE_NOMEM;
2449         /* check OOM */
2450         if (!mem_cgroup_handle_oom(mem_over_limit, gfp_mask, get_order(csize)))
2451                 return CHARGE_OOM_DIE;
2452
2453         return CHARGE_RETRY;
2454 }
2455
2456 /*
2457  * __mem_cgroup_try_charge() does
2458  * 1. detect memcg to be charged against from passed *mm and *ptr,
2459  * 2. update res_counter
2460  * 3. call memory reclaim if necessary.
2461  *
2462  * In some special case, if the task is fatal, fatal_signal_pending() or
2463  * has TIF_MEMDIE, this function returns -EINTR while writing root_mem_cgroup
2464  * to *ptr. There are two reasons for this. 1: fatal threads should quit as soon
2465  * as possible without any hazards. 2: all pages should have a valid
2466  * pc->mem_cgroup. If mm is NULL and the caller doesn't pass a valid memcg
2467  * pointer, that is treated as a charge to root_mem_cgroup.
2468  *
2469  * So __mem_cgroup_try_charge() will return
2470  *  0       ...  on success, filling *ptr with a valid memcg pointer.
2471  *  -ENOMEM ...  charge failure because of resource limits.
2472  *  -EINTR  ...  if thread is fatal. *ptr is filled with root_mem_cgroup.
2473  *
2474  * Unlike the exported interface, an "oom" parameter is added. if oom==true,
2475  * the oom-killer can be invoked.
2476  */
2477 static int __mem_cgroup_try_charge(struct mm_struct *mm,
2478                                    gfp_t gfp_mask,
2479                                    unsigned int nr_pages,
2480                                    struct mem_cgroup **ptr,
2481                                    bool oom)
2482 {
2483         unsigned int batch = max(CHARGE_BATCH, nr_pages);
2484         int nr_oom_retries = MEM_CGROUP_RECLAIM_RETRIES;
2485         struct mem_cgroup *memcg = NULL;
2486         int ret;
2487
2488         /*
2489          * Unlike gloval-vm's OOM-kill, we're not in memory shortage
2490          * in system level. So, allow to go ahead dying process in addition to
2491          * MEMDIE process.
2492          */
2493         if (unlikely(test_thread_flag(TIF_MEMDIE)
2494                      || fatal_signal_pending(current)))
2495                 goto bypass;
2496
2497         /*
2498          * We always charge the cgroup the mm_struct belongs to.
2499          * The mm_struct's mem_cgroup changes on task migration if the
2500          * thread group leader migrates. It's possible that mm is not
2501          * set, if so charge the root memcg (happens for pagecache usage).
2502          */
2503         if (!*ptr && !mm)
2504                 *ptr = root_mem_cgroup;
2505 again:
2506         if (*ptr) { /* css should be a valid one */
2507                 memcg = *ptr;
2508                 if (mem_cgroup_is_root(memcg))
2509                         goto done;
2510                 if (consume_stock(memcg, nr_pages))
2511                         goto done;
2512                 css_get(&memcg->css);
2513         } else {
2514                 struct task_struct *p;
2515
2516                 rcu_read_lock();
2517                 p = rcu_dereference(mm->owner);
2518                 /*
2519                  * Because we don't have task_lock(), "p" can exit.
2520                  * In that case, "memcg" can point to root or p can be NULL with
2521                  * race with swapoff. Then, we have small risk of mis-accouning.
2522                  * But such kind of mis-account by race always happens because
2523                  * we don't have cgroup_mutex(). It's overkill and we allo that
2524                  * small race, here.
2525                  * (*) swapoff at el will charge against mm-struct not against
2526                  * task-struct. So, mm->owner can be NULL.
2527                  */
2528                 memcg = mem_cgroup_from_task(p);
2529                 if (!memcg)
2530                         memcg = root_mem_cgroup;
2531                 if (mem_cgroup_is_root(memcg)) {
2532                         rcu_read_unlock();
2533                         goto done;
2534                 }
2535                 if (consume_stock(memcg, nr_pages)) {
2536                         /*
2537                          * It seems dagerous to access memcg without css_get().
2538                          * But considering how consume_stok works, it's not
2539                          * necessary. If consume_stock success, some charges
2540                          * from this memcg are cached on this cpu. So, we
2541                          * don't need to call css_get()/css_tryget() before
2542                          * calling consume_stock().
2543                          */
2544                         rcu_read_unlock();
2545                         goto done;
2546                 }
2547                 /* after here, we may be blocked. we need to get refcnt */
2548                 if (!css_tryget(&memcg->css)) {
2549                         rcu_read_unlock();
2550                         goto again;
2551                 }
2552                 rcu_read_unlock();
2553         }
2554
2555         do {
2556                 bool oom_check;
2557
2558                 /* If killed, bypass charge */
2559                 if (fatal_signal_pending(current)) {
2560                         css_put(&memcg->css);
2561                         goto bypass;
2562                 }
2563
2564                 oom_check = false;
2565                 if (oom && !nr_oom_retries) {
2566                         oom_check = true;
2567                         nr_oom_retries = MEM_CGROUP_RECLAIM_RETRIES;
2568                 }
2569
2570                 ret = mem_cgroup_do_charge(memcg, gfp_mask, batch, nr_pages,
2571                     oom_check);
2572                 switch (ret) {
2573                 case CHARGE_OK:
2574                         break;
2575                 case CHARGE_RETRY: /* not in OOM situation but retry */
2576                         batch = nr_pages;
2577                         css_put(&memcg->css);
2578                         memcg = NULL;
2579                         goto again;
2580                 case CHARGE_WOULDBLOCK: /* !__GFP_WAIT */
2581                         css_put(&memcg->css);
2582                         goto nomem;
2583                 case CHARGE_NOMEM: /* OOM routine works */
2584                         if (!oom) {
2585                                 css_put(&memcg->css);
2586                                 goto nomem;
2587                         }
2588                         /* If oom, we never return -ENOMEM */
2589                         nr_oom_retries--;
2590                         break;
2591                 case CHARGE_OOM_DIE: /* Killed by OOM Killer */
2592                         css_put(&memcg->css);
2593                         goto bypass;
2594                 }
2595         } while (ret != CHARGE_OK);
2596
2597         if (batch > nr_pages)
2598                 refill_stock(memcg, batch - nr_pages);
2599         css_put(&memcg->css);
2600 done:
2601         *ptr = memcg;
2602         return 0;
2603 nomem:
2604         *ptr = NULL;
2605         return -ENOMEM;
2606 bypass:
2607         *ptr = root_mem_cgroup;
2608         return -EINTR;
2609 }
2610
2611 /*
2612  * Somemtimes we have to undo a charge we got by try_charge().
2613  * This function is for that and do uncharge, put css's refcnt.
2614  * gotten by try_charge().
2615  */
2616 static void __mem_cgroup_cancel_charge(struct mem_cgroup *memcg,
2617                                        unsigned int nr_pages)
2618 {
2619         if (!mem_cgroup_is_root(memcg)) {
2620                 unsigned long bytes = nr_pages * PAGE_SIZE;
2621
2622                 res_counter_uncharge(&memcg->res, bytes);
2623                 if (do_swap_account)
2624                         res_counter_uncharge(&memcg->memsw, bytes);
2625         }
2626 }
2627
2628 /*
2629  * Cancel chrages in this cgroup....doesn't propagate to parent cgroup.
2630  * This is useful when moving usage to parent cgroup.
2631  */
2632 static void __mem_cgroup_cancel_local_charge(struct mem_cgroup *memcg,
2633                                         unsigned int nr_pages)
2634 {
2635         unsigned long bytes = nr_pages * PAGE_SIZE;
2636
2637         if (mem_cgroup_is_root(memcg))
2638                 return;
2639
2640         res_counter_uncharge_until(&memcg->res, memcg->res.parent, bytes);
2641         if (do_swap_account)
2642                 res_counter_uncharge_until(&memcg->memsw,
2643                                                 memcg->memsw.parent, bytes);
2644 }
2645
2646 /*
2647  * A helper function to get mem_cgroup from ID. must be called under
2648  * rcu_read_lock().  The caller is responsible for calling css_tryget if
2649  * the mem_cgroup is used for charging. (dropping refcnt from swap can be
2650  * called against removed memcg.)
2651  */
2652 static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
2653 {
2654         struct cgroup_subsys_state *css;
2655
2656         /* ID 0 is unused ID */
2657         if (!id)
2658                 return NULL;
2659         css = css_lookup(&mem_cgroup_subsys, id);
2660         if (!css)
2661                 return NULL;
2662         return mem_cgroup_from_css(css);
2663 }
2664
2665 struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
2666 {
2667         struct mem_cgroup *memcg = NULL;
2668         struct page_cgroup *pc;
2669         unsigned short id;
2670         swp_entry_t ent;
2671
2672         VM_BUG_ON(!PageLocked(page));
2673
2674         pc = lookup_page_cgroup(page);
2675         lock_page_cgroup(pc);
2676         if (PageCgroupUsed(pc)) {
2677                 memcg = pc->mem_cgroup;
2678                 if (memcg && !css_tryget(&memcg->css))
2679                         memcg = NULL;
2680         } else if (PageSwapCache(page)) {
2681                 ent.val = page_private(page);
2682                 id = lookup_swap_cgroup_id(ent);
2683                 rcu_read_lock();
2684                 memcg = mem_cgroup_lookup(id);
2685                 if (memcg && !css_tryget(&memcg->css))
2686                         memcg = NULL;
2687                 rcu_read_unlock();
2688         }
2689         unlock_page_cgroup(pc);
2690         return memcg;
2691 }
2692
2693 static void __mem_cgroup_commit_charge(struct mem_cgroup *memcg,
2694                                        struct page *page,
2695                                        unsigned int nr_pages,
2696                                        enum charge_type ctype,
2697                                        bool lrucare)
2698 {
2699         struct page_cgroup *pc = lookup_page_cgroup(page);
2700         struct zone *uninitialized_var(zone);
2701         struct lruvec *lruvec;
2702         bool was_on_lru = false;
2703         bool anon;
2704
2705         lock_page_cgroup(pc);
2706         VM_BUG_ON(PageCgroupUsed(pc));
2707         /*
2708          * we don't need page_cgroup_lock about tail pages, becase they are not
2709          * accessed by any other context at this point.
2710          */
2711
2712         /*
2713          * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2714          * may already be on some other mem_cgroup's LRU.  Take care of it.
2715          */
2716         if (lrucare) {
2717                 zone = page_zone(page);
2718                 spin_lock_irq(&zone->lru_lock);
2719                 if (PageLRU(page)) {
2720                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2721                         ClearPageLRU(page);
2722                         del_page_from_lru_list(page, lruvec, page_lru(page));
2723                         was_on_lru = true;
2724                 }
2725         }
2726
2727         pc->mem_cgroup = memcg;
2728         /*
2729          * We access a page_cgroup asynchronously without lock_page_cgroup().
2730          * Especially when a page_cgroup is taken from a page, pc->mem_cgroup
2731          * is accessed after testing USED bit. To make pc->mem_cgroup visible
2732          * before USED bit, we need memory barrier here.
2733          * See mem_cgroup_add_lru_list(), etc.
2734          */
2735         smp_wmb();
2736         SetPageCgroupUsed(pc);
2737
2738         if (lrucare) {
2739                 if (was_on_lru) {
2740                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2741                         VM_BUG_ON(PageLRU(page));
2742                         SetPageLRU(page);
2743                         add_page_to_lru_list(page, lruvec, page_lru(page));
2744                 }
2745                 spin_unlock_irq(&zone->lru_lock);
2746         }
2747
2748         if (ctype == MEM_CGROUP_CHARGE_TYPE_ANON)
2749                 anon = true;
2750         else
2751                 anon = false;
2752
2753         mem_cgroup_charge_statistics(memcg, page, anon, nr_pages);
2754         unlock_page_cgroup(pc);
2755
2756         /*
2757          * "charge_statistics" updated event counter.
2758          */
2759         memcg_check_events(memcg, page);
2760 }
2761
2762 static DEFINE_MUTEX(set_limit_mutex);
2763
2764 #ifdef CONFIG_MEMCG_KMEM
2765 static inline bool memcg_can_account_kmem(struct mem_cgroup *memcg)
2766 {
2767         return !mem_cgroup_disabled() && !mem_cgroup_is_root(memcg) &&
2768                 (memcg->kmem_account_flags & KMEM_ACCOUNTED_MASK);
2769 }
2770
2771 /*
2772  * This is a bit cumbersome, but it is rarely used and avoids a backpointer
2773  * in the memcg_cache_params struct.
2774  */
2775 static struct kmem_cache *memcg_params_to_cache(struct memcg_cache_params *p)
2776 {
2777         struct kmem_cache *cachep;
2778
2779         VM_BUG_ON(p->is_root_cache);
2780         cachep = p->root_cache;
2781         return cachep->memcg_params->memcg_caches[memcg_cache_id(p->memcg)];
2782 }
2783
2784 #ifdef CONFIG_SLABINFO
2785 static int mem_cgroup_slabinfo_read(struct cgroup_subsys_state *css,
2786                                     struct cftype *cft, struct seq_file *m)
2787 {
2788         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
2789         struct memcg_cache_params *params;
2790
2791         if (!memcg_can_account_kmem(memcg))
2792                 return -EIO;
2793
2794         print_slabinfo_header(m);
2795
2796         mutex_lock(&memcg->slab_caches_mutex);
2797         list_for_each_entry(params, &memcg->memcg_slab_caches, list)
2798                 cache_show(memcg_params_to_cache(params), m);
2799         mutex_unlock(&memcg->slab_caches_mutex);
2800
2801         return 0;
2802 }
2803 #endif
2804
2805 static int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp, u64 size)
2806 {
2807         struct res_counter *fail_res;
2808         struct mem_cgroup *_memcg;
2809         int ret = 0;
2810         bool may_oom;
2811
2812         ret = res_counter_charge(&memcg->kmem, size, &fail_res);
2813         if (ret)
2814                 return ret;
2815
2816         /*
2817          * Conditions under which we can wait for the oom_killer. Those are
2818          * the same conditions tested by the core page allocator
2819          */
2820         may_oom = (gfp & __GFP_FS) && !(gfp & __GFP_NORETRY);
2821
2822         _memcg = memcg;
2823         ret = __mem_cgroup_try_charge(NULL, gfp, size >> PAGE_SHIFT,
2824                                       &_memcg, may_oom);
2825
2826         if (ret == -EINTR)  {
2827                 /*
2828                  * __mem_cgroup_try_charge() chosed to bypass to root due to
2829                  * OOM kill or fatal signal.  Since our only options are to
2830                  * either fail the allocation or charge it to this cgroup, do
2831                  * it as a temporary condition. But we can't fail. From a
2832                  * kmem/slab perspective, the cache has already been selected,
2833                  * by mem_cgroup_kmem_get_cache(), so it is too late to change
2834                  * our minds.
2835                  *
2836                  * This condition will only trigger if the task entered
2837                  * memcg_charge_kmem in a sane state, but was OOM-killed during
2838                  * __mem_cgroup_try_charge() above. Tasks that were already
2839                  * dying when the allocation triggers should have been already
2840                  * directed to the root cgroup in memcontrol.h
2841                  */
2842                 res_counter_charge_nofail(&memcg->res, size, &fail_res);
2843                 if (do_swap_account)
2844                         res_counter_charge_nofail(&memcg->memsw, size,
2845                                                   &fail_res);
2846                 ret = 0;
2847         } else if (ret)
2848                 res_counter_uncharge(&memcg->kmem, size);
2849
2850         return ret;
2851 }
2852
2853 static void memcg_uncharge_kmem(struct mem_cgroup *memcg, u64 size)
2854 {
2855         res_counter_uncharge(&memcg->res, size);
2856         if (do_swap_account)
2857                 res_counter_uncharge(&memcg->memsw, size);
2858
2859         /* Not down to 0 */
2860         if (res_counter_uncharge(&memcg->kmem, size))
2861                 return;
2862
2863         /*
2864          * Releases a reference taken in kmem_cgroup_css_offline in case
2865          * this last uncharge is racing with the offlining code or it is
2866          * outliving the memcg existence.
2867          *
2868          * The memory barrier imposed by test&clear is paired with the
2869          * explicit one in memcg_kmem_mark_dead().
2870          */
2871         if (memcg_kmem_test_and_clear_dead(memcg))
2872                 css_put(&memcg->css);
2873 }
2874
2875 void memcg_cache_list_add(struct mem_cgroup *memcg, struct kmem_cache *cachep)
2876 {
2877         if (!memcg)
2878                 return;
2879
2880         mutex_lock(&memcg->slab_caches_mutex);
2881         list_add(&cachep->memcg_params->list, &memcg->memcg_slab_caches);
2882         mutex_unlock(&memcg->slab_caches_mutex);
2883 }
2884
2885 /*
2886  * helper for acessing a memcg's index. It will be used as an index in the
2887  * child cache array in kmem_cache, and also to derive its name. This function
2888  * will return -1 when this is not a kmem-limited memcg.
2889  */
2890 int memcg_cache_id(struct mem_cgroup *memcg)
2891 {
2892         return memcg ? memcg->kmemcg_id : -1;
2893 }
2894
2895 /*
2896  * This ends up being protected by the set_limit mutex, during normal
2897  * operation, because that is its main call site.
2898  *
2899  * But when we create a new cache, we can call this as well if its parent
2900  * is kmem-limited. That will have to hold set_limit_mutex as well.
2901  */
2902 int memcg_update_cache_sizes(struct mem_cgroup *memcg)
2903 {
2904         int num, ret;
2905
2906         num = ida_simple_get(&kmem_limited_groups,
2907                                 0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
2908         if (num < 0)
2909                 return num;
2910         /*
2911          * After this point, kmem_accounted (that we test atomically in
2912          * the beginning of this conditional), is no longer 0. This
2913          * guarantees only one process will set the following boolean
2914          * to true. We don't need test_and_set because we're protected
2915          * by the set_limit_mutex anyway.
2916          */
2917         memcg_kmem_set_activated(memcg);
2918
2919         ret = memcg_update_all_caches(num+1);
2920         if (ret) {
2921                 ida_simple_remove(&kmem_limited_groups, num);
2922                 memcg_kmem_clear_activated(memcg);
2923                 return ret;
2924         }
2925
2926         memcg->kmemcg_id = num;
2927         INIT_LIST_HEAD(&memcg->memcg_slab_caches);
2928         mutex_init(&memcg->slab_caches_mutex);
2929         return 0;
2930 }
2931
2932 static size_t memcg_caches_array_size(int num_groups)
2933 {
2934         ssize_t size;
2935         if (num_groups <= 0)
2936                 return 0;
2937
2938         size = 2 * num_groups;
2939         if (size < MEMCG_CACHES_MIN_SIZE)
2940                 size = MEMCG_CACHES_MIN_SIZE;
2941         else if (size > MEMCG_CACHES_MAX_SIZE)
2942                 size = MEMCG_CACHES_MAX_SIZE;
2943
2944         return size;
2945 }
2946
2947 /*
2948  * We should update the current array size iff all caches updates succeed. This
2949  * can only be done from the slab side. The slab mutex needs to be held when
2950  * calling this.
2951  */
2952 void memcg_update_array_size(int num)
2953 {
2954         if (num > memcg_limited_groups_array_size)
2955                 memcg_limited_groups_array_size = memcg_caches_array_size(num);
2956 }
2957
2958 static void kmem_cache_destroy_work_func(struct work_struct *w);
2959
2960 int memcg_update_cache_size(struct kmem_cache *s, int num_groups)
2961 {
2962         struct memcg_cache_params *cur_params = s->memcg_params;
2963
2964         VM_BUG_ON(s->memcg_params && !s->memcg_params->is_root_cache);
2965
2966         if (num_groups > memcg_limited_groups_array_size) {
2967                 int i;
2968                 ssize_t size = memcg_caches_array_size(num_groups);
2969
2970                 size *= sizeof(void *);
2971                 size += offsetof(struct memcg_cache_params, memcg_caches);
2972
2973                 s->memcg_params = kzalloc(size, GFP_KERNEL);
2974                 if (!s->memcg_params) {
2975                         s->memcg_params = cur_params;
2976                         return -ENOMEM;
2977                 }
2978
2979                 s->memcg_params->is_root_cache = true;
2980
2981                 /*
2982                  * There is the chance it will be bigger than
2983                  * memcg_limited_groups_array_size, if we failed an allocation
2984                  * in a cache, in which case all caches updated before it, will
2985                  * have a bigger array.
2986                  *
2987                  * But if that is the case, the data after
2988                  * memcg_limited_groups_array_size is certainly unused
2989                  */
2990                 for (i = 0; i < memcg_limited_groups_array_size; i++) {
2991                         if (!cur_params->memcg_caches[i])
2992                                 continue;
2993                         s->memcg_params->memcg_caches[i] =
2994                                                 cur_params->memcg_caches[i];
2995                 }
2996
2997                 /*
2998                  * Ideally, we would wait until all caches succeed, and only
2999                  * then free the old one. But this is not worth the extra
3000                  * pointer per-cache we'd have to have for this.
3001                  *
3002                  * It is not a big deal if some caches are left with a size
3003                  * bigger than the others. And all updates will reset this
3004                  * anyway.
3005                  */
3006                 kfree(cur_params);
3007         }
3008         return 0;
3009 }
3010
3011 int memcg_register_cache(struct mem_cgroup *memcg, struct kmem_cache *s,
3012                          struct kmem_cache *root_cache)
3013 {
3014         size_t size;
3015
3016         if (!memcg_kmem_enabled())
3017                 return 0;
3018
3019         if (!memcg) {
3020                 size = offsetof(struct memcg_cache_params, memcg_caches);
3021                 size += memcg_limited_groups_array_size * sizeof(void *);
3022         } else
3023                 size = sizeof(struct memcg_cache_params);
3024
3025         s->memcg_params = kzalloc(size, GFP_KERNEL);
3026         if (!s->memcg_params)
3027                 return -ENOMEM;
3028
3029         if (memcg) {
3030                 s->memcg_params->memcg = memcg;
3031                 s->memcg_params->root_cache = root_cache;
3032                 INIT_WORK(&s->memcg_params->destroy,
3033                                 kmem_cache_destroy_work_func);
3034         } else
3035                 s->memcg_params->is_root_cache = true;
3036
3037         return 0;
3038 }
3039
3040 void memcg_release_cache(struct kmem_cache *s)
3041 {
3042         struct kmem_cache *root;
3043         struct mem_cgroup *memcg;
3044         int id;
3045
3046         /*
3047          * This happens, for instance, when a root cache goes away before we
3048          * add any memcg.
3049          */
3050         if (!s->memcg_params)
3051                 return;
3052
3053         if (s->memcg_params->is_root_cache)
3054                 goto out;
3055
3056         memcg = s->memcg_params->memcg;
3057         id  = memcg_cache_id(memcg);
3058
3059         root = s->memcg_params->root_cache;
3060         root->memcg_params->memcg_caches[id] = NULL;
3061
3062         mutex_lock(&memcg->slab_caches_mutex);
3063         list_del(&s->memcg_params->list);
3064         mutex_unlock(&memcg->slab_caches_mutex);
3065
3066         css_put(&memcg->css);
3067 out:
3068         kfree(s->memcg_params);
3069 }
3070
3071 /*
3072  * During the creation a new cache, we need to disable our accounting mechanism
3073  * altogether. This is true even if we are not creating, but rather just
3074  * enqueing new caches to be created.
3075  *
3076  * This is because that process will trigger allocations; some visible, like
3077  * explicit kmallocs to auxiliary data structures, name strings and internal
3078  * cache structures; some well concealed, like INIT_WORK() that can allocate
3079  * objects during debug.
3080  *
3081  * If any allocation happens during memcg_kmem_get_cache, we will recurse back
3082  * to it. This may not be a bounded recursion: since the first cache creation
3083  * failed to complete (waiting on the allocation), we'll just try to create the
3084  * cache again, failing at the same point.
3085  *
3086  * memcg_kmem_get_cache is prepared to abort after seeing a positive count of
3087  * memcg_kmem_skip_account. So we enclose anything that might allocate memory
3088  * inside the following two functions.
3089  */
3090 static inline void memcg_stop_kmem_account(void)
3091 {
3092         VM_BUG_ON(!current->mm);
3093         current->memcg_kmem_skip_account++;
3094 }
3095
3096 static inline void memcg_resume_kmem_account(void)
3097 {
3098         VM_BUG_ON(!current->mm);
3099         current->memcg_kmem_skip_account--;
3100 }
3101
3102 static void kmem_cache_destroy_work_func(struct work_struct *w)
3103 {
3104         struct kmem_cache *cachep;
3105         struct memcg_cache_params *p;
3106
3107         p = container_of(w, struct memcg_cache_params, destroy);
3108
3109         cachep = memcg_params_to_cache(p);
3110
3111         /*
3112          * If we get down to 0 after shrink, we could delete right away.
3113          * However, memcg_release_pages() already puts us back in the workqueue
3114          * in that case. If we proceed deleting, we'll get a dangling
3115          * reference, and removing the object from the workqueue in that case
3116          * is unnecessary complication. We are not a fast path.
3117          *
3118          * Note that this case is fundamentally different from racing with
3119          * shrink_slab(): if memcg_cgroup_destroy_cache() is called in
3120          * kmem_cache_shrink, not only we would be reinserting a dead cache
3121          * into the queue, but doing so from inside the worker racing to
3122          * destroy it.
3123          *
3124          * So if we aren't down to zero, we'll just schedule a worker and try
3125          * again
3126          */
3127         if (atomic_read(&cachep->memcg_params->nr_pages) != 0) {
3128                 kmem_cache_shrink(cachep);
3129                 if (atomic_read(&cachep->memcg_params->nr_pages) == 0)
3130                         return;
3131         } else
3132                 kmem_cache_destroy(cachep);
3133 }
3134
3135 void mem_cgroup_destroy_cache(struct kmem_cache *cachep)
3136 {
3137         if (!cachep->memcg_params->dead)
3138                 return;
3139
3140         /*
3141          * There are many ways in which we can get here.
3142          *
3143          * We can get to a memory-pressure situation while the delayed work is
3144          * still pending to run. The vmscan shrinkers can then release all
3145          * cache memory and get us to destruction. If this is the case, we'll
3146          * be executed twice, which is a bug (the second time will execute over
3147          * bogus data). In this case, cancelling the work should be fine.
3148          *
3149          * But we can also get here from the worker itself, if
3150          * kmem_cache_shrink is enough to shake all the remaining objects and
3151          * get the page count to 0. In this case, we'll deadlock if we try to
3152          * cancel the work (the worker runs with an internal lock held, which
3153          * is the same lock we would hold for cancel_work_sync().)
3154          *
3155          * Since we can't possibly know who got us here, just refrain from
3156          * running if there is already work pending
3157          */
3158         if (work_pending(&cachep->memcg_params->destroy))
3159                 return;
3160         /*
3161          * We have to defer the actual destroying to a workqueue, because
3162          * we might currently be in a context that cannot sleep.
3163          */
3164         schedule_work(&cachep->memcg_params->destroy);
3165 }
3166
3167 /*
3168  * This lock protects updaters, not readers. We want readers to be as fast as
3169  * they can, and they will either see NULL or a valid cache value. Our model
3170  * allow them to see NULL, in which case the root memcg will be selected.
3171  *
3172  * We need this lock because multiple allocations to the same cache from a non
3173  * will span more than one worker. Only one of them can create the cache.
3174  */
3175 static DEFINE_MUTEX(memcg_cache_mutex);
3176
3177 /*
3178  * Called with memcg_cache_mutex held
3179  */
3180 static struct kmem_cache *kmem_cache_dup(struct mem_cgroup *memcg,
3181                                          struct kmem_cache *s)
3182 {
3183         struct kmem_cache *new;
3184         static char *tmp_name = NULL;
3185
3186         lockdep_assert_held(&memcg_cache_mutex);
3187
3188         /*
3189          * kmem_cache_create_memcg duplicates the given name and
3190          * cgroup_name for this name requires RCU context.
3191          * This static temporary buffer is used to prevent from
3192          * pointless shortliving allocation.
3193          */
3194         if (!tmp_name) {
3195                 tmp_name = kmalloc(PATH_MAX, GFP_KERNEL);
3196                 if (!tmp_name)
3197                         return NULL;
3198         }
3199
3200         rcu_read_lock();
3201         snprintf(tmp_name, PATH_MAX, "%s(%d:%s)", s->name,
3202                          memcg_cache_id(memcg), cgroup_name(memcg->css.cgroup));
3203         rcu_read_unlock();
3204
3205         new = kmem_cache_create_memcg(memcg, tmp_name, s->object_size, s->align,
3206                                       (s->flags & ~SLAB_PANIC), s->ctor, s);
3207
3208         if (new)
3209                 new->allocflags |= __GFP_KMEMCG;
3210
3211         return new;
3212 }
3213
3214 static struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *memcg,
3215                                                   struct kmem_cache *cachep)
3216 {
3217         struct kmem_cache *new_cachep;
3218         int idx;
3219
3220         BUG_ON(!memcg_can_account_kmem(memcg));
3221
3222         idx = memcg_cache_id(memcg);
3223
3224         mutex_lock(&memcg_cache_mutex);
3225         new_cachep = cachep->memcg_params->memcg_caches[idx];
3226         if (new_cachep) {
3227                 css_put(&memcg->css);
3228                 goto out;
3229         }
3230
3231         new_cachep = kmem_cache_dup(memcg, cachep);
3232         if (new_cachep == NULL) {
3233                 new_cachep = cachep;
3234                 css_put(&memcg->css);
3235                 goto out;
3236         }
3237
3238         atomic_set(&new_cachep->memcg_params->nr_pages , 0);
3239
3240         cachep->memcg_params->memcg_caches[idx] = new_cachep;
3241         /*
3242          * the readers won't lock, make sure everybody sees the updated value,
3243          * so they won't put stuff in the queue again for no reason
3244          */
3245         wmb();
3246 out:
3247         mutex_unlock(&memcg_cache_mutex);
3248         return new_cachep;
3249 }
3250
3251 void kmem_cache_destroy_memcg_children(struct kmem_cache *s)
3252 {
3253         struct kmem_cache *c;
3254         int i;
3255
3256         if (!s->memcg_params)
3257                 return;
3258         if (!s->memcg_params->is_root_cache)
3259                 return;
3260
3261         /*
3262          * If the cache is being destroyed, we trust that there is no one else
3263          * requesting objects from it. Even if there are, the sanity checks in
3264          * kmem_cache_destroy should caught this ill-case.
3265          *
3266          * Still, we don't want anyone else freeing memcg_caches under our
3267          * noses, which can happen if a new memcg comes to life. As usual,
3268          * we'll take the set_limit_mutex to protect ourselves against this.
3269          */
3270         mutex_lock(&set_limit_mutex);
3271         for (i = 0; i < memcg_limited_groups_array_size; i++) {
3272                 c = s->memcg_params->memcg_caches[i];
3273                 if (!c)
3274                         continue;
3275
3276                 /*
3277                  * We will now manually delete the caches, so to avoid races
3278                  * we need to cancel all pending destruction workers and
3279                  * proceed with destruction ourselves.
3280                  *
3281                  * kmem_cache_destroy() will call kmem_cache_shrink internally,
3282                  * and that could spawn the workers again: it is likely that
3283                  * the cache still have active pages until this very moment.
3284                  * This would lead us back to mem_cgroup_destroy_cache.
3285                  *
3286                  * But that will not execute at all if the "dead" flag is not
3287                  * set, so flip it down to guarantee we are in control.
3288                  */
3289                 c->memcg_params->dead = false;
3290                 cancel_work_sync(&c->memcg_params->destroy);
3291                 kmem_cache_destroy(c);
3292         }
3293         mutex_unlock(&set_limit_mutex);
3294 }
3295
3296 struct create_work {
3297         struct mem_cgroup *memcg;
3298         struct kmem_cache *cachep;
3299         struct work_struct work;
3300 };
3301
3302 static void mem_cgroup_destroy_all_caches(struct mem_cgroup *memcg)
3303 {
3304         struct kmem_cache *cachep;
3305         struct memcg_cache_params *params;
3306
3307         if (!memcg_kmem_is_active(memcg))
3308                 return;
3309
3310         mutex_lock(&memcg->slab_caches_mutex);
3311         list_for_each_entry(params, &memcg->memcg_slab_caches, list) {
3312                 cachep = memcg_params_to_cache(params);
3313                 cachep->memcg_params->dead = true;
3314                 schedule_work(&cachep->memcg_params->destroy);
3315         }
3316         mutex_unlock(&memcg->slab_caches_mutex);
3317 }
3318
3319 static void memcg_create_cache_work_func(struct work_struct *w)
3320 {
3321         struct create_work *cw;
3322
3323         cw = container_of(w, struct create_work, work);
3324         memcg_create_kmem_cache(cw->memcg, cw->cachep);
3325         kfree(cw);
3326 }
3327
3328 /*
3329  * Enqueue the creation of a per-memcg kmem_cache.
3330  */
3331 static void __memcg_create_cache_enqueue(struct mem_cgroup *memcg,
3332                                          struct kmem_cache *cachep)
3333 {
3334         struct create_work *cw;
3335
3336         cw = kmalloc(sizeof(struct create_work), GFP_NOWAIT);
3337         if (cw == NULL) {
3338                 css_put(&memcg->css);
3339                 return;
3340         }
3341
3342         cw->memcg = memcg;
3343         cw->cachep = cachep;
3344
3345         INIT_WORK(&cw->work, memcg_create_cache_work_func);
3346         schedule_work(&cw->work);
3347 }
3348
3349 static void memcg_create_cache_enqueue(struct mem_cgroup *memcg,
3350                                        struct kmem_cache *cachep)
3351 {
3352         /*
3353          * We need to stop accounting when we kmalloc, because if the
3354          * corresponding kmalloc cache is not yet created, the first allocation
3355          * in __memcg_create_cache_enqueue will recurse.
3356          *
3357          * However, it is better to enclose the whole function. Depending on
3358          * the debugging options enabled, INIT_WORK(), for instance, can
3359          * trigger an allocation. This too, will make us recurse. Because at
3360          * this point we can't allow ourselves back into memcg_kmem_get_cache,
3361          * the safest choice is to do it like this, wrapping the whole function.
3362          */
3363         memcg_stop_kmem_account();
3364         __memcg_create_cache_enqueue(memcg, cachep);
3365         memcg_resume_kmem_account();
3366 }
3367 /*
3368  * Return the kmem_cache we're supposed to use for a slab allocation.
3369  * We try to use the current memcg's version of the cache.
3370  *
3371  * If the cache does not exist yet, if we are the first user of it,
3372  * we either create it immediately, if possible, or create it asynchronously
3373  * in a workqueue.
3374  * In the latter case, we will let the current allocation go through with
3375  * the original cache.
3376  *
3377  * Can't be called in interrupt context or from kernel threads.
3378  * This function needs to be called with rcu_read_lock() held.
3379  */
3380 struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep,
3381                                           gfp_t gfp)
3382 {
3383         struct mem_cgroup *memcg;
3384         int idx;
3385
3386         VM_BUG_ON(!cachep->memcg_params);
3387         VM_BUG_ON(!cachep->memcg_params->is_root_cache);
3388
3389         if (!current->mm || current->memcg_kmem_skip_account)
3390                 return cachep;
3391
3392         rcu_read_lock();
3393         memcg = mem_cgroup_from_task(rcu_dereference(current->mm->owner));
3394
3395         if (!memcg_can_account_kmem(memcg))
3396                 goto out;
3397
3398         idx = memcg_cache_id(memcg);
3399
3400         /*
3401          * barrier to mare sure we're always seeing the up to date value.  The
3402          * code updating memcg_caches will issue a write barrier to match this.
3403          */
3404         read_barrier_depends();
3405         if (likely(cachep->memcg_params->memcg_caches[idx])) {
3406                 cachep = cachep->memcg_params->memcg_caches[idx];
3407                 goto out;
3408         }
3409
3410         /* The corresponding put will be done in the workqueue. */
3411         if (!css_tryget(&memcg->css))
3412                 goto out;
3413         rcu_read_unlock();
3414
3415         /*
3416          * If we are in a safe context (can wait, and not in interrupt
3417          * context), we could be be predictable and return right away.
3418          * This would guarantee that the allocation being performed
3419          * already belongs in the new cache.
3420          *
3421          * However, there are some clashes that can arrive from locking.
3422          * For instance, because we acquire the slab_mutex while doing
3423          * kmem_cache_dup, this means no further allocation could happen
3424          * with the slab_mutex held.
3425          *
3426          * Also, because cache creation issue get_online_cpus(), this
3427          * creates a lock chain: memcg_slab_mutex -> cpu_hotplug_mutex,
3428          * that ends up reversed during cpu hotplug. (cpuset allocates
3429          * a bunch of GFP_KERNEL memory during cpuup). Due to all that,
3430          * better to defer everything.
3431          */
3432         memcg_create_cache_enqueue(memcg, cachep);
3433         return cachep;
3434 out:
3435         rcu_read_unlock();
3436         return cachep;
3437 }
3438 EXPORT_SYMBOL(__memcg_kmem_get_cache);
3439
3440 /*
3441  * We need to verify if the allocation against current->mm->owner's memcg is
3442  * possible for the given order. But the page is not allocated yet, so we'll
3443  * need a further commit step to do the final arrangements.
3444  *
3445  * It is possible for the task to switch cgroups in this mean time, so at
3446  * commit time, we can't rely on task conversion any longer.  We'll then use
3447  * the handle argument to return to the caller which cgroup we should commit
3448  * against. We could also return the memcg directly and avoid the pointer
3449  * passing, but a boolean return value gives better semantics considering
3450  * the compiled-out case as well.
3451  *
3452  * Returning true means the allocation is possible.
3453  */
3454 bool
3455 __memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **_memcg, int order)
3456 {
3457         struct mem_cgroup *memcg;
3458         int ret;
3459
3460         *_memcg = NULL;
3461
3462         /*
3463          * Disabling accounting is only relevant for some specific memcg
3464          * internal allocations. Therefore we would initially not have such
3465          * check here, since direct calls to the page allocator that are marked
3466          * with GFP_KMEMCG only happen outside memcg core. We are mostly
3467          * concerned with cache allocations, and by having this test at
3468          * memcg_kmem_get_cache, we are already able to relay the allocation to
3469          * the root cache and bypass the memcg cache altogether.
3470          *
3471          * There is one exception, though: the SLUB allocator does not create
3472          * large order caches, but rather service large kmallocs directly from
3473          * the page allocator. Therefore, the following sequence when backed by
3474          * the SLUB allocator:
3475          *
3476          *      memcg_stop_kmem_account();
3477          *      kmalloc(<large_number>)
3478          *      memcg_resume_kmem_account();
3479          *
3480          * would effectively ignore the fact that we should skip accounting,
3481          * since it will drive us directly to this function without passing
3482          * through the cache selector memcg_kmem_get_cache. Such large
3483          * allocations are extremely rare but can happen, for instance, for the
3484          * cache arrays. We bring this test here.
3485          */
3486         if (!current->mm || current->memcg_kmem_skip_account)
3487                 return true;
3488
3489         memcg = try_get_mem_cgroup_from_mm(current->mm);
3490
3491         /*
3492          * very rare case described in mem_cgroup_from_task. Unfortunately there
3493          * isn't much we can do without complicating this too much, and it would
3494          * be gfp-dependent anyway. Just let it go
3495          */
3496         if (unlikely(!memcg))
3497                 return true;
3498
3499         if (!memcg_can_account_kmem(memcg)) {
3500                 css_put(&memcg->css);
3501                 return true;
3502         }
3503
3504         ret = memcg_charge_kmem(memcg, gfp, PAGE_SIZE << order);
3505         if (!ret)
3506                 *_memcg = memcg;
3507
3508         css_put(&memcg->css);
3509         return (ret == 0);
3510 }
3511
3512 void __memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg,
3513                               int order)
3514 {
3515         struct page_cgroup *pc;
3516
3517         VM_BUG_ON(mem_cgroup_is_root(memcg));
3518
3519         /* The page allocation failed. Revert */
3520         if (!page) {
3521                 memcg_uncharge_kmem(memcg, PAGE_SIZE << order);
3522                 return;
3523         }
3524
3525         pc = lookup_page_cgroup(page);
3526         lock_page_cgroup(pc);
3527         pc->mem_cgroup = memcg;
3528         SetPageCgroupUsed(pc);
3529         unlock_page_cgroup(pc);
3530 }
3531
3532 void __memcg_kmem_uncharge_pages(struct page *page, int order)
3533 {
3534         struct mem_cgroup *memcg = NULL;
3535         struct page_cgroup *pc;
3536
3537
3538         pc = lookup_page_cgroup(page);
3539         /*
3540          * Fast unlocked return. Theoretically might have changed, have to
3541          * check again after locking.
3542          */
3543         if (!PageCgroupUsed(pc))
3544                 return;
3545
3546         lock_page_cgroup(pc);
3547         if (PageCgroupUsed(pc)) {
3548                 memcg = pc->mem_cgroup;
3549                 ClearPageCgroupUsed(pc);
3550         }
3551         unlock_page_cgroup(pc);
3552
3553         /*
3554          * We trust that only if there is a memcg associated with the page, it
3555          * is a valid allocation
3556          */
3557         if (!memcg)
3558                 return;
3559
3560         VM_BUG_ON(mem_cgroup_is_root(memcg));
3561         memcg_uncharge_kmem(memcg, PAGE_SIZE << order);
3562 }
3563 #else
3564 static inline void mem_cgroup_destroy_all_caches(struct mem_cgroup *memcg)
3565 {
3566 }
3567 #endif /* CONFIG_MEMCG_KMEM */
3568
3569 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
3570
3571 #define PCGF_NOCOPY_AT_SPLIT (1 << PCG_LOCK | 1 << PCG_MIGRATION)
3572 /*
3573  * Because tail pages are not marked as "used", set it. We're under
3574  * zone->lru_lock, 'splitting on pmd' and compound_lock.
3575  * charge/uncharge will be never happen and move_account() is done under
3576  * compound_lock(), so we don't have to take care of races.
3577  */
3578 void mem_cgroup_split_huge_fixup(struct page *head)
3579 {
3580         struct page_cgroup *head_pc = lookup_page_cgroup(head);
3581         struct page_cgroup *pc;
3582         struct mem_cgroup *memcg;
3583         int i;
3584
3585         if (mem_cgroup_disabled())
3586                 return;
3587
3588         memcg = head_pc->mem_cgroup;
3589         for (i = 1; i < HPAGE_PMD_NR; i++) {
3590                 pc = head_pc + i;
3591                 pc->mem_cgroup = memcg;
3592                 smp_wmb();/* see __commit_charge() */
3593                 pc->flags = head_pc->flags & ~PCGF_NOCOPY_AT_SPLIT;
3594         }
3595         __this_cpu_sub(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
3596                        HPAGE_PMD_NR);
3597 }
3598 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
3599
3600 /**
3601  * mem_cgroup_move_account - move account of the page
3602  * @page: the page
3603  * @nr_pages: number of regular pages (>1 for huge pages)
3604  * @pc: page_cgroup of the page.
3605  * @from: mem_cgroup which the page is moved from.
3606  * @to: mem_cgroup which the page is moved to. @from != @to.
3607  *
3608  * The caller must confirm following.
3609  * - page is not on LRU (isolate_page() is useful.)
3610  * - compound_lock is held when nr_pages > 1
3611  *
3612  * This function doesn't do "charge" to new cgroup and doesn't do "uncharge"
3613  * from old cgroup.
3614  */
3615 static int mem_cgroup_move_account(struct page *page,
3616                                    unsigned int nr_pages,
3617                                    struct page_cgroup *pc,
3618                                    struct mem_cgroup *from,
3619                                    struct mem_cgroup *to)
3620 {
3621         unsigned long flags;
3622         int ret;
3623         bool anon = PageAnon(page);
3624
3625         VM_BUG_ON(from == to);
3626         VM_BUG_ON(PageLRU(page));
3627         /*
3628          * The page is isolated from LRU. So, collapse function
3629          * will not handle this page. But page splitting can happen.
3630          * Do this check under compound_page_lock(). The caller should
3631          * hold it.
3632          */
3633         ret = -EBUSY;
3634         if (nr_pages > 1 && !PageTransHuge(page))
3635                 goto out;
3636
3637         lock_page_cgroup(pc);
3638
3639         ret = -EINVAL;
3640         if (!PageCgroupUsed(pc) || pc->mem_cgroup != from)
3641                 goto unlock;
3642
3643         move_lock_mem_cgroup(from, &flags);
3644
3645         if (!anon && page_mapped(page)) {
3646                 /* Update mapped_file data for mem_cgroup */
3647                 preempt_disable();
3648                 __this_cpu_dec(from->stat->count[MEM_CGROUP_STAT_FILE_MAPPED]);
3649                 __this_cpu_inc(to->stat->count[MEM_CGROUP_STAT_FILE_MAPPED]);
3650                 preempt_enable();
3651         }
3652         mem_cgroup_charge_statistics(from, page, anon, -nr_pages);
3653
3654         /* caller should have done css_get */
3655         pc->mem_cgroup = to;
3656         mem_cgroup_charge_statistics(to, page, anon, nr_pages);
3657         move_unlock_mem_cgroup(from, &flags);
3658         ret = 0;
3659 unlock:
3660         unlock_page_cgroup(pc);
3661         /*
3662          * check events
3663          */
3664         memcg_check_events(to, page);
3665         memcg_check_events(from, page);
3666 out:
3667         return ret;
3668 }
3669
3670 /**
3671  * mem_cgroup_move_parent - moves page to the parent group
3672  * @page: the page to move
3673  * @pc: page_cgroup of the page
3674  * @child: page's cgroup
3675  *
3676  * move charges to its parent or the root cgroup if the group has no
3677  * parent (aka use_hierarchy==0).
3678  * Although this might fail (get_page_unless_zero, isolate_lru_page or
3679  * mem_cgroup_move_account fails) the failure is always temporary and
3680  * it signals a race with a page removal/uncharge or migration. In the
3681  * first case the page is on the way out and it will vanish from the LRU
3682  * on the next attempt and the call should be retried later.
3683  * Isolation from the LRU fails only if page has been isolated from
3684  * the LRU since we looked at it and that usually means either global
3685  * reclaim or migration going on. The page will either get back to the
3686  * LRU or vanish.
3687  * Finaly mem_cgroup_move_account fails only if the page got uncharged
3688  * (!PageCgroupUsed) or moved to a different group. The page will
3689  * disappear in the next attempt.
3690  */
3691 static int mem_cgroup_move_parent(struct page *page,
3692                                   struct page_cgroup *pc,
3693                                   struct mem_cgroup *child)
3694 {
3695         struct mem_cgroup *parent;
3696         unsigned int nr_pages;
3697         unsigned long uninitialized_var(flags);
3698         int ret;
3699
3700         VM_BUG_ON(mem_cgroup_is_root(child));
3701
3702         ret = -EBUSY;
3703         if (!get_page_unless_zero(page))
3704                 goto out;
3705         if (isolate_lru_page(page))
3706                 goto put;
3707
3708         nr_pages = hpage_nr_pages(page);
3709
3710         parent = parent_mem_cgroup(child);
3711         /*
3712          * If no parent, move charges to root cgroup.
3713          */
3714         if (!parent)
3715                 parent = root_mem_cgroup;
3716
3717         if (nr_pages > 1) {
3718                 VM_BUG_ON(!PageTransHuge(page));
3719                 flags = compound_lock_irqsave(page);
3720         }
3721
3722         ret = mem_cgroup_move_account(page, nr_pages,
3723                                 pc, child, parent);
3724         if (!ret)
3725                 __mem_cgroup_cancel_local_charge(child, nr_pages);
3726
3727         if (nr_pages > 1)
3728                 compound_unlock_irqrestore(page, flags);
3729         putback_lru_page(page);
3730 put:
3731         put_page(page);
3732 out:
3733         return ret;
3734 }
3735
3736 /*
3737  * Charge the memory controller for page usage.
3738  * Return
3739  * 0 if the charge was successful
3740  * < 0 if the cgroup is over its limit
3741  */
3742 static int mem_cgroup_charge_common(struct page *page, struct mm_struct *mm,
3743                                 gfp_t gfp_mask, enum charge_type ctype)
3744 {
3745         struct mem_cgroup *memcg = NULL;
3746         unsigned int nr_pages = 1;
3747         bool oom = true;
3748         int ret;
3749
3750         if (PageTransHuge(page)) {
3751                 nr_pages <<= compound_order(page);
3752                 VM_BUG_ON(!PageTransHuge(page));
3753                 /*
3754                  * Never OOM-kill a process for a huge page.  The
3755                  * fault handler will fall back to regular pages.
3756                  */
3757                 oom = false;
3758         }
3759
3760         ret = __mem_cgroup_try_charge(mm, gfp_mask, nr_pages, &memcg, oom);
3761         if (ret == -ENOMEM)
3762                 return ret;
3763         __mem_cgroup_commit_charge(memcg, page, nr_pages, ctype, false);
3764         return 0;
3765 }
3766
3767 int mem_cgroup_newpage_charge(struct page *page,
3768                               struct mm_struct *mm, gfp_t gfp_mask)
3769 {
3770         if (mem_cgroup_disabled())
3771                 return 0;
3772         VM_BUG_ON(page_mapped(page));
3773         VM_BUG_ON(page->mapping && !PageAnon(page));
3774         VM_BUG_ON(!mm);
3775         return mem_cgroup_charge_common(page, mm, gfp_mask,
3776                                         MEM_CGROUP_CHARGE_TYPE_ANON);
3777 }
3778
3779 /*
3780  * While swap-in, try_charge -> commit or cancel, the page is locked.
3781  * And when try_charge() successfully returns, one refcnt to memcg without
3782  * struct page_cgroup is acquired. This refcnt will be consumed by
3783  * "commit()" or removed by "cancel()"
3784  */
3785 static int __mem_cgroup_try_charge_swapin(struct mm_struct *mm,
3786                                           struct page *page,
3787                                           gfp_t mask,
3788                                           struct mem_cgroup **memcgp)
3789 {
3790         struct mem_cgroup *memcg;
3791         struct page_cgroup *pc;
3792         int ret;
3793
3794         pc = lookup_page_cgroup(page);
3795         /*
3796          * Every swap fault against a single page tries to charge the
3797          * page, bail as early as possible.  shmem_unuse() encounters
3798          * already charged pages, too.  The USED bit is protected by
3799          * the page lock, which serializes swap cache removal, which
3800          * in turn serializes uncharging.
3801          */
3802         if (PageCgroupUsed(pc))
3803                 return 0;
3804         if (!do_swap_account)
3805                 goto charge_cur_mm;
3806         memcg = try_get_mem_cgroup_from_page(page);
3807         if (!memcg)
3808                 goto charge_cur_mm;
3809         *memcgp = memcg;
3810         ret = __mem_cgroup_try_charge(NULL, mask, 1, memcgp, true);
3811         css_put(&memcg->css);
3812         if (ret == -EINTR)
3813                 ret = 0;
3814         return ret;
3815 charge_cur_mm:
3816         ret = __mem_cgroup_try_charge(mm, mask, 1, memcgp, true);
3817         if (ret == -EINTR)
3818                 ret = 0;
3819         return ret;
3820 }
3821
3822 int mem_cgroup_try_charge_swapin(struct mm_struct *mm, struct page *page,
3823                                  gfp_t gfp_mask, struct mem_cgroup **memcgp)
3824 {
3825         *memcgp = NULL;
3826         if (mem_cgroup_disabled())
3827                 return 0;
3828         /*
3829          * A racing thread's fault, or swapoff, may have already
3830          * updated the pte, and even removed page from swap cache: in
3831          * those cases unuse_pte()'s pte_same() test will fail; but
3832          * there's also a KSM case which does need to charge the page.
3833          */
3834         if (!PageSwapCache(page)) {
3835                 int ret;
3836
3837                 ret = __mem_cgroup_try_charge(mm, gfp_mask, 1, memcgp, true);
3838                 if (ret == -EINTR)
3839                         ret = 0;
3840                 return ret;
3841         }
3842         return __mem_cgroup_try_charge_swapin(mm, page, gfp_mask, memcgp);
3843 }
3844
3845 void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg)
3846 {
3847         if (mem_cgroup_disabled())
3848                 return;
3849         if (!memcg)
3850                 return;
3851         __mem_cgroup_cancel_charge(memcg, 1);
3852 }
3853
3854 static void
3855 __mem_cgroup_commit_charge_swapin(struct page *page, struct mem_cgroup *memcg,
3856                                         enum charge_type ctype)
3857 {
3858         if (mem_cgroup_disabled())
3859                 return;
3860         if (!memcg)
3861                 return;
3862
3863         __mem_cgroup_commit_charge(memcg, page, 1, ctype, true);
3864         /*
3865          * Now swap is on-memory. This means this page may be
3866          * counted both as mem and swap....double count.
3867          * Fix it by uncharging from memsw. Basically, this SwapCache is stable
3868          * under lock_page(). But in do_swap_page()::memory.c, reuse_swap_page()
3869          * may call delete_from_swap_cache() before reach here.
3870          */
3871         if (do_swap_account && PageSwapCache(page)) {
3872                 swp_entry_t ent = {.val = page_private(page)};
3873                 mem_cgroup_uncharge_swap(ent);
3874         }
3875 }
3876
3877 void mem_cgroup_commit_charge_swapin(struct page *page,
3878                                      struct mem_cgroup *memcg)
3879 {
3880         __mem_cgroup_commit_charge_swapin(page, memcg,
3881                                           MEM_CGROUP_CHARGE_TYPE_ANON);
3882 }
3883
3884 int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm,
3885                                 gfp_t gfp_mask)
3886 {
3887         struct mem_cgroup *memcg = NULL;
3888         enum charge_type type = MEM_CGROUP_CHARGE_TYPE_CACHE;
3889         int ret;
3890
3891         if (mem_cgroup_disabled())
3892                 return 0;
3893         if (PageCompound(page))
3894                 return 0;
3895
3896         if (!PageSwapCache(page))
3897                 ret = mem_cgroup_charge_common(page, mm, gfp_mask, type);
3898         else { /* page is swapcache/shmem */
3899                 ret = __mem_cgroup_try_charge_swapin(mm, page,
3900                                                      gfp_mask, &memcg);
3901                 if (!ret)
3902                         __mem_cgroup_commit_charge_swapin(page, memcg, type);
3903         }
3904         return ret;
3905 }
3906
3907 static void mem_cgroup_do_uncharge(struct mem_cgroup *memcg,
3908                                    unsigned int nr_pages,
3909                                    const enum charge_type ctype)
3910 {
3911         struct memcg_batch_info *batch = NULL;
3912         bool uncharge_memsw = true;
3913
3914         /* If swapout, usage of swap doesn't decrease */
3915         if (!do_swap_account || ctype == MEM_CGROUP_CHARGE_TYPE_SWAPOUT)
3916                 uncharge_memsw = false;
3917
3918         batch = &current->memcg_batch;
3919         /*
3920          * In usual, we do css_get() when we remember memcg pointer.
3921          * But in this case, we keep res->usage until end of a series of
3922          * uncharges. Then, it's ok to ignore memcg's refcnt.
3923          */
3924         if (!batch->memcg)
3925                 batch->memcg = memcg;
3926         /*
3927          * do_batch > 0 when unmapping pages or inode invalidate/truncate.
3928          * In those cases, all pages freed continuously can be expected to be in
3929          * the same cgroup and we have chance to coalesce uncharges.
3930          * But we do uncharge one by one if this is killed by OOM(TIF_MEMDIE)
3931          * because we want to do uncharge as soon as possible.
3932          */
3933
3934         if (!batch->do_batch || test_thread_flag(TIF_MEMDIE))
3935                 goto direct_uncharge;
3936
3937         if (nr_pages > 1)
3938                 goto direct_uncharge;
3939
3940         /*
3941          * In typical case, batch->memcg == mem. This means we can
3942          * merge a series of uncharges to an uncharge of res_counter.
3943          * If not, we uncharge res_counter ony by one.
3944          */
3945         if (batch->memcg != memcg)
3946                 goto direct_uncharge;
3947         /* remember freed charge and uncharge it later */
3948         batch->nr_pages++;
3949         if (uncharge_memsw)
3950                 batch->memsw_nr_pages++;
3951         return;
3952 direct_uncharge:
3953         res_counter_uncharge(&memcg->res, nr_pages * PAGE_SIZE);
3954         if (uncharge_memsw)
3955                 res_counter_uncharge(&memcg->memsw, nr_pages * PAGE_SIZE);
3956         if (unlikely(batch->memcg != memcg))
3957                 memcg_oom_recover(memcg);
3958 }
3959
3960 /*
3961  * uncharge if !page_mapped(page)
3962  */
3963 static struct mem_cgroup *
3964 __mem_cgroup_uncharge_common(struct page *page, enum charge_type ctype,
3965                              bool end_migration)
3966 {
3967         struct mem_cgroup *memcg = NULL;
3968         unsigned int nr_pages = 1;
3969         struct page_cgroup *pc;
3970         bool anon;
3971
3972         if (mem_cgroup_disabled())
3973                 return NULL;
3974
3975         if (PageTransHuge(page)) {
3976                 nr_pages <<= compound_order(page);
3977                 VM_BUG_ON(!PageTransHuge(page));
3978         }
3979         /*
3980          * Check if our page_cgroup is valid
3981          */
3982         pc = lookup_page_cgroup(page);
3983         if (unlikely(!PageCgroupUsed(pc)))
3984                 return NULL;
3985
3986         lock_page_cgroup(pc);
3987
3988         memcg = pc->mem_cgroup;
3989
3990         if (!PageCgroupUsed(pc))
3991                 goto unlock_out;
3992
3993         anon = PageAnon(page);
3994
3995         switch (ctype) {
3996         case MEM_CGROUP_CHARGE_TYPE_ANON:
3997                 /*
3998                  * Generally PageAnon tells if it's the anon statistics to be
3999                  * updated; but sometimes e.g. mem_cgroup_uncharge_page() is
4000                  * used before page reached the stage of being marked PageAnon.
4001                  */
4002                 anon = true;
4003                 /* fallthrough */
4004         case MEM_CGROUP_CHARGE_TYPE_DROP:
4005                 /* See mem_cgroup_prepare_migration() */
4006                 if (page_mapped(page))
4007                         goto unlock_out;
4008                 /*
4009                  * Pages under migration may not be uncharged.  But
4010                  * end_migration() /must/ be the one uncharging the
4011                  * unused post-migration page and so it has to call
4012                  * here with the migration bit still set.  See the
4013                  * res_counter handling below.
4014                  */
4015                 if (!end_migration && PageCgroupMigration(pc))
4016                         goto unlock_out;
4017                 break;
4018         case MEM_CGROUP_CHARGE_TYPE_SWAPOUT:
4019                 if (!PageAnon(page)) {  /* Shared memory */
4020                         if (page->mapping && !page_is_file_cache(page))
4021                                 goto unlock_out;
4022                 } else if (page_mapped(page)) /* Anon */
4023                                 goto unlock_out;
4024                 break;
4025         default:
4026                 break;
4027         }
4028
4029         mem_cgroup_charge_statistics(memcg, page, anon, -nr_pages);
4030
4031         ClearPageCgroupUsed(pc);
4032         /*
4033          * pc->mem_cgroup is not cleared here. It will be accessed when it's
4034          * freed from LRU. This is safe because uncharged page is expected not
4035          * to be reused (freed soon). Exception is SwapCache, it's handled by
4036          * special functions.
4037          */
4038
4039         unlock_page_cgroup(pc);
4040         /*
4041          * even after unlock, we have memcg->res.usage here and this memcg
4042          * will never be freed, so it's safe to call css_get().
4043          */
4044         memcg_check_events(memcg, page);
4045         if (do_swap_account && ctype == MEM_CGROUP_CHARGE_TYPE_SWAPOUT) {
4046                 mem_cgroup_swap_statistics(memcg, true);
4047                 css_get(&memcg->css);
4048         }
4049         /*
4050          * Migration does not charge the res_counter for the
4051          * replacement page, so leave it alone when phasing out the
4052          * page that is unused after the migration.
4053          */
4054         if (!end_migration && !mem_cgroup_is_root(memcg))
4055                 mem_cgroup_do_uncharge(memcg, nr_pages, ctype);
4056
4057         return memcg;
4058
4059 unlock_out:
4060         unlock_page_cgroup(pc);
4061         return NULL;
4062 }
4063
4064 void mem_cgroup_uncharge_page(struct page *page)
4065 {
4066         /* early check. */
4067         if (page_mapped(page))
4068                 return;
4069         VM_BUG_ON(page->mapping && !PageAnon(page));
4070         /*
4071          * If the page is in swap cache, uncharge should be deferred
4072          * to the swap path, which also properly accounts swap usage
4073          * and handles memcg lifetime.
4074          *
4075          * Note that this check is not stable and reclaim may add the
4076          * page to swap cache at any time after this.  However, if the
4077          * page is not in swap cache by the time page->mapcount hits
4078          * 0, there won't be any page table references to the swap
4079          * slot, and reclaim will free it and not actually write the
4080          * page to disk.
4081          */
4082         if (PageSwapCache(page))
4083                 return;
4084         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_ANON, false);
4085 }
4086
4087 void mem_cgroup_uncharge_cache_page(struct page *page)
4088 {
4089         VM_BUG_ON(page_mapped(page));
4090         VM_BUG_ON(page->mapping);
4091         __mem_cgroup_uncharge_common(page, MEM_CGROUP_CHARGE_TYPE_CACHE, false);
4092 }
4093
4094 /*
4095  * Batch_start/batch_end is called in unmap_page_range/invlidate/trucate.
4096  * In that cases, pages are freed continuously and we can expect pages
4097  * are in the same memcg. All these calls itself limits the number of
4098  * pages freed at once, then uncharge_start/end() is called properly.
4099  * This may be called prural(2) times in a context,
4100  */
4101
4102 void mem_cgroup_uncharge_start(void)
4103 {
4104         current->memcg_batch.do_batch++;
4105         /* We can do nest. */
4106         if (current->memcg_batch.do_batch == 1) {
4107                 current->memcg_batch.memcg = NULL;
4108                 current->memcg_batch.nr_pages = 0;
4109                 current->memcg_batch.memsw_nr_pages = 0;
4110         }
4111 }
4112
4113 void mem_cgroup_uncharge_end(void)
4114 {
4115         struct memcg_batch_info *batch = &current->memcg_batch;
4116
4117         if (!batch->do_batch)
4118                 return;
4119
4120         batch->do_batch--;
4121         if (batch->do_batch) /* If stacked, do nothing. */
4122                 return;
4123
4124         if (!batch->memcg)
4125                 return;
4126         /*
4127          * This "batch->memcg" is valid without any css_get/put etc...
4128          * bacause we hide charges behind us.
4129          */
4130         if (batch->nr_pages)
4131                 res_counter_uncharge(&batch->memcg->res,
4132                                      batch->nr_pages * PAGE_SIZE);
4133         if (batch->memsw_nr_pages)
4134                 res_counter_uncharge(&batch->memcg->memsw,
4135                                      batch->memsw_nr_pages * PAGE_SIZE);
4136         memcg_oom_recover(batch->memcg);
4137         /* forget this pointer (for sanity check) */
4138         batch->memcg = NULL;
4139 }
4140
4141 #ifdef CONFIG_SWAP
4142 /*
4143  * called after __delete_from_swap_cache() and drop "page" account.
4144  * memcg information is recorded to swap_cgroup of "ent"
4145  */
4146 void
4147 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
4148 {
4149         struct mem_cgroup *memcg;
4150         int ctype = MEM_CGROUP_CHARGE_TYPE_SWAPOUT;
4151
4152         if (!swapout) /* this was a swap cache but the swap is unused ! */
4153                 ctype = MEM_CGROUP_CHARGE_TYPE_DROP;
4154
4155         memcg = __mem_cgroup_uncharge_common(page, ctype, false);
4156
4157         /*
4158          * record memcg information,  if swapout && memcg != NULL,
4159          * css_get() was called in uncharge().
4160          */
4161         if (do_swap_account && swapout && memcg)
4162                 swap_cgroup_record(ent, css_id(&memcg->css));
4163 }
4164 #endif
4165
4166 #ifdef CONFIG_MEMCG_SWAP
4167 /*
4168  * called from swap_entry_free(). remove record in swap_cgroup and
4169  * uncharge "memsw" account.
4170  */
4171 void mem_cgroup_uncharge_swap(swp_entry_t ent)
4172 {
4173         struct mem_cgroup *memcg;
4174         unsigned short id;
4175
4176         if (!do_swap_account)
4177                 return;
4178
4179         id = swap_cgroup_record(ent, 0);
4180         rcu_read_lock();
4181         memcg = mem_cgroup_lookup(id);
4182         if (memcg) {
4183                 /*
4184                  * We uncharge this because swap is freed.
4185                  * This memcg can be obsolete one. We avoid calling css_tryget
4186                  */
4187                 if (!mem_cgroup_is_root(memcg))
4188                         res_counter_uncharge(&memcg->memsw, PAGE_SIZE);
4189                 mem_cgroup_swap_statistics(memcg, false);
4190                 css_put(&memcg->css);
4191         }
4192         rcu_read_unlock();
4193 }
4194
4195 /**
4196  * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
4197  * @entry: swap entry to be moved
4198  * @from:  mem_cgroup which the entry is moved from
4199  * @to:  mem_cgroup which the entry is moved to
4200  *
4201  * It succeeds only when the swap_cgroup's record for this entry is the same
4202  * as the mem_cgroup's id of @from.
4203  *
4204  * Returns 0 on success, -EINVAL on failure.
4205  *
4206  * The caller must have charged to @to, IOW, called res_counter_charge() about
4207  * both res and memsw, and called css_get().
4208  */
4209 static int mem_cgroup_move_swap_account(swp_entry_t entry,
4210                                 struct mem_cgroup *from, struct mem_cgroup *to)
4211 {
4212         unsigned short old_id, new_id;
4213
4214         old_id = css_id(&from->css);
4215         new_id = css_id(&to->css);
4216
4217         if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
4218                 mem_cgroup_swap_statistics(from, false);
4219                 mem_cgroup_swap_statistics(to, true);
4220                 /*
4221                  * This function is only called from task migration context now.
4222                  * It postpones res_counter and refcount handling till the end
4223                  * of task migration(mem_cgroup_clear_mc()) for performance
4224                  * improvement. But we cannot postpone css_get(to)  because if
4225                  * the process that has been moved to @to does swap-in, the
4226                  * refcount of @to might be decreased to 0.
4227                  *
4228                  * We are in attach() phase, so the cgroup is guaranteed to be
4229                  * alive, so we can just call css_get().
4230                  */
4231                 css_get(&to->css);
4232                 return 0;
4233         }
4234         return -EINVAL;
4235 }
4236 #else
4237 static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
4238                                 struct mem_cgroup *from, struct mem_cgroup *to)
4239 {
4240         return -EINVAL;
4241 }
4242 #endif
4243
4244 /*
4245  * Before starting migration, account PAGE_SIZE to mem_cgroup that the old
4246  * page belongs to.
4247  */
4248 void mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
4249                                   struct mem_cgroup **memcgp)
4250 {
4251         struct mem_cgroup *memcg = NULL;
4252         unsigned int nr_pages = 1;
4253         struct page_cgroup *pc;
4254         enum charge_type ctype;
4255
4256         *memcgp = NULL;
4257
4258         if (mem_cgroup_disabled())
4259                 return;
4260
4261         if (PageTransHuge(page))
4262                 nr_pages <<= compound_order(page);
4263
4264         pc = lookup_page_cgroup(page);
4265         lock_page_cgroup(pc);
4266         if (PageCgroupUsed(pc)) {
4267                 memcg = pc->mem_cgroup;
4268                 css_get(&memcg->css);
4269                 /*
4270                  * At migrating an anonymous page, its mapcount goes down
4271                  * to 0 and uncharge() will be called. But, even if it's fully
4272                  * unmapped, migration may fail and this page has to be
4273                  * charged again. We set MIGRATION flag here and delay uncharge
4274                  * until end_migration() is called
4275                  *
4276                  * Corner Case Thinking
4277                  * A)
4278                  * When the old page was mapped as Anon and it's unmap-and-freed
4279                  * while migration was ongoing.
4280                  * If unmap finds the old page, uncharge() of it will be delayed
4281                  * until end_migration(). If unmap finds a new page, it's
4282                  * uncharged when it make mapcount to be 1->0. If unmap code
4283                  * finds swap_migration_entry, the new page will not be mapped
4284                  * and end_migration() will find it(mapcount==0).
4285                  *
4286                  * B)
4287                  * When the old page was mapped but migraion fails, the kernel
4288                  * remaps it. A charge for it is kept by MIGRATION flag even
4289                  * if mapcount goes down to 0. We can do remap successfully
4290                  * without charging it again.
4291                  *
4292                  * C)
4293                  * The "old" page is under lock_page() until the end of
4294                  * migration, so, the old page itself will not be swapped-out.
4295                  * If the new page is swapped out before end_migraton, our
4296                  * hook to usual swap-out path will catch the event.
4297                  */
4298                 if (PageAnon(page))
4299                         SetPageCgroupMigration(pc);
4300         }
4301         unlock_page_cgroup(pc);
4302         /*
4303          * If the page is not charged at this point,
4304          * we return here.
4305          */
4306         if (!memcg)
4307                 return;
4308
4309         *memcgp = memcg;
4310         /*
4311          * We charge new page before it's used/mapped. So, even if unlock_page()
4312          * is called before end_migration, we can catch all events on this new
4313          * page. In the case new page is migrated but not remapped, new page's
4314          * mapcount will be finally 0 and we call uncharge in end_migration().
4315          */
4316         if (PageAnon(page))
4317                 ctype = MEM_CGROUP_CHARGE_TYPE_ANON;
4318         else
4319                 ctype = MEM_CGROUP_CHARGE_TYPE_CACHE;
4320         /*
4321          * The page is committed to the memcg, but it's not actually
4322          * charged to the res_counter since we plan on replacing the
4323          * old one and only one page is going to be left afterwards.
4324          */
4325         __mem_cgroup_commit_charge(memcg, newpage, nr_pages, ctype, false);
4326 }
4327
4328 /* remove redundant charge if migration failed*/
4329 void mem_cgroup_end_migration(struct mem_cgroup *memcg,
4330         struct page *oldpage, struct page *newpage, bool migration_ok)
4331 {
4332         struct page *used, *unused;
4333         struct page_cgroup *pc;
4334         bool anon;
4335
4336         if (!memcg)
4337                 return;
4338
4339         if (!migration_ok) {
4340                 used = oldpage;
4341                 unused = newpage;
4342         } else {
4343                 used = newpage;
4344                 unused = oldpage;
4345         }
4346         anon = PageAnon(used);
4347         __mem_cgroup_uncharge_common(unused,
4348                                      anon ? MEM_CGROUP_CHARGE_TYPE_ANON
4349                                      : MEM_CGROUP_CHARGE_TYPE_CACHE,
4350                                      true);
4351         css_put(&memcg->css);
4352         /*
4353          * We disallowed uncharge of pages under migration because mapcount
4354          * of the page goes down to zero, temporarly.
4355          * Clear the flag and check the page should be charged.
4356          */
4357         pc = lookup_page_cgroup(oldpage);
4358         lock_page_cgroup(pc);
4359         ClearPageCgroupMigration(pc);
4360         unlock_page_cgroup(pc);
4361
4362         /*
4363          * If a page is a file cache, radix-tree replacement is very atomic
4364          * and we can skip this check. When it was an Anon page, its mapcount
4365          * goes down to 0. But because we added MIGRATION flage, it's not
4366          * uncharged yet. There are several case but page->mapcount check
4367          * and USED bit check in mem_cgroup_uncharge_page() will do enough
4368          * check. (see prepare_charge() also)
4369          */
4370         if (anon)
4371                 mem_cgroup_uncharge_page(used);
4372 }
4373
4374 /*
4375  * At replace page cache, newpage is not under any memcg but it's on
4376  * LRU. So, this function doesn't touch res_counter but handles LRU
4377  * in correct way. Both pages are locked so we cannot race with uncharge.
4378  */
4379 void mem_cgroup_replace_page_cache(struct page *oldpage,
4380                                   struct page *newpage)
4381 {
4382         struct mem_cgroup *memcg = NULL;
4383         struct page_cgroup *pc;
4384         enum charge_type type = MEM_CGROUP_CHARGE_TYPE_CACHE;
4385
4386         if (mem_cgroup_disabled())
4387                 return;
4388
4389         pc = lookup_page_cgroup(oldpage);
4390         /* fix accounting on old pages */
4391         lock_page_cgroup(pc);
4392         if (PageCgroupUsed(pc)) {
4393                 memcg = pc->mem_cgroup;
4394                 mem_cgroup_charge_statistics(memcg, oldpage, false, -1);
4395                 ClearPageCgroupUsed(pc);
4396         }
4397         unlock_page_cgroup(pc);
4398
4399         /*
4400          * When called from shmem_replace_page(), in some cases the
4401          * oldpage has already been charged, and in some cases not.
4402          */
4403         if (!memcg)
4404                 return;
4405         /*
4406          * Even if newpage->mapping was NULL before starting replacement,
4407          * the newpage may be on LRU(or pagevec for LRU) already. We lock
4408          * LRU while we overwrite pc->mem_cgroup.
4409          */
4410         __mem_cgroup_commit_charge(memcg, newpage, 1, type, true);
4411 }
4412
4413 #ifdef CONFIG_DEBUG_VM
4414 static struct page_cgroup *lookup_page_cgroup_used(struct page *page)
4415 {
4416         struct page_cgroup *pc;
4417
4418         pc = lookup_page_cgroup(page);
4419         /*
4420          * Can be NULL while feeding pages into the page allocator for
4421          * the first time, i.e. during boot or memory hotplug;
4422          * or when mem_cgroup_disabled().
4423          */
4424         if (likely(pc) && PageCgroupUsed(pc))
4425                 return pc;
4426         return NULL;
4427 }
4428
4429 bool mem_cgroup_bad_page_check(struct page *page)
4430 {
4431         if (mem_cgroup_disabled())
4432                 return false;
4433
4434         return lookup_page_cgroup_used(page) != NULL;
4435 }
4436
4437 void mem_cgroup_print_bad_page(struct page *page)
4438 {
4439         struct page_cgroup *pc;
4440
4441         pc = lookup_page_cgroup_used(page);
4442         if (pc) {
4443                 pr_alert("pc:%p pc->flags:%lx pc->mem_cgroup:%p\n",
4444                          pc, pc->flags, pc->mem_cgroup);
4445         }
4446 }
4447 #endif
4448
4449 static int mem_cgroup_resize_limit(struct mem_cgroup *memcg,
4450                                 unsigned long long val)
4451 {
4452         int retry_count;
4453         u64 memswlimit, memlimit;
4454         int ret = 0;
4455         int children = mem_cgroup_count_children(memcg);
4456         u64 curusage, oldusage;
4457         int enlarge;
4458
4459         /*
4460          * For keeping hierarchical_reclaim simple, how long we should retry
4461          * is depends on callers. We set our retry-count to be function
4462          * of # of children which we should visit in this loop.
4463          */
4464         retry_count = MEM_CGROUP_RECLAIM_RETRIES * children;
4465
4466         oldusage = res_counter_read_u64(&memcg->res, RES_USAGE);
4467
4468         enlarge = 0;
4469         while (retry_count) {
4470                 if (signal_pending(current)) {
4471                         ret = -EINTR;
4472                         break;
4473                 }
4474                 /*
4475                  * Rather than hide all in some function, I do this in
4476                  * open coded manner. You see what this really does.
4477                  * We have to guarantee memcg->res.limit <= memcg->memsw.limit.
4478                  */
4479                 mutex_lock(&set_limit_mutex);
4480                 memswlimit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
4481                 if (memswlimit < val) {
4482                         ret = -EINVAL;
4483                         mutex_unlock(&set_limit_mutex);
4484                         break;
4485                 }
4486
4487                 memlimit = res_counter_read_u64(&memcg->res, RES_LIMIT);
4488                 if (memlimit < val)
4489                         enlarge = 1;
4490
4491                 ret = res_counter_set_limit(&memcg->res, val);
4492                 if (!ret) {
4493                         if (memswlimit == val)
4494                                 memcg->memsw_is_minimum = true;
4495                         else
4496                                 memcg->memsw_is_minimum = false;
4497                 }
4498                 mutex_unlock(&set_limit_mutex);
4499
4500                 if (!ret)
4501                         break;
4502
4503                 mem_cgroup_reclaim(memcg, GFP_KERNEL,
4504                                    MEM_CGROUP_RECLAIM_SHRINK);
4505                 curusage = res_counter_read_u64(&memcg->res, RES_USAGE);
4506                 /* Usage is reduced ? */
4507                 if (curusage >= oldusage)
4508                         retry_count--;
4509                 else
4510                         oldusage = curusage;
4511         }
4512         if (!ret && enlarge)
4513                 memcg_oom_recover(memcg);
4514
4515         return ret;
4516 }
4517
4518 static int mem_cgroup_resize_memsw_limit(struct mem_cgroup *memcg,
4519                                         unsigned long long val)
4520 {
4521         int retry_count;
4522         u64 memlimit, memswlimit, oldusage, curusage;
4523         int children = mem_cgroup_count_children(memcg);
4524         int ret = -EBUSY;
4525         int enlarge = 0;
4526
4527         /* see mem_cgroup_resize_res_limit */
4528         retry_count = children * MEM_CGROUP_RECLAIM_RETRIES;
4529         oldusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
4530         while (retry_count) {
4531                 if (signal_pending(current)) {
4532                         ret = -EINTR;
4533                         break;
4534                 }
4535                 /*
4536                  * Rather than hide all in some function, I do this in
4537                  * open coded manner. You see what this really does.
4538                  * We have to guarantee memcg->res.limit <= memcg->memsw.limit.
4539                  */
4540                 mutex_lock(&set_limit_mutex);
4541                 memlimit = res_counter_read_u64(&memcg->res, RES_LIMIT);
4542                 if (memlimit > val) {
4543                         ret = -EINVAL;
4544                         mutex_unlock(&set_limit_mutex);
4545                         break;
4546                 }
4547                 memswlimit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
4548                 if (memswlimit < val)
4549                         enlarge = 1;
4550                 ret = res_counter_set_limit(&memcg->memsw, val);
4551                 if (!ret) {
4552                         if (memlimit == val)
4553                                 memcg->memsw_is_minimum = true;
4554                         else
4555                                 memcg->memsw_is_minimum = false;
4556                 }
4557                 mutex_unlock(&set_limit_mutex);
4558
4559                 if (!ret)
4560                         break;
4561
4562                 mem_cgroup_reclaim(memcg, GFP_KERNEL,
4563                                    MEM_CGROUP_RECLAIM_NOSWAP |
4564                                    MEM_CGROUP_RECLAIM_SHRINK);
4565                 curusage = res_counter_read_u64(&memcg->memsw, RES_USAGE);
4566                 /* Usage is reduced ? */
4567                 if (curusage >= oldusage)
4568                         retry_count--;
4569                 else
4570                         oldusage = curusage;
4571         }
4572         if (!ret && enlarge)
4573                 memcg_oom_recover(memcg);
4574         return ret;
4575 }
4576
4577 /**
4578  * mem_cgroup_force_empty_list - clears LRU of a group
4579  * @memcg: group to clear
4580  * @node: NUMA node
4581  * @zid: zone id
4582  * @lru: lru to to clear
4583  *
4584  * Traverse a specified page_cgroup list and try to drop them all.  This doesn't
4585  * reclaim the pages page themselves - pages are moved to the parent (or root)
4586  * group.
4587  */
4588 static void mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
4589                                 int node, int zid, enum lru_list lru)
4590 {
4591         struct lruvec *lruvec;
4592         unsigned long flags;
4593         struct list_head *list;
4594         struct page *busy;
4595         struct zone *zone;
4596
4597         zone = &NODE_DATA(node)->node_zones[zid];
4598         lruvec = mem_cgroup_zone_lruvec(zone, memcg);
4599         list = &lruvec->lists[lru];
4600
4601         busy = NULL;
4602         do {
4603                 struct page_cgroup *pc;
4604                 struct page *page;
4605
4606                 spin_lock_irqsave(&zone->lru_lock, flags);
4607                 if (list_empty(list)) {
4608                         spin_unlock_irqrestore(&zone->lru_lock, flags);
4609                         break;
4610                 }
4611                 page = list_entry(list->prev, struct page, lru);
4612                 if (busy == page) {
4613                         list_move(&page->lru, list);
4614                         busy = NULL;
4615                         spin_unlock_irqrestore(&zone->lru_lock, flags);
4616                         continue;
4617                 }
4618                 spin_unlock_irqrestore(&zone->lru_lock, flags);
4619
4620                 pc = lookup_page_cgroup(page);
4621
4622                 if (mem_cgroup_move_parent(page, pc, memcg)) {
4623                         /* found lock contention or "pc" is obsolete. */
4624                         busy = page;
4625                         cond_resched();
4626                 } else
4627                         busy = NULL;
4628         } while (!list_empty(list));
4629 }
4630
4631 /*
4632  * make mem_cgroup's charge to be 0 if there is no task by moving
4633  * all the charges and pages to the parent.
4634  * This enables deleting this mem_cgroup.
4635  *
4636  * Caller is responsible for holding css reference on the memcg.
4637  */
4638 static void mem_cgroup_reparent_charges(struct mem_cgroup *memcg)
4639 {
4640         int node, zid;
4641         u64 usage;
4642
4643         do {
4644                 /* This is for making all *used* pages to be on LRU. */
4645                 lru_add_drain_all();
4646                 drain_all_stock_sync(memcg);
4647                 mem_cgroup_start_move(memcg);
4648                 for_each_node_state(node, N_MEMORY) {
4649                         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
4650                                 enum lru_list lru;
4651                                 for_each_lru(lru) {
4652                                         mem_cgroup_force_empty_list(memcg,
4653                                                         node, zid, lru);
4654                                 }
4655                         }
4656                 }
4657                 mem_cgroup_end_move(memcg);
4658                 memcg_oom_recover(memcg);
4659                 cond_resched();
4660
4661                 /*
4662                  * Kernel memory may not necessarily be trackable to a specific
4663                  * process. So they are not migrated, and therefore we can't
4664                  * expect their value to drop to 0 here.
4665                  * Having res filled up with kmem only is enough.
4666                  *
4667                  * This is a safety check because mem_cgroup_force_empty_list
4668                  * could have raced with mem_cgroup_replace_page_cache callers
4669                  * so the lru seemed empty but the page could have been added
4670                  * right after the check. RES_USAGE should be safe as we always
4671                  * charge before adding to the LRU.
4672                  */
4673                 usage = res_counter_read_u64(&memcg->res, RES_USAGE) -
4674                         res_counter_read_u64(&memcg->kmem, RES_USAGE);
4675         } while (usage > 0);
4676 }
4677
4678 /*
4679  * This mainly exists for tests during the setting of set of use_hierarchy.
4680  * Since this is the very setting we are changing, the current hierarchy value
4681  * is meaningless
4682  */
4683 static inline bool __memcg_has_children(struct mem_cgroup *memcg)
4684 {
4685         struct cgroup_subsys_state *pos;
4686
4687         /* bounce at first found */
4688         css_for_each_child(pos, &memcg->css)
4689                 return true;
4690         return false;
4691 }
4692
4693 /*
4694  * Must be called with memcg_create_mutex held, unless the cgroup is guaranteed
4695  * to be already dead (as in mem_cgroup_force_empty, for instance).  This is
4696  * from mem_cgroup_count_children(), in the sense that we don't really care how
4697  * many children we have; we only need to know if we have any.  It also counts
4698  * any memcg without hierarchy as infertile.
4699  */
4700 static inline bool memcg_has_children(struct mem_cgroup *memcg)
4701 {
4702         return memcg->use_hierarchy && __memcg_has_children(memcg);
4703 }
4704
4705 /*
4706  * Reclaims as many pages from the given memcg as possible and moves
4707  * the rest to the parent.
4708  *
4709  * Caller is responsible for holding css reference for memcg.
4710  */
4711 static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
4712 {
4713         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
4714         struct cgroup *cgrp = memcg->css.cgroup;
4715
4716         /* returns EBUSY if there is a task or if we come here twice. */
4717         if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children))
4718                 return -EBUSY;
4719
4720         /* we call try-to-free pages for make this cgroup empty */
4721         lru_add_drain_all();
4722         /* try to free all pages in this cgroup */
4723         while (nr_retries && res_counter_read_u64(&memcg->res, RES_USAGE) > 0) {
4724                 int progress;
4725
4726                 if (signal_pending(current))
4727                         return -EINTR;
4728
4729                 progress = try_to_free_mem_cgroup_pages(memcg, GFP_KERNEL,
4730                                                 false);
4731                 if (!progress) {
4732                         nr_retries--;
4733                         /* maybe some writeback is necessary */
4734                         congestion_wait(BLK_RW_ASYNC, HZ/10);
4735                 }
4736
4737         }
4738         lru_add_drain();
4739         mem_cgroup_reparent_charges(memcg);
4740
4741         return 0;
4742 }
4743
4744 static int mem_cgroup_force_empty_write(struct cgroup_subsys_state *css,
4745                                         unsigned int event)
4746 {
4747         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4748
4749         if (mem_cgroup_is_root(memcg))
4750                 return -EINVAL;
4751         return mem_cgroup_force_empty(memcg);
4752 }
4753
4754 static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
4755                                      struct cftype *cft)
4756 {
4757         return mem_cgroup_from_css(css)->use_hierarchy;
4758 }
4759
4760 static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
4761                                       struct cftype *cft, u64 val)
4762 {
4763         int retval = 0;
4764         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4765         struct mem_cgroup *parent_memcg = mem_cgroup_from_css(css_parent(&memcg->css));
4766
4767         mutex_lock(&memcg_create_mutex);
4768
4769         if (memcg->use_hierarchy == val)
4770                 goto out;
4771
4772         /*
4773          * If parent's use_hierarchy is set, we can't make any modifications
4774          * in the child subtrees. If it is unset, then the change can
4775          * occur, provided the current cgroup has no children.
4776          *
4777          * For the root cgroup, parent_mem is NULL, we allow value to be
4778          * set if there are no children.
4779          */
4780         if ((!parent_memcg || !parent_memcg->use_hierarchy) &&
4781                                 (val == 1 || val == 0)) {
4782                 if (!__memcg_has_children(memcg))
4783                         memcg->use_hierarchy = val;
4784                 else
4785                         retval = -EBUSY;
4786         } else
4787                 retval = -EINVAL;
4788
4789 out:
4790         mutex_unlock(&memcg_create_mutex);
4791
4792         return retval;
4793 }
4794
4795
4796 static unsigned long mem_cgroup_recursive_stat(struct mem_cgroup *memcg,
4797                                                enum mem_cgroup_stat_index idx)
4798 {
4799         struct mem_cgroup *iter;
4800         long val = 0;
4801
4802         /* Per-cpu values can be negative, use a signed accumulator */
4803         for_each_mem_cgroup_tree(iter, memcg)
4804                 val += mem_cgroup_read_stat(iter, idx);
4805
4806         if (val < 0) /* race ? */
4807                 val = 0;
4808         return val;
4809 }
4810
4811 static inline u64 mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
4812 {
4813         u64 val;
4814
4815         if (!mem_cgroup_is_root(memcg)) {
4816                 if (!swap)
4817                         return res_counter_read_u64(&memcg->res, RES_USAGE);
4818                 else
4819                         return res_counter_read_u64(&memcg->memsw, RES_USAGE);
4820         }
4821
4822         /*
4823          * Transparent hugepages are still accounted for in MEM_CGROUP_STAT_RSS
4824          * as well as in MEM_CGROUP_STAT_RSS_HUGE.
4825          */
4826         val = mem_cgroup_recursive_stat(memcg, MEM_CGROUP_STAT_CACHE);
4827         val += mem_cgroup_recursive_stat(memcg, MEM_CGROUP_STAT_RSS);
4828
4829         if (swap)
4830                 val += mem_cgroup_recursive_stat(memcg, MEM_CGROUP_STAT_SWAP);
4831
4832         return val << PAGE_SHIFT;
4833 }
4834
4835 static ssize_t mem_cgroup_read(struct cgroup_subsys_state *css,
4836                                struct cftype *cft, struct file *file,
4837                                char __user *buf, size_t nbytes, loff_t *ppos)
4838 {
4839         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4840         char str[64];
4841         u64 val;
4842         int name, len;
4843         enum res_type type;
4844
4845         type = MEMFILE_TYPE(cft->private);
4846         name = MEMFILE_ATTR(cft->private);
4847
4848         switch (type) {
4849         case _MEM:
4850                 if (name == RES_USAGE)
4851                         val = mem_cgroup_usage(memcg, false);
4852                 else
4853                         val = res_counter_read_u64(&memcg->res, name);
4854                 break;
4855         case _MEMSWAP:
4856                 if (name == RES_USAGE)
4857                         val = mem_cgroup_usage(memcg, true);
4858                 else
4859                         val = res_counter_read_u64(&memcg->memsw, name);
4860                 break;
4861         case _KMEM:
4862                 val = res_counter_read_u64(&memcg->kmem, name);
4863                 break;
4864         default:
4865                 BUG();
4866         }
4867
4868         len = scnprintf(str, sizeof(str), "%llu\n", (unsigned long long)val);
4869         return simple_read_from_buffer(buf, nbytes, ppos, str, len);
4870 }
4871
4872 static int memcg_update_kmem_limit(struct cgroup_subsys_state *css, u64 val)
4873 {
4874         int ret = -EINVAL;
4875 #ifdef CONFIG_MEMCG_KMEM
4876         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4877         /*
4878          * For simplicity, we won't allow this to be disabled.  It also can't
4879          * be changed if the cgroup has children already, or if tasks had
4880          * already joined.
4881          *
4882          * If tasks join before we set the limit, a person looking at
4883          * kmem.usage_in_bytes will have no way to determine when it took
4884          * place, which makes the value quite meaningless.
4885          *
4886          * After it first became limited, changes in the value of the limit are
4887          * of course permitted.
4888          */
4889         mutex_lock(&memcg_create_mutex);
4890         mutex_lock(&set_limit_mutex);
4891         if (!memcg->kmem_account_flags && val != RESOURCE_MAX) {
4892                 if (cgroup_task_count(css->cgroup) || memcg_has_children(memcg)) {
4893                         ret = -EBUSY;
4894                         goto out;
4895                 }
4896                 ret = res_counter_set_limit(&memcg->kmem, val);
4897                 VM_BUG_ON(ret);
4898
4899                 ret = memcg_update_cache_sizes(memcg);
4900                 if (ret) {
4901                         res_counter_set_limit(&memcg->kmem, RESOURCE_MAX);
4902                         goto out;
4903                 }
4904                 static_key_slow_inc(&memcg_kmem_enabled_key);
4905                 /*
4906                  * setting the active bit after the inc will guarantee no one
4907                  * starts accounting before all call sites are patched
4908                  */
4909                 memcg_kmem_set_active(memcg);
4910         } else
4911                 ret = res_counter_set_limit(&memcg->kmem, val);
4912 out:
4913         mutex_unlock(&set_limit_mutex);
4914         mutex_unlock(&memcg_create_mutex);
4915 #endif
4916         return ret;
4917 }
4918
4919 #ifdef CONFIG_MEMCG_KMEM
4920 static int memcg_propagate_kmem(struct mem_cgroup *memcg)
4921 {
4922         int ret = 0;
4923         struct mem_cgroup *parent = parent_mem_cgroup(memcg);
4924         if (!parent)
4925                 goto out;
4926
4927         memcg->kmem_account_flags = parent->kmem_account_flags;
4928         /*
4929          * When that happen, we need to disable the static branch only on those
4930          * memcgs that enabled it. To achieve this, we would be forced to
4931          * complicate the code by keeping track of which memcgs were the ones
4932          * that actually enabled limits, and which ones got it from its
4933          * parents.
4934          *
4935          * It is a lot simpler just to do static_key_slow_inc() on every child
4936          * that is accounted.
4937          */
4938         if (!memcg_kmem_is_active(memcg))
4939                 goto out;
4940
4941         /*
4942          * __mem_cgroup_free() will issue static_key_slow_dec() because this
4943          * memcg is active already. If the later initialization fails then the
4944          * cgroup core triggers the cleanup so we do not have to do it here.
4945          */
4946         static_key_slow_inc(&memcg_kmem_enabled_key);
4947
4948         mutex_lock(&set_limit_mutex);
4949         memcg_stop_kmem_account();
4950         ret = memcg_update_cache_sizes(memcg);
4951         memcg_resume_kmem_account();
4952         mutex_unlock(&set_limit_mutex);
4953 out:
4954         return ret;
4955 }
4956 #endif /* CONFIG_MEMCG_KMEM */
4957
4958 /*
4959  * The user of this function is...
4960  * RES_LIMIT.
4961  */
4962 static int mem_cgroup_write(struct cgroup_subsys_state *css, struct cftype *cft,
4963                             const char *buffer)
4964 {
4965         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4966         enum res_type type;
4967         int name;
4968         unsigned long long val;
4969         int ret;
4970
4971         type = MEMFILE_TYPE(cft->private);
4972         name = MEMFILE_ATTR(cft->private);
4973
4974         switch (name) {
4975         case RES_LIMIT:
4976                 if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
4977                         ret = -EINVAL;
4978                         break;
4979                 }
4980                 /* This function does all necessary parse...reuse it */
4981                 ret = res_counter_memparse_write_strategy(buffer, &val);
4982                 if (ret)
4983                         break;
4984                 if (type == _MEM)
4985                         ret = mem_cgroup_resize_limit(memcg, val);
4986                 else if (type == _MEMSWAP)
4987                         ret = mem_cgroup_resize_memsw_limit(memcg, val);
4988                 else if (type == _KMEM)
4989                         ret = memcg_update_kmem_limit(css, val);
4990                 else
4991                         return -EINVAL;
4992                 break;
4993         case RES_SOFT_LIMIT:
4994                 ret = res_counter_memparse_write_strategy(buffer, &val);
4995                 if (ret)
4996                         break;
4997                 /*
4998                  * For memsw, soft limits are hard to implement in terms
4999                  * of semantics, for now, we support soft limits for
5000                  * control without swap
5001                  */
5002                 if (type == _MEM)
5003                         ret = res_counter_set_soft_limit(&memcg->res, val);
5004                 else
5005                         ret = -EINVAL;
5006                 break;
5007         default:
5008                 ret = -EINVAL; /* should be BUG() ? */
5009                 break;
5010         }
5011         return ret;
5012 }
5013
5014 static void memcg_get_hierarchical_limit(struct mem_cgroup *memcg,
5015                 unsigned long long *mem_limit, unsigned long long *memsw_limit)
5016 {
5017         unsigned long long min_limit, min_memsw_limit, tmp;
5018
5019         min_limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
5020         min_memsw_limit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
5021         if (!memcg->use_hierarchy)
5022                 goto out;
5023
5024         while (css_parent(&memcg->css)) {
5025                 memcg = mem_cgroup_from_css(css_parent(&memcg->css));
5026                 if (!memcg->use_hierarchy)
5027                         break;
5028                 tmp = res_counter_read_u64(&memcg->res, RES_LIMIT);
5029                 min_limit = min(min_limit, tmp);
5030                 tmp = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
5031                 min_memsw_limit = min(min_memsw_limit, tmp);
5032         }
5033 out:
5034         *mem_limit = min_limit;
5035         *memsw_limit = min_memsw_limit;
5036 }
5037
5038 static int mem_cgroup_reset(struct cgroup_subsys_state *css, unsigned int event)
5039 {
5040         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5041         int name;
5042         enum res_type type;
5043
5044         type = MEMFILE_TYPE(event);
5045         name = MEMFILE_ATTR(event);
5046
5047         switch (name) {
5048         case RES_MAX_USAGE:
5049                 if (type == _MEM)
5050                         res_counter_reset_max(&memcg->res);
5051                 else if (type == _MEMSWAP)
5052                         res_counter_reset_max(&memcg->memsw);
5053                 else if (type == _KMEM)
5054                         res_counter_reset_max(&memcg->kmem);
5055                 else
5056                         return -EINVAL;
5057                 break;
5058         case RES_FAILCNT:
5059                 if (type == _MEM)
5060                         res_counter_reset_failcnt(&memcg->res);
5061                 else if (type == _MEMSWAP)
5062                         res_counter_reset_failcnt(&memcg->memsw);
5063                 else if (type == _KMEM)
5064                         res_counter_reset_failcnt(&memcg->kmem);
5065                 else
5066                         return -EINVAL;
5067                 break;
5068         }
5069
5070         return 0;
5071 }
5072
5073 static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
5074                                         struct cftype *cft)
5075 {
5076         return mem_cgroup_from_css(css)->move_charge_at_immigrate;
5077 }
5078
5079 #ifdef CONFIG_MMU
5080 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
5081                                         struct cftype *cft, u64 val)
5082 {
5083         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5084
5085         if (val >= (1 << NR_MOVE_TYPE))
5086                 return -EINVAL;
5087
5088         /*
5089          * No kind of locking is needed in here, because ->can_attach() will
5090          * check this value once in the beginning of the process, and then carry
5091          * on with stale data. This means that changes to this value will only
5092          * affect task migrations starting after the change.
5093          */
5094         memcg->move_charge_at_immigrate = val;
5095         return 0;
5096 }
5097 #else
5098 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
5099                                         struct cftype *cft, u64 val)
5100 {
5101         return -ENOSYS;
5102 }
5103 #endif
5104
5105 #ifdef CONFIG_NUMA
5106 static int memcg_numa_stat_show(struct cgroup_subsys_state *css,
5107                                 struct cftype *cft, struct seq_file *m)
5108 {
5109         int nid;
5110         unsigned long total_nr, file_nr, anon_nr, unevictable_nr;
5111         unsigned long node_nr;
5112         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5113
5114         total_nr = mem_cgroup_nr_lru_pages(memcg, LRU_ALL);
5115         seq_printf(m, "total=%lu", total_nr);
5116         for_each_node_state(nid, N_MEMORY) {
5117                 node_nr = mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL);
5118                 seq_printf(m, " N%d=%lu", nid, node_nr);
5119         }
5120         seq_putc(m, '\n');
5121
5122         file_nr = mem_cgroup_nr_lru_pages(memcg, LRU_ALL_FILE);
5123         seq_printf(m, "file=%lu", file_nr);
5124         for_each_node_state(nid, N_MEMORY) {
5125                 node_nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
5126                                 LRU_ALL_FILE);
5127                 seq_printf(m, " N%d=%lu", nid, node_nr);
5128         }
5129         seq_putc(m, '\n');
5130
5131         anon_nr = mem_cgroup_nr_lru_pages(memcg, LRU_ALL_ANON);
5132         seq_printf(m, "anon=%lu", anon_nr);
5133         for_each_node_state(nid, N_MEMORY) {
5134                 node_nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
5135                                 LRU_ALL_ANON);
5136                 seq_printf(m, " N%d=%lu", nid, node_nr);
5137         }
5138         seq_putc(m, '\n');
5139
5140         unevictable_nr = mem_cgroup_nr_lru_pages(memcg, BIT(LRU_UNEVICTABLE));
5141         seq_printf(m, "unevictable=%lu", unevictable_nr);
5142         for_each_node_state(nid, N_MEMORY) {
5143                 node_nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
5144                                 BIT(LRU_UNEVICTABLE));
5145                 seq_printf(m, " N%d=%lu", nid, node_nr);
5146         }
5147         seq_putc(m, '\n');
5148         return 0;
5149 }
5150 #endif /* CONFIG_NUMA */
5151
5152 static inline void mem_cgroup_lru_names_not_uptodate(void)
5153 {
5154         BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_lru_names) != NR_LRU_LISTS);
5155 }
5156
5157 static int memcg_stat_show(struct cgroup_subsys_state *css, struct cftype *cft,
5158                                  struct seq_file *m)
5159 {
5160         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5161         struct mem_cgroup *mi;
5162         unsigned int i;
5163
5164         for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
5165                 if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
5166                         continue;
5167                 seq_printf(m, "%s %ld\n", mem_cgroup_stat_names[i],
5168                            mem_cgroup_read_stat(memcg, i) * PAGE_SIZE);
5169         }
5170
5171         for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++)
5172                 seq_printf(m, "%s %lu\n", mem_cgroup_events_names[i],
5173                            mem_cgroup_read_events(memcg, i));
5174
5175         for (i = 0; i < NR_LRU_LISTS; i++)
5176                 seq_printf(m, "%s %lu\n", mem_cgroup_lru_names[i],
5177                            mem_cgroup_nr_lru_pages(memcg, BIT(i)) * PAGE_SIZE);
5178
5179         /* Hierarchical information */
5180         {
5181                 unsigned long long limit, memsw_limit;
5182                 memcg_get_hierarchical_limit(memcg, &limit, &memsw_limit);
5183                 seq_printf(m, "hierarchical_memory_limit %llu\n", limit);
5184                 if (do_swap_account)
5185                         seq_printf(m, "hierarchical_memsw_limit %llu\n",
5186                                    memsw_limit);
5187         }
5188
5189         for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
5190                 long long val = 0;
5191
5192                 if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
5193                         continue;
5194                 for_each_mem_cgroup_tree(mi, memcg)
5195                         val += mem_cgroup_read_stat(mi, i) * PAGE_SIZE;
5196                 seq_printf(m, "total_%s %lld\n", mem_cgroup_stat_names[i], val);
5197         }
5198
5199         for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
5200                 unsigned long long val = 0;
5201
5202                 for_each_mem_cgroup_tree(mi, memcg)
5203                         val += mem_cgroup_read_events(mi, i);
5204                 seq_printf(m, "total_%s %llu\n",
5205                            mem_cgroup_events_names[i], val);
5206         }
5207
5208         for (i = 0; i < NR_LRU_LISTS; i++) {
5209                 unsigned long long val = 0;
5210
5211                 for_each_mem_cgroup_tree(mi, memcg)
5212                         val += mem_cgroup_nr_lru_pages(mi, BIT(i)) * PAGE_SIZE;
5213                 seq_printf(m, "total_%s %llu\n", mem_cgroup_lru_names[i], val);
5214         }
5215
5216 #ifdef CONFIG_DEBUG_VM
5217         {
5218                 int nid, zid;
5219                 struct mem_cgroup_per_zone *mz;
5220                 struct zone_reclaim_stat *rstat;
5221                 unsigned long recent_rotated[2] = {0, 0};
5222                 unsigned long recent_scanned[2] = {0, 0};
5223
5224                 for_each_online_node(nid)
5225                         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
5226                                 mz = mem_cgroup_zoneinfo(memcg, nid, zid);
5227                                 rstat = &mz->lruvec.reclaim_stat;
5228
5229                                 recent_rotated[0] += rstat->recent_rotated[0];
5230                                 recent_rotated[1] += rstat->recent_rotated[1];
5231                                 recent_scanned[0] += rstat->recent_scanned[0];
5232                                 recent_scanned[1] += rstat->recent_scanned[1];
5233                         }
5234                 seq_printf(m, "recent_rotated_anon %lu\n", recent_rotated[0]);
5235                 seq_printf(m, "recent_rotated_file %lu\n", recent_rotated[1]);
5236                 seq_printf(m, "recent_scanned_anon %lu\n", recent_scanned[0]);
5237                 seq_printf(m, "recent_scanned_file %lu\n", recent_scanned[1]);
5238         }
5239 #endif
5240
5241         return 0;
5242 }
5243
5244 static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
5245                                       struct cftype *cft)
5246 {
5247         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5248
5249         return mem_cgroup_swappiness(memcg);
5250 }
5251
5252 static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
5253                                        struct cftype *cft, u64 val)
5254 {
5255         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5256         struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(&memcg->css));
5257
5258         if (val > 100 || !parent)
5259                 return -EINVAL;
5260
5261         mutex_lock(&memcg_create_mutex);
5262
5263         /* If under hierarchy, only empty-root can set this value */
5264         if ((parent->use_hierarchy) || memcg_has_children(memcg)) {
5265                 mutex_unlock(&memcg_create_mutex);
5266                 return -EINVAL;
5267         }
5268
5269         memcg->swappiness = val;
5270
5271         mutex_unlock(&memcg_create_mutex);
5272
5273         return 0;
5274 }
5275
5276 static void __mem_cgroup_threshold(struct mem_cgroup *memcg, bool swap)
5277 {
5278         struct mem_cgroup_threshold_ary *t;
5279         u64 usage;
5280         int i;
5281
5282         rcu_read_lock();
5283         if (!swap)
5284                 t = rcu_dereference(memcg->thresholds.primary);
5285         else
5286                 t = rcu_dereference(memcg->memsw_thresholds.primary);
5287
5288         if (!t)
5289                 goto unlock;
5290
5291         usage = mem_cgroup_usage(memcg, swap);
5292
5293         /*
5294          * current_threshold points to threshold just below or equal to usage.
5295          * If it's not true, a threshold was crossed after last
5296          * call of __mem_cgroup_threshold().
5297          */
5298         i = t->current_threshold;
5299
5300         /*
5301          * Iterate backward over array of thresholds starting from
5302          * current_threshold and check if a threshold is crossed.
5303          * If none of thresholds below usage is crossed, we read
5304          * only one element of the array here.
5305          */
5306         for (; i >= 0 && unlikely(t->entries[i].threshold > usage); i--)
5307                 eventfd_signal(t->entries[i].eventfd, 1);
5308
5309         /* i = current_threshold + 1 */
5310         i++;
5311
5312         /*
5313          * Iterate forward over array of thresholds starting from
5314          * current_threshold+1 and check if a threshold is crossed.
5315          * If none of thresholds above usage is crossed, we read
5316          * only one element of the array here.
5317          */
5318         for (; i < t->size && unlikely(t->entries[i].threshold <= usage); i++)
5319                 eventfd_signal(t->entries[i].eventfd, 1);
5320
5321         /* Update current_threshold */
5322         t->current_threshold = i - 1;
5323 unlock:
5324         rcu_read_unlock();
5325 }
5326
5327 static void mem_cgroup_threshold(struct mem_cgroup *memcg)
5328 {
5329         while (memcg) {
5330                 __mem_cgroup_threshold(memcg, false);
5331                 if (do_swap_account)
5332                         __mem_cgroup_threshold(memcg, true);
5333
5334                 memcg = parent_mem_cgroup(memcg);
5335         }
5336 }
5337
5338 static int compare_thresholds(const void *a, const void *b)
5339 {
5340         const struct mem_cgroup_threshold *_a = a;
5341         const struct mem_cgroup_threshold *_b = b;
5342
5343         if (_a->threshold > _b->threshold)
5344                 return 1;
5345
5346         if (_a->threshold < _b->threshold)
5347                 return -1;
5348
5349         return 0;
5350 }
5351
5352 static int mem_cgroup_oom_notify_cb(struct mem_cgroup *memcg)
5353 {
5354         struct mem_cgroup_eventfd_list *ev;
5355
5356         list_for_each_entry(ev, &memcg->oom_notify, list)
5357                 eventfd_signal(ev->eventfd, 1);
5358         return 0;
5359 }
5360
5361 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
5362 {
5363         struct mem_cgroup *iter;
5364
5365         for_each_mem_cgroup_tree(iter, memcg)
5366                 mem_cgroup_oom_notify_cb(iter);
5367 }
5368
5369 static int mem_cgroup_usage_register_event(struct cgroup_subsys_state *css,
5370         struct cftype *cft, struct eventfd_ctx *eventfd, const char *args)
5371 {
5372         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5373         struct mem_cgroup_thresholds *thresholds;
5374         struct mem_cgroup_threshold_ary *new;
5375         enum res_type type = MEMFILE_TYPE(cft->private);
5376         u64 threshold, usage;
5377         int i, size, ret;
5378
5379         ret = res_counter_memparse_write_strategy(args, &threshold);
5380         if (ret)
5381                 return ret;
5382
5383         mutex_lock(&memcg->thresholds_lock);
5384
5385         if (type == _MEM)
5386                 thresholds = &memcg->thresholds;
5387         else if (type == _MEMSWAP)
5388                 thresholds = &memcg->memsw_thresholds;
5389         else
5390                 BUG();
5391
5392         usage = mem_cgroup_usage(memcg, type == _MEMSWAP);
5393
5394         /* Check if a threshold crossed before adding a new one */
5395         if (thresholds->primary)
5396                 __mem_cgroup_threshold(memcg, type == _MEMSWAP);
5397
5398         size = thresholds->primary ? thresholds->primary->size + 1 : 1;
5399
5400         /* Allocate memory for new array of thresholds */
5401         new = kmalloc(sizeof(*new) + size * sizeof(struct mem_cgroup_threshold),
5402                         GFP_KERNEL);
5403         if (!new) {
5404                 ret = -ENOMEM;
5405                 goto unlock;
5406         }
5407         new->size = size;
5408
5409         /* Copy thresholds (if any) to new array */
5410         if (thresholds->primary) {
5411                 memcpy(new->entries, thresholds->primary->entries, (size - 1) *
5412                                 sizeof(struct mem_cgroup_threshold));
5413         }
5414
5415         /* Add new threshold */
5416         new->entries[size - 1].eventfd = eventfd;
5417         new->entries[size - 1].threshold = threshold;
5418
5419         /* Sort thresholds. Registering of new threshold isn't time-critical */
5420         sort(new->entries, size, sizeof(struct mem_cgroup_threshold),
5421                         compare_thresholds, NULL);
5422
5423         /* Find current threshold */
5424         new->current_threshold = -1;
5425         for (i = 0; i < size; i++) {
5426                 if (new->entries[i].threshold <= usage) {
5427                         /*
5428                          * new->current_threshold will not be used until
5429                          * rcu_assign_pointer(), so it's safe to increment
5430                          * it here.
5431                          */
5432                         ++new->current_threshold;
5433                 } else
5434                         break;
5435         }
5436
5437         /* Free old spare buffer and save old primary buffer as spare */
5438         kfree(thresholds->spare);
5439         thresholds->spare = thresholds->primary;
5440
5441         rcu_assign_pointer(thresholds->primary, new);
5442
5443         /* To be sure that nobody uses thresholds */
5444         synchronize_rcu();
5445
5446 unlock:
5447         mutex_unlock(&memcg->thresholds_lock);
5448
5449         return ret;
5450 }
5451
5452 static void mem_cgroup_usage_unregister_event(struct cgroup_subsys_state *css,
5453         struct cftype *cft, struct eventfd_ctx *eventfd)
5454 {
5455         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5456         struct mem_cgroup_thresholds *thresholds;
5457         struct mem_cgroup_threshold_ary *new;
5458         enum res_type type = MEMFILE_TYPE(cft->private);
5459         u64 usage;
5460         int i, j, size;
5461
5462         mutex_lock(&memcg->thresholds_lock);
5463         if (type == _MEM)
5464                 thresholds = &memcg->thresholds;
5465         else if (type == _MEMSWAP)
5466                 thresholds = &memcg->memsw_thresholds;
5467         else
5468                 BUG();
5469
5470         if (!thresholds->primary)
5471                 goto unlock;
5472
5473         usage = mem_cgroup_usage(memcg, type == _MEMSWAP);
5474
5475         /* Check if a threshold crossed before removing */
5476         __mem_cgroup_threshold(memcg, type == _MEMSWAP);
5477
5478         /* Calculate new number of threshold */
5479         size = 0;
5480         for (i = 0; i < thresholds->primary->size; i++) {
5481                 if (thresholds->primary->entries[i].eventfd != eventfd)
5482                         size++;
5483         }
5484
5485         new = thresholds->spare;
5486
5487         /* Set thresholds array to NULL if we don't have thresholds */
5488         if (!size) {
5489                 kfree(new);
5490                 new = NULL;
5491                 goto swap_buffers;
5492         }
5493
5494         new->size = size;
5495
5496         /* Copy thresholds and find current threshold */
5497         new->current_threshold = -1;
5498         for (i = 0, j = 0; i < thresholds->primary->size; i++) {
5499                 if (thresholds->primary->entries[i].eventfd == eventfd)
5500                         continue;
5501
5502                 new->entries[j] = thresholds->primary->entries[i];
5503                 if (new->entries[j].threshold <= usage) {
5504                         /*
5505                          * new->current_threshold will not be used
5506                          * until rcu_assign_pointer(), so it's safe to increment
5507                          * it here.
5508                          */
5509                         ++new->current_threshold;
5510                 }
5511                 j++;
5512         }
5513
5514 swap_buffers:
5515         /* Swap primary and spare array */
5516         thresholds->spare = thresholds->primary;
5517         /* If all events are unregistered, free the spare array */
5518         if (!new) {
5519                 kfree(thresholds->spare);
5520                 thresholds->spare = NULL;
5521         }
5522
5523         rcu_assign_pointer(thresholds->primary, new);
5524
5525         /* To be sure that nobody uses thresholds */
5526         synchronize_rcu();
5527 unlock:
5528         mutex_unlock(&memcg->thresholds_lock);
5529 }
5530
5531 static int mem_cgroup_oom_register_event(struct cgroup_subsys_state *css,
5532         struct cftype *cft, struct eventfd_ctx *eventfd, const char *args)
5533 {
5534         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5535         struct mem_cgroup_eventfd_list *event;
5536         enum res_type type = MEMFILE_TYPE(cft->private);
5537
5538         BUG_ON(type != _OOM_TYPE);
5539         event = kmalloc(sizeof(*event), GFP_KERNEL);
5540         if (!event)
5541                 return -ENOMEM;
5542
5543         spin_lock(&memcg_oom_lock);
5544
5545         event->eventfd = eventfd;
5546         list_add(&event->list, &memcg->oom_notify);
5547
5548         /* already in OOM ? */
5549         if (atomic_read(&memcg->under_oom))
5550                 eventfd_signal(eventfd, 1);
5551         spin_unlock(&memcg_oom_lock);
5552
5553         return 0;
5554 }
5555
5556 static void mem_cgroup_oom_unregister_event(struct cgroup_subsys_state *css,
5557         struct cftype *cft, struct eventfd_ctx *eventfd)
5558 {
5559         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5560         struct mem_cgroup_eventfd_list *ev, *tmp;
5561         enum res_type type = MEMFILE_TYPE(cft->private);
5562
5563         BUG_ON(type != _OOM_TYPE);
5564
5565         spin_lock(&memcg_oom_lock);
5566
5567         list_for_each_entry_safe(ev, tmp, &memcg->oom_notify, list) {
5568                 if (ev->eventfd == eventfd) {
5569                         list_del(&ev->list);
5570                         kfree(ev);
5571                 }
5572         }
5573
5574         spin_unlock(&memcg_oom_lock);
5575 }
5576
5577 static int mem_cgroup_oom_control_read(struct cgroup_subsys_state *css,
5578         struct cftype *cft,  struct cgroup_map_cb *cb)
5579 {
5580         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5581
5582         cb->fill(cb, "oom_kill_disable", memcg->oom_kill_disable);
5583
5584         if (atomic_read(&memcg->under_oom))
5585                 cb->fill(cb, "under_oom", 1);
5586         else
5587                 cb->fill(cb, "under_oom", 0);
5588         return 0;
5589 }
5590
5591 static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
5592         struct cftype *cft, u64 val)
5593 {
5594         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5595         struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(&memcg->css));
5596
5597         /* cannot set to root cgroup and only 0 and 1 are allowed */
5598         if (!parent || !((val == 0) || (val == 1)))
5599                 return -EINVAL;
5600
5601         mutex_lock(&memcg_create_mutex);
5602         /* oom-kill-disable is a flag for subhierarchy. */
5603         if ((parent->use_hierarchy) || memcg_has_children(memcg)) {
5604                 mutex_unlock(&memcg_create_mutex);
5605                 return -EINVAL;
5606         }
5607         memcg->oom_kill_disable = val;
5608         if (!val)
5609                 memcg_oom_recover(memcg);
5610         mutex_unlock(&memcg_create_mutex);
5611         return 0;
5612 }
5613
5614 #ifdef CONFIG_MEMCG_KMEM
5615 static int memcg_init_kmem(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
5616 {
5617         int ret;
5618
5619         memcg->kmemcg_id = -1;
5620         ret = memcg_propagate_kmem(memcg);
5621         if (ret)
5622                 return ret;
5623
5624         return mem_cgroup_sockets_init(memcg, ss);
5625 }
5626
5627 static void memcg_destroy_kmem(struct mem_cgroup *memcg)
5628 {
5629         mem_cgroup_sockets_destroy(memcg);
5630 }
5631
5632 static void kmem_cgroup_css_offline(struct mem_cgroup *memcg)
5633 {
5634         if (!memcg_kmem_is_active(memcg))
5635                 return;
5636
5637         /*
5638          * kmem charges can outlive the cgroup. In the case of slab
5639          * pages, for instance, a page contain objects from various
5640          * processes. As we prevent from taking a reference for every
5641          * such allocation we have to be careful when doing uncharge
5642          * (see memcg_uncharge_kmem) and here during offlining.
5643          *
5644          * The idea is that that only the _last_ uncharge which sees
5645          * the dead memcg will drop the last reference. An additional
5646          * reference is taken here before the group is marked dead
5647          * which is then paired with css_put during uncharge resp. here.
5648          *
5649          * Although this might sound strange as this path is called from
5650          * css_offline() when the referencemight have dropped down to 0
5651          * and shouldn't be incremented anymore (css_tryget would fail)
5652          * we do not have other options because of the kmem allocations
5653          * lifetime.
5654          */
5655         css_get(&memcg->css);
5656
5657         memcg_kmem_mark_dead(memcg);
5658
5659         if (res_counter_read_u64(&memcg->kmem, RES_USAGE) != 0)
5660                 return;
5661
5662         if (memcg_kmem_test_and_clear_dead(memcg))
5663                 css_put(&memcg->css);
5664 }
5665 #else
5666 static int memcg_init_kmem(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
5667 {
5668         return 0;
5669 }
5670
5671 static void memcg_destroy_kmem(struct mem_cgroup *memcg)
5672 {
5673 }
5674
5675 static void kmem_cgroup_css_offline(struct mem_cgroup *memcg)
5676 {
5677 }
5678 #endif
5679
5680 static struct cftype mem_cgroup_files[] = {
5681         {
5682                 .name = "usage_in_bytes",
5683                 .private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
5684                 .read = mem_cgroup_read,
5685                 .register_event = mem_cgroup_usage_register_event,
5686                 .unregister_event = mem_cgroup_usage_unregister_event,
5687         },
5688         {
5689                 .name = "max_usage_in_bytes",
5690                 .private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
5691                 .trigger = mem_cgroup_reset,
5692                 .read = mem_cgroup_read,
5693         },
5694         {
5695                 .name = "limit_in_bytes",
5696                 .private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
5697                 .write_string = mem_cgroup_write,
5698                 .read = mem_cgroup_read,
5699         },
5700         {
5701                 .name = "soft_limit_in_bytes",
5702                 .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
5703                 .write_string = mem_cgroup_write,
5704                 .read = mem_cgroup_read,
5705         },
5706         {
5707                 .name = "failcnt",
5708                 .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
5709                 .trigger = mem_cgroup_reset,
5710                 .read = mem_cgroup_read,
5711         },
5712         {
5713                 .name = "stat",
5714                 .read_seq_string = memcg_stat_show,
5715         },
5716         {
5717                 .name = "force_empty",
5718                 .trigger = mem_cgroup_force_empty_write,
5719         },
5720         {
5721                 .name = "use_hierarchy",
5722                 .flags = CFTYPE_INSANE,
5723                 .write_u64 = mem_cgroup_hierarchy_write,
5724                 .read_u64 = mem_cgroup_hierarchy_read,
5725         },
5726         {
5727                 .name = "swappiness",
5728                 .read_u64 = mem_cgroup_swappiness_read,
5729                 .write_u64 = mem_cgroup_swappiness_write,
5730         },
5731         {
5732                 .name = "move_charge_at_immigrate",
5733                 .read_u64 = mem_cgroup_move_charge_read,
5734                 .write_u64 = mem_cgroup_move_charge_write,
5735         },
5736         {
5737                 .name = "oom_control",
5738                 .read_map = mem_cgroup_oom_control_read,
5739                 .write_u64 = mem_cgroup_oom_control_write,
5740                 .register_event = mem_cgroup_oom_register_event,
5741                 .unregister_event = mem_cgroup_oom_unregister_event,
5742                 .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL),
5743         },
5744         {
5745                 .name = "pressure_level",
5746                 .register_event = vmpressure_register_event,
5747                 .unregister_event = vmpressure_unregister_event,
5748         },
5749 #ifdef CONFIG_NUMA
5750         {
5751                 .name = "numa_stat",
5752                 .read_seq_string = memcg_numa_stat_show,
5753         },
5754 #endif
5755 #ifdef CONFIG_MEMCG_KMEM
5756         {
5757                 .name = "kmem.limit_in_bytes",
5758                 .private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),
5759                 .write_string = mem_cgroup_write,
5760                 .read = mem_cgroup_read,
5761         },
5762         {
5763                 .name = "kmem.usage_in_bytes",
5764                 .private = MEMFILE_PRIVATE(_KMEM, RES_USAGE),
5765                 .read = mem_cgroup_read,
5766         },
5767         {
5768                 .name = "kmem.failcnt",
5769                 .private = MEMFILE_PRIVATE(_KMEM, RES_FAILCNT),
5770                 .trigger = mem_cgroup_reset,
5771                 .read = mem_cgroup_read,
5772         },
5773         {
5774                 .name = "kmem.max_usage_in_bytes",
5775                 .private = MEMFILE_PRIVATE(_KMEM, RES_MAX_USAGE),
5776                 .trigger = mem_cgroup_reset,
5777                 .read = mem_cgroup_read,
5778         },
5779 #ifdef CONFIG_SLABINFO
5780         {
5781                 .name = "kmem.slabinfo",
5782                 .read_seq_string = mem_cgroup_slabinfo_read,
5783         },
5784 #endif
5785 #endif
5786         { },    /* terminate */
5787 };
5788
5789 #ifdef CONFIG_MEMCG_SWAP
5790 static struct cftype memsw_cgroup_files[] = {
5791         {
5792                 .name = "memsw.usage_in_bytes",
5793                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_USAGE),
5794                 .read = mem_cgroup_read,
5795                 .register_event = mem_cgroup_usage_register_event,
5796                 .unregister_event = mem_cgroup_usage_unregister_event,
5797         },
5798         {
5799                 .name = "memsw.max_usage_in_bytes",
5800                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_MAX_USAGE),
5801                 .trigger = mem_cgroup_reset,
5802                 .read = mem_cgroup_read,
5803         },
5804         {
5805                 .name = "memsw.limit_in_bytes",
5806                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_LIMIT),
5807                 .write_string = mem_cgroup_write,
5808                 .read = mem_cgroup_read,
5809         },
5810         {
5811                 .name = "memsw.failcnt",
5812                 .private = MEMFILE_PRIVATE(_MEMSWAP, RES_FAILCNT),
5813                 .trigger = mem_cgroup_reset,
5814                 .read = mem_cgroup_read,
5815         },
5816         { },    /* terminate */
5817 };
5818 #endif
5819 static int alloc_mem_cgroup_per_zone_info(struct mem_cgroup *memcg, int node)
5820 {
5821         struct mem_cgroup_per_node *pn;
5822         struct mem_cgroup_per_zone *mz;
5823         int zone, tmp = node;
5824         /*
5825          * This routine is called against possible nodes.
5826          * But it's BUG to call kmalloc() against offline node.
5827          *
5828          * TODO: this routine can waste much memory for nodes which will
5829          *       never be onlined. It's better to use memory hotplug callback
5830          *       function.
5831          */
5832         if (!node_state(node, N_NORMAL_MEMORY))
5833                 tmp = -1;
5834         pn = kzalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
5835         if (!pn)
5836                 return 1;
5837
5838         for (zone = 0; zone < MAX_NR_ZONES; zone++) {
5839                 mz = &pn->zoneinfo[zone];
5840                 lruvec_init(&mz->lruvec);
5841                 mz->memcg = memcg;
5842         }
5843         memcg->nodeinfo[node] = pn;
5844         return 0;
5845 }
5846
5847 static void free_mem_cgroup_per_zone_info(struct mem_cgroup *memcg, int node)
5848 {
5849         kfree(memcg->nodeinfo[node]);
5850 }
5851
5852 static struct mem_cgroup *mem_cgroup_alloc(void)
5853 {
5854         struct mem_cgroup *memcg;
5855         size_t size = memcg_size();
5856
5857         /* Can be very big if nr_node_ids is very big */
5858         if (size < PAGE_SIZE)
5859                 memcg = kzalloc(size, GFP_KERNEL);
5860         else
5861                 memcg = vzalloc(size);
5862
5863         if (!memcg)
5864                 return NULL;
5865
5866         memcg->stat = alloc_percpu(struct mem_cgroup_stat_cpu);
5867         if (!memcg->stat)
5868                 goto out_free;
5869         spin_lock_init(&memcg->pcp_counter_lock);
5870         return memcg;
5871
5872 out_free:
5873         if (size < PAGE_SIZE)
5874                 kfree(memcg);
5875         else
5876                 vfree(memcg);
5877         return NULL;
5878 }
5879
5880 /*
5881  * At destroying mem_cgroup, references from swap_cgroup can remain.
5882  * (scanning all at force_empty is too costly...)
5883  *
5884  * Instead of clearing all references at force_empty, we remember
5885  * the number of reference from swap_cgroup and free mem_cgroup when
5886  * it goes down to 0.
5887  *
5888  * Removal of cgroup itself succeeds regardless of refs from swap.
5889  */
5890
5891 static void __mem_cgroup_free(struct mem_cgroup *memcg)
5892 {
5893         int node;
5894         size_t size = memcg_size();
5895
5896         free_css_id(&mem_cgroup_subsys, &memcg->css);
5897
5898         for_each_node(node)
5899                 free_mem_cgroup_per_zone_info(memcg, node);
5900
5901         free_percpu(memcg->stat);
5902
5903         /*
5904          * We need to make sure that (at least for now), the jump label
5905          * destruction code runs outside of the cgroup lock. This is because
5906          * get_online_cpus(), which is called from the static_branch update,
5907          * can't be called inside the cgroup_lock. cpusets are the ones
5908          * enforcing this dependency, so if they ever change, we might as well.
5909          *
5910          * schedule_work() will guarantee this happens. Be careful if you need
5911          * to move this code around, and make sure it is outside
5912          * the cgroup_lock.
5913          */
5914         disarm_static_keys(memcg);
5915         if (size < PAGE_SIZE)
5916                 kfree(memcg);
5917         else
5918                 vfree(memcg);
5919 }
5920
5921 /*
5922  * Returns the parent mem_cgroup in memcgroup hierarchy with hierarchy enabled.
5923  */
5924 struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
5925 {
5926         if (!memcg->res.parent)
5927                 return NULL;
5928         return mem_cgroup_from_res_counter(memcg->res.parent, res);
5929 }
5930 EXPORT_SYMBOL(parent_mem_cgroup);
5931
5932 static struct cgroup_subsys_state * __ref
5933 mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
5934 {
5935         struct mem_cgroup *memcg;
5936         long error = -ENOMEM;
5937         int node;
5938
5939         memcg = mem_cgroup_alloc();
5940         if (!memcg)
5941                 return ERR_PTR(error);
5942
5943         for_each_node(node)
5944                 if (alloc_mem_cgroup_per_zone_info(memcg, node))
5945                         goto free_out;
5946
5947         /* root ? */
5948         if (parent_css == NULL) {
5949                 root_mem_cgroup = memcg;
5950                 res_counter_init(&memcg->res, NULL);
5951                 res_counter_init(&memcg->memsw, NULL);
5952                 res_counter_init(&memcg->kmem, NULL);
5953         }
5954
5955         memcg->last_scanned_node = MAX_NUMNODES;
5956         INIT_LIST_HEAD(&memcg->oom_notify);
5957         memcg->move_charge_at_immigrate = 0;
5958         mutex_init(&memcg->thresholds_lock);
5959         spin_lock_init(&memcg->move_lock);
5960         vmpressure_init(&memcg->vmpressure);
5961         spin_lock_init(&memcg->soft_lock);
5962
5963         return &memcg->css;
5964
5965 free_out:
5966         __mem_cgroup_free(memcg);
5967         return ERR_PTR(error);
5968 }
5969
5970 static int
5971 mem_cgroup_css_online(struct cgroup_subsys_state *css)
5972 {
5973         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5974         struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(css));
5975         int error = 0;
5976
5977         if (!parent)
5978                 return 0;
5979
5980         mutex_lock(&memcg_create_mutex);
5981
5982         memcg->use_hierarchy = parent->use_hierarchy;
5983         memcg->oom_kill_disable = parent->oom_kill_disable;
5984         memcg->swappiness = mem_cgroup_swappiness(parent);
5985
5986         if (parent->use_hierarchy) {
5987                 res_counter_init(&memcg->res, &parent->res);
5988                 res_counter_init(&memcg->memsw, &parent->memsw);
5989                 res_counter_init(&memcg->kmem, &parent->kmem);
5990
5991                 /*
5992                  * No need to take a reference to the parent because cgroup
5993                  * core guarantees its existence.
5994                  */
5995         } else {
5996                 res_counter_init(&memcg->res, NULL);
5997                 res_counter_init(&memcg->memsw, NULL);
5998                 res_counter_init(&memcg->kmem, NULL);
5999                 /*
6000                  * Deeper hierachy with use_hierarchy == false doesn't make
6001                  * much sense so let cgroup subsystem know about this
6002                  * unfortunate state in our controller.
6003                  */
6004                 if (parent != root_mem_cgroup)
6005                         mem_cgroup_subsys.broken_hierarchy = true;
6006         }
6007
6008         error = memcg_init_kmem(memcg, &mem_cgroup_subsys);
6009         mutex_unlock(&memcg_create_mutex);
6010         return error;
6011 }
6012
6013 /*
6014  * Announce all parents that a group from their hierarchy is gone.
6015  */
6016 static void mem_cgroup_invalidate_reclaim_iterators(struct mem_cgroup *memcg)
6017 {
6018         struct mem_cgroup *parent = memcg;
6019
6020         while ((parent = parent_mem_cgroup(parent)))
6021                 mem_cgroup_iter_invalidate(parent);
6022
6023         /*
6024          * if the root memcg is not hierarchical we have to check it
6025          * explicitely.
6026          */
6027         if (!root_mem_cgroup->use_hierarchy)
6028                 mem_cgroup_iter_invalidate(root_mem_cgroup);
6029 }
6030
6031 static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
6032 {
6033         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
6034
6035         kmem_cgroup_css_offline(memcg);
6036
6037         mem_cgroup_invalidate_reclaim_iterators(memcg);
6038         mem_cgroup_reparent_charges(memcg);
6039         if (memcg->soft_contributed) {
6040                 while ((memcg = parent_mem_cgroup(memcg)))
6041                         atomic_dec(&memcg->children_in_excess);
6042         }
6043         mem_cgroup_destroy_all_caches(memcg);
6044         vmpressure_cleanup(&memcg->vmpressure);
6045 }
6046
6047 static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
6048 {
6049         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
6050
6051         memcg_destroy_kmem(memcg);
6052         __mem_cgroup_free(memcg);
6053 }
6054
6055 #ifdef CONFIG_MMU
6056 /* Handlers for move charge at task migration. */
6057 #define PRECHARGE_COUNT_AT_ONCE 256
6058 static int mem_cgroup_do_precharge(unsigned long count)
6059 {
6060         int ret = 0;
6061         int batch_count = PRECHARGE_COUNT_AT_ONCE;
6062         struct mem_cgroup *memcg = mc.to;
6063
6064         if (mem_cgroup_is_root(memcg)) {
6065                 mc.precharge += count;
6066                 /* we don't need css_get for root */
6067                 return ret;
6068         }
6069         /* try to charge at once */
6070         if (count > 1) {
6071                 struct res_counter *dummy;
6072                 /*
6073                  * "memcg" cannot be under rmdir() because we've already checked
6074                  * by cgroup_lock_live_cgroup() that it is not removed and we
6075                  * are still under the same cgroup_mutex. So we can postpone
6076                  * css_get().
6077                  */
6078                 if (res_counter_charge(&memcg->res, PAGE_SIZE * count, &dummy))
6079                         goto one_by_one;
6080                 if (do_swap_account && res_counter_charge(&memcg->memsw,
6081                                                 PAGE_SIZE * count, &dummy)) {
6082                         res_counter_uncharge(&memcg->res, PAGE_SIZE * count);
6083                         goto one_by_one;
6084                 }
6085                 mc.precharge += count;
6086                 return ret;
6087         }
6088 one_by_one:
6089         /* fall back to one by one charge */
6090         while (count--) {
6091                 if (signal_pending(current)) {
6092                         ret = -EINTR;
6093                         break;
6094                 }
6095                 if (!batch_count--) {
6096                         batch_count = PRECHARGE_COUNT_AT_ONCE;
6097                         cond_resched();
6098                 }
6099                 ret = __mem_cgroup_try_charge(NULL,
6100                                         GFP_KERNEL, 1, &memcg, false);
6101                 if (ret)
6102                         /* mem_cgroup_clear_mc() will do uncharge later */
6103                         return ret;
6104                 mc.precharge++;
6105         }
6106         return ret;
6107 }
6108
6109 /**
6110  * get_mctgt_type - get target type of moving charge
6111  * @vma: the vma the pte to be checked belongs
6112  * @addr: the address corresponding to the pte to be checked
6113  * @ptent: the pte to be checked
6114  * @target: the pointer the target page or swap ent will be stored(can be NULL)
6115  *
6116  * Returns
6117  *   0(MC_TARGET_NONE): if the pte is not a target for move charge.
6118  *   1(MC_TARGET_PAGE): if the page corresponding to this pte is a target for
6119  *     move charge. if @target is not NULL, the page is stored in target->page
6120  *     with extra refcnt got(Callers should handle it).
6121  *   2(MC_TARGET_SWAP): if the swap entry corresponding to this pte is a
6122  *     target for charge migration. if @target is not NULL, the entry is stored
6123  *     in target->ent.
6124  *
6125  * Called with pte lock held.
6126  */
6127 union mc_target {
6128         struct page     *page;
6129         swp_entry_t     ent;
6130 };
6131
6132 enum mc_target_type {
6133         MC_TARGET_NONE = 0,
6134         MC_TARGET_PAGE,
6135         MC_TARGET_SWAP,
6136 };
6137
6138 static struct page *mc_handle_present_pte(struct vm_area_struct *vma,
6139                                                 unsigned long addr, pte_t ptent)
6140 {
6141         struct page *page = vm_normal_page(vma, addr, ptent);
6142
6143         if (!page || !page_mapped(page))
6144                 return NULL;
6145         if (PageAnon(page)) {
6146                 /* we don't move shared anon */
6147                 if (!move_anon())
6148                         return NULL;
6149         } else if (!move_file())
6150                 /* we ignore mapcount for file pages */
6151                 return NULL;
6152         if (!get_page_unless_zero(page))
6153                 return NULL;
6154
6155         return page;
6156 }
6157
6158 #ifdef CONFIG_SWAP
6159 static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
6160                         unsigned long addr, pte_t ptent, swp_entry_t *entry)
6161 {
6162         struct page *page = NULL;
6163         swp_entry_t ent = pte_to_swp_entry(ptent);
6164
6165         if (!move_anon() || non_swap_entry(ent))
6166                 return NULL;
6167         /*
6168          * Because lookup_swap_cache() updates some statistics counter,
6169          * we call find_get_page() with swapper_space directly.
6170          */
6171         page = find_get_page(swap_address_space(ent), ent.val);
6172         if (do_swap_account)
6173                 entry->val = ent.val;
6174
6175         return page;
6176 }
6177 #else
6178 static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
6179                         unsigned long addr, pte_t ptent, swp_entry_t *entry)
6180 {
6181         return NULL;
6182 }
6183 #endif
6184
6185 static struct page *mc_handle_file_pte(struct vm_area_struct *vma,
6186                         unsigned long addr, pte_t ptent, swp_entry_t *entry)
6187 {
6188         struct page *page = NULL;
6189         struct address_space *mapping;
6190         pgoff_t pgoff;
6191
6192         if (!vma->vm_file) /* anonymous vma */
6193                 return NULL;
6194         if (!move_file())
6195                 return NULL;
6196
6197         mapping = vma->vm_file->f_mapping;
6198         if (pte_none(ptent))
6199                 pgoff = linear_page_index(vma, addr);
6200         else /* pte_file(ptent) is true */
6201                 pgoff = pte_to_pgoff(ptent);
6202
6203         /* page is moved even if it's not RSS of this task(page-faulted). */
6204         page = find_get_page(mapping, pgoff);
6205
6206 #ifdef CONFIG_SWAP
6207         /* shmem/tmpfs may report page out on swap: account for that too. */
6208         if (radix_tree_exceptional_entry(page)) {
6209                 swp_entry_t swap = radix_to_swp_entry(page);
6210                 if (do_swap_account)
6211                         *entry = swap;
6212                 page = find_get_page(swap_address_space(swap), swap.val);
6213         }
6214 #endif
6215         return page;
6216 }
6217
6218 static enum mc_target_type get_mctgt_type(struct vm_area_struct *vma,
6219                 unsigned long addr, pte_t ptent, union mc_target *target)
6220 {
6221         struct page *page = NULL;
6222         struct page_cgroup *pc;
6223         enum mc_target_type ret = MC_TARGET_NONE;
6224         swp_entry_t ent = { .val = 0 };
6225
6226         if (pte_present(ptent))
6227                 page = mc_handle_present_pte(vma, addr, ptent);
6228         else if (is_swap_pte(ptent))
6229                 page = mc_handle_swap_pte(vma, addr, ptent, &ent);
6230         else if (pte_none(ptent) || pte_file(ptent))
6231                 page = mc_handle_file_pte(vma, addr, ptent, &ent);
6232
6233         if (!page && !ent.val)
6234                 return ret;
6235         if (page) {
6236                 pc = lookup_page_cgroup(page);
6237                 /*
6238                  * Do only loose check w/o page_cgroup lock.
6239                  * mem_cgroup_move_account() checks the pc is valid or not under
6240                  * the lock.
6241                  */
6242                 if (PageCgroupUsed(pc) && pc->mem_cgroup == mc.from) {
6243                         ret = MC_TARGET_PAGE;
6244                         if (target)
6245                                 target->page = page;
6246                 }
6247                 if (!ret || !target)
6248                         put_page(page);
6249         }
6250         /* There is a swap entry and a page doesn't exist or isn't charged */
6251         if (ent.val && !ret &&
6252                         css_id(&mc.from->css) == lookup_swap_cgroup_id(ent)) {
6253                 ret = MC_TARGET_SWAP;
6254                 if (target)
6255                         target->ent = ent;
6256         }
6257         return ret;
6258 }
6259
6260 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
6261 /*
6262  * We don't consider swapping or file mapped pages because THP does not
6263  * support them for now.
6264  * Caller should make sure that pmd_trans_huge(pmd) is true.
6265  */
6266 static enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
6267                 unsigned long addr, pmd_t pmd, union mc_target *target)
6268 {
6269         struct page *page = NULL;
6270         struct page_cgroup *pc;
6271         enum mc_target_type ret = MC_TARGET_NONE;
6272
6273         page = pmd_page(pmd);
6274         VM_BUG_ON(!page || !PageHead(page));
6275         if (!move_anon())
6276                 return ret;
6277         pc = lookup_page_cgroup(page);
6278         if (PageCgroupUsed(pc) && pc->mem_cgroup == mc.from) {
6279                 ret = MC_TARGET_PAGE;
6280                 if (target) {
6281                         get_page(page);
6282                         target->page = page;
6283                 }
6284         }
6285         return ret;
6286 }
6287 #else
6288 static inline enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
6289                 unsigned long addr, pmd_t pmd, union mc_target *target)
6290 {
6291         return MC_TARGET_NONE;
6292 }
6293 #endif
6294
6295 static int mem_cgroup_count_precharge_pte_range(pmd_t *pmd,
6296                                         unsigned long addr, unsigned long end,
6297                                         struct mm_walk *walk)
6298 {
6299         struct vm_area_struct *vma = walk->private;
6300         pte_t *pte;
6301         spinlock_t *ptl;
6302
6303         if (pmd_trans_huge_lock(pmd, vma) == 1) {
6304                 if (get_mctgt_type_thp(vma, addr, *pmd, NULL) == MC_TARGET_PAGE)
6305                         mc.precharge += HPAGE_PMD_NR;
6306                 spin_unlock(&vma->vm_mm->page_table_lock);
6307                 return 0;
6308         }
6309
6310         if (pmd_trans_unstable(pmd))
6311                 return 0;
6312         pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
6313         for (; addr != end; pte++, addr += PAGE_SIZE)
6314                 if (get_mctgt_type(vma, addr, *pte, NULL))
6315                         mc.precharge++; /* increment precharge temporarily */
6316         pte_unmap_unlock(pte - 1, ptl);
6317         cond_resched();
6318
6319         return 0;
6320 }
6321
6322 static unsigned long mem_cgroup_count_precharge(struct mm_struct *mm)
6323 {
6324         unsigned long precharge;
6325         struct vm_area_struct *vma;
6326
6327         down_read(&mm->mmap_sem);
6328         for (vma = mm->mmap; vma; vma = vma->vm_next) {
6329                 struct mm_walk mem_cgroup_count_precharge_walk = {
6330                         .pmd_entry = mem_cgroup_count_precharge_pte_range,
6331                         .mm = mm,
6332                         .private = vma,
6333                 };
6334                 if (is_vm_hugetlb_page(vma))
6335                         continue;
6336                 walk_page_range(vma->vm_start, vma->vm_end,
6337                                         &mem_cgroup_count_precharge_walk);
6338         }
6339         up_read(&mm->mmap_sem);
6340
6341         precharge = mc.precharge;
6342         mc.precharge = 0;
6343
6344         return precharge;
6345 }
6346
6347 static int mem_cgroup_precharge_mc(struct mm_struct *mm)
6348 {
6349         unsigned long precharge = mem_cgroup_count_precharge(mm);
6350
6351         VM_BUG_ON(mc.moving_task);
6352         mc.moving_task = current;
6353         return mem_cgroup_do_precharge(precharge);
6354 }
6355
6356 /* cancels all extra charges on mc.from and mc.to, and wakes up all waiters. */
6357 static void __mem_cgroup_clear_mc(void)
6358 {
6359         struct mem_cgroup *from = mc.from;
6360         struct mem_cgroup *to = mc.to;
6361         int i;
6362
6363         /* we must uncharge all the leftover precharges from mc.to */
6364         if (mc.precharge) {
6365                 __mem_cgroup_cancel_charge(mc.to, mc.precharge);
6366                 mc.precharge = 0;
6367         }
6368         /*
6369          * we didn't uncharge from mc.from at mem_cgroup_move_account(), so
6370          * we must uncharge here.
6371          */
6372         if (mc.moved_charge) {
6373                 __mem_cgroup_cancel_charge(mc.from, mc.moved_charge);
6374                 mc.moved_charge = 0;
6375         }
6376         /* we must fixup refcnts and charges */
6377         if (mc.moved_swap) {
6378                 /* uncharge swap account from the old cgroup */
6379                 if (!mem_cgroup_is_root(mc.from))
6380                         res_counter_uncharge(&mc.from->memsw,
6381                                                 PAGE_SIZE * mc.moved_swap);
6382
6383                 for (i = 0; i < mc.moved_swap; i++)
6384                         css_put(&mc.from->css);
6385
6386                 if (!mem_cgroup_is_root(mc.to)) {
6387                         /*
6388                          * we charged both to->res and to->memsw, so we should
6389                          * uncharge to->res.
6390                          */
6391                         res_counter_uncharge(&mc.to->res,
6392                                                 PAGE_SIZE * mc.moved_swap);
6393                 }
6394                 /* we've already done css_get(mc.to) */
6395                 mc.moved_swap = 0;
6396         }
6397         memcg_oom_recover(from);
6398         memcg_oom_recover(to);
6399         wake_up_all(&mc.waitq);
6400 }
6401
6402 static void mem_cgroup_clear_mc(void)
6403 {
6404         struct mem_cgroup *from = mc.from;
6405
6406         /*
6407          * we must clear moving_task before waking up waiters at the end of
6408          * task migration.
6409          */
6410         mc.moving_task = NULL;
6411         __mem_cgroup_clear_mc();
6412         spin_lock(&mc.lock);
6413         mc.from = NULL;
6414         mc.to = NULL;
6415         spin_unlock(&mc.lock);
6416         mem_cgroup_end_move(from);
6417 }
6418
6419 static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
6420                                  struct cgroup_taskset *tset)
6421 {
6422         struct task_struct *p = cgroup_taskset_first(tset);
6423         int ret = 0;
6424         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
6425         unsigned long move_charge_at_immigrate;
6426
6427         /*
6428          * We are now commited to this value whatever it is. Changes in this
6429          * tunable will only affect upcoming migrations, not the current one.
6430          * So we need to save it, and keep it going.
6431          */
6432         move_charge_at_immigrate  = memcg->move_charge_at_immigrate;
6433         if (move_charge_at_immigrate) {
6434                 struct mm_struct *mm;
6435                 struct mem_cgroup *from = mem_cgroup_from_task(p);
6436
6437                 VM_BUG_ON(from == memcg);
6438
6439                 mm = get_task_mm(p);
6440                 if (!mm)
6441                         return 0;
6442                 /* We move charges only when we move a owner of the mm */
6443                 if (mm->owner == p) {
6444                         VM_BUG_ON(mc.from);
6445                         VM_BUG_ON(mc.to);
6446                         VM_BUG_ON(mc.precharge);
6447                         VM_BUG_ON(mc.moved_charge);
6448                         VM_BUG_ON(mc.moved_swap);
6449                         mem_cgroup_start_move(from);
6450                         spin_lock(&mc.lock);
6451                         mc.from = from;
6452                         mc.to = memcg;
6453                         mc.immigrate_flags = move_charge_at_immigrate;
6454                         spin_unlock(&mc.lock);
6455                         /* We set mc.moving_task later */
6456
6457                         ret = mem_cgroup_precharge_mc(mm);
6458                         if (ret)
6459                                 mem_cgroup_clear_mc();
6460                 }
6461                 mmput(mm);
6462         }
6463         return ret;
6464 }
6465
6466 static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
6467                                      struct cgroup_taskset *tset)
6468 {
6469         mem_cgroup_clear_mc();
6470 }
6471
6472 static int mem_cgroup_move_charge_pte_range(pmd_t *pmd,
6473                                 unsigned long addr, unsigned long end,
6474                                 struct mm_walk *walk)
6475 {
6476         int ret = 0;
6477         struct vm_area_struct *vma = walk->private;
6478         pte_t *pte;
6479         spinlock_t *ptl;
6480         enum mc_target_type target_type;
6481         union mc_target target;
6482         struct page *page;
6483         struct page_cgroup *pc;
6484
6485         /*
6486          * We don't take compound_lock() here but no race with splitting thp
6487          * happens because:
6488          *  - if pmd_trans_huge_lock() returns 1, the relevant thp is not
6489          *    under splitting, which means there's no concurrent thp split,
6490          *  - if another thread runs into split_huge_page() just after we
6491          *    entered this if-block, the thread must wait for page table lock
6492          *    to be unlocked in __split_huge_page_splitting(), where the main
6493          *    part of thp split is not executed yet.
6494          */
6495         if (pmd_trans_huge_lock(pmd, vma) == 1) {
6496                 if (mc.precharge < HPAGE_PMD_NR) {
6497                         spin_unlock(&vma->vm_mm->page_table_lock);
6498                         return 0;
6499                 }
6500                 target_type = get_mctgt_type_thp(vma, addr, *pmd, &target);
6501                 if (target_type == MC_TARGET_PAGE) {
6502                         page = target.page;
6503                         if (!isolate_lru_page(page)) {
6504                                 pc = lookup_page_cgroup(page);
6505                                 if (!mem_cgroup_move_account(page, HPAGE_PMD_NR,
6506                                                         pc, mc.from, mc.to)) {
6507                                         mc.precharge -= HPAGE_PMD_NR;
6508                                         mc.moved_charge += HPAGE_PMD_NR;
6509                                 }
6510                                 putback_lru_page(page);
6511                         }
6512                         put_page(page);
6513                 }
6514                 spin_unlock(&vma->vm_mm->page_table_lock);
6515                 return 0;
6516         }
6517
6518         if (pmd_trans_unstable(pmd))
6519                 return 0;
6520 retry:
6521         pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
6522         for (; addr != end; addr += PAGE_SIZE) {
6523                 pte_t ptent = *(pte++);
6524                 swp_entry_t ent;
6525
6526                 if (!mc.precharge)
6527                         break;
6528
6529                 switch (get_mctgt_type(vma, addr, ptent, &target)) {
6530                 case MC_TARGET_PAGE:
6531                         page = target.page;
6532                         if (isolate_lru_page(page))
6533                                 goto put;
6534                         pc = lookup_page_cgroup(page);
6535                         if (!mem_cgroup_move_account(page, 1, pc,
6536                                                      mc.from, mc.to)) {
6537                                 mc.precharge--;
6538                                 /* we uncharge from mc.from later. */
6539                                 mc.moved_charge++;
6540                         }
6541                         putback_lru_page(page);
6542 put:                    /* get_mctgt_type() gets the page */
6543                         put_page(page);
6544                         break;
6545                 case MC_TARGET_SWAP:
6546                         ent = target.ent;
6547                         if (!mem_cgroup_move_swap_account(ent, mc.from, mc.to)) {
6548                                 mc.precharge--;
6549                                 /* we fixup refcnts and charges later. */
6550                                 mc.moved_swap++;
6551                         }
6552                         break;
6553                 default:
6554                         break;
6555                 }
6556         }
6557         pte_unmap_unlock(pte - 1, ptl);
6558         cond_resched();
6559
6560         if (addr != end) {
6561                 /*
6562                  * We have consumed all precharges we got in can_attach().
6563                  * We try charge one by one, but don't do any additional
6564                  * charges to mc.to if we have failed in charge once in attach()
6565                  * phase.
6566                  */
6567                 ret = mem_cgroup_do_precharge(1);
6568                 if (!ret)
6569                         goto retry;
6570         }
6571
6572         return ret;
6573 }
6574
6575 static void mem_cgroup_move_charge(struct mm_struct *mm)
6576 {
6577         struct vm_area_struct *vma;
6578
6579         lru_add_drain_all();
6580 retry:
6581         if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
6582                 /*
6583                  * Someone who are holding the mmap_sem might be waiting in
6584                  * waitq. So we cancel all extra charges, wake up all waiters,
6585                  * and retry. Because we cancel precharges, we might not be able
6586                  * to move enough charges, but moving charge is a best-effort
6587                  * feature anyway, so it wouldn't be a big problem.
6588                  */
6589                 __mem_cgroup_clear_mc();
6590                 cond_resched();
6591                 goto retry;
6592         }
6593         for (vma = mm->mmap; vma; vma = vma->vm_next) {
6594                 int ret;
6595                 struct mm_walk mem_cgroup_move_charge_walk = {
6596                         .pmd_entry = mem_cgroup_move_charge_pte_range,
6597                         .mm = mm,
6598                         .private = vma,
6599                 };
6600                 if (is_vm_hugetlb_page(vma))
6601                         continue;
6602                 ret = walk_page_range(vma->vm_start, vma->vm_end,
6603                                                 &mem_cgroup_move_charge_walk);
6604                 if (ret)
6605                         /*
6606                          * means we have consumed all precharges and failed in
6607                          * doing additional charge. Just abandon here.
6608                          */
6609                         break;
6610         }
6611         up_read(&mm->mmap_sem);
6612 }
6613
6614 static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
6615                                  struct cgroup_taskset *tset)
6616 {
6617         struct task_struct *p = cgroup_taskset_first(tset);
6618         struct mm_struct *mm = get_task_mm(p);
6619
6620         if (mm) {
6621                 if (mc.to)
6622                         mem_cgroup_move_charge(mm);
6623                 mmput(mm);
6624         }
6625         if (mc.to)
6626                 mem_cgroup_clear_mc();
6627 }
6628 #else   /* !CONFIG_MMU */
6629 static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
6630                                  struct cgroup_taskset *tset)
6631 {
6632         return 0;
6633 }
6634 static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
6635                                      struct cgroup_taskset *tset)
6636 {
6637 }
6638 static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
6639                                  struct cgroup_taskset *tset)
6640 {
6641 }
6642 #endif
6643
6644 /*
6645  * Cgroup retains root cgroups across [un]mount cycles making it necessary
6646  * to verify sane_behavior flag on each mount attempt.
6647  */
6648 static void mem_cgroup_bind(struct cgroup_subsys_state *root_css)
6649 {
6650         /*
6651          * use_hierarchy is forced with sane_behavior.  cgroup core
6652          * guarantees that @root doesn't have any children, so turning it
6653          * on for the root memcg is enough.
6654          */
6655         if (cgroup_sane_behavior(root_css->cgroup))
6656                 mem_cgroup_from_css(root_css)->use_hierarchy = true;
6657 }
6658
6659 struct cgroup_subsys mem_cgroup_subsys = {
6660         .name = "memory",
6661         .subsys_id = mem_cgroup_subsys_id,
6662         .css_alloc = mem_cgroup_css_alloc,
6663         .css_online = mem_cgroup_css_online,
6664         .css_offline = mem_cgroup_css_offline,
6665         .css_free = mem_cgroup_css_free,
6666         .can_attach = mem_cgroup_can_attach,
6667         .cancel_attach = mem_cgroup_cancel_attach,
6668         .attach = mem_cgroup_move_task,
6669         .bind = mem_cgroup_bind,
6670         .base_cftypes = mem_cgroup_files,
6671         .early_init = 0,
6672         .use_id = 1,
6673 };
6674
6675 #ifdef CONFIG_MEMCG_SWAP
6676 static int __init enable_swap_account(char *s)
6677 {
6678         if (!strcmp(s, "1"))
6679                 really_do_swap_account = 1;
6680         else if (!strcmp(s, "0"))
6681                 really_do_swap_account = 0;
6682         return 1;
6683 }
6684 __setup("swapaccount=", enable_swap_account);
6685
6686 static void __init memsw_file_init(void)
6687 {
6688         WARN_ON(cgroup_add_cftypes(&mem_cgroup_subsys, memsw_cgroup_files));
6689 }
6690
6691 static void __init enable_swap_cgroup(void)
6692 {
6693         if (!mem_cgroup_disabled() && really_do_swap_account) {
6694                 do_swap_account = 1;
6695                 memsw_file_init();
6696         }
6697 }
6698
6699 #else
6700 static void __init enable_swap_cgroup(void)
6701 {
6702 }
6703 #endif
6704
6705 /*
6706  * subsys_initcall() for memory controller.
6707  *
6708  * Some parts like hotcpu_notifier() have to be initialized from this context
6709  * because of lock dependencies (cgroup_lock -> cpu hotplug) but basically
6710  * everything that doesn't depend on a specific mem_cgroup structure should
6711  * be initialized from here.
6712  */
6713 static int __init mem_cgroup_init(void)
6714 {
6715         hotcpu_notifier(memcg_cpu_hotplug_callback, 0);
6716         enable_swap_cgroup();
6717         memcg_stock_init();
6718         return 0;
6719 }
6720 subsys_initcall(mem_cgroup_init);