Merge branch 'fixes' of git://git.linaro.org/people/rmk/linux-arm
[opensuse: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/rbtree.h>
43 #include <linux/slab.h>
44 #include <linux/swap.h>
45 #include <linux/swapops.h>
46 #include <linux/spinlock.h>
47 #include <linux/eventfd.h>
48 #include <linux/sort.h>
49 #include <linux/fs.h>
50 #include <linux/seq_file.h>
51 #include <linux/vmalloc.h>
52 #include <linux/vmpressure.h>
53 #include <linux/mm_inline.h>
54 #include <linux/page_cgroup.h>
55 #include <linux/cpu.h>
56 #include <linux/oom.h>
57 #include "internal.h"
58 #include <net/sock.h>
59 #include <net/ip.h>
60 #include <net/tcp_memcontrol.h>
61
62 #include <asm/uaccess.h>
63
64 #include <trace/events/vmscan.h>
65
66 struct cgroup_subsys mem_cgroup_subsys __read_mostly;
67 EXPORT_SYMBOL(mem_cgroup_subsys);
68
69 #define MEM_CGROUP_RECLAIM_RETRIES      5
70 static struct mem_cgroup *root_mem_cgroup __read_mostly;
71
72 #ifdef CONFIG_MEMCG_SWAP
73 /* Turned on only when memory cgroup is enabled && really_do_swap_account = 1 */
74 int do_swap_account __read_mostly;
75
76 /* for remember boot option*/
77 #ifdef CONFIG_MEMCG_SWAP_ENABLED
78 static int really_do_swap_account __initdata = 1;
79 #else
80 static int really_do_swap_account __initdata = 0;
81 #endif
82
83 #else
84 #define do_swap_account         0
85 #endif
86
87
88 static const char * const mem_cgroup_stat_names[] = {
89         "cache",
90         "rss",
91         "rss_huge",
92         "mapped_file",
93         "writeback",
94         "swap",
95 };
96
97 enum mem_cgroup_events_index {
98         MEM_CGROUP_EVENTS_PGPGIN,       /* # of pages paged in */
99         MEM_CGROUP_EVENTS_PGPGOUT,      /* # of pages paged out */
100         MEM_CGROUP_EVENTS_PGFAULT,      /* # of page-faults */
101         MEM_CGROUP_EVENTS_PGMAJFAULT,   /* # of major page-faults */
102         MEM_CGROUP_EVENTS_NSTATS,
103 };
104
105 static const char * const mem_cgroup_events_names[] = {
106         "pgpgin",
107         "pgpgout",
108         "pgfault",
109         "pgmajfault",
110 };
111
112 static const char * const mem_cgroup_lru_names[] = {
113         "inactive_anon",
114         "active_anon",
115         "inactive_file",
116         "active_file",
117         "unevictable",
118 };
119
120 /*
121  * Per memcg event counter is incremented at every pagein/pageout. With THP,
122  * it will be incremated by the number of pages. This counter is used for
123  * for trigger some periodic events. This is straightforward and better
124  * than using jiffies etc. to handle periodic memcg event.
125  */
126 enum mem_cgroup_events_target {
127         MEM_CGROUP_TARGET_THRESH,
128         MEM_CGROUP_TARGET_SOFTLIMIT,
129         MEM_CGROUP_TARGET_NUMAINFO,
130         MEM_CGROUP_NTARGETS,
131 };
132 #define THRESHOLDS_EVENTS_TARGET 128
133 #define SOFTLIMIT_EVENTS_TARGET 1024
134 #define NUMAINFO_EVENTS_TARGET  1024
135
136 struct mem_cgroup_stat_cpu {
137         long count[MEM_CGROUP_STAT_NSTATS];
138         unsigned long events[MEM_CGROUP_EVENTS_NSTATS];
139         unsigned long nr_page_events;
140         unsigned long targets[MEM_CGROUP_NTARGETS];
141 };
142
143 struct mem_cgroup_reclaim_iter {
144         /*
145          * last scanned hierarchy member. Valid only if last_dead_count
146          * matches memcg->dead_count of the hierarchy root group.
147          */
148         struct mem_cgroup *last_visited;
149         unsigned long last_dead_count;
150
151         /* scan generation, increased every round-trip */
152         unsigned int generation;
153 };
154
155 /*
156  * per-zone information in memory controller.
157  */
158 struct mem_cgroup_per_zone {
159         struct lruvec           lruvec;
160         unsigned long           lru_size[NR_LRU_LISTS];
161
162         struct mem_cgroup_reclaim_iter reclaim_iter[DEF_PRIORITY + 1];
163
164         struct rb_node          tree_node;      /* RB tree node */
165         unsigned long long      usage_in_excess;/* Set to the value by which */
166                                                 /* the soft limit is exceeded*/
167         bool                    on_tree;
168         struct mem_cgroup       *memcg;         /* Back pointer, we cannot */
169                                                 /* use container_of        */
170 };
171
172 struct mem_cgroup_per_node {
173         struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
174 };
175
176 /*
177  * Cgroups above their limits are maintained in a RB-Tree, independent of
178  * their hierarchy representation
179  */
180
181 struct mem_cgroup_tree_per_zone {
182         struct rb_root rb_root;
183         spinlock_t lock;
184 };
185
186 struct mem_cgroup_tree_per_node {
187         struct mem_cgroup_tree_per_zone rb_tree_per_zone[MAX_NR_ZONES];
188 };
189
190 struct mem_cgroup_tree {
191         struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
192 };
193
194 static struct mem_cgroup_tree soft_limit_tree __read_mostly;
195
196 struct mem_cgroup_threshold {
197         struct eventfd_ctx *eventfd;
198         u64 threshold;
199 };
200
201 /* For threshold */
202 struct mem_cgroup_threshold_ary {
203         /* An array index points to threshold just below or equal to usage. */
204         int current_threshold;
205         /* Size of entries[] */
206         unsigned int size;
207         /* Array of thresholds */
208         struct mem_cgroup_threshold entries[0];
209 };
210
211 struct mem_cgroup_thresholds {
212         /* Primary thresholds array */
213         struct mem_cgroup_threshold_ary *primary;
214         /*
215          * Spare threshold array.
216          * This is needed to make mem_cgroup_unregister_event() "never fail".
217          * It must be able to store at least primary->size - 1 entries.
218          */
219         struct mem_cgroup_threshold_ary *spare;
220 };
221
222 /* for OOM */
223 struct mem_cgroup_eventfd_list {
224         struct list_head list;
225         struct eventfd_ctx *eventfd;
226 };
227
228 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
229 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
230
231 /*
232  * The memory controller data structure. The memory controller controls both
233  * page cache and RSS per cgroup. We would eventually like to provide
234  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
235  * to help the administrator determine what knobs to tune.
236  *
237  * TODO: Add a water mark for the memory controller. Reclaim will begin when
238  * we hit the water mark. May be even add a low water mark, such that
239  * no reclaim occurs from a cgroup at it's low water mark, this is
240  * a feature that will be implemented much later in the future.
241  */
242 struct mem_cgroup {
243         struct cgroup_subsys_state css;
244         /*
245          * the counter to account for memory usage
246          */
247         struct res_counter res;
248
249         /* vmpressure notifications */
250         struct vmpressure vmpressure;
251
252         /*
253          * the counter to account for mem+swap usage.
254          */
255         struct res_counter memsw;
256
257         /*
258          * the counter to account for kernel memory usage.
259          */
260         struct res_counter kmem;
261         /*
262          * Should the accounting and control be hierarchical, per subtree?
263          */
264         bool use_hierarchy;
265         unsigned long kmem_account_flags; /* See KMEM_ACCOUNTED_*, below */
266
267         bool            oom_lock;
268         atomic_t        under_oom;
269         atomic_t        oom_wakeups;
270
271         int     swappiness;
272         /* OOM-Killer disable */
273         int             oom_kill_disable;
274
275         /* set when res.limit == memsw.limit */
276         bool            memsw_is_minimum;
277
278         /* protect arrays of thresholds */
279         struct mutex thresholds_lock;
280
281         /* thresholds for memory usage. RCU-protected */
282         struct mem_cgroup_thresholds thresholds;
283
284         /* thresholds for mem+swap usage. RCU-protected */
285         struct mem_cgroup_thresholds memsw_thresholds;
286
287         /* For oom notifier event fd */
288         struct list_head oom_notify;
289
290         /*
291          * Should we move charges of a task when a task is moved into this
292          * mem_cgroup ? And what type of charges should we move ?
293          */
294         unsigned long move_charge_at_immigrate;
295         /*
296          * set > 0 if pages under this cgroup are moving to other cgroup.
297          */
298         atomic_t        moving_account;
299         /* taken only while moving_account > 0 */
300         spinlock_t      move_lock;
301         /*
302          * percpu counter.
303          */
304         struct mem_cgroup_stat_cpu __percpu *stat;
305         /*
306          * used when a cpu is offlined or other synchronizations
307          * See mem_cgroup_read_stat().
308          */
309         struct mem_cgroup_stat_cpu nocpu_base;
310         spinlock_t pcp_counter_lock;
311
312         atomic_t        dead_count;
313 #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
314         struct tcp_memcontrol tcp_mem;
315 #endif
316 #if defined(CONFIG_MEMCG_KMEM)
317         /* analogous to slab_common's slab_caches list. per-memcg */
318         struct list_head memcg_slab_caches;
319         /* Not a spinlock, we can take a lot of time walking the list */
320         struct mutex slab_caches_mutex;
321         /* Index in the kmem_cache->memcg_params->memcg_caches array */
322         int kmemcg_id;
323 #endif
324
325         int last_scanned_node;
326 #if MAX_NUMNODES > 1
327         nodemask_t      scan_nodes;
328         atomic_t        numainfo_events;
329         atomic_t        numainfo_updating;
330 #endif
331
332         struct mem_cgroup_per_node *nodeinfo[0];
333         /* WARNING: nodeinfo must be the last member here */
334 };
335
336 static size_t memcg_size(void)
337 {
338         return sizeof(struct mem_cgroup) +
339                 nr_node_ids * sizeof(struct mem_cgroup_per_node);
340 }
341
342 /* internal only representation about the status of kmem accounting. */
343 enum {
344         KMEM_ACCOUNTED_ACTIVE = 0, /* accounted by this cgroup itself */
345         KMEM_ACCOUNTED_ACTIVATED, /* static key enabled. */
346         KMEM_ACCOUNTED_DEAD, /* dead memcg with pending kmem charges */
347 };
348
349 /* We account when limit is on, but only after call sites are patched */
350 #define KMEM_ACCOUNTED_MASK \
351                 ((1 << KMEM_ACCOUNTED_ACTIVE) | (1 << KMEM_ACCOUNTED_ACTIVATED))
352
353 #ifdef CONFIG_MEMCG_KMEM
354 static inline void memcg_kmem_set_active(struct mem_cgroup *memcg)
355 {
356         set_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
357 }
358
359 static bool memcg_kmem_is_active(struct mem_cgroup *memcg)
360 {
361         return test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags);
362 }
363
364 static void memcg_kmem_set_activated(struct mem_cgroup *memcg)
365 {
366         set_bit(KMEM_ACCOUNTED_ACTIVATED, &memcg->kmem_account_flags);
367 }
368
369 static void memcg_kmem_clear_activated(struct mem_cgroup *memcg)
370 {
371         clear_bit(KMEM_ACCOUNTED_ACTIVATED, &memcg->kmem_account_flags);
372 }
373
374 static void memcg_kmem_mark_dead(struct mem_cgroup *memcg)
375 {
376         /*
377          * Our caller must use css_get() first, because memcg_uncharge_kmem()
378          * will call css_put() if it sees the memcg is dead.
379          */
380         smp_wmb();
381         if (test_bit(KMEM_ACCOUNTED_ACTIVE, &memcg->kmem_account_flags))
382                 set_bit(KMEM_ACCOUNTED_DEAD, &memcg->kmem_account_flags);
383 }
384
385 static bool memcg_kmem_test_and_clear_dead(struct mem_cgroup *memcg)
386 {
387         return test_and_clear_bit(KMEM_ACCOUNTED_DEAD,
388                                   &memcg->kmem_account_flags);
389 }
390 #endif
391
392 /* Stuffs for move charges at task migration. */
393 /*
394  * Types of charges to be moved. "move_charge_at_immitgrate" and
395  * "immigrate_flags" are treated as a left-shifted bitmap of these types.
396  */
397 enum move_type {
398         MOVE_CHARGE_TYPE_ANON,  /* private anonymous page and swap of it */
399         MOVE_CHARGE_TYPE_FILE,  /* file page(including tmpfs) and swap of it */
400         NR_MOVE_TYPE,
401 };
402
403 /* "mc" and its members are protected by cgroup_mutex */
404 static struct move_charge_struct {
405         spinlock_t        lock; /* for from, to */
406         struct mem_cgroup *from;
407         struct mem_cgroup *to;
408         unsigned long immigrate_flags;
409         unsigned long precharge;
410         unsigned long moved_charge;
411         unsigned long moved_swap;
412         struct task_struct *moving_task;        /* a task moving charges */
413         wait_queue_head_t waitq;                /* a waitq for other context */
414 } mc = {
415         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
416         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
417 };
418
419 static bool move_anon(void)
420 {
421         return test_bit(MOVE_CHARGE_TYPE_ANON, &mc.immigrate_flags);
422 }
423
424 static bool move_file(void)
425 {
426         return test_bit(MOVE_CHARGE_TYPE_FILE, &mc.immigrate_flags);
427 }
428
429 /*
430  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
431  * limit reclaim to prevent infinite loops, if they ever occur.
432  */
433 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
434 #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
435
436 enum charge_type {
437         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
438         MEM_CGROUP_CHARGE_TYPE_ANON,
439         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
440         MEM_CGROUP_CHARGE_TYPE_DROP,    /* a page was unused swap cache */
441         NR_CHARGE_TYPE,
442 };
443
444 /* for encoding cft->private value on file */
445 enum res_type {
446         _MEM,
447         _MEMSWAP,
448         _OOM_TYPE,
449         _KMEM,
450 };
451
452 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
453 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
454 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
455 /* Used for OOM nofiier */
456 #define OOM_CONTROL             (0)
457
458 /*
459  * Reclaim flags for mem_cgroup_hierarchical_reclaim
460  */
461 #define MEM_CGROUP_RECLAIM_NOSWAP_BIT   0x0
462 #define MEM_CGROUP_RECLAIM_NOSWAP       (1 << MEM_CGROUP_RECLAIM_NOSWAP_BIT)
463 #define MEM_CGROUP_RECLAIM_SHRINK_BIT   0x1
464 #define MEM_CGROUP_RECLAIM_SHRINK       (1 << MEM_CGROUP_RECLAIM_SHRINK_BIT)
465
466 /*
467  * The memcg_create_mutex will be held whenever a new cgroup is created.
468  * As a consequence, any change that needs to protect against new child cgroups
469  * appearing has to hold it as well.
470  */
471 static DEFINE_MUTEX(memcg_create_mutex);
472
473 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
474 {
475         return s ? container_of(s, struct mem_cgroup, css) : NULL;
476 }
477
478 /* Some nice accessors for the vmpressure. */
479 struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
480 {
481         if (!memcg)
482                 memcg = root_mem_cgroup;
483         return &memcg->vmpressure;
484 }
485
486 struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
487 {
488         return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
489 }
490
491 struct vmpressure *css_to_vmpressure(struct cgroup_subsys_state *css)
492 {
493         return &mem_cgroup_from_css(css)->vmpressure;
494 }
495
496 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
497 {
498         return (memcg == root_mem_cgroup);
499 }
500
501 /* Writing them here to avoid exposing memcg's inner layout */
502 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
503
504 void sock_update_memcg(struct sock *sk)
505 {
506         if (mem_cgroup_sockets_enabled) {
507                 struct mem_cgroup *memcg;
508                 struct cg_proto *cg_proto;
509
510                 BUG_ON(!sk->sk_prot->proto_cgroup);
511
512                 /* Socket cloning can throw us here with sk_cgrp already
513                  * filled. It won't however, necessarily happen from
514                  * process context. So the test for root memcg given
515                  * the current task's memcg won't help us in this case.
516                  *
517                  * Respecting the original socket's memcg is a better
518                  * decision in this case.
519                  */
520                 if (sk->sk_cgrp) {
521                         BUG_ON(mem_cgroup_is_root(sk->sk_cgrp->memcg));
522                         css_get(&sk->sk_cgrp->memcg->css);
523                         return;
524                 }
525
526                 rcu_read_lock();
527                 memcg = mem_cgroup_from_task(current);
528                 cg_proto = sk->sk_prot->proto_cgroup(memcg);
529                 if (!mem_cgroup_is_root(memcg) &&
530                     memcg_proto_active(cg_proto) && css_tryget(&memcg->css)) {
531                         sk->sk_cgrp = cg_proto;
532                 }
533                 rcu_read_unlock();
534         }
535 }
536 EXPORT_SYMBOL(sock_update_memcg);
537
538 void sock_release_memcg(struct sock *sk)
539 {
540         if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
541                 struct mem_cgroup *memcg;
542                 WARN_ON(!sk->sk_cgrp->memcg);
543                 memcg = sk->sk_cgrp->memcg;
544                 css_put(&sk->sk_cgrp->memcg->css);
545         }
546 }
547
548 struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
549 {
550         if (!memcg || mem_cgroup_is_root(memcg))
551                 return NULL;
552
553         return &memcg->tcp_mem.cg_proto;
554 }
555 EXPORT_SYMBOL(tcp_proto_cgroup);
556
557 static void disarm_sock_keys(struct mem_cgroup *memcg)
558 {
559         if (!memcg_proto_activated(&memcg->tcp_mem.cg_proto))
560                 return;
561         static_key_slow_dec(&memcg_socket_limit_enabled);
562 }
563 #else
564 static void disarm_sock_keys(struct mem_cgroup *memcg)
565 {
566 }
567 #endif
568
569 #ifdef CONFIG_MEMCG_KMEM
570 /*
571  * This will be the memcg's index in each cache's ->memcg_params->memcg_caches.
572  * There are two main reasons for not using the css_id for this:
573  *  1) this works better in sparse environments, where we have a lot of memcgs,
574  *     but only a few kmem-limited. Or also, if we have, for instance, 200
575  *     memcgs, and none but the 200th is kmem-limited, we'd have to have a
576  *     200 entry array for that.
577  *
578  *  2) In order not to violate the cgroup API, we would like to do all memory
579  *     allocation in ->create(). At that point, we haven't yet allocated the
580  *     css_id. Having a separate index prevents us from messing with the cgroup
581  *     core for this
582  *
583  * The current size of the caches array is stored in
584  * memcg_limited_groups_array_size.  It will double each time we have to
585  * increase it.
586  */
587 static DEFINE_IDA(kmem_limited_groups);
588 int memcg_limited_groups_array_size;
589
590 /*
591  * MIN_SIZE is different than 1, because we would like to avoid going through
592  * the alloc/free process all the time. In a small machine, 4 kmem-limited
593  * cgroups is a reasonable guess. In the future, it could be a parameter or
594  * tunable, but that is strictly not necessary.
595  *
596  * MAX_SIZE should be as large as the number of css_ids. Ideally, we could get
597  * this constant directly from cgroup, but it is understandable that this is
598  * better kept as an internal representation in cgroup.c. In any case, the
599  * css_id space is not getting any smaller, and we don't have to necessarily
600  * increase ours as well if it increases.
601  */
602 #define MEMCG_CACHES_MIN_SIZE 4
603 #define MEMCG_CACHES_MAX_SIZE 65535
604
605 /*
606  * A lot of the calls to the cache allocation functions are expected to be
607  * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
608  * conditional to this static branch, we'll have to allow modules that does
609  * kmem_cache_alloc and the such to see this symbol as well
610  */
611 struct static_key memcg_kmem_enabled_key;
612 EXPORT_SYMBOL(memcg_kmem_enabled_key);
613
614 static void disarm_kmem_keys(struct mem_cgroup *memcg)
615 {
616         if (memcg_kmem_is_active(memcg)) {
617                 static_key_slow_dec(&memcg_kmem_enabled_key);
618                 ida_simple_remove(&kmem_limited_groups, memcg->kmemcg_id);
619         }
620         /*
621          * This check can't live in kmem destruction function,
622          * since the charges will outlive the cgroup
623          */
624         WARN_ON(res_counter_read_u64(&memcg->kmem, RES_USAGE) != 0);
625 }
626 #else
627 static void disarm_kmem_keys(struct mem_cgroup *memcg)
628 {
629 }
630 #endif /* CONFIG_MEMCG_KMEM */
631
632 static void disarm_static_keys(struct mem_cgroup *memcg)
633 {
634         disarm_sock_keys(memcg);
635         disarm_kmem_keys(memcg);
636 }
637
638 static void drain_all_stock_async(struct mem_cgroup *memcg);
639
640 static struct mem_cgroup_per_zone *
641 mem_cgroup_zoneinfo(struct mem_cgroup *memcg, int nid, int zid)
642 {
643         VM_BUG_ON((unsigned)nid >= nr_node_ids);
644         return &memcg->nodeinfo[nid]->zoneinfo[zid];
645 }
646
647 struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)
648 {
649         return &memcg->css;
650 }
651
652 static struct mem_cgroup_per_zone *
653 page_cgroup_zoneinfo(struct mem_cgroup *memcg, struct page *page)
654 {
655         int nid = page_to_nid(page);
656         int zid = page_zonenum(page);
657
658         return mem_cgroup_zoneinfo(memcg, nid, zid);
659 }
660
661 static struct mem_cgroup_tree_per_zone *
662 soft_limit_tree_node_zone(int nid, int zid)
663 {
664         return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
665 }
666
667 static struct mem_cgroup_tree_per_zone *
668 soft_limit_tree_from_page(struct page *page)
669 {
670         int nid = page_to_nid(page);
671         int zid = page_zonenum(page);
672
673         return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
674 }
675
676 static void
677 __mem_cgroup_insert_exceeded(struct mem_cgroup *memcg,
678                                 struct mem_cgroup_per_zone *mz,
679                                 struct mem_cgroup_tree_per_zone *mctz,
680                                 unsigned long long new_usage_in_excess)
681 {
682         struct rb_node **p = &mctz->rb_root.rb_node;
683         struct rb_node *parent = NULL;
684         struct mem_cgroup_per_zone *mz_node;
685
686         if (mz->on_tree)
687                 return;
688
689         mz->usage_in_excess = new_usage_in_excess;
690         if (!mz->usage_in_excess)
691                 return;
692         while (*p) {
693                 parent = *p;
694                 mz_node = rb_entry(parent, struct mem_cgroup_per_zone,
695                                         tree_node);
696                 if (mz->usage_in_excess < mz_node->usage_in_excess)
697                         p = &(*p)->rb_left;
698                 /*
699                  * We can't avoid mem cgroups that are over their soft
700                  * limit by the same amount
701                  */
702                 else if (mz->usage_in_excess >= mz_node->usage_in_excess)
703                         p = &(*p)->rb_right;
704         }
705         rb_link_node(&mz->tree_node, parent, p);
706         rb_insert_color(&mz->tree_node, &mctz->rb_root);
707         mz->on_tree = true;
708 }
709
710 static void
711 __mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
712                                 struct mem_cgroup_per_zone *mz,
713                                 struct mem_cgroup_tree_per_zone *mctz)
714 {
715         if (!mz->on_tree)
716                 return;
717         rb_erase(&mz->tree_node, &mctz->rb_root);
718         mz->on_tree = false;
719 }
720
721 static void
722 mem_cgroup_remove_exceeded(struct mem_cgroup *memcg,
723                                 struct mem_cgroup_per_zone *mz,
724                                 struct mem_cgroup_tree_per_zone *mctz)
725 {
726         spin_lock(&mctz->lock);
727         __mem_cgroup_remove_exceeded(memcg, mz, mctz);
728         spin_unlock(&mctz->lock);
729 }
730
731
732 static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
733 {
734         unsigned long long excess;
735         struct mem_cgroup_per_zone *mz;
736         struct mem_cgroup_tree_per_zone *mctz;
737         int nid = page_to_nid(page);
738         int zid = page_zonenum(page);
739         mctz = soft_limit_tree_from_page(page);
740
741         /*
742          * Necessary to update all ancestors when hierarchy is used.
743          * because their event counter is not touched.
744          */
745         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
746                 mz = mem_cgroup_zoneinfo(memcg, nid, zid);
747                 excess = res_counter_soft_limit_excess(&memcg->res);
748                 /*
749                  * We have to update the tree if mz is on RB-tree or
750                  * mem is over its softlimit.
751                  */
752                 if (excess || mz->on_tree) {
753                         spin_lock(&mctz->lock);
754                         /* if on-tree, remove it */
755                         if (mz->on_tree)
756                                 __mem_cgroup_remove_exceeded(memcg, mz, mctz);
757                         /*
758                          * Insert again. mz->usage_in_excess will be updated.
759                          * If excess is 0, no tree ops.
760                          */
761                         __mem_cgroup_insert_exceeded(memcg, mz, mctz, excess);
762                         spin_unlock(&mctz->lock);
763                 }
764         }
765 }
766
767 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
768 {
769         int node, zone;
770         struct mem_cgroup_per_zone *mz;
771         struct mem_cgroup_tree_per_zone *mctz;
772
773         for_each_node(node) {
774                 for (zone = 0; zone < MAX_NR_ZONES; zone++) {
775                         mz = mem_cgroup_zoneinfo(memcg, node, zone);
776                         mctz = soft_limit_tree_node_zone(node, zone);
777                         mem_cgroup_remove_exceeded(memcg, mz, mctz);
778                 }
779         }
780 }
781
782 static struct mem_cgroup_per_zone *
783 __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
784 {
785         struct rb_node *rightmost = NULL;
786         struct mem_cgroup_per_zone *mz;
787
788 retry:
789         mz = NULL;
790         rightmost = rb_last(&mctz->rb_root);
791         if (!rightmost)
792                 goto done;              /* Nothing to reclaim from */
793
794         mz = rb_entry(rightmost, struct mem_cgroup_per_zone, tree_node);
795         /*
796          * Remove the node now but someone else can add it back,
797          * we will to add it back at the end of reclaim to its correct
798          * position in the tree.
799          */
800         __mem_cgroup_remove_exceeded(mz->memcg, mz, mctz);
801         if (!res_counter_soft_limit_excess(&mz->memcg->res) ||
802                 !css_tryget(&mz->memcg->css))
803                 goto retry;
804 done:
805         return mz;
806 }
807
808 static struct mem_cgroup_per_zone *
809 mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
810 {
811         struct mem_cgroup_per_zone *mz;
812
813         spin_lock(&mctz->lock);
814         mz = __mem_cgroup_largest_soft_limit_node(mctz);
815         spin_unlock(&mctz->lock);
816         return mz;
817 }
818
819 /*
820  * Implementation Note: reading percpu statistics for memcg.
821  *
822  * Both of vmstat[] and percpu_counter has threshold and do periodic
823  * synchronization to implement "quick" read. There are trade-off between
824  * reading cost and precision of value. Then, we may have a chance to implement
825  * a periodic synchronizion of counter in memcg's counter.
826  *
827  * But this _read() function is used for user interface now. The user accounts
828  * memory usage by memory cgroup and he _always_ requires exact value because
829  * he accounts memory. Even if we provide quick-and-fuzzy read, we always
830  * have to visit all online cpus and make sum. So, for now, unnecessary
831  * synchronization is not implemented. (just implemented for cpu hotplug)
832  *
833  * If there are kernel internal actions which can make use of some not-exact
834  * value, and reading all cpu value can be performance bottleneck in some
835  * common workload, threashold and synchonization as vmstat[] should be
836  * implemented.
837  */
838 static long mem_cgroup_read_stat(struct mem_cgroup *memcg,
839                                  enum mem_cgroup_stat_index idx)
840 {
841         long val = 0;
842         int cpu;
843
844         get_online_cpus();
845         for_each_online_cpu(cpu)
846                 val += per_cpu(memcg->stat->count[idx], cpu);
847 #ifdef CONFIG_HOTPLUG_CPU
848         spin_lock(&memcg->pcp_counter_lock);
849         val += memcg->nocpu_base.count[idx];
850         spin_unlock(&memcg->pcp_counter_lock);
851 #endif
852         put_online_cpus();
853         return val;
854 }
855
856 static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,
857                                          bool charge)
858 {
859         int val = (charge) ? 1 : -1;
860         this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_SWAP], val);
861 }
862
863 static unsigned long mem_cgroup_read_events(struct mem_cgroup *memcg,
864                                             enum mem_cgroup_events_index idx)
865 {
866         unsigned long val = 0;
867         int cpu;
868
869         for_each_online_cpu(cpu)
870                 val += per_cpu(memcg->stat->events[idx], cpu);
871 #ifdef CONFIG_HOTPLUG_CPU
872         spin_lock(&memcg->pcp_counter_lock);
873         val += memcg->nocpu_base.events[idx];
874         spin_unlock(&memcg->pcp_counter_lock);
875 #endif
876         return val;
877 }
878
879 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
880                                          struct page *page,
881                                          bool anon, int nr_pages)
882 {
883         preempt_disable();
884
885         /*
886          * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
887          * counted as CACHE even if it's on ANON LRU.
888          */
889         if (anon)
890                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],
891                                 nr_pages);
892         else
893                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_CACHE],
894                                 nr_pages);
895
896         if (PageTransHuge(page))
897                 __this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
898                                 nr_pages);
899
900         /* pagein of a big page is an event. So, ignore page size */
901         if (nr_pages > 0)
902                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGIN]);
903         else {
904                 __this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT]);
905                 nr_pages = -nr_pages; /* for event */
906         }
907
908         __this_cpu_add(memcg->stat->nr_page_events, nr_pages);
909
910         preempt_enable();
911 }
912
913 unsigned long
914 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
915 {
916         struct mem_cgroup_per_zone *mz;
917
918         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
919         return mz->lru_size[lru];
920 }
921
922 static unsigned long
923 mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
924                         unsigned int lru_mask)
925 {
926         struct mem_cgroup_per_zone *mz;
927         enum lru_list lru;
928         unsigned long ret = 0;
929
930         mz = mem_cgroup_zoneinfo(memcg, nid, zid);
931
932         for_each_lru(lru) {
933                 if (BIT(lru) & lru_mask)
934                         ret += mz->lru_size[lru];
935         }
936         return ret;
937 }
938
939 static unsigned long
940 mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
941                         int nid, unsigned int lru_mask)
942 {
943         u64 total = 0;
944         int zid;
945
946         for (zid = 0; zid < MAX_NR_ZONES; zid++)
947                 total += mem_cgroup_zone_nr_lru_pages(memcg,
948                                                 nid, zid, lru_mask);
949
950         return total;
951 }
952
953 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
954                         unsigned int lru_mask)
955 {
956         int nid;
957         u64 total = 0;
958
959         for_each_node_state(nid, N_MEMORY)
960                 total += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
961         return total;
962 }
963
964 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
965                                        enum mem_cgroup_events_target target)
966 {
967         unsigned long val, next;
968
969         val = __this_cpu_read(memcg->stat->nr_page_events);
970         next = __this_cpu_read(memcg->stat->targets[target]);
971         /* from time_after() in jiffies.h */
972         if ((long)next - (long)val < 0) {
973                 switch (target) {
974                 case MEM_CGROUP_TARGET_THRESH:
975                         next = val + THRESHOLDS_EVENTS_TARGET;
976                         break;
977                 case MEM_CGROUP_TARGET_SOFTLIMIT:
978                         next = val + SOFTLIMIT_EVENTS_TARGET;
979                         break;
980                 case MEM_CGROUP_TARGET_NUMAINFO:
981                         next = val + NUMAINFO_EVENTS_TARGET;
982                         break;
983                 default:
984                         break;
985                 }
986                 __this_cpu_write(memcg->stat->targets[target], next);
987                 return true;
988         }
989         return false;
990 }
991
992 /*
993  * Check events in order.
994  *
995  */
996 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
997 {
998         preempt_disable();
999         /* threshold event is triggered in finer grain than soft limit */
1000         if (unlikely(mem_cgroup_event_ratelimit(memcg,
1001                                                 MEM_CGROUP_TARGET_THRESH))) {
1002                 bool do_softlimit;
1003                 bool do_numainfo __maybe_unused;
1004
1005                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
1006                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
1007 #if MAX_NUMNODES > 1
1008                 do_numainfo = mem_cgroup_event_ratelimit(memcg,
1009                                                 MEM_CGROUP_TARGET_NUMAINFO);
1010 #endif
1011                 preempt_enable();
1012
1013                 mem_cgroup_threshold(memcg);
1014                 if (unlikely(do_softlimit))
1015                         mem_cgroup_update_tree(memcg, page);
1016 #if MAX_NUMNODES > 1
1017                 if (unlikely(do_numainfo))
1018                         atomic_inc(&memcg->numainfo_events);
1019 #endif
1020         } else
1021                 preempt_enable();
1022 }
1023
1024 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
1025 {
1026         /*
1027          * mm_update_next_owner() may clear mm->owner to NULL
1028          * if it races with swapoff, page migration, etc.
1029          * So this can be called with p == NULL.
1030          */
1031         if (unlikely(!p))
1032                 return NULL;
1033
1034         return mem_cgroup_from_css(task_css(p, mem_cgroup_subsys_id));
1035 }
1036
1037 struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
1038 {
1039         struct mem_cgroup *memcg = NULL;
1040
1041         if (!mm)
1042                 return NULL;
1043         /*
1044          * Because we have no locks, mm->owner's may be being moved to other
1045          * cgroup. We use css_tryget() here even if this looks
1046          * pessimistic (rather than adding locks here).
1047          */
1048         rcu_read_lock();
1049         do {
1050                 memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
1051                 if (unlikely(!memcg))
1052                         break;
1053         } while (!css_tryget(&memcg->css));
1054         rcu_read_unlock();
1055         return memcg;
1056 }
1057
1058 /*
1059  * Returns a next (in a pre-order walk) alive memcg (with elevated css
1060  * ref. count) or NULL if the whole root's subtree has been visited.
1061  *
1062  * helper function to be used by mem_cgroup_iter
1063  */
1064 static struct mem_cgroup *__mem_cgroup_iter_next(struct mem_cgroup *root,
1065                 struct mem_cgroup *last_visited)
1066 {
1067         struct cgroup_subsys_state *prev_css, *next_css;
1068
1069         prev_css = last_visited ? &last_visited->css : NULL;
1070 skip_node:
1071         next_css = css_next_descendant_pre(prev_css, &root->css);
1072
1073         /*
1074          * Even if we found a group we have to make sure it is
1075          * alive. css && !memcg means that the groups should be
1076          * skipped and we should continue the tree walk.
1077          * last_visited css is safe to use because it is
1078          * protected by css_get and the tree walk is rcu safe.
1079          */
1080         if (next_css) {
1081                 struct mem_cgroup *mem = mem_cgroup_from_css(next_css);
1082
1083                 if (css_tryget(&mem->css))
1084                         return mem;
1085                 else {
1086                         prev_css = next_css;
1087                         goto skip_node;
1088                 }
1089         }
1090
1091         return NULL;
1092 }
1093
1094 static void mem_cgroup_iter_invalidate(struct mem_cgroup *root)
1095 {
1096         /*
1097          * When a group in the hierarchy below root is destroyed, the
1098          * hierarchy iterator can no longer be trusted since it might
1099          * have pointed to the destroyed group.  Invalidate it.
1100          */
1101         atomic_inc(&root->dead_count);
1102 }
1103
1104 static struct mem_cgroup *
1105 mem_cgroup_iter_load(struct mem_cgroup_reclaim_iter *iter,
1106                      struct mem_cgroup *root,
1107                      int *sequence)
1108 {
1109         struct mem_cgroup *position = NULL;
1110         /*
1111          * A cgroup destruction happens in two stages: offlining and
1112          * release.  They are separated by a RCU grace period.
1113          *
1114          * If the iterator is valid, we may still race with an
1115          * offlining.  The RCU lock ensures the object won't be
1116          * released, tryget will fail if we lost the race.
1117          */
1118         *sequence = atomic_read(&root->dead_count);
1119         if (iter->last_dead_count == *sequence) {
1120                 smp_rmb();
1121                 position = iter->last_visited;
1122                 if (position && !css_tryget(&position->css))
1123                         position = NULL;
1124         }
1125         return position;
1126 }
1127
1128 static void mem_cgroup_iter_update(struct mem_cgroup_reclaim_iter *iter,
1129                                    struct mem_cgroup *last_visited,
1130                                    struct mem_cgroup *new_position,
1131                                    int sequence)
1132 {
1133         if (last_visited)
1134                 css_put(&last_visited->css);
1135         /*
1136          * We store the sequence count from the time @last_visited was
1137          * loaded successfully instead of rereading it here so that we
1138          * don't lose destruction events in between.  We could have
1139          * raced with the destruction of @new_position after all.
1140          */
1141         iter->last_visited = new_position;
1142         smp_wmb();
1143         iter->last_dead_count = sequence;
1144 }
1145
1146 /**
1147  * mem_cgroup_iter - iterate over memory cgroup hierarchy
1148  * @root: hierarchy root
1149  * @prev: previously returned memcg, NULL on first invocation
1150  * @reclaim: cookie for shared reclaim walks, NULL for full walks
1151  *
1152  * Returns references to children of the hierarchy below @root, or
1153  * @root itself, or %NULL after a full round-trip.
1154  *
1155  * Caller must pass the return value in @prev on subsequent
1156  * invocations for reference counting, or use mem_cgroup_iter_break()
1157  * to cancel a hierarchy walk before the round-trip is complete.
1158  *
1159  * Reclaimers can specify a zone and a priority level in @reclaim to
1160  * divide up the memcgs in the hierarchy among all concurrent
1161  * reclaimers operating on the same zone and priority.
1162  */
1163 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
1164                                    struct mem_cgroup *prev,
1165                                    struct mem_cgroup_reclaim_cookie *reclaim)
1166 {
1167         struct mem_cgroup *memcg = NULL;
1168         struct mem_cgroup *last_visited = NULL;
1169
1170         if (mem_cgroup_disabled())
1171                 return NULL;
1172
1173         if (!root)
1174                 root = root_mem_cgroup;
1175
1176         if (prev && !reclaim)
1177                 last_visited = prev;
1178
1179         if (!root->use_hierarchy && root != root_mem_cgroup) {
1180                 if (prev)
1181                         goto out_css_put;
1182                 return root;
1183         }
1184
1185         rcu_read_lock();
1186         while (!memcg) {
1187                 struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
1188                 int uninitialized_var(seq);
1189
1190                 if (reclaim) {
1191                         int nid = zone_to_nid(reclaim->zone);
1192                         int zid = zone_idx(reclaim->zone);
1193                         struct mem_cgroup_per_zone *mz;
1194
1195                         mz = mem_cgroup_zoneinfo(root, nid, zid);
1196                         iter = &mz->reclaim_iter[reclaim->priority];
1197                         if (prev && reclaim->generation != iter->generation) {
1198                                 iter->last_visited = NULL;
1199                                 goto out_unlock;
1200                         }
1201
1202                         last_visited = mem_cgroup_iter_load(iter, root, &seq);
1203                 }
1204
1205                 memcg = __mem_cgroup_iter_next(root, last_visited);
1206
1207                 if (reclaim) {
1208                         mem_cgroup_iter_update(iter, last_visited, memcg, seq);
1209
1210                         if (!memcg)
1211                                 iter->generation++;
1212                         else if (!prev && memcg)
1213                                 reclaim->generation = iter->generation;
1214                 }
1215
1216                 if (prev && !memcg)
1217                         goto out_unlock;
1218         }
1219 out_unlock:
1220         rcu_read_unlock();
1221 out_css_put:
1222         if (prev && prev != root)
1223                 css_put(&prev->css);
1224
1225         return memcg;
1226 }
1227
1228 /**
1229  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1230  * @root: hierarchy root
1231  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1232  */
1233 void mem_cgroup_iter_break(struct mem_cgroup *root,
1234                            struct mem_cgroup *prev)
1235 {
1236         if (!root)
1237                 root = root_mem_cgroup;
1238         if (prev && prev != root)
1239                 css_put(&prev->css);
1240 }
1241
1242 /*
1243  * Iteration constructs for visiting all cgroups (under a tree).  If
1244  * loops are exited prematurely (break), mem_cgroup_iter_break() must
1245  * be used for reference counting.
1246  */
1247 #define for_each_mem_cgroup_tree(iter, root)            \
1248         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
1249              iter != NULL;                              \
1250              iter = mem_cgroup_iter(root, iter, NULL))
1251
1252 #define for_each_mem_cgroup(iter)                       \
1253         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
1254              iter != NULL;                              \
1255              iter = mem_cgroup_iter(NULL, iter, NULL))
1256
1257 void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
1258 {
1259         struct mem_cgroup *memcg;
1260
1261         rcu_read_lock();
1262         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
1263         if (unlikely(!memcg))
1264                 goto out;
1265
1266         switch (idx) {
1267         case PGFAULT:
1268                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT]);
1269                 break;
1270         case PGMAJFAULT:
1271                 this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT]);
1272                 break;
1273         default:
1274                 BUG();
1275         }
1276 out:
1277         rcu_read_unlock();
1278 }
1279 EXPORT_SYMBOL(__mem_cgroup_count_vm_event);
1280
1281 /**
1282  * mem_cgroup_zone_lruvec - get the lru list vector for a zone and memcg
1283  * @zone: zone of the wanted lruvec
1284  * @memcg: memcg of the wanted lruvec
1285  *
1286  * Returns the lru list vector holding pages for the given @zone and
1287  * @mem.  This can be the global zone lruvec, if the memory controller
1288  * is disabled.
1289  */
1290 struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
1291                                       struct mem_cgroup *memcg)
1292 {
1293         struct mem_cgroup_per_zone *mz;
1294         struct lruvec *lruvec;
1295
1296         if (mem_cgroup_disabled()) {
1297                 lruvec = &zone->lruvec;
1298                 goto out;
1299         }
1300
1301         mz = mem_cgroup_zoneinfo(memcg, zone_to_nid(zone), zone_idx(zone));
1302         lruvec = &mz->lruvec;
1303 out:
1304         /*
1305          * Since a node can be onlined after the mem_cgroup was created,
1306          * we have to be prepared to initialize lruvec->zone here;
1307          * and if offlined then reonlined, we need to reinitialize it.
1308          */
1309         if (unlikely(lruvec->zone != zone))
1310                 lruvec->zone = zone;
1311         return lruvec;
1312 }
1313
1314 /*
1315  * Following LRU functions are allowed to be used without PCG_LOCK.
1316  * Operations are called by routine of global LRU independently from memcg.
1317  * What we have to take care of here is validness of pc->mem_cgroup.
1318  *
1319  * Changes to pc->mem_cgroup happens when
1320  * 1. charge
1321  * 2. moving account
1322  * In typical case, "charge" is done before add-to-lru. Exception is SwapCache.
1323  * It is added to LRU before charge.
1324  * If PCG_USED bit is not set, page_cgroup is not added to this private LRU.
1325  * When moving account, the page is not on LRU. It's isolated.
1326  */
1327
1328 /**
1329  * mem_cgroup_page_lruvec - return lruvec for adding an lru page
1330  * @page: the page
1331  * @zone: zone of the page
1332  */
1333 struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)
1334 {
1335         struct mem_cgroup_per_zone *mz;
1336         struct mem_cgroup *memcg;
1337         struct page_cgroup *pc;
1338         struct lruvec *lruvec;
1339
1340         if (mem_cgroup_disabled()) {
1341                 lruvec = &zone->lruvec;
1342                 goto out;
1343         }
1344
1345         pc = lookup_page_cgroup(page);
1346         memcg = pc->mem_cgroup;
1347
1348         /*
1349          * Surreptitiously switch any uncharged offlist page to root:
1350          * an uncharged page off lru does nothing to secure
1351          * its former mem_cgroup from sudden removal.
1352          *
1353          * Our caller holds lru_lock, and PageCgroupUsed is updated
1354          * under page_cgroup lock: between them, they make all uses
1355          * of pc->mem_cgroup safe.
1356          */
1357         if (!PageLRU(page) && !PageCgroupUsed(pc) && memcg != root_mem_cgroup)
1358                 pc->mem_cgroup = memcg = root_mem_cgroup;
1359
1360         mz = page_cgroup_zoneinfo(memcg, page);
1361         lruvec = &mz->lruvec;
1362 out:
1363         /*
1364          * Since a node can be onlined after the mem_cgroup was created,
1365          * we have to be prepared to initialize lruvec->zone here;
1366          * and if offlined then reonlined, we need to reinitialize it.
1367          */
1368         if (unlikely(lruvec->zone != zone))
1369                 lruvec->zone = zone;
1370         return lruvec;
1371 }
1372
1373 /**
1374  * mem_cgroup_update_lru_size - account for adding or removing an lru page
1375  * @lruvec: mem_cgroup per zone lru vector
1376  * @lru: index of lru list the page is sitting on
1377  * @nr_pages: positive when adding or negative when removing
1378  *
1379  * This function must be called when a page is added to or removed from an
1380  * lru list.
1381  */
1382 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1383                                 int nr_pages)
1384 {
1385         struct mem_cgroup_per_zone *mz;
1386         unsigned long *lru_size;
1387
1388         if (mem_cgroup_disabled())
1389                 return;
1390
1391         mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
1392         lru_size = mz->lru_size + lru;
1393         *lru_size += nr_pages;
1394         VM_BUG_ON((long)(*lru_size) < 0);
1395 }
1396
1397 /*
1398  * Checks whether given mem is same or in the root_mem_cgroup's
1399  * hierarchy subtree
1400  */
1401 bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1402                                   struct mem_cgroup *memcg)
1403 {
1404         if (root_memcg == memcg)
1405                 return true;
1406         if (!root_memcg->use_hierarchy || !memcg)
1407                 return false;
1408         return css_is_ancestor(&memcg->css, &root_memcg->css);
1409 }
1410
1411 static bool mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
1412                                        struct mem_cgroup *memcg)
1413 {
1414         bool ret;
1415
1416         rcu_read_lock();
1417         ret = __mem_cgroup_same_or_subtree(root_memcg, memcg);
1418         rcu_read_unlock();
1419         return ret;
1420 }
1421
1422 bool task_in_mem_cgroup(struct task_struct *task,
1423                         const struct mem_cgroup *memcg)
1424 {
1425         struct mem_cgroup *curr = NULL;
1426         struct task_struct *p;
1427         bool ret;
1428
1429         p = find_lock_task_mm(task);
1430         if (p) {
1431                 curr = try_get_mem_cgroup_from_mm(p->mm);
1432                 task_unlock(p);
1433         } else {
1434                 /*
1435                  * All threads may have already detached their mm's, but the oom
1436                  * killer still needs to detect if they have already been oom
1437                  * killed to prevent needlessly killing additional tasks.
1438                  */
1439                 rcu_read_lock();
1440                 curr = mem_cgroup_from_task(task);
1441                 if (curr)
1442                         css_get(&curr->css);
1443                 rcu_read_unlock();
1444         }
1445         if (!curr)
1446                 return false;
1447         /*
1448          * We should check use_hierarchy of "memcg" not "curr". Because checking
1449          * use_hierarchy of "curr" here make this function true if hierarchy is
1450          * enabled in "curr" and "curr" is a child of "memcg" in *cgroup*
1451          * hierarchy(even if use_hierarchy is disabled in "memcg").
1452          */
1453         ret = mem_cgroup_same_or_subtree(memcg, curr);
1454         css_put(&curr->css);
1455         return ret;
1456 }
1457
1458 int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
1459 {
1460         unsigned long inactive_ratio;
1461         unsigned long inactive;
1462         unsigned long active;
1463         unsigned long gb;
1464
1465         inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_ANON);
1466         active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_ANON);
1467
1468         gb = (inactive + active) >> (30 - PAGE_SHIFT);
1469         if (gb)
1470                 inactive_ratio = int_sqrt(10 * gb);
1471         else
1472                 inactive_ratio = 1;
1473
1474         return inactive * inactive_ratio < active;
1475 }
1476
1477 #define mem_cgroup_from_res_counter(counter, member)    \
1478         container_of(counter, struct mem_cgroup, member)
1479
1480 /**
1481  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1482  * @memcg: the memory cgroup
1483  *
1484  * Returns the maximum amount of memory @mem can be charged with, in
1485  * pages.
1486  */
1487 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1488 {
1489         unsigned long long margin;
1490
1491         margin = res_counter_margin(&memcg->res);
1492         if (do_swap_account)
1493                 margin = min(margin, res_counter_margin(&memcg->memsw));
1494         return margin >> PAGE_SHIFT;
1495 }
1496
1497 int mem_cgroup_swappiness(struct mem_cgroup *memcg)
1498 {
1499         /* root ? */
1500         if (!css_parent(&memcg->css))
1501                 return vm_swappiness;
1502
1503         return memcg->swappiness;
1504 }
1505
1506 /*
1507  * memcg->moving_account is used for checking possibility that some thread is
1508  * calling move_account(). When a thread on CPU-A starts moving pages under
1509  * a memcg, other threads should check memcg->moving_account under
1510  * rcu_read_lock(), like this:
1511  *
1512  *         CPU-A                                    CPU-B
1513  *                                              rcu_read_lock()
1514  *         memcg->moving_account+1              if (memcg->mocing_account)
1515  *                                                   take heavy locks.
1516  *         synchronize_rcu()                    update something.
1517  *                                              rcu_read_unlock()
1518  *         start move here.
1519  */
1520
1521 /* for quick checking without looking up memcg */
1522 atomic_t memcg_moving __read_mostly;
1523
1524 static void mem_cgroup_start_move(struct mem_cgroup *memcg)
1525 {
1526         atomic_inc(&memcg_moving);
1527         atomic_inc(&memcg->moving_account);
1528         synchronize_rcu();
1529 }
1530
1531 static void mem_cgroup_end_move(struct mem_cgroup *memcg)
1532 {
1533         /*
1534          * Now, mem_cgroup_clear_mc() may call this function with NULL.
1535          * We check NULL in callee rather than caller.
1536          */
1537         if (memcg) {
1538                 atomic_dec(&memcg_moving);
1539                 atomic_dec(&memcg->moving_account);
1540         }
1541 }
1542
1543 /*
1544  * 2 routines for checking "mem" is under move_account() or not.
1545  *
1546  * mem_cgroup_stolen() -  checking whether a cgroup is mc.from or not. This
1547  *                        is used for avoiding races in accounting.  If true,
1548  *                        pc->mem_cgroup may be overwritten.
1549  *
1550  * mem_cgroup_under_move() - checking a cgroup is mc.from or mc.to or
1551  *                        under hierarchy of moving cgroups. This is for
1552  *                        waiting at hith-memory prressure caused by "move".
1553  */
1554
1555 static bool mem_cgroup_stolen(struct mem_cgroup *memcg)
1556 {
1557         VM_BUG_ON(!rcu_read_lock_held());
1558         return atomic_read(&memcg->moving_account) > 0;
1559 }
1560
1561 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1562 {
1563         struct mem_cgroup *from;
1564         struct mem_cgroup *to;
1565         bool ret = false;
1566         /*
1567          * Unlike task_move routines, we access mc.to, mc.from not under
1568          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1569          */
1570         spin_lock(&mc.lock);
1571         from = mc.from;
1572         to = mc.to;
1573         if (!from)
1574                 goto unlock;
1575
1576         ret = mem_cgroup_same_or_subtree(memcg, from)
1577                 || mem_cgroup_same_or_subtree(memcg, to);
1578 unlock:
1579         spin_unlock(&mc.lock);
1580         return ret;
1581 }
1582
1583 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1584 {
1585         if (mc.moving_task && current != mc.moving_task) {
1586                 if (mem_cgroup_under_move(memcg)) {
1587                         DEFINE_WAIT(wait);
1588                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1589                         /* moving charge context might have finished. */
1590                         if (mc.moving_task)
1591                                 schedule();
1592                         finish_wait(&mc.waitq, &wait);
1593                         return true;
1594                 }
1595         }
1596         return false;
1597 }
1598
1599 /*
1600  * Take this lock when
1601  * - a code tries to modify page's memcg while it's USED.
1602  * - a code tries to modify page state accounting in a memcg.
1603  * see mem_cgroup_stolen(), too.
1604  */
1605 static void move_lock_mem_cgroup(struct mem_cgroup *memcg,
1606                                   unsigned long *flags)
1607 {
1608         spin_lock_irqsave(&memcg->move_lock, *flags);
1609 }
1610
1611 static void move_unlock_mem_cgroup(struct mem_cgroup *memcg,
1612                                 unsigned long *flags)
1613 {
1614         spin_unlock_irqrestore(&memcg->move_lock, *flags);
1615 }
1616
1617 #define K(x) ((x) << (PAGE_SHIFT-10))
1618 /**
1619  * mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.
1620  * @memcg: The memory cgroup that went over limit
1621  * @p: Task that is going to be killed
1622  *
1623  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1624  * enabled
1625  */
1626 void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
1627 {
1628         struct cgroup *task_cgrp;
1629         struct cgroup *mem_cgrp;
1630         /*
1631          * Need a buffer in BSS, can't rely on allocations. The code relies
1632          * on the assumption that OOM is serialized for memory controller.
1633          * If this assumption is broken, revisit this code.
1634          */
1635         static char memcg_name[PATH_MAX];
1636         int ret;
1637         struct mem_cgroup *iter;
1638         unsigned int i;
1639
1640         if (!p)
1641                 return;
1642
1643         rcu_read_lock();
1644
1645         mem_cgrp = memcg->css.cgroup;
1646         task_cgrp = task_cgroup(p, mem_cgroup_subsys_id);
1647
1648         ret = cgroup_path(task_cgrp, memcg_name, PATH_MAX);
1649         if (ret < 0) {
1650                 /*
1651                  * Unfortunately, we are unable to convert to a useful name
1652                  * But we'll still print out the usage information
1653                  */
1654                 rcu_read_unlock();
1655                 goto done;
1656         }
1657         rcu_read_unlock();
1658
1659         pr_info("Task in %s killed", memcg_name);
1660
1661         rcu_read_lock();
1662         ret = cgroup_path(mem_cgrp, memcg_name, PATH_MAX);
1663         if (ret < 0) {
1664                 rcu_read_unlock();
1665                 goto done;
1666         }
1667         rcu_read_unlock();
1668
1669         /*
1670          * Continues from above, so we don't need an KERN_ level
1671          */
1672         pr_cont(" as a result of limit of %s\n", memcg_name);
1673 done:
1674
1675         pr_info("memory: usage %llukB, limit %llukB, failcnt %llu\n",
1676                 res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
1677                 res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,
1678                 res_counter_read_u64(&memcg->res, RES_FAILCNT));
1679         pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %llu\n",
1680                 res_counter_read_u64(&memcg->memsw, RES_USAGE) >> 10,
1681                 res_counter_read_u64(&memcg->memsw, RES_LIMIT) >> 10,
1682                 res_counter_read_u64(&memcg->memsw, RES_FAILCNT));
1683         pr_info("kmem: usage %llukB, limit %llukB, failcnt %llu\n",
1684                 res_counter_read_u64(&memcg->kmem, RES_USAGE) >> 10,
1685                 res_counter_read_u64(&memcg->kmem, RES_LIMIT) >> 10,
1686                 res_counter_read_u64(&memcg->kmem, RES_FAILCNT));
1687
1688         for_each_mem_cgroup_tree(iter, memcg) {
1689                 pr_info("Memory cgroup stats");
1690
1691                 rcu_read_lock();
1692                 ret = cgroup_path(iter->css.cgroup, memcg_name, PATH_MAX);
1693                 if (!ret)
1694                         pr_cont(" for %s", memcg_name);
1695                 rcu_read_unlock();
1696                 pr_cont(":");
1697
1698                 for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
1699                         if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
1700                                 continue;
1701                         pr_cont(" %s:%ldKB", mem_cgroup_stat_names[i],
1702                                 K(mem_cgroup_read_stat(iter, i)));
1703                 }
1704
1705                 for (i = 0; i < NR_LRU_LISTS; i++)
1706                         pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
1707                                 K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
1708
1709                 pr_cont("\n");
1710         }
1711 }
1712
1713 /*
1714  * This function returns the number of memcg under hierarchy tree. Returns
1715  * 1(self count) if no children.
1716  */
1717 static int mem_cgroup_count_children(struct mem_cgroup *memcg)
1718 {
1719         int num = 0;
1720         struct mem_cgroup *iter;
1721
1722         for_each_mem_cgroup_tree(iter, memcg)
1723                 num++;
1724         return num;
1725 }
1726
1727 /*
1728  * Return the memory (and swap, if configured) limit for a memcg.
1729  */
1730 static u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)
1731 {
1732         u64 limit;
1733
1734         limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
1735
1736         /*
1737          * Do not consider swap space if we cannot swap due to swappiness
1738          */
1739         if (mem_cgroup_swappiness(memcg)) {
1740                 u64 memsw;
1741
1742                 limit += total_swap_pages << PAGE_SHIFT;
1743                 memsw = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
1744
1745                 /*
1746                  * If memsw is finite and limits the amount of swap space
1747                  * available to this memcg, return that limit.
1748                  */
1749                 limit = min(limit, memsw);
1750         }
1751
1752         return limit;
1753 }
1754
1755 static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1756                                      int order)
1757 {
1758         struct mem_cgroup *iter;
1759         unsigned long chosen_points = 0;
1760         unsigned long totalpages;
1761         unsigned int points = 0;
1762         struct task_struct *chosen = NULL;
1763
1764         /*
1765          * If current has a pending SIGKILL or is exiting, then automatically
1766          * select it.  The goal is to allow it to allocate so that it may
1767          * quickly exit and free its memory.
1768          */
1769         if (fatal_signal_pending(current) || current->flags & PF_EXITING) {
1770                 set_thread_flag(TIF_MEMDIE);
1771                 return;
1772         }
1773
1774         check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
1775         totalpages = mem_cgroup_get_limit(memcg) >> PAGE_SHIFT ? : 1;
1776         for_each_mem_cgroup_tree(iter, memcg) {
1777                 struct css_task_iter it;
1778                 struct task_struct *task;
1779
1780                 css_task_iter_start(&iter->css, &it);
1781                 while ((task = css_task_iter_next(&it))) {
1782                         switch (oom_scan_process_thread(task, totalpages, NULL,
1783                                                         false)) {
1784                         case OOM_SCAN_SELECT:
1785                                 if (chosen)
1786                                         put_task_struct(chosen);
1787                                 chosen = task;
1788                                 chosen_points = ULONG_MAX;
1789                                 get_task_struct(chosen);
1790                                 /* fall through */
1791                         case OOM_SCAN_CONTINUE:
1792                                 continue;
1793                         case OOM_SCAN_ABORT:
1794                                 css_task_iter_end(&it);
1795                                 mem_cgroup_iter_break(memcg, iter);
1796                                 if (chosen)
1797                                         put_task_struct(chosen);
1798                                 return;
1799                         case OOM_SCAN_OK:
1800                                 break;
1801                         };
1802                         points = oom_badness(task, memcg, NULL, totalpages);
1803                         if (points > chosen_points) {
1804                                 if (chosen)
1805                                         put_task_struct(chosen);
1806                                 chosen = task;
1807                                 chosen_points = points;
1808                                 get_task_struct(chosen);
1809                         }
1810                 }
1811                 css_task_iter_end(&it);
1812         }
1813
1814         if (!chosen)
1815                 return;
1816         points = chosen_points * 1000 / totalpages;
1817         oom_kill_process(chosen, gfp_mask, order, points, totalpages, memcg,
1818                          NULL, "Memory cgroup out of memory");
1819 }
1820
1821 static unsigned long mem_cgroup_reclaim(struct mem_cgroup *memcg,
1822                                         gfp_t gfp_mask,
1823                                         unsigned long flags)
1824 {
1825         unsigned long total = 0;
1826         bool noswap = false;
1827         int loop;
1828
1829         if (flags & MEM_CGROUP_RECLAIM_NOSWAP)
1830                 noswap = true;
1831         if (!(flags & MEM_CGROUP_RECLAIM_SHRINK) && memcg->memsw_is_minimum)
1832                 noswap = true;
1833
1834         for (loop = 0; loop < MEM_CGROUP_MAX_RECLAIM_LOOPS; loop++) {
1835                 if (loop)
1836                         drain_all_stock_async(memcg);
1837                 total += try_to_free_mem_cgroup_pages(memcg, gfp_mask, noswap);
1838                 /*
1839                  * Allow limit shrinkers, which are triggered directly
1840                  * by userspace, to catch signals and stop reclaim
1841                  * after minimal progress, regardless of the margin.
1842                  */
1843                 if (total && (flags & MEM_CGROUP_RECLAIM_SHRINK))
1844                         break;
1845                 if (mem_cgroup_margin(memcg))
1846                         break;
1847                 /*
1848                  * If nothing was reclaimed after two attempts, there
1849                  * may be no reclaimable pages in this hierarchy.
1850                  */
1851                 if (loop && !total)
1852                         break;
1853         }
1854         return total;
1855 }
1856
1857 /**
1858  * test_mem_cgroup_node_reclaimable
1859  * @memcg: the target memcg
1860  * @nid: the node ID to be checked.
1861  * @noswap : specify true here if the user wants flle only information.
1862  *
1863  * This function returns whether the specified memcg contains any
1864  * reclaimable pages on a node. Returns true if there are any reclaimable
1865  * pages in the node.
1866  */
1867 static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
1868                 int nid, bool noswap)
1869 {
1870         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))
1871                 return true;
1872         if (noswap || !total_swap_pages)
1873                 return false;
1874         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))
1875                 return true;
1876         return false;
1877
1878 }
1879 #if MAX_NUMNODES > 1
1880
1881 /*
1882  * Always updating the nodemask is not very good - even if we have an empty
1883  * list or the wrong list here, we can start from some node and traverse all
1884  * nodes based on the zonelist. So update the list loosely once per 10 secs.
1885  *
1886  */
1887 static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
1888 {
1889         int nid;
1890         /*
1891          * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
1892          * pagein/pageout changes since the last update.
1893          */
1894         if (!atomic_read(&memcg->numainfo_events))
1895                 return;
1896         if (atomic_inc_return(&memcg->numainfo_updating) > 1)
1897                 return;
1898
1899         /* make a nodemask where this memcg uses memory from */
1900         memcg->scan_nodes = node_states[N_MEMORY];
1901
1902         for_each_node_mask(nid, node_states[N_MEMORY]) {
1903
1904                 if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
1905                         node_clear(nid, memcg->scan_nodes);
1906         }
1907
1908         atomic_set(&memcg->numainfo_events, 0);
1909         atomic_set(&memcg->numainfo_updating, 0);
1910 }
1911
1912 /*
1913  * Selecting a node where we start reclaim from. Because what we need is just
1914  * reducing usage counter, start from anywhere is O,K. Considering
1915  * memory reclaim from current node, there are pros. and cons.
1916  *
1917  * Freeing memory from current node means freeing memory from a node which
1918  * we'll use or we've used. So, it may make LRU bad. And if several threads
1919  * hit limits, it will see a contention on a node. But freeing from remote
1920  * node means more costs for memory reclaim because of memory latency.
1921  *
1922  * Now, we use round-robin. Better algorithm is welcomed.
1923  */
1924 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1925 {
1926         int node;
1927
1928         mem_cgroup_may_update_nodemask(memcg);
1929         node = memcg->last_scanned_node;
1930
1931         node = next_node(node, memcg->scan_nodes);
1932         if (node == MAX_NUMNODES)
1933                 node = first_node(memcg->scan_nodes);
1934         /*
1935          * We call this when we hit limit, not when pages are added to LRU.
1936          * No LRU may hold pages because all pages are UNEVICTABLE or
1937          * memcg is too small and all pages are not on LRU. In that case,
1938          * we use curret node.
1939          */
1940         if (unlikely(node == MAX_NUMNODES))
1941                 node = numa_node_id();
1942
1943         memcg->last_scanned_node = node;
1944         return node;
1945 }
1946
1947 /*
1948  * Check all nodes whether it contains reclaimable pages or not.
1949  * For quick scan, we make use of scan_nodes. This will allow us to skip
1950  * unused nodes. But scan_nodes is lazily updated and may not cotain
1951  * enough new information. We need to do double check.
1952  */
1953 static bool mem_cgroup_reclaimable(struct mem_cgroup *memcg, bool noswap)
1954 {
1955         int nid;
1956
1957         /*
1958          * quick check...making use of scan_node.
1959          * We can skip unused nodes.
1960          */
1961         if (!nodes_empty(memcg->scan_nodes)) {
1962                 for (nid = first_node(memcg->scan_nodes);
1963                      nid < MAX_NUMNODES;
1964                      nid = next_node(nid, memcg->scan_nodes)) {
1965
1966                         if (test_mem_cgroup_node_reclaimable(memcg, nid, noswap))
1967                                 return true;
1968                 }
1969         }
1970         /*
1971          * Check rest of nodes.
1972          */
1973         for_each_node_state(nid, N_MEMORY) {
1974                 if (node_isset(nid, memcg->scan_nodes))
1975                         continue;
1976                 if (test_mem_cgroup_node_reclaimable(memcg, nid, noswap))
1977                         return true;
1978         }
1979         return false;
1980 }
1981
1982 #else
1983 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1984 {
1985         return 0;
1986 }
1987
1988 static bool mem_cgroup_reclaimable(struct mem_cgroup *memcg, bool noswap)
1989 {
1990         return test_mem_cgroup_node_reclaimable(memcg, 0, noswap);
1991 }
1992 #endif
1993
1994 static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1995                                    struct zone *zone,
1996                                    gfp_t gfp_mask,
1997                                    unsigned long *total_scanned)
1998 {
1999         struct mem_cgroup *victim = NULL;
2000         int total = 0;
2001         int loop = 0;
2002         unsigned long excess;
2003         unsigned long nr_scanned;
2004         struct mem_cgroup_reclaim_cookie reclaim = {
2005                 .zone = zone,
2006                 .priority = 0,
2007         };
2008
2009         excess = res_counter_soft_limit_excess(&root_memcg->res) >> PAGE_SHIFT;
2010
2011         while (1) {
2012                 victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
2013                 if (!victim) {
2014                         loop++;
2015                         if (loop >= 2) {
2016                                 /*
2017                                  * If we have not been able to reclaim
2018                                  * anything, it might because there are
2019                                  * no reclaimable pages under this hierarchy
2020                                  */
2021                                 if (!total)
2022                                         break;
2023                                 /*
2024                                  * We want to do more targeted reclaim.
2025                                  * excess >> 2 is not to excessive so as to
2026                                  * reclaim too much, nor too less that we keep
2027                                  * coming back to reclaim from this cgroup
2028                                  */
2029                                 if (total >= (excess >> 2) ||
2030                                         (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
2031                                         break;
2032                         }
2033                         continue;
2034                 }
2035                 if (!mem_cgroup_reclaimable(victim, false))
2036                         continue;
2037                 total += mem_cgroup_shrink_node_zone(victim, gfp_mask, false,
2038                                                      zone, &nr_scanned);
2039                 *total_scanned += nr_scanned;
2040                 if (!res_counter_soft_limit_excess(&root_memcg->res))
2041                         break;
2042         }
2043         mem_cgroup_iter_break(root_memcg, victim);
2044         return total;
2045 }
2046
2047 static DEFINE_SPINLOCK(memcg_oom_lock);
2048
2049 /*
2050  * Check OOM-Killer is already running under our hierarchy.
2051  * If someone is running, return false.
2052  */
2053 static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
2054 {
2055         struct mem_cgroup *iter, *failed = NULL;
2056
2057         spin_lock(&memcg_oom_lock);
2058
2059         for_each_mem_cgroup_tree(iter, memcg) {
2060                 if (iter->oom_lock) {
2061                         /*
2062                          * this subtree of our hierarchy is already locked
2063                          * so we cannot give a lock.
2064                          */
2065                         failed = iter;
2066                         mem_cgroup_iter_break(memcg, iter);
2067                         break;
2068                 } else
2069                         iter->oom_lock = true;
2070         }
2071
2072         if (failed) {
2073                 /*
2074                  * OK, we failed to lock the whole subtree so we have
2075                  * to clean up what we set up to the failing subtree
2076                  */
2077                 for_each_mem_cgroup_tree(iter, memcg) {
2078                         if (iter == failed) {
2079                                 mem_cgroup_iter_break(memcg, iter);
2080                                 break;
2081                         }
2082                         iter->oom_lock = false;
2083                 }
2084         }
2085
2086         spin_unlock(&memcg_oom_lock);
2087
2088         return !failed;
2089 }
2090
2091 static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
2092 {
2093         struct mem_cgroup *iter;
2094
2095         spin_lock(&memcg_oom_lock);
2096         for_each_mem_cgroup_tree(iter, memcg)
2097                 iter->oom_lock = false;
2098         spin_unlock(&memcg_oom_lock);
2099 }
2100
2101 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
2102 {
2103         struct mem_cgroup *iter;
2104
2105         for_each_mem_cgroup_tree(iter, memcg)
2106                 atomic_inc(&iter->under_oom);
2107 }
2108
2109 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
2110 {
2111         struct mem_cgroup *iter;
2112
2113         /*
2114          * When a new child is created while the hierarchy is under oom,
2115          * mem_cgroup_oom_lock() may not be called. We have to use
2116          * atomic_add_unless() here.
2117          */
2118         for_each_mem_cgroup_tree(iter, memcg)
2119                 atomic_add_unless(&iter->under_oom, -1, 0);
2120 }
2121
2122 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
2123
2124 struct oom_wait_info {
2125         struct mem_cgroup *memcg;
2126         wait_queue_t    wait;
2127 };
2128
2129 static int memcg_oom_wake_function(wait_queue_t *wait,
2130         unsigned mode, int sync, void *arg)
2131 {
2132         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
2133         struct mem_cgroup *oom_wait_memcg;
2134         struct oom_wait_info *oom_wait_info;
2135
2136         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
2137         oom_wait_memcg = oom_wait_info->memcg;
2138
2139         /*
2140          * Both of oom_wait_info->memcg and wake_memcg are stable under us.
2141          * Then we can use css_is_ancestor without taking care of RCU.
2142          */
2143         if (!mem_cgroup_same_or_subtree(oom_wait_memcg, wake_memcg)
2144                 && !mem_cgroup_same_or_subtree(wake_memcg, oom_wait_memcg))
2145                 return 0;
2146         return autoremove_wake_function(wait, mode, sync, arg);
2147 }
2148
2149 static void memcg_wakeup_oom(struct mem_cgroup *memcg)
2150 {
2151         atomic_inc(&memcg->oom_wakeups);
2152         /* for filtering, pass "memcg" as argument. */
2153         __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
2154 }
2155
2156 static void memcg_oom_recover(struct mem_cgroup *memcg)
2157 {
2158         if (memcg && atomic_read(&memcg->under_oom))
2159                 memcg_wakeup_oom(memcg);
2160 }
2161
2162 /*
2163  * try to call OOM killer
2164  */
2165 static void mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
2166 {
2167         bool locked;
2168         int wakeups;
2169
2170         if (!current->memcg_oom.may_oom)
2171                 return;
2172
2173         current->memcg_oom.in_memcg_oom = 1;
2174
2175         /*
2176          * As with any blocking lock, a contender needs to start
2177          * listening for wakeups before attempting the trylock,
2178          * otherwise it can miss the wakeup from the unlock and sleep
2179          * indefinitely.  This is just open-coded because our locking
2180          * is so particular to memcg hierarchies.
2181          */
2182         wakeups = atomic_read(&memcg->oom_wakeups);
2183         mem_cgroup_mark_under_oom(memcg);
2184
2185         locked = mem_cgroup_oom_trylock(memcg);
2186
2187         if (locked)
2188                 mem_cgroup_oom_notify(memcg);
2189
2190         if (locked && !memcg->oom_kill_disable) {
2191                 mem_cgroup_unmark_under_oom(memcg);
2192                 mem_cgroup_out_of_memory(memcg, mask, order);
2193                 mem_cgroup_oom_unlock(memcg);
2194                 /*
2195                  * There is no guarantee that an OOM-lock contender
2196                  * sees the wakeups triggered by the OOM kill
2197                  * uncharges.  Wake any sleepers explicitely.
2198                  */
2199                 memcg_oom_recover(memcg);
2200         } else {
2201                 /*
2202                  * A system call can just return -ENOMEM, but if this
2203                  * is a page fault and somebody else is handling the
2204                  * OOM already, we need to sleep on the OOM waitqueue
2205                  * for this memcg until the situation is resolved.
2206                  * Which can take some time because it might be
2207                  * handled by a userspace task.
2208                  *
2209                  * However, this is the charge context, which means
2210                  * that we may sit on a large call stack and hold
2211                  * various filesystem locks, the mmap_sem etc. and we
2212                  * don't want the OOM handler to deadlock on them
2213                  * while we sit here and wait.  Store the current OOM
2214                  * context in the task_struct, then return -ENOMEM.
2215                  * At the end of the page fault handler, with the
2216                  * stack unwound, pagefault_out_of_memory() will check
2217                  * back with us by calling
2218                  * mem_cgroup_oom_synchronize(), possibly putting the
2219                  * task to sleep.
2220                  */
2221                 current->memcg_oom.oom_locked = locked;
2222                 current->memcg_oom.wakeups = wakeups;
2223                 css_get(&memcg->css);
2224                 current->memcg_oom.wait_on_memcg = memcg;
2225         }
2226 }
2227
2228 /**
2229  * mem_cgroup_oom_synchronize - complete memcg OOM handling
2230  *
2231  * This has to be called at the end of a page fault if the the memcg
2232  * OOM handler was enabled and the fault is returning %VM_FAULT_OOM.
2233  *
2234  * Memcg supports userspace OOM handling, so failed allocations must
2235  * sleep on a waitqueue until the userspace task resolves the
2236  * situation.  Sleeping directly in the charge context with all kinds
2237  * of locks held is not a good idea, instead we remember an OOM state
2238  * in the task and mem_cgroup_oom_synchronize() has to be called at
2239  * the end of the page fault to put the task to sleep and clean up the
2240  * OOM state.
2241  *
2242  * Returns %true if an ongoing memcg OOM situation was detected and
2243  * finalized, %false otherwise.
2244  */
2245 bool mem_cgroup_oom_synchronize(void)
2246 {
2247         struct oom_wait_info owait;
2248         struct mem_cgroup *memcg;
2249
2250         /* OOM is global, do not handle */
2251         if (!current->memcg_oom.in_memcg_oom)
2252                 return false;
2253
2254         /*
2255          * We invoked the OOM killer but there is a chance that a kill
2256          * did not free up any charges.  Everybody else might already
2257          * be sleeping, so restart the fault and keep the rampage
2258          * going until some charges are released.
2259          */
2260         memcg = current->memcg_oom.wait_on_memcg;
2261         if (!memcg)
2262                 goto out;
2263
2264         if (test_thread_flag(TIF_MEMDIE) || fatal_signal_pending(current))
2265                 goto out_memcg;
2266
2267         owait.memcg = memcg;
2268         owait.wait.flags = 0;
2269         owait.wait.func = memcg_oom_wake_function;
2270         owait.wait.private = current;
2271         INIT_LIST_HEAD(&owait.wait.task_list);
2272
2273         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
2274         /* Only sleep if we didn't miss any wakeups since OOM */
2275         if (atomic_read(&memcg->oom_wakeups) == current->memcg_oom.wakeups)
2276                 schedule();
2277         finish_wait(&memcg_oom_waitq, &owait.wait);
2278 out_memcg:
2279         mem_cgroup_unmark_under_oom(memcg);
2280         if (current->memcg_oom.oom_locked) {
2281                 mem_cgroup_oom_unlock(memcg);
2282                 /*
2283                  * There is no guarantee that an OOM-lock contender
2284                  * sees the wakeups triggered by the OOM kill
2285                  * uncharges.  Wake any sleepers explicitely.
2286                  */
2287                 memcg_oom_recover(memcg);
2288         }
2289         css_put(&memcg->css);
2290         current->memcg_oom.wait_on_memcg = NULL;
2291 out:
2292         current->memcg_oom.in_memcg_oom = 0;
2293         return true;
2294 }
2295
2296 /*
2297  * Currently used to update mapped file statistics, but the routine can be
2298  * generalized to update other statistics as well.
2299  *
2300  * Notes: Race condition
2301  *
2302  * We usually use page_cgroup_lock() for accessing page_cgroup member but
2303  * it tends to be costly. But considering some conditions, we doesn't need
2304  * to do so _always_.
2305  *
2306  * Considering "charge", lock_page_cgroup() is not required because all
2307  * file-stat operations happen after a page is attached to radix-tree. There
2308  * are no race with "charge".
2309  *
2310  * Considering "uncharge", we know that memcg doesn't clear pc->mem_cgroup
2311  * at "uncharge" intentionally. So, we always see valid pc->mem_cgroup even
2312  * if there are race with "uncharge". Statistics itself is properly handled
2313  * by flags.
2314  *
2315  * Considering "move", this is an only case we see a race. To make the race
2316  * small, we check mm->moving_account and detect there are possibility of race
2317  * If there is, we take a lock.
2318  */
2319
2320 void __mem_cgroup_begin_update_page_stat(struct page *page,
2321                                 bool *locked, unsigned long *flags)
2322 {
2323         struct mem_cgroup *memcg;
2324         struct page_cgroup *pc;
2325
2326         pc = lookup_page_cgroup(page);
2327 again:
2328         memcg = pc->mem_cgroup;
2329         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2330                 return;
2331         /*
2332          * If this memory cgroup is not under account moving, we don't
2333          * need to take move_lock_mem_cgroup(). Because we already hold
2334          * rcu_read_lock(), any calls to move_account will be delayed until
2335          * rcu_read_unlock() if mem_cgroup_stolen() == true.
2336          */
2337         if (!mem_cgroup_stolen(memcg))
2338                 return;
2339
2340         move_lock_mem_cgroup(memcg, flags);
2341         if (memcg != pc->mem_cgroup || !PageCgroupUsed(pc)) {
2342                 move_unlock_mem_cgroup(memcg, flags);
2343                 goto again;
2344         }
2345         *locked = true;
2346 }
2347
2348 void __mem_cgroup_end_update_page_stat(struct page *page, unsigned long *flags)
2349 {
2350         struct page_cgroup *pc = lookup_page_cgroup(page);
2351
2352         /*
2353          * It's guaranteed that pc->mem_cgroup never changes while
2354          * lock is held because a routine modifies pc->mem_cgroup
2355          * should take move_lock_mem_cgroup().
2356          */
2357         move_unlock_mem_cgroup(pc->mem_cgroup, flags);
2358 }
2359
2360 void mem_cgroup_update_page_stat(struct page *page,
2361                                  enum mem_cgroup_stat_index idx, int val)
2362 {
2363         struct mem_cgroup *memcg;
2364         struct page_cgroup *pc = lookup_page_cgroup(page);
2365         unsigned long uninitialized_var(flags);
2366
2367         if (mem_cgroup_disabled())
2368                 return;
2369
2370         VM_BUG_ON(!rcu_read_lock_held());
2371         memcg = pc->mem_cgroup;
2372         if (unlikely(!memcg || !PageCgroupUsed(pc)))
2373                 return;
2374
2375         this_cpu_add(memcg->stat->count[idx], val);
2376 }
2377
2378 /*
2379  * size of first charge trial. "32" comes from vmscan.c's magic value.
2380  * TODO: maybe necessary to use big numbers in big irons.
2381  */
2382 #define CHARGE_BATCH    32U
2383 struct memcg_stock_pcp {
2384         struct mem_cgroup *cached; /* this never be root cgroup */
2385         unsigned int nr_pages;
2386         struct work_struct work;
2387         unsigned long flags;
2388 #define FLUSHING_CACHED_CHARGE  0
2389 };
2390 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
2391 static DEFINE_MUTEX(percpu_charge_mutex);
2392
2393 /**
2394  * consume_stock: Try to consume stocked charge on this cpu.
2395  * @memcg: memcg to consume from.
2396  * @nr_pages: how many pages to charge.
2397  *
2398  * The charges will only happen if @memcg matches the current cpu's memcg
2399  * stock, and at least @nr_pages are available in that stock.  Failure to
2400  * service an allocation will refill the stock.
2401  *
2402  * returns true if successful, false otherwise.
2403  */
2404 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2405 {
2406         struct memcg_stock_pcp *stock;
2407         bool ret = true;
2408
2409         if (nr_pages > CHARGE_BATCH)
2410                 return false;
2411
2412         stock = &get_cpu_var(memcg_stock);
2413         if (memcg == stock->cached && stock->nr_pages >= nr_pages)
2414                 stock->nr_pages -= nr_pages;
2415         else /* need to call res_counter_charge */
2416                 ret = false;
2417         put_cpu_var(memcg_stock);
2418         return ret;
2419 }
2420
2421 /*
2422  * Returns stocks cached in percpu to res_counter and reset cached information.
2423  */
2424 static void drain_stock(struct memcg_stock_pcp *stock)
2425 {
2426         struct mem_cgroup *old = stock->cached;
2427
2428         if (stock->nr_pages) {
2429                 unsigned long bytes = stock->nr_pages * PAGE_SIZE;
2430
2431                 res_counter_uncharge(&old->res, bytes);
2432                 if (do_swap_account)
2433                         res_counter_uncharge(&old->memsw, bytes);
2434                 stock->nr_pages = 0;
2435         }
2436         stock->cached = NULL;
2437 }
2438
2439 /*
2440  * This must be called under preempt disabled or must be called by
2441  * a thread which is pinned to local cpu.
2442  */
2443 static void drain_local_stock(struct work_struct *dummy)
2444 {
2445         struct memcg_stock_pcp *stock = &__get_cpu_var(memcg_stock);
2446         drain_stock(stock);
2447         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2448 }
2449
2450 static void __init memcg_stock_init(void)
2451 {
2452         int cpu;
2453
2454         for_each_possible_cpu(cpu) {
2455                 struct memcg_stock_pcp *stock =
2456                                         &per_cpu(memcg_stock, cpu);
2457                 INIT_WORK(&stock->work, drain_local_stock);
2458         }
2459 }
2460
2461 /*
2462  * Cache charges(val) which is from res_counter, to local per_cpu area.
2463  * This will be consumed by consume_stock() function, later.
2464  */
2465 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2466 {
2467         struct memcg_stock_pcp *stock = &get_cpu_var(memcg_stock);
2468
2469         if (stock->cached != memcg) { /* reset if necessary */
2470                 drain_stock(stock);
2471                 stock->cached = memcg;
2472         }
2473         stock->nr_pages += nr_pages;
2474         put_cpu_var(memcg_stock);
2475 }
2476
2477 /*
2478  * Drains all per-CPU charge caches for given root_memcg resp. subtree
2479  * of the hierarchy under it. sync flag says whether we should block
2480  * until the work is done.
2481  */
2482 static void drain_all_stock(struct mem_cgroup *root_memcg, bool sync)
2483 {
2484         int cpu, curcpu;
2485
2486         /* Notify other cpus that system-wide "drain" is running */
2487         get_online_cpus();
2488         curcpu = get_cpu();
2489         for_each_online_cpu(cpu) {
2490                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2491                 struct mem_cgroup *memcg;
2492
2493                 memcg = stock->cached;
2494                 if (!memcg || !stock->nr_pages)
2495                         continue;
2496                 if (!mem_cgroup_same_or_subtree(root_memcg, memcg))
2497                         continue;
2498                 if (!test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2499                         if (cpu == curcpu)
2500                                 drain_local_stock(&stock->work);
2501                         else
2502                                 schedule_work_on(cpu, &stock->work);
2503                 }
2504         }
2505         put_cpu();
2506
2507         if (!sync)
2508                 goto out;
2509
2510         for_each_online_cpu(cpu) {
2511                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2512                 if (test_bit(FLUSHING_CACHED_CHARGE, &stock->flags))
2513                         flush_work(&stock->work);
2514         }
2515 out:
2516         put_online_cpus();
2517 }
2518
2519 /*
2520  * Tries to drain stocked charges in other cpus. This function is asynchronous
2521  * and just put a work per cpu for draining localy on each cpu. Caller can
2522  * expects some charges will be back to res_counter later but cannot wait for
2523  * it.
2524  */
2525 static void drain_all_stock_async(struct mem_cgroup *root_memcg)
2526 {
2527         /*
2528          * If someone calls draining, avoid adding more kworker runs.
2529          */
2530         if (!mutex_trylock(&percpu_charge_mutex))
2531                 return;
2532         drain_all_stock(root_memcg, false);
2533         mutex_unlock(&percpu_charge_mutex);
2534 }
2535
2536 /* This is a synchronous drain interface. */
2537 static void drain_all_stock_sync(struct mem_cgroup *root_memcg)
2538 {
2539         /* called when force_empty is called */
2540         mutex_lock(&percpu_charge_mutex);
2541         drain_all_stock(root_memcg, true);
2542         mutex_unlock(&percpu_charge_mutex);
2543 }
2544
2545 /*
2546  * This function drains percpu counter value from DEAD cpu and
2547  * move it to local cpu. Note that this function can be preempted.
2548  */
2549 static void mem_cgroup_drain_pcp_counter(struct mem_cgroup *memcg, int cpu)
2550 {
2551         int i;
2552
2553         spin_lock(&memcg->pcp_counter_lock);
2554         for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
2555                 long x = per_cpu(memcg->stat->count[i], cpu);
2556
2557                 per_cpu(memcg->stat->count[i], cpu) = 0;
2558                 memcg->nocpu_base.count[i] += x;
2559         }
2560         for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
2561                 unsigned long x = per_cpu(memcg->stat->events[i], cpu);
2562
2563                 per_cpu(memcg->stat->events[i], cpu) = 0;
2564                 memcg->nocpu_base.events[i] += x;
2565         }
2566         spin_unlock(&memcg->pcp_counter_lock);
2567 }
2568
2569 static int memcg_cpu_hotplug_callback(struct notifier_block *nb,
2570                                         unsigned long action,
2571                                         void *hcpu)
2572 {
2573         int cpu = (unsigned long)hcpu;
2574         struct memcg_stock_pcp *stock;
2575         struct mem_cgroup *iter;
2576
2577         if (action == CPU_ONLINE)
2578                 return NOTIFY_OK;
2579
2580         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
2581                 return NOTIFY_OK;
2582
2583         for_each_mem_cgroup(iter)
2584                 mem_cgroup_drain_pcp_counter(iter, cpu);
2585
2586         stock = &per_cpu(memcg_stock, cpu);
2587         drain_stock(stock);
2588         return NOTIFY_OK;
2589 }
2590
2591
2592 /* See __mem_cgroup_try_charge() for details */
2593 enum {
2594         CHARGE_OK,              /* success */
2595         CHARGE_RETRY,           /* need to retry but retry is not bad */
2596         CHARGE_NOMEM,           /* we can't do more. return -ENOMEM */
2597         CHARGE_WOULDBLOCK,      /* GFP_WAIT wasn't set and no enough res. */
2598 };
2599
2600 static int mem_cgroup_do_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2601                                 unsigned int nr_pages, unsigned int min_pages,
2602                                 bool invoke_oom)
2603 {
2604         unsigned long csize = nr_pages * PAGE_SIZE;
2605         struct mem_cgroup *mem_over_limit;
2606         struct res_counter *fail_res;
2607         unsigned long flags = 0;
2608         int ret;
2609
2610         ret = res_counter_charge(&memcg->res, csize, &fail_res);
2611
2612         if (likely(!ret)) {
2613                 if (!do_swap_account)
2614                         return CHARGE_OK;
2615                 ret = res_counter_charge(&memcg->memsw, csize, &fail_res);
2616                 if (likely(!ret))
2617                         return CHARGE_OK;
2618
2619                 res_counter_uncharge(&memcg->res, csize);
2620                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, memsw);
2621                 flags |= MEM_CGROUP_RECLAIM_NOSWAP;
2622         } else
2623                 mem_over_limit = mem_cgroup_from_res_counter(fail_res, res);
2624         /*
2625          * Never reclaim on behalf of optional batching, retry with a
2626          * single page instead.
2627          */
2628         if (nr_pages > min_pages)
2629                 return CHARGE_RETRY;
2630
2631         if (!(gfp_mask & __GFP_WAIT))
2632                 return CHARGE_WOULDBLOCK;
2633
2634         if (gfp_mask & __GFP_NORETRY)
2635                 return CHARGE_NOMEM;
2636
2637         ret = mem_cgroup_reclaim(mem_over_limit, gfp_mask, flags);
2638         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2639                 return CHARGE_RETRY;
2640         /*
2641          * Even though the limit is exceeded at this point, reclaim
2642          * may have been able to free some pages.  Retry the charge
2643          * before killing the task.
2644          *
2645          * Only for regular pages, though: huge pages are rather
2646          * unlikely to succeed so close to the limit, and we fall back
2647          * to regular pages anyway in case of failure.
2648          */
2649         if (nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER) && ret)
2650                 return CHARGE_RETRY;
2651
2652         /*
2653          * At task move, charge accounts can be doubly counted. So, it's
2654          * better to wait until the end of task_move if something is going on.
2655          */
2656         if (mem_cgroup_wait_acct_move(mem_over_limit))
2657                 return CHARGE_RETRY;
2658
2659         if (invoke_oom)
2660                 mem_cgroup_oom(mem_over_limit, gfp_mask, get_order(csize));
2661
2662         return CHARGE_NOMEM;
2663 }
2664
2665 /*
2666  * __mem_cgroup_try_charge() does
2667  * 1. detect memcg to be charged against from passed *mm and *ptr,
2668  * 2. update res_counter
2669  * 3. call memory reclaim if necessary.
2670  *
2671  * In some special case, if the task is fatal, fatal_signal_pending() or
2672  * has TIF_MEMDIE, this function returns -EINTR while writing root_mem_cgroup
2673  * to *ptr. There are two reasons for this. 1: fatal threads should quit as soon
2674  * as possible without any hazards. 2: all pages should have a valid
2675  * pc->mem_cgroup. If mm is NULL and the caller doesn't pass a valid memcg
2676  * pointer, that is treated as a charge to root_mem_cgroup.
2677  *
2678  * So __mem_cgroup_try_charge() will return
2679  *  0       ...  on success, filling *ptr with a valid memcg pointer.
2680  *  -ENOMEM ...  charge failure because of resource limits.
2681  *  -EINTR  ...  if thread is fatal. *ptr is filled with root_mem_cgroup.
2682  *
2683  * Unlike the exported interface, an "oom" parameter is added. if oom==true,
2684  * the oom-killer can be invoked.
2685  */
2686 static int __mem_cgroup_try_charge(struct mm_struct *mm,
2687                                    gfp_t gfp_mask,
2688                                    unsigned int nr_pages,
2689                                    struct mem_cgroup **ptr,
2690                                    bool oom)
2691 {
2692         unsigned int batch = max(CHARGE_BATCH, nr_pages);
2693         int nr_oom_retries = MEM_CGROUP_RECLAIM_RETRIES;
2694         struct mem_cgroup *memcg = NULL;
2695         int ret;
2696
2697         /*
2698          * Unlike gloval-vm's OOM-kill, we're not in memory shortage
2699          * in system level. So, allow to go ahead dying process in addition to
2700          * MEMDIE process.
2701          */
2702         if (unlikely(test_thread_flag(TIF_MEMDIE)
2703                      || fatal_signal_pending(current)))
2704                 goto bypass;
2705
2706         /*
2707          * We always charge the cgroup the mm_struct belongs to.
2708          * The mm_struct's mem_cgroup changes on task migration if the
2709          * thread group leader migrates. It's possible that mm is not
2710          * set, if so charge the root memcg (happens for pagecache usage).
2711          */
2712         if (!*ptr && !mm)
2713                 *ptr = root_mem_cgroup;
2714 again:
2715         if (*ptr) { /* css should be a valid one */
2716                 memcg = *ptr;
2717                 if (mem_cgroup_is_root(memcg))
2718                         goto done;
2719                 if (consume_stock(memcg, nr_pages))
2720                         goto done;
2721                 css_get(&memcg->css);
2722         } else {
2723                 struct task_struct *p;
2724
2725                 rcu_read_lock();
2726                 p = rcu_dereference(mm->owner);
2727                 /*
2728                  * Because we don't have task_lock(), "p" can exit.
2729                  * In that case, "memcg" can point to root or p can be NULL with
2730                  * race with swapoff. Then, we have small risk of mis-accouning.
2731                  * But such kind of mis-account by race always happens because
2732                  * we don't have cgroup_mutex(). It's overkill and we allo that
2733                  * small race, here.
2734                  * (*) swapoff at el will charge against mm-struct not against
2735                  * task-struct. So, mm->owner can be NULL.
2736                  */
2737                 memcg = mem_cgroup_from_task(p);
2738                 if (!memcg)
2739                         memcg = root_mem_cgroup;
2740                 if (mem_cgroup_is_root(memcg)) {
2741                         rcu_read_unlock();
2742                         goto done;
2743                 }
2744                 if (consume_stock(memcg, nr_pages)) {
2745                         /*
2746                          * It seems dagerous to access memcg without css_get().
2747                          * But considering how consume_stok works, it's not
2748                          * necessary. If consume_stock success, some charges
2749                          * from this memcg are cached on this cpu. So, we
2750                          * don't need to call css_get()/css_tryget() before
2751                          * calling consume_stock().
2752                          */
2753                         rcu_read_unlock();
2754                         goto done;
2755                 }
2756                 /* after here, we may be blocked. we need to get refcnt */
2757                 if (!css_tryget(&memcg->css)) {
2758                         rcu_read_unlock();
2759                         goto again;
2760                 }
2761                 rcu_read_unlock();
2762         }
2763
2764         do {
2765                 bool invoke_oom = oom && !nr_oom_retries;
2766
2767                 /* If killed, bypass charge */
2768                 if (fatal_signal_pending(current)) {
2769                         css_put(&memcg->css);
2770                         goto bypass;
2771                 }
2772
2773                 ret = mem_cgroup_do_charge(memcg, gfp_mask, batch,
2774                                            nr_pages, invoke_oom);
2775                 switch (ret) {
2776                 case CHARGE_OK:
2777                         break;
2778                 case CHARGE_RETRY: /* not in OOM situation but retry */
2779                         batch = nr_pages;
2780                         css_put(&memcg->css);
2781                         memcg = NULL;
2782                         goto again;
2783                 case CHARGE_WOULDBLOCK: /* !__GFP_WAIT */
2784                         css_put(&memcg->css);
2785                         goto nomem;
2786                 case CHARGE_NOMEM: /* OOM routine works */
2787                         if (!oom || invoke_oom) {
2788                                 css_put(&memcg->css);
2789                                 goto nomem;
2790                         }
2791                         nr_oom_retries--;
2792                         break;
2793                 }
2794         } while (ret != CHARGE_OK);
2795
2796         if (batch > nr_pages)
2797                 refill_stock(memcg, batch - nr_pages);
2798         css_put(&memcg->css);
2799 done:
2800         *ptr = memcg;
2801         return 0;
2802 nomem:
2803         *ptr = NULL;
2804         return -ENOMEM;
2805 bypass:
2806         *ptr = root_mem_cgroup;
2807         return -EINTR;
2808 }
2809
2810 /*
2811  * Somemtimes we have to undo a charge we got by try_charge().
2812  * This function is for that and do uncharge, put css's refcnt.
2813  * gotten by try_charge().
2814  */
2815 static void __mem_cgroup_cancel_charge(struct mem_cgroup *memcg,
2816                                        unsigned int nr_pages)
2817 {
2818         if (!mem_cgroup_is_root(memcg)) {
2819                 unsigned long bytes = nr_pages * PAGE_SIZE;
2820
2821                 res_counter_uncharge(&memcg->res, bytes);
2822                 if (do_swap_account)
2823                         res_counter_uncharge(&memcg->memsw, bytes);
2824         }
2825 }
2826
2827 /*
2828  * Cancel chrages in this cgroup....doesn't propagate to parent cgroup.
2829  * This is useful when moving usage to parent cgroup.
2830  */
2831 static void __mem_cgroup_cancel_local_charge(struct mem_cgroup *memcg,
2832                                         unsigned int nr_pages)
2833 {
2834         unsigned long bytes = nr_pages * PAGE_SIZE;
2835
2836         if (mem_cgroup_is_root(memcg))
2837                 return;
2838
2839         res_counter_uncharge_until(&memcg->res, memcg->res.parent, bytes);
2840         if (do_swap_account)
2841                 res_counter_uncharge_until(&memcg->memsw,
2842                                                 memcg->memsw.parent, bytes);
2843 }
2844
2845 /*
2846  * A helper function to get mem_cgroup from ID. must be called under
2847  * rcu_read_lock().  The caller is responsible for calling css_tryget if
2848  * the mem_cgroup is used for charging. (dropping refcnt from swap can be
2849  * called against removed memcg.)
2850  */
2851 static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
2852 {
2853         struct cgroup_subsys_state *css;
2854
2855         /* ID 0 is unused ID */
2856         if (!id)
2857                 return NULL;
2858         css = css_lookup(&mem_cgroup_subsys, id);
2859         if (!css)
2860                 return NULL;
2861         return mem_cgroup_from_css(css);
2862 }
2863
2864 struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
2865 {
2866         struct mem_cgroup *memcg = NULL;
2867         struct page_cgroup *pc;
2868         unsigned short id;
2869         swp_entry_t ent;
2870
2871         VM_BUG_ON(!PageLocked(page));
2872
2873         pc = lookup_page_cgroup(page);
2874         lock_page_cgroup(pc);
2875         if (PageCgroupUsed(pc)) {
2876                 memcg = pc->mem_cgroup;
2877                 if (memcg && !css_tryget(&memcg->css))
2878                         memcg = NULL;
2879         } else if (PageSwapCache(page)) {
2880                 ent.val = page_private(page);
2881                 id = lookup_swap_cgroup_id(ent);
2882                 rcu_read_lock();
2883                 memcg = mem_cgroup_lookup(id);
2884                 if (memcg && !css_tryget(&memcg->css))
2885                         memcg = NULL;
2886                 rcu_read_unlock();
2887         }
2888         unlock_page_cgroup(pc);
2889         return memcg;
2890 }
2891
2892 static void __mem_cgroup_commit_charge(struct mem_cgroup *memcg,
2893                                        struct page *page,
2894                                        unsigned int nr_pages,
2895                                        enum charge_type ctype,
2896                                        bool lrucare)
2897 {
2898         struct page_cgroup *pc = lookup_page_cgroup(page);
2899         struct zone *uninitialized_var(zone);
2900         struct lruvec *lruvec;
2901         bool was_on_lru = false;
2902         bool anon;
2903
2904         lock_page_cgroup(pc);
2905         VM_BUG_ON(PageCgroupUsed(pc));
2906         /*
2907          * we don't need page_cgroup_lock about tail pages, becase they are not
2908          * accessed by any other context at this point.
2909          */
2910
2911         /*
2912          * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2913          * may already be on some other mem_cgroup's LRU.  Take care of it.
2914          */
2915         if (lrucare) {
2916                 zone = page_zone(page);
2917                 spin_lock_irq(&zone->lru_lock);
2918                 if (PageLRU(page)) {
2919                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2920                         ClearPageLRU(page);
2921                         del_page_from_lru_list(page, lruvec, page_lru(page));
2922                         was_on_lru = true;
2923                 }
2924         }
2925
2926         pc->mem_cgroup = memcg;
2927         /*
2928          * We access a page_cgroup asynchronously without lock_page_cgroup().
2929          * Especially when a page_cgroup is taken from a page, pc->mem_cgroup
2930          * is accessed after testing USED bit. To make pc->mem_cgroup visible
2931          * before USED bit, we need memory barrier here.
2932          * See mem_cgroup_add_lru_list(), etc.
2933          */
2934         smp_wmb();
2935         SetPageCgroupUsed(pc);
2936
2937         if (lrucare) {
2938                 if (was_on_lru) {
2939                         lruvec = mem_cgroup_zone_lruvec(zone, pc->mem_cgroup);
2940                         VM_BUG_ON(PageLRU(page));
2941                         SetPageLRU(page);
2942                         add_page_to_lru_list(page, lruvec, page_lru(page));
2943                 }
2944                 spin_unlock_irq(&zone->lru_lock);
2945         }
2946
2947         if (ctype == MEM_CGROUP_CHARGE_TYPE_ANON)
2948                 anon = true;
2949         else
2950                 anon = false;
2951
2952         mem_cgroup_charge_statistics(memcg, page, anon, nr_pages);
2953         unlock_page_cgroup(pc);
2954
2955         /*
2956          * "charge_statistics" updated event counter. Then, check it.
2957          * Insert ancestor (and ancestor's ancestors), to softlimit RB-tree.
2958          * if they exceeds softlimit.
2959          */
2960         memcg_check_events(memcg, page);
2961 }
2962
2963 static DEFINE_MUTEX(set_limit_mutex);
2964
2965 #ifdef CONFIG_MEMCG_KMEM
2966 static inline bool memcg_can_account_kmem(struct mem_cgroup *memcg)
2967 {
2968         return !mem_cgroup_disabled() && !mem_cgroup_is_root(memcg) &&
2969                 (memcg->kmem_account_flags & KMEM_ACCOUNTED_MASK);
2970 }
2971
2972 /*
2973  * This is a bit cumbersome, but it is rarely used and avoids a backpointer
2974  * in the memcg_cache_params struct.
2975  */
2976 static struct kmem_cache *memcg_params_to_cache(struct memcg_cache_params *p)
2977 {
2978         struct kmem_cache *cachep;
2979
2980         VM_BUG_ON(p->is_root_cache);
2981         cachep = p->root_cache;
2982         return cachep->memcg_params->memcg_caches[memcg_cache_id(p->memcg)];
2983 }
2984
2985 #ifdef CONFIG_SLABINFO
2986 static int mem_cgroup_slabinfo_read(struct cgroup_subsys_state *css,
2987                                     struct cftype *cft, struct seq_file *m)
2988 {
2989         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
2990         struct memcg_cache_params *params;
2991
2992         if (!memcg_can_account_kmem(memcg))
2993                 return -EIO;
2994
2995         print_slabinfo_header(m);
2996
2997         mutex_lock(&memcg->slab_caches_mutex);
2998         list_for_each_entry(params, &memcg->memcg_slab_caches, list)
2999                 cache_show(memcg_params_to_cache(params), m);
3000         mutex_unlock(&memcg->slab_caches_mutex);
3001
3002         return 0;
3003 }
3004 #endif
3005
3006 static int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp, u64 size)
3007 {
3008         struct res_counter *fail_res;
3009         struct mem_cgroup *_memcg;
3010         int ret = 0;
3011         bool may_oom;
3012
3013         ret = res_counter_charge(&memcg->kmem, size, &fail_res);
3014         if (ret)
3015                 return ret;
3016
3017         /*
3018          * Conditions under which we can wait for the oom_killer. Those are
3019          * the same conditions tested by the core page allocator
3020          */
3021         may_oom = (gfp & __GFP_FS) && !(gfp & __GFP_NORETRY);
3022
3023         _memcg = memcg;
3024         ret = __mem_cgroup_try_charge(NULL, gfp, size >> PAGE_SHIFT,
3025                                       &_memcg, may_oom);
3026
3027         if (ret == -EINTR)  {
3028                 /*
3029                  * __mem_cgroup_try_charge() chosed to bypass to root due to
3030                  * OOM kill or fatal signal.  Since our only options are to
3031                  * either fail the allocation or charge it to this cgroup, do
3032                  * it as a temporary condition. But we can't fail. From a
3033                  * kmem/slab perspective, the cache has already been selected,
3034                  * by mem_cgroup_kmem_get_cache(), so it is too late to change
3035                  * our minds.
3036                  *
3037                  * This condition will only trigger if the task entered
3038                  * memcg_charge_kmem in a sane state, but was OOM-killed during
3039                  * __mem_cgroup_try_charge() above. Tasks that were already
3040                  * dying when the allocation triggers should have been already
3041                  * directed to the root cgroup in memcontrol.h
3042                  */
3043                 res_counter_charge_nofail(&memcg->res, size, &fail_res);
3044                 if (do_swap_account)
3045                         res_counter_charge_nofail(&memcg->memsw, size,
3046                                                   &fail_res);
3047                 ret = 0;
3048         } else if (ret)
3049                 res_counter_uncharge(&memcg->kmem, size);
3050
3051         return ret;
3052 }
3053
3054 static void memcg_uncharge_kmem(struct mem_cgroup *memcg, u64 size)
3055 {
3056         res_counter_uncharge(&memcg->res, size);
3057         if (do_swap_account)
3058                 res_counter_uncharge(&memcg->memsw, size);
3059
3060         /* Not down to 0 */
3061         if (res_counter_uncharge(&memcg->kmem, size))
3062                 return;
3063
3064         /*
3065          * Releases a reference taken in kmem_cgroup_css_offline in case
3066          * this last uncharge is racing with the offlining code or it is
3067          * outliving the memcg existence.
3068          *
3069          * The memory barrier imposed by test&clear is paired with the
3070          * explicit one in memcg_kmem_mark_dead().
3071          */
3072         if (memcg_kmem_test_and_clear_dead(memcg))
3073                 css_put(&memcg->css);
3074 }
3075
3076 void memcg_cache_list_add(struct mem_cgroup *memcg, struct kmem_cache *cachep)
3077 {
3078         if (!memcg)
3079                 return;
3080
3081         mutex_lock(&memcg->slab_caches_mutex);
3082         list_add(&cachep->memcg_params->list, &memcg->memcg_slab_caches);
3083         mutex_unlock(&memcg->slab_caches_mutex);
3084 }
3085
3086 /*
3087  * helper for acessing a memcg's index. It will be used as an index in the
3088  * child cache array in kmem_cache, and also to derive its name. This function
3089  * will return -1 when this is not a kmem-limited memcg.
3090  */
3091 int memcg_cache_id(struct mem_cgroup *memcg)
3092 {
3093         return memcg ? memcg->kmemcg_id : -1;
3094 }
3095
3096 /*
3097  * This ends up being protected by the set_limit mutex, during normal
3098  * operation, because that is its main call site.
3099  *
3100  * But when we create a new cache, we can call this as well if its parent
3101  * is kmem-limited. That will have to hold set_limit_mutex as well.
3102  */
3103 int memcg_update_cache_sizes(struct mem_cgroup *memcg)
3104 {
3105         int num, ret;
3106
3107         num = ida_simple_get(&kmem_limited_groups,
3108                                 0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
3109         if (num < 0)
3110                 return num;
3111         /*
3112          * After this point, kmem_accounted (that we test atomically in
3113          * the beginning of this conditional), is no longer 0. This
3114          * guarantees only one process will set the following boolean
3115          * to true. We don't need test_and_set because we're protected
3116          * by the set_limit_mutex anyway.
3117          */
3118         memcg_kmem_set_activated(memcg);
3119
3120         ret = memcg_update_all_caches(num+1);
3121         if (ret) {
3122                 ida_simple_remove(&kmem_limited_groups, num);
3123                 memcg_kmem_clear_activated(memcg);
3124                 return ret;
3125         }
3126
3127         memcg->kmemcg_id = num;
3128         INIT_LIST_HEAD(&memcg->memcg_slab_caches);
3129         mutex_init(&memcg->slab_caches_mutex);
3130         return 0;
3131 }
3132
3133 static size_t memcg_caches_array_size(int num_groups)
3134 {
3135         ssize_t size;
3136         if (num_groups <= 0)
3137                 return 0;
3138
3139         size = 2 * num_groups;
3140         if (size < MEMCG_CACHES_MIN_SIZE)
3141                 size = MEMCG_CACHES_MIN_SIZE;
3142         else if (size > MEMCG_CACHES_MAX_SIZE)
3143                 size = MEMCG_CACHES_MAX_SIZE;
3144
3145         return size;
3146 }
3147
3148 /*
3149  * We should update the current array size iff all caches updates succeed. This
3150  * can only be done from the slab side. The slab mutex needs to be held when
3151  * calling this.
3152  */
3153 void memcg_update_array_size(int num)
3154 {
3155         if (num > memcg_limited_groups_array_size)
3156                 memcg_limited_groups_array_size = memcg_caches_array_size(num);
3157 }
3158
3159 static void kmem_cache_destroy_work_func(struct work_struct *w);
3160
3161 int memcg_update_cache_size(struct kmem_cache *s, int num_groups)
3162 {
3163         struct memcg_cache_params *cur_params = s->memcg_params;
3164
3165         VM_BUG_ON(s->memcg_params && !s->memcg_params->is_root_cache);
3166
3167         if (num_groups > memcg_limited_groups_array_size) {
3168                 int i;
3169                 ssize_t size = memcg_caches_array_size(num_groups);
3170
3171                 size *= sizeof(void *);
3172                 size += offsetof(struct memcg_cache_params, memcg_caches);
3173
3174                 s->memcg_params = kzalloc(size, GFP_KERNEL);
3175                 if (!s->memcg_params) {
3176                         s->memcg_params = cur_params;
3177                         return -ENOMEM;
3178                 }
3179
3180                 s->memcg_params->is_root_cache = true;
3181
3182                 /*
3183                  * There is the chance it will be bigger than
3184                  * memcg_limited_groups_array_size, if we failed an allocation
3185                  * in a cache, in which case all caches updated before it, will
3186                  * have a bigger array.
3187                  *
3188                  * But if that is the case, the data after
3189                  * memcg_limited_groups_array_size is certainly unused
3190                  */
3191                 for (i = 0; i < memcg_limited_groups_array_size; i++) {
3192                         if (!cur_params->memcg_caches[i])
3193                                 continue;
3194                         s->memcg_params->memcg_caches[i] =
3195                                                 cur_params->memcg_caches[i];
3196                 }
3197
3198                 /*
3199                  * Ideally, we would wait until all caches succeed, and only
3200                  * then free the old one. But this is not worth the extra
3201                  * pointer per-cache we'd have to have for this.
3202                  *
3203                  * It is not a big deal if some caches are left with a size
3204                  * bigger than the others. And all updates will reset this
3205                  * anyway.
3206                  */
3207                 kfree(cur_params);
3208         }
3209         return 0;
3210 }
3211
3212 int memcg_register_cache(struct mem_cgroup *memcg, struct kmem_cache *s,
3213                          struct kmem_cache *root_cache)
3214 {
3215         size_t size;
3216
3217         if (!memcg_kmem_enabled())
3218                 return 0;
3219
3220         if (!memcg) {
3221                 size = offsetof(struct memcg_cache_params, memcg_caches);
3222                 size += memcg_limited_groups_array_size * sizeof(void *);
3223         } else
3224                 size = sizeof(struct memcg_cache_params);
3225
3226         s->memcg_params = kzalloc(size, GFP_KERNEL);
3227         if (!s->memcg_params)
3228                 return -ENOMEM;
3229
3230         if (memcg) {
3231                 s->memcg_params->memcg = memcg;
3232                 s->memcg_params->root_cache = root_cache;
3233                 INIT_WORK(&s->memcg_params->destroy,
3234                                 kmem_cache_destroy_work_func);
3235         } else
3236                 s->memcg_params->is_root_cache = true;
3237
3238         return 0;
3239 }
3240
3241 void memcg_release_cache(struct kmem_cache *s)
3242 {
3243         struct kmem_cache *root;
3244         struct mem_cgroup *memcg;
3245         int id;
3246
3247         /*
3248          * This happens, for instance, when a root cache goes away before we
3249          * add any memcg.
3250          */
3251         if (!s->memcg_params)
3252                 return;
3253
3254         if (s->memcg_params->is_root_cache)
3255                 goto out;
3256
3257         memcg = s->memcg_params->memcg;
3258         id  = memcg_cache_id(memcg);
3259
3260         root = s->memcg_params->root_cache;
3261         root->memcg_params->memcg_caches[id] = NULL;
3262
3263         mutex_lock(&memcg->slab_caches_mutex);
3264         list_del(&s->memcg_params->list);
3265         mutex_unlock(&memcg->slab_caches_mutex);
3266
3267         css_put(&memcg->css);
3268 out:
3269         kfree(s->memcg_params);
3270 }
3271
3272 /*
3273  * During the creation a new cache, we need to disable our accounting mechanism
3274  * altogether. This is true even if we are not creating, but rather just
3275  * enqueing new caches to be created.
3276  *
3277  * This is because that process will trigger allocations; some visible, like
3278  * explicit kmallocs to auxiliary data structures, name strings and internal
3279  * cache structures; some well concealed, like INIT_WORK() that can allocate
3280  * objects during debug.
3281  *
3282  * If any allocation happens during memcg_kmem_get_cache, we will recurse back
3283  * to it. This may not be a bounded recursion: since the first cache creation
3284  * failed to complete (waiting on the allocation), we'll just try to create the
3285  * cache again, failing at the same point.
3286  *
3287  * memcg_kmem_get_cache is prepared to abort after seeing a positive count of
3288  * memcg_kmem_skip_account. So we enclose anything that might allocate memory
3289  * inside the following two functions.
3290  */
3291 static inline void memcg_stop_kmem_account(void)
3292 {
3293         VM_BUG_ON(!current->mm);
3294