memcg: fix NULL pointer dereference in __mem_cgroup_usage_unregister_event
[muen/linux.git] / mm / memcontrol.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* memcontrol.c - Memory Controller
3  *
4  * Copyright IBM Corporation, 2007
5  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
6  *
7  * Copyright 2007 OpenVZ SWsoft Inc
8  * Author: Pavel Emelianov <xemul@openvz.org>
9  *
10  * Memory thresholds
11  * Copyright (C) 2009 Nokia Corporation
12  * Author: Kirill A. Shutemov
13  *
14  * Kernel Memory Controller
15  * Copyright (C) 2012 Parallels Inc. and Google Inc.
16  * Authors: Glauber Costa and Suleiman Souhlal
17  *
18  * Native page reclaim
19  * Charge lifetime sanitation
20  * Lockless page tracking & accounting
21  * Unified hierarchy configuration model
22  * Copyright (C) 2015 Red Hat, Inc., Johannes Weiner
23  */
24
25 #include <linux/page_counter.h>
26 #include <linux/memcontrol.h>
27 #include <linux/cgroup.h>
28 #include <linux/pagewalk.h>
29 #include <linux/sched/mm.h>
30 #include <linux/shmem_fs.h>
31 #include <linux/hugetlb.h>
32 #include <linux/pagemap.h>
33 #include <linux/vm_event_item.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/poll.h>
49 #include <linux/sort.h>
50 #include <linux/fs.h>
51 #include <linux/seq_file.h>
52 #include <linux/vmpressure.h>
53 #include <linux/mm_inline.h>
54 #include <linux/swap_cgroup.h>
55 #include <linux/cpu.h>
56 #include <linux/oom.h>
57 #include <linux/lockdep.h>
58 #include <linux/file.h>
59 #include <linux/tracehook.h>
60 #include <linux/psi.h>
61 #include <linux/seq_buf.h>
62 #include "internal.h"
63 #include <net/sock.h>
64 #include <net/ip.h>
65 #include "slab.h"
66
67 #include <linux/uaccess.h>
68
69 #include <trace/events/vmscan.h>
70
71 struct cgroup_subsys memory_cgrp_subsys __read_mostly;
72 EXPORT_SYMBOL(memory_cgrp_subsys);
73
74 struct mem_cgroup *root_mem_cgroup __read_mostly;
75
76 #define MEM_CGROUP_RECLAIM_RETRIES      5
77
78 /* Socket memory accounting disabled? */
79 static bool cgroup_memory_nosocket;
80
81 /* Kernel memory accounting disabled? */
82 static bool cgroup_memory_nokmem;
83
84 /* Whether the swap controller is active */
85 #ifdef CONFIG_MEMCG_SWAP
86 int do_swap_account __read_mostly;
87 #else
88 #define do_swap_account         0
89 #endif
90
91 #ifdef CONFIG_CGROUP_WRITEBACK
92 static DECLARE_WAIT_QUEUE_HEAD(memcg_cgwb_frn_waitq);
93 #endif
94
95 /* Whether legacy memory+swap accounting is active */
96 static bool do_memsw_account(void)
97 {
98         return !cgroup_subsys_on_dfl(memory_cgrp_subsys) && do_swap_account;
99 }
100
101 #define THRESHOLDS_EVENTS_TARGET 128
102 #define SOFTLIMIT_EVENTS_TARGET 1024
103
104 /*
105  * Cgroups above their limits are maintained in a RB-Tree, independent of
106  * their hierarchy representation
107  */
108
109 struct mem_cgroup_tree_per_node {
110         struct rb_root rb_root;
111         struct rb_node *rb_rightmost;
112         spinlock_t lock;
113 };
114
115 struct mem_cgroup_tree {
116         struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
117 };
118
119 static struct mem_cgroup_tree soft_limit_tree __read_mostly;
120
121 /* for OOM */
122 struct mem_cgroup_eventfd_list {
123         struct list_head list;
124         struct eventfd_ctx *eventfd;
125 };
126
127 /*
128  * cgroup_event represents events which userspace want to receive.
129  */
130 struct mem_cgroup_event {
131         /*
132          * memcg which the event belongs to.
133          */
134         struct mem_cgroup *memcg;
135         /*
136          * eventfd to signal userspace about the event.
137          */
138         struct eventfd_ctx *eventfd;
139         /*
140          * Each of these stored in a list by the cgroup.
141          */
142         struct list_head list;
143         /*
144          * register_event() callback will be used to add new userspace
145          * waiter for changes related to this event.  Use eventfd_signal()
146          * on eventfd to send notification to userspace.
147          */
148         int (*register_event)(struct mem_cgroup *memcg,
149                               struct eventfd_ctx *eventfd, const char *args);
150         /*
151          * unregister_event() callback will be called when userspace closes
152          * the eventfd or on cgroup removing.  This callback must be set,
153          * if you want provide notification functionality.
154          */
155         void (*unregister_event)(struct mem_cgroup *memcg,
156                                  struct eventfd_ctx *eventfd);
157         /*
158          * All fields below needed to unregister event when
159          * userspace closes eventfd.
160          */
161         poll_table pt;
162         wait_queue_head_t *wqh;
163         wait_queue_entry_t wait;
164         struct work_struct remove;
165 };
166
167 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
168 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
169
170 /* Stuffs for move charges at task migration. */
171 /*
172  * Types of charges to be moved.
173  */
174 #define MOVE_ANON       0x1U
175 #define MOVE_FILE       0x2U
176 #define MOVE_MASK       (MOVE_ANON | MOVE_FILE)
177
178 /* "mc" and its members are protected by cgroup_mutex */
179 static struct move_charge_struct {
180         spinlock_t        lock; /* for from, to */
181         struct mm_struct  *mm;
182         struct mem_cgroup *from;
183         struct mem_cgroup *to;
184         unsigned long flags;
185         unsigned long precharge;
186         unsigned long moved_charge;
187         unsigned long moved_swap;
188         struct task_struct *moving_task;        /* a task moving charges */
189         wait_queue_head_t waitq;                /* a waitq for other context */
190 } mc = {
191         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
192         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
193 };
194
195 /*
196  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
197  * limit reclaim to prevent infinite loops, if they ever occur.
198  */
199 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
200 #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
201
202 enum charge_type {
203         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
204         MEM_CGROUP_CHARGE_TYPE_ANON,
205         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
206         MEM_CGROUP_CHARGE_TYPE_DROP,    /* a page was unused swap cache */
207         NR_CHARGE_TYPE,
208 };
209
210 /* for encoding cft->private value on file */
211 enum res_type {
212         _MEM,
213         _MEMSWAP,
214         _OOM_TYPE,
215         _KMEM,
216         _TCP,
217 };
218
219 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
220 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
221 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
222 /* Used for OOM nofiier */
223 #define OOM_CONTROL             (0)
224
225 /*
226  * Iteration constructs for visiting all cgroups (under a tree).  If
227  * loops are exited prematurely (break), mem_cgroup_iter_break() must
228  * be used for reference counting.
229  */
230 #define for_each_mem_cgroup_tree(iter, root)            \
231         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
232              iter != NULL;                              \
233              iter = mem_cgroup_iter(root, iter, NULL))
234
235 #define for_each_mem_cgroup(iter)                       \
236         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
237              iter != NULL;                              \
238              iter = mem_cgroup_iter(NULL, iter, NULL))
239
240 static inline bool should_force_charge(void)
241 {
242         return tsk_is_oom_victim(current) || fatal_signal_pending(current) ||
243                 (current->flags & PF_EXITING);
244 }
245
246 /* Some nice accessors for the vmpressure. */
247 struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
248 {
249         if (!memcg)
250                 memcg = root_mem_cgroup;
251         return &memcg->vmpressure;
252 }
253
254 struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
255 {
256         return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
257 }
258
259 #ifdef CONFIG_MEMCG_KMEM
260 /*
261  * This will be the memcg's index in each cache's ->memcg_params.memcg_caches.
262  * The main reason for not using cgroup id for this:
263  *  this works better in sparse environments, where we have a lot of memcgs,
264  *  but only a few kmem-limited. Or also, if we have, for instance, 200
265  *  memcgs, and none but the 200th is kmem-limited, we'd have to have a
266  *  200 entry array for that.
267  *
268  * The current size of the caches array is stored in memcg_nr_cache_ids. It
269  * will double each time we have to increase it.
270  */
271 static DEFINE_IDA(memcg_cache_ida);
272 int memcg_nr_cache_ids;
273
274 /* Protects memcg_nr_cache_ids */
275 static DECLARE_RWSEM(memcg_cache_ids_sem);
276
277 void memcg_get_cache_ids(void)
278 {
279         down_read(&memcg_cache_ids_sem);
280 }
281
282 void memcg_put_cache_ids(void)
283 {
284         up_read(&memcg_cache_ids_sem);
285 }
286
287 /*
288  * MIN_SIZE is different than 1, because we would like to avoid going through
289  * the alloc/free process all the time. In a small machine, 4 kmem-limited
290  * cgroups is a reasonable guess. In the future, it could be a parameter or
291  * tunable, but that is strictly not necessary.
292  *
293  * MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get
294  * this constant directly from cgroup, but it is understandable that this is
295  * better kept as an internal representation in cgroup.c. In any case, the
296  * cgrp_id space is not getting any smaller, and we don't have to necessarily
297  * increase ours as well if it increases.
298  */
299 #define MEMCG_CACHES_MIN_SIZE 4
300 #define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX
301
302 /*
303  * A lot of the calls to the cache allocation functions are expected to be
304  * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
305  * conditional to this static branch, we'll have to allow modules that does
306  * kmem_cache_alloc and the such to see this symbol as well
307  */
308 DEFINE_STATIC_KEY_FALSE(memcg_kmem_enabled_key);
309 EXPORT_SYMBOL(memcg_kmem_enabled_key);
310
311 struct workqueue_struct *memcg_kmem_cache_wq;
312 #endif
313
314 static int memcg_shrinker_map_size;
315 static DEFINE_MUTEX(memcg_shrinker_map_mutex);
316
317 static void memcg_free_shrinker_map_rcu(struct rcu_head *head)
318 {
319         kvfree(container_of(head, struct memcg_shrinker_map, rcu));
320 }
321
322 static int memcg_expand_one_shrinker_map(struct mem_cgroup *memcg,
323                                          int size, int old_size)
324 {
325         struct memcg_shrinker_map *new, *old;
326         int nid;
327
328         lockdep_assert_held(&memcg_shrinker_map_mutex);
329
330         for_each_node(nid) {
331                 old = rcu_dereference_protected(
332                         mem_cgroup_nodeinfo(memcg, nid)->shrinker_map, true);
333                 /* Not yet online memcg */
334                 if (!old)
335                         return 0;
336
337                 new = kvmalloc(sizeof(*new) + size, GFP_KERNEL);
338                 if (!new)
339                         return -ENOMEM;
340
341                 /* Set all old bits, clear all new bits */
342                 memset(new->map, (int)0xff, old_size);
343                 memset((void *)new->map + old_size, 0, size - old_size);
344
345                 rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_map, new);
346                 call_rcu(&old->rcu, memcg_free_shrinker_map_rcu);
347         }
348
349         return 0;
350 }
351
352 static void memcg_free_shrinker_maps(struct mem_cgroup *memcg)
353 {
354         struct mem_cgroup_per_node *pn;
355         struct memcg_shrinker_map *map;
356         int nid;
357
358         if (mem_cgroup_is_root(memcg))
359                 return;
360
361         for_each_node(nid) {
362                 pn = mem_cgroup_nodeinfo(memcg, nid);
363                 map = rcu_dereference_protected(pn->shrinker_map, true);
364                 if (map)
365                         kvfree(map);
366                 rcu_assign_pointer(pn->shrinker_map, NULL);
367         }
368 }
369
370 static int memcg_alloc_shrinker_maps(struct mem_cgroup *memcg)
371 {
372         struct memcg_shrinker_map *map;
373         int nid, size, ret = 0;
374
375         if (mem_cgroup_is_root(memcg))
376                 return 0;
377
378         mutex_lock(&memcg_shrinker_map_mutex);
379         size = memcg_shrinker_map_size;
380         for_each_node(nid) {
381                 map = kvzalloc(sizeof(*map) + size, GFP_KERNEL);
382                 if (!map) {
383                         memcg_free_shrinker_maps(memcg);
384                         ret = -ENOMEM;
385                         break;
386                 }
387                 rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_map, map);
388         }
389         mutex_unlock(&memcg_shrinker_map_mutex);
390
391         return ret;
392 }
393
394 int memcg_expand_shrinker_maps(int new_id)
395 {
396         int size, old_size, ret = 0;
397         struct mem_cgroup *memcg;
398
399         size = DIV_ROUND_UP(new_id + 1, BITS_PER_LONG) * sizeof(unsigned long);
400         old_size = memcg_shrinker_map_size;
401         if (size <= old_size)
402                 return 0;
403
404         mutex_lock(&memcg_shrinker_map_mutex);
405         if (!root_mem_cgroup)
406                 goto unlock;
407
408         for_each_mem_cgroup(memcg) {
409                 if (mem_cgroup_is_root(memcg))
410                         continue;
411                 ret = memcg_expand_one_shrinker_map(memcg, size, old_size);
412                 if (ret) {
413                         mem_cgroup_iter_break(NULL, memcg);
414                         goto unlock;
415                 }
416         }
417 unlock:
418         if (!ret)
419                 memcg_shrinker_map_size = size;
420         mutex_unlock(&memcg_shrinker_map_mutex);
421         return ret;
422 }
423
424 void memcg_set_shrinker_bit(struct mem_cgroup *memcg, int nid, int shrinker_id)
425 {
426         if (shrinker_id >= 0 && memcg && !mem_cgroup_is_root(memcg)) {
427                 struct memcg_shrinker_map *map;
428
429                 rcu_read_lock();
430                 map = rcu_dereference(memcg->nodeinfo[nid]->shrinker_map);
431                 /* Pairs with smp mb in shrink_slab() */
432                 smp_mb__before_atomic();
433                 set_bit(shrinker_id, map->map);
434                 rcu_read_unlock();
435         }
436 }
437
438 /**
439  * mem_cgroup_css_from_page - css of the memcg associated with a page
440  * @page: page of interest
441  *
442  * If memcg is bound to the default hierarchy, css of the memcg associated
443  * with @page is returned.  The returned css remains associated with @page
444  * until it is released.
445  *
446  * If memcg is bound to a traditional hierarchy, the css of root_mem_cgroup
447  * is returned.
448  */
449 struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
450 {
451         struct mem_cgroup *memcg;
452
453         memcg = page->mem_cgroup;
454
455         if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
456                 memcg = root_mem_cgroup;
457
458         return &memcg->css;
459 }
460
461 /**
462  * page_cgroup_ino - return inode number of the memcg a page is charged to
463  * @page: the page
464  *
465  * Look up the closest online ancestor of the memory cgroup @page is charged to
466  * and return its inode number or 0 if @page is not charged to any cgroup. It
467  * is safe to call this function without holding a reference to @page.
468  *
469  * Note, this function is inherently racy, because there is nothing to prevent
470  * the cgroup inode from getting torn down and potentially reallocated a moment
471  * after page_cgroup_ino() returns, so it only should be used by callers that
472  * do not care (such as procfs interfaces).
473  */
474 ino_t page_cgroup_ino(struct page *page)
475 {
476         struct mem_cgroup *memcg;
477         unsigned long ino = 0;
478
479         rcu_read_lock();
480         if (PageSlab(page) && !PageTail(page))
481                 memcg = memcg_from_slab_page(page);
482         else
483                 memcg = READ_ONCE(page->mem_cgroup);
484         while (memcg && !(memcg->css.flags & CSS_ONLINE))
485                 memcg = parent_mem_cgroup(memcg);
486         if (memcg)
487                 ino = cgroup_ino(memcg->css.cgroup);
488         rcu_read_unlock();
489         return ino;
490 }
491
492 static struct mem_cgroup_per_node *
493 mem_cgroup_page_nodeinfo(struct mem_cgroup *memcg, struct page *page)
494 {
495         int nid = page_to_nid(page);
496
497         return memcg->nodeinfo[nid];
498 }
499
500 static struct mem_cgroup_tree_per_node *
501 soft_limit_tree_node(int nid)
502 {
503         return soft_limit_tree.rb_tree_per_node[nid];
504 }
505
506 static struct mem_cgroup_tree_per_node *
507 soft_limit_tree_from_page(struct page *page)
508 {
509         int nid = page_to_nid(page);
510
511         return soft_limit_tree.rb_tree_per_node[nid];
512 }
513
514 static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz,
515                                          struct mem_cgroup_tree_per_node *mctz,
516                                          unsigned long new_usage_in_excess)
517 {
518         struct rb_node **p = &mctz->rb_root.rb_node;
519         struct rb_node *parent = NULL;
520         struct mem_cgroup_per_node *mz_node;
521         bool rightmost = true;
522
523         if (mz->on_tree)
524                 return;
525
526         mz->usage_in_excess = new_usage_in_excess;
527         if (!mz->usage_in_excess)
528                 return;
529         while (*p) {
530                 parent = *p;
531                 mz_node = rb_entry(parent, struct mem_cgroup_per_node,
532                                         tree_node);
533                 if (mz->usage_in_excess < mz_node->usage_in_excess) {
534                         p = &(*p)->rb_left;
535                         rightmost = false;
536                 }
537
538                 /*
539                  * We can't avoid mem cgroups that are over their soft
540                  * limit by the same amount
541                  */
542                 else if (mz->usage_in_excess >= mz_node->usage_in_excess)
543                         p = &(*p)->rb_right;
544         }
545
546         if (rightmost)
547                 mctz->rb_rightmost = &mz->tree_node;
548
549         rb_link_node(&mz->tree_node, parent, p);
550         rb_insert_color(&mz->tree_node, &mctz->rb_root);
551         mz->on_tree = true;
552 }
553
554 static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
555                                          struct mem_cgroup_tree_per_node *mctz)
556 {
557         if (!mz->on_tree)
558                 return;
559
560         if (&mz->tree_node == mctz->rb_rightmost)
561                 mctz->rb_rightmost = rb_prev(&mz->tree_node);
562
563         rb_erase(&mz->tree_node, &mctz->rb_root);
564         mz->on_tree = false;
565 }
566
567 static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
568                                        struct mem_cgroup_tree_per_node *mctz)
569 {
570         unsigned long flags;
571
572         spin_lock_irqsave(&mctz->lock, flags);
573         __mem_cgroup_remove_exceeded(mz, mctz);
574         spin_unlock_irqrestore(&mctz->lock, flags);
575 }
576
577 static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
578 {
579         unsigned long nr_pages = page_counter_read(&memcg->memory);
580         unsigned long soft_limit = READ_ONCE(memcg->soft_limit);
581         unsigned long excess = 0;
582
583         if (nr_pages > soft_limit)
584                 excess = nr_pages - soft_limit;
585
586         return excess;
587 }
588
589 static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
590 {
591         unsigned long excess;
592         struct mem_cgroup_per_node *mz;
593         struct mem_cgroup_tree_per_node *mctz;
594
595         mctz = soft_limit_tree_from_page(page);
596         if (!mctz)
597                 return;
598         /*
599          * Necessary to update all ancestors when hierarchy is used.
600          * because their event counter is not touched.
601          */
602         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
603                 mz = mem_cgroup_page_nodeinfo(memcg, page);
604                 excess = soft_limit_excess(memcg);
605                 /*
606                  * We have to update the tree if mz is on RB-tree or
607                  * mem is over its softlimit.
608                  */
609                 if (excess || mz->on_tree) {
610                         unsigned long flags;
611
612                         spin_lock_irqsave(&mctz->lock, flags);
613                         /* if on-tree, remove it */
614                         if (mz->on_tree)
615                                 __mem_cgroup_remove_exceeded(mz, mctz);
616                         /*
617                          * Insert again. mz->usage_in_excess will be updated.
618                          * If excess is 0, no tree ops.
619                          */
620                         __mem_cgroup_insert_exceeded(mz, mctz, excess);
621                         spin_unlock_irqrestore(&mctz->lock, flags);
622                 }
623         }
624 }
625
626 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
627 {
628         struct mem_cgroup_tree_per_node *mctz;
629         struct mem_cgroup_per_node *mz;
630         int nid;
631
632         for_each_node(nid) {
633                 mz = mem_cgroup_nodeinfo(memcg, nid);
634                 mctz = soft_limit_tree_node(nid);
635                 if (mctz)
636                         mem_cgroup_remove_exceeded(mz, mctz);
637         }
638 }
639
640 static struct mem_cgroup_per_node *
641 __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
642 {
643         struct mem_cgroup_per_node *mz;
644
645 retry:
646         mz = NULL;
647         if (!mctz->rb_rightmost)
648                 goto done;              /* Nothing to reclaim from */
649
650         mz = rb_entry(mctz->rb_rightmost,
651                       struct mem_cgroup_per_node, tree_node);
652         /*
653          * Remove the node now but someone else can add it back,
654          * we will to add it back at the end of reclaim to its correct
655          * position in the tree.
656          */
657         __mem_cgroup_remove_exceeded(mz, mctz);
658         if (!soft_limit_excess(mz->memcg) ||
659             !css_tryget_online(&mz->memcg->css))
660                 goto retry;
661 done:
662         return mz;
663 }
664
665 static struct mem_cgroup_per_node *
666 mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
667 {
668         struct mem_cgroup_per_node *mz;
669
670         spin_lock_irq(&mctz->lock);
671         mz = __mem_cgroup_largest_soft_limit_node(mctz);
672         spin_unlock_irq(&mctz->lock);
673         return mz;
674 }
675
676 /**
677  * __mod_memcg_state - update cgroup memory statistics
678  * @memcg: the memory cgroup
679  * @idx: the stat item - can be enum memcg_stat_item or enum node_stat_item
680  * @val: delta to add to the counter, can be negative
681  */
682 void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val)
683 {
684         long x;
685
686         if (mem_cgroup_disabled())
687                 return;
688
689         x = val + __this_cpu_read(memcg->vmstats_percpu->stat[idx]);
690         if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
691                 struct mem_cgroup *mi;
692
693                 /*
694                  * Batch local counters to keep them in sync with
695                  * the hierarchical ones.
696                  */
697                 __this_cpu_add(memcg->vmstats_local->stat[idx], x);
698                 for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
699                         atomic_long_add(x, &mi->vmstats[idx]);
700                 x = 0;
701         }
702         __this_cpu_write(memcg->vmstats_percpu->stat[idx], x);
703 }
704
705 static struct mem_cgroup_per_node *
706 parent_nodeinfo(struct mem_cgroup_per_node *pn, int nid)
707 {
708         struct mem_cgroup *parent;
709
710         parent = parent_mem_cgroup(pn->memcg);
711         if (!parent)
712                 return NULL;
713         return mem_cgroup_nodeinfo(parent, nid);
714 }
715
716 /**
717  * __mod_lruvec_state - update lruvec memory statistics
718  * @lruvec: the lruvec
719  * @idx: the stat item
720  * @val: delta to add to the counter, can be negative
721  *
722  * The lruvec is the intersection of the NUMA node and a cgroup. This
723  * function updates the all three counters that are affected by a
724  * change of state at this level: per-node, per-cgroup, per-lruvec.
725  */
726 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
727                         int val)
728 {
729         pg_data_t *pgdat = lruvec_pgdat(lruvec);
730         struct mem_cgroup_per_node *pn;
731         struct mem_cgroup *memcg;
732         long x;
733
734         /* Update node */
735         __mod_node_page_state(pgdat, idx, val);
736
737         if (mem_cgroup_disabled())
738                 return;
739
740         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
741         memcg = pn->memcg;
742
743         /* Update memcg */
744         __mod_memcg_state(memcg, idx, val);
745
746         /* Update lruvec */
747         __this_cpu_add(pn->lruvec_stat_local->count[idx], val);
748
749         x = val + __this_cpu_read(pn->lruvec_stat_cpu->count[idx]);
750         if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
751                 struct mem_cgroup_per_node *pi;
752
753                 for (pi = pn; pi; pi = parent_nodeinfo(pi, pgdat->node_id))
754                         atomic_long_add(x, &pi->lruvec_stat[idx]);
755                 x = 0;
756         }
757         __this_cpu_write(pn->lruvec_stat_cpu->count[idx], x);
758 }
759
760 void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val)
761 {
762         struct page *page = virt_to_head_page(p);
763         pg_data_t *pgdat = page_pgdat(page);
764         struct mem_cgroup *memcg;
765         struct lruvec *lruvec;
766
767         rcu_read_lock();
768         memcg = memcg_from_slab_page(page);
769
770         /* Untracked pages have no memcg, no lruvec. Update only the node */
771         if (!memcg || memcg == root_mem_cgroup) {
772                 __mod_node_page_state(pgdat, idx, val);
773         } else {
774                 lruvec = mem_cgroup_lruvec(memcg, pgdat);
775                 __mod_lruvec_state(lruvec, idx, val);
776         }
777         rcu_read_unlock();
778 }
779
780 /**
781  * __count_memcg_events - account VM events in a cgroup
782  * @memcg: the memory cgroup
783  * @idx: the event item
784  * @count: the number of events that occured
785  */
786 void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
787                           unsigned long count)
788 {
789         unsigned long x;
790
791         if (mem_cgroup_disabled())
792                 return;
793
794         x = count + __this_cpu_read(memcg->vmstats_percpu->events[idx]);
795         if (unlikely(x > MEMCG_CHARGE_BATCH)) {
796                 struct mem_cgroup *mi;
797
798                 /*
799                  * Batch local counters to keep them in sync with
800                  * the hierarchical ones.
801                  */
802                 __this_cpu_add(memcg->vmstats_local->events[idx], x);
803                 for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
804                         atomic_long_add(x, &mi->vmevents[idx]);
805                 x = 0;
806         }
807         __this_cpu_write(memcg->vmstats_percpu->events[idx], x);
808 }
809
810 static unsigned long memcg_events(struct mem_cgroup *memcg, int event)
811 {
812         return atomic_long_read(&memcg->vmevents[event]);
813 }
814
815 static unsigned long memcg_events_local(struct mem_cgroup *memcg, int event)
816 {
817         long x = 0;
818         int cpu;
819
820         for_each_possible_cpu(cpu)
821                 x += per_cpu(memcg->vmstats_local->events[event], cpu);
822         return x;
823 }
824
825 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
826                                          struct page *page,
827                                          bool compound, int nr_pages)
828 {
829         /*
830          * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
831          * counted as CACHE even if it's on ANON LRU.
832          */
833         if (PageAnon(page))
834                 __mod_memcg_state(memcg, MEMCG_RSS, nr_pages);
835         else {
836                 __mod_memcg_state(memcg, MEMCG_CACHE, nr_pages);
837                 if (PageSwapBacked(page))
838                         __mod_memcg_state(memcg, NR_SHMEM, nr_pages);
839         }
840
841         if (compound) {
842                 VM_BUG_ON_PAGE(!PageTransHuge(page), page);
843                 __mod_memcg_state(memcg, MEMCG_RSS_HUGE, nr_pages);
844         }
845
846         /* pagein of a big page is an event. So, ignore page size */
847         if (nr_pages > 0)
848                 __count_memcg_events(memcg, PGPGIN, 1);
849         else {
850                 __count_memcg_events(memcg, PGPGOUT, 1);
851                 nr_pages = -nr_pages; /* for event */
852         }
853
854         __this_cpu_add(memcg->vmstats_percpu->nr_page_events, nr_pages);
855 }
856
857 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
858                                        enum mem_cgroup_events_target target)
859 {
860         unsigned long val, next;
861
862         val = __this_cpu_read(memcg->vmstats_percpu->nr_page_events);
863         next = __this_cpu_read(memcg->vmstats_percpu->targets[target]);
864         /* from time_after() in jiffies.h */
865         if ((long)(next - val) < 0) {
866                 switch (target) {
867                 case MEM_CGROUP_TARGET_THRESH:
868                         next = val + THRESHOLDS_EVENTS_TARGET;
869                         break;
870                 case MEM_CGROUP_TARGET_SOFTLIMIT:
871                         next = val + SOFTLIMIT_EVENTS_TARGET;
872                         break;
873                 default:
874                         break;
875                 }
876                 __this_cpu_write(memcg->vmstats_percpu->targets[target], next);
877                 return true;
878         }
879         return false;
880 }
881
882 /*
883  * Check events in order.
884  *
885  */
886 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
887 {
888         /* threshold event is triggered in finer grain than soft limit */
889         if (unlikely(mem_cgroup_event_ratelimit(memcg,
890                                                 MEM_CGROUP_TARGET_THRESH))) {
891                 bool do_softlimit;
892
893                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
894                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
895                 mem_cgroup_threshold(memcg);
896                 if (unlikely(do_softlimit))
897                         mem_cgroup_update_tree(memcg, page);
898         }
899 }
900
901 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
902 {
903         /*
904          * mm_update_next_owner() may clear mm->owner to NULL
905          * if it races with swapoff, page migration, etc.
906          * So this can be called with p == NULL.
907          */
908         if (unlikely(!p))
909                 return NULL;
910
911         return mem_cgroup_from_css(task_css(p, memory_cgrp_id));
912 }
913 EXPORT_SYMBOL(mem_cgroup_from_task);
914
915 /**
916  * get_mem_cgroup_from_mm: Obtain a reference on given mm_struct's memcg.
917  * @mm: mm from which memcg should be extracted. It can be NULL.
918  *
919  * Obtain a reference on mm->memcg and returns it if successful. Otherwise
920  * root_mem_cgroup is returned. However if mem_cgroup is disabled, NULL is
921  * returned.
922  */
923 struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
924 {
925         struct mem_cgroup *memcg;
926
927         if (mem_cgroup_disabled())
928                 return NULL;
929
930         rcu_read_lock();
931         do {
932                 /*
933                  * Page cache insertions can happen withou an
934                  * actual mm context, e.g. during disk probing
935                  * on boot, loopback IO, acct() writes etc.
936                  */
937                 if (unlikely(!mm))
938                         memcg = root_mem_cgroup;
939                 else {
940                         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
941                         if (unlikely(!memcg))
942                                 memcg = root_mem_cgroup;
943                 }
944         } while (!css_tryget(&memcg->css));
945         rcu_read_unlock();
946         return memcg;
947 }
948 EXPORT_SYMBOL(get_mem_cgroup_from_mm);
949
950 /**
951  * get_mem_cgroup_from_page: Obtain a reference on given page's memcg.
952  * @page: page from which memcg should be extracted.
953  *
954  * Obtain a reference on page->memcg and returns it if successful. Otherwise
955  * root_mem_cgroup is returned.
956  */
957 struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
958 {
959         struct mem_cgroup *memcg = page->mem_cgroup;
960
961         if (mem_cgroup_disabled())
962                 return NULL;
963
964         rcu_read_lock();
965         if (!memcg || !css_tryget_online(&memcg->css))
966                 memcg = root_mem_cgroup;
967         rcu_read_unlock();
968         return memcg;
969 }
970 EXPORT_SYMBOL(get_mem_cgroup_from_page);
971
972 /**
973  * If current->active_memcg is non-NULL, do not fallback to current->mm->memcg.
974  */
975 static __always_inline struct mem_cgroup *get_mem_cgroup_from_current(void)
976 {
977         if (unlikely(current->active_memcg)) {
978                 struct mem_cgroup *memcg = root_mem_cgroup;
979
980                 rcu_read_lock();
981                 if (css_tryget_online(&current->active_memcg->css))
982                         memcg = current->active_memcg;
983                 rcu_read_unlock();
984                 return memcg;
985         }
986         return get_mem_cgroup_from_mm(current->mm);
987 }
988
989 /**
990  * mem_cgroup_iter - iterate over memory cgroup hierarchy
991  * @root: hierarchy root
992  * @prev: previously returned memcg, NULL on first invocation
993  * @reclaim: cookie for shared reclaim walks, NULL for full walks
994  *
995  * Returns references to children of the hierarchy below @root, or
996  * @root itself, or %NULL after a full round-trip.
997  *
998  * Caller must pass the return value in @prev on subsequent
999  * invocations for reference counting, or use mem_cgroup_iter_break()
1000  * to cancel a hierarchy walk before the round-trip is complete.
1001  *
1002  * Reclaimers can specify a node and a priority level in @reclaim to
1003  * divide up the memcgs in the hierarchy among all concurrent
1004  * reclaimers operating on the same node and priority.
1005  */
1006 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
1007                                    struct mem_cgroup *prev,
1008                                    struct mem_cgroup_reclaim_cookie *reclaim)
1009 {
1010         struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
1011         struct cgroup_subsys_state *css = NULL;
1012         struct mem_cgroup *memcg = NULL;
1013         struct mem_cgroup *pos = NULL;
1014
1015         if (mem_cgroup_disabled())
1016                 return NULL;
1017
1018         if (!root)
1019                 root = root_mem_cgroup;
1020
1021         if (prev && !reclaim)
1022                 pos = prev;
1023
1024         if (!root->use_hierarchy && root != root_mem_cgroup) {
1025                 if (prev)
1026                         goto out;
1027                 return root;
1028         }
1029
1030         rcu_read_lock();
1031
1032         if (reclaim) {
1033                 struct mem_cgroup_per_node *mz;
1034
1035                 mz = mem_cgroup_nodeinfo(root, reclaim->pgdat->node_id);
1036                 iter = &mz->iter;
1037
1038                 if (prev && reclaim->generation != iter->generation)
1039                         goto out_unlock;
1040
1041                 while (1) {
1042                         pos = READ_ONCE(iter->position);
1043                         if (!pos || css_tryget(&pos->css))
1044                                 break;
1045                         /*
1046                          * css reference reached zero, so iter->position will
1047                          * be cleared by ->css_released. However, we should not
1048                          * rely on this happening soon, because ->css_released
1049                          * is called from a work queue, and by busy-waiting we
1050                          * might block it. So we clear iter->position right
1051                          * away.
1052                          */
1053                         (void)cmpxchg(&iter->position, pos, NULL);
1054                 }
1055         }
1056
1057         if (pos)
1058                 css = &pos->css;
1059
1060         for (;;) {
1061                 css = css_next_descendant_pre(css, &root->css);
1062                 if (!css) {
1063                         /*
1064                          * Reclaimers share the hierarchy walk, and a
1065                          * new one might jump in right at the end of
1066                          * the hierarchy - make sure they see at least
1067                          * one group and restart from the beginning.
1068                          */
1069                         if (!prev)
1070                                 continue;
1071                         break;
1072                 }
1073
1074                 /*
1075                  * Verify the css and acquire a reference.  The root
1076                  * is provided by the caller, so we know it's alive
1077                  * and kicking, and don't take an extra reference.
1078                  */
1079                 memcg = mem_cgroup_from_css(css);
1080
1081                 if (css == &root->css)
1082                         break;
1083
1084                 if (css_tryget(css))
1085                         break;
1086
1087                 memcg = NULL;
1088         }
1089
1090         if (reclaim) {
1091                 /*
1092                  * The position could have already been updated by a competing
1093                  * thread, so check that the value hasn't changed since we read
1094                  * it to avoid reclaiming from the same cgroup twice.
1095                  */
1096                 (void)cmpxchg(&iter->position, pos, memcg);
1097
1098                 if (pos)
1099                         css_put(&pos->css);
1100
1101                 if (!memcg)
1102                         iter->generation++;
1103                 else if (!prev)
1104                         reclaim->generation = iter->generation;
1105         }
1106
1107 out_unlock:
1108         rcu_read_unlock();
1109 out:
1110         if (prev && prev != root)
1111                 css_put(&prev->css);
1112
1113         return memcg;
1114 }
1115
1116 /**
1117  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1118  * @root: hierarchy root
1119  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1120  */
1121 void mem_cgroup_iter_break(struct mem_cgroup *root,
1122                            struct mem_cgroup *prev)
1123 {
1124         if (!root)
1125                 root = root_mem_cgroup;
1126         if (prev && prev != root)
1127                 css_put(&prev->css);
1128 }
1129
1130 static void __invalidate_reclaim_iterators(struct mem_cgroup *from,
1131                                         struct mem_cgroup *dead_memcg)
1132 {
1133         struct mem_cgroup_reclaim_iter *iter;
1134         struct mem_cgroup_per_node *mz;
1135         int nid;
1136
1137         for_each_node(nid) {
1138                 mz = mem_cgroup_nodeinfo(from, nid);
1139                 iter = &mz->iter;
1140                 cmpxchg(&iter->position, dead_memcg, NULL);
1141         }
1142 }
1143
1144 static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
1145 {
1146         struct mem_cgroup *memcg = dead_memcg;
1147         struct mem_cgroup *last;
1148
1149         do {
1150                 __invalidate_reclaim_iterators(memcg, dead_memcg);
1151                 last = memcg;
1152         } while ((memcg = parent_mem_cgroup(memcg)));
1153
1154         /*
1155          * When cgruop1 non-hierarchy mode is used,
1156          * parent_mem_cgroup() does not walk all the way up to the
1157          * cgroup root (root_mem_cgroup). So we have to handle
1158          * dead_memcg from cgroup root separately.
1159          */
1160         if (last != root_mem_cgroup)
1161                 __invalidate_reclaim_iterators(root_mem_cgroup,
1162                                                 dead_memcg);
1163 }
1164
1165 /**
1166  * mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy
1167  * @memcg: hierarchy root
1168  * @fn: function to call for each task
1169  * @arg: argument passed to @fn
1170  *
1171  * This function iterates over tasks attached to @memcg or to any of its
1172  * descendants and calls @fn for each task. If @fn returns a non-zero
1173  * value, the function breaks the iteration loop and returns the value.
1174  * Otherwise, it will iterate over all tasks and return 0.
1175  *
1176  * This function must not be called for the root memory cgroup.
1177  */
1178 int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
1179                           int (*fn)(struct task_struct *, void *), void *arg)
1180 {
1181         struct mem_cgroup *iter;
1182         int ret = 0;
1183
1184         BUG_ON(memcg == root_mem_cgroup);
1185
1186         for_each_mem_cgroup_tree(iter, memcg) {
1187                 struct css_task_iter it;
1188                 struct task_struct *task;
1189
1190                 css_task_iter_start(&iter->css, CSS_TASK_ITER_PROCS, &it);
1191                 while (!ret && (task = css_task_iter_next(&it)))
1192                         ret = fn(task, arg);
1193                 css_task_iter_end(&it);
1194                 if (ret) {
1195                         mem_cgroup_iter_break(memcg, iter);
1196                         break;
1197                 }
1198         }
1199         return ret;
1200 }
1201
1202 /**
1203  * mem_cgroup_page_lruvec - return lruvec for isolating/putting an LRU page
1204  * @page: the page
1205  * @pgdat: pgdat of the page
1206  *
1207  * This function is only safe when following the LRU page isolation
1208  * and putback protocol: the LRU lock must be held, and the page must
1209  * either be PageLRU() or the caller must have isolated/allocated it.
1210  */
1211 struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct pglist_data *pgdat)
1212 {
1213         struct mem_cgroup_per_node *mz;
1214         struct mem_cgroup *memcg;
1215         struct lruvec *lruvec;
1216
1217         if (mem_cgroup_disabled()) {
1218                 lruvec = &pgdat->__lruvec;
1219                 goto out;
1220         }
1221
1222         memcg = page->mem_cgroup;
1223         /*
1224          * Swapcache readahead pages are added to the LRU - and
1225          * possibly migrated - before they are charged.
1226          */
1227         if (!memcg)
1228                 memcg = root_mem_cgroup;
1229
1230         mz = mem_cgroup_page_nodeinfo(memcg, page);
1231         lruvec = &mz->lruvec;
1232 out:
1233         /*
1234          * Since a node can be onlined after the mem_cgroup was created,
1235          * we have to be prepared to initialize lruvec->zone here;
1236          * and if offlined then reonlined, we need to reinitialize it.
1237          */
1238         if (unlikely(lruvec->pgdat != pgdat))
1239                 lruvec->pgdat = pgdat;
1240         return lruvec;
1241 }
1242
1243 /**
1244  * mem_cgroup_update_lru_size - account for adding or removing an lru page
1245  * @lruvec: mem_cgroup per zone lru vector
1246  * @lru: index of lru list the page is sitting on
1247  * @zid: zone id of the accounted pages
1248  * @nr_pages: positive when adding or negative when removing
1249  *
1250  * This function must be called under lru_lock, just before a page is added
1251  * to or just after a page is removed from an lru list (that ordering being
1252  * so as to allow it to check that lru_size 0 is consistent with list_empty).
1253  */
1254 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1255                                 int zid, int nr_pages)
1256 {
1257         struct mem_cgroup_per_node *mz;
1258         unsigned long *lru_size;
1259         long size;
1260
1261         if (mem_cgroup_disabled())
1262                 return;
1263
1264         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
1265         lru_size = &mz->lru_zone_size[zid][lru];
1266
1267         if (nr_pages < 0)
1268                 *lru_size += nr_pages;
1269
1270         size = *lru_size;
1271         if (WARN_ONCE(size < 0,
1272                 "%s(%p, %d, %d): lru_size %ld\n",
1273                 __func__, lruvec, lru, nr_pages, size)) {
1274                 VM_BUG_ON(1);
1275                 *lru_size = 0;
1276         }
1277
1278         if (nr_pages > 0)
1279                 *lru_size += nr_pages;
1280 }
1281
1282 /**
1283  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1284  * @memcg: the memory cgroup
1285  *
1286  * Returns the maximum amount of memory @mem can be charged with, in
1287  * pages.
1288  */
1289 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1290 {
1291         unsigned long margin = 0;
1292         unsigned long count;
1293         unsigned long limit;
1294
1295         count = page_counter_read(&memcg->memory);
1296         limit = READ_ONCE(memcg->memory.max);
1297         if (count < limit)
1298                 margin = limit - count;
1299
1300         if (do_memsw_account()) {
1301                 count = page_counter_read(&memcg->memsw);
1302                 limit = READ_ONCE(memcg->memsw.max);
1303                 if (count <= limit)
1304                         margin = min(margin, limit - count);
1305                 else
1306                         margin = 0;
1307         }
1308
1309         return margin;
1310 }
1311
1312 /*
1313  * A routine for checking "mem" is under move_account() or not.
1314  *
1315  * Checking a cgroup is mc.from or mc.to or under hierarchy of
1316  * moving cgroups. This is for waiting at high-memory pressure
1317  * caused by "move".
1318  */
1319 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1320 {
1321         struct mem_cgroup *from;
1322         struct mem_cgroup *to;
1323         bool ret = false;
1324         /*
1325          * Unlike task_move routines, we access mc.to, mc.from not under
1326          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1327          */
1328         spin_lock(&mc.lock);
1329         from = mc.from;
1330         to = mc.to;
1331         if (!from)
1332                 goto unlock;
1333
1334         ret = mem_cgroup_is_descendant(from, memcg) ||
1335                 mem_cgroup_is_descendant(to, memcg);
1336 unlock:
1337         spin_unlock(&mc.lock);
1338         return ret;
1339 }
1340
1341 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1342 {
1343         if (mc.moving_task && current != mc.moving_task) {
1344                 if (mem_cgroup_under_move(memcg)) {
1345                         DEFINE_WAIT(wait);
1346                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1347                         /* moving charge context might have finished. */
1348                         if (mc.moving_task)
1349                                 schedule();
1350                         finish_wait(&mc.waitq, &wait);
1351                         return true;
1352                 }
1353         }
1354         return false;
1355 }
1356
1357 static char *memory_stat_format(struct mem_cgroup *memcg)
1358 {
1359         struct seq_buf s;
1360         int i;
1361
1362         seq_buf_init(&s, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE);
1363         if (!s.buffer)
1364                 return NULL;
1365
1366         /*
1367          * Provide statistics on the state of the memory subsystem as
1368          * well as cumulative event counters that show past behavior.
1369          *
1370          * This list is ordered following a combination of these gradients:
1371          * 1) generic big picture -> specifics and details
1372          * 2) reflecting userspace activity -> reflecting kernel heuristics
1373          *
1374          * Current memory state:
1375          */
1376
1377         seq_buf_printf(&s, "anon %llu\n",
1378                        (u64)memcg_page_state(memcg, MEMCG_RSS) *
1379                        PAGE_SIZE);
1380         seq_buf_printf(&s, "file %llu\n",
1381                        (u64)memcg_page_state(memcg, MEMCG_CACHE) *
1382                        PAGE_SIZE);
1383         seq_buf_printf(&s, "kernel_stack %llu\n",
1384                        (u64)memcg_page_state(memcg, MEMCG_KERNEL_STACK_KB) *
1385                        1024);
1386         seq_buf_printf(&s, "slab %llu\n",
1387                        (u64)(memcg_page_state(memcg, NR_SLAB_RECLAIMABLE) +
1388                              memcg_page_state(memcg, NR_SLAB_UNRECLAIMABLE)) *
1389                        PAGE_SIZE);
1390         seq_buf_printf(&s, "sock %llu\n",
1391                        (u64)memcg_page_state(memcg, MEMCG_SOCK) *
1392                        PAGE_SIZE);
1393
1394         seq_buf_printf(&s, "shmem %llu\n",
1395                        (u64)memcg_page_state(memcg, NR_SHMEM) *
1396                        PAGE_SIZE);
1397         seq_buf_printf(&s, "file_mapped %llu\n",
1398                        (u64)memcg_page_state(memcg, NR_FILE_MAPPED) *
1399                        PAGE_SIZE);
1400         seq_buf_printf(&s, "file_dirty %llu\n",
1401                        (u64)memcg_page_state(memcg, NR_FILE_DIRTY) *
1402                        PAGE_SIZE);
1403         seq_buf_printf(&s, "file_writeback %llu\n",
1404                        (u64)memcg_page_state(memcg, NR_WRITEBACK) *
1405                        PAGE_SIZE);
1406
1407         /*
1408          * TODO: We should eventually replace our own MEMCG_RSS_HUGE counter
1409          * with the NR_ANON_THP vm counter, but right now it's a pain in the
1410          * arse because it requires migrating the work out of rmap to a place
1411          * where the page->mem_cgroup is set up and stable.
1412          */
1413         seq_buf_printf(&s, "anon_thp %llu\n",
1414                        (u64)memcg_page_state(memcg, MEMCG_RSS_HUGE) *
1415                        PAGE_SIZE);
1416
1417         for (i = 0; i < NR_LRU_LISTS; i++)
1418                 seq_buf_printf(&s, "%s %llu\n", lru_list_name(i),
1419                                (u64)memcg_page_state(memcg, NR_LRU_BASE + i) *
1420                                PAGE_SIZE);
1421
1422         seq_buf_printf(&s, "slab_reclaimable %llu\n",
1423                        (u64)memcg_page_state(memcg, NR_SLAB_RECLAIMABLE) *
1424                        PAGE_SIZE);
1425         seq_buf_printf(&s, "slab_unreclaimable %llu\n",
1426                        (u64)memcg_page_state(memcg, NR_SLAB_UNRECLAIMABLE) *
1427                        PAGE_SIZE);
1428
1429         /* Accumulated memory events */
1430
1431         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGFAULT),
1432                        memcg_events(memcg, PGFAULT));
1433         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGMAJFAULT),
1434                        memcg_events(memcg, PGMAJFAULT));
1435
1436         seq_buf_printf(&s, "workingset_refault %lu\n",
1437                        memcg_page_state(memcg, WORKINGSET_REFAULT));
1438         seq_buf_printf(&s, "workingset_activate %lu\n",
1439                        memcg_page_state(memcg, WORKINGSET_ACTIVATE));
1440         seq_buf_printf(&s, "workingset_nodereclaim %lu\n",
1441                        memcg_page_state(memcg, WORKINGSET_NODERECLAIM));
1442
1443         seq_buf_printf(&s, "%s %lu\n",  vm_event_name(PGREFILL),
1444                        memcg_events(memcg, PGREFILL));
1445         seq_buf_printf(&s, "pgscan %lu\n",
1446                        memcg_events(memcg, PGSCAN_KSWAPD) +
1447                        memcg_events(memcg, PGSCAN_DIRECT));
1448         seq_buf_printf(&s, "pgsteal %lu\n",
1449                        memcg_events(memcg, PGSTEAL_KSWAPD) +
1450                        memcg_events(memcg, PGSTEAL_DIRECT));
1451         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGACTIVATE),
1452                        memcg_events(memcg, PGACTIVATE));
1453         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGDEACTIVATE),
1454                        memcg_events(memcg, PGDEACTIVATE));
1455         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREE),
1456                        memcg_events(memcg, PGLAZYFREE));
1457         seq_buf_printf(&s, "%s %lu\n", vm_event_name(PGLAZYFREED),
1458                        memcg_events(memcg, PGLAZYFREED));
1459
1460 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1461         seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_FAULT_ALLOC),
1462                        memcg_events(memcg, THP_FAULT_ALLOC));
1463         seq_buf_printf(&s, "%s %lu\n", vm_event_name(THP_COLLAPSE_ALLOC),
1464                        memcg_events(memcg, THP_COLLAPSE_ALLOC));
1465 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
1466
1467         /* The above should easily fit into one page */
1468         WARN_ON_ONCE(seq_buf_has_overflowed(&s));
1469
1470         return s.buffer;
1471 }
1472
1473 #define K(x) ((x) << (PAGE_SHIFT-10))
1474 /**
1475  * mem_cgroup_print_oom_context: Print OOM information relevant to
1476  * memory controller.
1477  * @memcg: The memory cgroup that went over limit
1478  * @p: Task that is going to be killed
1479  *
1480  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1481  * enabled
1482  */
1483 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
1484 {
1485         rcu_read_lock();
1486
1487         if (memcg) {
1488                 pr_cont(",oom_memcg=");
1489                 pr_cont_cgroup_path(memcg->css.cgroup);
1490         } else
1491                 pr_cont(",global_oom");
1492         if (p) {
1493                 pr_cont(",task_memcg=");
1494                 pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
1495         }
1496         rcu_read_unlock();
1497 }
1498
1499 /**
1500  * mem_cgroup_print_oom_meminfo: Print OOM memory information relevant to
1501  * memory controller.
1502  * @memcg: The memory cgroup that went over limit
1503  */
1504 void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
1505 {
1506         char *buf;
1507
1508         pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
1509                 K((u64)page_counter_read(&memcg->memory)),
1510                 K((u64)memcg->memory.max), memcg->memory.failcnt);
1511         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
1512                 pr_info("swap: usage %llukB, limit %llukB, failcnt %lu\n",
1513                         K((u64)page_counter_read(&memcg->swap)),
1514                         K((u64)memcg->swap.max), memcg->swap.failcnt);
1515         else {
1516                 pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
1517                         K((u64)page_counter_read(&memcg->memsw)),
1518                         K((u64)memcg->memsw.max), memcg->memsw.failcnt);
1519                 pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
1520                         K((u64)page_counter_read(&memcg->kmem)),
1521                         K((u64)memcg->kmem.max), memcg->kmem.failcnt);
1522         }
1523
1524         pr_info("Memory cgroup stats for ");
1525         pr_cont_cgroup_path(memcg->css.cgroup);
1526         pr_cont(":");
1527         buf = memory_stat_format(memcg);
1528         if (!buf)
1529                 return;
1530         pr_info("%s", buf);
1531         kfree(buf);
1532 }
1533
1534 /*
1535  * Return the memory (and swap, if configured) limit for a memcg.
1536  */
1537 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg)
1538 {
1539         unsigned long max;
1540
1541         max = memcg->memory.max;
1542         if (mem_cgroup_swappiness(memcg)) {
1543                 unsigned long memsw_max;
1544                 unsigned long swap_max;
1545
1546                 memsw_max = memcg->memsw.max;
1547                 swap_max = memcg->swap.max;
1548                 swap_max = min(swap_max, (unsigned long)total_swap_pages);
1549                 max = min(max + swap_max, memsw_max);
1550         }
1551         return max;
1552 }
1553
1554 unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
1555 {
1556         return page_counter_read(&memcg->memory);
1557 }
1558
1559 static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1560                                      int order)
1561 {
1562         struct oom_control oc = {
1563                 .zonelist = NULL,
1564                 .nodemask = NULL,
1565                 .memcg = memcg,
1566                 .gfp_mask = gfp_mask,
1567                 .order = order,
1568         };
1569         bool ret;
1570
1571         if (mutex_lock_killable(&oom_lock))
1572                 return true;
1573         /*
1574          * A few threads which were not waiting at mutex_lock_killable() can
1575          * fail to bail out. Therefore, check again after holding oom_lock.
1576          */
1577         ret = should_force_charge() || out_of_memory(&oc);
1578         mutex_unlock(&oom_lock);
1579         return ret;
1580 }
1581
1582 static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1583                                    pg_data_t *pgdat,
1584                                    gfp_t gfp_mask,
1585                                    unsigned long *total_scanned)
1586 {
1587         struct mem_cgroup *victim = NULL;
1588         int total = 0;
1589         int loop = 0;
1590         unsigned long excess;
1591         unsigned long nr_scanned;
1592         struct mem_cgroup_reclaim_cookie reclaim = {
1593                 .pgdat = pgdat,
1594         };
1595
1596         excess = soft_limit_excess(root_memcg);
1597
1598         while (1) {
1599                 victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
1600                 if (!victim) {
1601                         loop++;
1602                         if (loop >= 2) {
1603                                 /*
1604                                  * If we have not been able to reclaim
1605                                  * anything, it might because there are
1606                                  * no reclaimable pages under this hierarchy
1607                                  */
1608                                 if (!total)
1609                                         break;
1610                                 /*
1611                                  * We want to do more targeted reclaim.
1612                                  * excess >> 2 is not to excessive so as to
1613                                  * reclaim too much, nor too less that we keep
1614                                  * coming back to reclaim from this cgroup
1615                                  */
1616                                 if (total >= (excess >> 2) ||
1617                                         (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
1618                                         break;
1619                         }
1620                         continue;
1621                 }
1622                 total += mem_cgroup_shrink_node(victim, gfp_mask, false,
1623                                         pgdat, &nr_scanned);
1624                 *total_scanned += nr_scanned;
1625                 if (!soft_limit_excess(root_memcg))
1626                         break;
1627         }
1628         mem_cgroup_iter_break(root_memcg, victim);
1629         return total;
1630 }
1631
1632 #ifdef CONFIG_LOCKDEP
1633 static struct lockdep_map memcg_oom_lock_dep_map = {
1634         .name = "memcg_oom_lock",
1635 };
1636 #endif
1637
1638 static DEFINE_SPINLOCK(memcg_oom_lock);
1639
1640 /*
1641  * Check OOM-Killer is already running under our hierarchy.
1642  * If someone is running, return false.
1643  */
1644 static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
1645 {
1646         struct mem_cgroup *iter, *failed = NULL;
1647
1648         spin_lock(&memcg_oom_lock);
1649
1650         for_each_mem_cgroup_tree(iter, memcg) {
1651                 if (iter->oom_lock) {
1652                         /*
1653                          * this subtree of our hierarchy is already locked
1654                          * so we cannot give a lock.
1655                          */
1656                         failed = iter;
1657                         mem_cgroup_iter_break(memcg, iter);
1658                         break;
1659                 } else
1660                         iter->oom_lock = true;
1661         }
1662
1663         if (failed) {
1664                 /*
1665                  * OK, we failed to lock the whole subtree so we have
1666                  * to clean up what we set up to the failing subtree
1667                  */
1668                 for_each_mem_cgroup_tree(iter, memcg) {
1669                         if (iter == failed) {
1670                                 mem_cgroup_iter_break(memcg, iter);
1671                                 break;
1672                         }
1673                         iter->oom_lock = false;
1674                 }
1675         } else
1676                 mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);
1677
1678         spin_unlock(&memcg_oom_lock);
1679
1680         return !failed;
1681 }
1682
1683 static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1684 {
1685         struct mem_cgroup *iter;
1686
1687         spin_lock(&memcg_oom_lock);
1688         mutex_release(&memcg_oom_lock_dep_map, _RET_IP_);
1689         for_each_mem_cgroup_tree(iter, memcg)
1690                 iter->oom_lock = false;
1691         spin_unlock(&memcg_oom_lock);
1692 }
1693
1694 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1695 {
1696         struct mem_cgroup *iter;
1697
1698         spin_lock(&memcg_oom_lock);
1699         for_each_mem_cgroup_tree(iter, memcg)
1700                 iter->under_oom++;
1701         spin_unlock(&memcg_oom_lock);
1702 }
1703
1704 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1705 {
1706         struct mem_cgroup *iter;
1707
1708         /*
1709          * When a new child is created while the hierarchy is under oom,
1710          * mem_cgroup_oom_lock() may not be called. Watch for underflow.
1711          */
1712         spin_lock(&memcg_oom_lock);
1713         for_each_mem_cgroup_tree(iter, memcg)
1714                 if (iter->under_oom > 0)
1715                         iter->under_oom--;
1716         spin_unlock(&memcg_oom_lock);
1717 }
1718
1719 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1720
1721 struct oom_wait_info {
1722         struct mem_cgroup *memcg;
1723         wait_queue_entry_t      wait;
1724 };
1725
1726 static int memcg_oom_wake_function(wait_queue_entry_t *wait,
1727         unsigned mode, int sync, void *arg)
1728 {
1729         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1730         struct mem_cgroup *oom_wait_memcg;
1731         struct oom_wait_info *oom_wait_info;
1732
1733         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1734         oom_wait_memcg = oom_wait_info->memcg;
1735
1736         if (!mem_cgroup_is_descendant(wake_memcg, oom_wait_memcg) &&
1737             !mem_cgroup_is_descendant(oom_wait_memcg, wake_memcg))
1738                 return 0;
1739         return autoremove_wake_function(wait, mode, sync, arg);
1740 }
1741
1742 static void memcg_oom_recover(struct mem_cgroup *memcg)
1743 {
1744         /*
1745          * For the following lockless ->under_oom test, the only required
1746          * guarantee is that it must see the state asserted by an OOM when
1747          * this function is called as a result of userland actions
1748          * triggered by the notification of the OOM.  This is trivially
1749          * achieved by invoking mem_cgroup_mark_under_oom() before
1750          * triggering notification.
1751          */
1752         if (memcg && memcg->under_oom)
1753                 __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
1754 }
1755
1756 enum oom_status {
1757         OOM_SUCCESS,
1758         OOM_FAILED,
1759         OOM_ASYNC,
1760         OOM_SKIPPED
1761 };
1762
1763 static enum oom_status mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
1764 {
1765         enum oom_status ret;
1766         bool locked;
1767
1768         if (order > PAGE_ALLOC_COSTLY_ORDER)
1769                 return OOM_SKIPPED;
1770
1771         memcg_memory_event(memcg, MEMCG_OOM);
1772
1773         /*
1774          * We are in the middle of the charge context here, so we
1775          * don't want to block when potentially sitting on a callstack
1776          * that holds all kinds of filesystem and mm locks.
1777          *
1778          * cgroup1 allows disabling the OOM killer and waiting for outside
1779          * handling until the charge can succeed; remember the context and put
1780          * the task to sleep at the end of the page fault when all locks are
1781          * released.
1782          *
1783          * On the other hand, in-kernel OOM killer allows for an async victim
1784          * memory reclaim (oom_reaper) and that means that we are not solely
1785          * relying on the oom victim to make a forward progress and we can
1786          * invoke the oom killer here.
1787          *
1788          * Please note that mem_cgroup_out_of_memory might fail to find a
1789          * victim and then we have to bail out from the charge path.
1790          */
1791         if (memcg->oom_kill_disable) {
1792                 if (!current->in_user_fault)
1793                         return OOM_SKIPPED;
1794                 css_get(&memcg->css);
1795                 current->memcg_in_oom = memcg;
1796                 current->memcg_oom_gfp_mask = mask;
1797                 current->memcg_oom_order = order;
1798
1799                 return OOM_ASYNC;
1800         }
1801
1802         mem_cgroup_mark_under_oom(memcg);
1803
1804         locked = mem_cgroup_oom_trylock(memcg);
1805
1806         if (locked)
1807                 mem_cgroup_oom_notify(memcg);
1808
1809         mem_cgroup_unmark_under_oom(memcg);
1810         if (mem_cgroup_out_of_memory(memcg, mask, order))
1811                 ret = OOM_SUCCESS;
1812         else
1813                 ret = OOM_FAILED;
1814
1815         if (locked)
1816                 mem_cgroup_oom_unlock(memcg);
1817
1818         return ret;
1819 }
1820
1821 /**
1822  * mem_cgroup_oom_synchronize - complete memcg OOM handling
1823  * @handle: actually kill/wait or just clean up the OOM state
1824  *
1825  * This has to be called at the end of a page fault if the memcg OOM
1826  * handler was enabled.
1827  *
1828  * Memcg supports userspace OOM handling where failed allocations must
1829  * sleep on a waitqueue until the userspace task resolves the
1830  * situation.  Sleeping directly in the charge context with all kinds
1831  * of locks held is not a good idea, instead we remember an OOM state
1832  * in the task and mem_cgroup_oom_synchronize() has to be called at
1833  * the end of the page fault to complete the OOM handling.
1834  *
1835  * Returns %true if an ongoing memcg OOM situation was detected and
1836  * completed, %false otherwise.
1837  */
1838 bool mem_cgroup_oom_synchronize(bool handle)
1839 {
1840         struct mem_cgroup *memcg = current->memcg_in_oom;
1841         struct oom_wait_info owait;
1842         bool locked;
1843
1844         /* OOM is global, do not handle */
1845         if (!memcg)
1846                 return false;
1847
1848         if (!handle)
1849                 goto cleanup;
1850
1851         owait.memcg = memcg;
1852         owait.wait.flags = 0;
1853         owait.wait.func = memcg_oom_wake_function;
1854         owait.wait.private = current;
1855         INIT_LIST_HEAD(&owait.wait.entry);
1856
1857         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
1858         mem_cgroup_mark_under_oom(memcg);
1859
1860         locked = mem_cgroup_oom_trylock(memcg);
1861
1862         if (locked)
1863                 mem_cgroup_oom_notify(memcg);
1864
1865         if (locked && !memcg->oom_kill_disable) {
1866                 mem_cgroup_unmark_under_oom(memcg);
1867                 finish_wait(&memcg_oom_waitq, &owait.wait);
1868                 mem_cgroup_out_of_memory(memcg, current->memcg_oom_gfp_mask,
1869                                          current->memcg_oom_order);
1870         } else {
1871                 schedule();
1872                 mem_cgroup_unmark_under_oom(memcg);
1873                 finish_wait(&memcg_oom_waitq, &owait.wait);
1874         }
1875
1876         if (locked) {
1877                 mem_cgroup_oom_unlock(memcg);
1878                 /*
1879                  * There is no guarantee that an OOM-lock contender
1880                  * sees the wakeups triggered by the OOM kill
1881                  * uncharges.  Wake any sleepers explicitely.
1882                  */
1883                 memcg_oom_recover(memcg);
1884         }
1885 cleanup:
1886         current->memcg_in_oom = NULL;
1887         css_put(&memcg->css);
1888         return true;
1889 }
1890
1891 /**
1892  * mem_cgroup_get_oom_group - get a memory cgroup to clean up after OOM
1893  * @victim: task to be killed by the OOM killer
1894  * @oom_domain: memcg in case of memcg OOM, NULL in case of system-wide OOM
1895  *
1896  * Returns a pointer to a memory cgroup, which has to be cleaned up
1897  * by killing all belonging OOM-killable tasks.
1898  *
1899  * Caller has to call mem_cgroup_put() on the returned non-NULL memcg.
1900  */
1901 struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
1902                                             struct mem_cgroup *oom_domain)
1903 {
1904         struct mem_cgroup *oom_group = NULL;
1905         struct mem_cgroup *memcg;
1906
1907         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
1908                 return NULL;
1909
1910         if (!oom_domain)
1911                 oom_domain = root_mem_cgroup;
1912
1913         rcu_read_lock();
1914
1915         memcg = mem_cgroup_from_task(victim);
1916         if (memcg == root_mem_cgroup)
1917                 goto out;
1918
1919         /*
1920          * Traverse the memory cgroup hierarchy from the victim task's
1921          * cgroup up to the OOMing cgroup (or root) to find the
1922          * highest-level memory cgroup with oom.group set.
1923          */
1924         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
1925                 if (memcg->oom_group)
1926                         oom_group = memcg;
1927
1928                 if (memcg == oom_domain)
1929                         break;
1930         }
1931
1932         if (oom_group)
1933                 css_get(&oom_group->css);
1934 out:
1935         rcu_read_unlock();
1936
1937         return oom_group;
1938 }
1939
1940 void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
1941 {
1942         pr_info("Tasks in ");
1943         pr_cont_cgroup_path(memcg->css.cgroup);
1944         pr_cont(" are going to be killed due to memory.oom.group set\n");
1945 }
1946
1947 /**
1948  * lock_page_memcg - lock a page->mem_cgroup binding
1949  * @page: the page
1950  *
1951  * This function protects unlocked LRU pages from being moved to
1952  * another cgroup.
1953  *
1954  * It ensures lifetime of the returned memcg. Caller is responsible
1955  * for the lifetime of the page; __unlock_page_memcg() is available
1956  * when @page might get freed inside the locked section.
1957  */
1958 struct mem_cgroup *lock_page_memcg(struct page *page)
1959 {
1960         struct mem_cgroup *memcg;
1961         unsigned long flags;
1962
1963         /*
1964          * The RCU lock is held throughout the transaction.  The fast
1965          * path can get away without acquiring the memcg->move_lock
1966          * because page moving starts with an RCU grace period.
1967          *
1968          * The RCU lock also protects the memcg from being freed when
1969          * the page state that is going to change is the only thing
1970          * preventing the page itself from being freed. E.g. writeback
1971          * doesn't hold a page reference and relies on PG_writeback to
1972          * keep off truncation, migration and so forth.
1973          */
1974         rcu_read_lock();
1975
1976         if (mem_cgroup_disabled())
1977                 return NULL;
1978 again:
1979         memcg = page->mem_cgroup;
1980         if (unlikely(!memcg))
1981                 return NULL;
1982
1983         if (atomic_read(&memcg->moving_account) <= 0)
1984                 return memcg;
1985
1986         spin_lock_irqsave(&memcg->move_lock, flags);
1987         if (memcg != page->mem_cgroup) {
1988                 spin_unlock_irqrestore(&memcg->move_lock, flags);
1989                 goto again;
1990         }
1991
1992         /*
1993          * When charge migration first begins, we can have locked and
1994          * unlocked page stat updates happening concurrently.  Track
1995          * the task who has the lock for unlock_page_memcg().
1996          */
1997         memcg->move_lock_task = current;
1998         memcg->move_lock_flags = flags;
1999
2000         return memcg;
2001 }
2002 EXPORT_SYMBOL(lock_page_memcg);
2003
2004 /**
2005  * __unlock_page_memcg - unlock and unpin a memcg
2006  * @memcg: the memcg
2007  *
2008  * Unlock and unpin a memcg returned by lock_page_memcg().
2009  */
2010 void __unlock_page_memcg(struct mem_cgroup *memcg)
2011 {
2012         if (memcg && memcg->move_lock_task == current) {
2013                 unsigned long flags = memcg->move_lock_flags;
2014
2015                 memcg->move_lock_task = NULL;
2016                 memcg->move_lock_flags = 0;
2017
2018                 spin_unlock_irqrestore(&memcg->move_lock, flags);
2019         }
2020
2021         rcu_read_unlock();
2022 }
2023
2024 /**
2025  * unlock_page_memcg - unlock a page->mem_cgroup binding
2026  * @page: the page
2027  */
2028 void unlock_page_memcg(struct page *page)
2029 {
2030         __unlock_page_memcg(page->mem_cgroup);
2031 }
2032 EXPORT_SYMBOL(unlock_page_memcg);
2033
2034 struct memcg_stock_pcp {
2035         struct mem_cgroup *cached; /* this never be root cgroup */
2036         unsigned int nr_pages;
2037         struct work_struct work;
2038         unsigned long flags;
2039 #define FLUSHING_CACHED_CHARGE  0
2040 };
2041 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
2042 static DEFINE_MUTEX(percpu_charge_mutex);
2043
2044 /**
2045  * consume_stock: Try to consume stocked charge on this cpu.
2046  * @memcg: memcg to consume from.
2047  * @nr_pages: how many pages to charge.
2048  *
2049  * The charges will only happen if @memcg matches the current cpu's memcg
2050  * stock, and at least @nr_pages are available in that stock.  Failure to
2051  * service an allocation will refill the stock.
2052  *
2053  * returns true if successful, false otherwise.
2054  */
2055 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2056 {
2057         struct memcg_stock_pcp *stock;
2058         unsigned long flags;
2059         bool ret = false;
2060
2061         if (nr_pages > MEMCG_CHARGE_BATCH)
2062                 return ret;
2063
2064         local_irq_save(flags);
2065
2066         stock = this_cpu_ptr(&memcg_stock);
2067         if (memcg == stock->cached && stock->nr_pages >= nr_pages) {
2068                 stock->nr_pages -= nr_pages;
2069                 ret = true;
2070         }
2071
2072         local_irq_restore(flags);
2073
2074         return ret;
2075 }
2076
2077 /*
2078  * Returns stocks cached in percpu and reset cached information.
2079  */
2080 static void drain_stock(struct memcg_stock_pcp *stock)
2081 {
2082         struct mem_cgroup *old = stock->cached;
2083
2084         if (stock->nr_pages) {
2085                 page_counter_uncharge(&old->memory, stock->nr_pages);
2086                 if (do_memsw_account())
2087                         page_counter_uncharge(&old->memsw, stock->nr_pages);
2088                 css_put_many(&old->css, stock->nr_pages);
2089                 stock->nr_pages = 0;
2090         }
2091         stock->cached = NULL;
2092 }
2093
2094 static void drain_local_stock(struct work_struct *dummy)
2095 {
2096         struct memcg_stock_pcp *stock;
2097         unsigned long flags;
2098
2099         /*
2100          * The only protection from memory hotplug vs. drain_stock races is
2101          * that we always operate on local CPU stock here with IRQ disabled
2102          */
2103         local_irq_save(flags);
2104
2105         stock = this_cpu_ptr(&memcg_stock);
2106         drain_stock(stock);
2107         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2108
2109         local_irq_restore(flags);
2110 }
2111
2112 /*
2113  * Cache charges(val) to local per_cpu area.
2114  * This will be consumed by consume_stock() function, later.
2115  */
2116 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2117 {
2118         struct memcg_stock_pcp *stock;
2119         unsigned long flags;
2120
2121         local_irq_save(flags);
2122
2123         stock = this_cpu_ptr(&memcg_stock);
2124         if (stock->cached != memcg) { /* reset if necessary */
2125                 drain_stock(stock);
2126                 stock->cached = memcg;
2127         }
2128         stock->nr_pages += nr_pages;
2129
2130         if (stock->nr_pages > MEMCG_CHARGE_BATCH)
2131                 drain_stock(stock);
2132
2133         local_irq_restore(flags);
2134 }
2135
2136 /*
2137  * Drains all per-CPU charge caches for given root_memcg resp. subtree
2138  * of the hierarchy under it.
2139  */
2140 static void drain_all_stock(struct mem_cgroup *root_memcg)
2141 {
2142         int cpu, curcpu;
2143
2144         /* If someone's already draining, avoid adding running more workers. */
2145         if (!mutex_trylock(&percpu_charge_mutex))
2146                 return;
2147         /*
2148          * Notify other cpus that system-wide "drain" is running
2149          * We do not care about races with the cpu hotplug because cpu down
2150          * as well as workers from this path always operate on the local
2151          * per-cpu data. CPU up doesn't touch memcg_stock at all.
2152          */
2153         curcpu = get_cpu();
2154         for_each_online_cpu(cpu) {
2155                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2156                 struct mem_cgroup *memcg;
2157                 bool flush = false;
2158
2159                 rcu_read_lock();
2160                 memcg = stock->cached;
2161                 if (memcg && stock->nr_pages &&
2162                     mem_cgroup_is_descendant(memcg, root_memcg))
2163                         flush = true;
2164                 rcu_read_unlock();
2165
2166                 if (flush &&
2167                     !test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2168                         if (cpu == curcpu)
2169                                 drain_local_stock(&stock->work);
2170                         else
2171                                 schedule_work_on(cpu, &stock->work);
2172                 }
2173         }
2174         put_cpu();
2175         mutex_unlock(&percpu_charge_mutex);
2176 }
2177
2178 static int memcg_hotplug_cpu_dead(unsigned int cpu)
2179 {
2180         struct memcg_stock_pcp *stock;
2181         struct mem_cgroup *memcg, *mi;
2182
2183         stock = &per_cpu(memcg_stock, cpu);
2184         drain_stock(stock);
2185
2186         for_each_mem_cgroup(memcg) {
2187                 int i;
2188
2189                 for (i = 0; i < MEMCG_NR_STAT; i++) {
2190                         int nid;
2191                         long x;
2192
2193                         x = this_cpu_xchg(memcg->vmstats_percpu->stat[i], 0);
2194                         if (x)
2195                                 for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
2196                                         atomic_long_add(x, &memcg->vmstats[i]);
2197
2198                         if (i >= NR_VM_NODE_STAT_ITEMS)
2199                                 continue;
2200
2201                         for_each_node(nid) {
2202                                 struct mem_cgroup_per_node *pn;
2203
2204                                 pn = mem_cgroup_nodeinfo(memcg, nid);
2205                                 x = this_cpu_xchg(pn->lruvec_stat_cpu->count[i], 0);
2206                                 if (x)
2207                                         do {
2208                                                 atomic_long_add(x, &pn->lruvec_stat[i]);
2209                                         } while ((pn = parent_nodeinfo(pn, nid)));
2210                         }
2211                 }
2212
2213                 for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
2214                         long x;
2215
2216                         x = this_cpu_xchg(memcg->vmstats_percpu->events[i], 0);
2217                         if (x)
2218                                 for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
2219                                         atomic_long_add(x, &memcg->vmevents[i]);
2220                 }
2221         }
2222
2223         return 0;
2224 }
2225
2226 static void reclaim_high(struct mem_cgroup *memcg,
2227                          unsigned int nr_pages,
2228                          gfp_t gfp_mask)
2229 {
2230         do {
2231                 if (page_counter_read(&memcg->memory) <= memcg->high)
2232                         continue;
2233                 memcg_memory_event(memcg, MEMCG_HIGH);
2234                 try_to_free_mem_cgroup_pages(memcg, nr_pages, gfp_mask, true);
2235         } while ((memcg = parent_mem_cgroup(memcg)));
2236 }
2237
2238 static void high_work_func(struct work_struct *work)
2239 {
2240         struct mem_cgroup *memcg;
2241
2242         memcg = container_of(work, struct mem_cgroup, high_work);
2243         reclaim_high(memcg, MEMCG_CHARGE_BATCH, GFP_KERNEL);
2244 }
2245
2246 /*
2247  * Clamp the maximum sleep time per allocation batch to 2 seconds. This is
2248  * enough to still cause a significant slowdown in most cases, while still
2249  * allowing diagnostics and tracing to proceed without becoming stuck.
2250  */
2251 #define MEMCG_MAX_HIGH_DELAY_JIFFIES (2UL*HZ)
2252
2253 /*
2254  * When calculating the delay, we use these either side of the exponentiation to
2255  * maintain precision and scale to a reasonable number of jiffies (see the table
2256  * below.
2257  *
2258  * - MEMCG_DELAY_PRECISION_SHIFT: Extra precision bits while translating the
2259  *   overage ratio to a delay.
2260  * - MEMCG_DELAY_SCALING_SHIFT: The number of bits to scale down down the
2261  *   proposed penalty in order to reduce to a reasonable number of jiffies, and
2262  *   to produce a reasonable delay curve.
2263  *
2264  * MEMCG_DELAY_SCALING_SHIFT just happens to be a number that produces a
2265  * reasonable delay curve compared to precision-adjusted overage, not
2266  * penalising heavily at first, but still making sure that growth beyond the
2267  * limit penalises misbehaviour cgroups by slowing them down exponentially. For
2268  * example, with a high of 100 megabytes:
2269  *
2270  *  +-------+------------------------+
2271  *  | usage | time to allocate in ms |
2272  *  +-------+------------------------+
2273  *  | 100M  |                      0 |
2274  *  | 101M  |                      6 |
2275  *  | 102M  |                     25 |
2276  *  | 103M  |                     57 |
2277  *  | 104M  |                    102 |
2278  *  | 105M  |                    159 |
2279  *  | 106M  |                    230 |
2280  *  | 107M  |                    313 |
2281  *  | 108M  |                    409 |
2282  *  | 109M  |                    518 |
2283  *  | 110M  |                    639 |
2284  *  | 111M  |                    774 |
2285  *  | 112M  |                    921 |
2286  *  | 113M  |                   1081 |
2287  *  | 114M  |                   1254 |
2288  *  | 115M  |                   1439 |
2289  *  | 116M  |                   1638 |
2290  *  | 117M  |                   1849 |
2291  *  | 118M  |                   2000 |
2292  *  | 119M  |                   2000 |
2293  *  | 120M  |                   2000 |
2294  *  +-------+------------------------+
2295  */
2296  #define MEMCG_DELAY_PRECISION_SHIFT 20
2297  #define MEMCG_DELAY_SCALING_SHIFT 14
2298
2299 /*
2300  * Scheduled by try_charge() to be executed from the userland return path
2301  * and reclaims memory over the high limit.
2302  */
2303 void mem_cgroup_handle_over_high(void)
2304 {
2305         unsigned long usage, high, clamped_high;
2306         unsigned long pflags;
2307         unsigned long penalty_jiffies, overage;
2308         unsigned int nr_pages = current->memcg_nr_pages_over_high;
2309         struct mem_cgroup *memcg;
2310
2311         if (likely(!nr_pages))
2312                 return;
2313
2314         memcg = get_mem_cgroup_from_mm(current->mm);
2315         reclaim_high(memcg, nr_pages, GFP_KERNEL);
2316         current->memcg_nr_pages_over_high = 0;
2317
2318         /*
2319          * memory.high is breached and reclaim is unable to keep up. Throttle
2320          * allocators proactively to slow down excessive growth.
2321          *
2322          * We use overage compared to memory.high to calculate the number of
2323          * jiffies to sleep (penalty_jiffies). Ideally this value should be
2324          * fairly lenient on small overages, and increasingly harsh when the
2325          * memcg in question makes it clear that it has no intention of stopping
2326          * its crazy behaviour, so we exponentially increase the delay based on
2327          * overage amount.
2328          */
2329
2330         usage = page_counter_read(&memcg->memory);
2331         high = READ_ONCE(memcg->high);
2332
2333         if (usage <= high)
2334                 goto out;
2335
2336         /*
2337          * Prevent division by 0 in overage calculation by acting as if it was a
2338          * threshold of 1 page
2339          */
2340         clamped_high = max(high, 1UL);
2341
2342         overage = div_u64((u64)(usage - high) << MEMCG_DELAY_PRECISION_SHIFT,
2343                           clamped_high);
2344
2345         penalty_jiffies = ((u64)overage * overage * HZ)
2346                 >> (MEMCG_DELAY_PRECISION_SHIFT + MEMCG_DELAY_SCALING_SHIFT);
2347
2348         /*
2349          * Factor in the task's own contribution to the overage, such that four
2350          * N-sized allocations are throttled approximately the same as one
2351          * 4N-sized allocation.
2352          *
2353          * MEMCG_CHARGE_BATCH pages is nominal, so work out how much smaller or
2354          * larger the current charge patch is than that.
2355          */
2356         penalty_jiffies = penalty_jiffies * nr_pages / MEMCG_CHARGE_BATCH;
2357
2358         /*
2359          * Clamp the max delay per usermode return so as to still keep the
2360          * application moving forwards and also permit diagnostics, albeit
2361          * extremely slowly.
2362          */
2363         penalty_jiffies = min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);
2364
2365         /*
2366          * Don't sleep if the amount of jiffies this memcg owes us is so low
2367          * that it's not even worth doing, in an attempt to be nice to those who
2368          * go only a small amount over their memory.high value and maybe haven't
2369          * been aggressively reclaimed enough yet.
2370          */
2371         if (penalty_jiffies <= HZ / 100)
2372                 goto out;
2373
2374         /*
2375          * If we exit early, we're guaranteed to die (since
2376          * schedule_timeout_killable sets TASK_KILLABLE). This means we don't
2377          * need to account for any ill-begotten jiffies to pay them off later.
2378          */
2379         psi_memstall_enter(&pflags);
2380         schedule_timeout_killable(penalty_jiffies);
2381         psi_memstall_leave(&pflags);
2382
2383 out:
2384         css_put(&memcg->css);
2385 }
2386
2387 static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2388                       unsigned int nr_pages)
2389 {
2390         unsigned int batch = max(MEMCG_CHARGE_BATCH, nr_pages);
2391         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
2392         struct mem_cgroup *mem_over_limit;
2393         struct page_counter *counter;
2394         unsigned long nr_reclaimed;
2395         bool may_swap = true;
2396         bool drained = false;
2397         enum oom_status oom_status;
2398
2399         if (mem_cgroup_is_root(memcg))
2400                 return 0;
2401 retry:
2402         if (consume_stock(memcg, nr_pages))
2403                 return 0;
2404
2405         if (!do_memsw_account() ||
2406             page_counter_try_charge(&memcg->memsw, batch, &counter)) {
2407                 if (page_counter_try_charge(&memcg->memory, batch, &counter))
2408                         goto done_restock;
2409                 if (do_memsw_account())
2410                         page_counter_uncharge(&memcg->memsw, batch);
2411                 mem_over_limit = mem_cgroup_from_counter(counter, memory);
2412         } else {
2413                 mem_over_limit = mem_cgroup_from_counter(counter, memsw);
2414                 may_swap = false;
2415         }
2416
2417         if (batch > nr_pages) {
2418                 batch = nr_pages;
2419                 goto retry;
2420         }
2421
2422         /*
2423          * Memcg doesn't have a dedicated reserve for atomic
2424          * allocations. But like the global atomic pool, we need to
2425          * put the burden of reclaim on regular allocation requests
2426          * and let these go through as privileged allocations.
2427          */
2428         if (gfp_mask & __GFP_ATOMIC)
2429                 goto force;
2430
2431         /*
2432          * Unlike in global OOM situations, memcg is not in a physical
2433          * memory shortage.  Allow dying and OOM-killed tasks to
2434          * bypass the last charges so that they can exit quickly and
2435          * free their memory.
2436          */
2437         if (unlikely(should_force_charge()))
2438                 goto force;
2439
2440         /*
2441          * Prevent unbounded recursion when reclaim operations need to
2442          * allocate memory. This might exceed the limits temporarily,
2443          * but we prefer facilitating memory reclaim and getting back
2444          * under the limit over triggering OOM kills in these cases.
2445          */
2446         if (unlikely(current->flags & PF_MEMALLOC))
2447                 goto force;
2448
2449         if (unlikely(task_in_memcg_oom(current)))
2450                 goto nomem;
2451
2452         if (!gfpflags_allow_blocking(gfp_mask))
2453                 goto nomem;
2454
2455         memcg_memory_event(mem_over_limit, MEMCG_MAX);
2456
2457         nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
2458                                                     gfp_mask, may_swap);
2459
2460         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2461                 goto retry;
2462
2463         if (!drained) {
2464                 drain_all_stock(mem_over_limit);
2465                 drained = true;
2466                 goto retry;
2467         }
2468
2469         if (gfp_mask & __GFP_NORETRY)
2470                 goto nomem;
2471         /*
2472          * Even though the limit is exceeded at this point, reclaim
2473          * may have been able to free some pages.  Retry the charge
2474          * before killing the task.
2475          *
2476          * Only for regular pages, though: huge pages are rather
2477          * unlikely to succeed so close to the limit, and we fall back
2478          * to regular pages anyway in case of failure.
2479          */
2480         if (nr_reclaimed && nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER))
2481                 goto retry;
2482         /*
2483          * At task move, charge accounts can be doubly counted. So, it's
2484          * better to wait until the end of task_move if something is going on.
2485          */
2486         if (mem_cgroup_wait_acct_move(mem_over_limit))
2487                 goto retry;
2488
2489         if (nr_retries--)
2490                 goto retry;
2491
2492         if (gfp_mask & __GFP_RETRY_MAYFAIL)
2493                 goto nomem;
2494
2495         if (gfp_mask & __GFP_NOFAIL)
2496                 goto force;
2497
2498         if (fatal_signal_pending(current))
2499                 goto force;
2500
2501         /*
2502          * keep retrying as long as the memcg oom killer is able to make
2503          * a forward progress or bypass the charge if the oom killer
2504          * couldn't make any progress.
2505          */
2506         oom_status = mem_cgroup_oom(mem_over_limit, gfp_mask,
2507                        get_order(nr_pages * PAGE_SIZE));
2508         switch (oom_status) {
2509         case OOM_SUCCESS:
2510                 nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
2511                 goto retry;
2512         case OOM_FAILED:
2513                 goto force;
2514         default:
2515                 goto nomem;
2516         }
2517 nomem:
2518         if (!(gfp_mask & __GFP_NOFAIL))
2519                 return -ENOMEM;
2520 force:
2521         /*
2522          * The allocation either can't fail or will lead to more memory
2523          * being freed very soon.  Allow memory usage go over the limit
2524          * temporarily by force charging it.
2525          */
2526         page_counter_charge(&memcg->memory, nr_pages);
2527         if (do_memsw_account())
2528                 page_counter_charge(&memcg->memsw, nr_pages);
2529         css_get_many(&memcg->css, nr_pages);
2530
2531         return 0;
2532
2533 done_restock:
2534         css_get_many(&memcg->css, batch);
2535         if (batch > nr_pages)
2536                 refill_stock(memcg, batch - nr_pages);
2537
2538         /*
2539          * If the hierarchy is above the normal consumption range, schedule
2540          * reclaim on returning to userland.  We can perform reclaim here
2541          * if __GFP_RECLAIM but let's always punt for simplicity and so that
2542          * GFP_KERNEL can consistently be used during reclaim.  @memcg is
2543          * not recorded as it most likely matches current's and won't
2544          * change in the meantime.  As high limit is checked again before
2545          * reclaim, the cost of mismatch is negligible.
2546          */
2547         do {
2548                 if (page_counter_read(&memcg->memory) > memcg->high) {
2549                         /* Don't bother a random interrupted task */
2550                         if (in_interrupt()) {
2551                                 schedule_work(&memcg->high_work);
2552                                 break;
2553                         }
2554                         current->memcg_nr_pages_over_high += batch;
2555                         set_notify_resume(current);
2556                         break;
2557                 }
2558         } while ((memcg = parent_mem_cgroup(memcg)));
2559
2560         return 0;
2561 }
2562
2563 static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
2564 {
2565         if (mem_cgroup_is_root(memcg))
2566                 return;
2567
2568         page_counter_uncharge(&memcg->memory, nr_pages);
2569         if (do_memsw_account())
2570                 page_counter_uncharge(&memcg->memsw, nr_pages);
2571
2572         css_put_many(&memcg->css, nr_pages);
2573 }
2574
2575 static void lock_page_lru(struct page *page, int *isolated)
2576 {
2577         pg_data_t *pgdat = page_pgdat(page);
2578
2579         spin_lock_irq(&pgdat->lru_lock);
2580         if (PageLRU(page)) {
2581                 struct lruvec *lruvec;
2582
2583                 lruvec = mem_cgroup_page_lruvec(page, pgdat);
2584                 ClearPageLRU(page);
2585                 del_page_from_lru_list(page, lruvec, page_lru(page));
2586                 *isolated = 1;
2587         } else
2588                 *isolated = 0;
2589 }
2590
2591 static void unlock_page_lru(struct page *page, int isolated)
2592 {
2593         pg_data_t *pgdat = page_pgdat(page);
2594
2595         if (isolated) {
2596                 struct lruvec *lruvec;
2597
2598                 lruvec = mem_cgroup_page_lruvec(page, pgdat);
2599                 VM_BUG_ON_PAGE(PageLRU(page), page);
2600                 SetPageLRU(page);
2601                 add_page_to_lru_list(page, lruvec, page_lru(page));
2602         }
2603         spin_unlock_irq(&pgdat->lru_lock);
2604 }
2605
2606 static void commit_charge(struct page *page, struct mem_cgroup *memcg,
2607                           bool lrucare)
2608 {
2609         int isolated;
2610
2611         VM_BUG_ON_PAGE(page->mem_cgroup, page);
2612
2613         /*
2614          * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2615          * may already be on some other mem_cgroup's LRU.  Take care of it.
2616          */
2617         if (lrucare)
2618                 lock_page_lru(page, &isolated);
2619
2620         /*
2621          * Nobody should be changing or seriously looking at
2622          * page->mem_cgroup at this point:
2623          *
2624          * - the page is uncharged
2625          *
2626          * - the page is off-LRU
2627          *
2628          * - an anonymous fault has exclusive page access, except for
2629          *   a locked page table
2630          *
2631          * - a page cache insertion, a swapin fault, or a migration
2632          *   have the page locked
2633          */
2634         page->mem_cgroup = memcg;
2635
2636         if (lrucare)
2637                 unlock_page_lru(page, isolated);
2638 }
2639
2640 #ifdef CONFIG_MEMCG_KMEM
2641 static int memcg_alloc_cache_id(void)
2642 {
2643         int id, size;
2644         int err;
2645
2646         id = ida_simple_get(&memcg_cache_ida,
2647                             0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
2648         if (id < 0)
2649                 return id;
2650
2651         if (id < memcg_nr_cache_ids)
2652                 return id;
2653
2654         /*
2655          * There's no space for the new id in memcg_caches arrays,
2656          * so we have to grow them.
2657          */
2658         down_write(&memcg_cache_ids_sem);
2659
2660         size = 2 * (id + 1);
2661         if (size < MEMCG_CACHES_MIN_SIZE)
2662                 size = MEMCG_CACHES_MIN_SIZE;
2663         else if (size > MEMCG_CACHES_MAX_SIZE)
2664                 size = MEMCG_CACHES_MAX_SIZE;
2665
2666         err = memcg_update_all_caches(size);
2667         if (!err)
2668                 err = memcg_update_all_list_lrus(size);
2669         if (!err)
2670                 memcg_nr_cache_ids = size;
2671
2672         up_write(&memcg_cache_ids_sem);
2673
2674         if (err) {
2675                 ida_simple_remove(&memcg_cache_ida, id);
2676                 return err;
2677         }
2678         return id;
2679 }
2680
2681 static void memcg_free_cache_id(int id)
2682 {
2683         ida_simple_remove(&memcg_cache_ida, id);
2684 }
2685
2686 struct memcg_kmem_cache_create_work {
2687         struct mem_cgroup *memcg;
2688         struct kmem_cache *cachep;
2689         struct work_struct work;
2690 };
2691
2692 static void memcg_kmem_cache_create_func(struct work_struct *w)
2693 {
2694         struct memcg_kmem_cache_create_work *cw =
2695                 container_of(w, struct memcg_kmem_cache_create_work, work);
2696         struct mem_cgroup *memcg = cw->memcg;
2697         struct kmem_cache *cachep = cw->cachep;
2698
2699         memcg_create_kmem_cache(memcg, cachep);
2700
2701         css_put(&memcg->css);
2702         kfree(cw);
2703 }
2704
2705 /*
2706  * Enqueue the creation of a per-memcg kmem_cache.
2707  */
2708 static void memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
2709                                                struct kmem_cache *cachep)
2710 {
2711         struct memcg_kmem_cache_create_work *cw;
2712
2713         if (!css_tryget_online(&memcg->css))
2714                 return;
2715
2716         cw = kmalloc(sizeof(*cw), GFP_NOWAIT | __GFP_NOWARN);
2717         if (!cw)
2718                 return;
2719
2720         cw->memcg = memcg;
2721         cw->cachep = cachep;
2722         INIT_WORK(&cw->work, memcg_kmem_cache_create_func);
2723
2724         queue_work(memcg_kmem_cache_wq, &cw->work);
2725 }
2726
2727 static inline bool memcg_kmem_bypass(void)
2728 {
2729         if (in_interrupt() || !current->mm || (current->flags & PF_KTHREAD))
2730                 return true;
2731         return false;
2732 }
2733
2734 /**
2735  * memcg_kmem_get_cache: select the correct per-memcg cache for allocation
2736  * @cachep: the original global kmem cache
2737  *
2738  * Return the kmem_cache we're supposed to use for a slab allocation.
2739  * We try to use the current memcg's version of the cache.
2740  *
2741  * If the cache does not exist yet, if we are the first user of it, we
2742  * create it asynchronously in a workqueue and let the current allocation
2743  * go through with the original cache.
2744  *
2745  * This function takes a reference to the cache it returns to assure it
2746  * won't get destroyed while we are working with it. Once the caller is
2747  * done with it, memcg_kmem_put_cache() must be called to release the
2748  * reference.
2749  */
2750 struct kmem_cache *memcg_kmem_get_cache(struct kmem_cache *cachep)
2751 {
2752         struct mem_cgroup *memcg;
2753         struct kmem_cache *memcg_cachep;
2754         struct memcg_cache_array *arr;
2755         int kmemcg_id;
2756
2757         VM_BUG_ON(!is_root_cache(cachep));
2758
2759         if (memcg_kmem_bypass())
2760                 return cachep;
2761
2762         rcu_read_lock();
2763
2764         if (unlikely(current->active_memcg))
2765                 memcg = current->active_memcg;
2766         else
2767                 memcg = mem_cgroup_from_task(current);
2768
2769         if (!memcg || memcg == root_mem_cgroup)
2770                 goto out_unlock;
2771
2772         kmemcg_id = READ_ONCE(memcg->kmemcg_id);
2773         if (kmemcg_id < 0)
2774                 goto out_unlock;
2775
2776         arr = rcu_dereference(cachep->memcg_params.memcg_caches);
2777
2778         /*
2779          * Make sure we will access the up-to-date value. The code updating
2780          * memcg_caches issues a write barrier to match the data dependency
2781          * barrier inside READ_ONCE() (see memcg_create_kmem_cache()).
2782          */
2783         memcg_cachep = READ_ONCE(arr->entries[kmemcg_id]);
2784
2785         /*
2786          * If we are in a safe context (can wait, and not in interrupt
2787          * context), we could be be predictable and return right away.
2788          * This would guarantee that the allocation being performed
2789          * already belongs in the new cache.
2790          *
2791          * However, there are some clashes that can arrive from locking.
2792          * For instance, because we acquire the slab_mutex while doing
2793          * memcg_create_kmem_cache, this means no further allocation
2794          * could happen with the slab_mutex held. So it's better to
2795          * defer everything.
2796          *
2797          * If the memcg is dying or memcg_cache is about to be released,
2798          * don't bother creating new kmem_caches. Because memcg_cachep
2799          * is ZEROed as the fist step of kmem offlining, we don't need
2800          * percpu_ref_tryget_live() here. css_tryget_online() check in
2801          * memcg_schedule_kmem_cache_create() will prevent us from
2802          * creation of a new kmem_cache.
2803          */
2804         if (unlikely(!memcg_cachep))
2805                 memcg_schedule_kmem_cache_create(memcg, cachep);
2806         else if (percpu_ref_tryget(&memcg_cachep->memcg_params.refcnt))
2807                 cachep = memcg_cachep;
2808 out_unlock:
2809         rcu_read_unlock();
2810         return cachep;
2811 }
2812
2813 /**
2814  * memcg_kmem_put_cache: drop reference taken by memcg_kmem_get_cache
2815  * @cachep: the cache returned by memcg_kmem_get_cache
2816  */
2817 void memcg_kmem_put_cache(struct kmem_cache *cachep)
2818 {
2819         if (!is_root_cache(cachep))
2820                 percpu_ref_put(&cachep->memcg_params.refcnt);
2821 }
2822
2823 /**
2824  * __memcg_kmem_charge_memcg: charge a kmem page
2825  * @page: page to charge
2826  * @gfp: reclaim mode
2827  * @order: allocation order
2828  * @memcg: memory cgroup to charge
2829  *
2830  * Returns 0 on success, an error code on failure.
2831  */
2832 int __memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
2833                             struct mem_cgroup *memcg)
2834 {
2835         unsigned int nr_pages = 1 << order;
2836         struct page_counter *counter;
2837         int ret;
2838
2839         ret = try_charge(memcg, gfp, nr_pages);
2840         if (ret)
2841                 return ret;
2842
2843         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) &&
2844             !page_counter_try_charge(&memcg->kmem, nr_pages, &counter)) {
2845
2846                 /*
2847                  * Enforce __GFP_NOFAIL allocation because callers are not
2848                  * prepared to see failures and likely do not have any failure
2849                  * handling code.
2850                  */
2851                 if (gfp & __GFP_NOFAIL) {
2852                         page_counter_charge(&memcg->kmem, nr_pages);
2853                         return 0;
2854                 }
2855                 cancel_charge(memcg, nr_pages);
2856                 return -ENOMEM;
2857         }
2858         return 0;
2859 }
2860
2861 /**
2862  * __memcg_kmem_charge: charge a kmem page to the current memory cgroup
2863  * @page: page to charge
2864  * @gfp: reclaim mode
2865  * @order: allocation order
2866  *
2867  * Returns 0 on success, an error code on failure.
2868  */
2869 int __memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
2870 {
2871         struct mem_cgroup *memcg;
2872         int ret = 0;
2873
2874         if (memcg_kmem_bypass())
2875                 return 0;
2876
2877         memcg = get_mem_cgroup_from_current();
2878         if (!mem_cgroup_is_root(memcg)) {
2879                 ret = __memcg_kmem_charge_memcg(page, gfp, order, memcg);
2880                 if (!ret) {
2881                         page->mem_cgroup = memcg;
2882                         __SetPageKmemcg(page);
2883                 }
2884         }
2885         css_put(&memcg->css);
2886         return ret;
2887 }
2888
2889 /**
2890  * __memcg_kmem_uncharge_memcg: uncharge a kmem page
2891  * @memcg: memcg to uncharge
2892  * @nr_pages: number of pages to uncharge
2893  */
2894 void __memcg_kmem_uncharge_memcg(struct mem_cgroup *memcg,
2895                                  unsigned int nr_pages)
2896 {
2897         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
2898                 page_counter_uncharge(&memcg->kmem, nr_pages);
2899
2900         page_counter_uncharge(&memcg->memory, nr_pages);
2901         if (do_memsw_account())
2902                 page_counter_uncharge(&memcg->memsw, nr_pages);
2903 }
2904 /**
2905  * __memcg_kmem_uncharge: uncharge a kmem page
2906  * @page: page to uncharge
2907  * @order: allocation order
2908  */
2909 void __memcg_kmem_uncharge(struct page *page, int order)
2910 {
2911         struct mem_cgroup *memcg = page->mem_cgroup;
2912         unsigned int nr_pages = 1 << order;
2913
2914         if (!memcg)
2915                 return;
2916
2917         VM_BUG_ON_PAGE(mem_cgroup_is_root(memcg), page);
2918         __memcg_kmem_uncharge_memcg(memcg, nr_pages);
2919         page->mem_cgroup = NULL;
2920
2921         /* slab pages do not have PageKmemcg flag set */
2922         if (PageKmemcg(page))
2923                 __ClearPageKmemcg(page);
2924
2925         css_put_many(&memcg->css, nr_pages);
2926 }
2927 #endif /* CONFIG_MEMCG_KMEM */
2928
2929 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
2930
2931 /*
2932  * Because tail pages are not marked as "used", set it. We're under
2933  * pgdat->lru_lock and migration entries setup in all page mappings.
2934  */
2935 void mem_cgroup_split_huge_fixup(struct page *head)
2936 {
2937         int i;
2938
2939         if (mem_cgroup_disabled())
2940                 return;
2941
2942         for (i = 1; i < HPAGE_PMD_NR; i++)
2943                 head[i].mem_cgroup = head->mem_cgroup;
2944
2945         __mod_memcg_state(head->mem_cgroup, MEMCG_RSS_HUGE, -HPAGE_PMD_NR);
2946 }
2947 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
2948
2949 #ifdef CONFIG_MEMCG_SWAP
2950 /**
2951  * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
2952  * @entry: swap entry to be moved
2953  * @from:  mem_cgroup which the entry is moved from
2954  * @to:  mem_cgroup which the entry is moved to
2955  *
2956  * It succeeds only when the swap_cgroup's record for this entry is the same
2957  * as the mem_cgroup's id of @from.
2958  *
2959  * Returns 0 on success, -EINVAL on failure.
2960  *
2961  * The caller must have charged to @to, IOW, called page_counter_charge() about
2962  * both res and memsw, and called css_get().
2963  */
2964 static int mem_cgroup_move_swap_account(swp_entry_t entry,
2965                                 struct mem_cgroup *from, struct mem_cgroup *to)
2966 {
2967         unsigned short old_id, new_id;
2968
2969         old_id = mem_cgroup_id(from);
2970         new_id = mem_cgroup_id(to);
2971
2972         if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
2973                 mod_memcg_state(from, MEMCG_SWAP, -1);
2974                 mod_memcg_state(to, MEMCG_SWAP, 1);
2975                 return 0;
2976         }
2977         return -EINVAL;
2978 }
2979 #else
2980 static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
2981                                 struct mem_cgroup *from, struct mem_cgroup *to)
2982 {
2983         return -EINVAL;
2984 }
2985 #endif
2986
2987 static DEFINE_MUTEX(memcg_max_mutex);
2988
2989 static int mem_cgroup_resize_max(struct mem_cgroup *memcg,
2990                                  unsigned long max, bool memsw)
2991 {
2992         bool enlarge = false;
2993         bool drained = false;
2994         int ret;
2995         bool limits_invariant;
2996         struct page_counter *counter = memsw ? &memcg->memsw : &memcg->memory;
2997
2998         do {
2999                 if (signal_pending(current)) {
3000                         ret = -EINTR;
3001                         break;
3002                 }
3003
3004                 mutex_lock(&memcg_max_mutex);
3005                 /*
3006                  * Make sure that the new limit (memsw or memory limit) doesn't
3007                  * break our basic invariant rule memory.max <= memsw.max.
3008                  */
3009                 limits_invariant = memsw ? max >= memcg->memory.max :
3010                                            max <= memcg->memsw.max;
3011                 if (!limits_invariant) {
3012                         mutex_unlock(&memcg_max_mutex);
3013                         ret = -EINVAL;
3014                         break;
3015                 }
3016                 if (max > counter->max)
3017                         enlarge = true;
3018                 ret = page_counter_set_max(counter, max);
3019                 mutex_unlock(&memcg_max_mutex);
3020
3021                 if (!ret)
3022                         break;
3023
3024                 if (!drained) {
3025                         drain_all_stock(memcg);
3026                         drained = true;
3027                         continue;
3028                 }
3029
3030                 if (!try_to_free_mem_cgroup_pages(memcg, 1,
3031                                         GFP_KERNEL, !memsw)) {
3032                         ret = -EBUSY;
3033                         break;
3034                 }
3035         } while (true);
3036
3037         if (!ret && enlarge)
3038                 memcg_oom_recover(memcg);
3039
3040         return ret;
3041 }
3042
3043 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
3044                                             gfp_t gfp_mask,
3045                                             unsigned long *total_scanned)
3046 {
3047         unsigned long nr_reclaimed = 0;
3048         struct mem_cgroup_per_node *mz, *next_mz = NULL;
3049         unsigned long reclaimed;
3050         int loop = 0;
3051         struct mem_cgroup_tree_per_node *mctz;
3052         unsigned long excess;
3053         unsigned long nr_scanned;
3054
3055         if (order > 0)
3056                 return 0;
3057
3058         mctz = soft_limit_tree_node(pgdat->node_id);
3059
3060         /*
3061          * Do not even bother to check the largest node if the root
3062          * is empty. Do it lockless to prevent lock bouncing. Races
3063          * are acceptable as soft limit is best effort anyway.
3064          */
3065         if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root))
3066                 return 0;
3067
3068         /*
3069          * This loop can run a while, specially if mem_cgroup's continuously
3070          * keep exceeding their soft limit and putting the system under
3071          * pressure
3072          */
3073         do {
3074                 if (next_mz)
3075                         mz = next_mz;
3076                 else
3077                         mz = mem_cgroup_largest_soft_limit_node(mctz);
3078                 if (!mz)
3079                         break;
3080
3081                 nr_scanned = 0;
3082                 reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat,
3083                                                     gfp_mask, &nr_scanned);
3084                 nr_reclaimed += reclaimed;
3085                 *total_scanned += nr_scanned;
3086                 spin_lock_irq(&mctz->lock);
3087                 __mem_cgroup_remove_exceeded(mz, mctz);
3088
3089                 /*
3090                  * If we failed to reclaim anything from this memory cgroup
3091                  * it is time to move on to the next cgroup
3092                  */
3093                 next_mz = NULL;
3094                 if (!reclaimed)
3095                         next_mz = __mem_cgroup_largest_soft_limit_node(mctz);
3096
3097                 excess = soft_limit_excess(mz->memcg);
3098                 /*
3099                  * One school of thought says that we should not add
3100                  * back the node to the tree if reclaim returns 0.
3101                  * But our reclaim could return 0, simply because due
3102                  * to priority we are exposing a smaller subset of
3103                  * memory to reclaim from. Consider this as a longer
3104                  * term TODO.
3105                  */
3106                 /* If excess == 0, no tree ops */
3107                 __mem_cgroup_insert_exceeded(mz, mctz, excess);
3108                 spin_unlock_irq(&mctz->lock);
3109                 css_put(&mz->memcg->css);
3110                 loop++;
3111                 /*
3112                  * Could not reclaim anything and there are no more
3113                  * mem cgroups to try or we seem to be looping without
3114                  * reclaiming anything.
3115                  */
3116                 if (!nr_reclaimed &&
3117                         (next_mz == NULL ||
3118                         loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
3119                         break;
3120         } while (!nr_reclaimed);
3121         if (next_mz)
3122                 css_put(&next_mz->memcg->css);
3123         return nr_reclaimed;
3124 }
3125
3126 /*
3127  * Test whether @memcg has children, dead or alive.  Note that this
3128  * function doesn't care whether @memcg has use_hierarchy enabled and
3129  * returns %true if there are child csses according to the cgroup
3130  * hierarchy.  Testing use_hierarchy is the caller's responsiblity.
3131  */
3132 static inline bool memcg_has_children(struct mem_cgroup *memcg)
3133 {
3134         bool ret;
3135
3136         rcu_read_lock();
3137         ret = css_next_child(NULL, &memcg->css);
3138         rcu_read_unlock();
3139         return ret;
3140 }
3141
3142 /*
3143  * Reclaims as many pages from the given memcg as possible.
3144  *
3145  * Caller is responsible for holding css reference for memcg.
3146  */
3147 static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
3148 {
3149         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
3150
3151         /* we call try-to-free pages for make this cgroup empty */
3152         lru_add_drain_all();
3153
3154         drain_all_stock(memcg);
3155
3156         /* try to free all pages in this cgroup */
3157         while (nr_retries && page_counter_read(&memcg->memory)) {
3158                 int progress;
3159
3160                 if (signal_pending(current))
3161                         return -EINTR;
3162
3163                 progress = try_to_free_mem_cgroup_pages(memcg, 1,
3164                                                         GFP_KERNEL, true);
3165                 if (!progress) {
3166                         nr_retries--;
3167                         /* maybe some writeback is necessary */
3168                         congestion_wait(BLK_RW_ASYNC, HZ/10);
3169                 }
3170
3171         }
3172
3173         return 0;
3174 }
3175
3176 static ssize_t mem_cgroup_force_empty_write(struct kernfs_open_file *of,
3177                                             char *buf, size_t nbytes,
3178                                             loff_t off)
3179 {
3180         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3181
3182         if (mem_cgroup_is_root(memcg))
3183                 return -EINVAL;
3184         return mem_cgroup_force_empty(memcg) ?: nbytes;
3185 }
3186
3187 static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
3188                                      struct cftype *cft)
3189 {
3190         return mem_cgroup_from_css(css)->use_hierarchy;
3191 }
3192
3193 static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
3194                                       struct cftype *cft, u64 val)
3195 {
3196         int retval = 0;
3197         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3198         struct mem_cgroup *parent_memcg = mem_cgroup_from_css(memcg->css.parent);
3199
3200         if (memcg->use_hierarchy == val)
3201                 return 0;
3202
3203         /*
3204          * If parent's use_hierarchy is set, we can't make any modifications
3205          * in the child subtrees. If it is unset, then the change can
3206          * occur, provided the current cgroup has no children.
3207          *
3208          * For the root cgroup, parent_mem is NULL, we allow value to be
3209          * set if there are no children.
3210          */
3211         if ((!parent_memcg || !parent_memcg->use_hierarchy) &&
3212                                 (val == 1 || val == 0)) {
3213                 if (!memcg_has_children(memcg))
3214                         memcg->use_hierarchy = val;
3215                 else
3216                         retval = -EBUSY;
3217         } else
3218                 retval = -EINVAL;
3219
3220         return retval;
3221 }
3222
3223 static unsigned long mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
3224 {
3225         unsigned long val;
3226
3227         if (mem_cgroup_is_root(memcg)) {
3228                 val = memcg_page_state(memcg, MEMCG_CACHE) +
3229                         memcg_page_state(memcg, MEMCG_RSS);
3230                 if (swap)
3231                         val += memcg_page_state(memcg, MEMCG_SWAP);
3232         } else {
3233                 if (!swap)
3234                         val = page_counter_read(&memcg->memory);
3235                 else
3236                         val = page_counter_read(&memcg->memsw);
3237         }
3238         return val;
3239 }
3240
3241 enum {
3242         RES_USAGE,
3243         RES_LIMIT,
3244         RES_MAX_USAGE,
3245         RES_FAILCNT,
3246         RES_SOFT_LIMIT,
3247 };
3248
3249 static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
3250                                struct cftype *cft)
3251 {
3252         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3253         struct page_counter *counter;
3254
3255         switch (MEMFILE_TYPE(cft->private)) {
3256         case _MEM:
3257                 counter = &memcg->memory;
3258                 break;
3259         case _MEMSWAP:
3260                 counter = &memcg->memsw;
3261                 break;
3262         case _KMEM:
3263                 counter = &memcg->kmem;
3264                 break;
3265         case _TCP:
3266                 counter = &memcg->tcpmem;
3267                 break;
3268         default:
3269                 BUG();
3270         }
3271
3272         switch (MEMFILE_ATTR(cft->private)) {
3273         case RES_USAGE:
3274                 if (counter == &memcg->memory)
3275                         return (u64)mem_cgroup_usage(memcg, false) * PAGE_SIZE;
3276                 if (counter == &memcg->memsw)
3277                         return (u64)mem_cgroup_usage(memcg, true) * PAGE_SIZE;
3278                 return (u64)page_counter_read(counter) * PAGE_SIZE;
3279         case RES_LIMIT:
3280                 return (u64)counter->max * PAGE_SIZE;
3281         case RES_MAX_USAGE:
3282                 return (u64)counter->watermark * PAGE_SIZE;
3283         case RES_FAILCNT:
3284                 return counter->failcnt;
3285         case RES_SOFT_LIMIT:
3286                 return (u64)memcg->soft_limit * PAGE_SIZE;
3287         default:
3288                 BUG();
3289         }
3290 }
3291
3292 static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg)
3293 {
3294         unsigned long stat[MEMCG_NR_STAT] = {0};
3295         struct mem_cgroup *mi;
3296         int node, cpu, i;
3297
3298         for_each_online_cpu(cpu)
3299                 for (i = 0; i < MEMCG_NR_STAT; i++)
3300                         stat[i] += per_cpu(memcg->vmstats_percpu->stat[i], cpu);
3301
3302         for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
3303                 for (i = 0; i < MEMCG_NR_STAT; i++)
3304                         atomic_long_add(stat[i], &mi->vmstats[i]);
3305
3306         for_each_node(node) {
3307                 struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
3308                 struct mem_cgroup_per_node *pi;
3309
3310                 for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3311                         stat[i] = 0;
3312
3313                 for_each_online_cpu(cpu)
3314                         for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3315                                 stat[i] += per_cpu(
3316                                         pn->lruvec_stat_cpu->count[i], cpu);
3317
3318                 for (pi = pn; pi; pi = parent_nodeinfo(pi, node))
3319                         for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3320                                 atomic_long_add(stat[i], &pi->lruvec_stat[i]);
3321         }
3322 }
3323
3324 static void memcg_flush_percpu_vmevents(struct mem_cgroup *memcg)
3325 {
3326         unsigned long events[NR_VM_EVENT_ITEMS];
3327         struct mem_cgroup *mi;
3328         int cpu, i;
3329
3330         for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3331                 events[i] = 0;
3332
3333         for_each_online_cpu(cpu)
3334                 for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3335                         events[i] += per_cpu(memcg->vmstats_percpu->events[i],
3336                                              cpu);
3337
3338         for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
3339                 for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3340                         atomic_long_add(events[i], &mi->vmevents[i]);
3341 }
3342
3343 #ifdef CONFIG_MEMCG_KMEM
3344 static int memcg_online_kmem(struct mem_cgroup *memcg)
3345 {
3346         int memcg_id;
3347
3348         if (cgroup_memory_nokmem)
3349                 return 0;
3350
3351         BUG_ON(memcg->kmemcg_id >= 0);
3352         BUG_ON(memcg->kmem_state);
3353
3354         memcg_id = memcg_alloc_cache_id();
3355         if (memcg_id < 0)
3356                 return memcg_id;
3357
3358         static_branch_inc(&memcg_kmem_enabled_key);
3359         /*
3360          * A memory cgroup is considered kmem-online as soon as it gets
3361          * kmemcg_id. Setting the id after enabling static branching will
3362          * guarantee no one starts accounting before all call sites are
3363          * patched.
3364          */
3365         memcg->kmemcg_id = memcg_id;
3366         memcg->kmem_state = KMEM_ONLINE;
3367         INIT_LIST_HEAD(&memcg->kmem_caches);
3368
3369         return 0;
3370 }
3371
3372 static void memcg_offline_kmem(struct mem_cgroup *memcg)
3373 {
3374         struct cgroup_subsys_state *css;
3375         struct mem_cgroup *parent, *child;
3376         int kmemcg_id;
3377
3378         if (memcg->kmem_state != KMEM_ONLINE)
3379                 return;
3380         /*
3381          * Clear the online state before clearing memcg_caches array
3382          * entries. The slab_mutex in memcg_deactivate_kmem_caches()
3383          * guarantees that no cache will be created for this cgroup
3384          * after we are done (see memcg_create_kmem_cache()).
3385          */
3386         memcg->kmem_state = KMEM_ALLOCATED;
3387
3388         parent = parent_mem_cgroup(memcg);
3389         if (!parent)
3390                 parent = root_mem_cgroup;
3391
3392         /*
3393          * Deactivate and reparent kmem_caches.
3394          */
3395         memcg_deactivate_kmem_caches(memcg, parent);
3396
3397         kmemcg_id = memcg->kmemcg_id;
3398         BUG_ON(kmemcg_id < 0);
3399
3400         /*
3401          * Change kmemcg_id of this cgroup and all its descendants to the
3402          * parent's id, and then move all entries from this cgroup's list_lrus
3403          * to ones of the parent. After we have finished, all list_lrus
3404          * corresponding to this cgroup are guaranteed to remain empty. The
3405          * ordering is imposed by list_lru_node->lock taken by
3406          * memcg_drain_all_list_lrus().
3407          */
3408         rcu_read_lock(); /* can be called from css_free w/o cgroup_mutex */
3409         css_for_each_descendant_pre(css, &memcg->css) {
3410                 child = mem_cgroup_from_css(css);
3411                 BUG_ON(child->kmemcg_id != kmemcg_id);
3412                 child->kmemcg_id = parent->kmemcg_id;
3413                 if (!memcg->use_hierarchy)
3414                         break;
3415         }
3416         rcu_read_unlock();
3417
3418         memcg_drain_all_list_lrus(kmemcg_id, parent);
3419
3420         memcg_free_cache_id(kmemcg_id);
3421 }
3422
3423 static void memcg_free_kmem(struct mem_cgroup *memcg)
3424 {
3425         /* css_alloc() failed, offlining didn't happen */
3426         if (unlikely(memcg->kmem_state == KMEM_ONLINE))
3427                 memcg_offline_kmem(memcg);
3428
3429         if (memcg->kmem_state == KMEM_ALLOCATED) {
3430                 WARN_ON(!list_empty(&memcg->kmem_caches));
3431                 static_branch_dec(&memcg_kmem_enabled_key);
3432         }
3433 }
3434 #else
3435 static int memcg_online_kmem(struct mem_cgroup *memcg)
3436 {
3437         return 0;
3438 }
3439 static void memcg_offline_kmem(struct mem_cgroup *memcg)
3440 {
3441 }
3442 static void memcg_free_kmem(struct mem_cgroup *memcg)
3443 {
3444 }
3445 #endif /* CONFIG_MEMCG_KMEM */
3446
3447 static int memcg_update_kmem_max(struct mem_cgroup *memcg,
3448                                  unsigned long max)
3449 {
3450         int ret;
3451
3452         mutex_lock(&memcg_max_mutex);
3453         ret = page_counter_set_max(&memcg->kmem, max);
3454         mutex_unlock(&memcg_max_mutex);
3455         return ret;
3456 }
3457
3458 static int memcg_update_tcp_max(struct mem_cgroup *memcg, unsigned long max)
3459 {
3460         int ret;
3461
3462         mutex_lock(&memcg_max_mutex);
3463
3464         ret = page_counter_set_max(&memcg->tcpmem, max);
3465         if (ret)
3466                 goto out;
3467
3468         if (!memcg->tcpmem_active) {
3469                 /*
3470                  * The active flag needs to be written after the static_key
3471                  * update. This is what guarantees that the socket activation
3472                  * function is the last one to run. See mem_cgroup_sk_alloc()
3473                  * for details, and note that we don't mark any socket as
3474                  * belonging to this memcg until that flag is up.
3475                  *
3476                  * We need to do this, because static_keys will span multiple
3477                  * sites, but we can't control their order. If we mark a socket
3478                  * as accounted, but the accounting functions are not patched in
3479                  * yet, we'll lose accounting.
3480                  *
3481                  * We never race with the readers in mem_cgroup_sk_alloc(),
3482                  * because when this value change, the code to process it is not
3483                  * patched in yet.
3484                  */
3485                 static_branch_inc(&memcg_sockets_enabled_key);
3486                 memcg->tcpmem_active = true;
3487         }
3488 out:
3489         mutex_unlock(&memcg_max_mutex);
3490         return ret;
3491 }
3492
3493 /*
3494  * The user of this function is...
3495  * RES_LIMIT.
3496  */
3497 static ssize_t mem_cgroup_write(struct kernfs_open_file *of,
3498                                 char *buf, size_t nbytes, loff_t off)
3499 {
3500         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3501         unsigned long nr_pages;
3502         int ret;
3503
3504         buf = strstrip(buf);
3505         ret = page_counter_memparse(buf, "-1", &nr_pages);
3506         if (ret)
3507                 return ret;
3508
3509         switch (MEMFILE_ATTR(of_cft(of)->private)) {
3510         case RES_LIMIT:
3511                 if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
3512                         ret = -EINVAL;
3513                         break;
3514                 }
3515                 switch (MEMFILE_TYPE(of_cft(of)->private)) {
3516                 case _MEM:
3517                         ret = mem_cgroup_resize_max(memcg, nr_pages, false);
3518                         break;
3519                 case _MEMSWAP:
3520                         ret = mem_cgroup_resize_max(memcg, nr_pages, true);
3521                         break;
3522                 case _KMEM:
3523                         pr_warn_once("kmem.limit_in_bytes is deprecated and will be removed. "
3524                                      "Please report your usecase to linux-mm@kvack.org if you "
3525                                      "depend on this functionality.\n");
3526                         ret = memcg_update_kmem_max(memcg, nr_pages);
3527                         break;
3528                 case _TCP:
3529                         ret = memcg_update_tcp_max(memcg, nr_pages);
3530                         break;
3531                 }
3532                 break;
3533         case RES_SOFT_LIMIT:
3534                 memcg->soft_limit = nr_pages;
3535                 ret = 0;
3536                 break;
3537         }
3538         return ret ?: nbytes;
3539 }
3540
3541 static ssize_t mem_cgroup_reset(struct kernfs_open_file *of, char *buf,
3542                                 size_t nbytes, loff_t off)
3543 {
3544         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3545         struct page_counter *counter;
3546
3547         switch (MEMFILE_TYPE(of_cft(of)->private)) {
3548         case _MEM:
3549                 counter = &memcg->memory;
3550                 break;
3551         case _MEMSWAP:
3552                 counter = &memcg->memsw;
3553                 break;
3554         case _KMEM:
3555                 counter = &memcg->kmem;
3556                 break;
3557         case _TCP:
3558                 counter = &memcg->tcpmem;
3559                 break;
3560         default:
3561                 BUG();
3562         }
3563
3564         switch (MEMFILE_ATTR(of_cft(of)->private)) {
3565         case RES_MAX_USAGE:
3566                 page_counter_reset_watermark(counter);
3567                 break;
3568         case RES_FAILCNT:
3569                 counter->failcnt = 0;
3570                 break;
3571         default:
3572                 BUG();
3573         }
3574
3575         return nbytes;
3576 }
3577
3578 static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
3579                                         struct cftype *cft)
3580 {
3581         return mem_cgroup_from_css(css)->move_charge_at_immigrate;
3582 }
3583
3584 #ifdef CONFIG_MMU
3585 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3586                                         struct cftype *cft, u64 val)