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 obj_cgroup;
  27 struct page;
  28 struct mm_struct;
  29 struct kmem_cache;
  30
  31 /* Cgroup-specific page state, on top of universal node page state */
  32 enum memcg_stat_item {
  33         MEMCG_SWAP = NR_VM_NODE_STAT_ITEMS,
  34         MEMCG_SOCK,
  35         MEMCG_NR_STAT,
  36 };
  37
  38 enum memcg_memory_event {
  39         MEMCG_LOW,
  40         MEMCG_HIGH,
  41         MEMCG_MAX,
  42         MEMCG_OOM,
  43         MEMCG_OOM_KILL,
  44         MEMCG_SWAP_HIGH,
  45         MEMCG_SWAP_MAX,
  46         MEMCG_SWAP_FAIL,
  47         MEMCG_NR_MEMORY_EVENTS,
  48 };
  49
  50 enum mem_cgroup_protection {
  51         MEMCG_PROT_NONE,
  52         MEMCG_PROT_LOW,
  53         MEMCG_PROT_MIN,
  54 };
  55
  56 struct mem_cgroup_reclaim_cookie {
  57         pg_data_t *pgdat;
  58         unsigned int generation;
  59 };
  60
  61 #ifdef CONFIG_MEMCG
  62
  63 #define MEM_CGROUP_ID_SHIFT     16
  64 #define MEM_CGROUP_ID_MAX       USHRT_MAX
  65
  66 struct mem_cgroup_id {
  67         int id;
  68         refcount_t ref;
  69 };
  70
  71 /*
  72  * Per memcg event counter is incremented at every pagein/pageout. With THP,
  73  * it will be incremated by the number of pages. This counter is used for
  74  * for trigger some periodic events. This is straightforward and better
  75  * than using jiffies etc. to handle periodic memcg event.
  76  */
  77 enum mem_cgroup_events_target {
  78         MEM_CGROUP_TARGET_THRESH,
  79         MEM_CGROUP_TARGET_SOFTLIMIT,
  80         MEM_CGROUP_NTARGETS,
  81 };
  82
  83 struct memcg_vmstats_percpu {
  84         long stat[MEMCG_NR_STAT];
  85         unsigned long events[NR_VM_EVENT_ITEMS];
  86         unsigned long nr_page_events;
  87         unsigned long targets[MEM_CGROUP_NTARGETS];
  88 };
  89
  90 struct mem_cgroup_reclaim_iter {
  91         struct mem_cgroup *position;
  92         /* scan generation, increased every round-trip */
  93         unsigned int generation;
  94 };
  95
  96 struct lruvec_stat {
  97         long count[NR_VM_NODE_STAT_ITEMS];
  98 };
  99
 100 /*
 101  * Bitmap of shrinker::id corresponding to memcg-aware shrinkers,
 102  * which have elements charged to this memcg.
 103  */
 104 struct memcg_shrinker_map {
 105         struct rcu_head rcu;
 106         unsigned long map[];
 107 };
 108
 109 /*
 110  * per-node information in memory controller.
 111  */
 112 struct mem_cgroup_per_node {
 113         struct lruvec           lruvec;
 114
 115         /* Legacy local VM stats */
 116         struct lruvec_stat __percpu *lruvec_stat_local;
 117
 118         /* Subtree VM stats (batched updates) */
 119         struct lruvec_stat __percpu *lruvec_stat_cpu;
 120         atomic_long_t           lruvec_stat[NR_VM_NODE_STAT_ITEMS];
 121
 122         unsigned long           lru_zone_size[MAX_NR_ZONES][NR_LRU_LISTS];
 123
 124         struct mem_cgroup_reclaim_iter  iter;
 125
 126         struct memcg_shrinker_map __rcu *shrinker_map;
 127
 128         struct rb_node          tree_node;      /* RB tree node */
 129         unsigned long           usage_in_excess;/* Set to the value by which */
 130                                                 /* the soft limit is exceeded*/
 131         bool                    on_tree;
 132         struct mem_cgroup       *memcg;         /* Back pointer, we cannot */
 133                                                 /* use container_of        */
 134 };
 135
 136 struct mem_cgroup_threshold {
 137         struct eventfd_ctx *eventfd;
 138         unsigned long threshold;
 139 };
 140
 141 /* For threshold */
 142 struct mem_cgroup_threshold_ary {
 143         /* An array index points to threshold just below or equal to usage. */
 144         int current_threshold;
 145         /* Size of entries[] */
 146         unsigned int size;
 147         /* Array of thresholds */
 148         struct mem_cgroup_threshold entries[];
 149 };
 150
 151 struct mem_cgroup_thresholds {
 152         /* Primary thresholds array */
 153         struct mem_cgroup_threshold_ary *primary;
 154         /*
 155          * Spare threshold array.
 156          * This is needed to make mem_cgroup_unregister_event() "never fail".
 157          * It must be able to store at least primary->size - 1 entries.
 158          */
 159         struct mem_cgroup_threshold_ary *spare;
 160 };
 161
 162 enum memcg_kmem_state {
 163         KMEM_NONE,
 164         KMEM_ALLOCATED,
 165         KMEM_ONLINE,
 166 };
 167
 168 #if defined(CONFIG_SMP)
 169 struct memcg_padding {
 170         char x[0];
 171 } ____cacheline_internodealigned_in_smp;
 172 #define MEMCG_PADDING(name)      struct memcg_padding name;
 173 #else
 174 #define MEMCG_PADDING(name)
 175 #endif
 176
 177 /*
 178  * Remember four most recent foreign writebacks with dirty pages in this
 179  * cgroup.  Inode sharing is expected to be uncommon and, even if we miss
 180  * one in a given round, we're likely to catch it later if it keeps
 181  * foreign-dirtying, so a fairly low count should be enough.
 182  *
 183  * See mem_cgroup_track_foreign_dirty_slowpath() for details.
 184  */
 185 #define MEMCG_CGWB_FRN_CNT      4
 186
 187 struct memcg_cgwb_frn {
 188         u64 bdi_id;                     /* bdi->id of the foreign inode */
 189         int memcg_id;                   /* memcg->css.id of foreign inode */
 190         u64 at;                         /* jiffies_64 at the time of dirtying */
 191         struct wb_completion done;      /* tracks in-flight foreign writebacks */
 192 };
 193
 194 /*
 195  * Bucket for arbitrarily byte-sized objects charged to a memory
 196  * cgroup. The bucket can be reparented in one piece when the cgroup
 197  * is destroyed, without having to round up the individual references
 198  * of all live memory objects in the wild.
 199  */
 200 struct obj_cgroup {
 201         struct percpu_ref refcnt;
 202         struct mem_cgroup *memcg;
 203         atomic_t nr_charged_bytes;
 204         union {
 205                 struct list_head list;
 206                 struct rcu_head rcu;
 207         };
 208 };
 209
 210 /*
 211  * The memory controller data structure. The memory controller controls both
 212  * page cache and RSS per cgroup. We would eventually like to provide
 213  * statistics based on the statistics developed by Rik Van Riel for clock-pro,
 214  * to help the administrator determine what knobs to tune.
 215  */
 216 struct mem_cgroup {
 217         struct cgroup_subsys_state css;
 218
 219         /* Private memcg ID. Used to ID objects that outlive the cgroup */
 220         struct mem_cgroup_id id;
 221
 222         /* Accounted resources */
 223         struct page_counter memory;
 224         struct page_counter swap;
 225
 226         /* Legacy consumer-oriented counters */
 227         struct page_counter memsw;
 228         struct page_counter kmem;
 229         struct page_counter tcpmem;
 230
 231         /* Range enforcement for interrupt charges */
 232         struct work_struct high_work;
 233
 234         unsigned long soft_limit;
 235
 236         /* vmpressure notifications */
 237         struct vmpressure vmpressure;
 238
 239         /*
 240          * Should the accounting and control be hierarchical, per subtree?
 241          */
 242         bool use_hierarchy;
 243
 244         /*
 245          * Should the OOM killer kill all belonging tasks, had it kill one?
 246          */
 247         bool oom_group;
 248
 249         /* protected by memcg_oom_lock */
 250         bool            oom_lock;
 251         int             under_oom;
 252
 253         int     swappiness;
 254         /* OOM-Killer disable */
 255         int             oom_kill_disable;
 256
 257         /* memory.events and memory.events.local */
 258         struct cgroup_file events_file;
 259         struct cgroup_file events_local_file;
 260
 261         /* handle for "memory.swap.events" */
 262         struct cgroup_file swap_events_file;
 263
 264         /* protect arrays of thresholds */
 265         struct mutex thresholds_lock;
 266
 267         /* thresholds for memory usage. RCU-protected */
 268         struct mem_cgroup_thresholds thresholds;
 269
 270         /* thresholds for mem+swap usage. RCU-protected */
 271         struct mem_cgroup_thresholds memsw_thresholds;
 272
 273         /* For oom notifier event fd */
 274         struct list_head oom_notify;
 275
 276         /*
 277          * Should we move charges of a task when a task is moved into this
 278          * mem_cgroup ? And what type of charges should we move ?
 279          */
 280         unsigned long move_charge_at_immigrate;
 281         /* taken only while moving_account > 0 */
 282         spinlock_t              move_lock;
 283         unsigned long           move_lock_flags;
 284
 285         MEMCG_PADDING(_pad1_);
 286
 287         /*
 288          * set > 0 if pages under this cgroup are moving to other cgroup.
 289          */
 290         atomic_t                moving_account;
 291         struct task_struct      *move_lock_task;
 292
 293         /* Legacy local VM stats and events */
 294         struct memcg_vmstats_percpu __percpu *vmstats_local;
 295
 296         /* Subtree VM stats and events (batched updates) */
 297         struct memcg_vmstats_percpu __percpu *vmstats_percpu;
 298
 299         MEMCG_PADDING(_pad2_);
 300
 301         atomic_long_t           vmstats[MEMCG_NR_STAT];
 302         atomic_long_t           vmevents[NR_VM_EVENT_ITEMS];
 303
 304         /* memory.events */
 305         atomic_long_t           memory_events[MEMCG_NR_MEMORY_EVENTS];
 306         atomic_long_t           memory_events_local[MEMCG_NR_MEMORY_EVENTS];
 307
 308         unsigned long           socket_pressure;
 309
 310         /* Legacy tcp memory accounting */
 311         bool                    tcpmem_active;
 312         int                     tcpmem_pressure;
 313
 314 #ifdef CONFIG_MEMCG_KMEM
 315         /* Index in the kmem_cache->memcg_params.memcg_caches array */
 316         int kmemcg_id;
 317         enum memcg_kmem_state kmem_state;
 318         struct obj_cgroup __rcu *objcg;
 319         struct list_head objcg_list; /* list of inherited objcgs */
 320 #endif
 321
 322 #ifdef CONFIG_CGROUP_WRITEBACK
 323         struct list_head cgwb_list;
 324         struct wb_domain cgwb_domain;
 325         struct memcg_cgwb_frn cgwb_frn[MEMCG_CGWB_FRN_CNT];
 326 #endif
 327
 328         /* List of events which userspace want to receive */
 329         struct list_head event_list;
 330         spinlock_t event_list_lock;
 331
 332 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 333         struct deferred_split deferred_split_queue;
 334 #endif
 335
 336         struct mem_cgroup_per_node *nodeinfo[0];
 337         /* WARNING: nodeinfo must be the last member here */
 338 };
 339
 340 /*
 341  * size of first charge trial. "32" comes from vmscan.c's magic value.
 342  * TODO: maybe necessary to use big numbers in big irons.
 343  */
 344 #define MEMCG_CHARGE_BATCH 32U
 345
 346 extern struct mem_cgroup *root_mem_cgroup;
 347
 348 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
 349 {
 350         return (memcg == root_mem_cgroup);
 351 }
 352
 353 static inline bool mem_cgroup_disabled(void)
 354 {
 355         return !cgroup_subsys_enabled(memory_cgrp_subsys);
 356 }
 357
 358 static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root,
 359                                                   struct mem_cgroup *memcg,
 360                                                   bool in_low_reclaim)
 361 {
 362         if (mem_cgroup_disabled())
 363                 return 0;
 364
 365         /*
 366          * There is no reclaim protection applied to a targeted reclaim.
 367          * We are special casing this specific case here because
 368          * mem_cgroup_protected calculation is not robust enough to keep
 369          * the protection invariant for calculated effective values for
 370          * parallel reclaimers with different reclaim target. This is
 371          * especially a problem for tail memcgs (as they have pages on LRU)
 372          * which would want to have effective values 0 for targeted reclaim
 373          * but a different value for external reclaim.
 374          *
 375          * Example
 376          * Let's have global and A's reclaim in parallel:
 377          *  |
 378          *  A (low=2G, usage = 3G, max = 3G, children_low_usage = 1.5G)
 379          *  |\
 380          *  | C (low = 1G, usage = 2.5G)
 381          *  B (low = 1G, usage = 0.5G)
 382          *
 383          * For the global reclaim
 384          * A.elow = A.low
 385          * B.elow = min(B.usage, B.low) because children_low_usage <= A.elow
 386          * C.elow = min(C.usage, C.low)
 387          *
 388          * With the effective values resetting we have A reclaim
 389          * A.elow = 0
 390          * B.elow = B.low
 391          * C.elow = C.low
 392          *
 393          * If the global reclaim races with A's reclaim then
 394          * B.elow = C.elow = 0 because children_low_usage > A.elow)
 395          * is possible and reclaiming B would be violating the protection.
 396          *
 397          */
 398         if (root == memcg)
 399                 return 0;
 400
 401         if (in_low_reclaim)
 402                 return READ_ONCE(memcg->memory.emin);
 403
 404         return max(READ_ONCE(memcg->memory.emin),
 405                    READ_ONCE(memcg->memory.elow));
 406 }
 407
 408 enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
 409                                                 struct mem_cgroup *memcg);
 410
 411 int mem_cgroup_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask);
 412
 413 void mem_cgroup_uncharge(struct page *page);
 414 void mem_cgroup_uncharge_list(struct list_head *page_list);
 415
 416 void mem_cgroup_migrate(struct page *oldpage, struct page *newpage);
 417
 418 static struct mem_cgroup_per_node *
 419 mem_cgroup_nodeinfo(struct mem_cgroup *memcg, int nid)
 420 {
 421         return memcg->nodeinfo[nid];
 422 }
 423
 424 /**
 425  * mem_cgroup_lruvec - get the lru list vector for a memcg & node
 426  * @memcg: memcg of the wanted lruvec
 427  *
 428  * Returns the lru list vector holding pages for a given @memcg &
 429  * @node combination. This can be the node lruvec, if the memory
 430  * controller is disabled.
 431  */
 432 static inline struct lruvec *mem_cgroup_lruvec(struct mem_cgroup *memcg,
 433                                                struct pglist_data *pgdat)
 434 {
 435         struct mem_cgroup_per_node *mz;
 436         struct lruvec *lruvec;
 437
 438         if (mem_cgroup_disabled()) {
 439                 lruvec = &pgdat->__lruvec;
 440                 goto out;
 441         }
 442
 443         if (!memcg)
 444                 memcg = root_mem_cgroup;
 445
 446         mz = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
 447         lruvec = &mz->lruvec;
 448 out:
 449         /*
 450          * Since a node can be onlined after the mem_cgroup was created,
 451          * we have to be prepared to initialize lruvec->pgdat here;
 452          * and if offlined then reonlined, we need to reinitialize it.
 453          */
 454         if (unlikely(lruvec->pgdat != pgdat))
 455                 lruvec->pgdat = pgdat;
 456         return lruvec;
 457 }
 458
 459 struct lruvec *mem_cgroup_page_lruvec(struct page *, struct pglist_data *);
 460
 461 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
 462
 463 struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm);
 464
 465 struct mem_cgroup *get_mem_cgroup_from_page(struct page *page);
 466
 467 static inline
 468 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css){
 469         return css ? container_of(css, struct mem_cgroup, css) : NULL;
 470 }
 471
 472 static inline bool obj_cgroup_tryget(struct obj_cgroup *objcg)
 473 {
 474         return percpu_ref_tryget(&objcg->refcnt);
 475 }
 476
 477 static inline void obj_cgroup_get(struct obj_cgroup *objcg)
 478 {
 479         percpu_ref_get(&objcg->refcnt);
 480 }
 481
 482 static inline void obj_cgroup_put(struct obj_cgroup *objcg)
 483 {
 484         percpu_ref_put(&objcg->refcnt);
 485 }
 486
 487 /*
 488  * After the initialization objcg->memcg is always pointing at
 489  * a valid memcg, but can be atomically swapped to the parent memcg.
 490  *
 491  * The caller must ensure that the returned memcg won't be released:
 492  * e.g. acquire the rcu_read_lock or css_set_lock.
 493  */
 494 static inline struct mem_cgroup *obj_cgroup_memcg(struct obj_cgroup *objcg)
 495 {
 496         return READ_ONCE(objcg->memcg);
 497 }
 498
 499 static inline void mem_cgroup_put(struct mem_cgroup *memcg)
 500 {
 501         if (memcg)
 502                 css_put(&memcg->css);
 503 }
 504
 505 #define mem_cgroup_from_counter(counter, member)        \
 506         container_of(counter, struct mem_cgroup, member)
 507
 508 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
 509                                    struct mem_cgroup *,
 510                                    struct mem_cgroup_reclaim_cookie *);
 511 void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
 512 int mem_cgroup_scan_tasks(struct mem_cgroup *,
 513                           int (*)(struct task_struct *, void *), void *);
 514
 515 static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
 516 {
 517         if (mem_cgroup_disabled())
 518                 return 0;
 519
 520         return memcg->id.id;
 521 }
 522 struct mem_cgroup *mem_cgroup_from_id(unsigned short id);
 523
 524 static inline struct mem_cgroup *mem_cgroup_from_seq(struct seq_file *m)
 525 {
 526         return mem_cgroup_from_css(seq_css(m));
 527 }
 528
 529 static inline struct mem_cgroup *lruvec_memcg(struct lruvec *lruvec)
 530 {
 531         struct mem_cgroup_per_node *mz;
 532
 533         if (mem_cgroup_disabled())
 534                 return NULL;
 535
 536         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
 537         return mz->memcg;
 538 }
 539
 540 /**
 541  * parent_mem_cgroup - find the accounting parent of a memcg
 542  * @memcg: memcg whose parent to find
 543  *
 544  * Returns the parent memcg, or NULL if this is the root or the memory
 545  * controller is in legacy no-hierarchy mode.
 546  */
 547 static inline struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
 548 {
 549         if (!memcg->memory.parent)
 550                 return NULL;
 551         return mem_cgroup_from_counter(memcg->memory.parent, memory);
 552 }
 553
 554 static inline bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
 555                               struct mem_cgroup *root)
 556 {
 557         if (root == memcg)
 558                 return true;
 559         if (!root->use_hierarchy)
 560                 return false;
 561         return cgroup_is_descendant(memcg->css.cgroup, root->css.cgroup);
 562 }
 563
 564 static inline bool mm_match_cgroup(struct mm_struct *mm,
 565                                    struct mem_cgroup *memcg)
 566 {
 567         struct mem_cgroup *task_memcg;
 568         bool match = false;
 569
 570         rcu_read_lock();
 571         task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
 572         if (task_memcg)
 573                 match = mem_cgroup_is_descendant(task_memcg, memcg);
 574         rcu_read_unlock();
 575         return match;
 576 }
 577
 578 struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page);
 579 ino_t page_cgroup_ino(struct page *page);
 580
 581 static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
 582 {
 583         if (mem_cgroup_disabled())
 584                 return true;
 585         return !!(memcg->css.flags & CSS_ONLINE);
 586 }
 587
 588 /*
 589  * For memory reclaim.
 590  */
 591 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 592
 593 void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
 594                 int zid, int nr_pages);
 595
 596 static inline
 597 unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec,
 598                 enum lru_list lru, int zone_idx)
 599 {
 600         struct mem_cgroup_per_node *mz;
 601
 602         mz = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
 603         return mz->lru_zone_size[zone_idx][lru];
 604 }
 605
 606 void mem_cgroup_handle_over_high(void);
 607
 608 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
 609
 610 unsigned long mem_cgroup_size(struct mem_cgroup *memcg);
 611
 612 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg,
 613                                 struct task_struct *p);
 614
 615 void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg);
 616
 617 static inline void mem_cgroup_enter_user_fault(void)
 618 {
 619         WARN_ON(current->in_user_fault);
 620         current->in_user_fault = 1;
 621 }
 622
 623 static inline void mem_cgroup_exit_user_fault(void)
 624 {
 625         WARN_ON(!current->in_user_fault);
 626         current->in_user_fault = 0;
 627 }
 628
 629 static inline bool task_in_memcg_oom(struct task_struct *p)
 630 {
 631         return p->memcg_in_oom;
 632 }
 633
 634 bool mem_cgroup_oom_synchronize(bool wait);
 635 struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
 636                                             struct mem_cgroup *oom_domain);
 637 void mem_cgroup_print_oom_group(struct mem_cgroup *memcg);
 638
 639 #ifdef CONFIG_MEMCG_SWAP
 640 extern bool cgroup_memory_noswap;
 641 #endif
 642
 643 struct mem_cgroup *lock_page_memcg(struct page *page);
 644 void __unlock_page_memcg(struct mem_cgroup *memcg);
 645 void unlock_page_memcg(struct page *page);
 646
 647 /*
 648  * idx can be of type enum memcg_stat_item or node_stat_item.
 649  * Keep in sync with memcg_exact_page_state().
 650  */
 651 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, int idx)
 652 {
 653         long x = atomic_long_read(&memcg->vmstats[idx]);
 654 #ifdef CONFIG_SMP
 655         if (x < 0)
 656                 x = 0;
 657 #endif
 658         return x;
 659 }
 660
 661 /*
 662  * idx can be of type enum memcg_stat_item or node_stat_item.
 663  * Keep in sync with memcg_exact_page_state().
 664  */
 665 static inline unsigned long memcg_page_state_local(struct mem_cgroup *memcg,
 666                                                    int idx)
 667 {
 668         long x = 0;
 669         int cpu;
 670
 671         for_each_possible_cpu(cpu)
 672                 x += per_cpu(memcg->vmstats_local->stat[idx], cpu);
 673 #ifdef CONFIG_SMP
 674         if (x < 0)
 675                 x = 0;
 676 #endif
 677         return x;
 678 }
 679
 680 void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val);
 681
 682 /* idx can be of type enum memcg_stat_item or node_stat_item */
 683 static inline void mod_memcg_state(struct mem_cgroup *memcg,
 684                                    int idx, int val)
 685 {
 686         unsigned long flags;
 687
 688         local_irq_save(flags);
 689         __mod_memcg_state(memcg, idx, val);
 690         local_irq_restore(flags);
 691 }
 692
 693 /**
 694  * mod_memcg_page_state - update page state statistics
 695  * @page: the page
 696  * @idx: page state item to account
 697  * @val: number of pages (positive or negative)
 698  *
 699  * The @page must be locked or the caller must use lock_page_memcg()
 700  * to prevent double accounting when the page is concurrently being
 701  * moved to another memcg:
 702  *
 703  *   lock_page(page) or lock_page_memcg(page)
 704  *   if (TestClearPageState(page))
 705  *     mod_memcg_page_state(page, state, -1);
 706  *   unlock_page(page) or unlock_page_memcg(page)
 707  *
 708  * Kernel pages are an exception to this, since they'll never move.
 709  */
 710 static inline void __mod_memcg_page_state(struct page *page,
 711                                           int idx, int val)
 712 {
 713         if (page->mem_cgroup)
 714                 __mod_memcg_state(page->mem_cgroup, idx, val);
 715 }
 716
 717 static inline void mod_memcg_page_state(struct page *page,
 718                                         int idx, int val)
 719 {
 720         if (page->mem_cgroup)
 721                 mod_memcg_state(page->mem_cgroup, idx, val);
 722 }
 723
 724 static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
 725                                               enum node_stat_item idx)
 726 {
 727         struct mem_cgroup_per_node *pn;
 728         long x;
 729
 730         if (mem_cgroup_disabled())
 731                 return node_page_state(lruvec_pgdat(lruvec), idx);
 732
 733         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
 734         x = atomic_long_read(&pn->lruvec_stat[idx]);
 735 #ifdef CONFIG_SMP
 736         if (x < 0)
 737                 x = 0;
 738 #endif
 739         return x;
 740 }
 741
 742 static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec,
 743                                                     enum node_stat_item idx)
 744 {
 745         struct mem_cgroup_per_node *pn;
 746         long x = 0;
 747         int cpu;
 748
 749         if (mem_cgroup_disabled())
 750                 return node_page_state(lruvec_pgdat(lruvec), idx);
 751
 752         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
 753         for_each_possible_cpu(cpu)
 754                 x += per_cpu(pn->lruvec_stat_local->count[idx], cpu);
 755 #ifdef CONFIG_SMP
 756         if (x < 0)
 757                 x = 0;
 758 #endif
 759         return x;
 760 }
 761
 762 void __mod_memcg_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
 763                               int val);
 764 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
 765                         int val);
 766 void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val);
 767
 768 void mod_memcg_obj_state(void *p, int idx, int val);
 769
 770 static inline void mod_lruvec_slab_state(void *p, enum node_stat_item idx,
 771                                          int val)
 772 {
 773         unsigned long flags;
 774
 775         local_irq_save(flags);
 776         __mod_lruvec_slab_state(p, idx, val);
 777         local_irq_restore(flags);
 778 }
 779
 780 static inline void mod_memcg_lruvec_state(struct lruvec *lruvec,
 781                                           enum node_stat_item idx, int val)
 782 {
 783         unsigned long flags;
 784
 785         local_irq_save(flags);
 786         __mod_memcg_lruvec_state(lruvec, idx, val);
 787         local_irq_restore(flags);
 788 }
 789
 790 static inline void mod_lruvec_state(struct lruvec *lruvec,
 791                                     enum node_stat_item idx, int val)
 792 {
 793         unsigned long flags;
 794
 795         local_irq_save(flags);
 796         __mod_lruvec_state(lruvec, idx, val);
 797         local_irq_restore(flags);
 798 }
 799
 800 static inline void __mod_lruvec_page_state(struct page *page,
 801                                            enum node_stat_item idx, int val)
 802 {
 803         struct page *head = compound_head(page); /* rmap on tail pages */
 804         pg_data_t *pgdat = page_pgdat(page);
 805         struct lruvec *lruvec;
 806
 807         /* Untracked pages have no memcg, no lruvec. Update only the node */
 808         if (!head->mem_cgroup) {
 809                 __mod_node_page_state(pgdat, idx, val);
 810                 return;
 811         }
 812
 813         lruvec = mem_cgroup_lruvec(head->mem_cgroup, pgdat);
 814         __mod_lruvec_state(lruvec, idx, val);
 815 }
 816
 817 static inline void mod_lruvec_page_state(struct page *page,
 818                                          enum node_stat_item idx, int val)
 819 {
 820         unsigned long flags;
 821
 822         local_irq_save(flags);
 823         __mod_lruvec_page_state(page, idx, val);
 824         local_irq_restore(flags);
 825 }
 826
 827 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
 828                                                 gfp_t gfp_mask,
 829                                                 unsigned long *total_scanned);
 830
 831 void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
 832                           unsigned long count);
 833
 834 static inline void count_memcg_events(struct mem_cgroup *memcg,
 835                                       enum vm_event_item idx,
 836                                       unsigned long count)
 837 {
 838         unsigned long flags;
 839
 840         local_irq_save(flags);
 841         __count_memcg_events(memcg, idx, count);
 842         local_irq_restore(flags);
 843 }
 844
 845 static inline void count_memcg_page_event(struct page *page,
 846                                           enum vm_event_item idx)
 847 {
 848         if (page->mem_cgroup)
 849                 count_memcg_events(page->mem_cgroup, idx, 1);
 850 }
 851
 852 static inline void count_memcg_event_mm(struct mm_struct *mm,
 853                                         enum vm_event_item idx)
 854 {
 855         struct mem_cgroup *memcg;
 856
 857         if (mem_cgroup_disabled())
 858                 return;
 859
 860         rcu_read_lock();
 861         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
 862         if (likely(memcg))
 863                 count_memcg_events(memcg, idx, 1);
 864         rcu_read_unlock();
 865 }
 866
 867 static inline void memcg_memory_event(struct mem_cgroup *memcg,
 868                                       enum memcg_memory_event event)
 869 {
 870         atomic_long_inc(&memcg->memory_events_local[event]);
 871         cgroup_file_notify(&memcg->events_local_file);
 872
 873         do {
 874                 atomic_long_inc(&memcg->memory_events[event]);
 875                 cgroup_file_notify(&memcg->events_file);
 876
 877                 if (!cgroup_subsys_on_dfl(memory_cgrp_subsys))
 878                         break;
 879                 if (cgrp_dfl_root.flags & CGRP_ROOT_MEMORY_LOCAL_EVENTS)
 880                         break;
 881         } while ((memcg = parent_mem_cgroup(memcg)) &&
 882                  !mem_cgroup_is_root(memcg));
 883 }
 884
 885 static inline void memcg_memory_event_mm(struct mm_struct *mm,
 886                                          enum memcg_memory_event event)
 887 {
 888         struct mem_cgroup *memcg;
 889
 890         if (mem_cgroup_disabled())
 891                 return;
 892
 893         rcu_read_lock();
 894         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
 895         if (likely(memcg))
 896                 memcg_memory_event(memcg, event);
 897         rcu_read_unlock();
 898 }
 899
 900 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 901 void mem_cgroup_split_huge_fixup(struct page *head);
 902 #endif
 903
 904 #else /* CONFIG_MEMCG */
 905
 906 #define MEM_CGROUP_ID_SHIFT     0
 907 #define MEM_CGROUP_ID_MAX       0
 908
 909 struct mem_cgroup;
 910
 911 static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
 912 {
 913         return true;
 914 }
 915
 916 static inline bool mem_cgroup_disabled(void)
 917 {
 918         return true;
 919 }
 920
 921 static inline void memcg_memory_event(struct mem_cgroup *memcg,
 922                                       enum memcg_memory_event event)
 923 {
 924 }
 925
 926 static inline void memcg_memory_event_mm(struct mm_struct *mm,
 927                                          enum memcg_memory_event event)
 928 {
 929 }
 930
 931 static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root,
 932                                                   struct mem_cgroup *memcg,
 933                                                   bool in_low_reclaim)
 934 {
 935         return 0;
 936 }
 937
 938 static inline enum mem_cgroup_protection mem_cgroup_protected(
 939         struct mem_cgroup *root, struct mem_cgroup *memcg)
 940 {
 941         return MEMCG_PROT_NONE;
 942 }
 943
 944 static inline int mem_cgroup_charge(struct page *page, struct mm_struct *mm,
 945                                     gfp_t gfp_mask)
 946 {
 947         return 0;
 948 }
 949
 950 static inline void mem_cgroup_uncharge(struct page *page)
 951 {
 952 }
 953
 954 static inline void mem_cgroup_uncharge_list(struct list_head *page_list)
 955 {
 956 }
 957
 958 static inline void mem_cgroup_migrate(struct page *old, struct page *new)
 959 {
 960 }
 961
 962 static inline struct lruvec *mem_cgroup_lruvec(struct mem_cgroup *memcg,
 963                                                struct pglist_data *pgdat)
 964 {
 965         return &pgdat->__lruvec;
 966 }
 967
 968 static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
 969                                                     struct pglist_data *pgdat)
 970 {
 971         return &pgdat->__lruvec;
 972 }
 973
 974 static inline struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
 975 {
 976         return NULL;
 977 }
 978
 979 static inline bool mm_match_cgroup(struct mm_struct *mm,
 980                 struct mem_cgroup *memcg)
 981 {
 982         return true;
 983 }
 984
 985 static inline struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
 986 {
 987         return NULL;
 988 }
 989
 990 static inline struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
 991 {
 992         return NULL;
 993 }
 994
 995 static inline void mem_cgroup_put(struct mem_cgroup *memcg)
 996 {
 997 }
 998
 999 static inline struct mem_cgroup *
1000 mem_cgroup_iter(struct mem_cgroup *root,
1001                 struct mem_cgroup *prev,
1002                 struct mem_cgroup_reclaim_cookie *reclaim)
1003 {
1004         return NULL;
1005 }
1006
1007 static inline void mem_cgroup_iter_break(struct mem_cgroup *root,
1008                                          struct mem_cgroup *prev)
1009 {
1010 }
1011
1012 static inline int mem_cgroup_scan_tasks(struct mem_cgroup *memcg,
1013                 int (*fn)(struct task_struct *, void *), void *arg)
1014 {
1015         return 0;
1016 }
1017
1018 static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
1019 {
1020         return 0;
1021 }
1022
1023 static inline struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
1024 {
1025         WARN_ON_ONCE(id);
1026         /* XXX: This should always return root_mem_cgroup */
1027         return NULL;
1028 }
1029
1030 static inline struct mem_cgroup *mem_cgroup_from_seq(struct seq_file *m)
1031 {
1032         return NULL;
1033 }
1034
1035 static inline struct mem_cgroup *lruvec_memcg(struct lruvec *lruvec)
1036 {
1037         return NULL;
1038 }
1039
1040 static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
1041 {
1042         return true;
1043 }
1044
1045 static inline
1046 unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec,
1047                 enum lru_list lru, int zone_idx)
1048 {
1049         return 0;
1050 }
1051
1052 static inline unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg)
1053 {
1054         return 0;
1055 }
1056
1057 static inline unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
1058 {
1059         return 0;
1060 }
1061
1062 static inline void
1063 mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
1064 {
1065 }
1066
1067 static inline void
1068 mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
1069 {
1070 }
1071
1072 static inline struct mem_cgroup *lock_page_memcg(struct page *page)
1073 {
1074         return NULL;
1075 }
1076
1077 static inline void __unlock_page_memcg(struct mem_cgroup *memcg)
1078 {
1079 }
1080
1081 static inline void unlock_page_memcg(struct page *page)
1082 {
1083 }
1084
1085 static inline void mem_cgroup_handle_over_high(void)
1086 {
1087 }
1088
1089 static inline void mem_cgroup_enter_user_fault(void)
1090 {
1091 }
1092
1093 static inline void mem_cgroup_exit_user_fault(void)
1094 {
1095 }
1096
1097 static inline bool task_in_memcg_oom(struct task_struct *p)
1098 {
1099         return false;
1100 }
1101
1102 static inline bool mem_cgroup_oom_synchronize(bool wait)
1103 {
1104         return false;
1105 }
1106
1107 static inline struct mem_cgroup *mem_cgroup_get_oom_group(
1108         struct task_struct *victim, struct mem_cgroup *oom_domain)
1109 {
1110         return NULL;
1111 }
1112
1113 static inline void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
1114 {
1115 }
1116
1117 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg, int idx)
1118 {
1119         return 0;
1120 }
1121
1122 static inline unsigned long memcg_page_state_local(struct mem_cgroup *memcg,
1123                                                    int idx)
1124 {
1125         return 0;
1126 }
1127
1128 static inline void __mod_memcg_state(struct mem_cgroup *memcg,
1129                                      int idx,
1130                                      int nr)
1131 {
1132 }
1133
1134 static inline void mod_memcg_state(struct mem_cgroup *memcg,
1135                                    int idx,
1136                                    int nr)
1137 {
1138 }
1139
1140 static inline void __mod_memcg_page_state(struct page *page,
1141                                           int idx,
1142                                           int nr)
1143 {
1144 }
1145
1146 static inline void mod_memcg_page_state(struct page *page,
1147                                         int idx,
1148                                         int nr)
1149 {
1150 }
1151
1152 static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
1153                                               enum node_stat_item idx)
1154 {
1155         return node_page_state(lruvec_pgdat(lruvec), idx);
1156 }
1157
1158 static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec,
1159                                                     enum node_stat_item idx)
1160 {
1161         return node_page_state(lruvec_pgdat(lruvec), idx);
1162 }
1163
1164 static inline void __mod_memcg_lruvec_state(struct lruvec *lruvec,
1165                                             enum node_stat_item idx, int val)
1166 {
1167 }
1168
1169 static inline void __mod_lruvec_state(struct lruvec *lruvec,
1170                                       enum node_stat_item idx, int val)
1171 {
1172         __mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
1173 }
1174
1175 static inline void mod_lruvec_state(struct lruvec *lruvec,
1176                                     enum node_stat_item idx, int val)
1177 {
1178         mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
1179 }
1180
1181 static inline void __mod_lruvec_page_state(struct page *page,
1182                                            enum node_stat_item idx, int val)
1183 {
1184         __mod_node_page_state(page_pgdat(page), idx, val);
1185 }
1186
1187 static inline void mod_lruvec_page_state(struct page *page,
1188                                          enum node_stat_item idx, int val)
1189 {
1190         mod_node_page_state(page_pgdat(page), idx, val);
1191 }
1192
1193 static inline void __mod_lruvec_slab_state(void *p, enum node_stat_item idx,
1194                                            int val)
1195 {
1196         struct page *page = virt_to_head_page(p);
1197
1198         __mod_node_page_state(page_pgdat(page), idx, val);
1199 }
1200
1201 static inline void mod_lruvec_slab_state(void *p, enum node_stat_item idx,
1202                                          int val)
1203 {
1204         struct page *page = virt_to_head_page(p);
1205
1206         mod_node_page_state(page_pgdat(page), idx, val);
1207 }
1208
1209 static inline void mod_memcg_obj_state(void *p, int idx, int val)
1210 {
1211 }
1212
1213 static inline
1214 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
1215                                             gfp_t gfp_mask,
1216                                             unsigned long *total_scanned)
1217 {
1218         return 0;
1219 }
1220
1221 static inline void mem_cgroup_split_huge_fixup(struct page *head)
1222 {
1223 }
1224
1225 static inline void count_memcg_events(struct mem_cgroup *memcg,
1226                                       enum vm_event_item idx,
1227                                       unsigned long count)
1228 {
1229 }
1230
1231 static inline void __count_memcg_events(struct mem_cgroup *memcg,
1232                                         enum vm_event_item idx,
1233                                         unsigned long count)
1234 {
1235 }
1236
1237 static inline void count_memcg_page_event(struct page *page,
1238                                           int idx)
1239 {
1240 }
1241
1242 static inline
1243 void count_memcg_event_mm(struct mm_struct *mm, enum vm_event_item idx)
1244 {
1245 }
1246 #endif /* CONFIG_MEMCG */
1247
1248 /* idx can be of type enum memcg_stat_item or node_stat_item */
1249 static inline void __inc_memcg_state(struct mem_cgroup *memcg,
1250                                      int idx)
1251 {
1252         __mod_memcg_state(memcg, idx, 1);
1253 }
1254
1255 /* idx can be of type enum memcg_stat_item or node_stat_item */
1256 static inline void __dec_memcg_state(struct mem_cgroup *memcg,
1257                                      int idx)
1258 {
1259         __mod_memcg_state(memcg, idx, -1);
1260 }
1261
1262 /* idx can be of type enum memcg_stat_item or node_stat_item */
1263 static inline void __inc_memcg_page_state(struct page *page,
1264                                           int idx)
1265 {
1266         __mod_memcg_page_state(page, idx, 1);
1267 }
1268
1269 /* idx can be of type enum memcg_stat_item or node_stat_item */
1270 static inline void __dec_memcg_page_state(struct page *page,
1271                                           int idx)
1272 {
1273         __mod_memcg_page_state(page, idx, -1);
1274 }
1275
1276 static inline void __inc_lruvec_state(struct lruvec *lruvec,
1277                                       enum node_stat_item idx)
1278 {
1279         __mod_lruvec_state(lruvec, idx, 1);
1280 }
1281
1282 static inline void __dec_lruvec_state(struct lruvec *lruvec,
1283                                       enum node_stat_item idx)
1284 {
1285         __mod_lruvec_state(lruvec, idx, -1);
1286 }
1287
1288 static inline void __inc_lruvec_page_state(struct page *page,
1289                                            enum node_stat_item idx)
1290 {
1291         __mod_lruvec_page_state(page, idx, 1);
1292 }
1293
1294 static inline void __dec_lruvec_page_state(struct page *page,
1295                                            enum node_stat_item idx)
1296 {
1297         __mod_lruvec_page_state(page, idx, -1);
1298 }
1299
1300 static inline void __inc_lruvec_slab_state(void *p, enum node_stat_item idx)
1301 {
1302         __mod_lruvec_slab_state(p, idx, 1);
1303 }
1304
1305 static inline void __dec_lruvec_slab_state(void *p, enum node_stat_item idx)
1306 {
1307         __mod_lruvec_slab_state(p, idx, -1);
1308 }
1309
1310 /* idx can be of type enum memcg_stat_item or node_stat_item */
1311 static inline void inc_memcg_state(struct mem_cgroup *memcg,
1312                                    int idx)
1313 {
1314         mod_memcg_state(memcg, idx, 1);
1315 }
1316
1317 /* idx can be of type enum memcg_stat_item or node_stat_item */
1318 static inline void dec_memcg_state(struct mem_cgroup *memcg,
1319                                    int idx)
1320 {
1321         mod_memcg_state(memcg, idx, -1);
1322 }
1323
1324 /* idx can be of type enum memcg_stat_item or node_stat_item */
1325 static inline void inc_memcg_page_state(struct page *page,
1326                                         int idx)
1327 {
1328         mod_memcg_page_state(page, idx, 1);
1329 }
1330
1331 /* idx can be of type enum memcg_stat_item or node_stat_item */
1332 static inline void dec_memcg_page_state(struct page *page,
1333                                         int idx)
1334 {
1335         mod_memcg_page_state(page, idx, -1);
1336 }
1337
1338 static inline void inc_lruvec_state(struct lruvec *lruvec,
1339                                     enum node_stat_item idx)
1340 {
1341         mod_lruvec_state(lruvec, idx, 1);
1342 }
1343
1344 static inline void dec_lruvec_state(struct lruvec *lruvec,
1345                                     enum node_stat_item idx)
1346 {
1347         mod_lruvec_state(lruvec, idx, -1);
1348 }
1349
1350 static inline void inc_lruvec_page_state(struct page *page,
1351                                          enum node_stat_item idx)
1352 {
1353         mod_lruvec_page_state(page, idx, 1);
1354 }
1355
1356 static inline void dec_lruvec_page_state(struct page *page,
1357                                          enum node_stat_item idx)
1358 {
1359         mod_lruvec_page_state(page, idx, -1);
1360 }
1361
1362 static inline struct lruvec *parent_lruvec(struct lruvec *lruvec)
1363 {
1364         struct mem_cgroup *memcg;
1365
1366         memcg = lruvec_memcg(lruvec);
1367         if (!memcg)
1368                 return NULL;
1369         memcg = parent_mem_cgroup(memcg);
1370         if (!memcg)
1371                 return NULL;
1372         return mem_cgroup_lruvec(memcg, lruvec_pgdat(lruvec));
1373 }
1374
1375 #ifdef CONFIG_CGROUP_WRITEBACK
1376
1377 struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
1378 void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
1379                          unsigned long *pheadroom, unsigned long *pdirty,
1380                          unsigned long *pwriteback);
1381
1382 void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
1383                                              struct bdi_writeback *wb);
1384
1385 static inline void mem_cgroup_track_foreign_dirty(struct page *page,
1386                                                   struct bdi_writeback *wb)
1387 {
1388         if (mem_cgroup_disabled())
1389                 return;
1390
1391         if (unlikely(&page->mem_cgroup->css != wb->memcg_css))
1392                 mem_cgroup_track_foreign_dirty_slowpath(page, wb);
1393 }
1394
1395 void mem_cgroup_flush_foreign(struct bdi_writeback *wb);
1396
1397 #else   /* CONFIG_CGROUP_WRITEBACK */
1398
1399 static inline struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
1400 {
1401         return NULL;
1402 }
1403
1404 static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
1405                                        unsigned long *pfilepages,
1406                                        unsigned long *pheadroom,
1407                                        unsigned long *pdirty,
1408                                        unsigned long *pwriteback)
1409 {
1410 }
1411
1412 static inline void mem_cgroup_track_foreign_dirty(struct page *page,
1413                                                   struct bdi_writeback *wb)
1414 {
1415 }
1416
1417 static inline void mem_cgroup_flush_foreign(struct bdi_writeback *wb)
1418 {
1419 }
1420
1421 #endif  /* CONFIG_CGROUP_WRITEBACK */
1422
1423 struct sock;
1424 bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
1425 void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
1426 #ifdef CONFIG_MEMCG
1427 extern struct static_key_false memcg_sockets_enabled_key;
1428 #define mem_cgroup_sockets_enabled static_branch_unlikely(&memcg_sockets_enabled_key)
1429 void mem_cgroup_sk_alloc(struct sock *sk);
1430 void mem_cgroup_sk_free(struct sock *sk);
1431 static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
1432 {
1433         if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && memcg->tcpmem_pressure)
1434                 return true;
1435         do {
1436                 if (time_before(jiffies, memcg->socket_pressure))
1437                         return true;
1438         } while ((memcg = parent_mem_cgroup(memcg)));
1439         return false;
1440 }
1441
1442 extern int memcg_expand_shrinker_maps(int new_id);
1443
1444 extern void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
1445                                    int nid, int shrinker_id);
1446 #else
1447 #define mem_cgroup_sockets_enabled 0
1448 static inline void mem_cgroup_sk_alloc(struct sock *sk) { };
1449 static inline void mem_cgroup_sk_free(struct sock *sk) { };
1450 static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
1451 {
1452         return false;
1453 }
1454
1455 static inline void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
1456                                           int nid, int shrinker_id)
1457 {
1458 }
1459 #endif
1460
1461 #ifdef CONFIG_MEMCG_KMEM
1462 int __memcg_kmem_charge(struct mem_cgroup *memcg, gfp_t gfp,
1463                         unsigned int nr_pages);
1464 void __memcg_kmem_uncharge(struct mem_cgroup *memcg, unsigned int nr_pages);
1465 int __memcg_kmem_charge_page(struct page *page, gfp_t gfp, int order);
1466 void __memcg_kmem_uncharge_page(struct page *page, int order);
1467
1468 struct obj_cgroup *get_obj_cgroup_from_current(void);
1469
1470 int obj_cgroup_charge(struct obj_cgroup *objcg, gfp_t gfp, size_t size);
1471 void obj_cgroup_uncharge(struct obj_cgroup *objcg, size_t size);
1472
1473 extern struct static_key_false memcg_kmem_enabled_key;
1474
1475 extern int memcg_nr_cache_ids;
1476 void memcg_get_cache_ids(void);
1477 void memcg_put_cache_ids(void);
1478
1479 /*
1480  * Helper macro to loop through all memcg-specific caches. Callers must still
1481  * check if the cache is valid (it is either valid or NULL).
1482  * the slab_mutex must be held when looping through those caches
1483  */
1484 #define for_each_memcg_cache_index(_idx)        \
1485         for ((_idx) = 0; (_idx) < memcg_nr_cache_ids; (_idx)++)
1486
1487 static inline bool memcg_kmem_enabled(void)
1488 {
1489         return static_branch_likely(&memcg_kmem_enabled_key);
1490 }
1491
1492 static inline bool memcg_kmem_bypass(void)
1493 {
1494         if (in_interrupt())
1495                 return true;
1496
1497         /* Allow remote memcg charging in kthread contexts. */
1498         if ((!current->mm || (current->flags & PF_KTHREAD)) &&
1499              !current->active_memcg)
1500                 return true;
1501         return false;
1502 }
1503
1504 static inline int memcg_kmem_charge_page(struct page *page, gfp_t gfp,
1505                                          int order)
1506 {
1507         if (memcg_kmem_enabled())
1508                 return __memcg_kmem_charge_page(page, gfp, order);
1509         return 0;
1510 }
1511
1512 static inline void memcg_kmem_uncharge_page(struct page *page, int order)
1513 {
1514         if (memcg_kmem_enabled())
1515                 __memcg_kmem_uncharge_page(page, order);
1516 }
1517
1518 static inline int memcg_kmem_charge(struct mem_cgroup *memcg, gfp_t gfp,
1519                                     unsigned int nr_pages)
1520 {
1521         if (memcg_kmem_enabled())
1522                 return __memcg_kmem_charge(memcg, gfp, nr_pages);
1523         return 0;
1524 }
1525
1526 static inline void memcg_kmem_uncharge(struct mem_cgroup *memcg,
1527                                        unsigned int nr_pages)
1528 {
1529         if (memcg_kmem_enabled())
1530                 __memcg_kmem_uncharge(memcg, nr_pages);
1531 }
1532
1533 /*
1534  * helper for accessing a memcg's index. It will be used as an index in the
1535  * child cache array in kmem_cache, and also to derive its name. This function
1536  * will return -1 when this is not a kmem-limited memcg.
1537  */
1538 static inline int memcg_cache_id(struct mem_cgroup *memcg)
1539 {
1540         return memcg ? memcg->kmemcg_id : -1;
1541 }
1542
1543 struct mem_cgroup *mem_cgroup_from_obj(void *p);
1544
1545 #else
1546
1547 static inline int memcg_kmem_charge_page(struct page *page, gfp_t gfp,
1548                                          int order)
1549 {
1550         return 0;
1551 }
1552
1553 static inline void memcg_kmem_uncharge_page(struct page *page, int order)
1554 {
1555 }
1556
1557 static inline int __memcg_kmem_charge_page(struct page *page, gfp_t gfp,
1558                                            int order)
1559 {
1560         return 0;
1561 }
1562
1563 static inline void __memcg_kmem_uncharge_page(struct page *page, int order)
1564 {
1565 }
1566
1567 #define for_each_memcg_cache_index(_idx)        \
1568         for (; NULL; )
1569
1570 static inline bool memcg_kmem_enabled(void)
1571 {
1572         return false;
1573 }
1574
1575 static inline int memcg_cache_id(struct mem_cgroup *memcg)
1576 {
1577         return -1;
1578 }
1579
1580 static inline void memcg_get_cache_ids(void)
1581 {
1582 }
1583
1584 static inline void memcg_put_cache_ids(void)
1585 {
1586 }
1587
1588 static inline struct mem_cgroup *mem_cgroup_from_obj(void *p)
1589 {
1590        return NULL;
1591 }
1592
1593 #endif /* CONFIG_MEMCG_KMEM */
1594
1595 #endif /* _LINUX_MEMCONTROL_H */