Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: /* memcontrol.h - Memory Controller 2: * 3: * Copyright IBM Corporation, 2007 4: * Author Balbir Singh <balbir@linux.vnet.ibm.com> 5: * 6: * Copyright 2007 OpenVZ SWsoft Inc 7: * Author: Pavel Emelianov <xemul@openvz.org> 8: * 9: * This program is free software; you can redistribute it and/or modify 10: * it under the terms of the GNU General Public License as published by 11: * the Free Software Foundation; either version 2 of the License, or 12: * (at your option) any later version. 13: * 14: * This program is distributed in the hope that it will be useful, 15: * but WITHOUT ANY WARRANTY; without even the implied warranty of 16: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17: * GNU General Public License for more details. 18: */ 19: 20: #ifndef _LINUX_MEMCONTROL_H 21: #define _LINUX_MEMCONTROL_H 22: #include <linux/cgroup.h> 23: #include <linux/vm_event_item.h> 24: #include <linux/hardirq.h> 25: #include <linux/jump_label.h> 26: 27: struct mem_cgroup; 28: struct page_cgroup; 29: struct page; 30: struct mm_struct; 31: struct kmem_cache; 32: 33: /* 34: * The corresponding mem_cgroup_stat_names is defined in mm/memcontrol.c, 35: * These two lists should keep in accord with each other. 36: */ 37: enum mem_cgroup_stat_index { 38: /* 39: * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss. 40: */ 41: MEM_CGROUP_STAT_CACHE, /* # of pages charged as cache */ 42: MEM_CGROUP_STAT_RSS, /* # of pages charged as anon rss */ 43: MEM_CGROUP_STAT_RSS_HUGE, /* # of pages charged as anon huge */ 44: MEM_CGROUP_STAT_FILE_MAPPED, /* # of pages charged as file rss */ 45: MEM_CGROUP_STAT_WRITEBACK, /* # of pages under writeback */ 46: MEM_CGROUP_STAT_SWAP, /* # of pages, swapped out */ 47: MEM_CGROUP_STAT_NSTATS, 48: }; 49: 50: struct mem_cgroup_reclaim_cookie { 51: struct zone *zone; 52: int priority; 53: unsigned int generation; 54: }; 55: 56: #ifdef CONFIG_MEMCG 57: /* 58: * All "charge" functions with gfp_mask should use GFP_KERNEL or 59: * (gfp_mask & GFP_RECLAIM_MASK). In current implementatin, memcg doesn't 60: * alloc memory but reclaims memory from all available zones. So, "where I want 61: * memory from" bits of gfp_mask has no meaning. So any bits of that field is 62: * available but adding a rule is better. charge functions' gfp_mask should 63: * be set to GFP_KERNEL or gfp_mask & GFP_RECLAIM_MASK for avoiding ambiguous 64: * codes. 65: * (Of course, if memcg does memory allocation in future, GFP_KERNEL is sane.) 66: */ 67: 68: extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, 69: gfp_t gfp_mask); 70: /* for swap handling */ 71: extern int mem_cgroup_try_charge_swapin(struct mm_struct *mm, 72: struct page *page, gfp_t mask, struct mem_cgroup **memcgp); 73: extern void mem_cgroup_commit_charge_swapin(struct page *page, 74: struct mem_cgroup *memcg); 75: extern void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg); 76: 77: extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm, 78: gfp_t gfp_mask); 79: 80: struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *); 81: struct lruvec *mem_cgroup_page_lruvec(struct page *, struct zone *); 82: 83: /* For coalescing uncharge for reducing memcg' overhead*/ 84: extern void mem_cgroup_uncharge_start(void); 85: extern void mem_cgroup_uncharge_end(void); 86: 87: extern void mem_cgroup_uncharge_page(struct page *page); 88: extern void mem_cgroup_uncharge_cache_page(struct page *page); 89: 90: bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg, 91: struct mem_cgroup *memcg); 92: bool task_in_mem_cgroup(struct task_struct *task, 93: const struct mem_cgroup *memcg); 94: 95: extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page); 96: extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); 97: extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm); 98: 99: extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg); 100: extern struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css); 101: 102: static inline 103: bool mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *memcg) 104: { 105: struct mem_cgroup *task_memcg; 106: bool match; 107: 108: rcu_read_lock(); 109: task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner)); 110: match = __mem_cgroup_same_or_subtree(memcg, task_memcg); 111: rcu_read_unlock(); 112: return match; 113: } 114: 115: extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg); 116: 117: extern void 118: mem_cgroup_prepare_migration(struct page *page, struct page *newpage, 119: struct mem_cgroup **memcgp); 120: extern void mem_cgroup_end_migration(struct mem_cgroup *memcg, 121: struct page *oldpage, struct page *newpage, bool migration_ok); 122: 123: struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *, 124: struct mem_cgroup *, 125: struct mem_cgroup_reclaim_cookie *); 126: void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *); 127: 128: /* 129: * For memory reclaim. 130: */ 131: int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec); 132: int mem_cgroup_select_victim_node(struct mem_cgroup *memcg); 133: unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list); 134: void mem_cgroup_update_lru_size(struct lruvec *, enum lru_list, int); 135: extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, 136: struct task_struct *p); 137: extern void mem_cgroup_replace_page_cache(struct page *oldpage, 138: struct page *newpage); 139: 140: static inline void mem_cgroup_oom_enable(void) 141: { 142: WARN_ON(current->memcg_oom.may_oom); 143: current->memcg_oom.may_oom = 1; 144: } 145: 146: static inline void mem_cgroup_oom_disable(void) 147: { 148: WARN_ON(!current->memcg_oom.may_oom); 149: current->memcg_oom.may_oom = 0; 150: } 151: 152: static inline bool task_in_memcg_oom(struct task_struct *p) 153: { 154: return p->memcg_oom.memcg; 155: } 156: 157: bool mem_cgroup_oom_synchronize(bool wait); 158: 159: #ifdef CONFIG_MEMCG_SWAP 160: extern int do_swap_account; 161: #endif 162: 163: static inline bool mem_cgroup_disabled(void) 164: { 165: if (mem_cgroup_subsys.disabled) 166: return true; 167: return false; 168: } 169: 170: void __mem_cgroup_begin_update_page_stat(struct page *page, bool *locked, 171: unsigned long *flags); 172: 173: extern atomic_t memcg_moving; 174: 175: static inline void mem_cgroup_begin_update_page_stat(struct page *page, 176: bool *locked, unsigned long *flags) 177: { 178: if (mem_cgroup_disabled()) 179: return; 180: rcu_read_lock(); 181: *locked = false; 182: if (atomic_read(&memcg_moving)) 183: __mem_cgroup_begin_update_page_stat(page, locked, flags); 184: } 185: 186: void __mem_cgroup_end_update_page_stat(struct page *page, 187: unsigned long *flags); 188: static inline void mem_cgroup_end_update_page_stat(struct page *page, 189: bool *locked, unsigned long *flags) 190: { 191: if (mem_cgroup_disabled()) 192: return; 193: if (*locked) 194: __mem_cgroup_end_update_page_stat(page, flags); 195: rcu_read_unlock(); 196: } 197: 198: void mem_cgroup_update_page_stat(struct page *page, 199: enum mem_cgroup_stat_index idx, 200: int val); 201: 202: static inline void mem_cgroup_inc_page_stat(struct page *page, 203: enum mem_cgroup_stat_index idx) 204: { 205: mem_cgroup_update_page_stat(page, idx, 1); 206: } 207: 208: static inline void mem_cgroup_dec_page_stat(struct page *page, 209: enum mem_cgroup_stat_index idx) 210: { 211: mem_cgroup_update_page_stat(page, idx, -1); 212: } 213: 214: unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, 215: gfp_t gfp_mask, 216: unsigned long *total_scanned); 217: 218: void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx); 219: static inline void mem_cgroup_count_vm_event(struct mm_struct *mm, 220: enum vm_event_item idx) 221: { 222: if (mem_cgroup_disabled()) 223: return; 224: __mem_cgroup_count_vm_event(mm, idx); 225: } 226: #ifdef CONFIG_TRANSPARENT_HUGEPAGE 227: void mem_cgroup_split_huge_fixup(struct page *head); 228: #endif 229: 230: #ifdef CONFIG_DEBUG_VM 231: bool mem_cgroup_bad_page_check(struct page *page); 232: void mem_cgroup_print_bad_page(struct page *page); 233: #endif 234: #else /* CONFIG_MEMCG */ 235: struct mem_cgroup; 236: 237: static inline int mem_cgroup_newpage_charge(struct page *page, 238: struct mm_struct *mm, gfp_t gfp_mask) 239: { 240: return 0; 241: } 242: 243: static inline int mem_cgroup_cache_charge(struct page *page, 244: struct mm_struct *mm, gfp_t gfp_mask) 245: { 246: return 0; 247: } 248: 249: static inline int mem_cgroup_try_charge_swapin(struct mm_struct *mm, 250: struct page *page, gfp_t gfp_mask, struct mem_cgroup **memcgp) 251: { 252: return 0; 253: } 254: 255: static inline void mem_cgroup_commit_charge_swapin(struct page *page, 256: struct mem_cgroup *memcg) 257: { 258: } 259: 260: static inline void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg) 261: { 262: } 263: 264: static inline void mem_cgroup_uncharge_start(void) 265: { 266: } 267: 268: static inline void mem_cgroup_uncharge_end(void) 269: { 270: } 271: 272: static inline void mem_cgroup_uncharge_page(struct page *page) 273: { 274: } 275: 276: static inline void mem_cgroup_uncharge_cache_page(struct page *page) 277: { 278: } 279: 280: static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone, 281: struct mem_cgroup *memcg) 282: { 283: return &zone->lruvec; 284: } 285: 286: static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page, 287: struct zone *zone) 288: { 289: return &zone->lruvec; 290: } 291: 292: static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page) 293: { 294: return NULL; 295: } 296: 297: static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm) 298: { 299: return NULL; 300: } 301: 302: static inline bool mm_match_cgroup(struct mm_struct *mm, 303: struct mem_cgroup *memcg) 304: { 305: return true; 306: } 307: 308: static inline bool task_in_mem_cgroup(struct task_struct *task, 309: const struct mem_cgroup *memcg) 310: { 311: return true; 312: } 313: 314: static inline struct cgroup_subsys_state 315: *mem_cgroup_css(struct mem_cgroup *memcg) 316: { 317: return NULL; 318: } 319: 320: static inline void 321: mem_cgroup_prepare_migration(struct page *page, struct page *newpage, 322: struct mem_cgroup **memcgp) 323: { 324: } 325: 326: static inline void mem_cgroup_end_migration(struct mem_cgroup *memcg, 327: struct page *oldpage, struct page *newpage, bool migration_ok) 328: { 329: } 330: 331: static inline struct mem_cgroup * 332: mem_cgroup_iter(struct mem_cgroup *root, 333: struct mem_cgroup *prev, 334: struct mem_cgroup_reclaim_cookie *reclaim) 335: { 336: return NULL; 337: } 338: 339: static inline void mem_cgroup_iter_break(struct mem_cgroup *root, 340: struct mem_cgroup *prev) 341: { 342: } 343: 344: static inline bool mem_cgroup_disabled(void) 345: { 346: return true; 347: } 348: 349: static inline int 350: mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec) 351: { 352: return 1; 353: } 354: 355: static inline unsigned long 356: mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru) 357: { 358: return 0; 359: } 360: 361: static inline void 362: mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru, 363: int increment) 364: { 365: } 366: 367: static inline void 368: mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p) 369: { 370: } 371: 372: static inline void mem_cgroup_begin_update_page_stat(struct page *page, 373: bool *locked, unsigned long *flags) 374: { 375: } 376: 377: static inline void mem_cgroup_end_update_page_stat(struct page *page, 378: bool *locked, unsigned long *flags) 379: { 380: } 381: 382: static inline void mem_cgroup_oom_enable(void) 383: { 384: } 385: 386: static inline void mem_cgroup_oom_disable(void) 387: { 388: } 389: 390: static inline bool task_in_memcg_oom(struct task_struct *p) 391: { 392: return false; 393: } 394: 395: static inline bool mem_cgroup_oom_synchronize(bool wait) 396: { 397: return false; 398: } 399: 400: static inline void mem_cgroup_inc_page_stat(struct page *page, 401: enum mem_cgroup_stat_index idx) 402: { 403: } 404: 405: static inline void mem_cgroup_dec_page_stat(struct page *page, 406: enum mem_cgroup_stat_index idx) 407: { 408: } 409: 410: static inline 411: unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, 412: gfp_t gfp_mask, 413: unsigned long *total_scanned) 414: { 415: return 0; 416: } 417: 418: static inline void mem_cgroup_split_huge_fixup(struct page *head) 419: { 420: } 421: 422: static inline 423: void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx) 424: { 425: } 426: static inline void mem_cgroup_replace_page_cache(struct page *oldpage, 427: struct page *newpage) 428: { 429: } 430: #endif /* CONFIG_MEMCG */ 431: 432: #if !defined(CONFIG_MEMCG) || !defined(CONFIG_DEBUG_VM) 433: static inline bool 434: mem_cgroup_bad_page_check(struct page *page) 435: { 436: return false; 437: } 438: 439: static inline void 440: mem_cgroup_print_bad_page(struct page *page) 441: { 442: } 443: #endif 444: 445: enum { 446: UNDER_LIMIT, 447: SOFT_LIMIT, 448: OVER_LIMIT, 449: }; 450: 451: struct sock; 452: #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM) 453: void sock_update_memcg(struct sock *sk); 454: void sock_release_memcg(struct sock *sk); 455: #else 456: static inline void sock_update_memcg(struct sock *sk) 457: { 458: } 459: static inline void sock_release_memcg(struct sock *sk) 460: { 461: } 462: #endif /* CONFIG_INET && CONFIG_MEMCG_KMEM */ 463: 464: #ifdef CONFIG_MEMCG_KMEM 465: extern struct static_key memcg_kmem_enabled_key; 466: 467: extern int memcg_limited_groups_array_size; 468: 469: /* 470: * Helper macro to loop through all memcg-specific caches. Callers must still 471: * check if the cache is valid (it is either valid or NULL). 472: * the slab_mutex must be held when looping through those caches 473: */ 474: #define for_each_memcg_cache_index(_idx) \ 475: for ((_idx) = 0; (_idx) < memcg_limited_groups_array_size; (_idx)++) 476: 477: static inline bool memcg_kmem_enabled(void) 478: { 479: return static_key_false(&memcg_kmem_enabled_key); 480: } 481: 482: /* 483: * In general, we'll do everything in our power to not incur in any overhead 484: * for non-memcg users for the kmem functions. Not even a function call, if we 485: * can avoid it. 486: * 487: * Therefore, we'll inline all those functions so that in the best case, we'll 488: * see that kmemcg is off for everybody and proceed quickly. If it is on, 489: * we'll still do most of the flag checking inline. We check a lot of 490: * conditions, but because they are pretty simple, they are expected to be 491: * fast. 492: */ 493: bool __memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, 494: int order); 495: void __memcg_kmem_commit_charge(struct page *page, 496: struct mem_cgroup *memcg, int order); 497: void __memcg_kmem_uncharge_pages(struct page *page, int order); 498: 499: int memcg_cache_id(struct mem_cgroup *memcg); 500: int memcg_register_cache(struct mem_cgroup *memcg, struct kmem_cache *s, 501: struct kmem_cache *root_cache); 502: void memcg_release_cache(struct kmem_cache *cachep); 503: void memcg_cache_list_add(struct mem_cgroup *memcg, struct kmem_cache *cachep); 504: 505: int memcg_update_cache_size(struct kmem_cache *s, int num_groups); 506: void memcg_update_array_size(int num_groups); 507: 508: struct kmem_cache * 509: __memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp); 510: 511: void mem_cgroup_destroy_cache(struct kmem_cache *cachep); 512: void kmem_cache_destroy_memcg_children(struct kmem_cache *s); 513: 514: /** 515: * memcg_kmem_newpage_charge: verify if a new kmem allocation is allowed. 516: * @gfp: the gfp allocation flags. 517: * @memcg: a pointer to the memcg this was charged against. 518: * @order: allocation order. 519: * 520: * returns true if the memcg where the current task belongs can hold this 521: * allocation. 522: * 523: * We return true automatically if this allocation is not to be accounted to 524: * any memcg. 525: */ 526: static inline bool 527: memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order) 528: { 529: if (!memcg_kmem_enabled()) 530: return true; 531: 532: /* 533: * __GFP_NOFAIL allocations will move on even if charging is not 534: * possible. Therefore we don't even try, and have this allocation 535: * unaccounted. We could in theory charge it with 536: * res_counter_charge_nofail, but we hope those allocations are rare, 537: * and won't be worth the trouble. 538: */ 539: if (!(gfp & __GFP_KMEMCG) || (gfp & __GFP_NOFAIL)) 540: return true; 541: if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD)) 542: return true; 543: 544: /* If the test is dying, just let it go. */ 545: if (unlikely(fatal_signal_pending(current))) 546: return true; 547: 548: return __memcg_kmem_newpage_charge(gfp, memcg, order); 549: } 550: 551: /** 552: * memcg_kmem_uncharge_pages: uncharge pages from memcg 553: * @page: pointer to struct page being freed 554: * @order: allocation order. 555: * 556: * there is no need to specify memcg here, since it is embedded in page_cgroup 557: */ 558: static inline void 559: memcg_kmem_uncharge_pages(struct page *page, int order) 560: { 561: if (memcg_kmem_enabled()) 562: __memcg_kmem_uncharge_pages(page, order); 563: } 564: 565: /** 566: * memcg_kmem_commit_charge: embeds correct memcg in a page 567: * @page: pointer to struct page recently allocated 568: * @memcg: the memcg structure we charged against 569: * @order: allocation order. 570: * 571: * Needs to be called after memcg_kmem_newpage_charge, regardless of success or 572: * failure of the allocation. if @page is NULL, this function will revert the 573: * charges. Otherwise, it will commit the memcg given by @memcg to the 574: * corresponding page_cgroup. 575: */ 576: static inline void 577: memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order) 578: { 579: if (memcg_kmem_enabled() && memcg) 580: __memcg_kmem_commit_charge(page, memcg, order); 581: } 582: 583: /** 584: * memcg_kmem_get_cache: selects the correct per-memcg cache for allocation 585: * @cachep: the original global kmem cache 586: * @gfp: allocation flags. 587: * 588: * This function assumes that the task allocating, which determines the memcg 589: * in the page allocator, belongs to the same cgroup throughout the whole 590: * process. Misacounting can happen if the task calls memcg_kmem_get_cache() 591: * while belonging to a cgroup, and later on changes. This is considered 592: * acceptable, and should only happen upon task migration. 593: * 594: * Before the cache is created by the memcg core, there is also a possible 595: * imbalance: the task belongs to a memcg, but the cache being allocated from 596: * is the global cache, since the child cache is not yet guaranteed to be 597: * ready. This case is also fine, since in this case the GFP_KMEMCG will not be 598: * passed and the page allocator will not attempt any cgroup accounting. 599: */ 600: static __always_inline struct kmem_cache * 601: memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp) 602: { 603: if (!memcg_kmem_enabled()) 604: return cachep; 605: if (gfp & __GFP_NOFAIL) 606: return cachep; 607: if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD)) 608: return cachep; 609: if (unlikely(fatal_signal_pending(current))) 610: return cachep; 611: 612: return __memcg_kmem_get_cache(cachep, gfp); 613: } 614: #else 615: #define for_each_memcg_cache_index(_idx) \ 616: for (; NULL; ) 617: 618: static inline bool memcg_kmem_enabled(void) 619: { 620: return false; 621: } 622: 623: static inline bool 624: memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order) 625: { 626: return true; 627: } 628: 629: static inline void memcg_kmem_uncharge_pages(struct page *page, int order) 630: { 631: } 632: 633: static inline void 634: memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order) 635: { 636: } 637: 638: static inline int memcg_cache_id(struct mem_cgroup *memcg) 639: { 640: return -1; 641: } 642: 643: static inline int 644: memcg_register_cache(struct mem_cgroup *memcg, struct kmem_cache *s, 645: struct kmem_cache *root_cache) 646: { 647: return 0; 648: } 649: 650: static inline void memcg_release_cache(struct kmem_cache *cachep) 651: { 652: } 653: 654: static inline void memcg_cache_list_add(struct mem_cgroup *memcg, 655: struct kmem_cache *s) 656: { 657: } 658: 659: static inline struct kmem_cache * 660: memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp) 661: { 662: return cachep; 663: } 664: 665: static inline void kmem_cache_destroy_memcg_children(struct kmem_cache *s) 666: { 667: } 668: #endif /* CONFIG_MEMCG_KMEM */ 669: #endif /* _LINUX_MEMCONTROL_H */ 670: 671: