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