treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / include / linux / memcontrol.h
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* memcontrol.h - 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
11 #ifndef _LINUX_MEMCONTROL_H
12 #define _LINUX_MEMCONTROL_H
13 #include <linux/cgroup.h>
14 #include <linux/vm_event_item.h>
15 #include <linux/hardirq.h>
16 #include <linux/jump_label.h>
17 #include <linux/page_counter.h>
18 #include <linux/vmpressure.h>
19 #include <linux/eventfd.h>
20 #include <linux/mm.h>
21 #include <linux/vmstat.h>
22 #include <linux/writeback.h>
23 #include <linux/page-flags.h>
24
25 struct mem_cgroup;
26 struct page;
27 struct mm_struct;
28 struct kmem_cache;
29
30 /* Cgroup-specific page state, on top of universal node page state */
31 enum memcg_stat_item {
32         MEMCG_CACHE = NR_VM_NODE_STAT_ITEMS,
33         MEMCG_RSS,
34         MEMCG_RSS_HUGE,
35         MEMCG_SWAP,
36         MEMCG_SOCK,
37         /* XXX: why are these zone and not node counters? */
38         MEMCG_KERNEL_STACK_KB,
39         MEMCG_NR_STAT,
40 };
41
42 enum memcg_memory_event {
43         MEMCG_LOW,
44         MEMCG_HIGH,
45         MEMCG_MAX,
46         MEMCG_OOM,
47         MEMCG_OOM_KILL,
48         MEMCG_SWAP_MAX,
49         MEMCG_SWAP_FAIL,
50         MEMCG_NR_MEMORY_EVENTS,
51 };
52
53 enum mem_cgroup_protection {
54         MEMCG_PROT_NONE,
55         MEMCG_PROT_LOW,
56         MEMCG_PROT_MIN,
57 };
58
59 struct mem_cgroup_reclaim_cookie {
60         pg_data_t *pgdat;
61         int priority;
62         unsigned int generation;
63 };
64
65 #ifdef CONFIG_MEMCG
66
67 #define MEM_CGROUP_ID_SHIFT     16
68 #define MEM_CGROUP_ID_MAX       USHRT_MAX
69
70 struct mem_cgroup_id {
71         int id;
72         refcount_t ref;
73 };
74
75 /*
76  * Per memcg event counter is incremented at every pagein/pageout. With THP,
77  * it will be incremated by the number of pages. This counter is used for
78  * for trigger some periodic events. This is straightforward and better
79  * than using jiffies etc. to handle periodic memcg event.
80  */
81 enum mem_cgroup_events_target {
82         MEM_CGROUP_TARGET_THRESH,
83         MEM_CGROUP_TARGET_SOFTLIMIT,
84         MEM_CGROUP_TARGET_NUMAINFO,
85         MEM_CGROUP_NTARGETS,
86 };
87
88 struct memcg_vmstats_percpu {
89         long stat[MEMCG_NR_STAT];
90         unsigned long events[NR_VM_EVENT_ITEMS];
91         unsigned long nr_page_events;
92         unsigned long targets[MEM_CGROUP_NTARGETS];
93 };
94
95 struct mem_cgroup_reclaim_iter {
96         struct mem_cgroup *position;
97         /* scan generation, increased every round-trip */
98         unsigned int generation;
99 };
100
101 struct lruvec_stat {
102         long count[NR_VM_NODE_STAT_ITEMS];
103 };
104
105 /*
106  * Bitmap of shrinker::id corresponding to memcg-aware shrinkers,
107  * which have elements charged to this memcg.
108  */
109 struct memcg_shrinker_map {
110         struct rcu_head rcu;
111         unsigned long map[0];
112 };
113
114 /*
115  * per-zone information in memory controller.
116  */
117 struct mem_cgroup_per_node {
118         struct lruvec           lruvec;
119
120         struct lruvec_stat __percpu *lruvec_stat_cpu;
121         atomic_long_t           lruvec_stat[NR_VM_NODE_STAT_ITEMS];
122         atomic_long_t           lruvec_stat_local[NR_VM_NODE_STAT_ITEMS];
123
124         unsigned long           lru_zone_size[MAX_NR_ZONES][NR_LRU_LISTS];
125
126         struct mem_cgroup_reclaim_iter  iter[DEF_PRIORITY + 1];
127
128 #ifdef CONFIG_MEMCG_KMEM
129         struct memcg_shrinker_map __rcu *shrinker_map;
130 #endif
131         struct rb_node          tree_node;      /* RB tree node */
132         unsigned long           usage_in_excess;/* Set to the value by which */
133                                                 /* the soft limit is exceeded*/
134         bool                    on_tree;
135         bool                    congested;      /* memcg has many dirty pages */
136                                                 /* backed by a congested BDI */
137
138         struct mem_cgroup       *memcg;         /* Back pointer, we cannot */
139                                                 /* use container_of        */
140 };
141
142 struct mem_cgroup_threshold {
143         struct eventfd_ctx *eventfd;
144         unsigned long threshold;
145 };
146
147 /* For threshold */
148 struct mem_cgroup_threshold_ary {
149         /* An array index points to threshold just below or equal to usage. */
150         int current_threshold;
151         /* Size of entries[] */
152         unsigned int size;
153         /* Array of thresholds */
154         struct mem_cgroup_threshold entries[0];
155 };
156
157 struct mem_cgroup_thresholds {
158         /* Primary thresholds array */
159         struct mem_cgroup_threshold_ary *primary;
160         /*
161          * Spare threshold array.
162          * This is needed to make mem_cgroup_unregister_event() "never fail".
163          * It must be able to store at least primary->size - 1 entries.
164          */
165         struct mem_cgroup_threshold_ary *spare;
166 };
167
168 enum memcg_kmem_state {
169         KMEM_NONE,
170         KMEM_ALLOCATED,
171         KMEM_ONLINE,
172 };
173
174 #if defined(CONFIG_SMP)
175 struct memcg_padding {
176         char x[0];
177 } ____cacheline_internodealigned_in_smp;
178 #define MEMCG_PADDING(name)      struct memcg_padding name;
179 #else
180 #define MEMCG_PADDING(name)
181 #endif
182
183 /*
184  * The memory controller data structure. The memory controller controls both
185  * page cache and RSS per cgroup. We would eventually like to provide
186  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
187  * to help the administrator determine what knobs to tune.
188  */
189 struct mem_cgroup {
190         struct cgroup_subsys_state css;
191
192         /* Private memcg ID. Used to ID objects that outlive the cgroup */
193         struct mem_cgroup_id id;
194
195         /* Accounted resources */
196         struct page_counter memory;
197         struct page_counter swap;
198
199         /* Legacy consumer-oriented counters */
200         struct page_counter memsw;
201         struct page_counter kmem;
202         struct page_counter tcpmem;
203
204         /* Upper bound of normal memory consumption range */
205         unsigned long high;
206
207         /* Range enforcement for interrupt charges */
208         struct work_struct high_work;
209
210         unsigned long soft_limit;
211
212         /* vmpressure notifications */
213         struct vmpressure vmpressure;
214
215         /*
216          * Should the accounting and control be hierarchical, per subtree?
217          */
218         bool use_hierarchy;
219
220         /*
221          * Should the OOM killer kill all belonging tasks, had it kill one?
222          */
223         bool oom_group;
224
225         /* protected by memcg_oom_lock */
226         bool            oom_lock;
227         int             under_oom;
228
229         int     swappiness;
230         /* OOM-Killer disable */
231         int             oom_kill_disable;
232
233         /* memory.events */
234         struct cgroup_file events_file;
235
236         /* handle for "memory.swap.events" */
237         struct cgroup_file swap_events_file;
238
239         /* protect arrays of thresholds */
240         struct mutex thresholds_lock;
241
242         /* thresholds for memory usage. RCU-protected */
243         struct mem_cgroup_thresholds thresholds;
244
245         /* thresholds for mem+swap usage. RCU-protected */
246         struct mem_cgroup_thresholds memsw_thresholds;
247
248         /* For oom notifier event fd */
249         struct list_head oom_notify;
250
251         /*
252          * Should we move charges of a task when a task is moved into this
253          * mem_cgroup ? And what type of charges should we move ?
254          */
255         unsigned long move_charge_at_immigrate;
256         /* taken only while moving_account > 0 */
257         spinlock_t              move_lock;
258         unsigned long           move_lock_flags;
259
260         MEMCG_PADDING(_pad1_);
261
262         /*
263          * set > 0 if pages under this cgroup are moving to other cgroup.
264          */
265         atomic_t                moving_account;
266         struct task_struct      *move_lock_task;
267
268         /* memory.stat */
269         struct memcg_vmstats_percpu __percpu *vmstats_percpu;
270
271         MEMCG_PADDING(_pad2_);
272
273         atomic_long_t           vmstats[MEMCG_NR_STAT];
274         atomic_long_t           vmstats_local[MEMCG_NR_STAT];
275
276         atomic_long_t           vmevents[NR_VM_EVENT_ITEMS];
277         atomic_long_t           vmevents_local[NR_VM_EVENT_ITEMS];
278
279         atomic_long_t           memory_events[MEMCG_NR_MEMORY_EVENTS];
280
281         unsigned long           socket_pressure;
282
283         /* Legacy tcp memory accounting */
284         bool                    tcpmem_active;
285         int                     tcpmem_pressure;
286
287 #ifdef CONFIG_MEMCG_KMEM
288         /* Index in the kmem_cache->memcg_params.memcg_caches array */
289         int kmemcg_id;
290         enum memcg_kmem_state kmem_state;
291         struct list_head kmem_caches;
292 #endif
293
294         int last_scanned_node;
295 #if MAX_NUMNODES > 1
296         nodemask_t      scan_nodes;
297         atomic_t        numainfo_events;
298         atomic_t        numainfo_updating;
299 #endif
300
301 #ifdef CONFIG_CGROUP_WRITEBACK
302         struct list_head cgwb_list;
303         struct wb_domain cgwb_domain;
304 #endif
305
306         /* List of events which userspace want to receive */
307         struct list_head event_list;
308         spinlock_t event_list_lock;
309
310         struct mem_cgroup_per_node *nodeinfo[0];
311         /* WARNING: nodeinfo must be the last member here */
312 };
313
314 /*
315  * size of first charge trial. "32" comes from vmscan.c's magic value.
316  * TODO: maybe necessary to use big numbers in big irons.
317  */
318 #define MEMCG_CHARGE_BATCH 32U
319
320 extern struct mem_cgroup *root_mem_cgroup;
321
322 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
323 {
324         return (memcg == root_mem_cgroup);
325 }
326
327 static inline bool mem_cgroup_disabled(void)
328 {
329         return !cgroup_subsys_enabled(memory_cgrp_subsys);
330 }
331
332 enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
333                                                 struct mem_cgroup *memcg);
334
335 int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
336                           gfp_t gfp_mask, struct mem_cgroup **memcgp,
337                           bool compound);
338 int mem_cgroup_try_charge_delay(struct page *page, struct mm_struct *mm,
339                           gfp_t gfp_mask, struct mem_cgroup **memcgp,
340                           bool compound);
341 void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
342                               bool lrucare, bool compound);
343 void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg,
344                 bool compound);
345 void mem_cgroup_uncharge(struct page *page);
346 void mem_cgroup_uncharge_list(struct list_head *page_list);
347
348 void mem_cgroup_migrate(struct page *oldpage, struct page *newpage);
349
350 static struct mem_cgroup_per_node *
351 mem_cgroup_nodeinfo(struct mem_cgroup *memcg, int nid)
352 {
353         return memcg->nodeinfo[nid];
354 }
355
356 /**
357  * mem_cgroup_lruvec - get the lru list vector for a node or a memcg zone
358  * @node: node of the wanted lruvec
359  * @memcg: memcg of the wanted lruvec
360  *
361  * Returns the lru list vector holding pages for a given @node or a given
362  * @memcg and @zone. This can be the node lruvec, if the memory controller
363  * is disabled.
364  */
365 static inline struct lruvec *mem_cgroup_lruvec(struct pglist_data *pgdat,
366                                 struct mem_cgroup *memcg)
367 {
368         struct mem_cgroup_per_node *mz;
369         struct lruvec *lruvec;
370
371         if (mem_cgroup_disabled()) {
372                 lruvec = node_lruvec(pgdat);
373                 goto out;
374         }
375
376         mz = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
377         lruvec = &mz->lruvec;
378 out:
379         /*
380          * Since a node can be onlined after the mem_cgroup was created,
381          * we have to be prepared to initialize lruvec->pgdat here;
382          * and if offlined then reonlined, we need to reinitialize it.
383          */
384         if (unlikely(lruvec->pgdat != pgdat))
385                 lruvec->pgdat = pgdat;
386         return lruvec;
387 }
388
389 struct lruvec *mem_cgroup_page_lruvec(struct page *, struct pglist_data *);
390
391 bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg);
392 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
393
394 struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm);
395
396 struct mem_cgroup *get_mem_cgroup_from_page(struct page *page);
397
398 static inline
399 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css){
400         return css ? container_of(css, struct mem_cgroup, css) : NULL;
401 }
402
403 static inline void mem_cgroup_put(struct mem_cgroup *memcg)
404 {
405         if (memcg)
406                 css_put(&memcg->css);
407 }
408
409 #define mem_cgroup_from_counter(counter, member)        \
410         container_of(counter, struct mem_cgroup, member)
411
412 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
413                                    struct mem_cgroup *,
414                                    struct mem_cgroup_reclaim_cookie *);
415 void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
416 int mem_cgroup_scan_tasks(struct mem_cgroup *,
417                           int (*)(struct task_struct *, void *), void *);
418
419 static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
420 {
421         if (mem_cgroup_disabled())
422                 return 0;
423
424         return memcg->id.id;
425 }
426 struct mem_cgroup *mem_cgroup_from_id(unsigned short id);
427
428 static inline struct mem_cgroup *mem_cgroup_from_seq(struct seq_file *m)
429 {
430         return mem_cgroup_from_css(seq_css(m));
431 }
432
433 static inline struct mem_cgroup *lruvec_memcg(struct lruvec *lruvec)
434 {
435         struct mem_cgroup_per_node *mz;
436
437         if (mem_cgroup_disabled())
438                 return NULL;
439
440         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
441         return mz->memcg;
442 }
443
444 /**
445  * parent_mem_cgroup - find the accounting parent of a memcg
446  * @memcg: memcg whose parent to find
447  *
448  * Returns the parent memcg, or NULL if this is the root or the memory
449  * controller is in legacy no-hierarchy mode.
450  */
451 static inline struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
452 {
453         if (!memcg->memory.parent)
454                 return NULL;
455         return mem_cgroup_from_counter(memcg->memory.parent, memory);
456 }
457
458 static inline bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
459                               struct mem_cgroup *root)
460 {
461         if (root == memcg)
462                 return true;
463         if (!root->use_hierarchy)
464                 return false;
465         return cgroup_is_descendant(memcg->css.cgroup, root->css.cgroup);
466 }
467
468 static inline bool mm_match_cgroup(struct mm_struct *mm,
469                                    struct mem_cgroup *memcg)
470 {
471         struct mem_cgroup *task_memcg;
472         bool match = false;
473
474         rcu_read_lock();
475         task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
476         if (task_memcg)
477                 match = mem_cgroup_is_descendant(task_memcg, memcg);
478         rcu_read_unlock();
479         return match;
480 }
481
482 struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page);
483 ino_t page_cgroup_ino(struct page *page);
484
485 static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
486 {
487         if (mem_cgroup_disabled())
488                 return true;
489         return !!(memcg->css.flags & CSS_ONLINE);
490 }
491
492 /*
493  * For memory reclaim.
494  */
495 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
496
497 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
498                 int zid, int nr_pages);
499
500 static inline
501 unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec,
502                 enum lru_list lru, int zone_idx)
503 {
504         struct mem_cgroup_per_node *mz;
505
506         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
507         return mz->lru_zone_size[zone_idx][lru];
508 }
509
510 void mem_cgroup_handle_over_high(void);
511
512 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
513
514 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg,
515                                 struct task_struct *p);
516
517 void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg);
518
519 static inline void mem_cgroup_enter_user_fault(void)
520 {
521         WARN_ON(current->in_user_fault);
522         current->in_user_fault = 1;
523 }
524
525 static inline void mem_cgroup_exit_user_fault(void)
526 {
527         WARN_ON(!current->in_user_fault);
528         current->in_user_fault = 0;
529 }
530
531 static inline bool task_in_memcg_oom(struct task_struct *p)
532 {
533         return p->memcg_in_oom;
534 }
535
536 bool mem_cgroup_oom_synchronize(bool wait);
537 struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
538                                             struct mem_cgroup *oom_domain);
539 void mem_cgroup_print_oom_group(struct mem_cgroup *memcg);
540
541 #ifdef CONFIG_MEMCG_SWAP
542 extern int do_swap_account;
543 #endif
544
545 struct mem_cgroup *lock_page_memcg(struct page *page);
546 void __unlock_page_memcg(struct mem_cgroup *memcg);
547 void unlock_page_memcg(struct page *page);
548
549 /*
550  * idx can be of type enum memcg_stat_item or node_stat_item.
551  * Keep in sync with memcg_exact_page_state().
552  */
553 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, int idx)
554 {
555         long x = atomic_long_read(&memcg->vmstats[idx]);
556 #ifdef CONFIG_SMP
557         if (x < 0)
558                 x = 0;
559 #endif
560         return x;
561 }
562
563 /*
564  * idx can be of type enum memcg_stat_item or node_stat_item.
565  * Keep in sync with memcg_exact_page_state().
566  */
567 static inline unsigned long memcg_page_state_local(struct mem_cgroup *memcg,
568                                                    int idx)
569 {
570         long x = atomic_long_read(&memcg->vmstats_local[idx]);
571 #ifdef CONFIG_SMP
572         if (x < 0)
573                 x = 0;
574 #endif
575         return x;
576 }
577
578 void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val);
579
580 /* idx can be of type enum memcg_stat_item or node_stat_item */
581 static inline void mod_memcg_state(struct mem_cgroup *memcg,
582                                    int idx, int val)
583 {
584         unsigned long flags;
585
586         local_irq_save(flags);
587         __mod_memcg_state(memcg, idx, val);
588         local_irq_restore(flags);
589 }
590
591 /**
592  * mod_memcg_page_state - update page state statistics
593  * @page: the page
594  * @idx: page state item to account
595  * @val: number of pages (positive or negative)
596  *
597  * The @page must be locked or the caller must use lock_page_memcg()
598  * to prevent double accounting when the page is concurrently being
599  * moved to another memcg:
600  *
601  *   lock_page(page) or lock_page_memcg(page)
602  *   if (TestClearPageState(page))
603  *     mod_memcg_page_state(page, state, -1);
604  *   unlock_page(page) or unlock_page_memcg(page)
605  *
606  * Kernel pages are an exception to this, since they'll never move.
607  */
608 static inline void __mod_memcg_page_state(struct page *page,
609                                           int idx, int val)
610 {
611         if (page->mem_cgroup)
612                 __mod_memcg_state(page->mem_cgroup, idx, val);
613 }
614
615 static inline void mod_memcg_page_state(struct page *page,
616                                         int idx, int val)
617 {
618         if (page->mem_cgroup)
619                 mod_memcg_state(page->mem_cgroup, idx, val);
620 }
621
622 static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
623                                               enum node_stat_item idx)
624 {
625         struct mem_cgroup_per_node *pn;
626         long x;
627
628         if (mem_cgroup_disabled())
629                 return node_page_state(lruvec_pgdat(lruvec), idx);
630
631         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
632         x = atomic_long_read(&pn->lruvec_stat[idx]);
633 #ifdef CONFIG_SMP
634         if (x < 0)
635                 x = 0;
636 #endif
637         return x;
638 }
639
640 static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec,
641                                                     enum node_stat_item idx)
642 {
643         struct mem_cgroup_per_node *pn;
644         long x;
645
646         if (mem_cgroup_disabled())
647                 return node_page_state(lruvec_pgdat(lruvec), idx);
648
649         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
650         x = atomic_long_read(&pn->lruvec_stat_local[idx]);
651 #ifdef CONFIG_SMP
652         if (x < 0)
653                 x = 0;
654 #endif
655         return x;
656 }
657
658 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
659                         int val);
660
661 static inline void mod_lruvec_state(struct lruvec *lruvec,
662                                     enum node_stat_item idx, int val)
663 {
664         unsigned long flags;
665
666         local_irq_save(flags);
667         __mod_lruvec_state(lruvec, idx, val);
668         local_irq_restore(flags);
669 }
670
671 static inline void __mod_lruvec_page_state(struct page *page,
672                                            enum node_stat_item idx, int val)
673 {
674         pg_data_t *pgdat = page_pgdat(page);
675         struct lruvec *lruvec;
676
677         /* Untracked pages have no memcg, no lruvec. Update only the node */
678         if (!page->mem_cgroup) {
679                 __mod_node_page_state(pgdat, idx, val);
680                 return;
681         }
682
683         lruvec = mem_cgroup_lruvec(pgdat, page->mem_cgroup);
684         __mod_lruvec_state(lruvec, idx, val);
685 }
686
687 static inline void mod_lruvec_page_state(struct page *page,
688                                          enum node_stat_item idx, int val)
689 {
690         unsigned long flags;
691
692         local_irq_save(flags);
693         __mod_lruvec_page_state(page, idx, val);
694         local_irq_restore(flags);
695 }
696
697 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
698                                                 gfp_t gfp_mask,
699                                                 unsigned long *total_scanned);
700
701 void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
702                           unsigned long count);
703
704 static inline void count_memcg_events(struct mem_cgroup *memcg,
705                                       enum vm_event_item idx,
706                                       unsigned long count)
707 {
708         unsigned long flags;
709
710         local_irq_save(flags);
711         __count_memcg_events(memcg, idx, count);
712         local_irq_restore(flags);
713 }
714
715 static inline void count_memcg_page_event(struct page *page,
716                                           enum vm_event_item idx)
717 {
718         if (page->mem_cgroup)
719                 count_memcg_events(page->mem_cgroup, idx, 1);
720 }
721
722 static inline void count_memcg_event_mm(struct mm_struct *mm,
723                                         enum vm_event_item idx)
724 {
725         struct mem_cgroup *memcg;
726
727         if (mem_cgroup_disabled())
728                 return;
729
730         rcu_read_lock();
731         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
732         if (likely(memcg))
733                 count_memcg_events(memcg, idx, 1);
734         rcu_read_unlock();
735 }
736
737 static inline void memcg_memory_event(struct mem_cgroup *memcg,
738                                       enum memcg_memory_event event)
739 {
740         atomic_long_inc(&memcg->memory_events[event]);
741         cgroup_file_notify(&memcg->events_file);
742 }
743
744 static inline void memcg_memory_event_mm(struct mm_struct *mm,
745                                          enum memcg_memory_event event)
746 {
747         struct mem_cgroup *memcg;
748
749         if (mem_cgroup_disabled())
750                 return;
751
752         rcu_read_lock();
753         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
754         if (likely(memcg))
755                 memcg_memory_event(memcg, event);
756         rcu_read_unlock();
757 }
758
759 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
760 void mem_cgroup_split_huge_fixup(struct page *head);
761 #endif
762
763 #else /* CONFIG_MEMCG */
764
765 #define MEM_CGROUP_ID_SHIFT     0
766 #define MEM_CGROUP_ID_MAX       0
767
768 struct mem_cgroup;
769
770 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
771 {
772         return true;
773 }
774
775 static inline bool mem_cgroup_disabled(void)
776 {
777         return true;
778 }
779
780 static inline void memcg_memory_event(struct mem_cgroup *memcg,
781                                       enum memcg_memory_event event)
782 {
783 }
784
785 static inline void memcg_memory_event_mm(struct mm_struct *mm,
786                                          enum memcg_memory_event event)
787 {
788 }
789
790 static inline enum mem_cgroup_protection mem_cgroup_protected(
791         struct mem_cgroup *root, struct mem_cgroup *memcg)
792 {
793         return MEMCG_PROT_NONE;
794 }
795
796 static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
797                                         gfp_t gfp_mask,
798                                         struct mem_cgroup **memcgp,
799                                         bool compound)
800 {
801         *memcgp = NULL;
802         return 0;
803 }
804
805 static inline int mem_cgroup_try_charge_delay(struct page *page,
806                                               struct mm_struct *mm,
807                                               gfp_t gfp_mask,
808                                               struct mem_cgroup **memcgp,
809                                               bool compound)
810 {
811         *memcgp = NULL;
812         return 0;
813 }
814
815 static inline void mem_cgroup_commit_charge(struct page *page,
816                                             struct mem_cgroup *memcg,
817                                             bool lrucare, bool compound)
818 {
819 }
820
821 static inline void mem_cgroup_cancel_charge(struct page *page,
822                                             struct mem_cgroup *memcg,
823                                             bool compound)
824 {
825 }
826
827 static inline void mem_cgroup_uncharge(struct page *page)
828 {
829 }
830
831 static inline void mem_cgroup_uncharge_list(struct list_head *page_list)
832 {
833 }
834
835 static inline void mem_cgroup_migrate(struct page *old, struct page *new)
836 {
837 }
838
839 static inline struct lruvec *mem_cgroup_lruvec(struct pglist_data *pgdat,
840                                 struct mem_cgroup *memcg)
841 {
842         return node_lruvec(pgdat);
843 }
844
845 static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
846                                                     struct pglist_data *pgdat)
847 {
848         return &pgdat->lruvec;
849 }
850
851 static inline bool mm_match_cgroup(struct mm_struct *mm,
852                 struct mem_cgroup *memcg)
853 {
854         return true;
855 }
856
857 static inline bool task_in_mem_cgroup(struct task_struct *task,
858                                       const struct mem_cgroup *memcg)
859 {
860         return true;
861 }
862
863 static inline struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
864 {
865         return NULL;
866 }
867
868 static inline struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
869 {
870         return NULL;
871 }
872
873 static inline void mem_cgroup_put(struct mem_cgroup *memcg)
874 {
875 }
876
877 static inline struct mem_cgroup *
878 mem_cgroup_iter(struct mem_cgroup *root,
879                 struct mem_cgroup *prev,
880                 struct mem_cgroup_reclaim_cookie *reclaim)
881 {
882         return NULL;
883 }
884
885 static inline void mem_cgroup_iter_break(struct mem_cgroup *root,
886                                          struct mem_cgroup *prev)
887 {
888 }
889
890 static inline int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
891                 int (*fn)(struct task_struct *, void *), void *arg)
892 {
893         return 0;
894 }
895
896 static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
897 {
898         return 0;
899 }
900
901 static inline struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
902 {
903         WARN_ON_ONCE(id);
904         /* XXX: This should always return root_mem_cgroup */
905         return NULL;
906 }
907
908 static inline struct mem_cgroup *mem_cgroup_from_seq(struct seq_file *m)
909 {
910         return NULL;
911 }
912
913 static inline struct mem_cgroup *lruvec_memcg(struct lruvec *lruvec)
914 {
915         return NULL;
916 }
917
918 static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
919 {
920         return true;
921 }
922
923 static inline
924 unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec,
925                 enum lru_list lru, int zone_idx)
926 {
927         return 0;
928 }
929
930 static inline unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg)
931 {
932         return 0;
933 }
934
935 static inline void
936 mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
937 {
938 }
939
940 static inline void
941 mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
942 {
943 }
944
945 static inline struct mem_cgroup *lock_page_memcg(struct page *page)
946 {
947         return NULL;
948 }
949
950 static inline void __unlock_page_memcg(struct mem_cgroup *memcg)
951 {
952 }
953
954 static inline void unlock_page_memcg(struct page *page)
955 {
956 }
957
958 static inline void mem_cgroup_handle_over_high(void)
959 {
960 }
961
962 static inline void mem_cgroup_enter_user_fault(void)
963 {
964 }
965
966 static inline void mem_cgroup_exit_user_fault(void)
967 {
968 }
969
970 static inline bool task_in_memcg_oom(struct task_struct *p)
971 {
972         return false;
973 }
974
975 static inline bool mem_cgroup_oom_synchronize(bool wait)
976 {
977         return false;
978 }
979
980 static inline struct mem_cgroup *mem_cgroup_get_oom_group(
981         struct task_struct *victim, struct mem_cgroup *oom_domain)
982 {
983         return NULL;
984 }
985
986 static inline void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
987 {
988 }
989
990 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, int idx)
991 {
992         return 0;
993 }
994
995 static inline unsigned long memcg_page_state_local(struct mem_cgroup *memcg,
996                                                    int idx)
997 {
998         return 0;
999 }
1000
1001 static inline void __mod_memcg_state(struct mem_cgroup *memcg,
1002                                      int idx,
1003                                      int nr)
1004 {
1005 }
1006
1007 static inline void mod_memcg_state(struct mem_cgroup *memcg,
1008                                    int idx,
1009                                    int nr)
1010 {
1011 }
1012
1013 static inline void __mod_memcg_page_state(struct page *page,
1014                                           int idx,
1015                                           int nr)
1016 {
1017 }
1018
1019 static inline void mod_memcg_page_state(struct page *page,
1020                                         int idx,
1021                                         int nr)
1022 {
1023 }
1024
1025 static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
1026                                               enum node_stat_item idx)
1027 {
1028         return node_page_state(lruvec_pgdat(lruvec), idx);
1029 }
1030
1031 static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec,
1032                                                     enum node_stat_item idx)
1033 {
1034         return node_page_state(lruvec_pgdat(lruvec), idx);
1035 }
1036
1037 static inline void __mod_lruvec_state(struct lruvec *lruvec,
1038                                       enum node_stat_item idx, int val)
1039 {
1040         __mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
1041 }
1042
1043 static inline void mod_lruvec_state(struct lruvec *lruvec,
1044                                     enum node_stat_item idx, int val)
1045 {
1046         mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
1047 }
1048
1049 static inline void __mod_lruvec_page_state(struct page *page,
1050                                            enum node_stat_item idx, int val)
1051 {
1052         __mod_node_page_state(page_pgdat(page), idx, val);
1053 }
1054
1055 static inline void mod_lruvec_page_state(struct page *page,
1056                                          enum node_stat_item idx, int val)
1057 {
1058         mod_node_page_state(page_pgdat(page), idx, val);
1059 }
1060
1061 static inline
1062 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
1063                                             gfp_t gfp_mask,
1064                                             unsigned long *total_scanned)
1065 {
1066         return 0;
1067 }
1068
1069 static inline void mem_cgroup_split_huge_fixup(struct page *head)
1070 {
1071 }
1072
1073 static inline void count_memcg_events(struct mem_cgroup *memcg,
1074                                       enum vm_event_item idx,
1075                                       unsigned long count)
1076 {
1077 }
1078
1079 static inline void __count_memcg_events(struct mem_cgroup *memcg,
1080                                         enum vm_event_item idx,
1081                                         unsigned long count)
1082 {
1083 }
1084
1085 static inline void count_memcg_page_event(struct page *page,
1086                                           int idx)
1087 {
1088 }
1089
1090 static inline
1091 void count_memcg_event_mm(struct mm_struct *mm, enum vm_event_item idx)
1092 {
1093 }
1094 #endif /* CONFIG_MEMCG */
1095
1096 /* idx can be of type enum memcg_stat_item or node_stat_item */
1097 static inline void __inc_memcg_state(struct mem_cgroup *memcg,
1098                                      int idx)
1099 {
1100         __mod_memcg_state(memcg, idx, 1);
1101 }
1102
1103 /* idx can be of type enum memcg_stat_item or node_stat_item */
1104 static inline void __dec_memcg_state(struct mem_cgroup *memcg,
1105                                      int idx)
1106 {
1107         __mod_memcg_state(memcg, idx, -1);
1108 }
1109
1110 /* idx can be of type enum memcg_stat_item or node_stat_item */
1111 static inline void __inc_memcg_page_state(struct page *page,
1112                                           int idx)
1113 {
1114         __mod_memcg_page_state(page, idx, 1);
1115 }
1116
1117 /* idx can be of type enum memcg_stat_item or node_stat_item */
1118 static inline void __dec_memcg_page_state(struct page *page,
1119                                           int idx)
1120 {
1121         __mod_memcg_page_state(page, idx, -1);
1122 }
1123
1124 static inline void __inc_lruvec_state(struct lruvec *lruvec,
1125                                       enum node_stat_item idx)
1126 {
1127         __mod_lruvec_state(lruvec, idx, 1);
1128 }
1129
1130 static inline void __dec_lruvec_state(struct lruvec *lruvec,
1131                                       enum node_stat_item idx)
1132 {
1133         __mod_lruvec_state(lruvec, idx, -1);
1134 }
1135
1136 static inline void __inc_lruvec_page_state(struct page *page,
1137                                            enum node_stat_item idx)
1138 {
1139         __mod_lruvec_page_state(page, idx, 1);
1140 }
1141
1142 static inline void __dec_lruvec_page_state(struct page *page,
1143                                            enum node_stat_item idx)
1144 {
1145         __mod_lruvec_page_state(page, idx, -1);
1146 }
1147
1148 /* idx can be of type enum memcg_stat_item or node_stat_item */
1149 static inline void inc_memcg_state(struct mem_cgroup *memcg,
1150                                    int idx)
1151 {
1152         mod_memcg_state(memcg, idx, 1);
1153 }
1154
1155 /* idx can be of type enum memcg_stat_item or node_stat_item */
1156 static inline void dec_memcg_state(struct mem_cgroup *memcg,
1157                                    int idx)
1158 {
1159         mod_memcg_state(memcg, idx, -1);
1160 }
1161
1162 /* idx can be of type enum memcg_stat_item or node_stat_item */
1163 static inline void inc_memcg_page_state(struct page *page,
1164                                         int idx)
1165 {
1166         mod_memcg_page_state(page, idx, 1);
1167 }
1168
1169 /* idx can be of type enum memcg_stat_item or node_stat_item */
1170 static inline void dec_memcg_page_state(struct page *page,
1171                                         int idx)
1172 {
1173         mod_memcg_page_state(page, idx, -1);
1174 }
1175
1176 static inline void inc_lruvec_state(struct lruvec *lruvec,
1177                                     enum node_stat_item idx)
1178 {
1179         mod_lruvec_state(lruvec, idx, 1);
1180 }
1181
1182 static inline void dec_lruvec_state(struct lruvec *lruvec,
1183                                     enum node_stat_item idx)
1184 {
1185         mod_lruvec_state(lruvec, idx, -1);
1186 }
1187
1188 static inline void inc_lruvec_page_state(struct page *page,
1189                                          enum node_stat_item idx)
1190 {
1191         mod_lruvec_page_state(page, idx, 1);
1192 }
1193
1194 static inline void dec_lruvec_page_state(struct page *page,
1195                                          enum node_stat_item idx)
1196 {
1197         mod_lruvec_page_state(page, idx, -1);
1198 }
1199
1200 #ifdef CONFIG_CGROUP_WRITEBACK
1201
1202 struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
1203 void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
1204                          unsigned long *pheadroom, unsigned long *pdirty,
1205                          unsigned long *pwriteback);
1206
1207 #else   /* CONFIG_CGROUP_WRITEBACK */
1208
1209 static inline struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
1210 {
1211         return NULL;
1212 }
1213
1214 static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
1215                                        unsigned long *pfilepages,
1216                                        unsigned long *pheadroom,
1217                                        unsigned long *pdirty,
1218                                        unsigned long *pwriteback)
1219 {
1220 }
1221
1222 #endif  /* CONFIG_CGROUP_WRITEBACK */
1223
1224 struct sock;
1225 bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
1226 void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
1227 #ifdef CONFIG_MEMCG
1228 extern struct static_key_false memcg_sockets_enabled_key;
1229 #define mem_cgroup_sockets_enabled static_branch_unlikely(&memcg_sockets_enabled_key)
1230 void mem_cgroup_sk_alloc(struct sock *sk);
1231 void mem_cgroup_sk_free(struct sock *sk);
1232 static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
1233 {
1234         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && memcg->tcpmem_pressure)
1235                 return true;
1236         do {
1237                 if (time_before(jiffies, memcg->socket_pressure))
1238                         return true;
1239         } while ((memcg = parent_mem_cgroup(memcg)));
1240         return false;
1241 }
1242 #else
1243 #define mem_cgroup_sockets_enabled 0
1244 static inline void mem_cgroup_sk_alloc(struct sock *sk) { };
1245 static inline void mem_cgroup_sk_free(struct sock *sk) { };
1246 static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
1247 {
1248         return false;
1249 }
1250 #endif
1251
1252 struct kmem_cache *memcg_kmem_get_cache(struct kmem_cache *cachep);
1253 void memcg_kmem_put_cache(struct kmem_cache *cachep);
1254
1255 #ifdef CONFIG_MEMCG_KMEM
1256 int __memcg_kmem_charge(struct page *page, gfp_t gfp, int order);
1257 void __memcg_kmem_uncharge(struct page *page, int order);
1258 int __memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
1259                               struct mem_cgroup *memcg);
1260
1261 extern struct static_key_false memcg_kmem_enabled_key;
1262 extern struct workqueue_struct *memcg_kmem_cache_wq;
1263
1264 extern int memcg_nr_cache_ids;
1265 void memcg_get_cache_ids(void);
1266 void memcg_put_cache_ids(void);
1267
1268 /*
1269  * Helper macro to loop through all memcg-specific caches. Callers must still
1270  * check if the cache is valid (it is either valid or NULL).
1271  * the slab_mutex must be held when looping through those caches
1272  */
1273 #define for_each_memcg_cache_index(_idx)        \
1274         for ((_idx) = 0; (_idx) < memcg_nr_cache_ids; (_idx)++)
1275
1276 static inline bool memcg_kmem_enabled(void)
1277 {
1278         return static_branch_unlikely(&memcg_kmem_enabled_key);
1279 }
1280
1281 static inline int memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
1282 {
1283         if (memcg_kmem_enabled())
1284                 return __memcg_kmem_charge(page, gfp, order);
1285         return 0;
1286 }
1287
1288 static inline void memcg_kmem_uncharge(struct page *page, int order)
1289 {
1290         if (memcg_kmem_enabled())
1291                 __memcg_kmem_uncharge(page, order);
1292 }
1293
1294 static inline int memcg_kmem_charge_memcg(struct page *page, gfp_t gfp,
1295                                           int order, struct mem_cgroup *memcg)
1296 {
1297         if (memcg_kmem_enabled())
1298                 return __memcg_kmem_charge_memcg(page, gfp, order, memcg);
1299         return 0;
1300 }
1301 /*
1302  * helper for accessing a memcg's index. It will be used as an index in the
1303  * child cache array in kmem_cache, and also to derive its name. This function
1304  * will return -1 when this is not a kmem-limited memcg.
1305  */
1306 static inline int memcg_cache_id(struct mem_cgroup *memcg)
1307 {
1308         return memcg ? memcg->kmemcg_id : -1;
1309 }
1310
1311 extern int memcg_expand_shrinker_maps(int new_id);
1312
1313 extern void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
1314                                    int nid, int shrinker_id);
1315 #else
1316
1317 static inline int memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
1318 {
1319         return 0;
1320 }
1321
1322 static inline void memcg_kmem_uncharge(struct page *page, int order)
1323 {
1324 }
1325
1326 static inline int __memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
1327 {
1328         return 0;
1329 }
1330
1331 static inline void __memcg_kmem_uncharge(struct page *page, int order)
1332 {
1333 }
1334
1335 #define for_each_memcg_cache_index(_idx)        \
1336         for (; NULL; )
1337
1338 static inline bool memcg_kmem_enabled(void)
1339 {
1340         return false;
1341 }
1342
1343 static inline int memcg_cache_id(struct mem_cgroup *memcg)
1344 {
1345         return -1;
1346 }
1347
1348 static inline void memcg_get_cache_ids(void)
1349 {
1350 }
1351
1352 static inline void memcg_put_cache_ids(void)
1353 {
1354 }
1355
1356 static inline void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
1357                                           int nid, int shrinker_id) { }
1358 #endif /* CONFIG_MEMCG_KMEM */
1359
1360 #endif /* _LINUX_MEMCONTROL_H */