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