126a939b600a12f0b77ab4933896a08b502f01d3
[sfrench/cifs-2.6.git] / mm / memcontrol.c
1 /* memcontrol.c - Memory Controller
2  *
3  * Copyright IBM Corporation, 2007
4  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
5  *
6  * Copyright 2007 OpenVZ SWsoft Inc
7  * Author: Pavel Emelianov <xemul@openvz.org>
8  *
9  * Memory thresholds
10  * Copyright (C) 2009 Nokia Corporation
11  * Author: Kirill A. Shutemov
12  *
13  * Kernel Memory Controller
14  * Copyright (C) 2012 Parallels Inc. and Google Inc.
15  * Authors: Glauber Costa and Suleiman Souhlal
16  *
17  * Native page reclaim
18  * Charge lifetime sanitation
19  * Lockless page tracking & accounting
20  * Unified hierarchy configuration model
21  * Copyright (C) 2015 Red Hat, Inc., Johannes Weiner
22  *
23  * This program is free software; you can redistribute it and/or modify
24  * it under the terms of the GNU General Public License as published by
25  * the Free Software Foundation; either version 2 of the License, or
26  * (at your option) any later version.
27  *
28  * This program is distributed in the hope that it will be useful,
29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31  * GNU General Public License for more details.
32  */
33
34 #include <linux/page_counter.h>
35 #include <linux/memcontrol.h>
36 #include <linux/cgroup.h>
37 #include <linux/mm.h>
38 #include <linux/sched/mm.h>
39 #include <linux/shmem_fs.h>
40 #include <linux/hugetlb.h>
41 #include <linux/pagemap.h>
42 #include <linux/smp.h>
43 #include <linux/page-flags.h>
44 #include <linux/backing-dev.h>
45 #include <linux/bit_spinlock.h>
46 #include <linux/rcupdate.h>
47 #include <linux/limits.h>
48 #include <linux/export.h>
49 #include <linux/mutex.h>
50 #include <linux/rbtree.h>
51 #include <linux/slab.h>
52 #include <linux/swap.h>
53 #include <linux/swapops.h>
54 #include <linux/spinlock.h>
55 #include <linux/eventfd.h>
56 #include <linux/poll.h>
57 #include <linux/sort.h>
58 #include <linux/fs.h>
59 #include <linux/seq_file.h>
60 #include <linux/vmpressure.h>
61 #include <linux/mm_inline.h>
62 #include <linux/swap_cgroup.h>
63 #include <linux/cpu.h>
64 #include <linux/oom.h>
65 #include <linux/lockdep.h>
66 #include <linux/file.h>
67 #include <linux/tracehook.h>
68 #include "internal.h"
69 #include <net/sock.h>
70 #include <net/ip.h>
71 #include "slab.h"
72
73 #include <linux/uaccess.h>
74
75 #include <trace/events/vmscan.h>
76
77 struct cgroup_subsys memory_cgrp_subsys __read_mostly;
78 EXPORT_SYMBOL(memory_cgrp_subsys);
79
80 struct mem_cgroup *root_mem_cgroup __read_mostly;
81
82 #define MEM_CGROUP_RECLAIM_RETRIES      5
83
84 /* Socket memory accounting disabled? */
85 static bool cgroup_memory_nosocket;
86
87 /* Kernel memory accounting disabled? */
88 static bool cgroup_memory_nokmem;
89
90 /* Whether the swap controller is active */
91 #ifdef CONFIG_MEMCG_SWAP
92 int do_swap_account __read_mostly;
93 #else
94 #define do_swap_account         0
95 #endif
96
97 /* Whether legacy memory+swap accounting is active */
98 static bool do_memsw_account(void)
99 {
100         return !cgroup_subsys_on_dfl(memory_cgrp_subsys) && do_swap_account;
101 }
102
103 static const char *const mem_cgroup_lru_names[] = {
104         "inactive_anon",
105         "active_anon",
106         "inactive_file",
107         "active_file",
108         "unevictable",
109 };
110
111 #define THRESHOLDS_EVENTS_TARGET 128
112 #define SOFTLIMIT_EVENTS_TARGET 1024
113 #define NUMAINFO_EVENTS_TARGET  1024
114
115 /*
116  * Cgroups above their limits are maintained in a RB-Tree, independent of
117  * their hierarchy representation
118  */
119
120 struct mem_cgroup_tree_per_node {
121         struct rb_root rb_root;
122         spinlock_t lock;
123 };
124
125 struct mem_cgroup_tree {
126         struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
127 };
128
129 static struct mem_cgroup_tree soft_limit_tree __read_mostly;
130
131 /* for OOM */
132 struct mem_cgroup_eventfd_list {
133         struct list_head list;
134         struct eventfd_ctx *eventfd;
135 };
136
137 /*
138  * cgroup_event represents events which userspace want to receive.
139  */
140 struct mem_cgroup_event {
141         /*
142          * memcg which the event belongs to.
143          */
144         struct mem_cgroup *memcg;
145         /*
146          * eventfd to signal userspace about the event.
147          */
148         struct eventfd_ctx *eventfd;
149         /*
150          * Each of these stored in a list by the cgroup.
151          */
152         struct list_head list;
153         /*
154          * register_event() callback will be used to add new userspace
155          * waiter for changes related to this event.  Use eventfd_signal()
156          * on eventfd to send notification to userspace.
157          */
158         int (*register_event)(struct mem_cgroup *memcg,
159                               struct eventfd_ctx *eventfd, const char *args);
160         /*
161          * unregister_event() callback will be called when userspace closes
162          * the eventfd or on cgroup removing.  This callback must be set,
163          * if you want provide notification functionality.
164          */
165         void (*unregister_event)(struct mem_cgroup *memcg,
166                                  struct eventfd_ctx *eventfd);
167         /*
168          * All fields below needed to unregister event when
169          * userspace closes eventfd.
170          */
171         poll_table pt;
172         wait_queue_head_t *wqh;
173         wait_queue_entry_t wait;
174         struct work_struct remove;
175 };
176
177 static void mem_cgroup_threshold(struct mem_cgroup *memcg);
178 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
179
180 /* Stuffs for move charges at task migration. */
181 /*
182  * Types of charges to be moved.
183  */
184 #define MOVE_ANON       0x1U
185 #define MOVE_FILE       0x2U
186 #define MOVE_MASK       (MOVE_ANON | MOVE_FILE)
187
188 /* "mc" and its members are protected by cgroup_mutex */
189 static struct move_charge_struct {
190         spinlock_t        lock; /* for from, to */
191         struct mm_struct  *mm;
192         struct mem_cgroup *from;
193         struct mem_cgroup *to;
194         unsigned long flags;
195         unsigned long precharge;
196         unsigned long moved_charge;
197         unsigned long moved_swap;
198         struct task_struct *moving_task;        /* a task moving charges */
199         wait_queue_head_t waitq;                /* a waitq for other context */
200 } mc = {
201         .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
202         .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
203 };
204
205 /*
206  * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
207  * limit reclaim to prevent infinite loops, if they ever occur.
208  */
209 #define MEM_CGROUP_MAX_RECLAIM_LOOPS            100
210 #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
211
212 enum charge_type {
213         MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
214         MEM_CGROUP_CHARGE_TYPE_ANON,
215         MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
216         MEM_CGROUP_CHARGE_TYPE_DROP,    /* a page was unused swap cache */
217         NR_CHARGE_TYPE,
218 };
219
220 /* for encoding cft->private value on file */
221 enum res_type {
222         _MEM,
223         _MEMSWAP,
224         _OOM_TYPE,
225         _KMEM,
226         _TCP,
227 };
228
229 #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
230 #define MEMFILE_TYPE(val)       ((val) >> 16 & 0xffff)
231 #define MEMFILE_ATTR(val)       ((val) & 0xffff)
232 /* Used for OOM nofiier */
233 #define OOM_CONTROL             (0)
234
235 /* Some nice accessors for the vmpressure. */
236 struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
237 {
238         if (!memcg)
239                 memcg = root_mem_cgroup;
240         return &memcg->vmpressure;
241 }
242
243 struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
244 {
245         return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
246 }
247
248 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
249 {
250         return (memcg == root_mem_cgroup);
251 }
252
253 #ifndef CONFIG_SLOB
254 /*
255  * This will be the memcg's index in each cache's ->memcg_params.memcg_caches.
256  * The main reason for not using cgroup id for this:
257  *  this works better in sparse environments, where we have a lot of memcgs,
258  *  but only a few kmem-limited. Or also, if we have, for instance, 200
259  *  memcgs, and none but the 200th is kmem-limited, we'd have to have a
260  *  200 entry array for that.
261  *
262  * The current size of the caches array is stored in memcg_nr_cache_ids. It
263  * will double each time we have to increase it.
264  */
265 static DEFINE_IDA(memcg_cache_ida);
266 int memcg_nr_cache_ids;
267
268 /* Protects memcg_nr_cache_ids */
269 static DECLARE_RWSEM(memcg_cache_ids_sem);
270
271 void memcg_get_cache_ids(void)
272 {
273         down_read(&memcg_cache_ids_sem);
274 }
275
276 void memcg_put_cache_ids(void)
277 {
278         up_read(&memcg_cache_ids_sem);
279 }
280
281 /*
282  * MIN_SIZE is different than 1, because we would like to avoid going through
283  * the alloc/free process all the time. In a small machine, 4 kmem-limited
284  * cgroups is a reasonable guess. In the future, it could be a parameter or
285  * tunable, but that is strictly not necessary.
286  *
287  * MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get
288  * this constant directly from cgroup, but it is understandable that this is
289  * better kept as an internal representation in cgroup.c. In any case, the
290  * cgrp_id space is not getting any smaller, and we don't have to necessarily
291  * increase ours as well if it increases.
292  */
293 #define MEMCG_CACHES_MIN_SIZE 4
294 #define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX
295
296 /*
297  * A lot of the calls to the cache allocation functions are expected to be
298  * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
299  * conditional to this static branch, we'll have to allow modules that does
300  * kmem_cache_alloc and the such to see this symbol as well
301  */
302 DEFINE_STATIC_KEY_FALSE(memcg_kmem_enabled_key);
303 EXPORT_SYMBOL(memcg_kmem_enabled_key);
304
305 struct workqueue_struct *memcg_kmem_cache_wq;
306
307 #endif /* !CONFIG_SLOB */
308
309 /**
310  * mem_cgroup_css_from_page - css of the memcg associated with a page
311  * @page: page of interest
312  *
313  * If memcg is bound to the default hierarchy, css of the memcg associated
314  * with @page is returned.  The returned css remains associated with @page
315  * until it is released.
316  *
317  * If memcg is bound to a traditional hierarchy, the css of root_mem_cgroup
318  * is returned.
319  */
320 struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
321 {
322         struct mem_cgroup *memcg;
323
324         memcg = page->mem_cgroup;
325
326         if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
327                 memcg = root_mem_cgroup;
328
329         return &memcg->css;
330 }
331
332 /**
333  * page_cgroup_ino - return inode number of the memcg a page is charged to
334  * @page: the page
335  *
336  * Look up the closest online ancestor of the memory cgroup @page is charged to
337  * and return its inode number or 0 if @page is not charged to any cgroup. It
338  * is safe to call this function without holding a reference to @page.
339  *
340  * Note, this function is inherently racy, because there is nothing to prevent
341  * the cgroup inode from getting torn down and potentially reallocated a moment
342  * after page_cgroup_ino() returns, so it only should be used by callers that
343  * do not care (such as procfs interfaces).
344  */
345 ino_t page_cgroup_ino(struct page *page)
346 {
347         struct mem_cgroup *memcg;
348         unsigned long ino = 0;
349
350         rcu_read_lock();
351         memcg = READ_ONCE(page->mem_cgroup);
352         while (memcg && !(memcg->css.flags & CSS_ONLINE))
353                 memcg = parent_mem_cgroup(memcg);
354         if (memcg)
355                 ino = cgroup_ino(memcg->css.cgroup);
356         rcu_read_unlock();
357         return ino;
358 }
359
360 static struct mem_cgroup_per_node *
361 mem_cgroup_page_nodeinfo(struct mem_cgroup *memcg, struct page *page)
362 {
363         int nid = page_to_nid(page);
364
365         return memcg->nodeinfo[nid];
366 }
367
368 static struct mem_cgroup_tree_per_node *
369 soft_limit_tree_node(int nid)
370 {
371         return soft_limit_tree.rb_tree_per_node[nid];
372 }
373
374 static struct mem_cgroup_tree_per_node *
375 soft_limit_tree_from_page(struct page *page)
376 {
377         int nid = page_to_nid(page);
378
379         return soft_limit_tree.rb_tree_per_node[nid];
380 }
381
382 static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz,
383                                          struct mem_cgroup_tree_per_node *mctz,
384                                          unsigned long new_usage_in_excess)
385 {
386         struct rb_node **p = &mctz->rb_root.rb_node;
387         struct rb_node *parent = NULL;
388         struct mem_cgroup_per_node *mz_node;
389
390         if (mz->on_tree)
391                 return;
392
393         mz->usage_in_excess = new_usage_in_excess;
394         if (!mz->usage_in_excess)
395                 return;
396         while (*p) {
397                 parent = *p;
398                 mz_node = rb_entry(parent, struct mem_cgroup_per_node,
399                                         tree_node);
400                 if (mz->usage_in_excess < mz_node->usage_in_excess)
401                         p = &(*p)->rb_left;
402                 /*
403                  * We can't avoid mem cgroups that are over their soft
404                  * limit by the same amount
405                  */
406                 else if (mz->usage_in_excess >= mz_node->usage_in_excess)
407                         p = &(*p)->rb_right;
408         }
409         rb_link_node(&mz->tree_node, parent, p);
410         rb_insert_color(&mz->tree_node, &mctz->rb_root);
411         mz->on_tree = true;
412 }
413
414 static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
415                                          struct mem_cgroup_tree_per_node *mctz)
416 {
417         if (!mz->on_tree)
418                 return;
419         rb_erase(&mz->tree_node, &mctz->rb_root);
420         mz->on_tree = false;
421 }
422
423 static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
424                                        struct mem_cgroup_tree_per_node *mctz)
425 {
426         unsigned long flags;
427
428         spin_lock_irqsave(&mctz->lock, flags);
429         __mem_cgroup_remove_exceeded(mz, mctz);
430         spin_unlock_irqrestore(&mctz->lock, flags);
431 }
432
433 static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
434 {
435         unsigned long nr_pages = page_counter_read(&memcg->memory);
436         unsigned long soft_limit = READ_ONCE(memcg->soft_limit);
437         unsigned long excess = 0;
438
439         if (nr_pages > soft_limit)
440                 excess = nr_pages - soft_limit;
441
442         return excess;
443 }
444
445 static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
446 {
447         unsigned long excess;
448         struct mem_cgroup_per_node *mz;
449         struct mem_cgroup_tree_per_node *mctz;
450
451         mctz = soft_limit_tree_from_page(page);
452         if (!mctz)
453                 return;
454         /*
455          * Necessary to update all ancestors when hierarchy is used.
456          * because their event counter is not touched.
457          */
458         for (; memcg; memcg = parent_mem_cgroup(memcg)) {
459                 mz = mem_cgroup_page_nodeinfo(memcg, page);
460                 excess = soft_limit_excess(memcg);
461                 /*
462                  * We have to update the tree if mz is on RB-tree or
463                  * mem is over its softlimit.
464                  */
465                 if (excess || mz->on_tree) {
466                         unsigned long flags;
467
468                         spin_lock_irqsave(&mctz->lock, flags);
469                         /* if on-tree, remove it */
470                         if (mz->on_tree)
471                                 __mem_cgroup_remove_exceeded(mz, mctz);
472                         /*
473                          * Insert again. mz->usage_in_excess will be updated.
474                          * If excess is 0, no tree ops.
475                          */
476                         __mem_cgroup_insert_exceeded(mz, mctz, excess);
477                         spin_unlock_irqrestore(&mctz->lock, flags);
478                 }
479         }
480 }
481
482 static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
483 {
484         struct mem_cgroup_tree_per_node *mctz;
485         struct mem_cgroup_per_node *mz;
486         int nid;
487
488         for_each_node(nid) {
489                 mz = mem_cgroup_nodeinfo(memcg, nid);
490                 mctz = soft_limit_tree_node(nid);
491                 if (mctz)
492                         mem_cgroup_remove_exceeded(mz, mctz);
493         }
494 }
495
496 static struct mem_cgroup_per_node *
497 __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
498 {
499         struct rb_node *rightmost = NULL;
500         struct mem_cgroup_per_node *mz;
501
502 retry:
503         mz = NULL;
504         rightmost = rb_last(&mctz->rb_root);
505         if (!rightmost)
506                 goto done;              /* Nothing to reclaim from */
507
508         mz = rb_entry(rightmost, struct mem_cgroup_per_node, tree_node);
509         /*
510          * Remove the node now but someone else can add it back,
511          * we will to add it back at the end of reclaim to its correct
512          * position in the tree.
513          */
514         __mem_cgroup_remove_exceeded(mz, mctz);
515         if (!soft_limit_excess(mz->memcg) ||
516             !css_tryget_online(&mz->memcg->css))
517                 goto retry;
518 done:
519         return mz;
520 }
521
522 static struct mem_cgroup_per_node *
523 mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
524 {
525         struct mem_cgroup_per_node *mz;
526
527         spin_lock_irq(&mctz->lock);
528         mz = __mem_cgroup_largest_soft_limit_node(mctz);
529         spin_unlock_irq(&mctz->lock);
530         return mz;
531 }
532
533 /*
534  * Return page count for single (non recursive) @memcg.
535  *
536  * Implementation Note: reading percpu statistics for memcg.
537  *
538  * Both of vmstat[] and percpu_counter has threshold and do periodic
539  * synchronization to implement "quick" read. There are trade-off between
540  * reading cost and precision of value. Then, we may have a chance to implement
541  * a periodic synchronization of counter in memcg's counter.
542  *
543  * But this _read() function is used for user interface now. The user accounts
544  * memory usage by memory cgroup and he _always_ requires exact value because
545  * he accounts memory. Even if we provide quick-and-fuzzy read, we always
546  * have to visit all online cpus and make sum. So, for now, unnecessary
547  * synchronization is not implemented. (just implemented for cpu hotplug)
548  *
549  * If there are kernel internal actions which can make use of some not-exact
550  * value, and reading all cpu value can be performance bottleneck in some
551  * common workload, threshold and synchronization as vmstat[] should be
552  * implemented.
553  *
554  * The parameter idx can be of type enum memcg_event_item or vm_event_item.
555  */
556
557 static unsigned long memcg_sum_events(struct mem_cgroup *memcg,
558                                       int event)
559 {
560         unsigned long val = 0;
561         int cpu;
562
563         for_each_possible_cpu(cpu)
564                 val += per_cpu(memcg->stat->events[event], cpu);
565         return val;
566 }
567
568 static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
569                                          struct page *page,
570                                          bool compound, int nr_pages)
571 {
572         /*
573          * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
574          * counted as CACHE even if it's on ANON LRU.
575          */
576         if (PageAnon(page))
577                 __this_cpu_add(memcg->stat->count[MEMCG_RSS], nr_pages);
578         else {
579                 __this_cpu_add(memcg->stat->count[MEMCG_CACHE], nr_pages);
580                 if (PageSwapBacked(page))
581                         __this_cpu_add(memcg->stat->count[NR_SHMEM], nr_pages);
582         }
583
584         if (compound) {
585                 VM_BUG_ON_PAGE(!PageTransHuge(page), page);
586                 __this_cpu_add(memcg->stat->count[MEMCG_RSS_HUGE], nr_pages);
587         }
588
589         /* pagein of a big page is an event. So, ignore page size */
590         if (nr_pages > 0)
591                 __this_cpu_inc(memcg->stat->events[PGPGIN]);
592         else {
593                 __this_cpu_inc(memcg->stat->events[PGPGOUT]);
594                 nr_pages = -nr_pages; /* for event */
595         }
596
597         __this_cpu_add(memcg->stat->nr_page_events, nr_pages);
598 }
599
600 unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
601                                            int nid, unsigned int lru_mask)
602 {
603         struct lruvec *lruvec = mem_cgroup_lruvec(NODE_DATA(nid), memcg);
604         unsigned long nr = 0;
605         enum lru_list lru;
606
607         VM_BUG_ON((unsigned)nid >= nr_node_ids);
608
609         for_each_lru(lru) {
610                 if (!(BIT(lru) & lru_mask))
611                         continue;
612                 nr += mem_cgroup_get_lru_size(lruvec, lru);
613         }
614         return nr;
615 }
616
617 static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
618                         unsigned int lru_mask)
619 {
620         unsigned long nr = 0;
621         int nid;
622
623         for_each_node_state(nid, N_MEMORY)
624                 nr += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
625         return nr;
626 }
627
628 static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
629                                        enum mem_cgroup_events_target target)
630 {
631         unsigned long val, next;
632
633         val = __this_cpu_read(memcg->stat->nr_page_events);
634         next = __this_cpu_read(memcg->stat->targets[target]);
635         /* from time_after() in jiffies.h */
636         if ((long)(next - val) < 0) {
637                 switch (target) {
638                 case MEM_CGROUP_TARGET_THRESH:
639                         next = val + THRESHOLDS_EVENTS_TARGET;
640                         break;
641                 case MEM_CGROUP_TARGET_SOFTLIMIT:
642                         next = val + SOFTLIMIT_EVENTS_TARGET;
643                         break;
644                 case MEM_CGROUP_TARGET_NUMAINFO:
645                         next = val + NUMAINFO_EVENTS_TARGET;
646                         break;
647                 default:
648                         break;
649                 }
650                 __this_cpu_write(memcg->stat->targets[target], next);
651                 return true;
652         }
653         return false;
654 }
655
656 /*
657  * Check events in order.
658  *
659  */
660 static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
661 {
662         /* threshold event is triggered in finer grain than soft limit */
663         if (unlikely(mem_cgroup_event_ratelimit(memcg,
664                                                 MEM_CGROUP_TARGET_THRESH))) {
665                 bool do_softlimit;
666                 bool do_numainfo __maybe_unused;
667
668                 do_softlimit = mem_cgroup_event_ratelimit(memcg,
669                                                 MEM_CGROUP_TARGET_SOFTLIMIT);
670 #if MAX_NUMNODES > 1
671                 do_numainfo = mem_cgroup_event_ratelimit(memcg,
672                                                 MEM_CGROUP_TARGET_NUMAINFO);
673 #endif
674                 mem_cgroup_threshold(memcg);
675                 if (unlikely(do_softlimit))
676                         mem_cgroup_update_tree(memcg, page);
677 #if MAX_NUMNODES > 1
678                 if (unlikely(do_numainfo))
679                         atomic_inc(&memcg->numainfo_events);
680 #endif
681         }
682 }
683
684 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
685 {
686         /*
687          * mm_update_next_owner() may clear mm->owner to NULL
688          * if it races with swapoff, page migration, etc.
689          * So this can be called with p == NULL.
690          */
691         if (unlikely(!p))
692                 return NULL;
693
694         return mem_cgroup_from_css(task_css(p, memory_cgrp_id));
695 }
696 EXPORT_SYMBOL(mem_cgroup_from_task);
697
698 static struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
699 {
700         struct mem_cgroup *memcg = NULL;
701
702         rcu_read_lock();
703         do {
704                 /*
705                  * Page cache insertions can happen withou an
706                  * actual mm context, e.g. during disk probing
707                  * on boot, loopback IO, acct() writes etc.
708                  */
709                 if (unlikely(!mm))
710                         memcg = root_mem_cgroup;
711                 else {
712                         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
713                         if (unlikely(!memcg))
714                                 memcg = root_mem_cgroup;
715                 }
716         } while (!css_tryget_online(&memcg->css));
717         rcu_read_unlock();
718         return memcg;
719 }
720
721 /**
722  * mem_cgroup_iter - iterate over memory cgroup hierarchy
723  * @root: hierarchy root
724  * @prev: previously returned memcg, NULL on first invocation
725  * @reclaim: cookie for shared reclaim walks, NULL for full walks
726  *
727  * Returns references to children of the hierarchy below @root, or
728  * @root itself, or %NULL after a full round-trip.
729  *
730  * Caller must pass the return value in @prev on subsequent
731  * invocations for reference counting, or use mem_cgroup_iter_break()
732  * to cancel a hierarchy walk before the round-trip is complete.
733  *
734  * Reclaimers can specify a zone and a priority level in @reclaim to
735  * divide up the memcgs in the hierarchy among all concurrent
736  * reclaimers operating on the same zone and priority.
737  */
738 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
739                                    struct mem_cgroup *prev,
740                                    struct mem_cgroup_reclaim_cookie *reclaim)
741 {
742         struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
743         struct cgroup_subsys_state *css = NULL;
744         struct mem_cgroup *memcg = NULL;
745         struct mem_cgroup *pos = NULL;
746
747         if (mem_cgroup_disabled())
748                 return NULL;
749
750         if (!root)
751                 root = root_mem_cgroup;
752
753         if (prev && !reclaim)
754                 pos = prev;
755
756         if (!root->use_hierarchy && root != root_mem_cgroup) {
757                 if (prev)
758                         goto out;
759                 return root;
760         }
761
762         rcu_read_lock();
763
764         if (reclaim) {
765                 struct mem_cgroup_per_node *mz;
766
767                 mz = mem_cgroup_nodeinfo(root, reclaim->pgdat->node_id);
768                 iter = &mz->iter[reclaim->priority];
769
770                 if (prev && reclaim->generation != iter->generation)
771                         goto out_unlock;
772
773                 while (1) {
774                         pos = READ_ONCE(iter->position);
775                         if (!pos || css_tryget(&pos->css))
776                                 break;
777                         /*
778                          * css reference reached zero, so iter->position will
779                          * be cleared by ->css_released. However, we should not
780                          * rely on this happening soon, because ->css_released
781                          * is called from a work queue, and by busy-waiting we
782                          * might block it. So we clear iter->position right
783                          * away.
784                          */
785                         (void)cmpxchg(&iter->position, pos, NULL);
786                 }
787         }
788
789         if (pos)
790                 css = &pos->css;
791
792         for (;;) {
793                 css = css_next_descendant_pre(css, &root->css);
794                 if (!css) {
795                         /*
796                          * Reclaimers share the hierarchy walk, and a
797                          * new one might jump in right at the end of
798                          * the hierarchy - make sure they see at least
799                          * one group and restart from the beginning.
800                          */
801                         if (!prev)
802                                 continue;
803                         break;
804                 }
805
806                 /*
807                  * Verify the css and acquire a reference.  The root
808                  * is provided by the caller, so we know it's alive
809                  * and kicking, and don't take an extra reference.
810                  */
811                 memcg = mem_cgroup_from_css(css);
812
813                 if (css == &root->css)
814                         break;
815
816                 if (css_tryget(css))
817                         break;
818
819                 memcg = NULL;
820         }
821
822         if (reclaim) {
823                 /*
824                  * The position could have already been updated by a competing
825                  * thread, so check that the value hasn't changed since we read
826                  * it to avoid reclaiming from the same cgroup twice.
827                  */
828                 (void)cmpxchg(&iter->position, pos, memcg);
829
830                 if (pos)
831                         css_put(&pos->css);
832
833                 if (!memcg)
834                         iter->generation++;
835                 else if (!prev)
836                         reclaim->generation = iter->generation;
837         }
838
839 out_unlock:
840         rcu_read_unlock();
841 out:
842         if (prev && prev != root)
843                 css_put(&prev->css);
844
845         return memcg;
846 }
847
848 /**
849  * mem_cgroup_iter_break - abort a hierarchy walk prematurely
850  * @root: hierarchy root
851  * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
852  */
853 void mem_cgroup_iter_break(struct mem_cgroup *root,
854                            struct mem_cgroup *prev)
855 {
856         if (!root)
857                 root = root_mem_cgroup;
858         if (prev && prev != root)
859                 css_put(&prev->css);
860 }
861
862 static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
863 {
864         struct mem_cgroup *memcg = dead_memcg;
865         struct mem_cgroup_reclaim_iter *iter;
866         struct mem_cgroup_per_node *mz;
867         int nid;
868         int i;
869
870         while ((memcg = parent_mem_cgroup(memcg))) {
871                 for_each_node(nid) {
872                         mz = mem_cgroup_nodeinfo(memcg, nid);
873                         for (i = 0; i <= DEF_PRIORITY; i++) {
874                                 iter = &mz->iter[i];
875                                 cmpxchg(&iter->position,
876                                         dead_memcg, NULL);
877                         }
878                 }
879         }
880 }
881
882 /*
883  * Iteration constructs for visiting all cgroups (under a tree).  If
884  * loops are exited prematurely (break), mem_cgroup_iter_break() must
885  * be used for reference counting.
886  */
887 #define for_each_mem_cgroup_tree(iter, root)            \
888         for (iter = mem_cgroup_iter(root, NULL, NULL);  \
889              iter != NULL;                              \
890              iter = mem_cgroup_iter(root, iter, NULL))
891
892 #define for_each_mem_cgroup(iter)                       \
893         for (iter = mem_cgroup_iter(NULL, NULL, NULL);  \
894              iter != NULL;                              \
895              iter = mem_cgroup_iter(NULL, iter, NULL))
896
897 /**
898  * mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy
899  * @memcg: hierarchy root
900  * @fn: function to call for each task
901  * @arg: argument passed to @fn
902  *
903  * This function iterates over tasks attached to @memcg or to any of its
904  * descendants and calls @fn for each task. If @fn returns a non-zero
905  * value, the function breaks the iteration loop and returns the value.
906  * Otherwise, it will iterate over all tasks and return 0.
907  *
908  * This function must not be called for the root memory cgroup.
909  */
910 int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
911                           int (*fn)(struct task_struct *, void *), void *arg)
912 {
913         struct mem_cgroup *iter;
914         int ret = 0;
915
916         BUG_ON(memcg == root_mem_cgroup);
917
918         for_each_mem_cgroup_tree(iter, memcg) {
919                 struct css_task_iter it;
920                 struct task_struct *task;
921
922                 css_task_iter_start(&iter->css, 0, &it);
923                 while (!ret && (task = css_task_iter_next(&it)))
924                         ret = fn(task, arg);
925                 css_task_iter_end(&it);
926                 if (ret) {
927                         mem_cgroup_iter_break(memcg, iter);
928                         break;
929                 }
930         }
931         return ret;
932 }
933
934 /**
935  * mem_cgroup_page_lruvec - return lruvec for isolating/putting an LRU page
936  * @page: the page
937  * @zone: zone of the page
938  *
939  * This function is only safe when following the LRU page isolation
940  * and putback protocol: the LRU lock must be held, and the page must
941  * either be PageLRU() or the caller must have isolated/allocated it.
942  */
943 struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct pglist_data *pgdat)
944 {
945         struct mem_cgroup_per_node *mz;
946         struct mem_cgroup *memcg;
947         struct lruvec *lruvec;
948
949         if (mem_cgroup_disabled()) {
950                 lruvec = &pgdat->lruvec;
951                 goto out;
952         }
953
954         memcg = page->mem_cgroup;
955         /*
956          * Swapcache readahead pages are added to the LRU - and
957          * possibly migrated - before they are charged.
958          */
959         if (!memcg)
960                 memcg = root_mem_cgroup;
961
962         mz = mem_cgroup_page_nodeinfo(memcg, page);
963         lruvec = &mz->lruvec;
964 out:
965         /*
966          * Since a node can be onlined after the mem_cgroup was created,
967          * we have to be prepared to initialize lruvec->zone here;
968          * and if offlined then reonlined, we need to reinitialize it.
969          */
970         if (unlikely(lruvec->pgdat != pgdat))
971                 lruvec->pgdat = pgdat;
972         return lruvec;
973 }
974
975 /**
976  * mem_cgroup_update_lru_size - account for adding or removing an lru page
977  * @lruvec: mem_cgroup per zone lru vector
978  * @lru: index of lru list the page is sitting on
979  * @zid: zone id of the accounted pages
980  * @nr_pages: positive when adding or negative when removing
981  *
982  * This function must be called under lru_lock, just before a page is added
983  * to or just after a page is removed from an lru list (that ordering being
984  * so as to allow it to check that lru_size 0 is consistent with list_empty).
985  */
986 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
987                                 int zid, int nr_pages)
988 {
989         struct mem_cgroup_per_node *mz;
990         unsigned long *lru_size;
991         long size;
992
993         if (mem_cgroup_disabled())
994                 return;
995
996         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
997         lru_size = &mz->lru_zone_size[zid][lru];
998
999         if (nr_pages < 0)
1000                 *lru_size += nr_pages;
1001
1002         size = *lru_size;
1003         if (WARN_ONCE(size < 0,
1004                 "%s(%p, %d, %d): lru_size %ld\n",
1005                 __func__, lruvec, lru, nr_pages, size)) {
1006                 VM_BUG_ON(1);
1007                 *lru_size = 0;
1008         }
1009
1010         if (nr_pages > 0)
1011                 *lru_size += nr_pages;
1012 }
1013
1014 bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg)
1015 {
1016         struct mem_cgroup *task_memcg;
1017         struct task_struct *p;
1018         bool ret;
1019
1020         p = find_lock_task_mm(task);
1021         if (p) {
1022                 task_memcg = get_mem_cgroup_from_mm(p->mm);
1023                 task_unlock(p);
1024         } else {
1025                 /*
1026                  * All threads may have already detached their mm's, but the oom
1027                  * killer still needs to detect if they have already been oom
1028                  * killed to prevent needlessly killing additional tasks.
1029                  */
1030                 rcu_read_lock();
1031                 task_memcg = mem_cgroup_from_task(task);
1032                 css_get(&task_memcg->css);
1033                 rcu_read_unlock();
1034         }
1035         ret = mem_cgroup_is_descendant(task_memcg, memcg);
1036         css_put(&task_memcg->css);
1037         return ret;
1038 }
1039
1040 /**
1041  * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1042  * @memcg: the memory cgroup
1043  *
1044  * Returns the maximum amount of memory @mem can be charged with, in
1045  * pages.
1046  */
1047 static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1048 {
1049         unsigned long margin = 0;
1050         unsigned long count;
1051         unsigned long limit;
1052
1053         count = page_counter_read(&memcg->memory);
1054         limit = READ_ONCE(memcg->memory.limit);
1055         if (count < limit)
1056                 margin = limit - count;
1057
1058         if (do_memsw_account()) {
1059                 count = page_counter_read(&memcg->memsw);
1060                 limit = READ_ONCE(memcg->memsw.limit);
1061                 if (count <= limit)
1062                         margin = min(margin, limit - count);
1063                 else
1064                         margin = 0;
1065         }
1066
1067         return margin;
1068 }
1069
1070 /*
1071  * A routine for checking "mem" is under move_account() or not.
1072  *
1073  * Checking a cgroup is mc.from or mc.to or under hierarchy of
1074  * moving cgroups. This is for waiting at high-memory pressure
1075  * caused by "move".
1076  */
1077 static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1078 {
1079         struct mem_cgroup *from;
1080         struct mem_cgroup *to;
1081         bool ret = false;
1082         /*
1083          * Unlike task_move routines, we access mc.to, mc.from not under
1084          * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1085          */
1086         spin_lock(&mc.lock);
1087         from = mc.from;
1088         to = mc.to;
1089         if (!from)
1090                 goto unlock;
1091
1092         ret = mem_cgroup_is_descendant(from, memcg) ||
1093                 mem_cgroup_is_descendant(to, memcg);
1094 unlock:
1095         spin_unlock(&mc.lock);
1096         return ret;
1097 }
1098
1099 static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1100 {
1101         if (mc.moving_task && current != mc.moving_task) {
1102                 if (mem_cgroup_under_move(memcg)) {
1103                         DEFINE_WAIT(wait);
1104                         prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1105                         /* moving charge context might have finished. */
1106                         if (mc.moving_task)
1107                                 schedule();
1108                         finish_wait(&mc.waitq, &wait);
1109                         return true;
1110                 }
1111         }
1112         return false;
1113 }
1114
1115 unsigned int memcg1_stats[] = {
1116         MEMCG_CACHE,
1117         MEMCG_RSS,
1118         MEMCG_RSS_HUGE,
1119         NR_SHMEM,
1120         NR_FILE_MAPPED,
1121         NR_FILE_DIRTY,
1122         NR_WRITEBACK,
1123         MEMCG_SWAP,
1124 };
1125
1126 static const char *const memcg1_stat_names[] = {
1127         "cache",
1128         "rss",
1129         "rss_huge",
1130         "shmem",
1131         "mapped_file",
1132         "dirty",
1133         "writeback",
1134         "swap",
1135 };
1136
1137 #define K(x) ((x) << (PAGE_SHIFT-10))
1138 /**
1139  * mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.
1140  * @memcg: The memory cgroup that went over limit
1141  * @p: Task that is going to be killed
1142  *
1143  * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1144  * enabled
1145  */
1146 void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
1147 {
1148         struct mem_cgroup *iter;
1149         unsigned int i;
1150
1151         rcu_read_lock();
1152
1153         if (p) {
1154                 pr_info("Task in ");
1155                 pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
1156                 pr_cont(" killed as a result of limit of ");
1157         } else {
1158                 pr_info("Memory limit reached of cgroup ");
1159         }
1160
1161         pr_cont_cgroup_path(memcg->css.cgroup);
1162         pr_cont("\n");
1163
1164         rcu_read_unlock();
1165
1166         pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
1167                 K((u64)page_counter_read(&memcg->memory)),
1168                 K((u64)memcg->memory.limit), memcg->memory.failcnt);
1169         pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
1170                 K((u64)page_counter_read(&memcg->memsw)),
1171                 K((u64)memcg->memsw.limit), memcg->memsw.failcnt);
1172         pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
1173                 K((u64)page_counter_read(&memcg->kmem)),
1174                 K((u64)memcg->kmem.limit), memcg->kmem.failcnt);
1175
1176         for_each_mem_cgroup_tree(iter, memcg) {
1177                 pr_info("Memory cgroup stats for ");
1178                 pr_cont_cgroup_path(iter->css.cgroup);
1179                 pr_cont(":");
1180
1181                 for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
1182                         if (memcg1_stats[i] == MEMCG_SWAP && !do_swap_account)
1183                                 continue;
1184                         pr_cont(" %s:%luKB", memcg1_stat_names[i],
1185                                 K(memcg_page_state(iter, memcg1_stats[i])));
1186                 }
1187
1188                 for (i = 0; i < NR_LRU_LISTS; i++)
1189                         pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
1190                                 K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
1191
1192                 pr_cont("\n");
1193         }
1194 }
1195
1196 /*
1197  * This function returns the number of memcg under hierarchy tree. Returns
1198  * 1(self count) if no children.
1199  */
1200 static int mem_cgroup_count_children(struct mem_cgroup *memcg)
1201 {
1202         int num = 0;
1203         struct mem_cgroup *iter;
1204
1205         for_each_mem_cgroup_tree(iter, memcg)
1206                 num++;
1207         return num;
1208 }
1209
1210 /*
1211  * Return the memory (and swap, if configured) limit for a memcg.
1212  */
1213 unsigned long mem_cgroup_get_limit(struct mem_cgroup *memcg)
1214 {
1215         unsigned long limit;
1216
1217         limit = memcg->memory.limit;
1218         if (mem_cgroup_swappiness(memcg)) {
1219                 unsigned long memsw_limit;
1220                 unsigned long swap_limit;
1221
1222                 memsw_limit = memcg->memsw.limit;
1223                 swap_limit = memcg->swap.limit;
1224                 swap_limit = min(swap_limit, (unsigned long)total_swap_pages);
1225                 limit = min(limit + swap_limit, memsw_limit);
1226         }
1227         return limit;
1228 }
1229
1230 static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1231                                      int order)
1232 {
1233         struct oom_control oc = {
1234                 .zonelist = NULL,
1235                 .nodemask = NULL,
1236                 .memcg = memcg,
1237                 .gfp_mask = gfp_mask,
1238                 .order = order,
1239         };
1240         bool ret;
1241
1242         mutex_lock(&oom_lock);
1243         ret = out_of_memory(&oc);
1244         mutex_unlock(&oom_lock);
1245         return ret;
1246 }
1247
1248 #if MAX_NUMNODES > 1
1249
1250 /**
1251  * test_mem_cgroup_node_reclaimable
1252  * @memcg: the target memcg
1253  * @nid: the node ID to be checked.
1254  * @noswap : specify true here if the user wants flle only information.
1255  *
1256  * This function returns whether the specified memcg contains any
1257  * reclaimable pages on a node. Returns true if there are any reclaimable
1258  * pages in the node.
1259  */
1260 static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
1261                 int nid, bool noswap)
1262 {
1263         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))
1264                 return true;
1265         if (noswap || !total_swap_pages)
1266                 return false;
1267         if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))
1268                 return true;
1269         return false;
1270
1271 }
1272
1273 /*
1274  * Always updating the nodemask is not very good - even if we have an empty
1275  * list or the wrong list here, we can start from some node and traverse all
1276  * nodes based on the zonelist. So update the list loosely once per 10 secs.
1277  *
1278  */
1279 static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
1280 {
1281         int nid;
1282         /*
1283          * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
1284          * pagein/pageout changes since the last update.
1285          */
1286         if (!atomic_read(&memcg->numainfo_events))
1287                 return;
1288         if (atomic_inc_return(&memcg->numainfo_updating) > 1)
1289                 return;
1290
1291         /* make a nodemask where this memcg uses memory from */
1292         memcg->scan_nodes = node_states[N_MEMORY];
1293
1294         for_each_node_mask(nid, node_states[N_MEMORY]) {
1295
1296                 if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
1297                         node_clear(nid, memcg->scan_nodes);
1298         }
1299
1300         atomic_set(&memcg->numainfo_events, 0);
1301         atomic_set(&memcg->numainfo_updating, 0);
1302 }
1303
1304 /*
1305  * Selecting a node where we start reclaim from. Because what we need is just
1306  * reducing usage counter, start from anywhere is O,K. Considering
1307  * memory reclaim from current node, there are pros. and cons.
1308  *
1309  * Freeing memory from current node means freeing memory from a node which
1310  * we'll use or we've used. So, it may make LRU bad. And if several threads
1311  * hit limits, it will see a contention on a node. But freeing from remote
1312  * node means more costs for memory reclaim because of memory latency.
1313  *
1314  * Now, we use round-robin. Better algorithm is welcomed.
1315  */
1316 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1317 {
1318         int node;
1319
1320         mem_cgroup_may_update_nodemask(memcg);
1321         node = memcg->last_scanned_node;
1322
1323         node = next_node_in(node, memcg->scan_nodes);
1324         /*
1325          * mem_cgroup_may_update_nodemask might have seen no reclaimmable pages
1326          * last time it really checked all the LRUs due to rate limiting.
1327          * Fallback to the current node in that case for simplicity.
1328          */
1329         if (unlikely(node == MAX_NUMNODES))
1330                 node = numa_node_id();
1331
1332         memcg->last_scanned_node = node;
1333         return node;
1334 }
1335 #else
1336 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1337 {
1338         return 0;
1339 }
1340 #endif
1341
1342 static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1343                                    pg_data_t *pgdat,
1344                                    gfp_t gfp_mask,
1345                                    unsigned long *total_scanned)
1346 {
1347         struct mem_cgroup *victim = NULL;
1348         int total = 0;
1349         int loop = 0;
1350         unsigned long excess;
1351         unsigned long nr_scanned;
1352         struct mem_cgroup_reclaim_cookie reclaim = {
1353                 .pgdat = pgdat,
1354                 .priority = 0,
1355         };
1356
1357         excess = soft_limit_excess(root_memcg);
1358
1359         while (1) {
1360                 victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
1361                 if (!victim) {
1362                         loop++;
1363                         if (loop >= 2) {
1364                                 /*
1365                                  * If we have not been able to reclaim
1366                                  * anything, it might because there are
1367                                  * no reclaimable pages under this hierarchy
1368                                  */
1369                                 if (!total)
1370                                         break;
1371                                 /*
1372                                  * We want to do more targeted reclaim.
1373                                  * excess >> 2 is not to excessive so as to
1374                                  * reclaim too much, nor too less that we keep
1375                                  * coming back to reclaim from this cgroup
1376                                  */
1377                                 if (total >= (excess >> 2) ||
1378                                         (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
1379                                         break;
1380                         }
1381                         continue;
1382                 }
1383                 total += mem_cgroup_shrink_node(victim, gfp_mask, false,
1384                                         pgdat, &nr_scanned);
1385                 *total_scanned += nr_scanned;
1386                 if (!soft_limit_excess(root_memcg))
1387                         break;
1388         }
1389         mem_cgroup_iter_break(root_memcg, victim);
1390         return total;
1391 }
1392
1393 #ifdef CONFIG_LOCKDEP
1394 static struct lockdep_map memcg_oom_lock_dep_map = {
1395         .name = "memcg_oom_lock",
1396 };
1397 #endif
1398
1399 static DEFINE_SPINLOCK(memcg_oom_lock);
1400
1401 /*
1402  * Check OOM-Killer is already running under our hierarchy.
1403  * If someone is running, return false.
1404  */
1405 static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
1406 {
1407         struct mem_cgroup *iter, *failed = NULL;
1408
1409         spin_lock(&memcg_oom_lock);
1410
1411         for_each_mem_cgroup_tree(iter, memcg) {
1412                 if (iter->oom_lock) {
1413                         /*
1414                          * this subtree of our hierarchy is already locked
1415                          * so we cannot give a lock.
1416                          */
1417                         failed = iter;
1418                         mem_cgroup_iter_break(memcg, iter);
1419                         break;
1420                 } else
1421                         iter->oom_lock = true;
1422         }
1423
1424         if (failed) {
1425                 /*
1426                  * OK, we failed to lock the whole subtree so we have
1427                  * to clean up what we set up to the failing subtree
1428                  */
1429                 for_each_mem_cgroup_tree(iter, memcg) {
1430                         if (iter == failed) {
1431                                 mem_cgroup_iter_break(memcg, iter);
1432                                 break;
1433                         }
1434                         iter->oom_lock = false;
1435                 }
1436         } else
1437                 mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);
1438
1439         spin_unlock(&memcg_oom_lock);
1440
1441         return !failed;
1442 }
1443
1444 static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1445 {
1446         struct mem_cgroup *iter;
1447
1448         spin_lock(&memcg_oom_lock);
1449         mutex_release(&memcg_oom_lock_dep_map, 1, _RET_IP_);
1450         for_each_mem_cgroup_tree(iter, memcg)
1451                 iter->oom_lock = false;
1452         spin_unlock(&memcg_oom_lock);
1453 }
1454
1455 static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1456 {
1457         struct mem_cgroup *iter;
1458
1459         spin_lock(&memcg_oom_lock);
1460         for_each_mem_cgroup_tree(iter, memcg)
1461                 iter->under_oom++;
1462         spin_unlock(&memcg_oom_lock);
1463 }
1464
1465 static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1466 {
1467         struct mem_cgroup *iter;
1468
1469         /*
1470          * When a new child is created while the hierarchy is under oom,
1471          * mem_cgroup_oom_lock() may not be called. Watch for underflow.
1472          */
1473         spin_lock(&memcg_oom_lock);
1474         for_each_mem_cgroup_tree(iter, memcg)
1475                 if (iter->under_oom > 0)
1476                         iter->under_oom--;
1477         spin_unlock(&memcg_oom_lock);
1478 }
1479
1480 static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1481
1482 struct oom_wait_info {
1483         struct mem_cgroup *memcg;
1484         wait_queue_entry_t      wait;
1485 };
1486
1487 static int memcg_oom_wake_function(wait_queue_entry_t *wait,
1488         unsigned mode, int sync, void *arg)
1489 {
1490         struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1491         struct mem_cgroup *oom_wait_memcg;
1492         struct oom_wait_info *oom_wait_info;
1493
1494         oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1495         oom_wait_memcg = oom_wait_info->memcg;
1496
1497         if (!mem_cgroup_is_descendant(wake_memcg, oom_wait_memcg) &&
1498             !mem_cgroup_is_descendant(oom_wait_memcg, wake_memcg))
1499                 return 0;
1500         return autoremove_wake_function(wait, mode, sync, arg);
1501 }
1502
1503 static void memcg_oom_recover(struct mem_cgroup *memcg)
1504 {
1505         /*
1506          * For the following lockless ->under_oom test, the only required
1507          * guarantee is that it must see the state asserted by an OOM when
1508          * this function is called as a result of userland actions
1509          * triggered by the notification of the OOM.  This is trivially
1510          * achieved by invoking mem_cgroup_mark_under_oom() before
1511          * triggering notification.
1512          */
1513         if (memcg && memcg->under_oom)
1514                 __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
1515 }
1516
1517 static void mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
1518 {
1519         if (!current->memcg_may_oom)
1520                 return;
1521         /*
1522          * We are in the middle of the charge context here, so we
1523          * don't want to block when potentially sitting on a callstack
1524          * that holds all kinds of filesystem and mm locks.
1525          *
1526          * Also, the caller may handle a failed allocation gracefully
1527          * (like optional page cache readahead) and so an OOM killer
1528          * invocation might not even be necessary.
1529          *
1530          * That's why we don't do anything here except remember the
1531          * OOM context and then deal with it at the end of the page
1532          * fault when the stack is unwound, the locks are released,
1533          * and when we know whether the fault was overall successful.
1534          */
1535         css_get(&memcg->css);
1536         current->memcg_in_oom = memcg;
1537         current->memcg_oom_gfp_mask = mask;
1538         current->memcg_oom_order = order;
1539 }
1540
1541 /**
1542  * mem_cgroup_oom_synchronize - complete memcg OOM handling
1543  * @handle: actually kill/wait or just clean up the OOM state
1544  *
1545  * This has to be called at the end of a page fault if the memcg OOM
1546  * handler was enabled.
1547  *
1548  * Memcg supports userspace OOM handling where failed allocations must
1549  * sleep on a waitqueue until the userspace task resolves the
1550  * situation.  Sleeping directly in the charge context with all kinds
1551  * of locks held is not a good idea, instead we remember an OOM state
1552  * in the task and mem_cgroup_oom_synchronize() has to be called at
1553  * the end of the page fault to complete the OOM handling.
1554  *
1555  * Returns %true if an ongoing memcg OOM situation was detected and
1556  * completed, %false otherwise.
1557  */
1558 bool mem_cgroup_oom_synchronize(bool handle)
1559 {
1560         struct mem_cgroup *memcg = current->memcg_in_oom;
1561         struct oom_wait_info owait;
1562         bool locked;
1563
1564         /* OOM is global, do not handle */
1565         if (!memcg)
1566                 return false;
1567
1568         if (!handle)
1569                 goto cleanup;
1570
1571         owait.memcg = memcg;
1572         owait.wait.flags = 0;
1573         owait.wait.func = memcg_oom_wake_function;
1574         owait.wait.private = current;
1575         INIT_LIST_HEAD(&owait.wait.entry);
1576
1577         prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
1578         mem_cgroup_mark_under_oom(memcg);
1579
1580         locked = mem_cgroup_oom_trylock(memcg);
1581
1582         if (locked)
1583                 mem_cgroup_oom_notify(memcg);
1584
1585         if (locked && !memcg->oom_kill_disable) {
1586                 mem_cgroup_unmark_under_oom(memcg);
1587                 finish_wait(&memcg_oom_waitq, &owait.wait);
1588                 mem_cgroup_out_of_memory(memcg, current->memcg_oom_gfp_mask,
1589                                          current->memcg_oom_order);
1590         } else {
1591                 schedule();
1592                 mem_cgroup_unmark_under_oom(memcg);
1593                 finish_wait(&memcg_oom_waitq, &owait.wait);
1594         }
1595
1596         if (locked) {
1597                 mem_cgroup_oom_unlock(memcg);
1598                 /*
1599                  * There is no guarantee that an OOM-lock contender
1600                  * sees the wakeups triggered by the OOM kill
1601                  * uncharges.  Wake any sleepers explicitely.
1602                  */
1603                 memcg_oom_recover(memcg);
1604         }
1605 cleanup:
1606         current->memcg_in_oom = NULL;
1607         css_put(&memcg->css);
1608         return true;
1609 }
1610
1611 /**
1612  * lock_page_memcg - lock a page->mem_cgroup binding
1613  * @page: the page
1614  *
1615  * This function protects unlocked LRU pages from being moved to
1616  * another cgroup.
1617  *
1618  * It ensures lifetime of the returned memcg. Caller is responsible
1619  * for the lifetime of the page; __unlock_page_memcg() is available
1620  * when @page might get freed inside the locked section.
1621  */
1622 struct mem_cgroup *lock_page_memcg(struct page *page)
1623 {
1624         struct mem_cgroup *memcg;
1625         unsigned long flags;
1626
1627         /*
1628          * The RCU lock is held throughout the transaction.  The fast
1629          * path can get away without acquiring the memcg->move_lock
1630          * because page moving starts with an RCU grace period.
1631          *
1632          * The RCU lock also protects the memcg from being freed when
1633          * the page state that is going to change is the only thing
1634          * preventing the page itself from being freed. E.g. writeback
1635          * doesn't hold a page reference and relies on PG_writeback to
1636          * keep off truncation, migration and so forth.
1637          */
1638         rcu_read_lock();
1639
1640         if (mem_cgroup_disabled())
1641                 return NULL;
1642 again:
1643         memcg = page->mem_cgroup;
1644         if (unlikely(!memcg))
1645                 return NULL;
1646
1647         if (atomic_read(&memcg->moving_account) <= 0)
1648                 return memcg;
1649
1650         spin_lock_irqsave(&memcg->move_lock, flags);
1651         if (memcg != page->mem_cgroup) {
1652                 spin_unlock_irqrestore(&memcg->move_lock, flags);
1653                 goto again;
1654         }
1655
1656         /*
1657          * When charge migration first begins, we can have locked and
1658          * unlocked page stat updates happening concurrently.  Track
1659          * the task who has the lock for unlock_page_memcg().
1660          */
1661         memcg->move_lock_task = current;
1662         memcg->move_lock_flags = flags;
1663
1664         return memcg;
1665 }
1666 EXPORT_SYMBOL(lock_page_memcg);
1667
1668 /**
1669  * __unlock_page_memcg - unlock and unpin a memcg
1670  * @memcg: the memcg
1671  *
1672  * Unlock and unpin a memcg returned by lock_page_memcg().
1673  */
1674 void __unlock_page_memcg(struct mem_cgroup *memcg)
1675 {
1676         if (memcg && memcg->move_lock_task == current) {
1677                 unsigned long flags = memcg->move_lock_flags;
1678
1679                 memcg->move_lock_task = NULL;
1680                 memcg->move_lock_flags = 0;
1681
1682                 spin_unlock_irqrestore(&memcg->move_lock, flags);
1683         }
1684
1685         rcu_read_unlock();
1686 }
1687
1688 /**
1689  * unlock_page_memcg - unlock a page->mem_cgroup binding
1690  * @page: the page
1691  */
1692 void unlock_page_memcg(struct page *page)
1693 {
1694         __unlock_page_memcg(page->mem_cgroup);
1695 }
1696 EXPORT_SYMBOL(unlock_page_memcg);
1697
1698 /*
1699  * size of first charge trial. "32" comes from vmscan.c's magic value.
1700  * TODO: maybe necessary to use big numbers in big irons.
1701  */
1702 #define CHARGE_BATCH    32U
1703 struct memcg_stock_pcp {
1704         struct mem_cgroup *cached; /* this never be root cgroup */
1705         unsigned int nr_pages;
1706         struct work_struct work;
1707         unsigned long flags;
1708 #define FLUSHING_CACHED_CHARGE  0
1709 };
1710 static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
1711 static DEFINE_MUTEX(percpu_charge_mutex);
1712
1713 /**
1714  * consume_stock: Try to consume stocked charge on this cpu.
1715  * @memcg: memcg to consume from.
1716  * @nr_pages: how many pages to charge.
1717  *
1718  * The charges will only happen if @memcg matches the current cpu's memcg
1719  * stock, and at least @nr_pages are available in that stock.  Failure to
1720  * service an allocation will refill the stock.
1721  *
1722  * returns true if successful, false otherwise.
1723  */
1724 static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
1725 {
1726         struct memcg_stock_pcp *stock;
1727         unsigned long flags;
1728         bool ret = false;
1729
1730         if (nr_pages > CHARGE_BATCH)
1731                 return ret;
1732
1733         local_irq_save(flags);
1734
1735         stock = this_cpu_ptr(&memcg_stock);
1736         if (memcg == stock->cached && stock->nr_pages >= nr_pages) {
1737                 stock->nr_pages -= nr_pages;
1738                 ret = true;
1739         }
1740
1741         local_irq_restore(flags);
1742
1743         return ret;
1744 }
1745
1746 /*
1747  * Returns stocks cached in percpu and reset cached information.
1748  */
1749 static void drain_stock(struct memcg_stock_pcp *stock)
1750 {
1751         struct mem_cgroup *old = stock->cached;
1752
1753         if (stock->nr_pages) {
1754                 page_counter_uncharge(&old->memory, stock->nr_pages);
1755                 if (do_memsw_account())
1756                         page_counter_uncharge(&old->memsw, stock->nr_pages);
1757                 css_put_many(&old->css, stock->nr_pages);
1758                 stock->nr_pages = 0;
1759         }
1760         stock->cached = NULL;
1761 }
1762
1763 static void drain_local_stock(struct work_struct *dummy)
1764 {
1765         struct memcg_stock_pcp *stock;
1766         unsigned long flags;
1767
1768         local_irq_save(flags);
1769
1770         stock = this_cpu_ptr(&memcg_stock);
1771         drain_stock(stock);
1772         clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
1773
1774         local_irq_restore(flags);
1775 }
1776
1777 /*
1778  * Cache charges(val) to local per_cpu area.
1779  * This will be consumed by consume_stock() function, later.
1780  */
1781 static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
1782 {
1783         struct memcg_stock_pcp *stock;
1784         unsigned long flags;
1785
1786         local_irq_save(flags);
1787
1788         stock = this_cpu_ptr(&memcg_stock);
1789         if (stock->cached != memcg) { /* reset if necessary */
1790                 drain_stock(stock);
1791                 stock->cached = memcg;
1792         }
1793         stock->nr_pages += nr_pages;
1794
1795         local_irq_restore(flags);
1796 }
1797
1798 /*
1799  * Drains all per-CPU charge caches for given root_memcg resp. subtree
1800  * of the hierarchy under it.
1801  */
1802 static void drain_all_stock(struct mem_cgroup *root_memcg)
1803 {
1804         int cpu, curcpu;
1805
1806         /* If someone's already draining, avoid adding running more workers. */
1807         if (!mutex_trylock(&percpu_charge_mutex))
1808                 return;
1809         /* Notify other cpus that system-wide "drain" is running */
1810         get_online_cpus();
1811         curcpu = get_cpu();
1812         for_each_online_cpu(cpu) {
1813                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
1814                 struct mem_cgroup *memcg;
1815
1816                 memcg = stock->cached;
1817                 if (!memcg || !stock->nr_pages)
1818                         continue;
1819                 if (!mem_cgroup_is_descendant(memcg, root_memcg))
1820                         continue;
1821                 if (!test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
1822                         if (cpu == curcpu)
1823                                 drain_local_stock(&stock->work);
1824                         else
1825                                 schedule_work_on(cpu, &stock->work);
1826                 }
1827         }
1828         put_cpu();
1829         put_online_cpus();
1830         mutex_unlock(&percpu_charge_mutex);
1831 }
1832
1833 static int memcg_hotplug_cpu_dead(unsigned int cpu)
1834 {
1835         struct memcg_stock_pcp *stock;
1836
1837         stock = &per_cpu(memcg_stock, cpu);
1838         drain_stock(stock);
1839         return 0;
1840 }
1841
1842 static void reclaim_high(struct mem_cgroup *memcg,
1843                          unsigned int nr_pages,
1844                          gfp_t gfp_mask)
1845 {
1846         do {
1847                 if (page_counter_read(&memcg->memory) <= memcg->high)
1848                         continue;
1849                 mem_cgroup_event(memcg, MEMCG_HIGH);
1850                 try_to_free_mem_cgroup_pages(memcg, nr_pages, gfp_mask, true);
1851         } while ((memcg = parent_mem_cgroup(memcg)));
1852 }
1853
1854 static void high_work_func(struct work_struct *work)
1855 {
1856         struct mem_cgroup *memcg;
1857
1858         memcg = container_of(work, struct mem_cgroup, high_work);
1859         reclaim_high(memcg, CHARGE_BATCH, GFP_KERNEL);
1860 }
1861
1862 /*
1863  * Scheduled by try_charge() to be executed from the userland return path
1864  * and reclaims memory over the high limit.
1865  */
1866 void mem_cgroup_handle_over_high(void)
1867 {
1868         unsigned int nr_pages = current->memcg_nr_pages_over_high;
1869         struct mem_cgroup *memcg;
1870
1871         if (likely(!nr_pages))
1872                 return;
1873
1874         memcg = get_mem_cgroup_from_mm(current->mm);
1875         reclaim_high(memcg, nr_pages, GFP_KERNEL);
1876         css_put(&memcg->css);
1877         current->memcg_nr_pages_over_high = 0;
1878 }
1879
1880 static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
1881                       unsigned int nr_pages)
1882 {
1883         unsigned int batch = max(CHARGE_BATCH, nr_pages);
1884         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
1885         struct mem_cgroup *mem_over_limit;
1886         struct page_counter *counter;
1887         unsigned long nr_reclaimed;
1888         bool may_swap = true;
1889         bool drained = false;
1890
1891         if (mem_cgroup_is_root(memcg))
1892                 return 0;
1893 retry:
1894         if (consume_stock(memcg, nr_pages))
1895                 return 0;
1896
1897         if (!do_memsw_account() ||
1898             page_counter_try_charge(&memcg->memsw, batch, &counter)) {
1899                 if (page_counter_try_charge(&memcg->memory, batch, &counter))
1900                         goto done_restock;
1901                 if (do_memsw_account())
1902                         page_counter_uncharge(&memcg->memsw, batch);
1903                 mem_over_limit = mem_cgroup_from_counter(counter, memory);
1904         } else {
1905                 mem_over_limit = mem_cgroup_from_counter(counter, memsw);
1906                 may_swap = false;
1907         }
1908
1909         if (batch > nr_pages) {
1910                 batch = nr_pages;
1911                 goto retry;
1912         }
1913
1914         /*
1915          * Unlike in global OOM situations, memcg is not in a physical
1916          * memory shortage.  Allow dying and OOM-killed tasks to
1917          * bypass the last charges so that they can exit quickly and
1918          * free their memory.
1919          */
1920         if (unlikely(tsk_is_oom_victim(current) ||
1921                      fatal_signal_pending(current) ||
1922                      current->flags & PF_EXITING))
1923                 goto force;
1924
1925         /*
1926          * Prevent unbounded recursion when reclaim operations need to
1927          * allocate memory. This might exceed the limits temporarily,
1928          * but we prefer facilitating memory reclaim and getting back
1929          * under the limit over triggering OOM kills in these cases.
1930          */
1931         if (unlikely(current->flags & PF_MEMALLOC))
1932                 goto force;
1933
1934         if (unlikely(task_in_memcg_oom(current)))
1935                 goto nomem;
1936
1937         if (!gfpflags_allow_blocking(gfp_mask))
1938                 goto nomem;
1939
1940         mem_cgroup_event(mem_over_limit, MEMCG_MAX);
1941
1942         nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
1943                                                     gfp_mask, may_swap);
1944
1945         if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
1946                 goto retry;
1947
1948         if (!drained) {
1949                 drain_all_stock(mem_over_limit);
1950                 drained = true;
1951                 goto retry;
1952         }
1953
1954         if (gfp_mask & __GFP_NORETRY)
1955                 goto nomem;
1956         /*
1957          * Even though the limit is exceeded at this point, reclaim
1958          * may have been able to free some pages.  Retry the charge
1959          * before killing the task.
1960          *
1961          * Only for regular pages, though: huge pages are rather
1962          * unlikely to succeed so close to the limit, and we fall back
1963          * to regular pages anyway in case of failure.
1964          */
1965         if (nr_reclaimed && nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER))
1966                 goto retry;
1967         /*
1968          * At task move, charge accounts can be doubly counted. So, it's
1969          * better to wait until the end of task_move if something is going on.
1970          */
1971         if (mem_cgroup_wait_acct_move(mem_over_limit))
1972                 goto retry;
1973
1974         if (nr_retries--)
1975                 goto retry;
1976
1977         if (gfp_mask & __GFP_NOFAIL)
1978                 goto force;
1979
1980         if (fatal_signal_pending(current))
1981                 goto force;
1982
1983         mem_cgroup_event(mem_over_limit, MEMCG_OOM);
1984
1985         mem_cgroup_oom(mem_over_limit, gfp_mask,
1986                        get_order(nr_pages * PAGE_SIZE));
1987 nomem:
1988         if (!(gfp_mask & __GFP_NOFAIL))
1989                 return -ENOMEM;
1990 force:
1991         /*
1992          * The allocation either can't fail or will lead to more memory
1993          * being freed very soon.  Allow memory usage go over the limit
1994          * temporarily by force charging it.
1995          */
1996         page_counter_charge(&memcg->memory, nr_pages);
1997         if (do_memsw_account())
1998                 page_counter_charge(&memcg->memsw, nr_pages);
1999         css_get_many(&memcg->css, nr_pages);
2000
2001         return 0;
2002
2003 done_restock:
2004         css_get_many(&memcg->css, batch);
2005         if (batch > nr_pages)
2006                 refill_stock(memcg, batch - nr_pages);
2007
2008         /*
2009          * If the hierarchy is above the normal consumption range, schedule
2010          * reclaim on returning to userland.  We can perform reclaim here
2011          * if __GFP_RECLAIM but let's always punt for simplicity and so that
2012          * GFP_KERNEL can consistently be used during reclaim.  @memcg is
2013          * not recorded as it most likely matches current's and won't
2014          * change in the meantime.  As high limit is checked again before
2015          * reclaim, the cost of mismatch is negligible.
2016          */
2017         do {
2018                 if (page_counter_read(&memcg->memory) > memcg->high) {
2019                         /* Don't bother a random interrupted task */
2020                         if (in_interrupt()) {
2021                                 schedule_work(&memcg->high_work);
2022                                 break;
2023                         }
2024                         current->memcg_nr_pages_over_high += batch;
2025                         set_notify_resume(current);
2026                         break;
2027                 }
2028         } while ((memcg = parent_mem_cgroup(memcg)));
2029
2030         return 0;
2031 }
2032
2033 static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
2034 {
2035         if (mem_cgroup_is_root(memcg))
2036                 return;
2037
2038         page_counter_uncharge(&memcg->memory, nr_pages);
2039         if (do_memsw_account())
2040                 page_counter_uncharge(&memcg->memsw, nr_pages);
2041
2042         css_put_many(&memcg->css, nr_pages);
2043 }
2044
2045 static void lock_page_lru(struct page *page, int *isolated)
2046 {
2047         struct zone *zone = page_zone(page);
2048
2049         spin_lock_irq(zone_lru_lock(zone));
2050         if (PageLRU(page)) {
2051                 struct lruvec *lruvec;
2052
2053                 lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
2054                 ClearPageLRU(page);
2055                 del_page_from_lru_list(page, lruvec, page_lru(page));
2056                 *isolated = 1;
2057         } else
2058                 *isolated = 0;
2059 }
2060
2061 static void unlock_page_lru(struct page *page, int isolated)
2062 {
2063         struct zone *zone = page_zone(page);
2064
2065         if (isolated) {
2066                 struct lruvec *lruvec;
2067
2068                 lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
2069                 VM_BUG_ON_PAGE(PageLRU(page), page);
2070                 SetPageLRU(page);
2071                 add_page_to_lru_list(page, lruvec, page_lru(page));
2072         }
2073         spin_unlock_irq(zone_lru_lock(zone));
2074 }
2075
2076 static void commit_charge(struct page *page, struct mem_cgroup *memcg,
2077                           bool lrucare)
2078 {
2079         int isolated;
2080
2081         VM_BUG_ON_PAGE(page->mem_cgroup, page);
2082
2083         /*
2084          * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2085          * may already be on some other mem_cgroup's LRU.  Take care of it.
2086          */
2087         if (lrucare)
2088                 lock_page_lru(page, &isolated);
2089
2090         /*
2091          * Nobody should be changing or seriously looking at
2092          * page->mem_cgroup at this point:
2093          *
2094          * - the page is uncharged
2095          *
2096          * - the page is off-LRU
2097          *
2098          * - an anonymous fault has exclusive page access, except for
2099          *   a locked page table
2100          *
2101          * - a page cache insertion, a swapin fault, or a migration
2102          *   have the page locked
2103          */
2104         page->mem_cgroup = memcg;
2105
2106         if (lrucare)
2107                 unlock_page_lru(page, isolated);
2108 }
2109
2110 #ifndef CONFIG_SLOB
2111 static int memcg_alloc_cache_id(void)
2112 {
2113         int id, size;
2114         int err;
2115
2116         id = ida_simple_get(&memcg_cache_ida,
2117                             0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
2118         if (id < 0)
2119                 return id;
2120
2121         if (id < memcg_nr_cache_ids)
2122                 return id;
2123
2124         /*
2125          * There's no space for the new id in memcg_caches arrays,
2126          * so we have to grow them.
2127          */
2128         down_write(&memcg_cache_ids_sem);
2129
2130         size = 2 * (id + 1);
2131         if (size < MEMCG_CACHES_MIN_SIZE)
2132                 size = MEMCG_CACHES_MIN_SIZE;
2133         else if (size > MEMCG_CACHES_MAX_SIZE)
2134                 size = MEMCG_CACHES_MAX_SIZE;
2135
2136         err = memcg_update_all_caches(size);
2137         if (!err)
2138                 err = memcg_update_all_list_lrus(size);
2139         if (!err)
2140                 memcg_nr_cache_ids = size;
2141
2142         up_write(&memcg_cache_ids_sem);
2143
2144         if (err) {
2145                 ida_simple_remove(&memcg_cache_ida, id);
2146                 return err;
2147         }
2148         return id;
2149 }
2150
2151 static void memcg_free_cache_id(int id)
2152 {
2153         ida_simple_remove(&memcg_cache_ida, id);
2154 }
2155
2156 struct memcg_kmem_cache_create_work {
2157         struct mem_cgroup *memcg;
2158         struct kmem_cache *cachep;
2159         struct work_struct work;
2160 };
2161
2162 static void memcg_kmem_cache_create_func(struct work_struct *w)
2163 {
2164         struct memcg_kmem_cache_create_work *cw =
2165                 container_of(w, struct memcg_kmem_cache_create_work, work);
2166         struct mem_cgroup *memcg = cw->memcg;
2167         struct kmem_cache *cachep = cw->cachep;
2168
2169         memcg_create_kmem_cache(memcg, cachep);
2170
2171         css_put(&memcg->css);
2172         kfree(cw);
2173 }
2174
2175 /*
2176  * Enqueue the creation of a per-memcg kmem_cache.
2177  */
2178 static void __memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
2179                                                struct kmem_cache *cachep)
2180 {
2181         struct memcg_kmem_cache_create_work *cw;
2182
2183         cw = kmalloc(sizeof(*cw), GFP_NOWAIT);
2184         if (!cw)
2185                 return;
2186
2187         css_get(&memcg->css);
2188
2189         cw->memcg = memcg;
2190         cw->cachep = cachep;
2191         INIT_WORK(&cw->work, memcg_kmem_cache_create_func);
2192
2193         queue_work(memcg_kmem_cache_wq, &cw->work);
2194 }
2195
2196 static void memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
2197                                              struct kmem_cache *cachep)
2198 {
2199         /*
2200          * We need to stop accounting when we kmalloc, because if the
2201          * corresponding kmalloc cache is not yet created, the first allocation
2202          * in __memcg_schedule_kmem_cache_create will recurse.
2203          *
2204          * However, it is better to enclose the whole function. Depending on
2205          * the debugging options enabled, INIT_WORK(), for instance, can
2206          * trigger an allocation. This too, will make us recurse. Because at
2207          * this point we can't allow ourselves back into memcg_kmem_get_cache,
2208          * the safest choice is to do it like this, wrapping the whole function.
2209          */
2210         current->memcg_kmem_skip_account = 1;
2211         __memcg_schedule_kmem_cache_create(memcg, cachep);
2212         current->memcg_kmem_skip_account = 0;
2213 }
2214
2215 static inline bool memcg_kmem_bypass(void)
2216 {
2217         if (in_interrupt() || !current->mm || (current->flags & PF_KTHREAD))
2218                 return true;
2219         return false;
2220 }
2221
2222 /**
2223  * memcg_kmem_get_cache: select the correct per-memcg cache for allocation
2224  * @cachep: the original global kmem cache
2225  *
2226  * Return the kmem_cache we're supposed to use for a slab allocation.
2227  * We try to use the current memcg's version of the cache.
2228  *
2229  * If the cache does not exist yet, if we are the first user of it, we
2230  * create it asynchronously in a workqueue and let the current allocation
2231  * go through with the original cache.
2232  *
2233  * This function takes a reference to the cache it returns to assure it
2234  * won't get destroyed while we are working with it. Once the caller is
2235  * done with it, memcg_kmem_put_cache() must be called to release the
2236  * reference.
2237  */
2238 struct kmem_cache *memcg_kmem_get_cache(struct kmem_cache *cachep)
2239 {
2240         struct mem_cgroup *memcg;
2241         struct kmem_cache *memcg_cachep;
2242         int kmemcg_id;
2243
2244         VM_BUG_ON(!is_root_cache(cachep));
2245
2246         if (memcg_kmem_bypass())
2247                 return cachep;
2248
2249         if (current->memcg_kmem_skip_account)
2250                 return cachep;
2251
2252         memcg = get_mem_cgroup_from_mm(current->mm);
2253         kmemcg_id = READ_ONCE(memcg->kmemcg_id);
2254         if (kmemcg_id < 0)
2255                 goto out;
2256
2257         memcg_cachep = cache_from_memcg_idx(cachep, kmemcg_id);
2258         if (likely(memcg_cachep))
2259                 return memcg_cachep;
2260
2261         /*
2262          * If we are in a safe context (can wait, and not in interrupt
2263          * context), we could be be predictable and return right away.
2264          * This would guarantee that the allocation being performed
2265          * already belongs in the new cache.
2266          *
2267          * However, there are some clashes that can arrive from locking.
2268          * For instance, because we acquire the slab_mutex while doing
2269          * memcg_create_kmem_cache, this means no further allocation
2270          * could happen with the slab_mutex held. So it's better to
2271          * defer everything.
2272          */
2273         memcg_schedule_kmem_cache_create(memcg, cachep);
2274 out:
2275         css_put(&memcg->css);
2276         return cachep;
2277 }
2278
2279 /**
2280  * memcg_kmem_put_cache: drop reference taken by memcg_kmem_get_cache
2281  * @cachep: the cache returned by memcg_kmem_get_cache
2282  */
2283 void memcg_kmem_put_cache(struct kmem_cache *cachep)
2284 {
2285         if (!is_root_cache(cachep))
2286                 css_put(&cachep->memcg_params.memcg->css);
2287 }
2288
2289 /**
2290  * memcg_kmem_charge: charge a kmem page
2291  * @page: page to charge
2292  * @gfp: reclaim mode
2293  * @order: allocation order
2294  * @memcg: memory cgroup to charge
2295  *
2296  * Returns 0 on success, an error code on failure.
2297  */
2298 int memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
2299                             struct mem_cgroup *memcg)
2300 {
2301         unsigned int nr_pages = 1 << order;
2302         struct page_counter *counter;
2303         int ret;
2304
2305         ret = try_charge(memcg, gfp, nr_pages);
2306         if (ret)
2307                 return ret;
2308
2309         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) &&
2310             !page_counter_try_charge(&memcg->kmem, nr_pages, &counter)) {
2311                 cancel_charge(memcg, nr_pages);
2312                 return -ENOMEM;
2313         }
2314
2315         page->mem_cgroup = memcg;
2316
2317         return 0;
2318 }
2319
2320 /**
2321  * memcg_kmem_charge: charge a kmem page to the current memory cgroup
2322  * @page: page to charge
2323  * @gfp: reclaim mode
2324  * @order: allocation order
2325  *
2326  * Returns 0 on success, an error code on failure.
2327  */
2328 int memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
2329 {
2330         struct mem_cgroup *memcg;
2331         int ret = 0;
2332
2333         if (memcg_kmem_bypass())
2334                 return 0;
2335
2336         memcg = get_mem_cgroup_from_mm(current->mm);
2337         if (!mem_cgroup_is_root(memcg)) {
2338                 ret = memcg_kmem_charge_memcg(page, gfp, order, memcg);
2339                 if (!ret)
2340                         __SetPageKmemcg(page);
2341         }
2342         css_put(&memcg->css);
2343         return ret;
2344 }
2345 /**
2346  * memcg_kmem_uncharge: uncharge a kmem page
2347  * @page: page to uncharge
2348  * @order: allocation order
2349  */
2350 void memcg_kmem_uncharge(struct page *page, int order)
2351 {
2352         struct mem_cgroup *memcg = page->mem_cgroup;
2353         unsigned int nr_pages = 1 << order;
2354
2355         if (!memcg)
2356                 return;
2357
2358         VM_BUG_ON_PAGE(mem_cgroup_is_root(memcg), page);
2359
2360         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
2361                 page_counter_uncharge(&memcg->kmem, nr_pages);
2362
2363         page_counter_uncharge(&memcg->memory, nr_pages);
2364         if (do_memsw_account())
2365                 page_counter_uncharge(&memcg->memsw, nr_pages);
2366
2367         page->mem_cgroup = NULL;
2368
2369         /* slab pages do not have PageKmemcg flag set */
2370         if (PageKmemcg(page))
2371                 __ClearPageKmemcg(page);
2372
2373         css_put_many(&memcg->css, nr_pages);
2374 }
2375 #endif /* !CONFIG_SLOB */
2376
2377 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
2378
2379 /*
2380  * Because tail pages are not marked as "used", set it. We're under
2381  * zone_lru_lock and migration entries setup in all page mappings.
2382  */
2383 void mem_cgroup_split_huge_fixup(struct page *head)
2384 {
2385         int i;
2386
2387         if (mem_cgroup_disabled())
2388                 return;
2389
2390         for (i = 1; i < HPAGE_PMD_NR; i++)
2391                 head[i].mem_cgroup = head->mem_cgroup;
2392
2393         __this_cpu_sub(head->mem_cgroup->stat->count[MEMCG_RSS_HUGE],
2394                        HPAGE_PMD_NR);
2395 }
2396 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
2397
2398 #ifdef CONFIG_MEMCG_SWAP
2399 static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,
2400                                        int nr_entries)
2401 {
2402         this_cpu_add(memcg->stat->count[MEMCG_SWAP], nr_entries);
2403 }
2404
2405 /**
2406  * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
2407  * @entry: swap entry to be moved
2408  * @from:  mem_cgroup which the entry is moved from
2409  * @to:  mem_cgroup which the entry is moved to
2410  *
2411  * It succeeds only when the swap_cgroup's record for this entry is the same
2412  * as the mem_cgroup's id of @from.
2413  *
2414  * Returns 0 on success, -EINVAL on failure.
2415  *
2416  * The caller must have charged to @to, IOW, called page_counter_charge() about
2417  * both res and memsw, and called css_get().
2418  */
2419 static int mem_cgroup_move_swap_account(swp_entry_t entry,
2420                                 struct mem_cgroup *from, struct mem_cgroup *to)
2421 {
2422         unsigned short old_id, new_id;
2423
2424         old_id = mem_cgroup_id(from);
2425         new_id = mem_cgroup_id(to);
2426
2427         if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
2428                 mem_cgroup_swap_statistics(from, -1);
2429                 mem_cgroup_swap_statistics(to, 1);
2430                 return 0;
2431         }
2432         return -EINVAL;
2433 }
2434 #else
2435 static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
2436                                 struct mem_cgroup *from, struct mem_cgroup *to)
2437 {
2438         return -EINVAL;
2439 }
2440 #endif
2441
2442 static DEFINE_MUTEX(memcg_limit_mutex);
2443
2444 static int mem_cgroup_resize_limit(struct mem_cgroup *memcg,
2445                                    unsigned long limit)
2446 {
2447         unsigned long curusage;
2448         unsigned long oldusage;
2449         bool enlarge = false;
2450         int retry_count;
2451         int ret;
2452
2453         /*
2454          * For keeping hierarchical_reclaim simple, how long we should retry
2455          * is depends on callers. We set our retry-count to be function
2456          * of # of children which we should visit in this loop.
2457          */
2458         retry_count = MEM_CGROUP_RECLAIM_RETRIES *
2459                       mem_cgroup_count_children(memcg);
2460
2461         oldusage = page_counter_read(&memcg->memory);
2462
2463         do {
2464                 if (signal_pending(current)) {
2465                         ret = -EINTR;
2466                         break;
2467                 }
2468
2469                 mutex_lock(&memcg_limit_mutex);
2470                 if (limit > memcg->memsw.limit) {
2471                         mutex_unlock(&memcg_limit_mutex);
2472                         ret = -EINVAL;
2473                         break;
2474                 }
2475                 if (limit > memcg->memory.limit)
2476                         enlarge = true;
2477                 ret = page_counter_limit(&memcg->memory, limit);
2478                 mutex_unlock(&memcg_limit_mutex);
2479
2480                 if (!ret)
2481                         break;
2482
2483                 try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL, true);
2484
2485                 curusage = page_counter_read(&memcg->memory);
2486                 /* Usage is reduced ? */
2487                 if (curusage >= oldusage)
2488                         retry_count--;
2489                 else
2490                         oldusage = curusage;
2491         } while (retry_count);
2492
2493         if (!ret && enlarge)
2494                 memcg_oom_recover(memcg);
2495
2496         return ret;
2497 }
2498
2499 static int mem_cgroup_resize_memsw_limit(struct mem_cgroup *memcg,
2500                                          unsigned long limit)
2501 {
2502         unsigned long curusage;
2503         unsigned long oldusage;
2504         bool enlarge = false;
2505         int retry_count;
2506         int ret;
2507
2508         /* see mem_cgroup_resize_res_limit */
2509         retry_count = MEM_CGROUP_RECLAIM_RETRIES *
2510                       mem_cgroup_count_children(memcg);
2511
2512         oldusage = page_counter_read(&memcg->memsw);
2513
2514         do {
2515                 if (signal_pending(current)) {
2516                         ret = -EINTR;
2517                         break;
2518                 }
2519
2520                 mutex_lock(&memcg_limit_mutex);
2521                 if (limit < memcg->memory.limit) {
2522                         mutex_unlock(&memcg_limit_mutex);
2523                         ret = -EINVAL;
2524                         break;
2525                 }
2526                 if (limit > memcg->memsw.limit)
2527                         enlarge = true;
2528                 ret = page_counter_limit(&memcg->memsw, limit);
2529                 mutex_unlock(&memcg_limit_mutex);
2530
2531                 if (!ret)
2532                         break;
2533
2534                 try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL, false);
2535
2536                 curusage = page_counter_read(&memcg->memsw);
2537                 /* Usage is reduced ? */
2538                 if (curusage >= oldusage)
2539                         retry_count--;
2540                 else
2541                         oldusage = curusage;
2542         } while (retry_count);
2543
2544         if (!ret && enlarge)
2545                 memcg_oom_recover(memcg);
2546
2547         return ret;
2548 }
2549
2550 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
2551                                             gfp_t gfp_mask,
2552                                             unsigned long *total_scanned)
2553 {
2554         unsigned long nr_reclaimed = 0;
2555         struct mem_cgroup_per_node *mz, *next_mz = NULL;
2556         unsigned long reclaimed;
2557         int loop = 0;
2558         struct mem_cgroup_tree_per_node *mctz;
2559         unsigned long excess;
2560         unsigned long nr_scanned;
2561
2562         if (order > 0)
2563                 return 0;
2564
2565         mctz = soft_limit_tree_node(pgdat->node_id);
2566
2567         /*
2568          * Do not even bother to check the largest node if the root
2569          * is empty. Do it lockless to prevent lock bouncing. Races
2570          * are acceptable as soft limit is best effort anyway.
2571          */
2572         if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root))
2573                 return 0;
2574
2575         /*
2576          * This loop can run a while, specially if mem_cgroup's continuously
2577          * keep exceeding their soft limit and putting the system under
2578          * pressure
2579          */
2580         do {
2581                 if (next_mz)
2582                         mz = next_mz;
2583                 else
2584                         mz = mem_cgroup_largest_soft_limit_node(mctz);
2585                 if (!mz)
2586                         break;
2587
2588                 nr_scanned = 0;
2589                 reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat,
2590                                                     gfp_mask, &nr_scanned);
2591                 nr_reclaimed += reclaimed;
2592                 *total_scanned += nr_scanned;
2593                 spin_lock_irq(&mctz->lock);
2594                 __mem_cgroup_remove_exceeded(mz, mctz);
2595
2596                 /*
2597                  * If we failed to reclaim anything from this memory cgroup
2598                  * it is time to move on to the next cgroup
2599                  */
2600                 next_mz = NULL;
2601                 if (!reclaimed)
2602                         next_mz = __mem_cgroup_largest_soft_limit_node(mctz);
2603
2604                 excess = soft_limit_excess(mz->memcg);
2605                 /*
2606                  * One school of thought says that we should not add
2607                  * back the node to the tree if reclaim returns 0.
2608                  * But our reclaim could return 0, simply because due
2609                  * to priority we are exposing a smaller subset of
2610                  * memory to reclaim from. Consider this as a longer
2611                  * term TODO.
2612                  */
2613                 /* If excess == 0, no tree ops */
2614                 __mem_cgroup_insert_exceeded(mz, mctz, excess);
2615                 spin_unlock_irq(&mctz->lock);
2616                 css_put(&mz->memcg->css);
2617                 loop++;
2618                 /*
2619                  * Could not reclaim anything and there are no more
2620                  * mem cgroups to try or we seem to be looping without
2621                  * reclaiming anything.
2622                  */
2623                 if (!nr_reclaimed &&
2624                         (next_mz == NULL ||
2625                         loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
2626                         break;
2627         } while (!nr_reclaimed);
2628         if (next_mz)
2629                 css_put(&next_mz->memcg->css);
2630         return nr_reclaimed;
2631 }
2632
2633 /*
2634  * Test whether @memcg has children, dead or alive.  Note that this
2635  * function doesn't care whether @memcg has use_hierarchy enabled and
2636  * returns %true if there are child csses according to the cgroup
2637  * hierarchy.  Testing use_hierarchy is the caller's responsiblity.
2638  */
2639 static inline bool memcg_has_children(struct mem_cgroup *memcg)
2640 {
2641         bool ret;
2642
2643         rcu_read_lock();
2644         ret = css_next_child(NULL, &memcg->css);
2645         rcu_read_unlock();
2646         return ret;
2647 }
2648
2649 /*
2650  * Reclaims as many pages from the given memcg as possible.
2651  *
2652  * Caller is responsible for holding css reference for memcg.
2653  */
2654 static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
2655 {
2656         int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
2657
2658         /* we call try-to-free pages for make this cgroup empty */
2659         lru_add_drain_all();
2660         /* try to free all pages in this cgroup */
2661         while (nr_retries && page_counter_read(&memcg->memory)) {
2662                 int progress;
2663
2664                 if (signal_pending(current))
2665                         return -EINTR;
2666
2667                 progress = try_to_free_mem_cgroup_pages(memcg, 1,
2668                                                         GFP_KERNEL, true);
2669                 if (!progress) {
2670                         nr_retries--;
2671                         /* maybe some writeback is necessary */
2672                         congestion_wait(BLK_RW_ASYNC, HZ/10);
2673                 }
2674
2675         }
2676
2677         return 0;
2678 }
2679
2680 static ssize_t mem_cgroup_force_empty_write(struct kernfs_open_file *of,
2681                                             char *buf, size_t nbytes,
2682                                             loff_t off)
2683 {
2684         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
2685
2686         if (mem_cgroup_is_root(memcg))
2687                 return -EINVAL;
2688         return mem_cgroup_force_empty(memcg) ?: nbytes;
2689 }
2690
2691 static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
2692                                      struct cftype *cft)
2693 {
2694         return mem_cgroup_from_css(css)->use_hierarchy;
2695 }
2696
2697 static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
2698                                       struct cftype *cft, u64 val)
2699 {
2700         int retval = 0;
2701         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
2702         struct mem_cgroup *parent_memcg = mem_cgroup_from_css(memcg->css.parent);
2703
2704         if (memcg->use_hierarchy == val)
2705                 return 0;
2706
2707         /*
2708          * If parent's use_hierarchy is set, we can't make any modifications
2709          * in the child subtrees. If it is unset, then the change can
2710          * occur, provided the current cgroup has no children.
2711          *
2712          * For the root cgroup, parent_mem is NULL, we allow value to be
2713          * set if there are no children.
2714          */
2715         if ((!parent_memcg || !parent_memcg->use_hierarchy) &&
2716                                 (val == 1 || val == 0)) {
2717                 if (!memcg_has_children(memcg))
2718                         memcg->use_hierarchy = val;
2719                 else
2720                         retval = -EBUSY;
2721         } else
2722                 retval = -EINVAL;
2723
2724         return retval;
2725 }
2726
2727 static void tree_stat(struct mem_cgroup *memcg, unsigned long *stat)
2728 {
2729         struct mem_cgroup *iter;
2730         int i;
2731
2732         memset(stat, 0, sizeof(*stat) * MEMCG_NR_STAT);
2733
2734         for_each_mem_cgroup_tree(iter, memcg) {
2735                 for (i = 0; i < MEMCG_NR_STAT; i++)
2736                         stat[i] += memcg_page_state(iter, i);
2737         }
2738 }
2739
2740 static void tree_events(struct mem_cgroup *memcg, unsigned long *events)
2741 {
2742         struct mem_cgroup *iter;
2743         int i;
2744
2745         memset(events, 0, sizeof(*events) * MEMCG_NR_EVENTS);
2746
2747         for_each_mem_cgroup_tree(iter, memcg) {
2748                 for (i = 0; i < MEMCG_NR_EVENTS; i++)
2749                         events[i] += memcg_sum_events(iter, i);
2750         }
2751 }
2752
2753 static unsigned long mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
2754 {
2755         unsigned long val = 0;
2756
2757         if (mem_cgroup_is_root(memcg)) {
2758                 struct mem_cgroup *iter;
2759
2760                 for_each_mem_cgroup_tree(iter, memcg) {
2761                         val += memcg_page_state(iter, MEMCG_CACHE);
2762                         val += memcg_page_state(iter, MEMCG_RSS);
2763                         if (swap)
2764                                 val += memcg_page_state(iter, MEMCG_SWAP);
2765                 }
2766         } else {
2767                 if (!swap)
2768                         val = page_counter_read(&memcg->memory);
2769                 else
2770                         val = page_counter_read(&memcg->memsw);
2771         }
2772         return val;
2773 }
2774
2775 enum {
2776         RES_USAGE,
2777         RES_LIMIT,
2778         RES_MAX_USAGE,
2779         RES_FAILCNT,
2780         RES_SOFT_LIMIT,
2781 };
2782
2783 static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
2784                                struct cftype *cft)
2785 {
2786         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
2787         struct page_counter *counter;
2788
2789         switch (MEMFILE_TYPE(cft->private)) {
2790         case _MEM:
2791                 counter = &memcg->memory;
2792                 break;
2793         case _MEMSWAP:
2794                 counter = &memcg->memsw;
2795                 break;
2796         case _KMEM:
2797                 counter = &memcg->kmem;
2798                 break;
2799         case _TCP:
2800                 counter = &memcg->tcpmem;
2801                 break;
2802         default:
2803                 BUG();
2804         }
2805
2806         switch (MEMFILE_ATTR(cft->private)) {
2807         case RES_USAGE:
2808                 if (counter == &memcg->memory)
2809                         return (u64)mem_cgroup_usage(memcg, false) * PAGE_SIZE;
2810                 if (counter == &memcg->memsw)
2811                         return (u64)mem_cgroup_usage(memcg, true) * PAGE_SIZE;
2812                 return (u64)page_counter_read(counter) * PAGE_SIZE;
2813         case RES_LIMIT:
2814                 return (u64)counter->limit * PAGE_SIZE;
2815         case RES_MAX_USAGE:
2816                 return (u64)counter->watermark * PAGE_SIZE;
2817         case RES_FAILCNT:
2818                 return counter->failcnt;
2819         case RES_SOFT_LIMIT:
2820                 return (u64)memcg->soft_limit * PAGE_SIZE;
2821         default:
2822                 BUG();
2823         }
2824 }
2825
2826 #ifndef CONFIG_SLOB
2827 static int memcg_online_kmem(struct mem_cgroup *memcg)
2828 {
2829         int memcg_id;
2830
2831         if (cgroup_memory_nokmem)
2832                 return 0;
2833
2834         BUG_ON(memcg->kmemcg_id >= 0);
2835         BUG_ON(memcg->kmem_state);
2836
2837         memcg_id = memcg_alloc_cache_id();
2838         if (memcg_id < 0)
2839                 return memcg_id;
2840
2841         static_branch_inc(&memcg_kmem_enabled_key);
2842         /*
2843          * A memory cgroup is considered kmem-online as soon as it gets
2844          * kmemcg_id. Setting the id after enabling static branching will
2845          * guarantee no one starts accounting before all call sites are
2846          * patched.
2847          */
2848         memcg->kmemcg_id = memcg_id;
2849         memcg->kmem_state = KMEM_ONLINE;
2850         INIT_LIST_HEAD(&memcg->kmem_caches);
2851
2852         return 0;
2853 }
2854
2855 static void memcg_offline_kmem(struct mem_cgroup *memcg)
2856 {
2857         struct cgroup_subsys_state *css;
2858         struct mem_cgroup *parent, *child;
2859         int kmemcg_id;
2860
2861         if (memcg->kmem_state != KMEM_ONLINE)
2862                 return;
2863         /*
2864          * Clear the online state before clearing memcg_caches array
2865          * entries. The slab_mutex in memcg_deactivate_kmem_caches()
2866          * guarantees that no cache will be created for this cgroup
2867          * after we are done (see memcg_create_kmem_cache()).
2868          */
2869         memcg->kmem_state = KMEM_ALLOCATED;
2870
2871         memcg_deactivate_kmem_caches(memcg);
2872
2873         kmemcg_id = memcg->kmemcg_id;
2874         BUG_ON(kmemcg_id < 0);
2875
2876         parent = parent_mem_cgroup(memcg);
2877         if (!parent)
2878                 parent = root_mem_cgroup;
2879
2880         /*
2881          * Change kmemcg_id of this cgroup and all its descendants to the
2882          * parent's id, and then move all entries from this cgroup's list_lrus
2883          * to ones of the parent. After we have finished, all list_lrus
2884          * corresponding to this cgroup are guaranteed to remain empty. The
2885          * ordering is imposed by list_lru_node->lock taken by
2886          * memcg_drain_all_list_lrus().
2887          */
2888         rcu_read_lock(); /* can be called from css_free w/o cgroup_mutex */
2889         css_for_each_descendant_pre(css, &memcg->css) {
2890                 child = mem_cgroup_from_css(css);
2891                 BUG_ON(child->kmemcg_id != kmemcg_id);
2892                 child->kmemcg_id = parent->kmemcg_id;
2893                 if (!memcg->use_hierarchy)
2894                         break;
2895         }
2896         rcu_read_unlock();
2897
2898         memcg_drain_all_list_lrus(kmemcg_id, parent->kmemcg_id);
2899
2900         memcg_free_cache_id(kmemcg_id);
2901 }
2902
2903 static void memcg_free_kmem(struct mem_cgroup *memcg)
2904 {
2905         /* css_alloc() failed, offlining didn't happen */
2906         if (unlikely(memcg->kmem_state == KMEM_ONLINE))
2907                 memcg_offline_kmem(memcg);
2908
2909         if (memcg->kmem_state == KMEM_ALLOCATED) {
2910                 memcg_destroy_kmem_caches(memcg);
2911                 static_branch_dec(&memcg_kmem_enabled_key);
2912                 WARN_ON(page_counter_read(&memcg->kmem));
2913         }
2914 }
2915 #else
2916 static int memcg_online_kmem(struct mem_cgroup *memcg)
2917 {
2918         return 0;
2919 }
2920 static void memcg_offline_kmem(struct mem_cgroup *memcg)
2921 {
2922 }
2923 static void memcg_free_kmem(struct mem_cgroup *memcg)
2924 {
2925 }
2926 #endif /* !CONFIG_SLOB */
2927
2928 static int memcg_update_kmem_limit(struct mem_cgroup *memcg,
2929                                    unsigned long limit)
2930 {
2931         int ret;
2932
2933         mutex_lock(&memcg_limit_mutex);
2934         ret = page_counter_limit(&memcg->kmem, limit);
2935         mutex_unlock(&memcg_limit_mutex);
2936         return ret;
2937 }
2938
2939 static int memcg_update_tcp_limit(struct mem_cgroup *memcg, unsigned long limit)
2940 {
2941         int ret;
2942
2943         mutex_lock(&memcg_limit_mutex);
2944
2945         ret = page_counter_limit(&memcg->tcpmem, limit);
2946         if (ret)
2947                 goto out;
2948
2949         if (!memcg->tcpmem_active) {
2950                 /*
2951                  * The active flag needs to be written after the static_key
2952                  * update. This is what guarantees that the socket activation
2953                  * function is the last one to run. See mem_cgroup_sk_alloc()
2954                  * for details, and note that we don't mark any socket as
2955                  * belonging to this memcg until that flag is up.
2956                  *
2957                  * We need to do this, because static_keys will span multiple
2958                  * sites, but we can't control their order. If we mark a socket
2959                  * as accounted, but the accounting functions are not patched in
2960                  * yet, we'll lose accounting.
2961                  *
2962                  * We never race with the readers in mem_cgroup_sk_alloc(),
2963                  * because when this value change, the code to process it is not
2964                  * patched in yet.
2965                  */
2966                 static_branch_inc(&memcg_sockets_enabled_key);
2967                 memcg->tcpmem_active = true;
2968         }
2969 out:
2970         mutex_unlock(&memcg_limit_mutex);
2971         return ret;
2972 }
2973
2974 /*
2975  * The user of this function is...
2976  * RES_LIMIT.
2977  */
2978 static ssize_t mem_cgroup_write(struct kernfs_open_file *of,
2979                                 char *buf, size_t nbytes, loff_t off)
2980 {
2981         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
2982         unsigned long nr_pages;
2983         int ret;
2984
2985         buf = strstrip(buf);
2986         ret = page_counter_memparse(buf, "-1", &nr_pages);
2987         if (ret)
2988                 return ret;
2989
2990         switch (MEMFILE_ATTR(of_cft(of)->private)) {
2991         case RES_LIMIT:
2992                 if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
2993                         ret = -EINVAL;
2994                         break;
2995                 }
2996                 switch (MEMFILE_TYPE(of_cft(of)->private)) {
2997                 case _MEM:
2998                         ret = mem_cgroup_resize_limit(memcg, nr_pages);
2999                         break;
3000                 case _MEMSWAP:
3001                         ret = mem_cgroup_resize_memsw_limit(memcg, nr_pages);
3002                         break;
3003                 case _KMEM:
3004                         ret = memcg_update_kmem_limit(memcg, nr_pages);
3005                         break;
3006                 case _TCP:
3007                         ret = memcg_update_tcp_limit(memcg, nr_pages);
3008                         break;
3009                 }
3010                 break;
3011         case RES_SOFT_LIMIT:
3012                 memcg->soft_limit = nr_pages;
3013                 ret = 0;
3014                 break;
3015         }
3016         return ret ?: nbytes;
3017 }
3018
3019 static ssize_t mem_cgroup_reset(struct kernfs_open_file *of, char *buf,
3020                                 size_t nbytes, loff_t off)
3021 {
3022         struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3023         struct page_counter *counter;
3024
3025         switch (MEMFILE_TYPE(of_cft(of)->private)) {
3026         case _MEM:
3027                 counter = &memcg->memory;
3028                 break;
3029         case _MEMSWAP:
3030                 counter = &memcg->memsw;
3031                 break;
3032         case _KMEM:
3033                 counter = &memcg->kmem;
3034                 break;
3035         case _TCP:
3036                 counter = &memcg->tcpmem;
3037                 break;
3038         default:
3039                 BUG();
3040         }
3041
3042         switch (MEMFILE_ATTR(of_cft(of)->private)) {
3043         case RES_MAX_USAGE:
3044                 page_counter_reset_watermark(counter);
3045                 break;
3046         case RES_FAILCNT:
3047                 counter->failcnt = 0;
3048                 break;
3049         default:
3050                 BUG();
3051         }
3052
3053         return nbytes;
3054 }
3055
3056 static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
3057                                         struct cftype *cft)
3058 {
3059         return mem_cgroup_from_css(css)->move_charge_at_immigrate;
3060 }
3061
3062 #ifdef CONFIG_MMU
3063 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3064                                         struct cftype *cft, u64 val)
3065 {
3066         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3067
3068         if (val & ~MOVE_MASK)
3069                 return -EINVAL;
3070
3071         /*
3072          * No kind of locking is needed in here, because ->can_attach() will
3073          * check this value once in the beginning of the process, and then carry
3074          * on with stale data. This means that changes to this value will only
3075          * affect task migrations starting after the change.
3076          */
3077         memcg->move_charge_at_immigrate = val;
3078         return 0;
3079 }
3080 #else
3081 static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3082                                         struct cftype *cft, u64 val)
3083 {
3084         return -ENOSYS;
3085 }
3086 #endif
3087
3088 #ifdef CONFIG_NUMA
3089 static int memcg_numa_stat_show(struct seq_file *m, void *v)
3090 {
3091         struct numa_stat {
3092                 const char *name;
3093                 unsigned int lru_mask;
3094         };
3095
3096         static const struct numa_stat stats[] = {
3097                 { "total", LRU_ALL },
3098                 { "file", LRU_ALL_FILE },
3099                 { "anon", LRU_ALL_ANON },
3100                 { "unevictable", BIT(LRU_UNEVICTABLE) },
3101         };
3102         const struct numa_stat *stat;
3103         int nid;
3104         unsigned long nr;
3105         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
3106
3107         for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
3108                 nr = mem_cgroup_nr_lru_pages(memcg, stat->lru_mask);
3109                 seq_printf(m, "%s=%lu", stat->name, nr);
3110                 for_each_node_state(nid, N_MEMORY) {
3111                         nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
3112                                                           stat->lru_mask);
3113                         seq_printf(m, " N%d=%lu", nid, nr);
3114                 }
3115                 seq_putc(m, '\n');
3116         }
3117
3118         for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
3119                 struct mem_cgroup *iter;
3120
3121                 nr = 0;
3122                 for_each_mem_cgroup_tree(iter, memcg)
3123                         nr += mem_cgroup_nr_lru_pages(iter, stat->lru_mask);
3124                 seq_printf(m, "hierarchical_%s=%lu", stat->name, nr);
3125                 for_each_node_state(nid, N_MEMORY) {
3126                         nr = 0;
3127                         for_each_mem_cgroup_tree(iter, memcg)
3128                                 nr += mem_cgroup_node_nr_lru_pages(
3129                                         iter, nid, stat->lru_mask);
3130                         seq_printf(m, " N%d=%lu", nid, nr);
3131                 }
3132                 seq_putc(m, '\n');
3133         }
3134
3135         return 0;
3136 }
3137 #endif /* CONFIG_NUMA */
3138
3139 /* Universal VM events cgroup1 shows, original sort order */
3140 unsigned int memcg1_events[] = {
3141         PGPGIN,
3142         PGPGOUT,
3143         PGFAULT,
3144         PGMAJFAULT,
3145 };
3146
3147 static const char *const memcg1_event_names[] = {
3148         "pgpgin",
3149         "pgpgout",
3150         "pgfault",
3151         "pgmajfault",
3152 };
3153
3154 static int memcg_stat_show(struct seq_file *m, void *v)
3155 {
3156         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
3157         unsigned long memory, memsw;
3158         struct mem_cgroup *mi;
3159         unsigned int i;
3160
3161         BUILD_BUG_ON(ARRAY_SIZE(memcg1_stat_names) != ARRAY_SIZE(memcg1_stats));
3162         BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_lru_names) != NR_LRU_LISTS);
3163
3164         for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
3165                 if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
3166                         continue;
3167                 seq_printf(m, "%s %lu\n", memcg1_stat_names[i],
3168                            memcg_page_state(memcg, memcg1_stats[i]) *
3169                            PAGE_SIZE);
3170         }
3171
3172         for (i = 0; i < ARRAY_SIZE(memcg1_events); i++)
3173                 seq_printf(m, "%s %lu\n", memcg1_event_names[i],
3174                            memcg_sum_events(memcg, memcg1_events[i]));
3175
3176         for (i = 0; i < NR_LRU_LISTS; i++)
3177                 seq_printf(m, "%s %lu\n", mem_cgroup_lru_names[i],
3178                            mem_cgroup_nr_lru_pages(memcg, BIT(i)) * PAGE_SIZE);
3179
3180         /* Hierarchical information */
3181         memory = memsw = PAGE_COUNTER_MAX;
3182         for (mi = memcg; mi; mi = parent_mem_cgroup(mi)) {
3183                 memory = min(memory, mi->memory.limit);
3184                 memsw = min(memsw, mi->memsw.limit);
3185         }
3186         seq_printf(m, "hierarchical_memory_limit %llu\n",
3187                    (u64)memory * PAGE_SIZE);
3188         if (do_memsw_account())
3189                 seq_printf(m, "hierarchical_memsw_limit %llu\n",
3190                            (u64)memsw * PAGE_SIZE);
3191
3192         for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
3193                 unsigned long long val = 0;
3194
3195                 if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
3196                         continue;
3197                 for_each_mem_cgroup_tree(mi, memcg)
3198                         val += memcg_page_state(mi, memcg1_stats[i]) *
3199                         PAGE_SIZE;
3200                 seq_printf(m, "total_%s %llu\n", memcg1_stat_names[i], val);
3201         }
3202
3203         for (i = 0; i < ARRAY_SIZE(memcg1_events); i++) {
3204                 unsigned long long val = 0;
3205
3206                 for_each_mem_cgroup_tree(mi, memcg)
3207                         val += memcg_sum_events(mi, memcg1_events[i]);
3208                 seq_printf(m, "total_%s %llu\n", memcg1_event_names[i], val);
3209         }
3210
3211         for (i = 0; i < NR_LRU_LISTS; i++) {
3212                 unsigned long long val = 0;
3213
3214                 for_each_mem_cgroup_tree(mi, memcg)
3215                         val += mem_cgroup_nr_lru_pages(mi, BIT(i)) * PAGE_SIZE;
3216                 seq_printf(m, "total_%s %llu\n", mem_cgroup_lru_names[i], val);
3217         }
3218
3219 #ifdef CONFIG_DEBUG_VM
3220         {
3221                 pg_data_t *pgdat;
3222                 struct mem_cgroup_per_node *mz;
3223                 struct zone_reclaim_stat *rstat;
3224                 unsigned long recent_rotated[2] = {0, 0};
3225                 unsigned long recent_scanned[2] = {0, 0};
3226
3227                 for_each_online_pgdat(pgdat) {
3228                         mz = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
3229                         rstat = &mz->lruvec.reclaim_stat;
3230
3231                         recent_rotated[0] += rstat->recent_rotated[0];
3232                         recent_rotated[1] += rstat->recent_rotated[1];
3233                         recent_scanned[0] += rstat->recent_scanned[0];
3234                         recent_scanned[1] += rstat->recent_scanned[1];
3235                 }
3236                 seq_printf(m, "recent_rotated_anon %lu\n", recent_rotated[0]);
3237                 seq_printf(m, "recent_rotated_file %lu\n", recent_rotated[1]);
3238                 seq_printf(m, "recent_scanned_anon %lu\n", recent_scanned[0]);
3239                 seq_printf(m, "recent_scanned_file %lu\n", recent_scanned[1]);
3240         }
3241 #endif
3242
3243         return 0;
3244 }
3245
3246 static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
3247                                       struct cftype *cft)
3248 {
3249         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3250
3251         return mem_cgroup_swappiness(memcg);
3252 }
3253
3254 static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
3255                                        struct cftype *cft, u64 val)
3256 {
3257         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3258
3259         if (val > 100)
3260                 return -EINVAL;
3261
3262         if (css->parent)
3263                 memcg->swappiness = val;
3264         else
3265                 vm_swappiness = val;
3266
3267         return 0;
3268 }
3269
3270 static void __mem_cgroup_threshold(struct mem_cgroup *memcg, bool swap)
3271 {
3272         struct mem_cgroup_threshold_ary *t;
3273         unsigned long usage;
3274         int i;
3275
3276         rcu_read_lock();
3277         if (!swap)
3278                 t = rcu_dereference(memcg->thresholds.primary);
3279         else
3280                 t = rcu_dereference(memcg->memsw_thresholds.primary);
3281
3282         if (!t)
3283                 goto unlock;
3284
3285         usage = mem_cgroup_usage(memcg, swap);
3286
3287         /*
3288          * current_threshold points to threshold just below or equal to usage.
3289          * If it's not true, a threshold was crossed after last
3290          * call of __mem_cgroup_threshold().
3291          */
3292         i = t->current_threshold;
3293
3294         /*
3295          * Iterate backward over array of thresholds starting from
3296          * current_threshold and check if a threshold is crossed.
3297          * If none of thresholds below usage is crossed, we read
3298          * only one element of the array here.
3299          */
3300         for (; i >= 0 && unlikely(t->entries[i].threshold > usage); i--)
3301                 eventfd_signal(t->entries[i].eventfd, 1);
3302
3303         /* i = current_threshold + 1 */
3304         i++;
3305
3306         /*
3307          * Iterate forward over array of thresholds starting from
3308          * current_threshold+1 and check if a threshold is crossed.
3309          * If none of thresholds above usage is crossed, we read
3310          * only one element of the array here.
3311          */
3312         for (; i < t->size && unlikely(t->entries[i].threshold <= usage); i++)
3313                 eventfd_signal(t->entries[i].eventfd, 1);
3314
3315         /* Update current_threshold */
3316         t->current_threshold = i - 1;
3317 unlock:
3318         rcu_read_unlock();
3319 }
3320
3321 static void mem_cgroup_threshold(struct mem_cgroup *memcg)
3322 {
3323         while (memcg) {
3324                 __mem_cgroup_threshold(memcg, false);
3325                 if (do_memsw_account())
3326                         __mem_cgroup_threshold(memcg, true);
3327
3328                 memcg = parent_mem_cgroup(memcg);
3329         }
3330 }
3331
3332 static int compare_thresholds(const void *a, const void *b)
3333 {
3334         const struct mem_cgroup_threshold *_a = a;
3335         const struct mem_cgroup_threshold *_b = b;
3336
3337         if (_a->threshold > _b->threshold)
3338                 return 1;
3339
3340         if (_a->threshold < _b->threshold)
3341                 return -1;
3342
3343         return 0;
3344 }
3345
3346 static int mem_cgroup_oom_notify_cb(struct mem_cgroup *memcg)
3347 {
3348         struct mem_cgroup_eventfd_list *ev;
3349
3350         spin_lock(&memcg_oom_lock);
3351
3352         list_for_each_entry(ev, &memcg->oom_notify, list)
3353                 eventfd_signal(ev->eventfd, 1);
3354
3355         spin_unlock(&memcg_oom_lock);
3356         return 0;
3357 }
3358
3359 static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
3360 {
3361         struct mem_cgroup *iter;
3362
3363         for_each_mem_cgroup_tree(iter, memcg)
3364                 mem_cgroup_oom_notify_cb(iter);
3365 }
3366
3367 static int __mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
3368         struct eventfd_ctx *eventfd, const char *args, enum res_type type)
3369 {
3370         struct mem_cgroup_thresholds *thresholds;
3371         struct mem_cgroup_threshold_ary *new;
3372         unsigned long threshold;
3373         unsigned long usage;
3374         int i, size, ret;
3375
3376         ret = page_counter_memparse(args, "-1", &threshold);
3377         if (ret)
3378                 return ret;
3379
3380         mutex_lock(&memcg->thresholds_lock);
3381
3382         if (type == _MEM) {
3383                 thresholds = &memcg->thresholds;
3384                 usage = mem_cgroup_usage(memcg, false);
3385         } else if (type == _MEMSWAP) {
3386                 thresholds = &memcg->memsw_thresholds;
3387                 usage = mem_cgroup_usage(memcg, true);
3388         } else
3389                 BUG();
3390
3391         /* Check if a threshold crossed before adding a new one */
3392         if (thresholds->primary)
3393                 __mem_cgroup_threshold(memcg, type == _MEMSWAP);
3394
3395         size = thresholds->primary ? thresholds->primary->size + 1 : 1;
3396
3397         /* Allocate memory for new array of thresholds */
3398         new = kmalloc(sizeof(*new) + size * sizeof(struct mem_cgroup_threshold),
3399                         GFP_KERNEL);
3400         if (!new) {
3401                 ret = -ENOMEM;
3402                 goto unlock;
3403         }
3404         new->size = size;
3405
3406         /* Copy thresholds (if any) to new array */
3407         if (thresholds->primary) {
3408                 memcpy(new->entries, thresholds->primary->entries, (size - 1) *
3409                                 sizeof(struct mem_cgroup_threshold));
3410         }
3411
3412         /* Add new threshold */
3413         new->entries[size - 1].eventfd = eventfd;
3414         new->entries[size - 1].threshold = threshold;
3415
3416         /* Sort thresholds. Registering of new threshold isn't time-critical */
3417         sort(new->entries, size, sizeof(struct mem_cgroup_threshold),
3418                         compare_thresholds, NULL);
3419
3420         /* Find current threshold */
3421         new->current_threshold = -1;
3422         for (i = 0; i < size; i++) {
3423                 if (new->entries[i].threshold <= usage) {
3424                         /*
3425                          * new->current_threshold will not be used until
3426                          * rcu_assign_pointer(), so it's safe to increment
3427                          * it here.
3428                          */
3429                         ++new->current_threshold;
3430                 } else
3431                         break;
3432         }
3433
3434         /* Free old spare buffer and save old primary buffer as spare */
3435         kfree(thresholds->spare);
3436         thresholds->spare = thresholds->primary;
3437
3438         rcu_assign_pointer(thresholds->primary, new);
3439
3440         /* To be sure that nobody uses thresholds */
3441         synchronize_rcu();
3442
3443 unlock:
3444         mutex_unlock(&memcg->thresholds_lock);
3445
3446         return ret;
3447 }
3448
3449 static int mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
3450         struct eventfd_ctx *eventfd, const char *args)
3451 {
3452         return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEM);
3453 }
3454
3455 static int memsw_cgroup_usage_register_event(struct mem_cgroup *memcg,
3456         struct eventfd_ctx *eventfd, const char *args)
3457 {
3458         return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEMSWAP);
3459 }
3460
3461 static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
3462         struct eventfd_ctx *eventfd, enum res_type type)
3463 {
3464         struct mem_cgroup_thresholds *thresholds;
3465         struct mem_cgroup_threshold_ary *new;
3466         unsigned long usage;
3467         int i, j, size;
3468
3469         mutex_lock(&memcg->thresholds_lock);
3470
3471         if (type == _MEM) {
3472                 thresholds = &memcg->thresholds;
3473                 usage = mem_cgroup_usage(memcg, false);
3474         } else if (type == _MEMSWAP) {
3475                 thresholds = &memcg->memsw_thresholds;
3476                 usage = mem_cgroup_usage(memcg, true);
3477         } else
3478                 BUG();
3479
3480         if (!thresholds->primary)
3481                 goto unlock;
3482
3483         /* Check if a threshold crossed before removing */
3484         __mem_cgroup_threshold(memcg, type == _MEMSWAP);
3485
3486         /* Calculate new number of threshold */
3487         size = 0;
3488         for (i = 0; i < thresholds->primary->size; i++) {
3489                 if (thresholds->primary->entries[i].eventfd != eventfd)
3490                         size++;
3491         }
3492
3493         new = thresholds->spare;
3494
3495         /* Set thresholds array to NULL if we don't have thresholds */
3496         if (!size) {
3497                 kfree(new);
3498                 new = NULL;
3499                 goto swap_buffers;
3500         }
3501
3502         new->size = size;
3503
3504         /* Copy thresholds and find current threshold */
3505         new->current_threshold = -1;
3506         for (i = 0, j = 0; i < thresholds->primary->size; i++) {
3507                 if (thresholds->primary->entries[i].eventfd == eventfd)
3508                         continue;
3509
3510                 new->entries[j] = thresholds->primary->entries[i];
3511                 if (new->entries[j].threshold <= usage) {
3512                         /*
3513                          * new->current_threshold will not be used
3514                          * until rcu_assign_pointer(), so it's safe to increment
3515                          * it here.
3516                          */
3517                         ++new->current_threshold;
3518                 }
3519                 j++;
3520         }
3521
3522 swap_buffers:
3523         /* Swap primary and spare array */
3524         thresholds->spare = thresholds->primary;
3525
3526         rcu_assign_pointer(thresholds->primary, new);
3527
3528         /* To be sure that nobody uses thresholds */
3529         synchronize_rcu();
3530
3531         /* If all events are unregistered, free the spare array */
3532         if (!new) {
3533                 kfree(thresholds->spare);
3534                 thresholds->spare = NULL;
3535         }
3536 unlock:
3537         mutex_unlock(&memcg->thresholds_lock);
3538 }
3539
3540 static void mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
3541         struct eventfd_ctx *eventfd)
3542 {
3543         return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEM);
3544 }
3545
3546 static void memsw_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
3547         struct eventfd_ctx *eventfd)
3548 {
3549         return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEMSWAP);
3550 }
3551
3552 static int mem_cgroup_oom_register_event(struct mem_cgroup *memcg,
3553         struct eventfd_ctx *eventfd, const char *args)
3554 {
3555         struct mem_cgroup_eventfd_list *event;
3556
3557         event = kmalloc(sizeof(*event), GFP_KERNEL);
3558         if (!event)
3559                 return -ENOMEM;
3560
3561         spin_lock(&memcg_oom_lock);
3562
3563         event->eventfd = eventfd;
3564         list_add(&event->list, &memcg->oom_notify);
3565
3566         /* already in OOM ? */
3567         if (memcg->under_oom)
3568                 eventfd_signal(eventfd, 1);
3569         spin_unlock(&memcg_oom_lock);
3570
3571         return 0;
3572 }
3573
3574 static void mem_cgroup_oom_unregister_event(struct mem_cgroup *memcg,
3575         struct eventfd_ctx *eventfd)
3576 {
3577         struct mem_cgroup_eventfd_list *ev, *tmp;
3578
3579         spin_lock(&memcg_oom_lock);
3580
3581         list_for_each_entry_safe(ev, tmp, &memcg->oom_notify, list) {
3582                 if (ev->eventfd == eventfd) {
3583                         list_del(&ev->list);
3584                         kfree(ev);
3585                 }
3586         }
3587
3588         spin_unlock(&memcg_oom_lock);
3589 }
3590
3591 static int mem_cgroup_oom_control_read(struct seq_file *sf, void *v)
3592 {
3593         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(sf));
3594
3595         seq_printf(sf, "oom_kill_disable %d\n", memcg->oom_kill_disable);
3596         seq_printf(sf, "under_oom %d\n", (bool)memcg->under_oom);
3597         seq_printf(sf, "oom_kill %lu\n", memcg_sum_events(memcg, OOM_KILL));
3598         return 0;
3599 }
3600
3601 static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
3602         struct cftype *cft, u64 val)
3603 {
3604         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3605
3606         /* cannot set to root cgroup and only 0 and 1 are allowed */
3607         if (!css->parent || !((val == 0) || (val == 1)))
3608                 return -EINVAL;
3609
3610         memcg->oom_kill_disable = val;
3611         if (!val)
3612                 memcg_oom_recover(memcg);
3613
3614         return 0;
3615 }
3616
3617 #ifdef CONFIG_CGROUP_WRITEBACK
3618
3619 struct list_head *mem_cgroup_cgwb_list(struct mem_cgroup *memcg)
3620 {
3621         return &memcg->cgwb_list;
3622 }
3623
3624 static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
3625 {
3626         return wb_domain_init(&memcg->cgwb_domain, gfp);
3627 }
3628
3629 static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
3630 {
3631         wb_domain_exit(&memcg->cgwb_domain);
3632 }
3633
3634 static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
3635 {
3636         wb_domain_size_changed(&memcg->cgwb_domain);
3637 }
3638
3639 struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
3640 {
3641         struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
3642
3643         if (!memcg->css.parent)
3644                 return NULL;
3645
3646         return &memcg->cgwb_domain;
3647 }
3648
3649 /**
3650  * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg
3651  * @wb: bdi_writeback in question
3652  * @pfilepages: out parameter for number of file pages
3653  * @pheadroom: out parameter for number of allocatable pages according to memcg
3654  * @pdirty: out parameter for number of dirty pages
3655  * @pwriteback: out parameter for number of pages under writeback
3656  *
3657  * Determine the numbers of file, headroom, dirty, and writeback pages in
3658  * @wb's memcg.  File, dirty and writeback are self-explanatory.  Headroom
3659  * is a bit more involved.
3660  *
3661  * A memcg's headroom is "min(max, high) - used".  In the hierarchy, the
3662  * headroom is calculated as the lowest headroom of itself and the
3663  * ancestors.  Note that this doesn't consider the actual amount of
3664  * available memory in the system.  The caller should further cap
3665  * *@pheadroom accordingly.
3666  */
3667 void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
3668                          unsigned long *pheadroom, unsigned long *pdirty,
3669                          unsigned long *pwriteback)
3670 {
3671         struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
3672         struct mem_cgroup *parent;
3673
3674         *pdirty = memcg_page_state(memcg, NR_FILE_DIRTY);
3675
3676         /* this should eventually include NR_UNSTABLE_NFS */
3677         *pwriteback = memcg_page_state(memcg, NR_WRITEBACK);
3678         *pfilepages = mem_cgroup_nr_lru_pages(memcg, (1 << LRU_INACTIVE_FILE) |
3679                                                      (1 << LRU_ACTIVE_FILE));
3680         *pheadroom = PAGE_COUNTER_MAX;
3681
3682         while ((parent = parent_mem_cgroup(memcg))) {
3683                 unsigned long ceiling = min(memcg->memory.limit, memcg->high);
3684                 unsigned long used = page_counter_read(&memcg->memory);
3685
3686                 *pheadroom = min(*pheadroom, ceiling - min(ceiling, used));
3687                 memcg = parent;
3688         }
3689 }
3690
3691 #else   /* CONFIG_CGROUP_WRITEBACK */
3692
3693 static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
3694 {
3695         return 0;
3696 }
3697
3698 static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
3699 {
3700 }
3701
3702 static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
3703 {
3704 }
3705
3706 #endif  /* CONFIG_CGROUP_WRITEBACK */
3707
3708 /*
3709  * DO NOT USE IN NEW FILES.
3710  *
3711  * "cgroup.event_control" implementation.
3712  *
3713  * This is way over-engineered.  It tries to support fully configurable
3714  * events for each user.  Such level of flexibility is completely
3715  * unnecessary especially in the light of the planned unified hierarchy.
3716  *
3717  * Please deprecate this and replace with something simpler if at all
3718  * possible.
3719  */
3720
3721 /*
3722  * Unregister event and free resources.
3723  *
3724  * Gets called from workqueue.
3725  */
3726 static void memcg_event_remove(struct work_struct *work)
3727 {
3728         struct mem_cgroup_event *event =
3729                 container_of(work, struct mem_cgroup_event, remove);
3730         struct mem_cgroup *memcg = event->memcg;
3731
3732         remove_wait_queue(event->wqh, &event->wait);
3733
3734         event->unregister_event(memcg, event->eventfd);
3735
3736         /* Notify userspace the event is going away. */
3737         eventfd_signal(event->eventfd, 1);
3738
3739         eventfd_ctx_put(event->eventfd);
3740         kfree(event);
3741         css_put(&memcg->css);
3742 }
3743
3744 /*
3745  * Gets called on POLLHUP on eventfd when user closes it.
3746  *
3747  * Called with wqh->lock held and interrupts disabled.
3748  */
3749 static int memcg_event_wake(wait_queue_entry_t *wait, unsigned mode,
3750                             int sync, void *key)
3751 {
3752         struct mem_cgroup_event *event =
3753                 container_of(wait, struct mem_cgroup_event, wait);
3754         struct mem_cgroup *memcg = event->memcg;
3755         unsigned long flags = (unsigned long)key;
3756
3757         if (flags & POLLHUP) {
3758                 /*
3759                  * If the event has been detached at cgroup removal, we
3760                  * can simply return knowing the other side will cleanup
3761                  * for us.
3762                  *
3763                  * We can't race against event freeing since the other
3764                  * side will require wqh->lock via remove_wait_queue(),
3765                  * which we hold.
3766                  */
3767                 spin_lock(&memcg->event_list_lock);
3768                 if (!list_empty(&event->list)) {
3769                         list_del_init(&event->list);
3770                         /*
3771                          * We are in atomic context, but cgroup_event_remove()
3772                          * may sleep, so we have to call it in workqueue.
3773                          */
3774                         schedule_work(&event->remove);
3775                 }
3776                 spin_unlock(&memcg->event_list_lock);
3777         }
3778
3779         return 0;
3780 }
3781
3782 static void memcg_event_ptable_queue_proc(struct file *file,
3783                 wait_queue_head_t *wqh, poll_table *pt)
3784 {
3785         struct mem_cgroup_event *event =
3786                 container_of(pt, struct mem_cgroup_event, pt);
3787
3788         event->wqh = wqh;
3789         add_wait_queue(wqh, &event->wait);
3790 }
3791
3792 /*
3793  * DO NOT USE IN NEW FILES.
3794  *
3795  * Parse input and register new cgroup event handler.
3796  *
3797  * Input must be in format '<event_fd> <control_fd> <args>'.
3798  * Interpretation of args is defined by control file implementation.
3799  */
3800 static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
3801                                          char *buf, size_t nbytes, loff_t off)
3802 {
3803         struct cgroup_subsys_state *css = of_css(of);
3804         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3805         struct mem_cgroup_event *event;
3806         struct cgroup_subsys_state *cfile_css;
3807         unsigned int efd, cfd;
3808         struct fd efile;
3809         struct fd cfile;
3810         const char *name;
3811         char *endp;
3812         int ret;
3813
3814         buf = strstrip(buf);
3815
3816         efd = simple_strtoul(buf, &endp, 10);
3817         if (*endp != ' ')
3818                 return -EINVAL;
3819         buf = endp + 1;
3820
3821         cfd = simple_strtoul(buf, &endp, 10);
3822         if ((*endp != ' ') && (*endp != '\0'))
3823                 return -EINVAL;
3824         buf = endp + 1;
3825
3826         event = kzalloc(sizeof(*event), GFP_KERNEL);
3827         if (!event)
3828                 return -ENOMEM;
3829
3830         event->memcg = memcg;
3831         INIT_LIST_HEAD(&event->list);
3832         init_poll_funcptr(&event->pt, memcg_event_ptable_queue_proc);
3833         init_waitqueue_func_entry(&event->wait, memcg_event_wake);
3834         INIT_WORK(&event->remove, memcg_event_remove);
3835
3836         efile = fdget(efd);
3837         if (!efile.file) {
3838                 ret = -EBADF;
3839                 goto out_kfree;
3840         }
3841
3842         event->eventfd = eventfd_ctx_fileget(efile.file);
3843         if (IS_ERR(event->eventfd)) {
3844                 ret = PTR_ERR(event->eventfd);
3845                 goto out_put_efile;
3846         }
3847
3848         cfile = fdget(cfd);
3849         if (!cfile.file) {
3850                 ret = -EBADF;
3851                 goto out_put_eventfd;
3852         }
3853
3854         /* the process need read permission on control file */
3855         /* AV: shouldn't we check that it's been opened for read instead? */
3856         ret = inode_permission(file_inode(cfile.file), MAY_READ);
3857         if (ret < 0)
3858                 goto out_put_cfile;
3859
3860         /*
3861          * Determine the event callbacks and set them in @event.  This used
3862          * to be done via struct cftype but cgroup core no longer knows
3863          * about these events.  The following is crude but the whole thing
3864          * is for compatibility anyway.
3865          *
3866          * DO NOT ADD NEW FILES.
3867          */
3868         name = cfile.file->f_path.dentry->d_name.name;
3869
3870         if (!strcmp(name, "memory.usage_in_bytes")) {
3871                 event->register_event = mem_cgroup_usage_register_event;
3872                 event->unregister_event = mem_cgroup_usage_unregister_event;
3873         } else if (!strcmp(name, "memory.oom_control")) {
3874                 event->register_event = mem_cgroup_oom_register_event;
3875                 event->unregister_event = mem_cgroup_oom_unregister_event;
3876         } else if (!strcmp(name, "memory.pressure_level")) {
3877                 event->register_event = vmpressure_register_event;
3878                 event->unregister_event = vmpressure_unregister_event;
3879         } else if (!strcmp(name, "memory.memsw.usage_in_bytes")) {
3880                 event->register_event = memsw_cgroup_usage_register_event;
3881                 event->unregister_event = memsw_cgroup_usage_unregister_event;
3882         } else {
3883                 ret = -EINVAL;
3884                 goto out_put_cfile;
3885         }
3886
3887         /*
3888          * Verify @cfile should belong to @css.  Also, remaining events are
3889          * automatically removed on cgroup destruction but the removal is
3890          * asynchronous, so take an extra ref on @css.
3891          */
3892         cfile_css = css_tryget_online_from_dir(cfile.file->f_path.dentry->d_parent,
3893                                                &memory_cgrp_subsys);
3894         ret = -EINVAL;
3895         if (IS_ERR(cfile_css))
3896                 goto out_put_cfile;
3897         if (cfile_css != css) {
3898                 css_put(cfile_css);
3899                 goto out_put_cfile;
3900         }
3901
3902         ret = event->register_event(memcg, event->eventfd, buf);
3903         if (ret)
3904                 goto out_put_css;
3905
3906         efile.file->f_op->poll(efile.file, &event->pt);
3907
3908         spin_lock(&memcg->event_list_lock);
3909         list_add(&event->list, &memcg->event_list);
3910         spin_unlock(&memcg->event_list_lock);
3911
3912         fdput(cfile);
3913         fdput(efile);
3914
3915         return nbytes;
3916
3917 out_put_css:
3918         css_put(css);
3919 out_put_cfile:
3920         fdput(cfile);
3921 out_put_eventfd:
3922         eventfd_ctx_put(event->eventfd);
3923 out_put_efile:
3924         fdput(efile);
3925 out_kfree:
3926         kfree(event);
3927
3928         return ret;
3929 }
3930
3931 static struct cftype mem_cgroup_legacy_files[] = {
3932         {
3933                 .name = "usage_in_bytes",
3934                 .private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
3935                 .read_u64 = mem_cgroup_read_u64,
3936         },
3937         {
3938                 .name = "max_usage_in_bytes",
3939                 .private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
3940                 .write = mem_cgroup_reset,
3941                 .read_u64 = mem_cgroup_read_u64,
3942         },
3943         {
3944                 .name = "limit_in_bytes",
3945                 .private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
3946                 .write = mem_cgroup_write,
3947                 .read_u64 = mem_cgroup_read_u64,
3948         },
3949         {
3950                 .name = "soft_limit_in_bytes",
3951                 .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
3952                 .write = mem_cgroup_write,
3953                 .read_u64 = mem_cgroup_read_u64,
3954         },
3955         {
3956                 .name = "failcnt",
3957                 .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
3958                 .write = mem_cgroup_reset,
3959                 .read_u64 = mem_cgroup_read_u64,
3960         },
3961         {
3962                 .name = "stat",
3963                 .seq_show = memcg_stat_show,
3964         },
3965         {
3966                 .name = "force_empty",
3967                 .write = mem_cgroup_force_empty_write,
3968         },
3969         {
3970                 .name = "use_hierarchy",
3971                 .write_u64 = mem_cgroup_hierarchy_write,
3972                 .read_u64 = mem_cgroup_hierarchy_read,
3973         },
3974         {
3975                 .name = "cgroup.event_control",         /* XXX: for compat */
3976                 .write = memcg_write_event_control,
3977                 .flags = CFTYPE_NO_PREFIX | CFTYPE_WORLD_WRITABLE,
3978         },
3979         {
3980                 .name = "swappiness",
3981                 .read_u64 = mem_cgroup_swappiness_read,
3982                 .write_u64 = mem_cgroup_swappiness_write,
3983         },
3984         {
3985                 .name = "move_charge_at_immigrate",
3986                 .read_u64 = mem_cgroup_move_charge_read,
3987                 .write_u64 = mem_cgroup_move_charge_write,
3988         },
3989         {
3990                 .name = "oom_control",
3991                 .seq_show = mem_cgroup_oom_control_read,
3992                 .write_u64 = mem_cgroup_oom_control_write,
3993                 .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL),
3994         },
3995         {
3996                 .name = "pressure_level",
3997         },
3998 #ifdef CONFIG_NUMA
3999         {
4000                 .name = "numa_stat",
4001                 .seq_show = memcg_numa_stat_show,
4002         },
4003 #endif
4004         {
4005                 .name = "kmem.limit_in_bytes",
4006                 .private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),