Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* memcontrol.c - Memory Controller
3 : : *
4 : : * Copyright IBM Corporation, 2007
5 : : * Author Balbir Singh <balbir@linux.vnet.ibm.com>
6 : : *
7 : : * Copyright 2007 OpenVZ SWsoft Inc
8 : : * Author: Pavel Emelianov <xemul@openvz.org>
9 : : *
10 : : * Memory thresholds
11 : : * Copyright (C) 2009 Nokia Corporation
12 : : * Author: Kirill A. Shutemov
13 : : *
14 : : * Kernel Memory Controller
15 : : * Copyright (C) 2012 Parallels Inc. and Google Inc.
16 : : * Authors: Glauber Costa and Suleiman Souhlal
17 : : *
18 : : * Native page reclaim
19 : : * Charge lifetime sanitation
20 : : * Lockless page tracking & accounting
21 : : * Unified hierarchy configuration model
22 : : * Copyright (C) 2015 Red Hat, Inc., Johannes Weiner
23 : : */
24 : :
25 : : #include <linux/page_counter.h>
26 : : #include <linux/memcontrol.h>
27 : : #include <linux/cgroup.h>
28 : : #include <linux/pagewalk.h>
29 : : #include <linux/sched/mm.h>
30 : : #include <linux/shmem_fs.h>
31 : : #include <linux/hugetlb.h>
32 : : #include <linux/pagemap.h>
33 : : #include <linux/vm_event_item.h>
34 : : #include <linux/smp.h>
35 : : #include <linux/page-flags.h>
36 : : #include <linux/backing-dev.h>
37 : : #include <linux/bit_spinlock.h>
38 : : #include <linux/rcupdate.h>
39 : : #include <linux/limits.h>
40 : : #include <linux/export.h>
41 : : #include <linux/mutex.h>
42 : : #include <linux/rbtree.h>
43 : : #include <linux/slab.h>
44 : : #include <linux/swap.h>
45 : : #include <linux/swapops.h>
46 : : #include <linux/spinlock.h>
47 : : #include <linux/eventfd.h>
48 : : #include <linux/poll.h>
49 : : #include <linux/sort.h>
50 : : #include <linux/fs.h>
51 : : #include <linux/seq_file.h>
52 : : #include <linux/vmpressure.h>
53 : : #include <linux/mm_inline.h>
54 : : #include <linux/swap_cgroup.h>
55 : : #include <linux/cpu.h>
56 : : #include <linux/oom.h>
57 : : #include <linux/lockdep.h>
58 : : #include <linux/file.h>
59 : : #include <linux/tracehook.h>
60 : : #include <linux/psi.h>
61 : : #include <linux/seq_buf.h>
62 : : #include "internal.h"
63 : : #include <net/sock.h>
64 : : #include <net/ip.h>
65 : : #include "slab.h"
66 : :
67 : : #include <linux/uaccess.h>
68 : :
69 : : #include <trace/events/vmscan.h>
70 : :
71 : : struct cgroup_subsys memory_cgrp_subsys __read_mostly;
72 : : EXPORT_SYMBOL(memory_cgrp_subsys);
73 : :
74 : : struct mem_cgroup *root_mem_cgroup __read_mostly;
75 : :
76 : : #define MEM_CGROUP_RECLAIM_RETRIES 5
77 : :
78 : : /* Socket memory accounting disabled? */
79 : : static bool cgroup_memory_nosocket;
80 : :
81 : : /* Kernel memory accounting disabled? */
82 : : static bool cgroup_memory_nokmem;
83 : :
84 : : /* Whether the swap controller is active */
85 : : #ifdef CONFIG_MEMCG_SWAP
86 : : int do_swap_account __read_mostly;
87 : : #else
88 : : #define do_swap_account 0
89 : : #endif
90 : :
91 : : #ifdef CONFIG_CGROUP_WRITEBACK
92 : : static DECLARE_WAIT_QUEUE_HEAD(memcg_cgwb_frn_waitq);
93 : : #endif
94 : :
95 : : /* Whether legacy memory+swap accounting is active */
96 : : static bool do_memsw_account(void)
97 : : {
98 : : return !cgroup_subsys_on_dfl(memory_cgrp_subsys) && do_swap_account;
99 : : }
100 : :
101 : : static const char *const mem_cgroup_lru_names[] = {
102 : : "inactive_anon",
103 : : "active_anon",
104 : : "inactive_file",
105 : : "active_file",
106 : : "unevictable",
107 : : };
108 : :
109 : : #define THRESHOLDS_EVENTS_TARGET 128
110 : : #define SOFTLIMIT_EVENTS_TARGET 1024
111 : : #define NUMAINFO_EVENTS_TARGET 1024
112 : :
113 : : /*
114 : : * Cgroups above their limits are maintained in a RB-Tree, independent of
115 : : * their hierarchy representation
116 : : */
117 : :
118 : : struct mem_cgroup_tree_per_node {
119 : : struct rb_root rb_root;
120 : : struct rb_node *rb_rightmost;
121 : : spinlock_t lock;
122 : : };
123 : :
124 : : struct mem_cgroup_tree {
125 : : struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
126 : : };
127 : :
128 : : static struct mem_cgroup_tree soft_limit_tree __read_mostly;
129 : :
130 : : /* for OOM */
131 : : struct mem_cgroup_eventfd_list {
132 : : struct list_head list;
133 : : struct eventfd_ctx *eventfd;
134 : : };
135 : :
136 : : /*
137 : : * cgroup_event represents events which userspace want to receive.
138 : : */
139 : : struct mem_cgroup_event {
140 : : /*
141 : : * memcg which the event belongs to.
142 : : */
143 : : struct mem_cgroup *memcg;
144 : : /*
145 : : * eventfd to signal userspace about the event.
146 : : */
147 : : struct eventfd_ctx *eventfd;
148 : : /*
149 : : * Each of these stored in a list by the cgroup.
150 : : */
151 : : struct list_head list;
152 : : /*
153 : : * register_event() callback will be used to add new userspace
154 : : * waiter for changes related to this event. Use eventfd_signal()
155 : : * on eventfd to send notification to userspace.
156 : : */
157 : : int (*register_event)(struct mem_cgroup *memcg,
158 : : struct eventfd_ctx *eventfd, const char *args);
159 : : /*
160 : : * unregister_event() callback will be called when userspace closes
161 : : * the eventfd or on cgroup removing. This callback must be set,
162 : : * if you want provide notification functionality.
163 : : */
164 : : void (*unregister_event)(struct mem_cgroup *memcg,
165 : : struct eventfd_ctx *eventfd);
166 : : /*
167 : : * All fields below needed to unregister event when
168 : : * userspace closes eventfd.
169 : : */
170 : : poll_table pt;
171 : : wait_queue_head_t *wqh;
172 : : wait_queue_entry_t wait;
173 : : struct work_struct remove;
174 : : };
175 : :
176 : : static void mem_cgroup_threshold(struct mem_cgroup *memcg);
177 : : static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
178 : :
179 : : /* Stuffs for move charges at task migration. */
180 : : /*
181 : : * Types of charges to be moved.
182 : : */
183 : : #define MOVE_ANON 0x1U
184 : : #define MOVE_FILE 0x2U
185 : : #define MOVE_MASK (MOVE_ANON | MOVE_FILE)
186 : :
187 : : /* "mc" and its members are protected by cgroup_mutex */
188 : : static struct move_charge_struct {
189 : : spinlock_t lock; /* for from, to */
190 : : struct mm_struct *mm;
191 : : struct mem_cgroup *from;
192 : : struct mem_cgroup *to;
193 : : unsigned long flags;
194 : : unsigned long precharge;
195 : : unsigned long moved_charge;
196 : : unsigned long moved_swap;
197 : : struct task_struct *moving_task; /* a task moving charges */
198 : : wait_queue_head_t waitq; /* a waitq for other context */
199 : : } mc = {
200 : : .lock = __SPIN_LOCK_UNLOCKED(mc.lock),
201 : : .waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
202 : : };
203 : :
204 : : /*
205 : : * Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
206 : : * limit reclaim to prevent infinite loops, if they ever occur.
207 : : */
208 : : #define MEM_CGROUP_MAX_RECLAIM_LOOPS 100
209 : : #define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
210 : :
211 : : enum charge_type {
212 : : MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
213 : : MEM_CGROUP_CHARGE_TYPE_ANON,
214 : : MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
215 : : MEM_CGROUP_CHARGE_TYPE_DROP, /* a page was unused swap cache */
216 : : NR_CHARGE_TYPE,
217 : : };
218 : :
219 : : /* for encoding cft->private value on file */
220 : : enum res_type {
221 : : _MEM,
222 : : _MEMSWAP,
223 : : _OOM_TYPE,
224 : : _KMEM,
225 : : _TCP,
226 : : };
227 : :
228 : : #define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
229 : : #define MEMFILE_TYPE(val) ((val) >> 16 & 0xffff)
230 : : #define MEMFILE_ATTR(val) ((val) & 0xffff)
231 : : /* Used for OOM nofiier */
232 : : #define OOM_CONTROL (0)
233 : :
234 : : /*
235 : : * Iteration constructs for visiting all cgroups (under a tree). If
236 : : * loops are exited prematurely (break), mem_cgroup_iter_break() must
237 : : * be used for reference counting.
238 : : */
239 : : #define for_each_mem_cgroup_tree(iter, root) \
240 : : for (iter = mem_cgroup_iter(root, NULL, NULL); \
241 : : iter != NULL; \
242 : : iter = mem_cgroup_iter(root, iter, NULL))
243 : :
244 : : #define for_each_mem_cgroup(iter) \
245 : : for (iter = mem_cgroup_iter(NULL, NULL, NULL); \
246 : : iter != NULL; \
247 : : iter = mem_cgroup_iter(NULL, iter, NULL))
248 : :
249 : 0 : static inline bool should_force_charge(void)
250 : : {
251 : 0 : return tsk_is_oom_victim(current) || fatal_signal_pending(current) ||
252 : 0 : (current->flags & PF_EXITING);
253 : : }
254 : :
255 : : /* Some nice accessors for the vmpressure. */
256 : 0 : struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
257 : : {
258 : 0 : if (!memcg)
259 : 0 : memcg = root_mem_cgroup;
260 : 0 : return &memcg->vmpressure;
261 : : }
262 : :
263 : 0 : struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
264 : : {
265 : 0 : return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
266 : : }
267 : :
268 : : #ifdef CONFIG_MEMCG_KMEM
269 : : /*
270 : : * This will be the memcg's index in each cache's ->memcg_params.memcg_caches.
271 : : * The main reason for not using cgroup id for this:
272 : : * this works better in sparse environments, where we have a lot of memcgs,
273 : : * but only a few kmem-limited. Or also, if we have, for instance, 200
274 : : * memcgs, and none but the 200th is kmem-limited, we'd have to have a
275 : : * 200 entry array for that.
276 : : *
277 : : * The current size of the caches array is stored in memcg_nr_cache_ids. It
278 : : * will double each time we have to increase it.
279 : : */
280 : : static DEFINE_IDA(memcg_cache_ida);
281 : : int memcg_nr_cache_ids;
282 : :
283 : : /* Protects memcg_nr_cache_ids */
284 : : static DECLARE_RWSEM(memcg_cache_ids_sem);
285 : :
286 : 3 : void memcg_get_cache_ids(void)
287 : : {
288 : 3 : down_read(&memcg_cache_ids_sem);
289 : 3 : }
290 : :
291 : 3 : void memcg_put_cache_ids(void)
292 : : {
293 : 3 : up_read(&memcg_cache_ids_sem);
294 : 3 : }
295 : :
296 : : /*
297 : : * MIN_SIZE is different than 1, because we would like to avoid going through
298 : : * the alloc/free process all the time. In a small machine, 4 kmem-limited
299 : : * cgroups is a reasonable guess. In the future, it could be a parameter or
300 : : * tunable, but that is strictly not necessary.
301 : : *
302 : : * MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get
303 : : * this constant directly from cgroup, but it is understandable that this is
304 : : * better kept as an internal representation in cgroup.c. In any case, the
305 : : * cgrp_id space is not getting any smaller, and we don't have to necessarily
306 : : * increase ours as well if it increases.
307 : : */
308 : : #define MEMCG_CACHES_MIN_SIZE 4
309 : : #define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX
310 : :
311 : : /*
312 : : * A lot of the calls to the cache allocation functions are expected to be
313 : : * inlined by the compiler. Since the calls to memcg_kmem_get_cache are
314 : : * conditional to this static branch, we'll have to allow modules that does
315 : : * kmem_cache_alloc and the such to see this symbol as well
316 : : */
317 : : DEFINE_STATIC_KEY_FALSE(memcg_kmem_enabled_key);
318 : : EXPORT_SYMBOL(memcg_kmem_enabled_key);
319 : :
320 : : struct workqueue_struct *memcg_kmem_cache_wq;
321 : : #endif
322 : :
323 : : static int memcg_shrinker_map_size;
324 : : static DEFINE_MUTEX(memcg_shrinker_map_mutex);
325 : :
326 : 0 : static void memcg_free_shrinker_map_rcu(struct rcu_head *head)
327 : : {
328 : 0 : kvfree(container_of(head, struct memcg_shrinker_map, rcu));
329 : 0 : }
330 : :
331 : 0 : static int memcg_expand_one_shrinker_map(struct mem_cgroup *memcg,
332 : : int size, int old_size)
333 : : {
334 : : struct memcg_shrinker_map *new, *old;
335 : : int nid;
336 : :
337 : : lockdep_assert_held(&memcg_shrinker_map_mutex);
338 : :
339 : 0 : for_each_node(nid) {
340 : 0 : old = rcu_dereference_protected(
341 : : mem_cgroup_nodeinfo(memcg, nid)->shrinker_map, true);
342 : : /* Not yet online memcg */
343 : 0 : if (!old)
344 : : return 0;
345 : :
346 : 0 : new = kvmalloc(sizeof(*new) + size, GFP_KERNEL);
347 : 0 : if (!new)
348 : : return -ENOMEM;
349 : :
350 : : /* Set all old bits, clear all new bits */
351 : 0 : memset(new->map, (int)0xff, old_size);
352 : 0 : memset((void *)new->map + old_size, 0, size - old_size);
353 : :
354 : 0 : rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_map, new);
355 : 0 : call_rcu(&old->rcu, memcg_free_shrinker_map_rcu);
356 : : }
357 : :
358 : : return 0;
359 : : }
360 : :
361 : 0 : static void memcg_free_shrinker_maps(struct mem_cgroup *memcg)
362 : : {
363 : : struct mem_cgroup_per_node *pn;
364 : : struct memcg_shrinker_map *map;
365 : : int nid;
366 : :
367 : 0 : if (mem_cgroup_is_root(memcg))
368 : 0 : return;
369 : :
370 : 0 : for_each_node(nid) {
371 : : pn = mem_cgroup_nodeinfo(memcg, nid);
372 : 0 : map = rcu_dereference_protected(pn->shrinker_map, true);
373 : 0 : if (map)
374 : 0 : kvfree(map);
375 : : rcu_assign_pointer(pn->shrinker_map, NULL);
376 : : }
377 : : }
378 : :
379 : 3 : static int memcg_alloc_shrinker_maps(struct mem_cgroup *memcg)
380 : : {
381 : : struct memcg_shrinker_map *map;
382 : : int nid, size, ret = 0;
383 : :
384 : 3 : if (mem_cgroup_is_root(memcg))
385 : : return 0;
386 : :
387 : 0 : mutex_lock(&memcg_shrinker_map_mutex);
388 : 0 : size = memcg_shrinker_map_size;
389 : 0 : for_each_node(nid) {
390 : 0 : map = kvzalloc(sizeof(*map) + size, GFP_KERNEL);
391 : 0 : if (!map) {
392 : 0 : memcg_free_shrinker_maps(memcg);
393 : : ret = -ENOMEM;
394 : 0 : break;
395 : : }
396 : 0 : rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_map, map);
397 : : }
398 : 0 : mutex_unlock(&memcg_shrinker_map_mutex);
399 : :
400 : 0 : return ret;
401 : : }
402 : :
403 : 3 : int memcg_expand_shrinker_maps(int new_id)
404 : : {
405 : : int size, old_size, ret = 0;
406 : : struct mem_cgroup *memcg;
407 : :
408 : 3 : size = DIV_ROUND_UP(new_id + 1, BITS_PER_LONG) * sizeof(unsigned long);
409 : 3 : old_size = memcg_shrinker_map_size;
410 : 3 : if (size <= old_size)
411 : : return 0;
412 : :
413 : 3 : mutex_lock(&memcg_shrinker_map_mutex);
414 : 3 : if (!root_mem_cgroup)
415 : : goto unlock;
416 : :
417 : 3 : for_each_mem_cgroup(memcg) {
418 : 0 : if (mem_cgroup_is_root(memcg))
419 : 0 : continue;
420 : 0 : ret = memcg_expand_one_shrinker_map(memcg, size, old_size);
421 : 0 : if (ret) {
422 : 0 : mem_cgroup_iter_break(NULL, memcg);
423 : 0 : goto unlock;
424 : : }
425 : : }
426 : : unlock:
427 : 3 : if (!ret)
428 : 3 : memcg_shrinker_map_size = size;
429 : 3 : mutex_unlock(&memcg_shrinker_map_mutex);
430 : 3 : return ret;
431 : : }
432 : :
433 : 3 : void memcg_set_shrinker_bit(struct mem_cgroup *memcg, int nid, int shrinker_id)
434 : : {
435 : 3 : if (shrinker_id >= 0 && memcg && !mem_cgroup_is_root(memcg)) {
436 : : struct memcg_shrinker_map *map;
437 : :
438 : : rcu_read_lock();
439 : 0 : map = rcu_dereference(memcg->nodeinfo[nid]->shrinker_map);
440 : : /* Pairs with smp mb in shrink_slab() */
441 : 0 : smp_mb__before_atomic();
442 : 0 : set_bit(shrinker_id, map->map);
443 : : rcu_read_unlock();
444 : : }
445 : 3 : }
446 : :
447 : : /**
448 : : * mem_cgroup_css_from_page - css of the memcg associated with a page
449 : : * @page: page of interest
450 : : *
451 : : * If memcg is bound to the default hierarchy, css of the memcg associated
452 : : * with @page is returned. The returned css remains associated with @page
453 : : * until it is released.
454 : : *
455 : : * If memcg is bound to a traditional hierarchy, the css of root_mem_cgroup
456 : : * is returned.
457 : : */
458 : 1 : struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page)
459 : : {
460 : : struct mem_cgroup *memcg;
461 : :
462 : 1 : memcg = page->mem_cgroup;
463 : :
464 : 1 : if (!memcg || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
465 : 1 : memcg = root_mem_cgroup;
466 : :
467 : 1 : return &memcg->css;
468 : : }
469 : :
470 : : /**
471 : : * page_cgroup_ino - return inode number of the memcg a page is charged to
472 : : * @page: the page
473 : : *
474 : : * Look up the closest online ancestor of the memory cgroup @page is charged to
475 : : * and return its inode number or 0 if @page is not charged to any cgroup. It
476 : : * is safe to call this function without holding a reference to @page.
477 : : *
478 : : * Note, this function is inherently racy, because there is nothing to prevent
479 : : * the cgroup inode from getting torn down and potentially reallocated a moment
480 : : * after page_cgroup_ino() returns, so it only should be used by callers that
481 : : * do not care (such as procfs interfaces).
482 : : */
483 : 0 : ino_t page_cgroup_ino(struct page *page)
484 : : {
485 : : struct mem_cgroup *memcg;
486 : : unsigned long ino = 0;
487 : :
488 : : rcu_read_lock();
489 : 0 : if (PageSlab(page) && !PageTail(page))
490 : 0 : memcg = memcg_from_slab_page(page);
491 : : else
492 : 0 : memcg = READ_ONCE(page->mem_cgroup);
493 : 0 : while (memcg && !(memcg->css.flags & CSS_ONLINE))
494 : : memcg = parent_mem_cgroup(memcg);
495 : 0 : if (memcg)
496 : 0 : ino = cgroup_ino(memcg->css.cgroup);
497 : : rcu_read_unlock();
498 : 0 : return ino;
499 : : }
500 : :
501 : : static struct mem_cgroup_per_node *
502 : : mem_cgroup_page_nodeinfo(struct mem_cgroup *memcg, struct page *page)
503 : : {
504 : : int nid = page_to_nid(page);
505 : :
506 : 0 : return memcg->nodeinfo[nid];
507 : : }
508 : :
509 : : static struct mem_cgroup_tree_per_node *
510 : : soft_limit_tree_node(int nid)
511 : : {
512 : 0 : return soft_limit_tree.rb_tree_per_node[nid];
513 : : }
514 : :
515 : : static struct mem_cgroup_tree_per_node *
516 : : soft_limit_tree_from_page(struct page *page)
517 : : {
518 : : int nid = page_to_nid(page);
519 : :
520 : 0 : return soft_limit_tree.rb_tree_per_node[nid];
521 : : }
522 : :
523 : 0 : static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_node *mz,
524 : : struct mem_cgroup_tree_per_node *mctz,
525 : : unsigned long new_usage_in_excess)
526 : : {
527 : 0 : struct rb_node **p = &mctz->rb_root.rb_node;
528 : : struct rb_node *parent = NULL;
529 : : struct mem_cgroup_per_node *mz_node;
530 : : bool rightmost = true;
531 : :
532 : 0 : if (mz->on_tree)
533 : : return;
534 : :
535 : 0 : mz->usage_in_excess = new_usage_in_excess;
536 : 0 : if (!mz->usage_in_excess)
537 : : return;
538 : 0 : while (*p) {
539 : : parent = *p;
540 : : mz_node = rb_entry(parent, struct mem_cgroup_per_node,
541 : : tree_node);
542 : 0 : if (mz->usage_in_excess < mz_node->usage_in_excess) {
543 : 0 : p = &(*p)->rb_left;
544 : : rightmost = false;
545 : : }
546 : :
547 : : /*
548 : : * We can't avoid mem cgroups that are over their soft
549 : : * limit by the same amount
550 : : */
551 : 0 : else if (mz->usage_in_excess >= mz_node->usage_in_excess)
552 : 0 : p = &(*p)->rb_right;
553 : : }
554 : :
555 : 0 : if (rightmost)
556 : 0 : mctz->rb_rightmost = &mz->tree_node;
557 : :
558 : 0 : rb_link_node(&mz->tree_node, parent, p);
559 : 0 : rb_insert_color(&mz->tree_node, &mctz->rb_root);
560 : 0 : mz->on_tree = true;
561 : : }
562 : :
563 : 0 : static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
564 : : struct mem_cgroup_tree_per_node *mctz)
565 : : {
566 : 0 : if (!mz->on_tree)
567 : 0 : return;
568 : :
569 : 0 : if (&mz->tree_node == mctz->rb_rightmost)
570 : 0 : mctz->rb_rightmost = rb_prev(&mz->tree_node);
571 : :
572 : 0 : rb_erase(&mz->tree_node, &mctz->rb_root);
573 : 0 : mz->on_tree = false;
574 : : }
575 : :
576 : 0 : static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_node *mz,
577 : : struct mem_cgroup_tree_per_node *mctz)
578 : : {
579 : : unsigned long flags;
580 : :
581 : 0 : spin_lock_irqsave(&mctz->lock, flags);
582 : 0 : __mem_cgroup_remove_exceeded(mz, mctz);
583 : : spin_unlock_irqrestore(&mctz->lock, flags);
584 : 0 : }
585 : :
586 : : static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
587 : : {
588 : : unsigned long nr_pages = page_counter_read(&memcg->memory);
589 : : unsigned long soft_limit = READ_ONCE(memcg->soft_limit);
590 : : unsigned long excess = 0;
591 : :
592 : 0 : if (nr_pages > soft_limit)
593 : 0 : excess = nr_pages - soft_limit;
594 : :
595 : : return excess;
596 : : }
597 : :
598 : 0 : static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
599 : : {
600 : : unsigned long excess;
601 : : struct mem_cgroup_per_node *mz;
602 : : struct mem_cgroup_tree_per_node *mctz;
603 : :
604 : : mctz = soft_limit_tree_from_page(page);
605 : 0 : if (!mctz)
606 : 0 : return;
607 : : /*
608 : : * Necessary to update all ancestors when hierarchy is used.
609 : : * because their event counter is not touched.
610 : : */
611 : 0 : for (; memcg; memcg = parent_mem_cgroup(memcg)) {
612 : : mz = mem_cgroup_page_nodeinfo(memcg, page);
613 : : excess = soft_limit_excess(memcg);
614 : : /*
615 : : * We have to update the tree if mz is on RB-tree or
616 : : * mem is over its softlimit.
617 : : */
618 : 0 : if (excess || mz->on_tree) {
619 : : unsigned long flags;
620 : :
621 : 0 : spin_lock_irqsave(&mctz->lock, flags);
622 : : /* if on-tree, remove it */
623 : 0 : if (mz->on_tree)
624 : 0 : __mem_cgroup_remove_exceeded(mz, mctz);
625 : : /*
626 : : * Insert again. mz->usage_in_excess will be updated.
627 : : * If excess is 0, no tree ops.
628 : : */
629 : 0 : __mem_cgroup_insert_exceeded(mz, mctz, excess);
630 : : spin_unlock_irqrestore(&mctz->lock, flags);
631 : : }
632 : : }
633 : : }
634 : :
635 : 0 : static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
636 : : {
637 : : struct mem_cgroup_tree_per_node *mctz;
638 : : struct mem_cgroup_per_node *mz;
639 : : int nid;
640 : :
641 : 0 : for_each_node(nid) {
642 : : mz = mem_cgroup_nodeinfo(memcg, nid);
643 : : mctz = soft_limit_tree_node(nid);
644 : 0 : if (mctz)
645 : 0 : mem_cgroup_remove_exceeded(mz, mctz);
646 : : }
647 : 0 : }
648 : :
649 : : static struct mem_cgroup_per_node *
650 : 0 : __mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
651 : : {
652 : : struct mem_cgroup_per_node *mz;
653 : :
654 : : retry:
655 : : mz = NULL;
656 : 0 : if (!mctz->rb_rightmost)
657 : : goto done; /* Nothing to reclaim from */
658 : :
659 : 0 : mz = rb_entry(mctz->rb_rightmost,
660 : : struct mem_cgroup_per_node, tree_node);
661 : : /*
662 : : * Remove the node now but someone else can add it back,
663 : : * we will to add it back at the end of reclaim to its correct
664 : : * position in the tree.
665 : : */
666 : 0 : __mem_cgroup_remove_exceeded(mz, mctz);
667 : 0 : if (!soft_limit_excess(mz->memcg) ||
668 : : !css_tryget_online(&mz->memcg->css))
669 : : goto retry;
670 : : done:
671 : 0 : return mz;
672 : : }
673 : :
674 : : static struct mem_cgroup_per_node *
675 : 0 : mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_node *mctz)
676 : : {
677 : : struct mem_cgroup_per_node *mz;
678 : :
679 : : spin_lock_irq(&mctz->lock);
680 : 0 : mz = __mem_cgroup_largest_soft_limit_node(mctz);
681 : : spin_unlock_irq(&mctz->lock);
682 : 0 : return mz;
683 : : }
684 : :
685 : : /**
686 : : * __mod_memcg_state - update cgroup memory statistics
687 : : * @memcg: the memory cgroup
688 : : * @idx: the stat item - can be enum memcg_stat_item or enum node_stat_item
689 : : * @val: delta to add to the counter, can be negative
690 : : */
691 : 0 : void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val)
692 : : {
693 : : long x;
694 : :
695 : 0 : if (mem_cgroup_disabled())
696 : 0 : return;
697 : :
698 : 0 : x = val + __this_cpu_read(memcg->vmstats_percpu->stat[idx]);
699 : 0 : if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
700 : : struct mem_cgroup *mi;
701 : :
702 : : /*
703 : : * Batch local counters to keep them in sync with
704 : : * the hierarchical ones.
705 : : */
706 : 0 : __this_cpu_add(memcg->vmstats_local->stat[idx], x);
707 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
708 : 0 : atomic_long_add(x, &mi->vmstats[idx]);
709 : : x = 0;
710 : : }
711 : 0 : __this_cpu_write(memcg->vmstats_percpu->stat[idx], x);
712 : : }
713 : :
714 : : static struct mem_cgroup_per_node *
715 : : parent_nodeinfo(struct mem_cgroup_per_node *pn, int nid)
716 : : {
717 : : struct mem_cgroup *parent;
718 : :
719 : 0 : parent = parent_mem_cgroup(pn->memcg);
720 : 0 : if (!parent)
721 : : return NULL;
722 : : return mem_cgroup_nodeinfo(parent, nid);
723 : : }
724 : :
725 : : /**
726 : : * __mod_lruvec_state - update lruvec memory statistics
727 : : * @lruvec: the lruvec
728 : : * @idx: the stat item
729 : : * @val: delta to add to the counter, can be negative
730 : : *
731 : : * The lruvec is the intersection of the NUMA node and a cgroup. This
732 : : * function updates the all three counters that are affected by a
733 : : * change of state at this level: per-node, per-cgroup, per-lruvec.
734 : : */
735 : 3 : void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
736 : : int val)
737 : : {
738 : : pg_data_t *pgdat = lruvec_pgdat(lruvec);
739 : : struct mem_cgroup_per_node *pn;
740 : : struct mem_cgroup *memcg;
741 : : long x;
742 : :
743 : : /* Update node */
744 : 3 : __mod_node_page_state(pgdat, idx, val);
745 : :
746 : 3 : if (mem_cgroup_disabled())
747 : 3 : return;
748 : :
749 : : pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
750 : 0 : memcg = pn->memcg;
751 : :
752 : : /* Update memcg */
753 : 0 : __mod_memcg_state(memcg, idx, val);
754 : :
755 : : /* Update lruvec */
756 : 0 : __this_cpu_add(pn->lruvec_stat_local->count[idx], val);
757 : :
758 : 0 : x = val + __this_cpu_read(pn->lruvec_stat_cpu->count[idx]);
759 : 0 : if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
760 : : struct mem_cgroup_per_node *pi;
761 : :
762 : 0 : for (pi = pn; pi; pi = parent_nodeinfo(pi, pgdat->node_id))
763 : 0 : atomic_long_add(x, &pi->lruvec_stat[idx]);
764 : : x = 0;
765 : : }
766 : 0 : __this_cpu_write(pn->lruvec_stat_cpu->count[idx], x);
767 : : }
768 : :
769 : 0 : void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val)
770 : : {
771 : : struct page *page = virt_to_head_page(p);
772 : : pg_data_t *pgdat = page_pgdat(page);
773 : : struct mem_cgroup *memcg;
774 : : struct lruvec *lruvec;
775 : :
776 : : rcu_read_lock();
777 : : memcg = memcg_from_slab_page(page);
778 : :
779 : : /* Untracked pages have no memcg, no lruvec. Update only the node */
780 : 0 : if (!memcg || memcg == root_mem_cgroup) {
781 : 0 : __mod_node_page_state(pgdat, idx, val);
782 : : } else {
783 : : lruvec = mem_cgroup_lruvec(pgdat, memcg);
784 : 0 : __mod_lruvec_state(lruvec, idx, val);
785 : : }
786 : : rcu_read_unlock();
787 : 0 : }
788 : :
789 : 3 : void mod_memcg_obj_state(void *p, int idx, int val)
790 : : {
791 : : struct mem_cgroup *memcg;
792 : :
793 : : rcu_read_lock();
794 : 3 : memcg = mem_cgroup_from_obj(p);
795 : 3 : if (memcg)
796 : 0 : mod_memcg_state(memcg, idx, val);
797 : : rcu_read_unlock();
798 : 3 : }
799 : :
800 : : /**
801 : : * __count_memcg_events - account VM events in a cgroup
802 : : * @memcg: the memory cgroup
803 : : * @idx: the event item
804 : : * @count: the number of events that occured
805 : : */
806 : 0 : void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
807 : : unsigned long count)
808 : : {
809 : : unsigned long x;
810 : :
811 : 0 : if (mem_cgroup_disabled())
812 : 0 : return;
813 : :
814 : 0 : x = count + __this_cpu_read(memcg->vmstats_percpu->events[idx]);
815 : 0 : if (unlikely(x > MEMCG_CHARGE_BATCH)) {
816 : : struct mem_cgroup *mi;
817 : :
818 : : /*
819 : : * Batch local counters to keep them in sync with
820 : : * the hierarchical ones.
821 : : */
822 : 0 : __this_cpu_add(memcg->vmstats_local->events[idx], x);
823 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
824 : 0 : atomic_long_add(x, &mi->vmevents[idx]);
825 : : x = 0;
826 : : }
827 : 0 : __this_cpu_write(memcg->vmstats_percpu->events[idx], x);
828 : : }
829 : :
830 : : static unsigned long memcg_events(struct mem_cgroup *memcg, int event)
831 : : {
832 : 0 : return atomic_long_read(&memcg->vmevents[event]);
833 : : }
834 : :
835 : 0 : static unsigned long memcg_events_local(struct mem_cgroup *memcg, int event)
836 : : {
837 : : long x = 0;
838 : : int cpu;
839 : :
840 : 0 : for_each_possible_cpu(cpu)
841 : 0 : x += per_cpu(memcg->vmstats_local->events[event], cpu);
842 : 0 : return x;
843 : : }
844 : :
845 : 0 : static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
846 : : struct page *page,
847 : : bool compound, int nr_pages)
848 : : {
849 : : /*
850 : : * Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
851 : : * counted as CACHE even if it's on ANON LRU.
852 : : */
853 : 0 : if (PageAnon(page))
854 : 0 : __mod_memcg_state(memcg, MEMCG_RSS, nr_pages);
855 : : else {
856 : 0 : __mod_memcg_state(memcg, MEMCG_CACHE, nr_pages);
857 : 0 : if (PageSwapBacked(page))
858 : 0 : __mod_memcg_state(memcg, NR_SHMEM, nr_pages);
859 : : }
860 : :
861 : 0 : if (compound) {
862 : : VM_BUG_ON_PAGE(!PageTransHuge(page), page);
863 : 0 : __mod_memcg_state(memcg, MEMCG_RSS_HUGE, nr_pages);
864 : : }
865 : :
866 : : /* pagein of a big page is an event. So, ignore page size */
867 : 0 : if (nr_pages > 0)
868 : 0 : __count_memcg_events(memcg, PGPGIN, 1);
869 : : else {
870 : 0 : __count_memcg_events(memcg, PGPGOUT, 1);
871 : 0 : nr_pages = -nr_pages; /* for event */
872 : : }
873 : :
874 : 0 : __this_cpu_add(memcg->vmstats_percpu->nr_page_events, nr_pages);
875 : 0 : }
876 : :
877 : 0 : static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
878 : : enum mem_cgroup_events_target target)
879 : : {
880 : : unsigned long val, next;
881 : :
882 : 0 : val = __this_cpu_read(memcg->vmstats_percpu->nr_page_events);
883 : 0 : next = __this_cpu_read(memcg->vmstats_percpu->targets[target]);
884 : : /* from time_after() in jiffies.h */
885 : 0 : if ((long)(next - val) < 0) {
886 : 0 : switch (target) {
887 : : case MEM_CGROUP_TARGET_THRESH:
888 : 0 : next = val + THRESHOLDS_EVENTS_TARGET;
889 : 0 : break;
890 : : case MEM_CGROUP_TARGET_SOFTLIMIT:
891 : 0 : next = val + SOFTLIMIT_EVENTS_TARGET;
892 : 0 : break;
893 : : case MEM_CGROUP_TARGET_NUMAINFO:
894 : 0 : next = val + NUMAINFO_EVENTS_TARGET;
895 : 0 : break;
896 : : default:
897 : : break;
898 : : }
899 : 0 : __this_cpu_write(memcg->vmstats_percpu->targets[target], next);
900 : 0 : return true;
901 : : }
902 : : return false;
903 : : }
904 : :
905 : : /*
906 : : * Check events in order.
907 : : *
908 : : */
909 : 0 : static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
910 : : {
911 : : /* threshold event is triggered in finer grain than soft limit */
912 : 0 : if (unlikely(mem_cgroup_event_ratelimit(memcg,
913 : : MEM_CGROUP_TARGET_THRESH))) {
914 : : bool do_softlimit;
915 : : bool do_numainfo __maybe_unused;
916 : :
917 : 0 : do_softlimit = mem_cgroup_event_ratelimit(memcg,
918 : : MEM_CGROUP_TARGET_SOFTLIMIT);
919 : : #if MAX_NUMNODES > 1
920 : : do_numainfo = mem_cgroup_event_ratelimit(memcg,
921 : : MEM_CGROUP_TARGET_NUMAINFO);
922 : : #endif
923 : 0 : mem_cgroup_threshold(memcg);
924 : 0 : if (unlikely(do_softlimit))
925 : 0 : mem_cgroup_update_tree(memcg, page);
926 : : #if MAX_NUMNODES > 1
927 : : if (unlikely(do_numainfo))
928 : : atomic_inc(&memcg->numainfo_events);
929 : : #endif
930 : : }
931 : 0 : }
932 : :
933 : 0 : struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
934 : : {
935 : : /*
936 : : * mm_update_next_owner() may clear mm->owner to NULL
937 : : * if it races with swapoff, page migration, etc.
938 : : * So this can be called with p == NULL.
939 : : */
940 : 0 : if (unlikely(!p))
941 : : return NULL;
942 : :
943 : 0 : return mem_cgroup_from_css(task_css(p, memory_cgrp_id));
944 : : }
945 : : EXPORT_SYMBOL(mem_cgroup_from_task);
946 : :
947 : : /**
948 : : * get_mem_cgroup_from_mm: Obtain a reference on given mm_struct's memcg.
949 : : * @mm: mm from which memcg should be extracted. It can be NULL.
950 : : *
951 : : * Obtain a reference on mm->memcg and returns it if successful. Otherwise
952 : : * root_mem_cgroup is returned. However if mem_cgroup is disabled, NULL is
953 : : * returned.
954 : : */
955 : 3 : struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
956 : : {
957 : : struct mem_cgroup *memcg;
958 : :
959 : 3 : if (mem_cgroup_disabled())
960 : : return NULL;
961 : :
962 : : rcu_read_lock();
963 : : do {
964 : : /*
965 : : * Page cache insertions can happen withou an
966 : : * actual mm context, e.g. during disk probing
967 : : * on boot, loopback IO, acct() writes etc.
968 : : */
969 : 0 : if (unlikely(!mm))
970 : 0 : memcg = root_mem_cgroup;
971 : : else {
972 : 0 : memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
973 : 0 : if (unlikely(!memcg))
974 : 0 : memcg = root_mem_cgroup;
975 : : }
976 : 0 : } while (!css_tryget(&memcg->css));
977 : : rcu_read_unlock();
978 : 0 : return memcg;
979 : : }
980 : : EXPORT_SYMBOL(get_mem_cgroup_from_mm);
981 : :
982 : : /**
983 : : * get_mem_cgroup_from_page: Obtain a reference on given page's memcg.
984 : : * @page: page from which memcg should be extracted.
985 : : *
986 : : * Obtain a reference on page->memcg and returns it if successful. Otherwise
987 : : * root_mem_cgroup is returned.
988 : : */
989 : 3 : struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
990 : : {
991 : 3 : struct mem_cgroup *memcg = page->mem_cgroup;
992 : :
993 : 3 : if (mem_cgroup_disabled())
994 : : return NULL;
995 : :
996 : : rcu_read_lock();
997 : 0 : if (!memcg || !css_tryget_online(&memcg->css))
998 : 0 : memcg = root_mem_cgroup;
999 : : rcu_read_unlock();
1000 : 0 : return memcg;
1001 : : }
1002 : : EXPORT_SYMBOL(get_mem_cgroup_from_page);
1003 : :
1004 : : /**
1005 : : * If current->active_memcg is non-NULL, do not fallback to current->mm->memcg.
1006 : : */
1007 : : static __always_inline struct mem_cgroup *get_mem_cgroup_from_current(void)
1008 : : {
1009 : 0 : if (unlikely(current->active_memcg)) {
1010 : 0 : struct mem_cgroup *memcg = root_mem_cgroup;
1011 : :
1012 : : rcu_read_lock();
1013 : 0 : if (css_tryget_online(¤t->active_memcg->css))
1014 : 0 : memcg = current->active_memcg;
1015 : 0 : rcu_read_unlock();
1016 : : return memcg;
1017 : : }
1018 : 0 : return get_mem_cgroup_from_mm(current->mm);
1019 : : }
1020 : :
1021 : : /**
1022 : : * mem_cgroup_iter - iterate over memory cgroup hierarchy
1023 : : * @root: hierarchy root
1024 : : * @prev: previously returned memcg, NULL on first invocation
1025 : : * @reclaim: cookie for shared reclaim walks, NULL for full walks
1026 : : *
1027 : : * Returns references to children of the hierarchy below @root, or
1028 : : * @root itself, or %NULL after a full round-trip.
1029 : : *
1030 : : * Caller must pass the return value in @prev on subsequent
1031 : : * invocations for reference counting, or use mem_cgroup_iter_break()
1032 : : * to cancel a hierarchy walk before the round-trip is complete.
1033 : : *
1034 : : * Reclaimers can specify a node and a priority level in @reclaim to
1035 : : * divide up the memcgs in the hierarchy among all concurrent
1036 : : * reclaimers operating on the same node and priority.
1037 : : */
1038 : 3 : struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
1039 : : struct mem_cgroup *prev,
1040 : : struct mem_cgroup_reclaim_cookie *reclaim)
1041 : : {
1042 : : struct mem_cgroup_reclaim_iter *uninitialized_var(iter);
1043 : : struct cgroup_subsys_state *css = NULL;
1044 : : struct mem_cgroup *memcg = NULL;
1045 : : struct mem_cgroup *pos = NULL;
1046 : :
1047 : 3 : if (mem_cgroup_disabled())
1048 : : return NULL;
1049 : :
1050 : 0 : if (!root)
1051 : 0 : root = root_mem_cgroup;
1052 : :
1053 : 0 : if (prev && !reclaim)
1054 : : pos = prev;
1055 : :
1056 : 0 : if (!root->use_hierarchy && root != root_mem_cgroup) {
1057 : 0 : if (prev)
1058 : : goto out;
1059 : : return root;
1060 : : }
1061 : :
1062 : : rcu_read_lock();
1063 : :
1064 : 0 : if (reclaim) {
1065 : : struct mem_cgroup_per_node *mz;
1066 : :
1067 : 0 : mz = mem_cgroup_nodeinfo(root, reclaim->pgdat->node_id);
1068 : 0 : iter = &mz->iter[reclaim->priority];
1069 : :
1070 : 0 : if (prev && reclaim->generation != iter->generation)
1071 : : goto out_unlock;
1072 : :
1073 : : while (1) {
1074 : 0 : pos = READ_ONCE(iter->position);
1075 : 0 : if (!pos || css_tryget(&pos->css))
1076 : : break;
1077 : : /*
1078 : : * css reference reached zero, so iter->position will
1079 : : * be cleared by ->css_released. However, we should not
1080 : : * rely on this happening soon, because ->css_released
1081 : : * is called from a work queue, and by busy-waiting we
1082 : : * might block it. So we clear iter->position right
1083 : : * away.
1084 : : */
1085 : 0 : (void)cmpxchg(&iter->position, pos, NULL);
1086 : 0 : }
1087 : : }
1088 : :
1089 : 0 : if (pos)
1090 : 0 : css = &pos->css;
1091 : :
1092 : : for (;;) {
1093 : 0 : css = css_next_descendant_pre(css, &root->css);
1094 : 0 : if (!css) {
1095 : : /*
1096 : : * Reclaimers share the hierarchy walk, and a
1097 : : * new one might jump in right at the end of
1098 : : * the hierarchy - make sure they see at least
1099 : : * one group and restart from the beginning.
1100 : : */
1101 : 0 : if (!prev)
1102 : 0 : continue;
1103 : : break;
1104 : : }
1105 : :
1106 : : /*
1107 : : * Verify the css and acquire a reference. The root
1108 : : * is provided by the caller, so we know it's alive
1109 : : * and kicking, and don't take an extra reference.
1110 : : */
1111 : : memcg = mem_cgroup_from_css(css);
1112 : :
1113 : 0 : if (css == &root->css)
1114 : : break;
1115 : :
1116 : 0 : if (css_tryget(css))
1117 : : break;
1118 : :
1119 : : memcg = NULL;
1120 : : }
1121 : :
1122 : 0 : if (reclaim) {
1123 : : /*
1124 : : * The position could have already been updated by a competing
1125 : : * thread, so check that the value hasn't changed since we read
1126 : : * it to avoid reclaiming from the same cgroup twice.
1127 : : */
1128 : 0 : (void)cmpxchg(&iter->position, pos, memcg);
1129 : :
1130 : 0 : if (pos)
1131 : : css_put(&pos->css);
1132 : :
1133 : 0 : if (!memcg)
1134 : 0 : iter->generation++;
1135 : 0 : else if (!prev)
1136 : 0 : reclaim->generation = iter->generation;
1137 : : }
1138 : :
1139 : : out_unlock:
1140 : : rcu_read_unlock();
1141 : : out:
1142 : 0 : if (prev && prev != root)
1143 : : css_put(&prev->css);
1144 : :
1145 : 0 : return memcg;
1146 : : }
1147 : :
1148 : : /**
1149 : : * mem_cgroup_iter_break - abort a hierarchy walk prematurely
1150 : : * @root: hierarchy root
1151 : : * @prev: last visited hierarchy member as returned by mem_cgroup_iter()
1152 : : */
1153 : 0 : void mem_cgroup_iter_break(struct mem_cgroup *root,
1154 : : struct mem_cgroup *prev)
1155 : : {
1156 : 0 : if (!root)
1157 : 0 : root = root_mem_cgroup;
1158 : 0 : if (prev && prev != root)
1159 : : css_put(&prev->css);
1160 : 0 : }
1161 : :
1162 : 0 : static void __invalidate_reclaim_iterators(struct mem_cgroup *from,
1163 : : struct mem_cgroup *dead_memcg)
1164 : : {
1165 : : struct mem_cgroup_reclaim_iter *iter;
1166 : : struct mem_cgroup_per_node *mz;
1167 : : int nid;
1168 : : int i;
1169 : :
1170 : 0 : for_each_node(nid) {
1171 : : mz = mem_cgroup_nodeinfo(from, nid);
1172 : 0 : for (i = 0; i <= DEF_PRIORITY; i++) {
1173 : : iter = &mz->iter[i];
1174 : 0 : cmpxchg(&iter->position,
1175 : : dead_memcg, NULL);
1176 : : }
1177 : : }
1178 : 0 : }
1179 : :
1180 : 0 : static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
1181 : : {
1182 : : struct mem_cgroup *memcg = dead_memcg;
1183 : : struct mem_cgroup *last;
1184 : :
1185 : : do {
1186 : 0 : __invalidate_reclaim_iterators(memcg, dead_memcg);
1187 : : last = memcg;
1188 : 0 : } while ((memcg = parent_mem_cgroup(memcg)));
1189 : :
1190 : : /*
1191 : : * When cgruop1 non-hierarchy mode is used,
1192 : : * parent_mem_cgroup() does not walk all the way up to the
1193 : : * cgroup root (root_mem_cgroup). So we have to handle
1194 : : * dead_memcg from cgroup root separately.
1195 : : */
1196 : 0 : if (last != root_mem_cgroup)
1197 : 0 : __invalidate_reclaim_iterators(root_mem_cgroup,
1198 : : dead_memcg);
1199 : 0 : }
1200 : :
1201 : : /**
1202 : : * mem_cgroup_scan_tasks - iterate over tasks of a memory cgroup hierarchy
1203 : : * @memcg: hierarchy root
1204 : : * @fn: function to call for each task
1205 : : * @arg: argument passed to @fn
1206 : : *
1207 : : * This function iterates over tasks attached to @memcg or to any of its
1208 : : * descendants and calls @fn for each task. If @fn returns a non-zero
1209 : : * value, the function breaks the iteration loop and returns the value.
1210 : : * Otherwise, it will iterate over all tasks and return 0.
1211 : : *
1212 : : * This function must not be called for the root memory cgroup.
1213 : : */
1214 : 0 : int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
1215 : : int (*fn)(struct task_struct *, void *), void *arg)
1216 : : {
1217 : : struct mem_cgroup *iter;
1218 : : int ret = 0;
1219 : :
1220 : 0 : BUG_ON(memcg == root_mem_cgroup);
1221 : :
1222 : 0 : for_each_mem_cgroup_tree(iter, memcg) {
1223 : : struct css_task_iter it;
1224 : : struct task_struct *task;
1225 : :
1226 : 0 : css_task_iter_start(&iter->css, CSS_TASK_ITER_PROCS, &it);
1227 : 0 : while (!ret && (task = css_task_iter_next(&it)))
1228 : 0 : ret = fn(task, arg);
1229 : 0 : css_task_iter_end(&it);
1230 : 0 : if (ret) {
1231 : 0 : mem_cgroup_iter_break(memcg, iter);
1232 : 0 : break;
1233 : : }
1234 : : }
1235 : 0 : return ret;
1236 : : }
1237 : :
1238 : : /**
1239 : : * mem_cgroup_page_lruvec - return lruvec for isolating/putting an LRU page
1240 : : * @page: the page
1241 : : * @pgdat: pgdat of the page
1242 : : *
1243 : : * This function is only safe when following the LRU page isolation
1244 : : * and putback protocol: the LRU lock must be held, and the page must
1245 : : * either be PageLRU() or the caller must have isolated/allocated it.
1246 : : */
1247 : 3 : struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct pglist_data *pgdat)
1248 : : {
1249 : : struct mem_cgroup_per_node *mz;
1250 : : struct mem_cgroup *memcg;
1251 : : struct lruvec *lruvec;
1252 : :
1253 : 3 : if (mem_cgroup_disabled()) {
1254 : 3 : lruvec = &pgdat->lruvec;
1255 : 3 : goto out;
1256 : : }
1257 : :
1258 : 0 : memcg = page->mem_cgroup;
1259 : : /*
1260 : : * Swapcache readahead pages are added to the LRU - and
1261 : : * possibly migrated - before they are charged.
1262 : : */
1263 : 0 : if (!memcg)
1264 : 0 : memcg = root_mem_cgroup;
1265 : :
1266 : : mz = mem_cgroup_page_nodeinfo(memcg, page);
1267 : 0 : lruvec = &mz->lruvec;
1268 : : out:
1269 : : /*
1270 : : * Since a node can be onlined after the mem_cgroup was created,
1271 : : * we have to be prepared to initialize lruvec->zone here;
1272 : : * and if offlined then reonlined, we need to reinitialize it.
1273 : : */
1274 : 3 : if (unlikely(lruvec->pgdat != pgdat))
1275 : 0 : lruvec->pgdat = pgdat;
1276 : 3 : return lruvec;
1277 : : }
1278 : :
1279 : : /**
1280 : : * mem_cgroup_update_lru_size - account for adding or removing an lru page
1281 : : * @lruvec: mem_cgroup per zone lru vector
1282 : : * @lru: index of lru list the page is sitting on
1283 : : * @zid: zone id of the accounted pages
1284 : : * @nr_pages: positive when adding or negative when removing
1285 : : *
1286 : : * This function must be called under lru_lock, just before a page is added
1287 : : * to or just after a page is removed from an lru list (that ordering being
1288 : : * so as to allow it to check that lru_size 0 is consistent with list_empty).
1289 : : */
1290 : 3 : void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
1291 : : int zid, int nr_pages)
1292 : : {
1293 : : struct mem_cgroup_per_node *mz;
1294 : : unsigned long *lru_size;
1295 : : long size;
1296 : :
1297 : 3 : if (mem_cgroup_disabled())
1298 : 3 : return;
1299 : :
1300 : : mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
1301 : : lru_size = &mz->lru_zone_size[zid][lru];
1302 : :
1303 : 0 : if (nr_pages < 0)
1304 : 0 : *lru_size += nr_pages;
1305 : :
1306 : 0 : size = *lru_size;
1307 : 0 : if (WARN_ONCE(size < 0,
1308 : : "%s(%p, %d, %d): lru_size %ld\n",
1309 : : __func__, lruvec, lru, nr_pages, size)) {
1310 : : VM_BUG_ON(1);
1311 : 0 : *lru_size = 0;
1312 : : }
1313 : :
1314 : 0 : if (nr_pages > 0)
1315 : 0 : *lru_size += nr_pages;
1316 : : }
1317 : :
1318 : : /**
1319 : : * mem_cgroup_margin - calculate chargeable space of a memory cgroup
1320 : : * @memcg: the memory cgroup
1321 : : *
1322 : : * Returns the maximum amount of memory @mem can be charged with, in
1323 : : * pages.
1324 : : */
1325 : : static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
1326 : : {
1327 : : unsigned long margin = 0;
1328 : : unsigned long count;
1329 : : unsigned long limit;
1330 : :
1331 : : count = page_counter_read(&memcg->memory);
1332 : : limit = READ_ONCE(memcg->memory.max);
1333 : 0 : if (count < limit)
1334 : 0 : margin = limit - count;
1335 : :
1336 : : if (do_memsw_account()) {
1337 : : count = page_counter_read(&memcg->memsw);
1338 : : limit = READ_ONCE(memcg->memsw.max);
1339 : : if (count <= limit)
1340 : : margin = min(margin, limit - count);
1341 : : else
1342 : : margin = 0;
1343 : : }
1344 : :
1345 : : return margin;
1346 : : }
1347 : :
1348 : : /*
1349 : : * A routine for checking "mem" is under move_account() or not.
1350 : : *
1351 : : * Checking a cgroup is mc.from or mc.to or under hierarchy of
1352 : : * moving cgroups. This is for waiting at high-memory pressure
1353 : : * caused by "move".
1354 : : */
1355 : 0 : static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
1356 : : {
1357 : : struct mem_cgroup *from;
1358 : : struct mem_cgroup *to;
1359 : : bool ret = false;
1360 : : /*
1361 : : * Unlike task_move routines, we access mc.to, mc.from not under
1362 : : * mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
1363 : : */
1364 : : spin_lock(&mc.lock);
1365 : 0 : from = mc.from;
1366 : 0 : to = mc.to;
1367 : 0 : if (!from)
1368 : : goto unlock;
1369 : :
1370 : 0 : ret = mem_cgroup_is_descendant(from, memcg) ||
1371 : 0 : mem_cgroup_is_descendant(to, memcg);
1372 : : unlock:
1373 : : spin_unlock(&mc.lock);
1374 : 0 : return ret;
1375 : : }
1376 : :
1377 : 0 : static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
1378 : : {
1379 : 0 : if (mc.moving_task && current != mc.moving_task) {
1380 : 0 : if (mem_cgroup_under_move(memcg)) {
1381 : 0 : DEFINE_WAIT(wait);
1382 : 0 : prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
1383 : : /* moving charge context might have finished. */
1384 : 0 : if (mc.moving_task)
1385 : 0 : schedule();
1386 : 0 : finish_wait(&mc.waitq, &wait);
1387 : : return true;
1388 : : }
1389 : : }
1390 : : return false;
1391 : : }
1392 : :
1393 : 0 : static char *memory_stat_format(struct mem_cgroup *memcg)
1394 : : {
1395 : : struct seq_buf s;
1396 : : int i;
1397 : :
1398 : : seq_buf_init(&s, kmalloc(PAGE_SIZE, GFP_KERNEL), PAGE_SIZE);
1399 : 0 : if (!s.buffer)
1400 : : return NULL;
1401 : :
1402 : : /*
1403 : : * Provide statistics on the state of the memory subsystem as
1404 : : * well as cumulative event counters that show past behavior.
1405 : : *
1406 : : * This list is ordered following a combination of these gradients:
1407 : : * 1) generic big picture -> specifics and details
1408 : : * 2) reflecting userspace activity -> reflecting kernel heuristics
1409 : : *
1410 : : * Current memory state:
1411 : : */
1412 : :
1413 : 0 : seq_buf_printf(&s, "anon %llu\n",
1414 : 0 : (u64)memcg_page_state(memcg, MEMCG_RSS) *
1415 : : PAGE_SIZE);
1416 : 0 : seq_buf_printf(&s, "file %llu\n",
1417 : 0 : (u64)memcg_page_state(memcg, MEMCG_CACHE) *
1418 : : PAGE_SIZE);
1419 : 0 : seq_buf_printf(&s, "kernel_stack %llu\n",
1420 : 0 : (u64)memcg_page_state(memcg, MEMCG_KERNEL_STACK_KB) *
1421 : : 1024);
1422 : 0 : seq_buf_printf(&s, "slab %llu\n",
1423 : 0 : (u64)(memcg_page_state(memcg, NR_SLAB_RECLAIMABLE) +
1424 : : memcg_page_state(memcg, NR_SLAB_UNRECLAIMABLE)) *
1425 : : PAGE_SIZE);
1426 : 0 : seq_buf_printf(&s, "sock %llu\n",
1427 : 0 : (u64)memcg_page_state(memcg, MEMCG_SOCK) *
1428 : : PAGE_SIZE);
1429 : :
1430 : 0 : seq_buf_printf(&s, "shmem %llu\n",
1431 : 0 : (u64)memcg_page_state(memcg, NR_SHMEM) *
1432 : : PAGE_SIZE);
1433 : 0 : seq_buf_printf(&s, "file_mapped %llu\n",
1434 : 0 : (u64)memcg_page_state(memcg, NR_FILE_MAPPED) *
1435 : : PAGE_SIZE);
1436 : 0 : seq_buf_printf(&s, "file_dirty %llu\n",
1437 : 0 : (u64)memcg_page_state(memcg, NR_FILE_DIRTY) *
1438 : : PAGE_SIZE);
1439 : 0 : seq_buf_printf(&s, "file_writeback %llu\n",
1440 : 0 : (u64)memcg_page_state(memcg, NR_WRITEBACK) *
1441 : : PAGE_SIZE);
1442 : :
1443 : : /*
1444 : : * TODO: We should eventually replace our own MEMCG_RSS_HUGE counter
1445 : : * with the NR_ANON_THP vm counter, but right now it's a pain in the
1446 : : * arse because it requires migrating the work out of rmap to a place
1447 : : * where the page->mem_cgroup is set up and stable.
1448 : : */
1449 : 0 : seq_buf_printf(&s, "anon_thp %llu\n",
1450 : 0 : (u64)memcg_page_state(memcg, MEMCG_RSS_HUGE) *
1451 : : PAGE_SIZE);
1452 : :
1453 : 0 : for (i = 0; i < NR_LRU_LISTS; i++)
1454 : 0 : seq_buf_printf(&s, "%s %llu\n", mem_cgroup_lru_names[i],
1455 : 0 : (u64)memcg_page_state(memcg, NR_LRU_BASE + i) *
1456 : : PAGE_SIZE);
1457 : :
1458 : 0 : seq_buf_printf(&s, "slab_reclaimable %llu\n",
1459 : 0 : (u64)memcg_page_state(memcg, NR_SLAB_RECLAIMABLE) *
1460 : : PAGE_SIZE);
1461 : 0 : seq_buf_printf(&s, "slab_unreclaimable %llu\n",
1462 : 0 : (u64)memcg_page_state(memcg, NR_SLAB_UNRECLAIMABLE) *
1463 : : PAGE_SIZE);
1464 : :
1465 : : /* Accumulated memory events */
1466 : :
1467 : 0 : seq_buf_printf(&s, "pgfault %lu\n", memcg_events(memcg, PGFAULT));
1468 : 0 : seq_buf_printf(&s, "pgmajfault %lu\n", memcg_events(memcg, PGMAJFAULT));
1469 : :
1470 : 0 : seq_buf_printf(&s, "workingset_refault %lu\n",
1471 : : memcg_page_state(memcg, WORKINGSET_REFAULT));
1472 : 0 : seq_buf_printf(&s, "workingset_activate %lu\n",
1473 : : memcg_page_state(memcg, WORKINGSET_ACTIVATE));
1474 : 0 : seq_buf_printf(&s, "workingset_nodereclaim %lu\n",
1475 : : memcg_page_state(memcg, WORKINGSET_NODERECLAIM));
1476 : :
1477 : 0 : seq_buf_printf(&s, "pgrefill %lu\n", memcg_events(memcg, PGREFILL));
1478 : 0 : seq_buf_printf(&s, "pgscan %lu\n",
1479 : : memcg_events(memcg, PGSCAN_KSWAPD) +
1480 : : memcg_events(memcg, PGSCAN_DIRECT));
1481 : 0 : seq_buf_printf(&s, "pgsteal %lu\n",
1482 : : memcg_events(memcg, PGSTEAL_KSWAPD) +
1483 : : memcg_events(memcg, PGSTEAL_DIRECT));
1484 : 0 : seq_buf_printf(&s, "pgactivate %lu\n", memcg_events(memcg, PGACTIVATE));
1485 : 0 : seq_buf_printf(&s, "pgdeactivate %lu\n", memcg_events(memcg, PGDEACTIVATE));
1486 : 0 : seq_buf_printf(&s, "pglazyfree %lu\n", memcg_events(memcg, PGLAZYFREE));
1487 : 0 : seq_buf_printf(&s, "pglazyfreed %lu\n", memcg_events(memcg, PGLAZYFREED));
1488 : :
1489 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1490 : : seq_buf_printf(&s, "thp_fault_alloc %lu\n",
1491 : : memcg_events(memcg, THP_FAULT_ALLOC));
1492 : : seq_buf_printf(&s, "thp_collapse_alloc %lu\n",
1493 : : memcg_events(memcg, THP_COLLAPSE_ALLOC));
1494 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
1495 : :
1496 : : /* The above should easily fit into one page */
1497 : 0 : WARN_ON_ONCE(seq_buf_has_overflowed(&s));
1498 : :
1499 : 0 : return s.buffer;
1500 : : }
1501 : :
1502 : : #define K(x) ((x) << (PAGE_SHIFT-10))
1503 : : /**
1504 : : * mem_cgroup_print_oom_context: Print OOM information relevant to
1505 : : * memory controller.
1506 : : * @memcg: The memory cgroup that went over limit
1507 : : * @p: Task that is going to be killed
1508 : : *
1509 : : * NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
1510 : : * enabled
1511 : : */
1512 : 0 : void mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
1513 : : {
1514 : : rcu_read_lock();
1515 : :
1516 : 0 : if (memcg) {
1517 : 0 : pr_cont(",oom_memcg=");
1518 : 0 : pr_cont_cgroup_path(memcg->css.cgroup);
1519 : : } else
1520 : 0 : pr_cont(",global_oom");
1521 : 0 : if (p) {
1522 : 0 : pr_cont(",task_memcg=");
1523 : : pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
1524 : : }
1525 : : rcu_read_unlock();
1526 : 0 : }
1527 : :
1528 : : /**
1529 : : * mem_cgroup_print_oom_meminfo: Print OOM memory information relevant to
1530 : : * memory controller.
1531 : : * @memcg: The memory cgroup that went over limit
1532 : : */
1533 : 0 : void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
1534 : : {
1535 : : char *buf;
1536 : :
1537 : 0 : pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
1538 : : K((u64)page_counter_read(&memcg->memory)),
1539 : : K((u64)memcg->memory.max), memcg->memory.failcnt);
1540 : 0 : if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
1541 : 0 : pr_info("swap: usage %llukB, limit %llukB, failcnt %lu\n",
1542 : : K((u64)page_counter_read(&memcg->swap)),
1543 : : K((u64)memcg->swap.max), memcg->swap.failcnt);
1544 : : else {
1545 : 0 : pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
1546 : : K((u64)page_counter_read(&memcg->memsw)),
1547 : : K((u64)memcg->memsw.max), memcg->memsw.failcnt);
1548 : 0 : pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
1549 : : K((u64)page_counter_read(&memcg->kmem)),
1550 : : K((u64)memcg->kmem.max), memcg->kmem.failcnt);
1551 : : }
1552 : :
1553 : 0 : pr_info("Memory cgroup stats for ");
1554 : 0 : pr_cont_cgroup_path(memcg->css.cgroup);
1555 : 0 : pr_cont(":");
1556 : 0 : buf = memory_stat_format(memcg);
1557 : 0 : if (!buf)
1558 : 0 : return;
1559 : 0 : pr_info("%s", buf);
1560 : 0 : kfree(buf);
1561 : : }
1562 : :
1563 : : /*
1564 : : * Return the memory (and swap, if configured) limit for a memcg.
1565 : : */
1566 : 0 : unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg)
1567 : : {
1568 : : unsigned long max;
1569 : :
1570 : 0 : max = memcg->memory.max;
1571 : 0 : if (mem_cgroup_swappiness(memcg)) {
1572 : : unsigned long memsw_max;
1573 : : unsigned long swap_max;
1574 : :
1575 : 0 : memsw_max = memcg->memsw.max;
1576 : 0 : swap_max = memcg->swap.max;
1577 : 0 : swap_max = min(swap_max, (unsigned long)total_swap_pages);
1578 : 0 : max = min(max + swap_max, memsw_max);
1579 : : }
1580 : 0 : return max;
1581 : : }
1582 : :
1583 : 0 : unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
1584 : : {
1585 : 0 : return page_counter_read(&memcg->memory);
1586 : : }
1587 : :
1588 : 0 : static bool mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
1589 : : int order)
1590 : : {
1591 : 0 : struct oom_control oc = {
1592 : : .zonelist = NULL,
1593 : : .nodemask = NULL,
1594 : : .memcg = memcg,
1595 : : .gfp_mask = gfp_mask,
1596 : : .order = order,
1597 : : };
1598 : : bool ret;
1599 : :
1600 : 0 : if (mutex_lock_killable(&oom_lock))
1601 : : return true;
1602 : : /*
1603 : : * A few threads which were not waiting at mutex_lock_killable() can
1604 : : * fail to bail out. Therefore, check again after holding oom_lock.
1605 : : */
1606 : 0 : ret = should_force_charge() || out_of_memory(&oc);
1607 : 0 : mutex_unlock(&oom_lock);
1608 : 0 : return ret;
1609 : : }
1610 : :
1611 : : #if MAX_NUMNODES > 1
1612 : :
1613 : : /**
1614 : : * test_mem_cgroup_node_reclaimable
1615 : : * @memcg: the target memcg
1616 : : * @nid: the node ID to be checked.
1617 : : * @noswap : specify true here if the user wants flle only information.
1618 : : *
1619 : : * This function returns whether the specified memcg contains any
1620 : : * reclaimable pages on a node. Returns true if there are any reclaimable
1621 : : * pages in the node.
1622 : : */
1623 : : static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
1624 : : int nid, bool noswap)
1625 : : {
1626 : : struct lruvec *lruvec = mem_cgroup_lruvec(NODE_DATA(nid), memcg);
1627 : :
1628 : : if (lruvec_page_state(lruvec, NR_INACTIVE_FILE) ||
1629 : : lruvec_page_state(lruvec, NR_ACTIVE_FILE))
1630 : : return true;
1631 : : if (noswap || !total_swap_pages)
1632 : : return false;
1633 : : if (lruvec_page_state(lruvec, NR_INACTIVE_ANON) ||
1634 : : lruvec_page_state(lruvec, NR_ACTIVE_ANON))
1635 : : return true;
1636 : : return false;
1637 : :
1638 : : }
1639 : :
1640 : : /*
1641 : : * Always updating the nodemask is not very good - even if we have an empty
1642 : : * list or the wrong list here, we can start from some node and traverse all
1643 : : * nodes based on the zonelist. So update the list loosely once per 10 secs.
1644 : : *
1645 : : */
1646 : : static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
1647 : : {
1648 : : int nid;
1649 : : /*
1650 : : * numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
1651 : : * pagein/pageout changes since the last update.
1652 : : */
1653 : : if (!atomic_read(&memcg->numainfo_events))
1654 : : return;
1655 : : if (atomic_inc_return(&memcg->numainfo_updating) > 1)
1656 : : return;
1657 : :
1658 : : /* make a nodemask where this memcg uses memory from */
1659 : : memcg->scan_nodes = node_states[N_MEMORY];
1660 : :
1661 : : for_each_node_mask(nid, node_states[N_MEMORY]) {
1662 : :
1663 : : if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
1664 : : node_clear(nid, memcg->scan_nodes);
1665 : : }
1666 : :
1667 : : atomic_set(&memcg->numainfo_events, 0);
1668 : : atomic_set(&memcg->numainfo_updating, 0);
1669 : : }
1670 : :
1671 : : /*
1672 : : * Selecting a node where we start reclaim from. Because what we need is just
1673 : : * reducing usage counter, start from anywhere is O,K. Considering
1674 : : * memory reclaim from current node, there are pros. and cons.
1675 : : *
1676 : : * Freeing memory from current node means freeing memory from a node which
1677 : : * we'll use or we've used. So, it may make LRU bad. And if several threads
1678 : : * hit limits, it will see a contention on a node. But freeing from remote
1679 : : * node means more costs for memory reclaim because of memory latency.
1680 : : *
1681 : : * Now, we use round-robin. Better algorithm is welcomed.
1682 : : */
1683 : : int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1684 : : {
1685 : : int node;
1686 : :
1687 : : mem_cgroup_may_update_nodemask(memcg);
1688 : : node = memcg->last_scanned_node;
1689 : :
1690 : : node = next_node_in(node, memcg->scan_nodes);
1691 : : /*
1692 : : * mem_cgroup_may_update_nodemask might have seen no reclaimmable pages
1693 : : * last time it really checked all the LRUs due to rate limiting.
1694 : : * Fallback to the current node in that case for simplicity.
1695 : : */
1696 : : if (unlikely(node == MAX_NUMNODES))
1697 : : node = numa_node_id();
1698 : :
1699 : : memcg->last_scanned_node = node;
1700 : : return node;
1701 : : }
1702 : : #else
1703 : 0 : int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
1704 : : {
1705 : 0 : return 0;
1706 : : }
1707 : : #endif
1708 : :
1709 : 0 : static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
1710 : : pg_data_t *pgdat,
1711 : : gfp_t gfp_mask,
1712 : : unsigned long *total_scanned)
1713 : : {
1714 : : struct mem_cgroup *victim = NULL;
1715 : : int total = 0;
1716 : : int loop = 0;
1717 : : unsigned long excess;
1718 : : unsigned long nr_scanned;
1719 : 0 : struct mem_cgroup_reclaim_cookie reclaim = {
1720 : : .pgdat = pgdat,
1721 : : .priority = 0,
1722 : : };
1723 : :
1724 : : excess = soft_limit_excess(root_memcg);
1725 : :
1726 : : while (1) {
1727 : 0 : victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
1728 : 0 : if (!victim) {
1729 : 0 : loop++;
1730 : 0 : if (loop >= 2) {
1731 : : /*
1732 : : * If we have not been able to reclaim
1733 : : * anything, it might because there are
1734 : : * no reclaimable pages under this hierarchy
1735 : : */
1736 : 0 : if (!total)
1737 : : break;
1738 : : /*
1739 : : * We want to do more targeted reclaim.
1740 : : * excess >> 2 is not to excessive so as to
1741 : : * reclaim too much, nor too less that we keep
1742 : : * coming back to reclaim from this cgroup
1743 : : */
1744 : 0 : if (total >= (excess >> 2) ||
1745 : : (loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
1746 : : break;
1747 : : }
1748 : 0 : continue;
1749 : : }
1750 : 0 : total += mem_cgroup_shrink_node(victim, gfp_mask, false,
1751 : : pgdat, &nr_scanned);
1752 : 0 : *total_scanned += nr_scanned;
1753 : 0 : if (!soft_limit_excess(root_memcg))
1754 : : break;
1755 : : }
1756 : 0 : mem_cgroup_iter_break(root_memcg, victim);
1757 : 0 : return total;
1758 : : }
1759 : :
1760 : : #ifdef CONFIG_LOCKDEP
1761 : : static struct lockdep_map memcg_oom_lock_dep_map = {
1762 : : .name = "memcg_oom_lock",
1763 : : };
1764 : : #endif
1765 : :
1766 : : static DEFINE_SPINLOCK(memcg_oom_lock);
1767 : :
1768 : : /*
1769 : : * Check OOM-Killer is already running under our hierarchy.
1770 : : * If someone is running, return false.
1771 : : */
1772 : 0 : static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
1773 : : {
1774 : : struct mem_cgroup *iter, *failed = NULL;
1775 : :
1776 : : spin_lock(&memcg_oom_lock);
1777 : :
1778 : 0 : for_each_mem_cgroup_tree(iter, memcg) {
1779 : 0 : if (iter->oom_lock) {
1780 : : /*
1781 : : * this subtree of our hierarchy is already locked
1782 : : * so we cannot give a lock.
1783 : : */
1784 : 0 : failed = iter;
1785 : 0 : mem_cgroup_iter_break(memcg, iter);
1786 : 0 : break;
1787 : : } else
1788 : 0 : iter->oom_lock = true;
1789 : : }
1790 : :
1791 : 0 : if (failed) {
1792 : : /*
1793 : : * OK, we failed to lock the whole subtree so we have
1794 : : * to clean up what we set up to the failing subtree
1795 : : */
1796 : 0 : for_each_mem_cgroup_tree(iter, memcg) {
1797 : 0 : if (iter == failed) {
1798 : 0 : mem_cgroup_iter_break(memcg, iter);
1799 : 0 : break;
1800 : : }
1801 : 0 : iter->oom_lock = false;
1802 : : }
1803 : : } else
1804 : : mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);
1805 : :
1806 : : spin_unlock(&memcg_oom_lock);
1807 : :
1808 : 0 : return !failed;
1809 : : }
1810 : :
1811 : 0 : static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
1812 : : {
1813 : : struct mem_cgroup *iter;
1814 : :
1815 : : spin_lock(&memcg_oom_lock);
1816 : : mutex_release(&memcg_oom_lock_dep_map, 1, _RET_IP_);
1817 : 0 : for_each_mem_cgroup_tree(iter, memcg)
1818 : 0 : iter->oom_lock = false;
1819 : : spin_unlock(&memcg_oom_lock);
1820 : 0 : }
1821 : :
1822 : 0 : static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
1823 : : {
1824 : : struct mem_cgroup *iter;
1825 : :
1826 : : spin_lock(&memcg_oom_lock);
1827 : 0 : for_each_mem_cgroup_tree(iter, memcg)
1828 : 0 : iter->under_oom++;
1829 : : spin_unlock(&memcg_oom_lock);
1830 : 0 : }
1831 : :
1832 : 0 : static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
1833 : : {
1834 : : struct mem_cgroup *iter;
1835 : :
1836 : : /*
1837 : : * When a new child is created while the hierarchy is under oom,
1838 : : * mem_cgroup_oom_lock() may not be called. Watch for underflow.
1839 : : */
1840 : : spin_lock(&memcg_oom_lock);
1841 : 0 : for_each_mem_cgroup_tree(iter, memcg)
1842 : 0 : if (iter->under_oom > 0)
1843 : 0 : iter->under_oom--;
1844 : : spin_unlock(&memcg_oom_lock);
1845 : 0 : }
1846 : :
1847 : : static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
1848 : :
1849 : : struct oom_wait_info {
1850 : : struct mem_cgroup *memcg;
1851 : : wait_queue_entry_t wait;
1852 : : };
1853 : :
1854 : 0 : static int memcg_oom_wake_function(wait_queue_entry_t *wait,
1855 : : unsigned mode, int sync, void *arg)
1856 : : {
1857 : : struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
1858 : : struct mem_cgroup *oom_wait_memcg;
1859 : : struct oom_wait_info *oom_wait_info;
1860 : :
1861 : : oom_wait_info = container_of(wait, struct oom_wait_info, wait);
1862 : 0 : oom_wait_memcg = oom_wait_info->memcg;
1863 : :
1864 : 0 : if (!mem_cgroup_is_descendant(wake_memcg, oom_wait_memcg) &&
1865 : 0 : !mem_cgroup_is_descendant(oom_wait_memcg, wake_memcg))
1866 : : return 0;
1867 : 0 : return autoremove_wake_function(wait, mode, sync, arg);
1868 : : }
1869 : :
1870 : 0 : static void memcg_oom_recover(struct mem_cgroup *memcg)
1871 : : {
1872 : : /*
1873 : : * For the following lockless ->under_oom test, the only required
1874 : : * guarantee is that it must see the state asserted by an OOM when
1875 : : * this function is called as a result of userland actions
1876 : : * triggered by the notification of the OOM. This is trivially
1877 : : * achieved by invoking mem_cgroup_mark_under_oom() before
1878 : : * triggering notification.
1879 : : */
1880 : 0 : if (memcg && memcg->under_oom)
1881 : 0 : __wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
1882 : 0 : }
1883 : :
1884 : : enum oom_status {
1885 : : OOM_SUCCESS,
1886 : : OOM_FAILED,
1887 : : OOM_ASYNC,
1888 : : OOM_SKIPPED
1889 : : };
1890 : :
1891 : 0 : static enum oom_status mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
1892 : : {
1893 : : enum oom_status ret;
1894 : : bool locked;
1895 : :
1896 : 0 : if (order > PAGE_ALLOC_COSTLY_ORDER)
1897 : : return OOM_SKIPPED;
1898 : :
1899 : 0 : memcg_memory_event(memcg, MEMCG_OOM);
1900 : :
1901 : : /*
1902 : : * We are in the middle of the charge context here, so we
1903 : : * don't want to block when potentially sitting on a callstack
1904 : : * that holds all kinds of filesystem and mm locks.
1905 : : *
1906 : : * cgroup1 allows disabling the OOM killer and waiting for outside
1907 : : * handling until the charge can succeed; remember the context and put
1908 : : * the task to sleep at the end of the page fault when all locks are
1909 : : * released.
1910 : : *
1911 : : * On the other hand, in-kernel OOM killer allows for an async victim
1912 : : * memory reclaim (oom_reaper) and that means that we are not solely
1913 : : * relying on the oom victim to make a forward progress and we can
1914 : : * invoke the oom killer here.
1915 : : *
1916 : : * Please note that mem_cgroup_out_of_memory might fail to find a
1917 : : * victim and then we have to bail out from the charge path.
1918 : : */
1919 : 0 : if (memcg->oom_kill_disable) {
1920 : 0 : if (!current->in_user_fault)
1921 : : return OOM_SKIPPED;
1922 : : css_get(&memcg->css);
1923 : 0 : current->memcg_in_oom = memcg;
1924 : 0 : current->memcg_oom_gfp_mask = mask;
1925 : 0 : current->memcg_oom_order = order;
1926 : :
1927 : 0 : return OOM_ASYNC;
1928 : : }
1929 : :
1930 : 0 : mem_cgroup_mark_under_oom(memcg);
1931 : :
1932 : 0 : locked = mem_cgroup_oom_trylock(memcg);
1933 : :
1934 : 0 : if (locked)
1935 : 0 : mem_cgroup_oom_notify(memcg);
1936 : :
1937 : 0 : mem_cgroup_unmark_under_oom(memcg);
1938 : 0 : if (mem_cgroup_out_of_memory(memcg, mask, order))
1939 : : ret = OOM_SUCCESS;
1940 : : else
1941 : : ret = OOM_FAILED;
1942 : :
1943 : 0 : if (locked)
1944 : 0 : mem_cgroup_oom_unlock(memcg);
1945 : :
1946 : 0 : return ret;
1947 : : }
1948 : :
1949 : : /**
1950 : : * mem_cgroup_oom_synchronize - complete memcg OOM handling
1951 : : * @handle: actually kill/wait or just clean up the OOM state
1952 : : *
1953 : : * This has to be called at the end of a page fault if the memcg OOM
1954 : : * handler was enabled.
1955 : : *
1956 : : * Memcg supports userspace OOM handling where failed allocations must
1957 : : * sleep on a waitqueue until the userspace task resolves the
1958 : : * situation. Sleeping directly in the charge context with all kinds
1959 : : * of locks held is not a good idea, instead we remember an OOM state
1960 : : * in the task and mem_cgroup_oom_synchronize() has to be called at
1961 : : * the end of the page fault to complete the OOM handling.
1962 : : *
1963 : : * Returns %true if an ongoing memcg OOM situation was detected and
1964 : : * completed, %false otherwise.
1965 : : */
1966 : 0 : bool mem_cgroup_oom_synchronize(bool handle)
1967 : : {
1968 : 0 : struct mem_cgroup *memcg = current->memcg_in_oom;
1969 : : struct oom_wait_info owait;
1970 : : bool locked;
1971 : :
1972 : : /* OOM is global, do not handle */
1973 : 0 : if (!memcg)
1974 : : return false;
1975 : :
1976 : 0 : if (!handle)
1977 : : goto cleanup;
1978 : :
1979 : 0 : owait.memcg = memcg;
1980 : 0 : owait.wait.flags = 0;
1981 : 0 : owait.wait.func = memcg_oom_wake_function;
1982 : 0 : owait.wait.private = current;
1983 : : INIT_LIST_HEAD(&owait.wait.entry);
1984 : :
1985 : 0 : prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
1986 : 0 : mem_cgroup_mark_under_oom(memcg);
1987 : :
1988 : 0 : locked = mem_cgroup_oom_trylock(memcg);
1989 : :
1990 : 0 : if (locked)
1991 : 0 : mem_cgroup_oom_notify(memcg);
1992 : :
1993 : 0 : if (locked && !memcg->oom_kill_disable) {
1994 : 0 : mem_cgroup_unmark_under_oom(memcg);
1995 : 0 : finish_wait(&memcg_oom_waitq, &owait.wait);
1996 : 0 : mem_cgroup_out_of_memory(memcg, current->memcg_oom_gfp_mask,
1997 : : current->memcg_oom_order);
1998 : : } else {
1999 : 0 : schedule();
2000 : 0 : mem_cgroup_unmark_under_oom(memcg);
2001 : 0 : finish_wait(&memcg_oom_waitq, &owait.wait);
2002 : : }
2003 : :
2004 : 0 : if (locked) {
2005 : 0 : mem_cgroup_oom_unlock(memcg);
2006 : : /*
2007 : : * There is no guarantee that an OOM-lock contender
2008 : : * sees the wakeups triggered by the OOM kill
2009 : : * uncharges. Wake any sleepers explicitely.
2010 : : */
2011 : 0 : memcg_oom_recover(memcg);
2012 : : }
2013 : : cleanup:
2014 : 0 : current->memcg_in_oom = NULL;
2015 : : css_put(&memcg->css);
2016 : : return true;
2017 : : }
2018 : :
2019 : : /**
2020 : : * mem_cgroup_get_oom_group - get a memory cgroup to clean up after OOM
2021 : : * @victim: task to be killed by the OOM killer
2022 : : * @oom_domain: memcg in case of memcg OOM, NULL in case of system-wide OOM
2023 : : *
2024 : : * Returns a pointer to a memory cgroup, which has to be cleaned up
2025 : : * by killing all belonging OOM-killable tasks.
2026 : : *
2027 : : * Caller has to call mem_cgroup_put() on the returned non-NULL memcg.
2028 : : */
2029 : 0 : struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
2030 : : struct mem_cgroup *oom_domain)
2031 : : {
2032 : : struct mem_cgroup *oom_group = NULL;
2033 : : struct mem_cgroup *memcg;
2034 : :
2035 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
2036 : : return NULL;
2037 : :
2038 : 0 : if (!oom_domain)
2039 : 0 : oom_domain = root_mem_cgroup;
2040 : :
2041 : : rcu_read_lock();
2042 : :
2043 : : memcg = mem_cgroup_from_task(victim);
2044 : 0 : if (memcg == root_mem_cgroup)
2045 : : goto out;
2046 : :
2047 : : /*
2048 : : * Traverse the memory cgroup hierarchy from the victim task's
2049 : : * cgroup up to the OOMing cgroup (or root) to find the
2050 : : * highest-level memory cgroup with oom.group set.
2051 : : */
2052 : 0 : for (; memcg; memcg = parent_mem_cgroup(memcg)) {
2053 : 0 : if (memcg->oom_group)
2054 : : oom_group = memcg;
2055 : :
2056 : 0 : if (memcg == oom_domain)
2057 : : break;
2058 : : }
2059 : :
2060 : 0 : if (oom_group)
2061 : : css_get(&oom_group->css);
2062 : : out:
2063 : : rcu_read_unlock();
2064 : :
2065 : 0 : return oom_group;
2066 : : }
2067 : :
2068 : 0 : void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
2069 : : {
2070 : 0 : pr_info("Tasks in ");
2071 : 0 : pr_cont_cgroup_path(memcg->css.cgroup);
2072 : 0 : pr_cont(" are going to be killed due to memory.oom.group set\n");
2073 : 0 : }
2074 : :
2075 : : /**
2076 : : * lock_page_memcg - lock a page->mem_cgroup binding
2077 : : * @page: the page
2078 : : *
2079 : : * This function protects unlocked LRU pages from being moved to
2080 : : * another cgroup.
2081 : : *
2082 : : * It ensures lifetime of the returned memcg. Caller is responsible
2083 : : * for the lifetime of the page; __unlock_page_memcg() is available
2084 : : * when @page might get freed inside the locked section.
2085 : : */
2086 : 3 : struct mem_cgroup *lock_page_memcg(struct page *page)
2087 : : {
2088 : : struct mem_cgroup *memcg;
2089 : : unsigned long flags;
2090 : :
2091 : : /*
2092 : : * The RCU lock is held throughout the transaction. The fast
2093 : : * path can get away without acquiring the memcg->move_lock
2094 : : * because page moving starts with an RCU grace period.
2095 : : *
2096 : : * The RCU lock also protects the memcg from being freed when
2097 : : * the page state that is going to change is the only thing
2098 : : * preventing the page itself from being freed. E.g. writeback
2099 : : * doesn't hold a page reference and relies on PG_writeback to
2100 : : * keep off truncation, migration and so forth.
2101 : : */
2102 : : rcu_read_lock();
2103 : :
2104 : 3 : if (mem_cgroup_disabled())
2105 : : return NULL;
2106 : : again:
2107 : 0 : memcg = page->mem_cgroup;
2108 : 0 : if (unlikely(!memcg))
2109 : : return NULL;
2110 : :
2111 : 0 : if (atomic_read(&memcg->moving_account) <= 0)
2112 : 0 : return memcg;
2113 : :
2114 : 0 : spin_lock_irqsave(&memcg->move_lock, flags);
2115 : 0 : if (memcg != page->mem_cgroup) {
2116 : : spin_unlock_irqrestore(&memcg->move_lock, flags);
2117 : : goto again;
2118 : : }
2119 : :
2120 : : /*
2121 : : * When charge migration first begins, we can have locked and
2122 : : * unlocked page stat updates happening concurrently. Track
2123 : : * the task who has the lock for unlock_page_memcg().
2124 : : */
2125 : 0 : memcg->move_lock_task = current;
2126 : 0 : memcg->move_lock_flags = flags;
2127 : :
2128 : 0 : return memcg;
2129 : : }
2130 : : EXPORT_SYMBOL(lock_page_memcg);
2131 : :
2132 : : /**
2133 : : * __unlock_page_memcg - unlock and unpin a memcg
2134 : : * @memcg: the memcg
2135 : : *
2136 : : * Unlock and unpin a memcg returned by lock_page_memcg().
2137 : : */
2138 : 3 : void __unlock_page_memcg(struct mem_cgroup *memcg)
2139 : : {
2140 : 3 : if (memcg && memcg->move_lock_task == current) {
2141 : 0 : unsigned long flags = memcg->move_lock_flags;
2142 : :
2143 : 0 : memcg->move_lock_task = NULL;
2144 : 0 : memcg->move_lock_flags = 0;
2145 : :
2146 : : spin_unlock_irqrestore(&memcg->move_lock, flags);
2147 : : }
2148 : :
2149 : : rcu_read_unlock();
2150 : 3 : }
2151 : :
2152 : : /**
2153 : : * unlock_page_memcg - unlock a page->mem_cgroup binding
2154 : : * @page: the page
2155 : : */
2156 : 3 : void unlock_page_memcg(struct page *page)
2157 : : {
2158 : 3 : __unlock_page_memcg(page->mem_cgroup);
2159 : 3 : }
2160 : : EXPORT_SYMBOL(unlock_page_memcg);
2161 : :
2162 : : struct memcg_stock_pcp {
2163 : : struct mem_cgroup *cached; /* this never be root cgroup */
2164 : : unsigned int nr_pages;
2165 : : struct work_struct work;
2166 : : unsigned long flags;
2167 : : #define FLUSHING_CACHED_CHARGE 0
2168 : : };
2169 : : static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
2170 : : static DEFINE_MUTEX(percpu_charge_mutex);
2171 : :
2172 : : /**
2173 : : * consume_stock: Try to consume stocked charge on this cpu.
2174 : : * @memcg: memcg to consume from.
2175 : : * @nr_pages: how many pages to charge.
2176 : : *
2177 : : * The charges will only happen if @memcg matches the current cpu's memcg
2178 : : * stock, and at least @nr_pages are available in that stock. Failure to
2179 : : * service an allocation will refill the stock.
2180 : : *
2181 : : * returns true if successful, false otherwise.
2182 : : */
2183 : 0 : static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2184 : : {
2185 : : struct memcg_stock_pcp *stock;
2186 : : unsigned long flags;
2187 : : bool ret = false;
2188 : :
2189 : 0 : if (nr_pages > MEMCG_CHARGE_BATCH)
2190 : : return ret;
2191 : :
2192 : 0 : local_irq_save(flags);
2193 : :
2194 : 0 : stock = this_cpu_ptr(&memcg_stock);
2195 : 0 : if (memcg == stock->cached && stock->nr_pages >= nr_pages) {
2196 : 0 : stock->nr_pages -= nr_pages;
2197 : : ret = true;
2198 : : }
2199 : :
2200 : 0 : local_irq_restore(flags);
2201 : :
2202 : 0 : return ret;
2203 : : }
2204 : :
2205 : : /*
2206 : : * Returns stocks cached in percpu and reset cached information.
2207 : : */
2208 : 0 : static void drain_stock(struct memcg_stock_pcp *stock)
2209 : : {
2210 : 0 : struct mem_cgroup *old = stock->cached;
2211 : :
2212 : 0 : if (stock->nr_pages) {
2213 : 0 : page_counter_uncharge(&old->memory, stock->nr_pages);
2214 : : if (do_memsw_account())
2215 : : page_counter_uncharge(&old->memsw, stock->nr_pages);
2216 : 0 : css_put_many(&old->css, stock->nr_pages);
2217 : 0 : stock->nr_pages = 0;
2218 : : }
2219 : 0 : stock->cached = NULL;
2220 : 0 : }
2221 : :
2222 : 0 : static void drain_local_stock(struct work_struct *dummy)
2223 : : {
2224 : : struct memcg_stock_pcp *stock;
2225 : : unsigned long flags;
2226 : :
2227 : : /*
2228 : : * The only protection from memory hotplug vs. drain_stock races is
2229 : : * that we always operate on local CPU stock here with IRQ disabled
2230 : : */
2231 : 0 : local_irq_save(flags);
2232 : :
2233 : 0 : stock = this_cpu_ptr(&memcg_stock);
2234 : 0 : drain_stock(stock);
2235 : 0 : clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
2236 : :
2237 : 0 : local_irq_restore(flags);
2238 : 0 : }
2239 : :
2240 : : /*
2241 : : * Cache charges(val) to local per_cpu area.
2242 : : * This will be consumed by consume_stock() function, later.
2243 : : */
2244 : 0 : static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
2245 : : {
2246 : : struct memcg_stock_pcp *stock;
2247 : : unsigned long flags;
2248 : :
2249 : 0 : local_irq_save(flags);
2250 : :
2251 : 0 : stock = this_cpu_ptr(&memcg_stock);
2252 : 0 : if (stock->cached != memcg) { /* reset if necessary */
2253 : 0 : drain_stock(stock);
2254 : 0 : stock->cached = memcg;
2255 : : }
2256 : 0 : stock->nr_pages += nr_pages;
2257 : :
2258 : 0 : if (stock->nr_pages > MEMCG_CHARGE_BATCH)
2259 : 0 : drain_stock(stock);
2260 : :
2261 : 0 : local_irq_restore(flags);
2262 : 0 : }
2263 : :
2264 : : /*
2265 : : * Drains all per-CPU charge caches for given root_memcg resp. subtree
2266 : : * of the hierarchy under it.
2267 : : */
2268 : 0 : static void drain_all_stock(struct mem_cgroup *root_memcg)
2269 : : {
2270 : : int cpu, curcpu;
2271 : :
2272 : : /* If someone's already draining, avoid adding running more workers. */
2273 : 0 : if (!mutex_trylock(&percpu_charge_mutex))
2274 : 0 : return;
2275 : : /*
2276 : : * Notify other cpus that system-wide "drain" is running
2277 : : * We do not care about races with the cpu hotplug because cpu down
2278 : : * as well as workers from this path always operate on the local
2279 : : * per-cpu data. CPU up doesn't touch memcg_stock at all.
2280 : : */
2281 : 0 : curcpu = get_cpu();
2282 : 0 : for_each_online_cpu(cpu) {
2283 : 0 : struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
2284 : : struct mem_cgroup *memcg;
2285 : : bool flush = false;
2286 : :
2287 : : rcu_read_lock();
2288 : 0 : memcg = stock->cached;
2289 : 0 : if (memcg && stock->nr_pages &&
2290 : 0 : mem_cgroup_is_descendant(memcg, root_memcg))
2291 : : flush = true;
2292 : : rcu_read_unlock();
2293 : :
2294 : 0 : if (flush &&
2295 : 0 : !test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
2296 : 0 : if (cpu == curcpu)
2297 : 0 : drain_local_stock(&stock->work);
2298 : : else
2299 : 0 : schedule_work_on(cpu, &stock->work);
2300 : : }
2301 : : }
2302 : 0 : put_cpu();
2303 : 0 : mutex_unlock(&percpu_charge_mutex);
2304 : : }
2305 : :
2306 : 0 : static int memcg_hotplug_cpu_dead(unsigned int cpu)
2307 : : {
2308 : : struct memcg_stock_pcp *stock;
2309 : : struct mem_cgroup *memcg, *mi;
2310 : :
2311 : 0 : stock = &per_cpu(memcg_stock, cpu);
2312 : 0 : drain_stock(stock);
2313 : :
2314 : 0 : for_each_mem_cgroup(memcg) {
2315 : : int i;
2316 : :
2317 : 0 : for (i = 0; i < MEMCG_NR_STAT; i++) {
2318 : : int nid;
2319 : : long x;
2320 : :
2321 : 0 : x = this_cpu_xchg(memcg->vmstats_percpu->stat[i], 0);
2322 : 0 : if (x)
2323 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
2324 : 0 : atomic_long_add(x, &memcg->vmstats[i]);
2325 : :
2326 : 0 : if (i >= NR_VM_NODE_STAT_ITEMS)
2327 : 0 : continue;
2328 : :
2329 : 0 : for_each_node(nid) {
2330 : : struct mem_cgroup_per_node *pn;
2331 : :
2332 : : pn = mem_cgroup_nodeinfo(memcg, nid);
2333 : 0 : x = this_cpu_xchg(pn->lruvec_stat_cpu->count[i], 0);
2334 : 0 : if (x)
2335 : : do {
2336 : 0 : atomic_long_add(x, &pn->lruvec_stat[i]);
2337 : 0 : } while ((pn = parent_nodeinfo(pn, nid)));
2338 : : }
2339 : : }
2340 : :
2341 : 0 : for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
2342 : : long x;
2343 : :
2344 : 0 : x = this_cpu_xchg(memcg->vmstats_percpu->events[i], 0);
2345 : 0 : if (x)
2346 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
2347 : 0 : atomic_long_add(x, &memcg->vmevents[i]);
2348 : : }
2349 : : }
2350 : :
2351 : 0 : return 0;
2352 : : }
2353 : :
2354 : 0 : static void reclaim_high(struct mem_cgroup *memcg,
2355 : : unsigned int nr_pages,
2356 : : gfp_t gfp_mask)
2357 : : {
2358 : : do {
2359 : 0 : if (page_counter_read(&memcg->memory) <= memcg->high)
2360 : 0 : continue;
2361 : 0 : memcg_memory_event(memcg, MEMCG_HIGH);
2362 : 0 : try_to_free_mem_cgroup_pages(memcg, nr_pages, gfp_mask, true);
2363 : 0 : } while ((memcg = parent_mem_cgroup(memcg)));
2364 : 0 : }
2365 : :
2366 : 0 : static void high_work_func(struct work_struct *work)
2367 : : {
2368 : : struct mem_cgroup *memcg;
2369 : :
2370 : 0 : memcg = container_of(work, struct mem_cgroup, high_work);
2371 : 0 : reclaim_high(memcg, MEMCG_CHARGE_BATCH, GFP_KERNEL);
2372 : 0 : }
2373 : :
2374 : : /*
2375 : : * Clamp the maximum sleep time per allocation batch to 2 seconds. This is
2376 : : * enough to still cause a significant slowdown in most cases, while still
2377 : : * allowing diagnostics and tracing to proceed without becoming stuck.
2378 : : */
2379 : : #define MEMCG_MAX_HIGH_DELAY_JIFFIES (2UL*HZ)
2380 : :
2381 : : /*
2382 : : * When calculating the delay, we use these either side of the exponentiation to
2383 : : * maintain precision and scale to a reasonable number of jiffies (see the table
2384 : : * below.
2385 : : *
2386 : : * - MEMCG_DELAY_PRECISION_SHIFT: Extra precision bits while translating the
2387 : : * overage ratio to a delay.
2388 : : * - MEMCG_DELAY_SCALING_SHIFT: The number of bits to scale down down the
2389 : : * proposed penalty in order to reduce to a reasonable number of jiffies, and
2390 : : * to produce a reasonable delay curve.
2391 : : *
2392 : : * MEMCG_DELAY_SCALING_SHIFT just happens to be a number that produces a
2393 : : * reasonable delay curve compared to precision-adjusted overage, not
2394 : : * penalising heavily at first, but still making sure that growth beyond the
2395 : : * limit penalises misbehaviour cgroups by slowing them down exponentially. For
2396 : : * example, with a high of 100 megabytes:
2397 : : *
2398 : : * +-------+------------------------+
2399 : : * | usage | time to allocate in ms |
2400 : : * +-------+------------------------+
2401 : : * | 100M | 0 |
2402 : : * | 101M | 6 |
2403 : : * | 102M | 25 |
2404 : : * | 103M | 57 |
2405 : : * | 104M | 102 |
2406 : : * | 105M | 159 |
2407 : : * | 106M | 230 |
2408 : : * | 107M | 313 |
2409 : : * | 108M | 409 |
2410 : : * | 109M | 518 |
2411 : : * | 110M | 639 |
2412 : : * | 111M | 774 |
2413 : : * | 112M | 921 |
2414 : : * | 113M | 1081 |
2415 : : * | 114M | 1254 |
2416 : : * | 115M | 1439 |
2417 : : * | 116M | 1638 |
2418 : : * | 117M | 1849 |
2419 : : * | 118M | 2000 |
2420 : : * | 119M | 2000 |
2421 : : * | 120M | 2000 |
2422 : : * +-------+------------------------+
2423 : : */
2424 : : #define MEMCG_DELAY_PRECISION_SHIFT 20
2425 : : #define MEMCG_DELAY_SCALING_SHIFT 14
2426 : :
2427 : : /*
2428 : : * Get the number of jiffies that we should penalise a mischievous cgroup which
2429 : : * is exceeding its memory.high by checking both it and its ancestors.
2430 : : */
2431 : 0 : static unsigned long calculate_high_delay(struct mem_cgroup *memcg,
2432 : : unsigned int nr_pages)
2433 : : {
2434 : : unsigned long penalty_jiffies;
2435 : : u64 max_overage = 0;
2436 : :
2437 : : do {
2438 : : unsigned long usage, high;
2439 : : u64 overage;
2440 : :
2441 : : usage = page_counter_read(&memcg->memory);
2442 : : high = READ_ONCE(memcg->high);
2443 : :
2444 : 0 : if (usage <= high)
2445 : 0 : continue;
2446 : :
2447 : : /*
2448 : : * Prevent division by 0 in overage calculation by acting as if
2449 : : * it was a threshold of 1 page
2450 : : */
2451 : 0 : high = max(high, 1UL);
2452 : :
2453 : 0 : overage = usage - high;
2454 : 0 : overage <<= MEMCG_DELAY_PRECISION_SHIFT;
2455 : 0 : overage = div64_u64(overage, high);
2456 : :
2457 : : if (overage > max_overage)
2458 : : max_overage = overage;
2459 : 0 : } while ((memcg = parent_mem_cgroup(memcg)) &&
2460 : 0 : !mem_cgroup_is_root(memcg));
2461 : :
2462 : : if (!max_overage)
2463 : : return 0;
2464 : :
2465 : : /*
2466 : : * We use overage compared to memory.high to calculate the number of
2467 : : * jiffies to sleep (penalty_jiffies). Ideally this value should be
2468 : : * fairly lenient on small overages, and increasingly harsh when the
2469 : : * memcg in question makes it clear that it has no intention of stopping
2470 : : * its crazy behaviour, so we exponentially increase the delay based on
2471 : : * overage amount.
2472 : : */
2473 : : penalty_jiffies = max_overage * max_overage * HZ;
2474 : : penalty_jiffies >>= MEMCG_DELAY_PRECISION_SHIFT;
2475 : : penalty_jiffies >>= MEMCG_DELAY_SCALING_SHIFT;
2476 : :
2477 : : /*
2478 : : * Factor in the task's own contribution to the overage, such that four
2479 : : * N-sized allocations are throttled approximately the same as one
2480 : : * 4N-sized allocation.
2481 : : *
2482 : : * MEMCG_CHARGE_BATCH pages is nominal, so work out how much smaller or
2483 : : * larger the current charge patch is than that.
2484 : : */
2485 : : penalty_jiffies = penalty_jiffies * nr_pages / MEMCG_CHARGE_BATCH;
2486 : :
2487 : : /*
2488 : : * Clamp the max delay per usermode return so as to still keep the
2489 : : * application moving forwards and also permit diagnostics, albeit
2490 : : * extremely slowly.
2491 : : */
2492 : : return min(penalty_jiffies, MEMCG_MAX_HIGH_DELAY_JIFFIES);
2493 : : }
2494 : :
2495 : : /*
2496 : : * Scheduled by try_charge() to be executed from the userland return path
2497 : : * and reclaims memory over the high limit.
2498 : : */
2499 : 3 : void mem_cgroup_handle_over_high(void)
2500 : : {
2501 : : unsigned long penalty_jiffies;
2502 : : unsigned long pflags;
2503 : 3 : unsigned int nr_pages = current->memcg_nr_pages_over_high;
2504 : : struct mem_cgroup *memcg;
2505 : :
2506 : 3 : if (likely(!nr_pages))
2507 : 3 : return;
2508 : :
2509 : 0 : memcg = get_mem_cgroup_from_mm(current->mm);
2510 : 0 : reclaim_high(memcg, nr_pages, GFP_KERNEL);
2511 : 0 : current->memcg_nr_pages_over_high = 0;
2512 : :
2513 : : /*
2514 : : * memory.high is breached and reclaim is unable to keep up. Throttle
2515 : : * allocators proactively to slow down excessive growth.
2516 : : */
2517 : 0 : penalty_jiffies = calculate_high_delay(memcg, nr_pages);
2518 : :
2519 : : /*
2520 : : * Don't sleep if the amount of jiffies this memcg owes us is so low
2521 : : * that it's not even worth doing, in an attempt to be nice to those who
2522 : : * go only a small amount over their memory.high value and maybe haven't
2523 : : * been aggressively reclaimed enough yet.
2524 : : */
2525 : 0 : if (penalty_jiffies <= HZ / 100)
2526 : : goto out;
2527 : :
2528 : : /*
2529 : : * If we exit early, we're guaranteed to die (since
2530 : : * schedule_timeout_killable sets TASK_KILLABLE). This means we don't
2531 : : * need to account for any ill-begotten jiffies to pay them off later.
2532 : : */
2533 : : psi_memstall_enter(&pflags);
2534 : 0 : schedule_timeout_killable(penalty_jiffies);
2535 : : psi_memstall_leave(&pflags);
2536 : :
2537 : : out:
2538 : : css_put(&memcg->css);
2539 : : }
2540 : :
2541 : 0 : static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
2542 : : unsigned int nr_pages)
2543 : : {
2544 : 0 : unsigned int batch = max(MEMCG_CHARGE_BATCH, nr_pages);
2545 : : int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
2546 : : struct mem_cgroup *mem_over_limit;
2547 : : struct page_counter *counter;
2548 : : unsigned long nr_reclaimed;
2549 : : bool may_swap = true;
2550 : : bool drained = false;
2551 : : enum oom_status oom_status;
2552 : :
2553 : 0 : if (mem_cgroup_is_root(memcg))
2554 : : return 0;
2555 : : retry:
2556 : 0 : if (consume_stock(memcg, nr_pages))
2557 : : return 0;
2558 : :
2559 : : if (!do_memsw_account() ||
2560 : : page_counter_try_charge(&memcg->memsw, batch, &counter)) {
2561 : 0 : if (page_counter_try_charge(&memcg->memory, batch, &counter))
2562 : : goto done_restock;
2563 : : if (do_memsw_account())
2564 : : page_counter_uncharge(&memcg->memsw, batch);
2565 : 0 : mem_over_limit = mem_cgroup_from_counter(counter, memory);
2566 : : } else {
2567 : : mem_over_limit = mem_cgroup_from_counter(counter, memsw);
2568 : : may_swap = false;
2569 : : }
2570 : :
2571 : 0 : if (batch > nr_pages) {
2572 : : batch = nr_pages;
2573 : : goto retry;
2574 : : }
2575 : :
2576 : : /*
2577 : : * Memcg doesn't have a dedicated reserve for atomic
2578 : : * allocations. But like the global atomic pool, we need to
2579 : : * put the burden of reclaim on regular allocation requests
2580 : : * and let these go through as privileged allocations.
2581 : : */
2582 : 0 : if (gfp_mask & __GFP_ATOMIC)
2583 : : goto force;
2584 : :
2585 : : /*
2586 : : * Unlike in global OOM situations, memcg is not in a physical
2587 : : * memory shortage. Allow dying and OOM-killed tasks to
2588 : : * bypass the last charges so that they can exit quickly and
2589 : : * free their memory.
2590 : : */
2591 : 0 : if (unlikely(should_force_charge()))
2592 : : goto force;
2593 : :
2594 : : /*
2595 : : * Prevent unbounded recursion when reclaim operations need to
2596 : : * allocate memory. This might exceed the limits temporarily,
2597 : : * but we prefer facilitating memory reclaim and getting back
2598 : : * under the limit over triggering OOM kills in these cases.
2599 : : */
2600 : 0 : if (unlikely(current->flags & PF_MEMALLOC))
2601 : : goto force;
2602 : :
2603 : 0 : if (unlikely(task_in_memcg_oom(current)))
2604 : : goto nomem;
2605 : :
2606 : 0 : if (!gfpflags_allow_blocking(gfp_mask))
2607 : : goto nomem;
2608 : :
2609 : 0 : memcg_memory_event(mem_over_limit, MEMCG_MAX);
2610 : :
2611 : 0 : nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
2612 : : gfp_mask, may_swap);
2613 : :
2614 : 0 : if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
2615 : : goto retry;
2616 : :
2617 : 0 : if (!drained) {
2618 : 0 : drain_all_stock(mem_over_limit);
2619 : : drained = true;
2620 : 0 : goto retry;
2621 : : }
2622 : :
2623 : 0 : if (gfp_mask & __GFP_NORETRY)
2624 : : goto nomem;
2625 : : /*
2626 : : * Even though the limit is exceeded at this point, reclaim
2627 : : * may have been able to free some pages. Retry the charge
2628 : : * before killing the task.
2629 : : *
2630 : : * Only for regular pages, though: huge pages are rather
2631 : : * unlikely to succeed so close to the limit, and we fall back
2632 : : * to regular pages anyway in case of failure.
2633 : : */
2634 : 0 : if (nr_reclaimed && nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER))
2635 : : goto retry;
2636 : : /*
2637 : : * At task move, charge accounts can be doubly counted. So, it's
2638 : : * better to wait until the end of task_move if something is going on.
2639 : : */
2640 : 0 : if (mem_cgroup_wait_acct_move(mem_over_limit))
2641 : : goto retry;
2642 : :
2643 : 0 : if (nr_retries--)
2644 : : goto retry;
2645 : :
2646 : 0 : if (gfp_mask & __GFP_RETRY_MAYFAIL)
2647 : : goto nomem;
2648 : :
2649 : 0 : if (gfp_mask & __GFP_NOFAIL)
2650 : : goto force;
2651 : :
2652 : 0 : if (fatal_signal_pending(current))
2653 : : goto force;
2654 : :
2655 : : /*
2656 : : * keep retrying as long as the memcg oom killer is able to make
2657 : : * a forward progress or bypass the charge if the oom killer
2658 : : * couldn't make any progress.
2659 : : */
2660 : 0 : oom_status = mem_cgroup_oom(mem_over_limit, gfp_mask,
2661 : : get_order(nr_pages * PAGE_SIZE));
2662 : 0 : switch (oom_status) {
2663 : : case OOM_SUCCESS:
2664 : : nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
2665 : : goto retry;
2666 : : case OOM_FAILED:
2667 : : goto force;
2668 : : default:
2669 : : goto nomem;
2670 : : }
2671 : : nomem:
2672 : 0 : if (!(gfp_mask & __GFP_NOFAIL))
2673 : : return -ENOMEM;
2674 : : force:
2675 : : /*
2676 : : * The allocation either can't fail or will lead to more memory
2677 : : * being freed very soon. Allow memory usage go over the limit
2678 : : * temporarily by force charging it.
2679 : : */
2680 : 0 : page_counter_charge(&memcg->memory, nr_pages);
2681 : : if (do_memsw_account())
2682 : : page_counter_charge(&memcg->memsw, nr_pages);
2683 : : css_get_many(&memcg->css, nr_pages);
2684 : :
2685 : : return 0;
2686 : :
2687 : : done_restock:
2688 : : css_get_many(&memcg->css, batch);
2689 : 0 : if (batch > nr_pages)
2690 : 0 : refill_stock(memcg, batch - nr_pages);
2691 : :
2692 : : /*
2693 : : * If the hierarchy is above the normal consumption range, schedule
2694 : : * reclaim on returning to userland. We can perform reclaim here
2695 : : * if __GFP_RECLAIM but let's always punt for simplicity and so that
2696 : : * GFP_KERNEL can consistently be used during reclaim. @memcg is
2697 : : * not recorded as it most likely matches current's and won't
2698 : : * change in the meantime. As high limit is checked again before
2699 : : * reclaim, the cost of mismatch is negligible.
2700 : : */
2701 : : do {
2702 : 0 : if (page_counter_read(&memcg->memory) > memcg->high) {
2703 : : /* Don't bother a random interrupted task */
2704 : 0 : if (in_interrupt()) {
2705 : 0 : schedule_work(&memcg->high_work);
2706 : : break;
2707 : : }
2708 : 0 : current->memcg_nr_pages_over_high += batch;
2709 : 0 : set_notify_resume(current);
2710 : 0 : break;
2711 : : }
2712 : 0 : } while ((memcg = parent_mem_cgroup(memcg)));
2713 : :
2714 : : return 0;
2715 : : }
2716 : :
2717 : 0 : static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
2718 : : {
2719 : 0 : if (mem_cgroup_is_root(memcg))
2720 : 0 : return;
2721 : :
2722 : 0 : page_counter_uncharge(&memcg->memory, nr_pages);
2723 : : if (do_memsw_account())
2724 : : page_counter_uncharge(&memcg->memsw, nr_pages);
2725 : :
2726 : : css_put_many(&memcg->css, nr_pages);
2727 : : }
2728 : :
2729 : 0 : static void lock_page_lru(struct page *page, int *isolated)
2730 : : {
2731 : : pg_data_t *pgdat = page_pgdat(page);
2732 : :
2733 : : spin_lock_irq(&pgdat->lru_lock);
2734 : 0 : if (PageLRU(page)) {
2735 : : struct lruvec *lruvec;
2736 : :
2737 : 0 : lruvec = mem_cgroup_page_lruvec(page, pgdat);
2738 : : ClearPageLRU(page);
2739 : : del_page_from_lru_list(page, lruvec, page_lru(page));
2740 : 0 : *isolated = 1;
2741 : : } else
2742 : 0 : *isolated = 0;
2743 : 0 : }
2744 : :
2745 : 0 : static void unlock_page_lru(struct page *page, int isolated)
2746 : : {
2747 : : pg_data_t *pgdat = page_pgdat(page);
2748 : :
2749 : 0 : if (isolated) {
2750 : : struct lruvec *lruvec;
2751 : :
2752 : 0 : lruvec = mem_cgroup_page_lruvec(page, pgdat);
2753 : : VM_BUG_ON_PAGE(PageLRU(page), page);
2754 : : SetPageLRU(page);
2755 : : add_page_to_lru_list(page, lruvec, page_lru(page));
2756 : : }
2757 : : spin_unlock_irq(&pgdat->lru_lock);
2758 : 0 : }
2759 : :
2760 : 0 : static void commit_charge(struct page *page, struct mem_cgroup *memcg,
2761 : : bool lrucare)
2762 : : {
2763 : : int isolated;
2764 : :
2765 : : VM_BUG_ON_PAGE(page->mem_cgroup, page);
2766 : :
2767 : : /*
2768 : : * In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
2769 : : * may already be on some other mem_cgroup's LRU. Take care of it.
2770 : : */
2771 : 0 : if (lrucare)
2772 : 0 : lock_page_lru(page, &isolated);
2773 : :
2774 : : /*
2775 : : * Nobody should be changing or seriously looking at
2776 : : * page->mem_cgroup at this point:
2777 : : *
2778 : : * - the page is uncharged
2779 : : *
2780 : : * - the page is off-LRU
2781 : : *
2782 : : * - an anonymous fault has exclusive page access, except for
2783 : : * a locked page table
2784 : : *
2785 : : * - a page cache insertion, a swapin fault, or a migration
2786 : : * have the page locked
2787 : : */
2788 : 0 : page->mem_cgroup = memcg;
2789 : :
2790 : 0 : if (lrucare)
2791 : 0 : unlock_page_lru(page, isolated);
2792 : 0 : }
2793 : :
2794 : : #ifdef CONFIG_MEMCG_KMEM
2795 : : /*
2796 : : * Returns a pointer to the memory cgroup to which the kernel object is charged.
2797 : : *
2798 : : * The caller must ensure the memcg lifetime, e.g. by taking rcu_read_lock(),
2799 : : * cgroup_mutex, etc.
2800 : : */
2801 : 3 : struct mem_cgroup *mem_cgroup_from_obj(void *p)
2802 : : {
2803 : : struct page *page;
2804 : :
2805 : 3 : if (mem_cgroup_disabled())
2806 : : return NULL;
2807 : :
2808 : : page = virt_to_head_page(p);
2809 : :
2810 : : /*
2811 : : * Slab pages don't have page->mem_cgroup set because corresponding
2812 : : * kmem caches can be reparented during the lifetime. That's why
2813 : : * memcg_from_slab_page() should be used instead.
2814 : : */
2815 : 0 : if (PageSlab(page))
2816 : 0 : return memcg_from_slab_page(page);
2817 : :
2818 : : /* All other pages use page->mem_cgroup */
2819 : 0 : return page->mem_cgroup;
2820 : : }
2821 : :
2822 : 0 : static int memcg_alloc_cache_id(void)
2823 : : {
2824 : : int id, size;
2825 : : int err;
2826 : :
2827 : 0 : id = ida_simple_get(&memcg_cache_ida,
2828 : : 0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
2829 : 0 : if (id < 0)
2830 : : return id;
2831 : :
2832 : 0 : if (id < memcg_nr_cache_ids)
2833 : : return id;
2834 : :
2835 : : /*
2836 : : * There's no space for the new id in memcg_caches arrays,
2837 : : * so we have to grow them.
2838 : : */
2839 : 0 : down_write(&memcg_cache_ids_sem);
2840 : :
2841 : 0 : size = 2 * (id + 1);
2842 : 0 : if (size < MEMCG_CACHES_MIN_SIZE)
2843 : : size = MEMCG_CACHES_MIN_SIZE;
2844 : 0 : else if (size > MEMCG_CACHES_MAX_SIZE)
2845 : : size = MEMCG_CACHES_MAX_SIZE;
2846 : :
2847 : 0 : err = memcg_update_all_caches(size);
2848 : 0 : if (!err)
2849 : 0 : err = memcg_update_all_list_lrus(size);
2850 : 0 : if (!err)
2851 : 0 : memcg_nr_cache_ids = size;
2852 : :
2853 : 0 : up_write(&memcg_cache_ids_sem);
2854 : :
2855 : 0 : if (err) {
2856 : 0 : ida_simple_remove(&memcg_cache_ida, id);
2857 : 0 : return err;
2858 : : }
2859 : : return id;
2860 : : }
2861 : :
2862 : : static void memcg_free_cache_id(int id)
2863 : : {
2864 : 0 : ida_simple_remove(&memcg_cache_ida, id);
2865 : : }
2866 : :
2867 : : struct memcg_kmem_cache_create_work {
2868 : : struct mem_cgroup *memcg;
2869 : : struct kmem_cache *cachep;
2870 : : struct work_struct work;
2871 : : };
2872 : :
2873 : 0 : static void memcg_kmem_cache_create_func(struct work_struct *w)
2874 : : {
2875 : : struct memcg_kmem_cache_create_work *cw =
2876 : 0 : container_of(w, struct memcg_kmem_cache_create_work, work);
2877 : 0 : struct mem_cgroup *memcg = cw->memcg;
2878 : 0 : struct kmem_cache *cachep = cw->cachep;
2879 : :
2880 : 0 : memcg_create_kmem_cache(memcg, cachep);
2881 : :
2882 : : css_put(&memcg->css);
2883 : 0 : kfree(cw);
2884 : 0 : }
2885 : :
2886 : : /*
2887 : : * Enqueue the creation of a per-memcg kmem_cache.
2888 : : */
2889 : 0 : static void memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
2890 : : struct kmem_cache *cachep)
2891 : : {
2892 : : struct memcg_kmem_cache_create_work *cw;
2893 : :
2894 : 0 : if (!css_tryget_online(&memcg->css))
2895 : : return;
2896 : :
2897 : : cw = kmalloc(sizeof(*cw), GFP_NOWAIT | __GFP_NOWARN);
2898 : 0 : if (!cw) {
2899 : : css_put(&memcg->css);
2900 : : return;
2901 : : }
2902 : :
2903 : 0 : cw->memcg = memcg;
2904 : 0 : cw->cachep = cachep;
2905 : 0 : INIT_WORK(&cw->work, memcg_kmem_cache_create_func);
2906 : :
2907 : 0 : queue_work(memcg_kmem_cache_wq, &cw->work);
2908 : : }
2909 : :
2910 : 0 : static inline bool memcg_kmem_bypass(void)
2911 : : {
2912 : 0 : if (in_interrupt() || !current->mm || (current->flags & PF_KTHREAD))
2913 : : return true;
2914 : 0 : return false;
2915 : : }
2916 : :
2917 : : /**
2918 : : * memcg_kmem_get_cache: select the correct per-memcg cache for allocation
2919 : : * @cachep: the original global kmem cache
2920 : : *
2921 : : * Return the kmem_cache we're supposed to use for a slab allocation.
2922 : : * We try to use the current memcg's version of the cache.
2923 : : *
2924 : : * If the cache does not exist yet, if we are the first user of it, we
2925 : : * create it asynchronously in a workqueue and let the current allocation
2926 : : * go through with the original cache.
2927 : : *
2928 : : * This function takes a reference to the cache it returns to assure it
2929 : : * won't get destroyed while we are working with it. Once the caller is
2930 : : * done with it, memcg_kmem_put_cache() must be called to release the
2931 : : * reference.
2932 : : */
2933 : 0 : struct kmem_cache *memcg_kmem_get_cache(struct kmem_cache *cachep)
2934 : : {
2935 : : struct mem_cgroup *memcg;
2936 : : struct kmem_cache *memcg_cachep;
2937 : : struct memcg_cache_array *arr;
2938 : : int kmemcg_id;
2939 : :
2940 : : VM_BUG_ON(!is_root_cache(cachep));
2941 : :
2942 : 0 : if (memcg_kmem_bypass())
2943 : : return cachep;
2944 : :
2945 : : rcu_read_lock();
2946 : :
2947 : 0 : if (unlikely(current->active_memcg))
2948 : : memcg = current->active_memcg;
2949 : : else
2950 : : memcg = mem_cgroup_from_task(current);
2951 : :
2952 : 0 : if (!memcg || memcg == root_mem_cgroup)
2953 : : goto out_unlock;
2954 : :
2955 : 0 : kmemcg_id = READ_ONCE(memcg->kmemcg_id);
2956 : 0 : if (kmemcg_id < 0)
2957 : : goto out_unlock;
2958 : :
2959 : 0 : arr = rcu_dereference(cachep->memcg_params.memcg_caches);
2960 : :
2961 : : /*
2962 : : * Make sure we will access the up-to-date value. The code updating
2963 : : * memcg_caches issues a write barrier to match the data dependency
2964 : : * barrier inside READ_ONCE() (see memcg_create_kmem_cache()).
2965 : : */
2966 : 0 : memcg_cachep = READ_ONCE(arr->entries[kmemcg_id]);
2967 : :
2968 : : /*
2969 : : * If we are in a safe context (can wait, and not in interrupt
2970 : : * context), we could be be predictable and return right away.
2971 : : * This would guarantee that the allocation being performed
2972 : : * already belongs in the new cache.
2973 : : *
2974 : : * However, there are some clashes that can arrive from locking.
2975 : : * For instance, because we acquire the slab_mutex while doing
2976 : : * memcg_create_kmem_cache, this means no further allocation
2977 : : * could happen with the slab_mutex held. So it's better to
2978 : : * defer everything.
2979 : : *
2980 : : * If the memcg is dying or memcg_cache is about to be released,
2981 : : * don't bother creating new kmem_caches. Because memcg_cachep
2982 : : * is ZEROed as the fist step of kmem offlining, we don't need
2983 : : * percpu_ref_tryget_live() here. css_tryget_online() check in
2984 : : * memcg_schedule_kmem_cache_create() will prevent us from
2985 : : * creation of a new kmem_cache.
2986 : : */
2987 : 0 : if (unlikely(!memcg_cachep))
2988 : 0 : memcg_schedule_kmem_cache_create(memcg, cachep);
2989 : 0 : else if (percpu_ref_tryget(&memcg_cachep->memcg_params.refcnt))
2990 : : cachep = memcg_cachep;
2991 : : out_unlock:
2992 : : rcu_read_unlock();
2993 : 0 : return cachep;
2994 : : }
2995 : :
2996 : : /**
2997 : : * memcg_kmem_put_cache: drop reference taken by memcg_kmem_get_cache
2998 : : * @cachep: the cache returned by memcg_kmem_get_cache
2999 : : */
3000 : 0 : void memcg_kmem_put_cache(struct kmem_cache *cachep)
3001 : : {
3002 : 0 : if (!is_root_cache(cachep))
3003 : 0 : percpu_ref_put(&cachep->memcg_params.refcnt);
3004 : 0 : }
3005 : :
3006 : : /**
3007 : : * __memcg_kmem_charge_memcg: charge a kmem page
3008 : : * @page: page to charge
3009 : : * @gfp: reclaim mode
3010 : : * @order: allocation order
3011 : : * @memcg: memory cgroup to charge
3012 : : *
3013 : : * Returns 0 on success, an error code on failure.
3014 : : */
3015 : 0 : int __memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
3016 : : struct mem_cgroup *memcg)
3017 : : {
3018 : 0 : unsigned int nr_pages = 1 << order;
3019 : : struct page_counter *counter;
3020 : : int ret;
3021 : :
3022 : 0 : ret = try_charge(memcg, gfp, nr_pages);
3023 : 0 : if (ret)
3024 : : return ret;
3025 : :
3026 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) &&
3027 : 0 : !page_counter_try_charge(&memcg->kmem, nr_pages, &counter)) {
3028 : :
3029 : : /*
3030 : : * Enforce __GFP_NOFAIL allocation because callers are not
3031 : : * prepared to see failures and likely do not have any failure
3032 : : * handling code.
3033 : : */
3034 : 0 : if (gfp & __GFP_NOFAIL) {
3035 : 0 : page_counter_charge(&memcg->kmem, nr_pages);
3036 : 0 : return 0;
3037 : : }
3038 : 0 : cancel_charge(memcg, nr_pages);
3039 : 0 : return -ENOMEM;
3040 : : }
3041 : : return 0;
3042 : : }
3043 : :
3044 : : /**
3045 : : * __memcg_kmem_charge: charge a kmem page to the current memory cgroup
3046 : : * @page: page to charge
3047 : : * @gfp: reclaim mode
3048 : : * @order: allocation order
3049 : : *
3050 : : * Returns 0 on success, an error code on failure.
3051 : : */
3052 : 0 : int __memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
3053 : : {
3054 : : struct mem_cgroup *memcg;
3055 : : int ret = 0;
3056 : :
3057 : 0 : if (memcg_kmem_bypass())
3058 : : return 0;
3059 : :
3060 : : memcg = get_mem_cgroup_from_current();
3061 : 0 : if (!mem_cgroup_is_root(memcg)) {
3062 : 0 : ret = __memcg_kmem_charge_memcg(page, gfp, order, memcg);
3063 : 0 : if (!ret) {
3064 : 0 : page->mem_cgroup = memcg;
3065 : : __SetPageKmemcg(page);
3066 : : }
3067 : : }
3068 : : css_put(&memcg->css);
3069 : 0 : return ret;
3070 : : }
3071 : :
3072 : : /**
3073 : : * __memcg_kmem_uncharge_memcg: uncharge a kmem page
3074 : : * @memcg: memcg to uncharge
3075 : : * @nr_pages: number of pages to uncharge
3076 : : */
3077 : 0 : void __memcg_kmem_uncharge_memcg(struct mem_cgroup *memcg,
3078 : : unsigned int nr_pages)
3079 : : {
3080 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
3081 : 0 : page_counter_uncharge(&memcg->kmem, nr_pages);
3082 : :
3083 : 0 : page_counter_uncharge(&memcg->memory, nr_pages);
3084 : : if (do_memsw_account())
3085 : : page_counter_uncharge(&memcg->memsw, nr_pages);
3086 : 0 : }
3087 : : /**
3088 : : * __memcg_kmem_uncharge: uncharge a kmem page
3089 : : * @page: page to uncharge
3090 : : * @order: allocation order
3091 : : */
3092 : 0 : void __memcg_kmem_uncharge(struct page *page, int order)
3093 : : {
3094 : 0 : struct mem_cgroup *memcg = page->mem_cgroup;
3095 : 0 : unsigned int nr_pages = 1 << order;
3096 : :
3097 : 0 : if (!memcg)
3098 : 0 : return;
3099 : :
3100 : : VM_BUG_ON_PAGE(mem_cgroup_is_root(memcg), page);
3101 : 0 : __memcg_kmem_uncharge_memcg(memcg, nr_pages);
3102 : 0 : page->mem_cgroup = NULL;
3103 : :
3104 : : /* slab pages do not have PageKmemcg flag set */
3105 : 0 : if (PageKmemcg(page))
3106 : : __ClearPageKmemcg(page);
3107 : :
3108 : : css_put_many(&memcg->css, nr_pages);
3109 : : }
3110 : : #endif /* CONFIG_MEMCG_KMEM */
3111 : :
3112 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
3113 : :
3114 : : /*
3115 : : * Because tail pages are not marked as "used", set it. We're under
3116 : : * pgdat->lru_lock and migration entries setup in all page mappings.
3117 : : */
3118 : : void mem_cgroup_split_huge_fixup(struct page *head)
3119 : : {
3120 : : int i;
3121 : :
3122 : : if (mem_cgroup_disabled())
3123 : : return;
3124 : :
3125 : : for (i = 1; i < HPAGE_PMD_NR; i++)
3126 : : head[i].mem_cgroup = head->mem_cgroup;
3127 : :
3128 : : __mod_memcg_state(head->mem_cgroup, MEMCG_RSS_HUGE, -HPAGE_PMD_NR);
3129 : : }
3130 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
3131 : :
3132 : : #ifdef CONFIG_MEMCG_SWAP
3133 : : /**
3134 : : * mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
3135 : : * @entry: swap entry to be moved
3136 : : * @from: mem_cgroup which the entry is moved from
3137 : : * @to: mem_cgroup which the entry is moved to
3138 : : *
3139 : : * It succeeds only when the swap_cgroup's record for this entry is the same
3140 : : * as the mem_cgroup's id of @from.
3141 : : *
3142 : : * Returns 0 on success, -EINVAL on failure.
3143 : : *
3144 : : * The caller must have charged to @to, IOW, called page_counter_charge() about
3145 : : * both res and memsw, and called css_get().
3146 : : */
3147 : : static int mem_cgroup_move_swap_account(swp_entry_t entry,
3148 : : struct mem_cgroup *from, struct mem_cgroup *to)
3149 : : {
3150 : : unsigned short old_id, new_id;
3151 : :
3152 : : old_id = mem_cgroup_id(from);
3153 : : new_id = mem_cgroup_id(to);
3154 : :
3155 : : if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
3156 : : mod_memcg_state(from, MEMCG_SWAP, -1);
3157 : : mod_memcg_state(to, MEMCG_SWAP, 1);
3158 : : return 0;
3159 : : }
3160 : : return -EINVAL;
3161 : : }
3162 : : #else
3163 : : static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
3164 : : struct mem_cgroup *from, struct mem_cgroup *to)
3165 : : {
3166 : : return -EINVAL;
3167 : : }
3168 : : #endif
3169 : :
3170 : : static DEFINE_MUTEX(memcg_max_mutex);
3171 : :
3172 : 0 : static int mem_cgroup_resize_max(struct mem_cgroup *memcg,
3173 : : unsigned long max, bool memsw)
3174 : : {
3175 : : bool enlarge = false;
3176 : : bool drained = false;
3177 : : int ret;
3178 : : bool limits_invariant;
3179 : 0 : struct page_counter *counter = memsw ? &memcg->memsw : &memcg->memory;
3180 : :
3181 : : do {
3182 : 0 : if (signal_pending(current)) {
3183 : : ret = -EINTR;
3184 : : break;
3185 : : }
3186 : :
3187 : 0 : mutex_lock(&memcg_max_mutex);
3188 : : /*
3189 : : * Make sure that the new limit (memsw or memory limit) doesn't
3190 : : * break our basic invariant rule memory.max <= memsw.max.
3191 : : */
3192 : 0 : limits_invariant = memsw ? max >= memcg->memory.max :
3193 : 0 : max <= memcg->memsw.max;
3194 : 0 : if (!limits_invariant) {
3195 : 0 : mutex_unlock(&memcg_max_mutex);
3196 : : ret = -EINVAL;
3197 : 0 : break;
3198 : : }
3199 : 0 : if (max > counter->max)
3200 : : enlarge = true;
3201 : 0 : ret = page_counter_set_max(counter, max);
3202 : 0 : mutex_unlock(&memcg_max_mutex);
3203 : :
3204 : 0 : if (!ret)
3205 : : break;
3206 : :
3207 : 0 : if (!drained) {
3208 : 0 : drain_all_stock(memcg);
3209 : : drained = true;
3210 : 0 : continue;
3211 : : }
3212 : :
3213 : 0 : if (!try_to_free_mem_cgroup_pages(memcg, 1,
3214 : 0 : GFP_KERNEL, !memsw)) {
3215 : : ret = -EBUSY;
3216 : : break;
3217 : : }
3218 : : } while (true);
3219 : :
3220 : 0 : if (!ret && enlarge)
3221 : 0 : memcg_oom_recover(memcg);
3222 : :
3223 : 0 : return ret;
3224 : : }
3225 : :
3226 : 0 : unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
3227 : : gfp_t gfp_mask,
3228 : : unsigned long *total_scanned)
3229 : : {
3230 : : unsigned long nr_reclaimed = 0;
3231 : : struct mem_cgroup_per_node *mz, *next_mz = NULL;
3232 : : unsigned long reclaimed;
3233 : : int loop = 0;
3234 : : struct mem_cgroup_tree_per_node *mctz;
3235 : : unsigned long excess;
3236 : : unsigned long nr_scanned;
3237 : :
3238 : 0 : if (order > 0)
3239 : : return 0;
3240 : :
3241 : 0 : mctz = soft_limit_tree_node(pgdat->node_id);
3242 : :
3243 : : /*
3244 : : * Do not even bother to check the largest node if the root
3245 : : * is empty. Do it lockless to prevent lock bouncing. Races
3246 : : * are acceptable as soft limit is best effort anyway.
3247 : : */
3248 : 0 : if (!mctz || RB_EMPTY_ROOT(&mctz->rb_root))
3249 : : return 0;
3250 : :
3251 : : /*
3252 : : * This loop can run a while, specially if mem_cgroup's continuously
3253 : : * keep exceeding their soft limit and putting the system under
3254 : : * pressure
3255 : : */
3256 : : do {
3257 : 0 : if (next_mz)
3258 : : mz = next_mz;
3259 : : else
3260 : 0 : mz = mem_cgroup_largest_soft_limit_node(mctz);
3261 : 0 : if (!mz)
3262 : : break;
3263 : :
3264 : 0 : nr_scanned = 0;
3265 : 0 : reclaimed = mem_cgroup_soft_reclaim(mz->memcg, pgdat,
3266 : : gfp_mask, &nr_scanned);
3267 : 0 : nr_reclaimed += reclaimed;
3268 : 0 : *total_scanned += nr_scanned;
3269 : : spin_lock_irq(&mctz->lock);
3270 : 0 : __mem_cgroup_remove_exceeded(mz, mctz);
3271 : :
3272 : : /*
3273 : : * If we failed to reclaim anything from this memory cgroup
3274 : : * it is time to move on to the next cgroup
3275 : : */
3276 : : next_mz = NULL;
3277 : 0 : if (!reclaimed)
3278 : 0 : next_mz = __mem_cgroup_largest_soft_limit_node(mctz);
3279 : :
3280 : 0 : excess = soft_limit_excess(mz->memcg);
3281 : : /*
3282 : : * One school of thought says that we should not add
3283 : : * back the node to the tree if reclaim returns 0.
3284 : : * But our reclaim could return 0, simply because due
3285 : : * to priority we are exposing a smaller subset of
3286 : : * memory to reclaim from. Consider this as a longer
3287 : : * term TODO.
3288 : : */
3289 : : /* If excess == 0, no tree ops */
3290 : 0 : __mem_cgroup_insert_exceeded(mz, mctz, excess);
3291 : : spin_unlock_irq(&mctz->lock);
3292 : 0 : css_put(&mz->memcg->css);
3293 : 0 : loop++;
3294 : : /*
3295 : : * Could not reclaim anything and there are no more
3296 : : * mem cgroups to try or we seem to be looping without
3297 : : * reclaiming anything.
3298 : : */
3299 : 0 : if (!nr_reclaimed &&
3300 : 0 : (next_mz == NULL ||
3301 : 0 : loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
3302 : : break;
3303 : 0 : } while (!nr_reclaimed);
3304 : 0 : if (next_mz)
3305 : 0 : css_put(&next_mz->memcg->css);
3306 : 0 : return nr_reclaimed;
3307 : : }
3308 : :
3309 : : /*
3310 : : * Test whether @memcg has children, dead or alive. Note that this
3311 : : * function doesn't care whether @memcg has use_hierarchy enabled and
3312 : : * returns %true if there are child csses according to the cgroup
3313 : : * hierarchy. Testing use_hierarchy is the caller's responsiblity.
3314 : : */
3315 : : static inline bool memcg_has_children(struct mem_cgroup *memcg)
3316 : : {
3317 : : bool ret;
3318 : :
3319 : : rcu_read_lock();
3320 : 0 : ret = css_next_child(NULL, &memcg->css);
3321 : : rcu_read_unlock();
3322 : : return ret;
3323 : : }
3324 : :
3325 : : /*
3326 : : * Reclaims as many pages from the given memcg as possible.
3327 : : *
3328 : : * Caller is responsible for holding css reference for memcg.
3329 : : */
3330 : 0 : static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
3331 : : {
3332 : : int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
3333 : :
3334 : : /* we call try-to-free pages for make this cgroup empty */
3335 : 0 : lru_add_drain_all();
3336 : :
3337 : 0 : drain_all_stock(memcg);
3338 : :
3339 : : /* try to free all pages in this cgroup */
3340 : 0 : while (nr_retries && page_counter_read(&memcg->memory)) {
3341 : : int progress;
3342 : :
3343 : 0 : if (signal_pending(current))
3344 : : return -EINTR;
3345 : :
3346 : 0 : progress = try_to_free_mem_cgroup_pages(memcg, 1,
3347 : : GFP_KERNEL, true);
3348 : 0 : if (!progress) {
3349 : 0 : nr_retries--;
3350 : : /* maybe some writeback is necessary */
3351 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/10);
3352 : : }
3353 : :
3354 : : }
3355 : :
3356 : : return 0;
3357 : : }
3358 : :
3359 : 0 : static ssize_t mem_cgroup_force_empty_write(struct kernfs_open_file *of,
3360 : : char *buf, size_t nbytes,
3361 : : loff_t off)
3362 : : {
3363 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3364 : :
3365 : 0 : if (mem_cgroup_is_root(memcg))
3366 : : return -EINVAL;
3367 : 0 : return mem_cgroup_force_empty(memcg) ?: nbytes;
3368 : : }
3369 : :
3370 : 0 : static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
3371 : : struct cftype *cft)
3372 : : {
3373 : 0 : return mem_cgroup_from_css(css)->use_hierarchy;
3374 : : }
3375 : :
3376 : 0 : static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
3377 : : struct cftype *cft, u64 val)
3378 : : {
3379 : : int retval = 0;
3380 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3381 : 0 : struct mem_cgroup *parent_memcg = mem_cgroup_from_css(memcg->css.parent);
3382 : :
3383 : 0 : if (memcg->use_hierarchy == val)
3384 : : return 0;
3385 : :
3386 : : /*
3387 : : * If parent's use_hierarchy is set, we can't make any modifications
3388 : : * in the child subtrees. If it is unset, then the change can
3389 : : * occur, provided the current cgroup has no children.
3390 : : *
3391 : : * For the root cgroup, parent_mem is NULL, we allow value to be
3392 : : * set if there are no children.
3393 : : */
3394 : 0 : if ((!parent_memcg || !parent_memcg->use_hierarchy) &&
3395 : : (val == 1 || val == 0)) {
3396 : 0 : if (!memcg_has_children(memcg))
3397 : 0 : memcg->use_hierarchy = val;
3398 : : else
3399 : : retval = -EBUSY;
3400 : : } else
3401 : : retval = -EINVAL;
3402 : :
3403 : 0 : return retval;
3404 : : }
3405 : :
3406 : 0 : static unsigned long mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
3407 : : {
3408 : : unsigned long val;
3409 : :
3410 : 0 : if (mem_cgroup_is_root(memcg)) {
3411 : 0 : val = memcg_page_state(memcg, MEMCG_CACHE) +
3412 : : memcg_page_state(memcg, MEMCG_RSS);
3413 : 0 : if (swap)
3414 : 0 : val += memcg_page_state(memcg, MEMCG_SWAP);
3415 : : } else {
3416 : 0 : if (!swap)
3417 : : val = page_counter_read(&memcg->memory);
3418 : : else
3419 : : val = page_counter_read(&memcg->memsw);
3420 : : }
3421 : 0 : return val;
3422 : : }
3423 : :
3424 : : enum {
3425 : : RES_USAGE,
3426 : : RES_LIMIT,
3427 : : RES_MAX_USAGE,
3428 : : RES_FAILCNT,
3429 : : RES_SOFT_LIMIT,
3430 : : };
3431 : :
3432 : 0 : static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
3433 : : struct cftype *cft)
3434 : : {
3435 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3436 : : struct page_counter *counter;
3437 : :
3438 : 0 : switch (MEMFILE_TYPE(cft->private)) {
3439 : : case _MEM:
3440 : 0 : counter = &memcg->memory;
3441 : 0 : break;
3442 : : case _MEMSWAP:
3443 : 0 : counter = &memcg->memsw;
3444 : 0 : break;
3445 : : case _KMEM:
3446 : 0 : counter = &memcg->kmem;
3447 : 0 : break;
3448 : : case _TCP:
3449 : 0 : counter = &memcg->tcpmem;
3450 : 0 : break;
3451 : : default:
3452 : 0 : BUG();
3453 : : }
3454 : :
3455 : 0 : switch (MEMFILE_ATTR(cft->private)) {
3456 : : case RES_USAGE:
3457 : 0 : if (counter == &memcg->memory)
3458 : 0 : return (u64)mem_cgroup_usage(memcg, false) * PAGE_SIZE;
3459 : 0 : if (counter == &memcg->memsw)
3460 : 0 : return (u64)mem_cgroup_usage(memcg, true) * PAGE_SIZE;
3461 : 0 : return (u64)page_counter_read(counter) * PAGE_SIZE;
3462 : : case RES_LIMIT:
3463 : 0 : return (u64)counter->max * PAGE_SIZE;
3464 : : case RES_MAX_USAGE:
3465 : 0 : return (u64)counter->watermark * PAGE_SIZE;
3466 : : case RES_FAILCNT:
3467 : 0 : return counter->failcnt;
3468 : : case RES_SOFT_LIMIT:
3469 : 0 : return (u64)memcg->soft_limit * PAGE_SIZE;
3470 : : default:
3471 : 0 : BUG();
3472 : : }
3473 : : }
3474 : :
3475 : 0 : static void memcg_flush_percpu_vmstats(struct mem_cgroup *memcg)
3476 : : {
3477 : 0 : unsigned long stat[MEMCG_NR_STAT] = {0};
3478 : : struct mem_cgroup *mi;
3479 : : int node, cpu, i;
3480 : :
3481 : 0 : for_each_online_cpu(cpu)
3482 : 0 : for (i = 0; i < MEMCG_NR_STAT; i++)
3483 : 0 : stat[i] += per_cpu(memcg->vmstats_percpu->stat[i], cpu);
3484 : :
3485 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
3486 : 0 : for (i = 0; i < MEMCG_NR_STAT; i++)
3487 : 0 : atomic_long_add(stat[i], &mi->vmstats[i]);
3488 : :
3489 : 0 : for_each_node(node) {
3490 : 0 : struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
3491 : : struct mem_cgroup_per_node *pi;
3492 : :
3493 : 0 : for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3494 : 0 : stat[i] = 0;
3495 : :
3496 : 0 : for_each_online_cpu(cpu)
3497 : 0 : for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3498 : 0 : stat[i] += per_cpu(
3499 : : pn->lruvec_stat_cpu->count[i], cpu);
3500 : :
3501 : 0 : for (pi = pn; pi; pi = parent_nodeinfo(pi, node))
3502 : 0 : for (i = 0; i < NR_VM_NODE_STAT_ITEMS; i++)
3503 : 0 : atomic_long_add(stat[i], &pi->lruvec_stat[i]);
3504 : : }
3505 : 0 : }
3506 : :
3507 : 0 : static void memcg_flush_percpu_vmevents(struct mem_cgroup *memcg)
3508 : : {
3509 : : unsigned long events[NR_VM_EVENT_ITEMS];
3510 : : struct mem_cgroup *mi;
3511 : : int cpu, i;
3512 : :
3513 : 0 : for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3514 : 0 : events[i] = 0;
3515 : :
3516 : 0 : for_each_online_cpu(cpu)
3517 : 0 : for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3518 : 0 : events[i] += per_cpu(memcg->vmstats_percpu->events[i],
3519 : : cpu);
3520 : :
3521 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi))
3522 : 0 : for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
3523 : 0 : atomic_long_add(events[i], &mi->vmevents[i]);
3524 : 0 : }
3525 : :
3526 : : #ifdef CONFIG_MEMCG_KMEM
3527 : 0 : static int memcg_online_kmem(struct mem_cgroup *memcg)
3528 : : {
3529 : : int memcg_id;
3530 : :
3531 : 0 : if (cgroup_memory_nokmem)
3532 : : return 0;
3533 : :
3534 : 0 : BUG_ON(memcg->kmemcg_id >= 0);
3535 : 0 : BUG_ON(memcg->kmem_state);
3536 : :
3537 : 0 : memcg_id = memcg_alloc_cache_id();
3538 : 0 : if (memcg_id < 0)
3539 : : return memcg_id;
3540 : :
3541 : 0 : static_branch_inc(&memcg_kmem_enabled_key);
3542 : : /*
3543 : : * A memory cgroup is considered kmem-online as soon as it gets
3544 : : * kmemcg_id. Setting the id after enabling static branching will
3545 : : * guarantee no one starts accounting before all call sites are
3546 : : * patched.
3547 : : */
3548 : 0 : memcg->kmemcg_id = memcg_id;
3549 : 0 : memcg->kmem_state = KMEM_ONLINE;
3550 : 0 : INIT_LIST_HEAD(&memcg->kmem_caches);
3551 : :
3552 : 0 : return 0;
3553 : : }
3554 : :
3555 : 0 : static void memcg_offline_kmem(struct mem_cgroup *memcg)
3556 : : {
3557 : : struct cgroup_subsys_state *css;
3558 : : struct mem_cgroup *parent, *child;
3559 : : int kmemcg_id;
3560 : :
3561 : 0 : if (memcg->kmem_state != KMEM_ONLINE)
3562 : 0 : return;
3563 : : /*
3564 : : * Clear the online state before clearing memcg_caches array
3565 : : * entries. The slab_mutex in memcg_deactivate_kmem_caches()
3566 : : * guarantees that no cache will be created for this cgroup
3567 : : * after we are done (see memcg_create_kmem_cache()).
3568 : : */
3569 : 0 : memcg->kmem_state = KMEM_ALLOCATED;
3570 : :
3571 : : parent = parent_mem_cgroup(memcg);
3572 : 0 : if (!parent)
3573 : 0 : parent = root_mem_cgroup;
3574 : :
3575 : : /*
3576 : : * Deactivate and reparent kmem_caches.
3577 : : */
3578 : 0 : memcg_deactivate_kmem_caches(memcg, parent);
3579 : :
3580 : 0 : kmemcg_id = memcg->kmemcg_id;
3581 : 0 : BUG_ON(kmemcg_id < 0);
3582 : :
3583 : : /*
3584 : : * Change kmemcg_id of this cgroup and all its descendants to the
3585 : : * parent's id, and then move all entries from this cgroup's list_lrus
3586 : : * to ones of the parent. After we have finished, all list_lrus
3587 : : * corresponding to this cgroup are guaranteed to remain empty. The
3588 : : * ordering is imposed by list_lru_node->lock taken by
3589 : : * memcg_drain_all_list_lrus().
3590 : : */
3591 : : rcu_read_lock(); /* can be called from css_free w/o cgroup_mutex */
3592 : 0 : css_for_each_descendant_pre(css, &memcg->css) {
3593 : : child = mem_cgroup_from_css(css);
3594 : 0 : BUG_ON(child->kmemcg_id != kmemcg_id);
3595 : 0 : child->kmemcg_id = parent->kmemcg_id;
3596 : 0 : if (!memcg->use_hierarchy)
3597 : : break;
3598 : : }
3599 : : rcu_read_unlock();
3600 : :
3601 : 0 : memcg_drain_all_list_lrus(kmemcg_id, parent);
3602 : :
3603 : : memcg_free_cache_id(kmemcg_id);
3604 : : }
3605 : :
3606 : 0 : static void memcg_free_kmem(struct mem_cgroup *memcg)
3607 : : {
3608 : : /* css_alloc() failed, offlining didn't happen */
3609 : 0 : if (unlikely(memcg->kmem_state == KMEM_ONLINE))
3610 : 0 : memcg_offline_kmem(memcg);
3611 : :
3612 : 0 : if (memcg->kmem_state == KMEM_ALLOCATED) {
3613 : 0 : WARN_ON(!list_empty(&memcg->kmem_caches));
3614 : 0 : static_branch_dec(&memcg_kmem_enabled_key);
3615 : : }
3616 : 0 : }
3617 : : #else
3618 : : static int memcg_online_kmem(struct mem_cgroup *memcg)
3619 : : {
3620 : : return 0;
3621 : : }
3622 : : static void memcg_offline_kmem(struct mem_cgroup *memcg)
3623 : : {
3624 : : }
3625 : : static void memcg_free_kmem(struct mem_cgroup *memcg)
3626 : : {
3627 : : }
3628 : : #endif /* CONFIG_MEMCG_KMEM */
3629 : :
3630 : 0 : static int memcg_update_kmem_max(struct mem_cgroup *memcg,
3631 : : unsigned long max)
3632 : : {
3633 : : int ret;
3634 : :
3635 : 0 : mutex_lock(&memcg_max_mutex);
3636 : 0 : ret = page_counter_set_max(&memcg->kmem, max);
3637 : 0 : mutex_unlock(&memcg_max_mutex);
3638 : 0 : return ret;
3639 : : }
3640 : :
3641 : 0 : static int memcg_update_tcp_max(struct mem_cgroup *memcg, unsigned long max)
3642 : : {
3643 : : int ret;
3644 : :
3645 : 0 : mutex_lock(&memcg_max_mutex);
3646 : :
3647 : 0 : ret = page_counter_set_max(&memcg->tcpmem, max);
3648 : 0 : if (ret)
3649 : : goto out;
3650 : :
3651 : 0 : if (!memcg->tcpmem_active) {
3652 : : /*
3653 : : * The active flag needs to be written after the static_key
3654 : : * update. This is what guarantees that the socket activation
3655 : : * function is the last one to run. See mem_cgroup_sk_alloc()
3656 : : * for details, and note that we don't mark any socket as
3657 : : * belonging to this memcg until that flag is up.
3658 : : *
3659 : : * We need to do this, because static_keys will span multiple
3660 : : * sites, but we can't control their order. If we mark a socket
3661 : : * as accounted, but the accounting functions are not patched in
3662 : : * yet, we'll lose accounting.
3663 : : *
3664 : : * We never race with the readers in mem_cgroup_sk_alloc(),
3665 : : * because when this value change, the code to process it is not
3666 : : * patched in yet.
3667 : : */
3668 : 0 : static_branch_inc(&memcg_sockets_enabled_key);
3669 : 0 : memcg->tcpmem_active = true;
3670 : : }
3671 : : out:
3672 : 0 : mutex_unlock(&memcg_max_mutex);
3673 : 0 : return ret;
3674 : : }
3675 : :
3676 : : /*
3677 : : * The user of this function is...
3678 : : * RES_LIMIT.
3679 : : */
3680 : 0 : static ssize_t mem_cgroup_write(struct kernfs_open_file *of,
3681 : : char *buf, size_t nbytes, loff_t off)
3682 : : {
3683 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3684 : : unsigned long nr_pages;
3685 : : int ret;
3686 : :
3687 : : buf = strstrip(buf);
3688 : 0 : ret = page_counter_memparse(buf, "-1", &nr_pages);
3689 : 0 : if (ret)
3690 : : return ret;
3691 : :
3692 : 0 : switch (MEMFILE_ATTR(of_cft(of)->private)) {
3693 : : case RES_LIMIT:
3694 : 0 : if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
3695 : : ret = -EINVAL;
3696 : : break;
3697 : : }
3698 : 0 : switch (MEMFILE_TYPE(of_cft(of)->private)) {
3699 : : case _MEM:
3700 : 0 : ret = mem_cgroup_resize_max(memcg, nr_pages, false);
3701 : 0 : break;
3702 : : case _MEMSWAP:
3703 : 0 : ret = mem_cgroup_resize_max(memcg, nr_pages, true);
3704 : 0 : break;
3705 : : case _KMEM:
3706 : 0 : pr_warn_once("kmem.limit_in_bytes is deprecated and will be removed. "
3707 : : "Please report your usecase to linux-mm@kvack.org if you "
3708 : : "depend on this functionality.\n");
3709 : 0 : ret = memcg_update_kmem_max(memcg, nr_pages);
3710 : 0 : break;
3711 : : case _TCP:
3712 : 0 : ret = memcg_update_tcp_max(memcg, nr_pages);
3713 : 0 : break;
3714 : : }
3715 : : break;
3716 : : case RES_SOFT_LIMIT:
3717 : 0 : memcg->soft_limit = nr_pages;
3718 : : ret = 0;
3719 : 0 : break;
3720 : : }
3721 : 0 : return ret ?: nbytes;
3722 : : }
3723 : :
3724 : 0 : static ssize_t mem_cgroup_reset(struct kernfs_open_file *of, char *buf,
3725 : : size_t nbytes, loff_t off)
3726 : : {
3727 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
3728 : : struct page_counter *counter;
3729 : :
3730 : 0 : switch (MEMFILE_TYPE(of_cft(of)->private)) {
3731 : : case _MEM:
3732 : 0 : counter = &memcg->memory;
3733 : 0 : break;
3734 : : case _MEMSWAP:
3735 : 0 : counter = &memcg->memsw;
3736 : 0 : break;
3737 : : case _KMEM:
3738 : 0 : counter = &memcg->kmem;
3739 : 0 : break;
3740 : : case _TCP:
3741 : 0 : counter = &memcg->tcpmem;
3742 : 0 : break;
3743 : : default:
3744 : 0 : BUG();
3745 : : }
3746 : :
3747 : 0 : switch (MEMFILE_ATTR(of_cft(of)->private)) {
3748 : : case RES_MAX_USAGE:
3749 : : page_counter_reset_watermark(counter);
3750 : : break;
3751 : : case RES_FAILCNT:
3752 : 0 : counter->failcnt = 0;
3753 : 0 : break;
3754 : : default:
3755 : 0 : BUG();
3756 : : }
3757 : :
3758 : 0 : return nbytes;
3759 : : }
3760 : :
3761 : 0 : static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
3762 : : struct cftype *cft)
3763 : : {
3764 : 0 : return mem_cgroup_from_css(css)->move_charge_at_immigrate;
3765 : : }
3766 : :
3767 : : #ifdef CONFIG_MMU
3768 : 0 : static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3769 : : struct cftype *cft, u64 val)
3770 : : {
3771 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
3772 : :
3773 : 0 : if (val & ~MOVE_MASK)
3774 : : return -EINVAL;
3775 : :
3776 : : /*
3777 : : * No kind of locking is needed in here, because ->can_attach() will
3778 : : * check this value once in the beginning of the process, and then carry
3779 : : * on with stale data. This means that changes to this value will only
3780 : : * affect task migrations starting after the change.
3781 : : */
3782 : 0 : memcg->move_charge_at_immigrate = val;
3783 : 0 : return 0;
3784 : : }
3785 : : #else
3786 : : static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
3787 : : struct cftype *cft, u64 val)
3788 : : {
3789 : : return -ENOSYS;
3790 : : }
3791 : : #endif
3792 : :
3793 : : #ifdef CONFIG_NUMA
3794 : :
3795 : : #define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
3796 : : #define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
3797 : : #define LRU_ALL ((1 << NR_LRU_LISTS) - 1)
3798 : :
3799 : : static unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
3800 : : int nid, unsigned int lru_mask)
3801 : : {
3802 : : struct lruvec *lruvec = mem_cgroup_lruvec(NODE_DATA(nid), memcg);
3803 : : unsigned long nr = 0;
3804 : : enum lru_list lru;
3805 : :
3806 : : VM_BUG_ON((unsigned)nid >= nr_node_ids);
3807 : :
3808 : : for_each_lru(lru) {
3809 : : if (!(BIT(lru) & lru_mask))
3810 : : continue;
3811 : : nr += lruvec_page_state_local(lruvec, NR_LRU_BASE + lru);
3812 : : }
3813 : : return nr;
3814 : : }
3815 : :
3816 : : static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
3817 : : unsigned int lru_mask)
3818 : : {
3819 : : unsigned long nr = 0;
3820 : : enum lru_list lru;
3821 : :
3822 : : for_each_lru(lru) {
3823 : : if (!(BIT(lru) & lru_mask))
3824 : : continue;
3825 : : nr += memcg_page_state_local(memcg, NR_LRU_BASE + lru);
3826 : : }
3827 : : return nr;
3828 : : }
3829 : :
3830 : : static int memcg_numa_stat_show(struct seq_file *m, void *v)
3831 : : {
3832 : : struct numa_stat {
3833 : : const char *name;
3834 : : unsigned int lru_mask;
3835 : : };
3836 : :
3837 : : static const struct numa_stat stats[] = {
3838 : : { "total", LRU_ALL },
3839 : : { "file", LRU_ALL_FILE },
3840 : : { "anon", LRU_ALL_ANON },
3841 : : { "unevictable", BIT(LRU_UNEVICTABLE) },
3842 : : };
3843 : : const struct numa_stat *stat;
3844 : : int nid;
3845 : : unsigned long nr;
3846 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
3847 : :
3848 : : for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
3849 : : nr = mem_cgroup_nr_lru_pages(memcg, stat->lru_mask);
3850 : : seq_printf(m, "%s=%lu", stat->name, nr);
3851 : : for_each_node_state(nid, N_MEMORY) {
3852 : : nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
3853 : : stat->lru_mask);
3854 : : seq_printf(m, " N%d=%lu", nid, nr);
3855 : : }
3856 : : seq_putc(m, '\n');
3857 : : }
3858 : :
3859 : : for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
3860 : : struct mem_cgroup *iter;
3861 : :
3862 : : nr = 0;
3863 : : for_each_mem_cgroup_tree(iter, memcg)
3864 : : nr += mem_cgroup_nr_lru_pages(iter, stat->lru_mask);
3865 : : seq_printf(m, "hierarchical_%s=%lu", stat->name, nr);
3866 : : for_each_node_state(nid, N_MEMORY) {
3867 : : nr = 0;
3868 : : for_each_mem_cgroup_tree(iter, memcg)
3869 : : nr += mem_cgroup_node_nr_lru_pages(
3870 : : iter, nid, stat->lru_mask);
3871 : : seq_printf(m, " N%d=%lu", nid, nr);
3872 : : }
3873 : : seq_putc(m, '\n');
3874 : : }
3875 : :
3876 : : return 0;
3877 : : }
3878 : : #endif /* CONFIG_NUMA */
3879 : :
3880 : : static const unsigned int memcg1_stats[] = {
3881 : : MEMCG_CACHE,
3882 : : MEMCG_RSS,
3883 : : MEMCG_RSS_HUGE,
3884 : : NR_SHMEM,
3885 : : NR_FILE_MAPPED,
3886 : : NR_FILE_DIRTY,
3887 : : NR_WRITEBACK,
3888 : : MEMCG_SWAP,
3889 : : };
3890 : :
3891 : : static const char *const memcg1_stat_names[] = {
3892 : : "cache",
3893 : : "rss",
3894 : : "rss_huge",
3895 : : "shmem",
3896 : : "mapped_file",
3897 : : "dirty",
3898 : : "writeback",
3899 : : "swap",
3900 : : };
3901 : :
3902 : : /* Universal VM events cgroup1 shows, original sort order */
3903 : : static const unsigned int memcg1_events[] = {
3904 : : PGPGIN,
3905 : : PGPGOUT,
3906 : : PGFAULT,
3907 : : PGMAJFAULT,
3908 : : };
3909 : :
3910 : : static const char *const memcg1_event_names[] = {
3911 : : "pgpgin",
3912 : : "pgpgout",
3913 : : "pgfault",
3914 : : "pgmajfault",
3915 : : };
3916 : :
3917 : 0 : static int memcg_stat_show(struct seq_file *m, void *v)
3918 : : {
3919 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
3920 : : unsigned long memory, memsw;
3921 : : struct mem_cgroup *mi;
3922 : : unsigned int i;
3923 : :
3924 : : BUILD_BUG_ON(ARRAY_SIZE(memcg1_stat_names) != ARRAY_SIZE(memcg1_stats));
3925 : : BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_lru_names) != NR_LRU_LISTS);
3926 : :
3927 : 0 : for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
3928 : 0 : if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
3929 : 0 : continue;
3930 : 0 : seq_printf(m, "%s %lu\n", memcg1_stat_names[i],
3931 : 0 : memcg_page_state_local(memcg, memcg1_stats[i]) *
3932 : : PAGE_SIZE);
3933 : : }
3934 : :
3935 : 0 : for (i = 0; i < ARRAY_SIZE(memcg1_events); i++)
3936 : 0 : seq_printf(m, "%s %lu\n", memcg1_event_names[i],
3937 : 0 : memcg_events_local(memcg, memcg1_events[i]));
3938 : :
3939 : 0 : for (i = 0; i < NR_LRU_LISTS; i++)
3940 : 0 : seq_printf(m, "%s %lu\n", mem_cgroup_lru_names[i],
3941 : 0 : memcg_page_state_local(memcg, NR_LRU_BASE + i) *
3942 : : PAGE_SIZE);
3943 : :
3944 : : /* Hierarchical information */
3945 : : memory = memsw = PAGE_COUNTER_MAX;
3946 : 0 : for (mi = memcg; mi; mi = parent_mem_cgroup(mi)) {
3947 : 0 : memory = min(memory, mi->memory.max);
3948 : : memsw = min(memsw, mi->memsw.max);
3949 : : }
3950 : 0 : seq_printf(m, "hierarchical_memory_limit %llu\n",
3951 : 0 : (u64)memory * PAGE_SIZE);
3952 : : if (do_memsw_account())
3953 : : seq_printf(m, "hierarchical_memsw_limit %llu\n",
3954 : : (u64)memsw * PAGE_SIZE);
3955 : :
3956 : 0 : for (i = 0; i < ARRAY_SIZE(memcg1_stats); i++) {
3957 : 0 : if (memcg1_stats[i] == MEMCG_SWAP && !do_memsw_account())
3958 : 0 : continue;
3959 : 0 : seq_printf(m, "total_%s %llu\n", memcg1_stat_names[i],
3960 : 0 : (u64)memcg_page_state(memcg, memcg1_stats[i]) *
3961 : : PAGE_SIZE);
3962 : : }
3963 : :
3964 : 0 : for (i = 0; i < ARRAY_SIZE(memcg1_events); i++)
3965 : 0 : seq_printf(m, "total_%s %llu\n", memcg1_event_names[i],
3966 : 0 : (u64)memcg_events(memcg, memcg1_events[i]));
3967 : :
3968 : 0 : for (i = 0; i < NR_LRU_LISTS; i++)
3969 : 0 : seq_printf(m, "total_%s %llu\n", mem_cgroup_lru_names[i],
3970 : 0 : (u64)memcg_page_state(memcg, NR_LRU_BASE + i) *
3971 : : PAGE_SIZE);
3972 : :
3973 : : #ifdef CONFIG_DEBUG_VM
3974 : : {
3975 : : pg_data_t *pgdat;
3976 : : struct mem_cgroup_per_node *mz;
3977 : : struct zone_reclaim_stat *rstat;
3978 : : unsigned long recent_rotated[2] = {0, 0};
3979 : : unsigned long recent_scanned[2] = {0, 0};
3980 : :
3981 : : for_each_online_pgdat(pgdat) {
3982 : : mz = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
3983 : : rstat = &mz->lruvec.reclaim_stat;
3984 : :
3985 : : recent_rotated[0] += rstat->recent_rotated[0];
3986 : : recent_rotated[1] += rstat->recent_rotated[1];
3987 : : recent_scanned[0] += rstat->recent_scanned[0];
3988 : : recent_scanned[1] += rstat->recent_scanned[1];
3989 : : }
3990 : : seq_printf(m, "recent_rotated_anon %lu\n", recent_rotated[0]);
3991 : : seq_printf(m, "recent_rotated_file %lu\n", recent_rotated[1]);
3992 : : seq_printf(m, "recent_scanned_anon %lu\n", recent_scanned[0]);
3993 : : seq_printf(m, "recent_scanned_file %lu\n", recent_scanned[1]);
3994 : : }
3995 : : #endif
3996 : :
3997 : 0 : return 0;
3998 : : }
3999 : :
4000 : 0 : static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
4001 : : struct cftype *cft)
4002 : : {
4003 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4004 : :
4005 : 0 : return mem_cgroup_swappiness(memcg);
4006 : : }
4007 : :
4008 : 0 : static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
4009 : : struct cftype *cft, u64 val)
4010 : : {
4011 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4012 : :
4013 : 0 : if (val > 100)
4014 : : return -EINVAL;
4015 : :
4016 : 0 : if (css->parent)
4017 : 0 : memcg->swappiness = val;
4018 : : else
4019 : 0 : vm_swappiness = val;
4020 : :
4021 : : return 0;
4022 : : }
4023 : :
4024 : 0 : static void __mem_cgroup_threshold(struct mem_cgroup *memcg, bool swap)
4025 : : {
4026 : : struct mem_cgroup_threshold_ary *t;
4027 : : unsigned long usage;
4028 : : int i;
4029 : :
4030 : : rcu_read_lock();
4031 : 0 : if (!swap)
4032 : 0 : t = rcu_dereference(memcg->thresholds.primary);
4033 : : else
4034 : 0 : t = rcu_dereference(memcg->memsw_thresholds.primary);
4035 : :
4036 : 0 : if (!t)
4037 : : goto unlock;
4038 : :
4039 : 0 : usage = mem_cgroup_usage(memcg, swap);
4040 : :
4041 : : /*
4042 : : * current_threshold points to threshold just below or equal to usage.
4043 : : * If it's not true, a threshold was crossed after last
4044 : : * call of __mem_cgroup_threshold().
4045 : : */
4046 : 0 : i = t->current_threshold;
4047 : :
4048 : : /*
4049 : : * Iterate backward over array of thresholds starting from
4050 : : * current_threshold and check if a threshold is crossed.
4051 : : * If none of thresholds below usage is crossed, we read
4052 : : * only one element of the array here.
4053 : : */
4054 : 0 : for (; i >= 0 && unlikely(t->entries[i].threshold > usage); i--)
4055 : 0 : eventfd_signal(t->entries[i].eventfd, 1);
4056 : :
4057 : : /* i = current_threshold + 1 */
4058 : 0 : i++;
4059 : :
4060 : : /*
4061 : : * Iterate forward over array of thresholds starting from
4062 : : * current_threshold+1 and check if a threshold is crossed.
4063 : : * If none of thresholds above usage is crossed, we read
4064 : : * only one element of the array here.
4065 : : */
4066 : 0 : for (; i < t->size && unlikely(t->entries[i].threshold <= usage); i++)
4067 : 0 : eventfd_signal(t->entries[i].eventfd, 1);
4068 : :
4069 : : /* Update current_threshold */
4070 : 0 : t->current_threshold = i - 1;
4071 : : unlock:
4072 : : rcu_read_unlock();
4073 : 0 : }
4074 : :
4075 : 0 : static void mem_cgroup_threshold(struct mem_cgroup *memcg)
4076 : : {
4077 : 0 : while (memcg) {
4078 : 0 : __mem_cgroup_threshold(memcg, false);
4079 : : if (do_memsw_account())
4080 : : __mem_cgroup_threshold(memcg, true);
4081 : :
4082 : : memcg = parent_mem_cgroup(memcg);
4083 : : }
4084 : 0 : }
4085 : :
4086 : 0 : static int compare_thresholds(const void *a, const void *b)
4087 : : {
4088 : : const struct mem_cgroup_threshold *_a = a;
4089 : : const struct mem_cgroup_threshold *_b = b;
4090 : :
4091 : 0 : if (_a->threshold > _b->threshold)
4092 : : return 1;
4093 : :
4094 : 0 : if (_a->threshold < _b->threshold)
4095 : : return -1;
4096 : :
4097 : 0 : return 0;
4098 : : }
4099 : :
4100 : 0 : static int mem_cgroup_oom_notify_cb(struct mem_cgroup *memcg)
4101 : : {
4102 : : struct mem_cgroup_eventfd_list *ev;
4103 : :
4104 : : spin_lock(&memcg_oom_lock);
4105 : :
4106 : 0 : list_for_each_entry(ev, &memcg->oom_notify, list)
4107 : 0 : eventfd_signal(ev->eventfd, 1);
4108 : :
4109 : : spin_unlock(&memcg_oom_lock);
4110 : 0 : return 0;
4111 : : }
4112 : :
4113 : 0 : static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
4114 : : {
4115 : : struct mem_cgroup *iter;
4116 : :
4117 : 0 : for_each_mem_cgroup_tree(iter, memcg)
4118 : 0 : mem_cgroup_oom_notify_cb(iter);
4119 : 0 : }
4120 : :
4121 : 0 : static int __mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
4122 : : struct eventfd_ctx *eventfd, const char *args, enum res_type type)
4123 : : {
4124 : : struct mem_cgroup_thresholds *thresholds;
4125 : : struct mem_cgroup_threshold_ary *new;
4126 : : unsigned long threshold;
4127 : : unsigned long usage;
4128 : : int i, size, ret;
4129 : :
4130 : 0 : ret = page_counter_memparse(args, "-1", &threshold);
4131 : 0 : if (ret)
4132 : : return ret;
4133 : :
4134 : 0 : mutex_lock(&memcg->thresholds_lock);
4135 : :
4136 : 0 : if (type == _MEM) {
4137 : 0 : thresholds = &memcg->thresholds;
4138 : 0 : usage = mem_cgroup_usage(memcg, false);
4139 : 0 : } else if (type == _MEMSWAP) {
4140 : 0 : thresholds = &memcg->memsw_thresholds;
4141 : 0 : usage = mem_cgroup_usage(memcg, true);
4142 : : } else
4143 : 0 : BUG();
4144 : :
4145 : : /* Check if a threshold crossed before adding a new one */
4146 : 0 : if (thresholds->primary)
4147 : 0 : __mem_cgroup_threshold(memcg, type == _MEMSWAP);
4148 : :
4149 : 0 : size = thresholds->primary ? thresholds->primary->size + 1 : 1;
4150 : :
4151 : : /* Allocate memory for new array of thresholds */
4152 : 0 : new = kmalloc(struct_size(new, entries, size), GFP_KERNEL);
4153 : 0 : if (!new) {
4154 : : ret = -ENOMEM;
4155 : : goto unlock;
4156 : : }
4157 : 0 : new->size = size;
4158 : :
4159 : : /* Copy thresholds (if any) to new array */
4160 : 0 : if (thresholds->primary) {
4161 : 0 : memcpy(new->entries, thresholds->primary->entries, (size - 1) *
4162 : : sizeof(struct mem_cgroup_threshold));
4163 : : }
4164 : :
4165 : : /* Add new threshold */
4166 : 0 : new->entries[size - 1].eventfd = eventfd;
4167 : 0 : new->entries[size - 1].threshold = threshold;
4168 : :
4169 : : /* Sort thresholds. Registering of new threshold isn't time-critical */
4170 : 0 : sort(new->entries, size, sizeof(struct mem_cgroup_threshold),
4171 : : compare_thresholds, NULL);
4172 : :
4173 : : /* Find current threshold */
4174 : 0 : new->current_threshold = -1;
4175 : 0 : for (i = 0; i < size; i++) {
4176 : 0 : if (new->entries[i].threshold <= usage) {
4177 : : /*
4178 : : * new->current_threshold will not be used until
4179 : : * rcu_assign_pointer(), so it's safe to increment
4180 : : * it here.
4181 : : */
4182 : 0 : ++new->current_threshold;
4183 : : } else
4184 : : break;
4185 : : }
4186 : :
4187 : : /* Free old spare buffer and save old primary buffer as spare */
4188 : 0 : kfree(thresholds->spare);
4189 : 0 : thresholds->spare = thresholds->primary;
4190 : :
4191 : 0 : rcu_assign_pointer(thresholds->primary, new);
4192 : :
4193 : : /* To be sure that nobody uses thresholds */
4194 : 0 : synchronize_rcu();
4195 : :
4196 : : unlock:
4197 : 0 : mutex_unlock(&memcg->thresholds_lock);
4198 : :
4199 : 0 : return ret;
4200 : : }
4201 : :
4202 : 0 : static int mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
4203 : : struct eventfd_ctx *eventfd, const char *args)
4204 : : {
4205 : 0 : return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEM);
4206 : : }
4207 : :
4208 : 0 : static int memsw_cgroup_usage_register_event(struct mem_cgroup *memcg,
4209 : : struct eventfd_ctx *eventfd, const char *args)
4210 : : {
4211 : 0 : return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEMSWAP);
4212 : : }
4213 : :
4214 : 0 : static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4215 : : struct eventfd_ctx *eventfd, enum res_type type)
4216 : : {
4217 : : struct mem_cgroup_thresholds *thresholds;
4218 : : struct mem_cgroup_threshold_ary *new;
4219 : : unsigned long usage;
4220 : : int i, j, size, entries;
4221 : :
4222 : 0 : mutex_lock(&memcg->thresholds_lock);
4223 : :
4224 : 0 : if (type == _MEM) {
4225 : 0 : thresholds = &memcg->thresholds;
4226 : 0 : usage = mem_cgroup_usage(memcg, false);
4227 : 0 : } else if (type == _MEMSWAP) {
4228 : 0 : thresholds = &memcg->memsw_thresholds;
4229 : 0 : usage = mem_cgroup_usage(memcg, true);
4230 : : } else
4231 : 0 : BUG();
4232 : :
4233 : 0 : if (!thresholds->primary)
4234 : : goto unlock;
4235 : :
4236 : : /* Check if a threshold crossed before removing */
4237 : 0 : __mem_cgroup_threshold(memcg, type == _MEMSWAP);
4238 : :
4239 : : /* Calculate new number of threshold */
4240 : : size = entries = 0;
4241 : 0 : for (i = 0; i < thresholds->primary->size; i++) {
4242 : 0 : if (thresholds->primary->entries[i].eventfd != eventfd)
4243 : 0 : size++;
4244 : : else
4245 : 0 : entries++;
4246 : : }
4247 : :
4248 : 0 : new = thresholds->spare;
4249 : :
4250 : : /* If no items related to eventfd have been cleared, nothing to do */
4251 : 0 : if (!entries)
4252 : : goto unlock;
4253 : :
4254 : : /* Set thresholds array to NULL if we don't have thresholds */
4255 : 0 : if (!size) {
4256 : 0 : kfree(new);
4257 : : new = NULL;
4258 : 0 : goto swap_buffers;
4259 : : }
4260 : :
4261 : 0 : new->size = size;
4262 : :
4263 : : /* Copy thresholds and find current threshold */
4264 : 0 : new->current_threshold = -1;
4265 : 0 : for (i = 0, j = 0; i < thresholds->primary->size; i++) {
4266 : 0 : if (thresholds->primary->entries[i].eventfd == eventfd)
4267 : 0 : continue;
4268 : :
4269 : 0 : new->entries[j] = thresholds->primary->entries[i];
4270 : 0 : if (new->entries[j].threshold <= usage) {
4271 : : /*
4272 : : * new->current_threshold will not be used
4273 : : * until rcu_assign_pointer(), so it's safe to increment
4274 : : * it here.
4275 : : */
4276 : 0 : ++new->current_threshold;
4277 : : }
4278 : 0 : j++;
4279 : : }
4280 : :
4281 : : swap_buffers:
4282 : : /* Swap primary and spare array */
4283 : 0 : thresholds->spare = thresholds->primary;
4284 : :
4285 : 0 : rcu_assign_pointer(thresholds->primary, new);
4286 : :
4287 : : /* To be sure that nobody uses thresholds */
4288 : 0 : synchronize_rcu();
4289 : :
4290 : : /* If all events are unregistered, free the spare array */
4291 : 0 : if (!new) {
4292 : 0 : kfree(thresholds->spare);
4293 : 0 : thresholds->spare = NULL;
4294 : : }
4295 : : unlock:
4296 : 0 : mutex_unlock(&memcg->thresholds_lock);
4297 : 0 : }
4298 : :
4299 : 0 : static void mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4300 : : struct eventfd_ctx *eventfd)
4301 : : {
4302 : 0 : return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEM);
4303 : : }
4304 : :
4305 : 0 : static void memsw_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
4306 : : struct eventfd_ctx *eventfd)
4307 : : {
4308 : 0 : return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEMSWAP);
4309 : : }
4310 : :
4311 : 0 : static int mem_cgroup_oom_register_event(struct mem_cgroup *memcg,
4312 : : struct eventfd_ctx *eventfd, const char *args)
4313 : : {
4314 : : struct mem_cgroup_eventfd_list *event;
4315 : :
4316 : : event = kmalloc(sizeof(*event), GFP_KERNEL);
4317 : 0 : if (!event)
4318 : : return -ENOMEM;
4319 : :
4320 : : spin_lock(&memcg_oom_lock);
4321 : :
4322 : 0 : event->eventfd = eventfd;
4323 : 0 : list_add(&event->list, &memcg->oom_notify);
4324 : :
4325 : : /* already in OOM ? */
4326 : 0 : if (memcg->under_oom)
4327 : 0 : eventfd_signal(eventfd, 1);
4328 : : spin_unlock(&memcg_oom_lock);
4329 : :
4330 : 0 : return 0;
4331 : : }
4332 : :
4333 : 0 : static void mem_cgroup_oom_unregister_event(struct mem_cgroup *memcg,
4334 : : struct eventfd_ctx *eventfd)
4335 : : {
4336 : : struct mem_cgroup_eventfd_list *ev, *tmp;
4337 : :
4338 : : spin_lock(&memcg_oom_lock);
4339 : :
4340 : 0 : list_for_each_entry_safe(ev, tmp, &memcg->oom_notify, list) {
4341 : 0 : if (ev->eventfd == eventfd) {
4342 : : list_del(&ev->list);
4343 : 0 : kfree(ev);
4344 : : }
4345 : : }
4346 : :
4347 : : spin_unlock(&memcg_oom_lock);
4348 : 0 : }
4349 : :
4350 : 0 : static int mem_cgroup_oom_control_read(struct seq_file *sf, void *v)
4351 : : {
4352 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(sf);
4353 : :
4354 : 0 : seq_printf(sf, "oom_kill_disable %d\n", memcg->oom_kill_disable);
4355 : 0 : seq_printf(sf, "under_oom %d\n", (bool)memcg->under_oom);
4356 : 0 : seq_printf(sf, "oom_kill %lu\n",
4357 : : atomic_long_read(&memcg->memory_events[MEMCG_OOM_KILL]));
4358 : 0 : return 0;
4359 : : }
4360 : :
4361 : 0 : static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
4362 : : struct cftype *cft, u64 val)
4363 : : {
4364 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4365 : :
4366 : : /* cannot set to root cgroup and only 0 and 1 are allowed */
4367 : 0 : if (!css->parent || !((val == 0) || (val == 1)))
4368 : : return -EINVAL;
4369 : :
4370 : 0 : memcg->oom_kill_disable = val;
4371 : 0 : if (!val)
4372 : 0 : memcg_oom_recover(memcg);
4373 : :
4374 : : return 0;
4375 : : }
4376 : :
4377 : : #ifdef CONFIG_CGROUP_WRITEBACK
4378 : :
4379 : : #include <trace/events/writeback.h>
4380 : :
4381 : : static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
4382 : : {
4383 : 3 : return wb_domain_init(&memcg->cgwb_domain, gfp);
4384 : : }
4385 : :
4386 : : static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
4387 : : {
4388 : 0 : wb_domain_exit(&memcg->cgwb_domain);
4389 : : }
4390 : :
4391 : : static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
4392 : : {
4393 : 3 : wb_domain_size_changed(&memcg->cgwb_domain);
4394 : : }
4395 : :
4396 : 3 : struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
4397 : : {
4398 : 3 : struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4399 : :
4400 : 3 : if (!memcg->css.parent)
4401 : : return NULL;
4402 : :
4403 : 0 : return &memcg->cgwb_domain;
4404 : : }
4405 : :
4406 : : /*
4407 : : * idx can be of type enum memcg_stat_item or node_stat_item.
4408 : : * Keep in sync with memcg_exact_page().
4409 : : */
4410 : 0 : static unsigned long memcg_exact_page_state(struct mem_cgroup *memcg, int idx)
4411 : : {
4412 : 0 : long x = atomic_long_read(&memcg->vmstats[idx]);
4413 : : int cpu;
4414 : :
4415 : 0 : for_each_online_cpu(cpu)
4416 : 0 : x += per_cpu_ptr(memcg->vmstats_percpu, cpu)->stat[idx];
4417 : 0 : if (x < 0)
4418 : : x = 0;
4419 : 0 : return x;
4420 : : }
4421 : :
4422 : : /**
4423 : : * mem_cgroup_wb_stats - retrieve writeback related stats from its memcg
4424 : : * @wb: bdi_writeback in question
4425 : : * @pfilepages: out parameter for number of file pages
4426 : : * @pheadroom: out parameter for number of allocatable pages according to memcg
4427 : : * @pdirty: out parameter for number of dirty pages
4428 : : * @pwriteback: out parameter for number of pages under writeback
4429 : : *
4430 : : * Determine the numbers of file, headroom, dirty, and writeback pages in
4431 : : * @wb's memcg. File, dirty and writeback are self-explanatory. Headroom
4432 : : * is a bit more involved.
4433 : : *
4434 : : * A memcg's headroom is "min(max, high) - used". In the hierarchy, the
4435 : : * headroom is calculated as the lowest headroom of itself and the
4436 : : * ancestors. Note that this doesn't consider the actual amount of
4437 : : * available memory in the system. The caller should further cap
4438 : : * *@pheadroom accordingly.
4439 : : */
4440 : 0 : void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
4441 : : unsigned long *pheadroom, unsigned long *pdirty,
4442 : : unsigned long *pwriteback)
4443 : : {
4444 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4445 : : struct mem_cgroup *parent;
4446 : :
4447 : 0 : *pdirty = memcg_exact_page_state(memcg, NR_FILE_DIRTY);
4448 : :
4449 : : /* this should eventually include NR_UNSTABLE_NFS */
4450 : 0 : *pwriteback = memcg_exact_page_state(memcg, NR_WRITEBACK);
4451 : 0 : *pfilepages = memcg_exact_page_state(memcg, NR_INACTIVE_FILE) +
4452 : 0 : memcg_exact_page_state(memcg, NR_ACTIVE_FILE);
4453 : 0 : *pheadroom = PAGE_COUNTER_MAX;
4454 : :
4455 : 0 : while ((parent = parent_mem_cgroup(memcg))) {
4456 : 0 : unsigned long ceiling = min(memcg->memory.max, memcg->high);
4457 : : unsigned long used = page_counter_read(&memcg->memory);
4458 : :
4459 : 0 : *pheadroom = min(*pheadroom, ceiling - min(ceiling, used));
4460 : : memcg = parent;
4461 : : }
4462 : 0 : }
4463 : :
4464 : : /*
4465 : : * Foreign dirty flushing
4466 : : *
4467 : : * There's an inherent mismatch between memcg and writeback. The former
4468 : : * trackes ownership per-page while the latter per-inode. This was a
4469 : : * deliberate design decision because honoring per-page ownership in the
4470 : : * writeback path is complicated, may lead to higher CPU and IO overheads
4471 : : * and deemed unnecessary given that write-sharing an inode across
4472 : : * different cgroups isn't a common use-case.
4473 : : *
4474 : : * Combined with inode majority-writer ownership switching, this works well
4475 : : * enough in most cases but there are some pathological cases. For
4476 : : * example, let's say there are two cgroups A and B which keep writing to
4477 : : * different but confined parts of the same inode. B owns the inode and
4478 : : * A's memory is limited far below B's. A's dirty ratio can rise enough to
4479 : : * trigger balance_dirty_pages() sleeps but B's can be low enough to avoid
4480 : : * triggering background writeback. A will be slowed down without a way to
4481 : : * make writeback of the dirty pages happen.
4482 : : *
4483 : : * Conditions like the above can lead to a cgroup getting repatedly and
4484 : : * severely throttled after making some progress after each
4485 : : * dirty_expire_interval while the underyling IO device is almost
4486 : : * completely idle.
4487 : : *
4488 : : * Solving this problem completely requires matching the ownership tracking
4489 : : * granularities between memcg and writeback in either direction. However,
4490 : : * the more egregious behaviors can be avoided by simply remembering the
4491 : : * most recent foreign dirtying events and initiating remote flushes on
4492 : : * them when local writeback isn't enough to keep the memory clean enough.
4493 : : *
4494 : : * The following two functions implement such mechanism. When a foreign
4495 : : * page - a page whose memcg and writeback ownerships don't match - is
4496 : : * dirtied, mem_cgroup_track_foreign_dirty() records the inode owning
4497 : : * bdi_writeback on the page owning memcg. When balance_dirty_pages()
4498 : : * decides that the memcg needs to sleep due to high dirty ratio, it calls
4499 : : * mem_cgroup_flush_foreign() which queues writeback on the recorded
4500 : : * foreign bdi_writebacks which haven't expired. Both the numbers of
4501 : : * recorded bdi_writebacks and concurrent in-flight foreign writebacks are
4502 : : * limited to MEMCG_CGWB_FRN_CNT.
4503 : : *
4504 : : * The mechanism only remembers IDs and doesn't hold any object references.
4505 : : * As being wrong occasionally doesn't matter, updates and accesses to the
4506 : : * records are lockless and racy.
4507 : : */
4508 : 0 : void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
4509 : : struct bdi_writeback *wb)
4510 : : {
4511 : 0 : struct mem_cgroup *memcg = page->mem_cgroup;
4512 : : struct memcg_cgwb_frn *frn;
4513 : 0 : u64 now = get_jiffies_64();
4514 : : u64 oldest_at = now;
4515 : : int oldest = -1;
4516 : : int i;
4517 : :
4518 : 0 : trace_track_foreign_dirty(page, wb);
4519 : :
4520 : : /*
4521 : : * Pick the slot to use. If there is already a slot for @wb, keep
4522 : : * using it. If not replace the oldest one which isn't being
4523 : : * written out.
4524 : : */
4525 : 0 : for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++) {
4526 : 0 : frn = &memcg->cgwb_frn[i];
4527 : 0 : if (frn->bdi_id == wb->bdi->id &&
4528 : 0 : frn->memcg_id == wb->memcg_css->id)
4529 : : break;
4530 : 0 : if (time_before64(frn->at, oldest_at) &&
4531 : 0 : atomic_read(&frn->done.cnt) == 1) {
4532 : : oldest = i;
4533 : : oldest_at = frn->at;
4534 : : }
4535 : : }
4536 : :
4537 : 0 : if (i < MEMCG_CGWB_FRN_CNT) {
4538 : : /*
4539 : : * Re-using an existing one. Update timestamp lazily to
4540 : : * avoid making the cacheline hot. We want them to be
4541 : : * reasonably up-to-date and significantly shorter than
4542 : : * dirty_expire_interval as that's what expires the record.
4543 : : * Use the shorter of 1s and dirty_expire_interval / 8.
4544 : : */
4545 : : unsigned long update_intv =
4546 : 0 : min_t(unsigned long, HZ,
4547 : : msecs_to_jiffies(dirty_expire_interval * 10) / 8);
4548 : :
4549 : 0 : if (time_before64(frn->at, now - update_intv))
4550 : 0 : frn->at = now;
4551 : 0 : } else if (oldest >= 0) {
4552 : : /* replace the oldest free one */
4553 : : frn = &memcg->cgwb_frn[oldest];
4554 : 0 : frn->bdi_id = wb->bdi->id;
4555 : 0 : frn->memcg_id = wb->memcg_css->id;
4556 : 0 : frn->at = now;
4557 : : }
4558 : 0 : }
4559 : :
4560 : : /* issue foreign writeback flushes for recorded foreign dirtying events */
4561 : 0 : void mem_cgroup_flush_foreign(struct bdi_writeback *wb)
4562 : : {
4563 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(wb->memcg_css);
4564 : 0 : unsigned long intv = msecs_to_jiffies(dirty_expire_interval * 10);
4565 : 0 : u64 now = jiffies_64;
4566 : : int i;
4567 : :
4568 : 0 : for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++) {
4569 : : struct memcg_cgwb_frn *frn = &memcg->cgwb_frn[i];
4570 : :
4571 : : /*
4572 : : * If the record is older than dirty_expire_interval,
4573 : : * writeback on it has already started. No need to kick it
4574 : : * off again. Also, don't start a new one if there's
4575 : : * already one in flight.
4576 : : */
4577 : 0 : if (time_after64(frn->at, now - intv) &&
4578 : 0 : atomic_read(&frn->done.cnt) == 1) {
4579 : 0 : frn->at = 0;
4580 : 0 : trace_flush_foreign(wb, frn->bdi_id, frn->memcg_id);
4581 : 0 : cgroup_writeback_by_id(frn->bdi_id, frn->memcg_id, 0,
4582 : : WB_REASON_FOREIGN_FLUSH,
4583 : : &frn->done);
4584 : : }
4585 : : }
4586 : 0 : }
4587 : :
4588 : : #else /* CONFIG_CGROUP_WRITEBACK */
4589 : :
4590 : : static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
4591 : : {
4592 : : return 0;
4593 : : }
4594 : :
4595 : : static void memcg_wb_domain_exit(struct mem_cgroup *memcg)
4596 : : {
4597 : : }
4598 : :
4599 : : static void memcg_wb_domain_size_changed(struct mem_cgroup *memcg)
4600 : : {
4601 : : }
4602 : :
4603 : : #endif /* CONFIG_CGROUP_WRITEBACK */
4604 : :
4605 : : /*
4606 : : * DO NOT USE IN NEW FILES.
4607 : : *
4608 : : * "cgroup.event_control" implementation.
4609 : : *
4610 : : * This is way over-engineered. It tries to support fully configurable
4611 : : * events for each user. Such level of flexibility is completely
4612 : : * unnecessary especially in the light of the planned unified hierarchy.
4613 : : *
4614 : : * Please deprecate this and replace with something simpler if at all
4615 : : * possible.
4616 : : */
4617 : :
4618 : : /*
4619 : : * Unregister event and free resources.
4620 : : *
4621 : : * Gets called from workqueue.
4622 : : */
4623 : 0 : static void memcg_event_remove(struct work_struct *work)
4624 : : {
4625 : : struct mem_cgroup_event *event =
4626 : 0 : container_of(work, struct mem_cgroup_event, remove);
4627 : 0 : struct mem_cgroup *memcg = event->memcg;
4628 : :
4629 : 0 : remove_wait_queue(event->wqh, &event->wait);
4630 : :
4631 : 0 : event->unregister_event(memcg, event->eventfd);
4632 : :
4633 : : /* Notify userspace the event is going away. */
4634 : 0 : eventfd_signal(event->eventfd, 1);
4635 : :
4636 : 0 : eventfd_ctx_put(event->eventfd);
4637 : 0 : kfree(event);
4638 : : css_put(&memcg->css);
4639 : 0 : }
4640 : :
4641 : : /*
4642 : : * Gets called on EPOLLHUP on eventfd when user closes it.
4643 : : *
4644 : : * Called with wqh->lock held and interrupts disabled.
4645 : : */
4646 : 0 : static int memcg_event_wake(wait_queue_entry_t *wait, unsigned mode,
4647 : : int sync, void *key)
4648 : : {
4649 : : struct mem_cgroup_event *event =
4650 : : container_of(wait, struct mem_cgroup_event, wait);
4651 : 0 : struct mem_cgroup *memcg = event->memcg;
4652 : 0 : __poll_t flags = key_to_poll(key);
4653 : :
4654 : 0 : if (flags & EPOLLHUP) {
4655 : : /*
4656 : : * If the event has been detached at cgroup removal, we
4657 : : * can simply return knowing the other side will cleanup
4658 : : * for us.
4659 : : *
4660 : : * We can't race against event freeing since the other
4661 : : * side will require wqh->lock via remove_wait_queue(),
4662 : : * which we hold.
4663 : : */
4664 : : spin_lock(&memcg->event_list_lock);
4665 : 0 : if (!list_empty(&event->list)) {
4666 : : list_del_init(&event->list);
4667 : : /*
4668 : : * We are in atomic context, but cgroup_event_remove()
4669 : : * may sleep, so we have to call it in workqueue.
4670 : : */
4671 : 0 : schedule_work(&event->remove);
4672 : : }
4673 : : spin_unlock(&memcg->event_list_lock);
4674 : : }
4675 : :
4676 : 0 : return 0;
4677 : : }
4678 : :
4679 : 0 : static void memcg_event_ptable_queue_proc(struct file *file,
4680 : : wait_queue_head_t *wqh, poll_table *pt)
4681 : : {
4682 : : struct mem_cgroup_event *event =
4683 : : container_of(pt, struct mem_cgroup_event, pt);
4684 : :
4685 : 0 : event->wqh = wqh;
4686 : 0 : add_wait_queue(wqh, &event->wait);
4687 : 0 : }
4688 : :
4689 : : /*
4690 : : * DO NOT USE IN NEW FILES.
4691 : : *
4692 : : * Parse input and register new cgroup event handler.
4693 : : *
4694 : : * Input must be in format '<event_fd> <control_fd> <args>'.
4695 : : * Interpretation of args is defined by control file implementation.
4696 : : */
4697 : 0 : static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
4698 : : char *buf, size_t nbytes, loff_t off)
4699 : : {
4700 : 0 : struct cgroup_subsys_state *css = of_css(of);
4701 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4702 : : struct mem_cgroup_event *event;
4703 : : struct cgroup_subsys_state *cfile_css;
4704 : : unsigned int efd, cfd;
4705 : : struct fd efile;
4706 : : struct fd cfile;
4707 : : const char *name;
4708 : : char *endp;
4709 : : int ret;
4710 : :
4711 : : buf = strstrip(buf);
4712 : :
4713 : 0 : efd = simple_strtoul(buf, &endp, 10);
4714 : 0 : if (*endp != ' ')
4715 : : return -EINVAL;
4716 : 0 : buf = endp + 1;
4717 : :
4718 : 0 : cfd = simple_strtoul(buf, &endp, 10);
4719 : 0 : if ((*endp != ' ') && (*endp != '\0'))
4720 : : return -EINVAL;
4721 : 0 : buf = endp + 1;
4722 : :
4723 : 0 : event = kzalloc(sizeof(*event), GFP_KERNEL);
4724 : 0 : if (!event)
4725 : : return -ENOMEM;
4726 : :
4727 : 0 : event->memcg = memcg;
4728 : 0 : INIT_LIST_HEAD(&event->list);
4729 : : init_poll_funcptr(&event->pt, memcg_event_ptable_queue_proc);
4730 : : init_waitqueue_func_entry(&event->wait, memcg_event_wake);
4731 : 0 : INIT_WORK(&event->remove, memcg_event_remove);
4732 : :
4733 : : efile = fdget(efd);
4734 : 0 : if (!efile.file) {
4735 : : ret = -EBADF;
4736 : : goto out_kfree;
4737 : : }
4738 : :
4739 : 0 : event->eventfd = eventfd_ctx_fileget(efile.file);
4740 : 0 : if (IS_ERR(event->eventfd)) {
4741 : : ret = PTR_ERR(event->eventfd);
4742 : 0 : goto out_put_efile;
4743 : : }
4744 : :
4745 : : cfile = fdget(cfd);
4746 : 0 : if (!cfile.file) {
4747 : : ret = -EBADF;
4748 : : goto out_put_eventfd;
4749 : : }
4750 : :
4751 : : /* the process need read permission on control file */
4752 : : /* AV: shouldn't we check that it's been opened for read instead? */
4753 : 0 : ret = inode_permission(file_inode(cfile.file), MAY_READ);
4754 : 0 : if (ret < 0)
4755 : : goto out_put_cfile;
4756 : :
4757 : : /*
4758 : : * Determine the event callbacks and set them in @event. This used
4759 : : * to be done via struct cftype but cgroup core no longer knows
4760 : : * about these events. The following is crude but the whole thing
4761 : : * is for compatibility anyway.
4762 : : *
4763 : : * DO NOT ADD NEW FILES.
4764 : : */
4765 : 0 : name = cfile.file->f_path.dentry->d_name.name;
4766 : :
4767 : 0 : if (!strcmp(name, "memory.usage_in_bytes")) {
4768 : 0 : event->register_event = mem_cgroup_usage_register_event;
4769 : 0 : event->unregister_event = mem_cgroup_usage_unregister_event;
4770 : 0 : } else if (!strcmp(name, "memory.oom_control")) {
4771 : 0 : event->register_event = mem_cgroup_oom_register_event;
4772 : 0 : event->unregister_event = mem_cgroup_oom_unregister_event;
4773 : 0 : } else if (!strcmp(name, "memory.pressure_level")) {
4774 : 0 : event->register_event = vmpressure_register_event;
4775 : 0 : event->unregister_event = vmpressure_unregister_event;
4776 : 0 : } else if (!strcmp(name, "memory.memsw.usage_in_bytes")) {
4777 : 0 : event->register_event = memsw_cgroup_usage_register_event;
4778 : 0 : event->unregister_event = memsw_cgroup_usage_unregister_event;
4779 : : } else {
4780 : : ret = -EINVAL;
4781 : : goto out_put_cfile;
4782 : : }
4783 : :
4784 : : /*
4785 : : * Verify @cfile should belong to @css. Also, remaining events are
4786 : : * automatically removed on cgroup destruction but the removal is
4787 : : * asynchronous, so take an extra ref on @css.
4788 : : */
4789 : 0 : cfile_css = css_tryget_online_from_dir(cfile.file->f_path.dentry->d_parent,
4790 : : &memory_cgrp_subsys);
4791 : : ret = -EINVAL;
4792 : 0 : if (IS_ERR(cfile_css))
4793 : : goto out_put_cfile;
4794 : 0 : if (cfile_css != css) {
4795 : : css_put(cfile_css);
4796 : : goto out_put_cfile;
4797 : : }
4798 : :
4799 : 0 : ret = event->register_event(memcg, event->eventfd, buf);
4800 : 0 : if (ret)
4801 : : goto out_put_css;
4802 : :
4803 : 0 : vfs_poll(efile.file, &event->pt);
4804 : :
4805 : : spin_lock(&memcg->event_list_lock);
4806 : 0 : list_add(&event->list, &memcg->event_list);
4807 : : spin_unlock(&memcg->event_list_lock);
4808 : :
4809 : : fdput(cfile);
4810 : : fdput(efile);
4811 : :
4812 : 0 : return nbytes;
4813 : :
4814 : : out_put_css:
4815 : : css_put(css);
4816 : : out_put_cfile:
4817 : : fdput(cfile);
4818 : : out_put_eventfd:
4819 : 0 : eventfd_ctx_put(event->eventfd);
4820 : : out_put_efile:
4821 : : fdput(efile);
4822 : : out_kfree:
4823 : 0 : kfree(event);
4824 : :
4825 : 0 : return ret;
4826 : : }
4827 : :
4828 : : static struct cftype mem_cgroup_legacy_files[] = {
4829 : : {
4830 : : .name = "usage_in_bytes",
4831 : : .private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
4832 : : .read_u64 = mem_cgroup_read_u64,
4833 : : },
4834 : : {
4835 : : .name = "max_usage_in_bytes",
4836 : : .private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
4837 : : .write = mem_cgroup_reset,
4838 : : .read_u64 = mem_cgroup_read_u64,
4839 : : },
4840 : : {
4841 : : .name = "limit_in_bytes",
4842 : : .private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
4843 : : .write = mem_cgroup_write,
4844 : : .read_u64 = mem_cgroup_read_u64,
4845 : : },
4846 : : {
4847 : : .name = "soft_limit_in_bytes",
4848 : : .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
4849 : : .write = mem_cgroup_write,
4850 : : .read_u64 = mem_cgroup_read_u64,
4851 : : },
4852 : : {
4853 : : .name = "failcnt",
4854 : : .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
4855 : : .write = mem_cgroup_reset,
4856 : : .read_u64 = mem_cgroup_read_u64,
4857 : : },
4858 : : {
4859 : : .name = "stat",
4860 : : .seq_show = memcg_stat_show,
4861 : : },
4862 : : {
4863 : : .name = "force_empty",
4864 : : .write = mem_cgroup_force_empty_write,
4865 : : },
4866 : : {
4867 : : .name = "use_hierarchy",
4868 : : .write_u64 = mem_cgroup_hierarchy_write,
4869 : : .read_u64 = mem_cgroup_hierarchy_read,
4870 : : },
4871 : : {
4872 : : .name = "cgroup.event_control", /* XXX: for compat */
4873 : : .write = memcg_write_event_control,
4874 : : .flags = CFTYPE_NO_PREFIX | CFTYPE_WORLD_WRITABLE,
4875 : : },
4876 : : {
4877 : : .name = "swappiness",
4878 : : .read_u64 = mem_cgroup_swappiness_read,
4879 : : .write_u64 = mem_cgroup_swappiness_write,
4880 : : },
4881 : : {
4882 : : .name = "move_charge_at_immigrate",
4883 : : .read_u64 = mem_cgroup_move_charge_read,
4884 : : .write_u64 = mem_cgroup_move_charge_write,
4885 : : },
4886 : : {
4887 : : .name = "oom_control",
4888 : : .seq_show = mem_cgroup_oom_control_read,
4889 : : .write_u64 = mem_cgroup_oom_control_write,
4890 : : .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL),
4891 : : },
4892 : : {
4893 : : .name = "pressure_level",
4894 : : },
4895 : : #ifdef CONFIG_NUMA
4896 : : {
4897 : : .name = "numa_stat",
4898 : : .seq_show = memcg_numa_stat_show,
4899 : : },
4900 : : #endif
4901 : : {
4902 : : .name = "kmem.limit_in_bytes",
4903 : : .private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),
4904 : : .write = mem_cgroup_write,
4905 : : .read_u64 = mem_cgroup_read_u64,
4906 : : },
4907 : : {
4908 : : .name = "kmem.usage_in_bytes",
4909 : : .private = MEMFILE_PRIVATE(_KMEM, RES_USAGE),
4910 : : .read_u64 = mem_cgroup_read_u64,
4911 : : },
4912 : : {
4913 : : .name = "kmem.failcnt",
4914 : : .private = MEMFILE_PRIVATE(_KMEM, RES_FAILCNT),
4915 : : .write = mem_cgroup_reset,
4916 : : .read_u64 = mem_cgroup_read_u64,
4917 : : },
4918 : : {
4919 : : .name = "kmem.max_usage_in_bytes",
4920 : : .private = MEMFILE_PRIVATE(_KMEM, RES_MAX_USAGE),
4921 : : .write = mem_cgroup_reset,
4922 : : .read_u64 = mem_cgroup_read_u64,
4923 : : },
4924 : : #if defined(CONFIG_SLAB) || defined(CONFIG_SLUB_DEBUG)
4925 : : {
4926 : : .name = "kmem.slabinfo",
4927 : : .seq_start = memcg_slab_start,
4928 : : .seq_next = memcg_slab_next,
4929 : : .seq_stop = memcg_slab_stop,
4930 : : .seq_show = memcg_slab_show,
4931 : : },
4932 : : #endif
4933 : : {
4934 : : .name = "kmem.tcp.limit_in_bytes",
4935 : : .private = MEMFILE_PRIVATE(_TCP, RES_LIMIT),
4936 : : .write = mem_cgroup_write,
4937 : : .read_u64 = mem_cgroup_read_u64,
4938 : : },
4939 : : {
4940 : : .name = "kmem.tcp.usage_in_bytes",
4941 : : .private = MEMFILE_PRIVATE(_TCP, RES_USAGE),
4942 : : .read_u64 = mem_cgroup_read_u64,
4943 : : },
4944 : : {
4945 : : .name = "kmem.tcp.failcnt",
4946 : : .private = MEMFILE_PRIVATE(_TCP, RES_FAILCNT),
4947 : : .write = mem_cgroup_reset,
4948 : : .read_u64 = mem_cgroup_read_u64,
4949 : : },
4950 : : {
4951 : : .name = "kmem.tcp.max_usage_in_bytes",
4952 : : .private = MEMFILE_PRIVATE(_TCP, RES_MAX_USAGE),
4953 : : .write = mem_cgroup_reset,
4954 : : .read_u64 = mem_cgroup_read_u64,
4955 : : },
4956 : : { }, /* terminate */
4957 : : };
4958 : :
4959 : : /*
4960 : : * Private memory cgroup IDR
4961 : : *
4962 : : * Swap-out records and page cache shadow entries need to store memcg
4963 : : * references in constrained space, so we maintain an ID space that is
4964 : : * limited to 16 bit (MEM_CGROUP_ID_MAX), limiting the total number of
4965 : : * memory-controlled cgroups to 64k.
4966 : : *
4967 : : * However, there usually are many references to the oflline CSS after
4968 : : * the cgroup has been destroyed, such as page cache or reclaimable
4969 : : * slab objects, that don't need to hang on to the ID. We want to keep
4970 : : * those dead CSS from occupying IDs, or we might quickly exhaust the
4971 : : * relatively small ID space and prevent the creation of new cgroups
4972 : : * even when there are much fewer than 64k cgroups - possibly none.
4973 : : *
4974 : : * Maintain a private 16-bit ID space for memcg, and allow the ID to
4975 : : * be freed and recycled when it's no longer needed, which is usually
4976 : : * when the CSS is offlined.
4977 : : *
4978 : : * The only exception to that are records of swapped out tmpfs/shmem
4979 : : * pages that need to be attributed to live ancestors on swapin. But
4980 : : * those references are manageable from userspace.
4981 : : */
4982 : :
4983 : : static DEFINE_IDR(mem_cgroup_idr);
4984 : :
4985 : : static void mem_cgroup_id_remove(struct mem_cgroup *memcg)
4986 : : {
4987 : 0 : if (memcg->id.id > 0) {
4988 : 0 : idr_remove(&mem_cgroup_idr, memcg->id.id);
4989 : 0 : memcg->id.id = 0;
4990 : : }
4991 : : }
4992 : :
4993 : : static void mem_cgroup_id_get_many(struct mem_cgroup *memcg, unsigned int n)
4994 : : {
4995 : : refcount_add(n, &memcg->id.ref);
4996 : : }
4997 : :
4998 : 0 : static void mem_cgroup_id_put_many(struct mem_cgroup *memcg, unsigned int n)
4999 : : {
5000 : 0 : if (refcount_sub_and_test(n, &memcg->id.ref)) {
5001 : : mem_cgroup_id_remove(memcg);
5002 : :
5003 : : /* Memcg ID pins CSS */
5004 : : css_put(&memcg->css);
5005 : : }
5006 : 0 : }
5007 : :
5008 : : static inline void mem_cgroup_id_put(struct mem_cgroup *memcg)
5009 : : {
5010 : 0 : mem_cgroup_id_put_many(memcg, 1);
5011 : : }
5012 : :
5013 : : /**
5014 : : * mem_cgroup_from_id - look up a memcg from a memcg id
5015 : : * @id: the memcg id to look up
5016 : : *
5017 : : * Caller must hold rcu_read_lock().
5018 : : */
5019 : 0 : struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
5020 : : {
5021 : : WARN_ON_ONCE(!rcu_read_lock_held());
5022 : 0 : return idr_find(&mem_cgroup_idr, id);
5023 : : }
5024 : :
5025 : 3 : static int alloc_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node)
5026 : : {
5027 : : struct mem_cgroup_per_node *pn;
5028 : : int tmp = node;
5029 : : /*
5030 : : * This routine is called against possible nodes.
5031 : : * But it's BUG to call kmalloc() against offline node.
5032 : : *
5033 : : * TODO: this routine can waste much memory for nodes which will
5034 : : * never be onlined. It's better to use memory hotplug callback
5035 : : * function.
5036 : : */
5037 : 3 : if (!node_state(node, N_NORMAL_MEMORY))
5038 : : tmp = -1;
5039 : 3 : pn = kzalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
5040 : 3 : if (!pn)
5041 : : return 1;
5042 : :
5043 : 3 : pn->lruvec_stat_local = alloc_percpu(struct lruvec_stat);
5044 : 3 : if (!pn->lruvec_stat_local) {
5045 : 0 : kfree(pn);
5046 : 0 : return 1;
5047 : : }
5048 : :
5049 : 3 : pn->lruvec_stat_cpu = alloc_percpu(struct lruvec_stat);
5050 : 3 : if (!pn->lruvec_stat_cpu) {
5051 : 0 : free_percpu(pn->lruvec_stat_local);
5052 : 0 : kfree(pn);
5053 : 0 : return 1;
5054 : : }
5055 : :
5056 : 3 : lruvec_init(&pn->lruvec);
5057 : 3 : pn->usage_in_excess = 0;
5058 : 3 : pn->on_tree = false;
5059 : 3 : pn->memcg = memcg;
5060 : :
5061 : 3 : memcg->nodeinfo[node] = pn;
5062 : 3 : return 0;
5063 : : }
5064 : :
5065 : 0 : static void free_mem_cgroup_per_node_info(struct mem_cgroup *memcg, int node)
5066 : : {
5067 : 0 : struct mem_cgroup_per_node *pn = memcg->nodeinfo[node];
5068 : :
5069 : 0 : if (!pn)
5070 : 0 : return;
5071 : :
5072 : 0 : free_percpu(pn->lruvec_stat_cpu);
5073 : 0 : free_percpu(pn->lruvec_stat_local);
5074 : 0 : kfree(pn);
5075 : : }
5076 : :
5077 : 0 : static void __mem_cgroup_free(struct mem_cgroup *memcg)
5078 : : {
5079 : : int node;
5080 : :
5081 : 0 : for_each_node(node)
5082 : 0 : free_mem_cgroup_per_node_info(memcg, node);
5083 : 0 : free_percpu(memcg->vmstats_percpu);
5084 : 0 : free_percpu(memcg->vmstats_local);
5085 : 0 : kfree(memcg);
5086 : 0 : }
5087 : :
5088 : 0 : static void mem_cgroup_free(struct mem_cgroup *memcg)
5089 : : {
5090 : : memcg_wb_domain_exit(memcg);
5091 : : /*
5092 : : * Flush percpu vmstats and vmevents to guarantee the value correctness
5093 : : * on parent's and all ancestor levels.
5094 : : */
5095 : 0 : memcg_flush_percpu_vmstats(memcg);
5096 : 0 : memcg_flush_percpu_vmevents(memcg);
5097 : 0 : __mem_cgroup_free(memcg);
5098 : 0 : }
5099 : :
5100 : 3 : static struct mem_cgroup *mem_cgroup_alloc(void)
5101 : : {
5102 : : struct mem_cgroup *memcg;
5103 : : unsigned int size;
5104 : : int node;
5105 : : int __maybe_unused i;
5106 : : long error = -ENOMEM;
5107 : :
5108 : : size = sizeof(struct mem_cgroup);
5109 : : size += nr_node_ids * sizeof(struct mem_cgroup_per_node *);
5110 : :
5111 : 3 : memcg = kzalloc(size, GFP_KERNEL);
5112 : 3 : if (!memcg)
5113 : : return ERR_PTR(error);
5114 : :
5115 : 3 : memcg->id.id = idr_alloc(&mem_cgroup_idr, NULL,
5116 : : 1, MEM_CGROUP_ID_MAX,
5117 : : GFP_KERNEL);
5118 : 3 : if (memcg->id.id < 0) {
5119 : : error = memcg->id.id;
5120 : : goto fail;
5121 : : }
5122 : :
5123 : 3 : memcg->vmstats_local = alloc_percpu(struct memcg_vmstats_percpu);
5124 : 3 : if (!memcg->vmstats_local)
5125 : : goto fail;
5126 : :
5127 : 3 : memcg->vmstats_percpu = alloc_percpu(struct memcg_vmstats_percpu);
5128 : 3 : if (!memcg->vmstats_percpu)
5129 : : goto fail;
5130 : :
5131 : 3 : for_each_node(node)
5132 : 3 : if (alloc_mem_cgroup_per_node_info(memcg, node))
5133 : : goto fail;
5134 : :
5135 : 3 : if (memcg_wb_domain_init(memcg, GFP_KERNEL))
5136 : : goto fail;
5137 : :
5138 : 3 : INIT_WORK(&memcg->high_work, high_work_func);
5139 : 3 : memcg->last_scanned_node = MAX_NUMNODES;
5140 : 3 : INIT_LIST_HEAD(&memcg->oom_notify);
5141 : 3 : mutex_init(&memcg->thresholds_lock);
5142 : 3 : spin_lock_init(&memcg->move_lock);
5143 : 3 : vmpressure_init(&memcg->vmpressure);
5144 : 3 : INIT_LIST_HEAD(&memcg->event_list);
5145 : 3 : spin_lock_init(&memcg->event_list_lock);
5146 : 3 : memcg->socket_pressure = jiffies;
5147 : : #ifdef CONFIG_MEMCG_KMEM
5148 : 3 : memcg->kmemcg_id = -1;
5149 : : #endif
5150 : : #ifdef CONFIG_CGROUP_WRITEBACK
5151 : 3 : INIT_LIST_HEAD(&memcg->cgwb_list);
5152 : 3 : for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++)
5153 : 3 : memcg->cgwb_frn[i].done =
5154 : : __WB_COMPLETION_INIT(&memcg_cgwb_frn_waitq);
5155 : : #endif
5156 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5157 : : spin_lock_init(&memcg->deferred_split_queue.split_queue_lock);
5158 : : INIT_LIST_HEAD(&memcg->deferred_split_queue.split_queue);
5159 : : memcg->deferred_split_queue.split_queue_len = 0;
5160 : : #endif
5161 : 3 : idr_replace(&mem_cgroup_idr, memcg, memcg->id.id);
5162 : 3 : return memcg;
5163 : : fail:
5164 : : mem_cgroup_id_remove(memcg);
5165 : 0 : __mem_cgroup_free(memcg);
5166 : 0 : return ERR_PTR(error);
5167 : : }
5168 : :
5169 : : static struct cgroup_subsys_state * __ref
5170 : 3 : mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
5171 : : {
5172 : : struct mem_cgroup *parent = mem_cgroup_from_css(parent_css);
5173 : : struct mem_cgroup *memcg;
5174 : : long error = -ENOMEM;
5175 : :
5176 : 3 : memcg = mem_cgroup_alloc();
5177 : 3 : if (IS_ERR(memcg))
5178 : : return ERR_CAST(memcg);
5179 : :
5180 : 3 : memcg->high = PAGE_COUNTER_MAX;
5181 : 3 : memcg->soft_limit = PAGE_COUNTER_MAX;
5182 : 3 : if (parent) {
5183 : 0 : memcg->swappiness = mem_cgroup_swappiness(parent);
5184 : 0 : memcg->oom_kill_disable = parent->oom_kill_disable;
5185 : : }
5186 : 3 : if (parent && parent->use_hierarchy) {
5187 : 0 : memcg->use_hierarchy = true;
5188 : 0 : page_counter_init(&memcg->memory, &parent->memory);
5189 : 0 : page_counter_init(&memcg->swap, &parent->swap);
5190 : 0 : page_counter_init(&memcg->memsw, &parent->memsw);
5191 : 0 : page_counter_init(&memcg->kmem, &parent->kmem);
5192 : 0 : page_counter_init(&memcg->tcpmem, &parent->tcpmem);
5193 : : } else {
5194 : : page_counter_init(&memcg->memory, NULL);
5195 : : page_counter_init(&memcg->swap, NULL);
5196 : : page_counter_init(&memcg->memsw, NULL);
5197 : : page_counter_init(&memcg->kmem, NULL);
5198 : : page_counter_init(&memcg->tcpmem, NULL);
5199 : : /*
5200 : : * Deeper hierachy with use_hierarchy == false doesn't make
5201 : : * much sense so let cgroup subsystem know about this
5202 : : * unfortunate state in our controller.
5203 : : */
5204 : 3 : if (parent != root_mem_cgroup)
5205 : 0 : memory_cgrp_subsys.broken_hierarchy = true;
5206 : : }
5207 : :
5208 : : /* The following stuff does not apply to the root */
5209 : 3 : if (!parent) {
5210 : : #ifdef CONFIG_MEMCG_KMEM
5211 : 3 : INIT_LIST_HEAD(&memcg->kmem_caches);
5212 : : #endif
5213 : 3 : root_mem_cgroup = memcg;
5214 : 3 : return &memcg->css;
5215 : : }
5216 : :
5217 : 0 : error = memcg_online_kmem(memcg);
5218 : 0 : if (error)
5219 : : goto fail;
5220 : :
5221 : 0 : if (cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_nosocket)
5222 : 0 : static_branch_inc(&memcg_sockets_enabled_key);
5223 : :
5224 : 0 : return &memcg->css;
5225 : : fail:
5226 : : mem_cgroup_id_remove(memcg);
5227 : 0 : mem_cgroup_free(memcg);
5228 : 0 : return ERR_PTR(error);
5229 : : }
5230 : :
5231 : 3 : static int mem_cgroup_css_online(struct cgroup_subsys_state *css)
5232 : : {
5233 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5234 : :
5235 : : /*
5236 : : * A memcg must be visible for memcg_expand_shrinker_maps()
5237 : : * by the time the maps are allocated. So, we allocate maps
5238 : : * here, when for_each_mem_cgroup() can't skip it.
5239 : : */
5240 : 3 : if (memcg_alloc_shrinker_maps(memcg)) {
5241 : : mem_cgroup_id_remove(memcg);
5242 : : return -ENOMEM;
5243 : : }
5244 : :
5245 : : /* Online state pins memcg ID, memcg ID pins CSS */
5246 : : refcount_set(&memcg->id.ref, 1);
5247 : : css_get(css);
5248 : : return 0;
5249 : : }
5250 : :
5251 : 0 : static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
5252 : : {
5253 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5254 : : struct mem_cgroup_event *event, *tmp;
5255 : :
5256 : : /*
5257 : : * Unregister events and notify userspace.
5258 : : * Notify userspace about cgroup removing only after rmdir of cgroup
5259 : : * directory to avoid race between userspace and kernelspace.
5260 : : */
5261 : : spin_lock(&memcg->event_list_lock);
5262 : 0 : list_for_each_entry_safe(event, tmp, &memcg->event_list, list) {
5263 : : list_del_init(&event->list);
5264 : 0 : schedule_work(&event->remove);
5265 : : }
5266 : : spin_unlock(&memcg->event_list_lock);
5267 : :
5268 : 0 : page_counter_set_min(&memcg->memory, 0);
5269 : 0 : page_counter_set_low(&memcg->memory, 0);
5270 : :
5271 : 0 : memcg_offline_kmem(memcg);
5272 : 0 : wb_memcg_offline(memcg);
5273 : :
5274 : 0 : drain_all_stock(memcg);
5275 : :
5276 : : mem_cgroup_id_put(memcg);
5277 : 0 : }
5278 : :
5279 : 0 : static void mem_cgroup_css_released(struct cgroup_subsys_state *css)
5280 : : {
5281 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5282 : :
5283 : 0 : invalidate_reclaim_iterators(memcg);
5284 : 0 : }
5285 : :
5286 : 0 : static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
5287 : : {
5288 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5289 : : int __maybe_unused i;
5290 : :
5291 : : #ifdef CONFIG_CGROUP_WRITEBACK
5292 : 0 : for (i = 0; i < MEMCG_CGWB_FRN_CNT; i++)
5293 : 0 : wb_wait_for_completion(&memcg->cgwb_frn[i].done);
5294 : : #endif
5295 : 0 : if (cgroup_subsys_on_dfl(memory_cgrp_subsys) && !cgroup_memory_nosocket)
5296 : 0 : static_branch_dec(&memcg_sockets_enabled_key);
5297 : :
5298 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && memcg->tcpmem_active)
5299 : 0 : static_branch_dec(&memcg_sockets_enabled_key);
5300 : :
5301 : 0 : vmpressure_cleanup(&memcg->vmpressure);
5302 : 0 : cancel_work_sync(&memcg->high_work);
5303 : 0 : mem_cgroup_remove_from_trees(memcg);
5304 : 0 : memcg_free_shrinker_maps(memcg);
5305 : 0 : memcg_free_kmem(memcg);
5306 : 0 : mem_cgroup_free(memcg);
5307 : 0 : }
5308 : :
5309 : : /**
5310 : : * mem_cgroup_css_reset - reset the states of a mem_cgroup
5311 : : * @css: the target css
5312 : : *
5313 : : * Reset the states of the mem_cgroup associated with @css. This is
5314 : : * invoked when the userland requests disabling on the default hierarchy
5315 : : * but the memcg is pinned through dependency. The memcg should stop
5316 : : * applying policies and should revert to the vanilla state as it may be
5317 : : * made visible again.
5318 : : *
5319 : : * The current implementation only resets the essential configurations.
5320 : : * This needs to be expanded to cover all the visible parts.
5321 : : */
5322 : 3 : static void mem_cgroup_css_reset(struct cgroup_subsys_state *css)
5323 : : {
5324 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
5325 : :
5326 : 3 : page_counter_set_max(&memcg->memory, PAGE_COUNTER_MAX);
5327 : 3 : page_counter_set_max(&memcg->swap, PAGE_COUNTER_MAX);
5328 : 3 : page_counter_set_max(&memcg->memsw, PAGE_COUNTER_MAX);
5329 : 3 : page_counter_set_max(&memcg->kmem, PAGE_COUNTER_MAX);
5330 : 3 : page_counter_set_max(&memcg->tcpmem, PAGE_COUNTER_MAX);
5331 : 3 : page_counter_set_min(&memcg->memory, 0);
5332 : 3 : page_counter_set_low(&memcg->memory, 0);
5333 : 3 : memcg->high = PAGE_COUNTER_MAX;
5334 : 3 : memcg->soft_limit = PAGE_COUNTER_MAX;
5335 : : memcg_wb_domain_size_changed(memcg);
5336 : 3 : }
5337 : :
5338 : : #ifdef CONFIG_MMU
5339 : : /* Handlers for move charge at task migration. */
5340 : 0 : static int mem_cgroup_do_precharge(unsigned long count)
5341 : : {
5342 : : int ret;
5343 : :
5344 : : /* Try a single bulk charge without reclaim first, kswapd may wake */
5345 : 0 : ret = try_charge(mc.to, GFP_KERNEL & ~__GFP_DIRECT_RECLAIM, count);
5346 : 0 : if (!ret) {
5347 : 0 : mc.precharge += count;
5348 : 0 : return ret;
5349 : : }
5350 : :
5351 : : /* Try charges one by one with reclaim, but do not retry */
5352 : 0 : while (count--) {
5353 : 0 : ret = try_charge(mc.to, GFP_KERNEL | __GFP_NORETRY, 1);
5354 : 0 : if (ret)
5355 : 0 : return ret;
5356 : 0 : mc.precharge++;
5357 : 0 : cond_resched();
5358 : : }
5359 : : return 0;
5360 : : }
5361 : :
5362 : : union mc_target {
5363 : : struct page *page;
5364 : : swp_entry_t ent;
5365 : : };
5366 : :
5367 : : enum mc_target_type {
5368 : : MC_TARGET_NONE = 0,
5369 : : MC_TARGET_PAGE,
5370 : : MC_TARGET_SWAP,
5371 : : MC_TARGET_DEVICE,
5372 : : };
5373 : :
5374 : 0 : static struct page *mc_handle_present_pte(struct vm_area_struct *vma,
5375 : : unsigned long addr, pte_t ptent)
5376 : : {
5377 : 0 : struct page *page = vm_normal_page(vma, addr, ptent);
5378 : :
5379 : 0 : if (!page || !page_mapped(page))
5380 : : return NULL;
5381 : 0 : if (PageAnon(page)) {
5382 : 0 : if (!(mc.flags & MOVE_ANON))
5383 : : return NULL;
5384 : : } else {
5385 : 0 : if (!(mc.flags & MOVE_FILE))
5386 : : return NULL;
5387 : : }
5388 : 0 : if (!get_page_unless_zero(page))
5389 : : return NULL;
5390 : :
5391 : 0 : return page;
5392 : : }
5393 : :
5394 : : #if defined(CONFIG_SWAP) || defined(CONFIG_DEVICE_PRIVATE)
5395 : 0 : static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
5396 : : pte_t ptent, swp_entry_t *entry)
5397 : : {
5398 : : struct page *page = NULL;
5399 : : swp_entry_t ent = pte_to_swp_entry(ptent);
5400 : :
5401 : 0 : if (!(mc.flags & MOVE_ANON) || non_swap_entry(ent))
5402 : : return NULL;
5403 : :
5404 : : /*
5405 : : * Handle MEMORY_DEVICE_PRIVATE which are ZONE_DEVICE page belonging to
5406 : : * a device and because they are not accessible by CPU they are store
5407 : : * as special swap entry in the CPU page table.
5408 : : */
5409 : : if (is_device_private_entry(ent)) {
5410 : : page = device_private_entry_to_page(ent);
5411 : : /*
5412 : : * MEMORY_DEVICE_PRIVATE means ZONE_DEVICE page and which have
5413 : : * a refcount of 1 when free (unlike normal page)
5414 : : */
5415 : : if (!page_ref_add_unless(page, 1, 1))
5416 : : return NULL;
5417 : : return page;
5418 : : }
5419 : :
5420 : : /*
5421 : : * Because lookup_swap_cache() updates some statistics counter,
5422 : : * we call find_get_page() with swapper_space directly.
5423 : : */
5424 : 0 : page = find_get_page(swap_address_space(ent), swp_offset(ent));
5425 : : if (do_memsw_account())
5426 : : entry->val = ent.val;
5427 : :
5428 : : return page;
5429 : : }
5430 : : #else
5431 : : static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
5432 : : pte_t ptent, swp_entry_t *entry)
5433 : : {
5434 : : return NULL;
5435 : : }
5436 : : #endif
5437 : :
5438 : 0 : static struct page *mc_handle_file_pte(struct vm_area_struct *vma,
5439 : : unsigned long addr, pte_t ptent, swp_entry_t *entry)
5440 : : {
5441 : : struct page *page = NULL;
5442 : : struct address_space *mapping;
5443 : : pgoff_t pgoff;
5444 : :
5445 : 0 : if (!vma->vm_file) /* anonymous vma */
5446 : : return NULL;
5447 : 0 : if (!(mc.flags & MOVE_FILE))
5448 : : return NULL;
5449 : :
5450 : 0 : mapping = vma->vm_file->f_mapping;
5451 : : pgoff = linear_page_index(vma, addr);
5452 : :
5453 : : /* page is moved even if it's not RSS of this task(page-faulted). */
5454 : : #ifdef CONFIG_SWAP
5455 : : /* shmem/tmpfs may report page out on swap: account for that too. */
5456 : 0 : if (shmem_mapping(mapping)) {
5457 : 0 : page = find_get_entry(mapping, pgoff);
5458 : 0 : if (xa_is_value(page)) {
5459 : : swp_entry_t swp = radix_to_swp_entry(page);
5460 : : if (do_memsw_account())
5461 : : *entry = swp;
5462 : 0 : page = find_get_page(swap_address_space(swp),
5463 : : swp_offset(swp));
5464 : : }
5465 : : } else
5466 : : page = find_get_page(mapping, pgoff);
5467 : : #else
5468 : : page = find_get_page(mapping, pgoff);
5469 : : #endif
5470 : 0 : return page;
5471 : : }
5472 : :
5473 : : /**
5474 : : * mem_cgroup_move_account - move account of the page
5475 : : * @page: the page
5476 : : * @compound: charge the page as compound or small page
5477 : : * @from: mem_cgroup which the page is moved from.
5478 : : * @to: mem_cgroup which the page is moved to. @from != @to.
5479 : : *
5480 : : * The caller must make sure the page is not on LRU (isolate_page() is useful.)
5481 : : *
5482 : : * This function doesn't do "charge" to new cgroup and doesn't do "uncharge"
5483 : : * from old cgroup.
5484 : : */
5485 : 0 : static int mem_cgroup_move_account(struct page *page,
5486 : : bool compound,
5487 : : struct mem_cgroup *from,
5488 : : struct mem_cgroup *to)
5489 : : {
5490 : : struct lruvec *from_vec, *to_vec;
5491 : : struct pglist_data *pgdat;
5492 : : unsigned long flags;
5493 : : unsigned int nr_pages = compound ? hpage_nr_pages(page) : 1;
5494 : : int ret;
5495 : : bool anon;
5496 : :
5497 : : VM_BUG_ON(from == to);
5498 : : VM_BUG_ON_PAGE(PageLRU(page), page);
5499 : : VM_BUG_ON(compound && !PageTransHuge(page));
5500 : :
5501 : : /*
5502 : : * Prevent mem_cgroup_migrate() from looking at
5503 : : * page->mem_cgroup of its source page while we change it.
5504 : : */
5505 : : ret = -EBUSY;
5506 : 0 : if (!trylock_page(page))
5507 : : goto out;
5508 : :
5509 : : ret = -EINVAL;
5510 : 0 : if (page->mem_cgroup != from)
5511 : : goto out_unlock;
5512 : :
5513 : : anon = PageAnon(page);
5514 : :
5515 : : pgdat = page_pgdat(page);
5516 : : from_vec = mem_cgroup_lruvec(pgdat, from);
5517 : : to_vec = mem_cgroup_lruvec(pgdat, to);
5518 : :
5519 : 0 : spin_lock_irqsave(&from->move_lock, flags);
5520 : :
5521 : 0 : if (!anon && page_mapped(page)) {
5522 : 0 : __mod_lruvec_state(from_vec, NR_FILE_MAPPED, -nr_pages);
5523 : 0 : __mod_lruvec_state(to_vec, NR_FILE_MAPPED, nr_pages);
5524 : : }
5525 : :
5526 : : /*
5527 : : * move_lock grabbed above and caller set from->moving_account, so
5528 : : * mod_memcg_page_state will serialize updates to PageDirty.
5529 : : * So mapping should be stable for dirty pages.
5530 : : */
5531 : 0 : if (!anon && PageDirty(page)) {
5532 : 0 : struct address_space *mapping = page_mapping(page);
5533 : :
5534 : 0 : if (mapping_cap_account_dirty(mapping)) {
5535 : 0 : __mod_lruvec_state(from_vec, NR_FILE_DIRTY, -nr_pages);
5536 : 0 : __mod_lruvec_state(to_vec, NR_FILE_DIRTY, nr_pages);
5537 : : }
5538 : : }
5539 : :
5540 : 0 : if (PageWriteback(page)) {
5541 : 0 : __mod_lruvec_state(from_vec, NR_WRITEBACK, -nr_pages);
5542 : 0 : __mod_lruvec_state(to_vec, NR_WRITEBACK, nr_pages);
5543 : : }
5544 : :
5545 : : /*
5546 : : * It is safe to change page->mem_cgroup here because the page
5547 : : * is referenced, charged, and isolated - we can't race with
5548 : : * uncharging, charging, migration, or LRU putback.
5549 : : */
5550 : :
5551 : : /* caller should have done css_get */
5552 : 0 : page->mem_cgroup = to;
5553 : :
5554 : : spin_unlock_irqrestore(&from->move_lock, flags);
5555 : :
5556 : : ret = 0;
5557 : :
5558 : 0 : local_irq_disable();
5559 : 0 : mem_cgroup_charge_statistics(to, page, compound, nr_pages);
5560 : 0 : memcg_check_events(to, page);
5561 : 0 : mem_cgroup_charge_statistics(from, page, compound, -nr_pages);
5562 : 0 : memcg_check_events(from, page);
5563 : 0 : local_irq_enable();
5564 : : out_unlock:
5565 : 0 : unlock_page(page);
5566 : : out:
5567 : 0 : return ret;
5568 : : }
5569 : :
5570 : : /**
5571 : : * get_mctgt_type - get target type of moving charge
5572 : : * @vma: the vma the pte to be checked belongs
5573 : : * @addr: the address corresponding to the pte to be checked
5574 : : * @ptent: the pte to be checked
5575 : : * @target: the pointer the target page or swap ent will be stored(can be NULL)
5576 : : *
5577 : : * Returns
5578 : : * 0(MC_TARGET_NONE): if the pte is not a target for move charge.
5579 : : * 1(MC_TARGET_PAGE): if the page corresponding to this pte is a target for
5580 : : * move charge. if @target is not NULL, the page is stored in target->page
5581 : : * with extra refcnt got(Callers should handle it).
5582 : : * 2(MC_TARGET_SWAP): if the swap entry corresponding to this pte is a
5583 : : * target for charge migration. if @target is not NULL, the entry is stored
5584 : : * in target->ent.
5585 : : * 3(MC_TARGET_DEVICE): like MC_TARGET_PAGE but page is MEMORY_DEVICE_PRIVATE
5586 : : * (so ZONE_DEVICE page and thus not on the lru).
5587 : : * For now we such page is charge like a regular page would be as for all
5588 : : * intent and purposes it is just special memory taking the place of a
5589 : : * regular page.
5590 : : *
5591 : : * See Documentations/vm/hmm.txt and include/linux/hmm.h
5592 : : *
5593 : : * Called with pte lock held.
5594 : : */
5595 : :
5596 : 0 : static enum mc_target_type get_mctgt_type(struct vm_area_struct *vma,
5597 : : unsigned long addr, pte_t ptent, union mc_target *target)
5598 : : {
5599 : : struct page *page = NULL;
5600 : : enum mc_target_type ret = MC_TARGET_NONE;
5601 : 0 : swp_entry_t ent = { .val = 0 };
5602 : :
5603 : 0 : if (pte_present(ptent))
5604 : 0 : page = mc_handle_present_pte(vma, addr, ptent);
5605 : 0 : else if (is_swap_pte(ptent))
5606 : 0 : page = mc_handle_swap_pte(vma, ptent, &ent);
5607 : 0 : else if (pte_none(ptent))
5608 : 0 : page = mc_handle_file_pte(vma, addr, ptent, &ent);
5609 : :
5610 : 0 : if (!page && !ent.val)
5611 : : return ret;
5612 : 0 : if (page) {
5613 : : /*
5614 : : * Do only loose check w/o serialization.
5615 : : * mem_cgroup_move_account() checks the page is valid or
5616 : : * not under LRU exclusion.
5617 : : */
5618 : 0 : if (page->mem_cgroup == mc.from) {
5619 : : ret = MC_TARGET_PAGE;
5620 : : if (is_device_private_page(page))
5621 : : ret = MC_TARGET_DEVICE;
5622 : 0 : if (target)
5623 : 0 : target->page = page;
5624 : : }
5625 : 0 : if (!ret || !target)
5626 : 0 : put_page(page);
5627 : : }
5628 : : /*
5629 : : * There is a swap entry and a page doesn't exist or isn't charged.
5630 : : * But we cannot move a tail-page in a THP.
5631 : : */
5632 : 0 : if (ent.val && !ret && (!page || !PageTransCompound(page)) &&
5633 : 0 : mem_cgroup_id(mc.from) == lookup_swap_cgroup_id(ent)) {
5634 : : ret = MC_TARGET_SWAP;
5635 : 0 : if (target)
5636 : 0 : target->ent = ent;
5637 : : }
5638 : 0 : return ret;
5639 : : }
5640 : :
5641 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5642 : : /*
5643 : : * We don't consider PMD mapped swapping or file mapped pages because THP does
5644 : : * not support them for now.
5645 : : * Caller should make sure that pmd_trans_huge(pmd) is true.
5646 : : */
5647 : : static enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
5648 : : unsigned long addr, pmd_t pmd, union mc_target *target)
5649 : : {
5650 : : struct page *page = NULL;
5651 : : enum mc_target_type ret = MC_TARGET_NONE;
5652 : :
5653 : : if (unlikely(is_swap_pmd(pmd))) {
5654 : : VM_BUG_ON(thp_migration_supported() &&
5655 : : !is_pmd_migration_entry(pmd));
5656 : : return ret;
5657 : : }
5658 : : page = pmd_page(pmd);
5659 : : VM_BUG_ON_PAGE(!page || !PageHead(page), page);
5660 : : if (!(mc.flags & MOVE_ANON))
5661 : : return ret;
5662 : : if (page->mem_cgroup == mc.from) {
5663 : : ret = MC_TARGET_PAGE;
5664 : : if (target) {
5665 : : get_page(page);
5666 : : target->page = page;
5667 : : }
5668 : : }
5669 : : return ret;
5670 : : }
5671 : : #else
5672 : : static inline enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
5673 : : unsigned long addr, pmd_t pmd, union mc_target *target)
5674 : : {
5675 : : return MC_TARGET_NONE;
5676 : : }
5677 : : #endif
5678 : :
5679 : 0 : static int mem_cgroup_count_precharge_pte_range(pmd_t *pmd,
5680 : : unsigned long addr, unsigned long end,
5681 : : struct mm_walk *walk)
5682 : : {
5683 : 0 : struct vm_area_struct *vma = walk->vma;
5684 : : pte_t *pte;
5685 : : spinlock_t *ptl;
5686 : :
5687 : : ptl = pmd_trans_huge_lock(pmd, vma);
5688 : : if (ptl) {
5689 : : /*
5690 : : * Note their can not be MC_TARGET_DEVICE for now as we do not
5691 : : * support transparent huge page with MEMORY_DEVICE_PRIVATE but
5692 : : * this might change.
5693 : : */
5694 : : if (get_mctgt_type_thp(vma, addr, *pmd, NULL) == MC_TARGET_PAGE)
5695 : : mc.precharge += HPAGE_PMD_NR;
5696 : : spin_unlock(ptl);
5697 : : return 0;
5698 : : }
5699 : :
5700 : : if (pmd_trans_unstable(pmd))
5701 : : return 0;
5702 : 0 : pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
5703 : 0 : for (; addr != end; pte++, addr += PAGE_SIZE)
5704 : 0 : if (get_mctgt_type(vma, addr, *pte, NULL))
5705 : 0 : mc.precharge++; /* increment precharge temporarily */
5706 : : pte_unmap_unlock(pte - 1, ptl);
5707 : 0 : cond_resched();
5708 : :
5709 : : return 0;
5710 : : }
5711 : :
5712 : : static const struct mm_walk_ops precharge_walk_ops = {
5713 : : .pmd_entry = mem_cgroup_count_precharge_pte_range,
5714 : : };
5715 : :
5716 : 0 : static unsigned long mem_cgroup_count_precharge(struct mm_struct *mm)
5717 : : {
5718 : : unsigned long precharge;
5719 : :
5720 : 0 : down_read(&mm->mmap_sem);
5721 : 0 : walk_page_range(mm, 0, mm->highest_vm_end, &precharge_walk_ops, NULL);
5722 : 0 : up_read(&mm->mmap_sem);
5723 : :
5724 : 0 : precharge = mc.precharge;
5725 : 0 : mc.precharge = 0;
5726 : :
5727 : 0 : return precharge;
5728 : : }
5729 : :
5730 : 0 : static int mem_cgroup_precharge_mc(struct mm_struct *mm)
5731 : : {
5732 : 0 : unsigned long precharge = mem_cgroup_count_precharge(mm);
5733 : :
5734 : : VM_BUG_ON(mc.moving_task);
5735 : 0 : mc.moving_task = current;
5736 : 0 : return mem_cgroup_do_precharge(precharge);
5737 : : }
5738 : :
5739 : : /* cancels all extra charges on mc.from and mc.to, and wakes up all waiters. */
5740 : 0 : static void __mem_cgroup_clear_mc(void)
5741 : : {
5742 : 0 : struct mem_cgroup *from = mc.from;
5743 : 0 : struct mem_cgroup *to = mc.to;
5744 : :
5745 : : /* we must uncharge all the leftover precharges from mc.to */
5746 : 0 : if (mc.precharge) {
5747 : 0 : cancel_charge(mc.to, mc.precharge);
5748 : 0 : mc.precharge = 0;
5749 : : }
5750 : : /*
5751 : : * we didn't uncharge from mc.from at mem_cgroup_move_account(), so
5752 : : * we must uncharge here.
5753 : : */
5754 : 0 : if (mc.moved_charge) {
5755 : 0 : cancel_charge(mc.from, mc.moved_charge);
5756 : 0 : mc.moved_charge = 0;
5757 : : }
5758 : : /* we must fixup refcnts and charges */
5759 : 0 : if (mc.moved_swap) {
5760 : : /* uncharge swap account from the old cgroup */
5761 : 0 : if (!mem_cgroup_is_root(mc.from))
5762 : 0 : page_counter_uncharge(&mc.from->memsw, mc.moved_swap);
5763 : :
5764 : 0 : mem_cgroup_id_put_many(mc.from, mc.moved_swap);
5765 : :
5766 : : /*
5767 : : * we charged both to->memory and to->memsw, so we
5768 : : * should uncharge to->memory.
5769 : : */
5770 : 0 : if (!mem_cgroup_is_root(mc.to))
5771 : 0 : page_counter_uncharge(&mc.to->memory, mc.moved_swap);
5772 : :
5773 : 0 : css_put_many(&mc.to->css, mc.moved_swap);
5774 : :
5775 : 0 : mc.moved_swap = 0;
5776 : : }
5777 : 0 : memcg_oom_recover(from);
5778 : 0 : memcg_oom_recover(to);
5779 : 0 : wake_up_all(&mc.waitq);
5780 : 0 : }
5781 : :
5782 : 0 : static void mem_cgroup_clear_mc(void)
5783 : : {
5784 : 0 : struct mm_struct *mm = mc.mm;
5785 : :
5786 : : /*
5787 : : * we must clear moving_task before waking up waiters at the end of
5788 : : * task migration.
5789 : : */
5790 : 0 : mc.moving_task = NULL;
5791 : 0 : __mem_cgroup_clear_mc();
5792 : : spin_lock(&mc.lock);
5793 : 0 : mc.from = NULL;
5794 : 0 : mc.to = NULL;
5795 : 0 : mc.mm = NULL;
5796 : : spin_unlock(&mc.lock);
5797 : :
5798 : 0 : mmput(mm);
5799 : 0 : }
5800 : :
5801 : 0 : static int mem_cgroup_can_attach(struct cgroup_taskset *tset)
5802 : : {
5803 : : struct cgroup_subsys_state *css;
5804 : : struct mem_cgroup *memcg = NULL; /* unneeded init to make gcc happy */
5805 : : struct mem_cgroup *from;
5806 : : struct task_struct *leader, *p;
5807 : : struct mm_struct *mm;
5808 : : unsigned long move_flags;
5809 : : int ret = 0;
5810 : :
5811 : : /* charge immigration isn't supported on the default hierarchy */
5812 : 0 : if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
5813 : : return 0;
5814 : :
5815 : : /*
5816 : : * Multi-process migrations only happen on the default hierarchy
5817 : : * where charge immigration is not used. Perform charge
5818 : : * immigration if @tset contains a leader and whine if there are
5819 : : * multiple.
5820 : : */
5821 : : p = NULL;
5822 : 0 : cgroup_taskset_for_each_leader(leader, css, tset) {
5823 : 0 : WARN_ON_ONCE(p);
5824 : : p = leader;
5825 : 0 : memcg = mem_cgroup_from_css(css);
5826 : : }
5827 : 0 : if (!p)
5828 : : return 0;
5829 : :
5830 : : /*
5831 : : * We are now commited to this value whatever it is. Changes in this
5832 : : * tunable will only affect upcoming migrations, not the current one.
5833 : : * So we need to save it, and keep it going.
5834 : : */
5835 : : move_flags = READ_ONCE(memcg->move_charge_at_immigrate);
5836 : 0 : if (!move_flags)
5837 : : return 0;
5838 : :
5839 : : from = mem_cgroup_from_task(p);
5840 : :
5841 : : VM_BUG_ON(from == memcg);
5842 : :
5843 : 0 : mm = get_task_mm(p);
5844 : 0 : if (!mm)
5845 : : return 0;
5846 : : /* We move charges only when we move a owner of the mm */
5847 : 0 : if (mm->owner == p) {
5848 : : VM_BUG_ON(mc.from);
5849 : : VM_BUG_ON(mc.to);
5850 : : VM_BUG_ON(mc.precharge);
5851 : : VM_BUG_ON(mc.moved_charge);
5852 : : VM_BUG_ON(mc.moved_swap);
5853 : :
5854 : : spin_lock(&mc.lock);
5855 : 0 : mc.mm = mm;
5856 : 0 : mc.from = from;
5857 : 0 : mc.to = memcg;
5858 : 0 : mc.flags = move_flags;
5859 : : spin_unlock(&mc.lock);
5860 : : /* We set mc.moving_task later */
5861 : :
5862 : 0 : ret = mem_cgroup_precharge_mc(mm);
5863 : 0 : if (ret)
5864 : 0 : mem_cgroup_clear_mc();
5865 : : } else {
5866 : 0 : mmput(mm);
5867 : : }
5868 : 0 : return ret;
5869 : : }
5870 : :
5871 : 0 : static void mem_cgroup_cancel_attach(struct cgroup_taskset *tset)
5872 : : {
5873 : 0 : if (mc.to)
5874 : 0 : mem_cgroup_clear_mc();
5875 : 0 : }
5876 : :
5877 : 0 : static int mem_cgroup_move_charge_pte_range(pmd_t *pmd,
5878 : : unsigned long addr, unsigned long end,
5879 : : struct mm_walk *walk)
5880 : : {
5881 : : int ret = 0;
5882 : 0 : struct vm_area_struct *vma = walk->vma;
5883 : : pte_t *pte;
5884 : : spinlock_t *ptl;
5885 : : enum mc_target_type target_type;
5886 : : union mc_target target;
5887 : : struct page *page;
5888 : :
5889 : : ptl = pmd_trans_huge_lock(pmd, vma);
5890 : : if (ptl) {
5891 : : if (mc.precharge < HPAGE_PMD_NR) {
5892 : : spin_unlock(ptl);
5893 : : return 0;
5894 : : }
5895 : : target_type = get_mctgt_type_thp(vma, addr, *pmd, &target);
5896 : : if (target_type == MC_TARGET_PAGE) {
5897 : : page = target.page;
5898 : : if (!isolate_lru_page(page)) {
5899 : : if (!mem_cgroup_move_account(page, true,
5900 : : mc.from, mc.to)) {
5901 : : mc.precharge -= HPAGE_PMD_NR;
5902 : : mc.moved_charge += HPAGE_PMD_NR;
5903 : : }
5904 : : putback_lru_page(page);
5905 : : }
5906 : : put_page(page);
5907 : : } else if (target_type == MC_TARGET_DEVICE) {
5908 : : page = target.page;
5909 : : if (!mem_cgroup_move_account(page, true,
5910 : : mc.from, mc.to)) {
5911 : : mc.precharge -= HPAGE_PMD_NR;
5912 : : mc.moved_charge += HPAGE_PMD_NR;
5913 : : }
5914 : : put_page(page);
5915 : : }
5916 : : spin_unlock(ptl);
5917 : : return 0;
5918 : : }
5919 : :
5920 : : if (pmd_trans_unstable(pmd))
5921 : : return 0;
5922 : : retry:
5923 : 0 : pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
5924 : 0 : for (; addr != end; addr += PAGE_SIZE) {
5925 : 0 : pte_t ptent = *(pte++);
5926 : : bool device = false;
5927 : : swp_entry_t ent;
5928 : :
5929 : 0 : if (!mc.precharge)
5930 : : break;
5931 : :
5932 : 0 : switch (get_mctgt_type(vma, addr, ptent, &target)) {
5933 : : case MC_TARGET_DEVICE:
5934 : : device = true;
5935 : : /* fall through */
5936 : : case MC_TARGET_PAGE:
5937 : 0 : page = target.page;
5938 : : /*
5939 : : * We can have a part of the split pmd here. Moving it
5940 : : * can be done but it would be too convoluted so simply
5941 : : * ignore such a partial THP and keep it in original
5942 : : * memcg. There should be somebody mapping the head.
5943 : : */
5944 : : if (PageTransCompound(page))
5945 : : goto put;
5946 : 0 : if (!device && isolate_lru_page(page))
5947 : : goto put;
5948 : 0 : if (!mem_cgroup_move_account(page, false,
5949 : : mc.from, mc.to)) {
5950 : 0 : mc.precharge--;
5951 : : /* we uncharge from mc.from later. */
5952 : 0 : mc.moved_charge++;
5953 : : }
5954 : 0 : if (!device)
5955 : 0 : putback_lru_page(page);
5956 : : put: /* get_mctgt_type() gets the page */
5957 : 0 : put_page(page);
5958 : 0 : break;
5959 : : case MC_TARGET_SWAP:
5960 : : ent = target.ent;
5961 : : if (!mem_cgroup_move_swap_account(ent, mc.from, mc.to)) {
5962 : : mc.precharge--;
5963 : : mem_cgroup_id_get_many(mc.to, 1);
5964 : : /* we fixup other refcnts and charges later. */
5965 : : mc.moved_swap++;
5966 : : }
5967 : : break;
5968 : : default:
5969 : : break;
5970 : : }
5971 : : }
5972 : : pte_unmap_unlock(pte - 1, ptl);
5973 : 0 : cond_resched();
5974 : :
5975 : 0 : if (addr != end) {
5976 : : /*
5977 : : * We have consumed all precharges we got in can_attach().
5978 : : * We try charge one by one, but don't do any additional
5979 : : * charges to mc.to if we have failed in charge once in attach()
5980 : : * phase.
5981 : : */
5982 : 0 : ret = mem_cgroup_do_precharge(1);
5983 : 0 : if (!ret)
5984 : : goto retry;
5985 : : }
5986 : :
5987 : : return ret;
5988 : : }
5989 : :
5990 : : static const struct mm_walk_ops charge_walk_ops = {
5991 : : .pmd_entry = mem_cgroup_move_charge_pte_range,
5992 : : };
5993 : :
5994 : 0 : static void mem_cgroup_move_charge(void)
5995 : : {
5996 : 0 : lru_add_drain_all();
5997 : : /*
5998 : : * Signal lock_page_memcg() to take the memcg's move_lock
5999 : : * while we're moving its pages to another memcg. Then wait
6000 : : * for already started RCU-only updates to finish.
6001 : : */
6002 : 0 : atomic_inc(&mc.from->moving_account);
6003 : 0 : synchronize_rcu();
6004 : : retry:
6005 : 0 : if (unlikely(!down_read_trylock(&mc.mm->mmap_sem))) {
6006 : : /*
6007 : : * Someone who are holding the mmap_sem might be waiting in
6008 : : * waitq. So we cancel all extra charges, wake up all waiters,
6009 : : * and retry. Because we cancel precharges, we might not be able
6010 : : * to move enough charges, but moving charge is a best-effort
6011 : : * feature anyway, so it wouldn't be a big problem.
6012 : : */
6013 : 0 : __mem_cgroup_clear_mc();
6014 : 0 : cond_resched();
6015 : 0 : goto retry;
6016 : : }
6017 : : /*
6018 : : * When we have consumed all precharges and failed in doing
6019 : : * additional charge, the page walk just aborts.
6020 : : */
6021 : 0 : walk_page_range(mc.mm, 0, mc.mm->highest_vm_end, &charge_walk_ops,
6022 : : NULL);
6023 : :
6024 : 0 : up_read(&mc.mm->mmap_sem);
6025 : 0 : atomic_dec(&mc.from->moving_account);
6026 : 0 : }
6027 : :
6028 : 3 : static void mem_cgroup_move_task(void)
6029 : : {
6030 : 3 : if (mc.to) {
6031 : 0 : mem_cgroup_move_charge();
6032 : 0 : mem_cgroup_clear_mc();
6033 : : }
6034 : 3 : }
6035 : : #else /* !CONFIG_MMU */
6036 : : static int mem_cgroup_can_attach(struct cgroup_taskset *tset)
6037 : : {
6038 : : return 0;
6039 : : }
6040 : : static void mem_cgroup_cancel_attach(struct cgroup_taskset *tset)
6041 : : {
6042 : : }
6043 : : static void mem_cgroup_move_task(void)
6044 : : {
6045 : : }
6046 : : #endif
6047 : :
6048 : : /*
6049 : : * Cgroup retains root cgroups across [un]mount cycles making it necessary
6050 : : * to verify whether we're attached to the default hierarchy on each mount
6051 : : * attempt.
6052 : : */
6053 : 0 : static void mem_cgroup_bind(struct cgroup_subsys_state *root_css)
6054 : : {
6055 : : /*
6056 : : * use_hierarchy is forced on the default hierarchy. cgroup core
6057 : : * guarantees that @root doesn't have any children, so turning it
6058 : : * on for the root memcg is enough.
6059 : : */
6060 : 0 : if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
6061 : 0 : root_mem_cgroup->use_hierarchy = true;
6062 : : else
6063 : 0 : root_mem_cgroup->use_hierarchy = false;
6064 : 0 : }
6065 : :
6066 : 0 : static int seq_puts_memcg_tunable(struct seq_file *m, unsigned long value)
6067 : : {
6068 : 0 : if (value == PAGE_COUNTER_MAX)
6069 : 0 : seq_puts(m, "max\n");
6070 : : else
6071 : 0 : seq_printf(m, "%llu\n", (u64)value * PAGE_SIZE);
6072 : :
6073 : 0 : return 0;
6074 : : }
6075 : :
6076 : 0 : static u64 memory_current_read(struct cgroup_subsys_state *css,
6077 : : struct cftype *cft)
6078 : : {
6079 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
6080 : :
6081 : 0 : return (u64)page_counter_read(&memcg->memory) * PAGE_SIZE;
6082 : : }
6083 : :
6084 : 0 : static int memory_min_show(struct seq_file *m, void *v)
6085 : : {
6086 : 0 : return seq_puts_memcg_tunable(m,
6087 : : READ_ONCE(mem_cgroup_from_seq(m)->memory.min));
6088 : : }
6089 : :
6090 : 0 : static ssize_t memory_min_write(struct kernfs_open_file *of,
6091 : : char *buf, size_t nbytes, loff_t off)
6092 : : {
6093 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6094 : : unsigned long min;
6095 : : int err;
6096 : :
6097 : : buf = strstrip(buf);
6098 : 0 : err = page_counter_memparse(buf, "max", &min);
6099 : 0 : if (err)
6100 : : return err;
6101 : :
6102 : 0 : page_counter_set_min(&memcg->memory, min);
6103 : :
6104 : 0 : return nbytes;
6105 : : }
6106 : :
6107 : 0 : static int memory_low_show(struct seq_file *m, void *v)
6108 : : {
6109 : 0 : return seq_puts_memcg_tunable(m,
6110 : : READ_ONCE(mem_cgroup_from_seq(m)->memory.low));
6111 : : }
6112 : :
6113 : 0 : static ssize_t memory_low_write(struct kernfs_open_file *of,
6114 : : char *buf, size_t nbytes, loff_t off)
6115 : : {
6116 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6117 : : unsigned long low;
6118 : : int err;
6119 : :
6120 : : buf = strstrip(buf);
6121 : 0 : err = page_counter_memparse(buf, "max", &low);
6122 : 0 : if (err)
6123 : : return err;
6124 : :
6125 : 0 : page_counter_set_low(&memcg->memory, low);
6126 : :
6127 : 0 : return nbytes;
6128 : : }
6129 : :
6130 : 0 : static int memory_high_show(struct seq_file *m, void *v)
6131 : : {
6132 : 0 : return seq_puts_memcg_tunable(m, READ_ONCE(mem_cgroup_from_seq(m)->high));
6133 : : }
6134 : :
6135 : 0 : static ssize_t memory_high_write(struct kernfs_open_file *of,
6136 : : char *buf, size_t nbytes, loff_t off)
6137 : : {
6138 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6139 : : unsigned long nr_pages;
6140 : : unsigned long high;
6141 : : int err;
6142 : :
6143 : : buf = strstrip(buf);
6144 : 0 : err = page_counter_memparse(buf, "max", &high);
6145 : 0 : if (err)
6146 : : return err;
6147 : :
6148 : 0 : memcg->high = high;
6149 : :
6150 : : nr_pages = page_counter_read(&memcg->memory);
6151 : 0 : if (nr_pages > high)
6152 : 0 : try_to_free_mem_cgroup_pages(memcg, nr_pages - high,
6153 : : GFP_KERNEL, true);
6154 : :
6155 : : memcg_wb_domain_size_changed(memcg);
6156 : 0 : return nbytes;
6157 : : }
6158 : :
6159 : 0 : static int memory_max_show(struct seq_file *m, void *v)
6160 : : {
6161 : 0 : return seq_puts_memcg_tunable(m,
6162 : : READ_ONCE(mem_cgroup_from_seq(m)->memory.max));
6163 : : }
6164 : :
6165 : 0 : static ssize_t memory_max_write(struct kernfs_open_file *of,
6166 : : char *buf, size_t nbytes, loff_t off)
6167 : : {
6168 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6169 : : unsigned int nr_reclaims = MEM_CGROUP_RECLAIM_RETRIES;
6170 : : bool drained = false;
6171 : : unsigned long max;
6172 : : int err;
6173 : :
6174 : : buf = strstrip(buf);
6175 : 0 : err = page_counter_memparse(buf, "max", &max);
6176 : 0 : if (err)
6177 : : return err;
6178 : :
6179 : 0 : xchg(&memcg->memory.max, max);
6180 : :
6181 : : for (;;) {
6182 : : unsigned long nr_pages = page_counter_read(&memcg->memory);
6183 : :
6184 : 0 : if (nr_pages <= max)
6185 : : break;
6186 : :
6187 : 0 : if (signal_pending(current)) {
6188 : : err = -EINTR;
6189 : : break;
6190 : : }
6191 : :
6192 : 0 : if (!drained) {
6193 : 0 : drain_all_stock(memcg);
6194 : : drained = true;
6195 : 0 : continue;
6196 : : }
6197 : :
6198 : 0 : if (nr_reclaims) {
6199 : 0 : if (!try_to_free_mem_cgroup_pages(memcg, nr_pages - max,
6200 : : GFP_KERNEL, true))
6201 : 0 : nr_reclaims--;
6202 : 0 : continue;
6203 : : }
6204 : :
6205 : 0 : memcg_memory_event(memcg, MEMCG_OOM);
6206 : 0 : if (!mem_cgroup_out_of_memory(memcg, GFP_KERNEL, 0))
6207 : : break;
6208 : : }
6209 : :
6210 : : memcg_wb_domain_size_changed(memcg);
6211 : 0 : return nbytes;
6212 : : }
6213 : :
6214 : 0 : static void __memory_events_show(struct seq_file *m, atomic_long_t *events)
6215 : : {
6216 : 0 : seq_printf(m, "low %lu\n", atomic_long_read(&events[MEMCG_LOW]));
6217 : 0 : seq_printf(m, "high %lu\n", atomic_long_read(&events[MEMCG_HIGH]));
6218 : 0 : seq_printf(m, "max %lu\n", atomic_long_read(&events[MEMCG_MAX]));
6219 : 0 : seq_printf(m, "oom %lu\n", atomic_long_read(&events[MEMCG_OOM]));
6220 : 0 : seq_printf(m, "oom_kill %lu\n",
6221 : : atomic_long_read(&events[MEMCG_OOM_KILL]));
6222 : 0 : }
6223 : :
6224 : 0 : static int memory_events_show(struct seq_file *m, void *v)
6225 : : {
6226 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6227 : :
6228 : 0 : __memory_events_show(m, memcg->memory_events);
6229 : 0 : return 0;
6230 : : }
6231 : :
6232 : 0 : static int memory_events_local_show(struct seq_file *m, void *v)
6233 : : {
6234 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6235 : :
6236 : 0 : __memory_events_show(m, memcg->memory_events_local);
6237 : 0 : return 0;
6238 : : }
6239 : :
6240 : 0 : static int memory_stat_show(struct seq_file *m, void *v)
6241 : : {
6242 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6243 : : char *buf;
6244 : :
6245 : 0 : buf = memory_stat_format(memcg);
6246 : 0 : if (!buf)
6247 : : return -ENOMEM;
6248 : 0 : seq_puts(m, buf);
6249 : 0 : kfree(buf);
6250 : 0 : return 0;
6251 : : }
6252 : :
6253 : 0 : static int memory_oom_group_show(struct seq_file *m, void *v)
6254 : : {
6255 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
6256 : :
6257 : 0 : seq_printf(m, "%d\n", memcg->oom_group);
6258 : :
6259 : 0 : return 0;
6260 : : }
6261 : :
6262 : 0 : static ssize_t memory_oom_group_write(struct kernfs_open_file *of,
6263 : : char *buf, size_t nbytes, loff_t off)
6264 : : {
6265 : 0 : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
6266 : : int ret, oom_group;
6267 : :
6268 : : buf = strstrip(buf);
6269 : 0 : if (!buf)
6270 : : return -EINVAL;
6271 : :
6272 : 0 : ret = kstrtoint(buf, 0, &oom_group);
6273 : 0 : if (ret)
6274 : : return ret;
6275 : :
6276 : 0 : if (oom_group != 0 && oom_group != 1)
6277 : : return -EINVAL;
6278 : :
6279 : 0 : memcg->oom_group = oom_group;
6280 : :
6281 : 0 : return nbytes;
6282 : : }
6283 : :
6284 : : static struct cftype memory_files[] = {
6285 : : {
6286 : : .name = "current",
6287 : : .flags = CFTYPE_NOT_ON_ROOT,
6288 : : .read_u64 = memory_current_read,
6289 : : },
6290 : : {
6291 : : .name = "min",
6292 : : .flags = CFTYPE_NOT_ON_ROOT,
6293 : : .seq_show = memory_min_show,
6294 : : .write = memory_min_write,
6295 : : },
6296 : : {
6297 : : .name = "low",
6298 : : .flags = CFTYPE_NOT_ON_ROOT,
6299 : : .seq_show = memory_low_show,
6300 : : .write = memory_low_write,
6301 : : },
6302 : : {
6303 : : .name = "high",
6304 : : .flags = CFTYPE_NOT_ON_ROOT,
6305 : : .seq_show = memory_high_show,
6306 : : .write = memory_high_write,
6307 : : },
6308 : : {
6309 : : .name = "max",
6310 : : .flags = CFTYPE_NOT_ON_ROOT,
6311 : : .seq_show = memory_max_show,
6312 : : .write = memory_max_write,
6313 : : },
6314 : : {
6315 : : .name = "events",
6316 : : .flags = CFTYPE_NOT_ON_ROOT,
6317 : : .file_offset = offsetof(struct mem_cgroup, events_file),
6318 : : .seq_show = memory_events_show,
6319 : : },
6320 : : {
6321 : : .name = "events.local",
6322 : : .flags = CFTYPE_NOT_ON_ROOT,
6323 : : .file_offset = offsetof(struct mem_cgroup, events_local_file),
6324 : : .seq_show = memory_events_local_show,
6325 : : },
6326 : : {
6327 : : .name = "stat",
6328 : : .flags = CFTYPE_NOT_ON_ROOT,
6329 : : .seq_show = memory_stat_show,
6330 : : },
6331 : : {
6332 : : .name = "oom.group",
6333 : : .flags = CFTYPE_NOT_ON_ROOT | CFTYPE_NS_DELEGATABLE,
6334 : : .seq_show = memory_oom_group_show,
6335 : : .write = memory_oom_group_write,
6336 : : },
6337 : : { } /* terminate */
6338 : : };
6339 : :
6340 : : struct cgroup_subsys memory_cgrp_subsys = {
6341 : : .css_alloc = mem_cgroup_css_alloc,
6342 : : .css_online = mem_cgroup_css_online,
6343 : : .css_offline = mem_cgroup_css_offline,
6344 : : .css_released = mem_cgroup_css_released,
6345 : : .css_free = mem_cgroup_css_free,
6346 : : .css_reset = mem_cgroup_css_reset,
6347 : : .can_attach = mem_cgroup_can_attach,
6348 : : .cancel_attach = mem_cgroup_cancel_attach,
6349 : : .post_attach = mem_cgroup_move_task,
6350 : : .bind = mem_cgroup_bind,
6351 : : .dfl_cftypes = memory_files,
6352 : : .legacy_cftypes = mem_cgroup_legacy_files,
6353 : : .early_init = 0,
6354 : : };
6355 : :
6356 : : /**
6357 : : * mem_cgroup_protected - check if memory consumption is in the normal range
6358 : : * @root: the top ancestor of the sub-tree being checked
6359 : : * @memcg: the memory cgroup to check
6360 : : *
6361 : : * WARNING: This function is not stateless! It can only be used as part
6362 : : * of a top-down tree iteration, not for isolated queries.
6363 : : *
6364 : : * Returns one of the following:
6365 : : * MEMCG_PROT_NONE: cgroup memory is not protected
6366 : : * MEMCG_PROT_LOW: cgroup memory is protected as long there is
6367 : : * an unprotected supply of reclaimable memory from other cgroups.
6368 : : * MEMCG_PROT_MIN: cgroup memory is protected
6369 : : *
6370 : : * @root is exclusive; it is never protected when looked at directly
6371 : : *
6372 : : * To provide a proper hierarchical behavior, effective memory.min/low values
6373 : : * are used. Below is the description of how effective memory.low is calculated.
6374 : : * Effective memory.min values is calculated in the same way.
6375 : : *
6376 : : * Effective memory.low is always equal or less than the original memory.low.
6377 : : * If there is no memory.low overcommittment (which is always true for
6378 : : * top-level memory cgroups), these two values are equal.
6379 : : * Otherwise, it's a part of parent's effective memory.low,
6380 : : * calculated as a cgroup's memory.low usage divided by sum of sibling's
6381 : : * memory.low usages, where memory.low usage is the size of actually
6382 : : * protected memory.
6383 : : *
6384 : : * low_usage
6385 : : * elow = min( memory.low, parent->elow * ------------------ ),
6386 : : * siblings_low_usage
6387 : : *
6388 : : * | memory.current, if memory.current < memory.low
6389 : : * low_usage = |
6390 : : * | 0, otherwise.
6391 : : *
6392 : : *
6393 : : * Such definition of the effective memory.low provides the expected
6394 : : * hierarchical behavior: parent's memory.low value is limiting
6395 : : * children, unprotected memory is reclaimed first and cgroups,
6396 : : * which are not using their guarantee do not affect actual memory
6397 : : * distribution.
6398 : : *
6399 : : * For example, if there are memcgs A, A/B, A/C, A/D and A/E:
6400 : : *
6401 : : * A A/memory.low = 2G, A/memory.current = 6G
6402 : : * //\\
6403 : : * BC DE B/memory.low = 3G B/memory.current = 2G
6404 : : * C/memory.low = 1G C/memory.current = 2G
6405 : : * D/memory.low = 0 D/memory.current = 2G
6406 : : * E/memory.low = 10G E/memory.current = 0
6407 : : *
6408 : : * and the memory pressure is applied, the following memory distribution
6409 : : * is expected (approximately):
6410 : : *
6411 : : * A/memory.current = 2G
6412 : : *
6413 : : * B/memory.current = 1.3G
6414 : : * C/memory.current = 0.6G
6415 : : * D/memory.current = 0
6416 : : * E/memory.current = 0
6417 : : *
6418 : : * These calculations require constant tracking of the actual low usages
6419 : : * (see propagate_protected_usage()), as well as recursive calculation of
6420 : : * effective memory.low values. But as we do call mem_cgroup_protected()
6421 : : * path for each memory cgroup top-down from the reclaim,
6422 : : * it's possible to optimize this part, and save calculated elow
6423 : : * for next usage. This part is intentionally racy, but it's ok,
6424 : : * as memory.low is a best-effort mechanism.
6425 : : */
6426 : 0 : enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
6427 : : struct mem_cgroup *memcg)
6428 : : {
6429 : : struct mem_cgroup *parent;
6430 : : unsigned long emin, parent_emin;
6431 : : unsigned long elow, parent_elow;
6432 : : unsigned long usage;
6433 : :
6434 : 0 : if (mem_cgroup_disabled())
6435 : : return MEMCG_PROT_NONE;
6436 : :
6437 : 0 : if (!root)
6438 : 0 : root = root_mem_cgroup;
6439 : 0 : if (memcg == root)
6440 : : return MEMCG_PROT_NONE;
6441 : :
6442 : : usage = page_counter_read(&memcg->memory);
6443 : 0 : if (!usage)
6444 : : return MEMCG_PROT_NONE;
6445 : :
6446 : 0 : emin = memcg->memory.min;
6447 : 0 : elow = memcg->memory.low;
6448 : :
6449 : : parent = parent_mem_cgroup(memcg);
6450 : : /* No parent means a non-hierarchical mode on v1 memcg */
6451 : 0 : if (!parent)
6452 : : return MEMCG_PROT_NONE;
6453 : :
6454 : 0 : if (parent == root)
6455 : : goto exit;
6456 : :
6457 : : parent_emin = READ_ONCE(parent->memory.emin);
6458 : 0 : emin = min(emin, parent_emin);
6459 : 0 : if (emin && parent_emin) {
6460 : : unsigned long min_usage, siblings_min_usage;
6461 : :
6462 : 0 : min_usage = min(usage, memcg->memory.min);
6463 : 0 : siblings_min_usage = atomic_long_read(
6464 : : &parent->memory.children_min_usage);
6465 : :
6466 : 0 : if (min_usage && siblings_min_usage)
6467 : 0 : emin = min(emin, parent_emin * min_usage /
6468 : : siblings_min_usage);
6469 : : }
6470 : :
6471 : : parent_elow = READ_ONCE(parent->memory.elow);
6472 : 0 : elow = min(elow, parent_elow);
6473 : 0 : if (elow && parent_elow) {
6474 : : unsigned long low_usage, siblings_low_usage;
6475 : :
6476 : 0 : low_usage = min(usage, memcg->memory.low);
6477 : 0 : siblings_low_usage = atomic_long_read(
6478 : : &parent->memory.children_low_usage);
6479 : :
6480 : 0 : if (low_usage && siblings_low_usage)
6481 : 0 : elow = min(elow, parent_elow * low_usage /
6482 : : siblings_low_usage);
6483 : : }
6484 : :
6485 : : exit:
6486 : 0 : memcg->memory.emin = emin;
6487 : 0 : memcg->memory.elow = elow;
6488 : :
6489 : 0 : if (usage <= emin)
6490 : : return MEMCG_PROT_MIN;
6491 : 0 : else if (usage <= elow)
6492 : : return MEMCG_PROT_LOW;
6493 : : else
6494 : 0 : return MEMCG_PROT_NONE;
6495 : : }
6496 : :
6497 : : /**
6498 : : * mem_cgroup_try_charge - try charging a page
6499 : : * @page: page to charge
6500 : : * @mm: mm context of the victim
6501 : : * @gfp_mask: reclaim mode
6502 : : * @memcgp: charged memcg return
6503 : : * @compound: charge the page as compound or small page
6504 : : *
6505 : : * Try to charge @page to the memcg that @mm belongs to, reclaiming
6506 : : * pages according to @gfp_mask if necessary.
6507 : : *
6508 : : * Returns 0 on success, with *@memcgp pointing to the charged memcg.
6509 : : * Otherwise, an error code is returned.
6510 : : *
6511 : : * After page->mapping has been set up, the caller must finalize the
6512 : : * charge with mem_cgroup_commit_charge(). Or abort the transaction
6513 : : * with mem_cgroup_cancel_charge() in case page instantiation fails.
6514 : : */
6515 : 3 : int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
6516 : : gfp_t gfp_mask, struct mem_cgroup **memcgp,
6517 : : bool compound)
6518 : : {
6519 : : struct mem_cgroup *memcg = NULL;
6520 : : unsigned int nr_pages = compound ? hpage_nr_pages(page) : 1;
6521 : : int ret = 0;
6522 : :
6523 : 3 : if (mem_cgroup_disabled())
6524 : : goto out;
6525 : :
6526 : 0 : if (PageSwapCache(page)) {
6527 : : /*
6528 : : * Every swap fault against a single page tries to charge the
6529 : : * page, bail as early as possible. shmem_unuse() encounters
6530 : : * already charged pages, too. The USED bit is protected by
6531 : : * the page lock, which serializes swap cache removal, which
6532 : : * in turn serializes uncharging.
6533 : : */
6534 : : VM_BUG_ON_PAGE(!PageLocked(page), page);
6535 : 0 : if (compound_head(page)->mem_cgroup)
6536 : : goto out;
6537 : :
6538 : : if (do_swap_account) {
6539 : : swp_entry_t ent = { .val = page_private(page), };
6540 : : unsigned short id = lookup_swap_cgroup_id(ent);
6541 : :
6542 : : rcu_read_lock();
6543 : : memcg = mem_cgroup_from_id(id);
6544 : : if (memcg && !css_tryget_online(&memcg->css))
6545 : : memcg = NULL;
6546 : : rcu_read_unlock();
6547 : : }
6548 : : }
6549 : :
6550 : : if (!memcg)
6551 : 0 : memcg = get_mem_cgroup_from_mm(mm);
6552 : :
6553 : 0 : ret = try_charge(memcg, gfp_mask, nr_pages);
6554 : :
6555 : : css_put(&memcg->css);
6556 : : out:
6557 : 3 : *memcgp = memcg;
6558 : 3 : return ret;
6559 : : }
6560 : :
6561 : 3 : int mem_cgroup_try_charge_delay(struct page *page, struct mm_struct *mm,
6562 : : gfp_t gfp_mask, struct mem_cgroup **memcgp,
6563 : : bool compound)
6564 : : {
6565 : : struct mem_cgroup *memcg;
6566 : : int ret;
6567 : :
6568 : 3 : ret = mem_cgroup_try_charge(page, mm, gfp_mask, memcgp, compound);
6569 : 3 : memcg = *memcgp;
6570 : 3 : mem_cgroup_throttle_swaprate(memcg, page_to_nid(page), gfp_mask);
6571 : 3 : return ret;
6572 : : }
6573 : :
6574 : : /**
6575 : : * mem_cgroup_commit_charge - commit a page charge
6576 : : * @page: page to charge
6577 : : * @memcg: memcg to charge the page to
6578 : : * @lrucare: page might be on LRU already
6579 : : * @compound: charge the page as compound or small page
6580 : : *
6581 : : * Finalize a charge transaction started by mem_cgroup_try_charge(),
6582 : : * after page->mapping has been set up. This must happen atomically
6583 : : * as part of the page instantiation, i.e. under the page table lock
6584 : : * for anonymous pages, under the page lock for page and swap cache.
6585 : : *
6586 : : * In addition, the page must not be on the LRU during the commit, to
6587 : : * prevent racing with task migration. If it might be, use @lrucare.
6588 : : *
6589 : : * Use mem_cgroup_cancel_charge() to cancel the transaction instead.
6590 : : */
6591 : 3 : void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
6592 : : bool lrucare, bool compound)
6593 : : {
6594 : : unsigned int nr_pages = compound ? hpage_nr_pages(page) : 1;
6595 : :
6596 : : VM_BUG_ON_PAGE(!page->mapping, page);
6597 : : VM_BUG_ON_PAGE(PageLRU(page) && !lrucare, page);
6598 : :
6599 : 3 : if (mem_cgroup_disabled())
6600 : : return;
6601 : : /*
6602 : : * Swap faults will attempt to charge the same page multiple
6603 : : * times. But reuse_swap_page() might have removed the page
6604 : : * from swapcache already, so we can't check PageSwapCache().
6605 : : */
6606 : 0 : if (!memcg)
6607 : : return;
6608 : :
6609 : 0 : commit_charge(page, memcg, lrucare);
6610 : :
6611 : 0 : local_irq_disable();
6612 : 0 : mem_cgroup_charge_statistics(memcg, page, compound, nr_pages);
6613 : 0 : memcg_check_events(memcg, page);
6614 : 0 : local_irq_enable();
6615 : :
6616 : : if (do_memsw_account() && PageSwapCache(page)) {
6617 : : swp_entry_t entry = { .val = page_private(page) };
6618 : : /*
6619 : : * The swap entry might not get freed for a long time,
6620 : : * let's not wait for it. The page already received a
6621 : : * memory+swap charge, drop the swap entry duplicate.
6622 : : */
6623 : : mem_cgroup_uncharge_swap(entry, nr_pages);
6624 : : }
6625 : : }
6626 : :
6627 : : /**
6628 : : * mem_cgroup_cancel_charge - cancel a page charge
6629 : : * @page: page to charge
6630 : : * @memcg: memcg to charge the page to
6631 : : * @compound: charge the page as compound or small page
6632 : : *
6633 : : * Cancel a charge transaction started by mem_cgroup_try_charge().
6634 : : */
6635 : 3 : void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg,
6636 : : bool compound)
6637 : : {
6638 : : unsigned int nr_pages = compound ? hpage_nr_pages(page) : 1;
6639 : :
6640 : 3 : if (mem_cgroup_disabled())
6641 : : return;
6642 : : /*
6643 : : * Swap faults will attempt to charge the same page multiple
6644 : : * times. But reuse_swap_page() might have removed the page
6645 : : * from swapcache already, so we can't check PageSwapCache().
6646 : : */
6647 : 0 : if (!memcg)
6648 : : return;
6649 : :
6650 : 0 : cancel_charge(memcg, nr_pages);
6651 : : }
6652 : :
6653 : : struct uncharge_gather {
6654 : : struct mem_cgroup *memcg;
6655 : : unsigned long pgpgout;
6656 : : unsigned long nr_anon;
6657 : : unsigned long nr_file;
6658 : : unsigned long nr_kmem;
6659 : : unsigned long nr_huge;
6660 : : unsigned long nr_shmem;
6661 : : struct page *dummy_page;
6662 : : };
6663 : :
6664 : : static inline void uncharge_gather_clear(struct uncharge_gather *ug)
6665 : : {
6666 : 0 : memset(ug, 0, sizeof(*ug));
6667 : : }
6668 : :
6669 : 0 : static void uncharge_batch(const struct uncharge_gather *ug)
6670 : : {
6671 : 0 : unsigned long nr_pages = ug->nr_anon + ug->nr_file + ug->nr_kmem;
6672 : : unsigned long flags;
6673 : :
6674 : 0 : if (!mem_cgroup_is_root(ug->memcg)) {
6675 : 0 : page_counter_uncharge(&ug->memcg->memory, nr_pages);
6676 : : if (do_memsw_account())
6677 : : page_counter_uncharge(&ug->memcg->memsw, nr_pages);
6678 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && ug->nr_kmem)
6679 : 0 : page_counter_uncharge(&ug->memcg->kmem, ug->nr_kmem);
6680 : 0 : memcg_oom_recover(ug->memcg);
6681 : : }
6682 : :
6683 : 0 : local_irq_save(flags);
6684 : 0 : __mod_memcg_state(ug->memcg, MEMCG_RSS, -ug->nr_anon);
6685 : 0 : __mod_memcg_state(ug->memcg, MEMCG_CACHE, -ug->nr_file);
6686 : 0 : __mod_memcg_state(ug->memcg, MEMCG_RSS_HUGE, -ug->nr_huge);
6687 : 0 : __mod_memcg_state(ug->memcg, NR_SHMEM, -ug->nr_shmem);
6688 : 0 : __count_memcg_events(ug->memcg, PGPGOUT, ug->pgpgout);
6689 : 0 : __this_cpu_add(ug->memcg->vmstats_percpu->nr_page_events, nr_pages);
6690 : 0 : memcg_check_events(ug->memcg, ug->dummy_page);
6691 : 0 : local_irq_restore(flags);
6692 : :
6693 : 0 : if (!mem_cgroup_is_root(ug->memcg))
6694 : : css_put_many(&ug->memcg->css, nr_pages);
6695 : 0 : }
6696 : :
6697 : 0 : static void uncharge_page(struct page *page, struct uncharge_gather *ug)
6698 : : {
6699 : : VM_BUG_ON_PAGE(PageLRU(page), page);
6700 : : VM_BUG_ON_PAGE(page_count(page) && !is_zone_device_page(page) &&
6701 : : !PageHWPoison(page) , page);
6702 : :
6703 : 0 : if (!page->mem_cgroup)
6704 : 0 : return;
6705 : :
6706 : : /*
6707 : : * Nobody should be changing or seriously looking at
6708 : : * page->mem_cgroup at this point, we have fully
6709 : : * exclusive access to the page.
6710 : : */
6711 : :
6712 : 0 : if (ug->memcg != page->mem_cgroup) {
6713 : 0 : if (ug->memcg) {
6714 : 0 : uncharge_batch(ug);
6715 : : uncharge_gather_clear(ug);
6716 : : }
6717 : 0 : ug->memcg = page->mem_cgroup;
6718 : : }
6719 : :
6720 : 0 : if (!PageKmemcg(page)) {
6721 : : unsigned int nr_pages = 1;
6722 : :
6723 : : if (PageTransHuge(page)) {
6724 : : nr_pages = compound_nr(page);
6725 : : ug->nr_huge += nr_pages;
6726 : : }
6727 : 0 : if (PageAnon(page))
6728 : 0 : ug->nr_anon += nr_pages;
6729 : : else {
6730 : 0 : ug->nr_file += nr_pages;
6731 : 0 : if (PageSwapBacked(page))
6732 : 0 : ug->nr_shmem += nr_pages;
6733 : : }
6734 : 0 : ug->pgpgout++;
6735 : : } else {
6736 : 0 : ug->nr_kmem += compound_nr(page);
6737 : : __ClearPageKmemcg(page);
6738 : : }
6739 : :
6740 : 0 : ug->dummy_page = page;
6741 : 0 : page->mem_cgroup = NULL;
6742 : : }
6743 : :
6744 : 0 : static void uncharge_list(struct list_head *page_list)
6745 : : {
6746 : : struct uncharge_gather ug;
6747 : : struct list_head *next;
6748 : :
6749 : : uncharge_gather_clear(&ug);
6750 : :
6751 : : /*
6752 : : * Note that the list can be a single page->lru; hence the
6753 : : * do-while loop instead of a simple list_for_each_entry().
6754 : : */
6755 : 0 : next = page_list->next;
6756 : : do {
6757 : : struct page *page;
6758 : :
6759 : 0 : page = list_entry(next, struct page, lru);
6760 : 0 : next = page->lru.next;
6761 : :
6762 : 0 : uncharge_page(page, &ug);
6763 : 0 : } while (next != page_list);
6764 : :
6765 : 0 : if (ug.memcg)
6766 : 0 : uncharge_batch(&ug);
6767 : 0 : }
6768 : :
6769 : : /**
6770 : : * mem_cgroup_uncharge - uncharge a page
6771 : : * @page: page to uncharge
6772 : : *
6773 : : * Uncharge a page previously charged with mem_cgroup_try_charge() and
6774 : : * mem_cgroup_commit_charge().
6775 : : */
6776 : 3 : void mem_cgroup_uncharge(struct page *page)
6777 : : {
6778 : : struct uncharge_gather ug;
6779 : :
6780 : 3 : if (mem_cgroup_disabled())
6781 : 3 : return;
6782 : :
6783 : : /* Don't touch page->lru of any random page, pre-check: */
6784 : 0 : if (!page->mem_cgroup)
6785 : : return;
6786 : :
6787 : : uncharge_gather_clear(&ug);
6788 : 0 : uncharge_page(page, &ug);
6789 : 0 : uncharge_batch(&ug);
6790 : : }
6791 : :
6792 : : /**
6793 : : * mem_cgroup_uncharge_list - uncharge a list of page
6794 : : * @page_list: list of pages to uncharge
6795 : : *
6796 : : * Uncharge a list of pages previously charged with
6797 : : * mem_cgroup_try_charge() and mem_cgroup_commit_charge().
6798 : : */
6799 : 3 : void mem_cgroup_uncharge_list(struct list_head *page_list)
6800 : : {
6801 : 3 : if (mem_cgroup_disabled())
6802 : 3 : return;
6803 : :
6804 : 0 : if (!list_empty(page_list))
6805 : 0 : uncharge_list(page_list);
6806 : : }
6807 : :
6808 : : /**
6809 : : * mem_cgroup_migrate - charge a page's replacement
6810 : : * @oldpage: currently circulating page
6811 : : * @newpage: replacement page
6812 : : *
6813 : : * Charge @newpage as a replacement page for @oldpage. @oldpage will
6814 : : * be uncharged upon free.
6815 : : *
6816 : : * Both pages must be locked, @newpage->mapping must be set up.
6817 : : */
6818 : 0 : void mem_cgroup_migrate(struct page *oldpage, struct page *newpage)
6819 : : {
6820 : : struct mem_cgroup *memcg;
6821 : : unsigned int nr_pages;
6822 : : bool compound;
6823 : : unsigned long flags;
6824 : :
6825 : : VM_BUG_ON_PAGE(!PageLocked(oldpage), oldpage);
6826 : : VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
6827 : : VM_BUG_ON_PAGE(PageAnon(oldpage) != PageAnon(newpage), newpage);
6828 : : VM_BUG_ON_PAGE(PageTransHuge(oldpage) != PageTransHuge(newpage),
6829 : : newpage);
6830 : :
6831 : 0 : if (mem_cgroup_disabled())
6832 : : return;
6833 : :
6834 : : /* Page cache replacement: new page already charged? */
6835 : 0 : if (newpage->mem_cgroup)
6836 : : return;
6837 : :
6838 : : /* Swapcache readahead pages can get replaced before being charged */
6839 : 0 : memcg = oldpage->mem_cgroup;
6840 : 0 : if (!memcg)
6841 : : return;
6842 : :
6843 : : /* Force-charge the new page. The old one will be freed soon */
6844 : : compound = PageTransHuge(newpage);
6845 : : nr_pages = compound ? hpage_nr_pages(newpage) : 1;
6846 : :
6847 : 0 : page_counter_charge(&memcg->memory, nr_pages);
6848 : : if (do_memsw_account())
6849 : : page_counter_charge(&memcg->memsw, nr_pages);
6850 : : css_get_many(&memcg->css, nr_pages);
6851 : :
6852 : 0 : commit_charge(newpage, memcg, false);
6853 : :
6854 : 0 : local_irq_save(flags);
6855 : 0 : mem_cgroup_charge_statistics(memcg, newpage, compound, nr_pages);
6856 : 0 : memcg_check_events(memcg, newpage);
6857 : 0 : local_irq_restore(flags);
6858 : : }
6859 : :
6860 : : DEFINE_STATIC_KEY_FALSE(memcg_sockets_enabled_key);
6861 : : EXPORT_SYMBOL(memcg_sockets_enabled_key);
6862 : :
6863 : 3 : void mem_cgroup_sk_alloc(struct sock *sk)
6864 : : {
6865 : : struct mem_cgroup *memcg;
6866 : :
6867 : 3 : if (!mem_cgroup_sockets_enabled)
6868 : : return;
6869 : :
6870 : : /* Do not associate the sock with unrelated interrupted task's memcg. */
6871 : 0 : if (in_interrupt())
6872 : : return;
6873 : :
6874 : : rcu_read_lock();
6875 : 0 : memcg = mem_cgroup_from_task(current);
6876 : 0 : if (memcg == root_mem_cgroup)
6877 : : goto out;
6878 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && !memcg->tcpmem_active)
6879 : : goto out;
6880 : 0 : if (css_tryget_online(&memcg->css))
6881 : 0 : sk->sk_memcg = memcg;
6882 : : out:
6883 : : rcu_read_unlock();
6884 : : }
6885 : :
6886 : 3 : void mem_cgroup_sk_free(struct sock *sk)
6887 : : {
6888 : 3 : if (sk->sk_memcg)
6889 : : css_put(&sk->sk_memcg->css);
6890 : 3 : }
6891 : :
6892 : : /**
6893 : : * mem_cgroup_charge_skmem - charge socket memory
6894 : : * @memcg: memcg to charge
6895 : : * @nr_pages: number of pages to charge
6896 : : *
6897 : : * Charges @nr_pages to @memcg. Returns %true if the charge fit within
6898 : : * @memcg's configured limit, %false if the charge had to be forced.
6899 : : */
6900 : 0 : bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages)
6901 : : {
6902 : : gfp_t gfp_mask = GFP_KERNEL;
6903 : :
6904 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys)) {
6905 : : struct page_counter *fail;
6906 : :
6907 : 0 : if (page_counter_try_charge(&memcg->tcpmem, nr_pages, &fail)) {
6908 : 0 : memcg->tcpmem_pressure = 0;
6909 : 0 : return true;
6910 : : }
6911 : 0 : page_counter_charge(&memcg->tcpmem, nr_pages);
6912 : 0 : memcg->tcpmem_pressure = 1;
6913 : 0 : return false;
6914 : : }
6915 : :
6916 : : /* Don't block in the packet receive path */
6917 : 0 : if (in_softirq())
6918 : : gfp_mask = GFP_NOWAIT;
6919 : :
6920 : 0 : mod_memcg_state(memcg, MEMCG_SOCK, nr_pages);
6921 : :
6922 : 0 : if (try_charge(memcg, gfp_mask, nr_pages) == 0)
6923 : : return true;
6924 : :
6925 : 0 : try_charge(memcg, gfp_mask|__GFP_NOFAIL, nr_pages);
6926 : 0 : return false;
6927 : : }
6928 : :
6929 : : /**
6930 : : * mem_cgroup_uncharge_skmem - uncharge socket memory
6931 : : * @memcg: memcg to uncharge
6932 : : * @nr_pages: number of pages to uncharge
6933 : : */
6934 : 0 : void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages)
6935 : : {
6936 : 0 : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys)) {
6937 : 0 : page_counter_uncharge(&memcg->tcpmem, nr_pages);
6938 : 0 : return;
6939 : : }
6940 : :
6941 : 0 : mod_memcg_state(memcg, MEMCG_SOCK, -nr_pages);
6942 : :
6943 : 0 : refill_stock(memcg, nr_pages);
6944 : : }
6945 : :
6946 : 0 : static int __init cgroup_memory(char *s)
6947 : : {
6948 : : char *token;
6949 : :
6950 : 0 : while ((token = strsep(&s, ",")) != NULL) {
6951 : 0 : if (!*token)
6952 : 0 : continue;
6953 : 0 : if (!strcmp(token, "nosocket"))
6954 : 0 : cgroup_memory_nosocket = true;
6955 : 0 : if (!strcmp(token, "nokmem"))
6956 : 0 : cgroup_memory_nokmem = true;
6957 : : }
6958 : 0 : return 0;
6959 : : }
6960 : : __setup("cgroup.memory=", cgroup_memory);
6961 : :
6962 : : /*
6963 : : * subsys_initcall() for memory controller.
6964 : : *
6965 : : * Some parts like memcg_hotplug_cpu_dead() have to be initialized from this
6966 : : * context because of lock dependencies (cgroup_lock -> cpu hotplug) but
6967 : : * basically everything that doesn't depend on a specific mem_cgroup structure
6968 : : * should be initialized from here.
6969 : : */
6970 : 3 : static int __init mem_cgroup_init(void)
6971 : : {
6972 : : int cpu, node;
6973 : :
6974 : : #ifdef CONFIG_MEMCG_KMEM
6975 : : /*
6976 : : * Kmem cache creation is mostly done with the slab_mutex held,
6977 : : * so use a workqueue with limited concurrency to avoid stalling
6978 : : * all worker threads in case lots of cgroups are created and
6979 : : * destroyed simultaneously.
6980 : : */
6981 : 3 : memcg_kmem_cache_wq = alloc_workqueue("memcg_kmem_cache", 0, 1);
6982 : 3 : BUG_ON(!memcg_kmem_cache_wq);
6983 : : #endif
6984 : :
6985 : : cpuhp_setup_state_nocalls(CPUHP_MM_MEMCQ_DEAD, "mm/memctrl:dead", NULL,
6986 : : memcg_hotplug_cpu_dead);
6987 : :
6988 : 3 : for_each_possible_cpu(cpu)
6989 : 3 : INIT_WORK(&per_cpu_ptr(&memcg_stock, cpu)->work,
6990 : : drain_local_stock);
6991 : :
6992 : 3 : for_each_node(node) {
6993 : : struct mem_cgroup_tree_per_node *rtpn;
6994 : :
6995 : 3 : rtpn = kzalloc_node(sizeof(*rtpn), GFP_KERNEL,
6996 : : node_online(node) ? node : NUMA_NO_NODE);
6997 : :
6998 : 3 : rtpn->rb_root = RB_ROOT;
6999 : 3 : rtpn->rb_rightmost = NULL;
7000 : 3 : spin_lock_init(&rtpn->lock);
7001 : 3 : soft_limit_tree.rb_tree_per_node[node] = rtpn;
7002 : : }
7003 : :
7004 : 3 : return 0;
7005 : : }
7006 : : subsys_initcall(mem_cgroup_init);
7007 : :
7008 : : #ifdef CONFIG_MEMCG_SWAP
7009 : : static struct mem_cgroup *mem_cgroup_id_get_online(struct mem_cgroup *memcg)
7010 : : {
7011 : : while (!refcount_inc_not_zero(&memcg->id.ref)) {
7012 : : /*
7013 : : * The root cgroup cannot be destroyed, so it's refcount must
7014 : : * always be >= 1.
7015 : : */
7016 : : if (WARN_ON_ONCE(memcg == root_mem_cgroup)) {
7017 : : VM_BUG_ON(1);
7018 : : break;
7019 : : }
7020 : : memcg = parent_mem_cgroup(memcg);
7021 : : if (!memcg)
7022 : : memcg = root_mem_cgroup;
7023 : : }
7024 : : return memcg;
7025 : : }
7026 : :
7027 : : /**
7028 : : * mem_cgroup_swapout - transfer a memsw charge to swap
7029 : : * @page: page whose memsw charge to transfer
7030 : : * @entry: swap entry to move the charge to
7031 : : *
7032 : : * Transfer the memsw charge of @page to @entry.
7033 : : */
7034 : : void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
7035 : : {
7036 : : struct mem_cgroup *memcg, *swap_memcg;
7037 : : unsigned int nr_entries;
7038 : : unsigned short oldid;
7039 : :
7040 : : VM_BUG_ON_PAGE(PageLRU(page), page);
7041 : : VM_BUG_ON_PAGE(page_count(page), page);
7042 : :
7043 : : if (!do_memsw_account())
7044 : : return;
7045 : :
7046 : : memcg = page->mem_cgroup;
7047 : :
7048 : : /* Readahead page, never charged */
7049 : : if (!memcg)
7050 : : return;
7051 : :
7052 : : /*
7053 : : * In case the memcg owning these pages has been offlined and doesn't
7054 : : * have an ID allocated to it anymore, charge the closest online
7055 : : * ancestor for the swap instead and transfer the memory+swap charge.
7056 : : */
7057 : : swap_memcg = mem_cgroup_id_get_online(memcg);
7058 : : nr_entries = hpage_nr_pages(page);
7059 : : /* Get references for the tail pages, too */
7060 : : if (nr_entries > 1)
7061 : : mem_cgroup_id_get_many(swap_memcg, nr_entries - 1);
7062 : : oldid = swap_cgroup_record(entry, mem_cgroup_id(swap_memcg),
7063 : : nr_entries);
7064 : : VM_BUG_ON_PAGE(oldid, page);
7065 : : mod_memcg_state(swap_memcg, MEMCG_SWAP, nr_entries);
7066 : :
7067 : : page->mem_cgroup = NULL;
7068 : :
7069 : : if (!mem_cgroup_is_root(memcg))
7070 : : page_counter_uncharge(&memcg->memory, nr_entries);
7071 : :
7072 : : if (memcg != swap_memcg) {
7073 : : if (!mem_cgroup_is_root(swap_memcg))
7074 : : page_counter_charge(&swap_memcg->memsw, nr_entries);
7075 : : page_counter_uncharge(&memcg->memsw, nr_entries);
7076 : : }
7077 : :
7078 : : /*
7079 : : * Interrupts should be disabled here because the caller holds the
7080 : : * i_pages lock which is taken with interrupts-off. It is
7081 : : * important here to have the interrupts disabled because it is the
7082 : : * only synchronisation we have for updating the per-CPU variables.
7083 : : */
7084 : : VM_BUG_ON(!irqs_disabled());
7085 : : mem_cgroup_charge_statistics(memcg, page, PageTransHuge(page),
7086 : : -nr_entries);
7087 : : memcg_check_events(memcg, page);
7088 : :
7089 : : if (!mem_cgroup_is_root(memcg))
7090 : : css_put_many(&memcg->css, nr_entries);
7091 : : }
7092 : :
7093 : : /**
7094 : : * mem_cgroup_try_charge_swap - try charging swap space for a page
7095 : : * @page: page being added to swap
7096 : : * @entry: swap entry to charge
7097 : : *
7098 : : * Try to charge @page's memcg for the swap space at @entry.
7099 : : *
7100 : : * Returns 0 on success, -ENOMEM on failure.
7101 : : */
7102 : : int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry)
7103 : : {
7104 : : unsigned int nr_pages = hpage_nr_pages(page);
7105 : : struct page_counter *counter;
7106 : : struct mem_cgroup *memcg;
7107 : : unsigned short oldid;
7108 : :
7109 : : if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) || !do_swap_account)
7110 : : return 0;
7111 : :
7112 : : memcg = page->mem_cgroup;
7113 : :
7114 : : /* Readahead page, never charged */
7115 : : if (!memcg)
7116 : : return 0;
7117 : :
7118 : : if (!entry.val) {
7119 : : memcg_memory_event(memcg, MEMCG_SWAP_FAIL);
7120 : : return 0;
7121 : : }
7122 : :
7123 : : memcg = mem_cgroup_id_get_online(memcg);
7124 : :
7125 : : if (!mem_cgroup_is_root(memcg) &&
7126 : : !page_counter_try_charge(&memcg->swap, nr_pages, &counter)) {
7127 : : memcg_memory_event(memcg, MEMCG_SWAP_MAX);
7128 : : memcg_memory_event(memcg, MEMCG_SWAP_FAIL);
7129 : : mem_cgroup_id_put(memcg);
7130 : : return -ENOMEM;
7131 : : }
7132 : :
7133 : : /* Get references for the tail pages, too */
7134 : : if (nr_pages > 1)
7135 : : mem_cgroup_id_get_many(memcg, nr_pages - 1);
7136 : : oldid = swap_cgroup_record(entry, mem_cgroup_id(memcg), nr_pages);
7137 : : VM_BUG_ON_PAGE(oldid, page);
7138 : : mod_memcg_state(memcg, MEMCG_SWAP, nr_pages);
7139 : :
7140 : : return 0;
7141 : : }
7142 : :
7143 : : /**
7144 : : * mem_cgroup_uncharge_swap - uncharge swap space
7145 : : * @entry: swap entry to uncharge
7146 : : * @nr_pages: the amount of swap space to uncharge
7147 : : */
7148 : : void mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages)
7149 : : {
7150 : : struct mem_cgroup *memcg;
7151 : : unsigned short id;
7152 : :
7153 : : if (!do_swap_account)
7154 : : return;
7155 : :
7156 : : id = swap_cgroup_record(entry, 0, nr_pages);
7157 : : rcu_read_lock();
7158 : : memcg = mem_cgroup_from_id(id);
7159 : : if (memcg) {
7160 : : if (!mem_cgroup_is_root(memcg)) {
7161 : : if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
7162 : : page_counter_uncharge(&memcg->swap, nr_pages);
7163 : : else
7164 : : page_counter_uncharge(&memcg->memsw, nr_pages);
7165 : : }
7166 : : mod_memcg_state(memcg, MEMCG_SWAP, -nr_pages);
7167 : : mem_cgroup_id_put_many(memcg, nr_pages);
7168 : : }
7169 : : rcu_read_unlock();
7170 : : }
7171 : :
7172 : : long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg)
7173 : : {
7174 : : long nr_swap_pages = get_nr_swap_pages();
7175 : :
7176 : : if (!do_swap_account || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
7177 : : return nr_swap_pages;
7178 : : for (; memcg != root_mem_cgroup; memcg = parent_mem_cgroup(memcg))
7179 : : nr_swap_pages = min_t(long, nr_swap_pages,
7180 : : READ_ONCE(memcg->swap.max) -
7181 : : page_counter_read(&memcg->swap));
7182 : : return nr_swap_pages;
7183 : : }
7184 : :
7185 : : bool mem_cgroup_swap_full(struct page *page)
7186 : : {
7187 : : struct mem_cgroup *memcg;
7188 : :
7189 : : VM_BUG_ON_PAGE(!PageLocked(page), page);
7190 : :
7191 : : if (vm_swap_full())
7192 : : return true;
7193 : : if (!do_swap_account || !cgroup_subsys_on_dfl(memory_cgrp_subsys))
7194 : : return false;
7195 : :
7196 : : memcg = page->mem_cgroup;
7197 : : if (!memcg)
7198 : : return false;
7199 : :
7200 : : for (; memcg != root_mem_cgroup; memcg = parent_mem_cgroup(memcg))
7201 : : if (page_counter_read(&memcg->swap) * 2 >= memcg->swap.max)
7202 : : return true;
7203 : :
7204 : : return false;
7205 : : }
7206 : :
7207 : : /* for remember boot option*/
7208 : : #ifdef CONFIG_MEMCG_SWAP_ENABLED
7209 : : static int really_do_swap_account __initdata = 1;
7210 : : #else
7211 : : static int really_do_swap_account __initdata;
7212 : : #endif
7213 : :
7214 : : static int __init enable_swap_account(char *s)
7215 : : {
7216 : : if (!strcmp(s, "1"))
7217 : : really_do_swap_account = 1;
7218 : : else if (!strcmp(s, "0"))
7219 : : really_do_swap_account = 0;
7220 : : return 1;
7221 : : }
7222 : : __setup("swapaccount=", enable_swap_account);
7223 : :
7224 : : static u64 swap_current_read(struct cgroup_subsys_state *css,
7225 : : struct cftype *cft)
7226 : : {
7227 : : struct mem_cgroup *memcg = mem_cgroup_from_css(css);
7228 : :
7229 : : return (u64)page_counter_read(&memcg->swap) * PAGE_SIZE;
7230 : : }
7231 : :
7232 : : static int swap_max_show(struct seq_file *m, void *v)
7233 : : {
7234 : : return seq_puts_memcg_tunable(m,
7235 : : READ_ONCE(mem_cgroup_from_seq(m)->swap.max));
7236 : : }
7237 : :
7238 : : static ssize_t swap_max_write(struct kernfs_open_file *of,
7239 : : char *buf, size_t nbytes, loff_t off)
7240 : : {
7241 : : struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
7242 : : unsigned long max;
7243 : : int err;
7244 : :
7245 : : buf = strstrip(buf);
7246 : : err = page_counter_memparse(buf, "max", &max);
7247 : : if (err)
7248 : : return err;
7249 : :
7250 : : xchg(&memcg->swap.max, max);
7251 : :
7252 : : return nbytes;
7253 : : }
7254 : :
7255 : : static int swap_events_show(struct seq_file *m, void *v)
7256 : : {
7257 : : struct mem_cgroup *memcg = mem_cgroup_from_seq(m);
7258 : :
7259 : : seq_printf(m, "max %lu\n",
7260 : : atomic_long_read(&memcg->memory_events[MEMCG_SWAP_MAX]));
7261 : : seq_printf(m, "fail %lu\n",
7262 : : atomic_long_read(&memcg->memory_events[MEMCG_SWAP_FAIL]));
7263 : :
7264 : : return 0;
7265 : : }
7266 : :
7267 : : static struct cftype swap_files[] = {
7268 : : {
7269 : : .name = "swap.current",
7270 : : .flags = CFTYPE_NOT_ON_ROOT,
7271 : : .read_u64 = swap_current_read,
7272 : : },
7273 : : {
7274 : : .name = "swap.max",
7275 : : .flags = CFTYPE_NOT_ON_ROOT,
7276 : : .seq_show = swap_max_show,
7277 : : .write = swap_max_write,
7278 : : },
7279 : : {
7280 : : .name = "swap.events",
7281 : : .flags = CFTYPE_NOT_ON_ROOT,
7282 : : .file_offset = offsetof(struct mem_cgroup, swap_events_file),
7283 : : .seq_show = swap_events_show,
7284 : : },
7285 : : { } /* terminate */
7286 : : };
7287 : :
7288 : : static struct cftype memsw_cgroup_files[] = {
7289 : : {
7290 : : .name = "memsw.usage_in_bytes",
7291 : : .private = MEMFILE_PRIVATE(_MEMSWAP, RES_USAGE),
7292 : : .read_u64 = mem_cgroup_read_u64,
7293 : : },
7294 : : {
7295 : : .name = "memsw.max_usage_in_bytes",
7296 : : .private = MEMFILE_PRIVATE(_MEMSWAP, RES_MAX_USAGE),
7297 : : .write = mem_cgroup_reset,
7298 : : .read_u64 = mem_cgroup_read_u64,
7299 : : },
7300 : : {
7301 : : .name = "memsw.limit_in_bytes",
7302 : : .private = MEMFILE_PRIVATE(_MEMSWAP, RES_LIMIT),
7303 : : .write = mem_cgroup_write,
7304 : : .read_u64 = mem_cgroup_read_u64,
7305 : : },
7306 : : {
7307 : : .name = "memsw.failcnt",
7308 : : .private = MEMFILE_PRIVATE(_MEMSWAP, RES_FAILCNT),
7309 : : .write = mem_cgroup_reset,
7310 : : .read_u64 = mem_cgroup_read_u64,
7311 : : },
7312 : : { }, /* terminate */
7313 : : };
7314 : :
7315 : : static int __init mem_cgroup_swap_init(void)
7316 : : {
7317 : : if (!mem_cgroup_disabled() && really_do_swap_account) {
7318 : : do_swap_account = 1;
7319 : : WARN_ON(cgroup_add_dfl_cftypes(&memory_cgrp_subsys,
7320 : : swap_files));
7321 : : WARN_ON(cgroup_add_legacy_cftypes(&memory_cgrp_subsys,
7322 : : memsw_cgroup_files));
7323 : : }
7324 : : return 0;
7325 : : }
7326 : : subsys_initcall(mem_cgroup_swap_init);
7327 : :
7328 : : #endif /* CONFIG_MEMCG_SWAP */
|
