Balbir Singh | 8cdea7c | 2008-02-07 00:13:50 -0800 | [diff] [blame] | 1 | /* memcontrol.h - Memory Controller |
| 2 | * |
| 3 | * Copyright IBM Corporation, 2007 |
| 4 | * Author Balbir Singh <balbir@linux.vnet.ibm.com> |
| 5 | * |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 6 | * Copyright 2007 OpenVZ SWsoft Inc |
| 7 | * Author: Pavel Emelianov <xemul@openvz.org> |
| 8 | * |
Balbir Singh | 8cdea7c | 2008-02-07 00:13:50 -0800 | [diff] [blame] | 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 |
Hirokazu Takahashi | f8d66542 | 2009-01-07 18:08:02 -0800 | [diff] [blame] | 22 | #include <linux/cgroup.h> |
Ying Han | 456f998 | 2011-05-26 16:25:38 -0700 | [diff] [blame] | 23 | #include <linux/vm_event_item.h> |
| 24 | |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 25 | struct mem_cgroup; |
| 26 | struct page_cgroup; |
Balbir Singh | 8697d33 | 2008-02-07 00:13:59 -0800 | [diff] [blame] | 27 | struct page; |
| 28 | struct mm_struct; |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 29 | |
Greg Thelen | 2a7106f | 2011-01-13 15:47:37 -0800 | [diff] [blame] | 30 | /* Stats that can be updated by kernel. */ |
| 31 | enum mem_cgroup_page_stat_item { |
| 32 | MEMCG_NR_FILE_MAPPED, /* # of pages charged as file rss */ |
| 33 | }; |
| 34 | |
Johannes Weiner | 5660048 | 2012-01-12 17:17:59 -0800 | [diff] [blame] | 35 | struct mem_cgroup_reclaim_cookie { |
| 36 | struct zone *zone; |
| 37 | int priority; |
| 38 | unsigned int generation; |
| 39 | }; |
| 40 | |
Balbir Singh | 00f0b82 | 2008-03-04 14:28:39 -0800 | [diff] [blame] | 41 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR |
KAMEZAWA Hiroyuki | 2c26fdd | 2009-01-07 18:08:10 -0800 | [diff] [blame] | 42 | /* |
| 43 | * All "charge" functions with gfp_mask should use GFP_KERNEL or |
| 44 | * (gfp_mask & GFP_RECLAIM_MASK). In current implementatin, memcg doesn't |
| 45 | * alloc memory but reclaims memory from all available zones. So, "where I want |
| 46 | * memory from" bits of gfp_mask has no meaning. So any bits of that field is |
| 47 | * available but adding a rule is better. charge functions' gfp_mask should |
| 48 | * be set to GFP_KERNEL or gfp_mask & GFP_RECLAIM_MASK for avoiding ambiguous |
| 49 | * codes. |
| 50 | * (Of course, if memcg does memory allocation in future, GFP_KERNEL is sane.) |
| 51 | */ |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 52 | |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 53 | extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, |
Balbir Singh | e1a1cd5 | 2008-02-07 00:14:02 -0800 | [diff] [blame] | 54 | gfp_t gfp_mask); |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 55 | /* for swap handling */ |
KAMEZAWA Hiroyuki | 8c7c6e34 | 2009-01-07 18:08:00 -0800 | [diff] [blame] | 56 | extern int mem_cgroup_try_charge_swapin(struct mm_struct *mm, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 57 | struct page *page, gfp_t mask, struct mem_cgroup **memcgp); |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 58 | extern void mem_cgroup_commit_charge_swapin(struct page *page, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 59 | struct mem_cgroup *memcg); |
| 60 | extern void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg); |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 61 | |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 62 | extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm, |
| 63 | gfp_t gfp_mask); |
Johannes Weiner | 925b767 | 2012-01-12 17:18:15 -0800 | [diff] [blame] | 64 | |
| 65 | struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *); |
| 66 | struct lruvec *mem_cgroup_lru_add_list(struct zone *, struct page *, |
| 67 | enum lru_list); |
| 68 | void mem_cgroup_lru_del_list(struct page *, enum lru_list); |
| 69 | void mem_cgroup_lru_del(struct page *); |
| 70 | struct lruvec *mem_cgroup_lru_move_lists(struct zone *, struct page *, |
| 71 | enum lru_list, enum lru_list); |
KAMEZAWA Hiroyuki | 569b846 | 2009-12-15 16:47:03 -0800 | [diff] [blame] | 72 | |
| 73 | /* For coalescing uncharge for reducing memcg' overhead*/ |
| 74 | extern void mem_cgroup_uncharge_start(void); |
| 75 | extern void mem_cgroup_uncharge_end(void); |
| 76 | |
Balbir Singh | 3c541e1 | 2008-02-07 00:14:41 -0800 | [diff] [blame] | 77 | extern void mem_cgroup_uncharge_page(struct page *page); |
KAMEZAWA Hiroyuki | 69029cd | 2008-07-25 01:47:14 -0700 | [diff] [blame] | 78 | extern void mem_cgroup_uncharge_cache_page(struct page *page); |
KAMEZAWA Hiroyuki | c9b0ed5 | 2008-07-25 01:47:15 -0700 | [diff] [blame] | 79 | |
David Rientjes | e845e19 | 2012-03-21 16:34:10 -0700 | [diff] [blame] | 80 | extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask, |
| 81 | int order); |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 82 | int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *memcg); |
David Rientjes | 3062fc6 | 2008-02-07 00:14:03 -0800 | [diff] [blame] | 83 | |
Wu Fengguang | e42d9d5 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 84 | extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page); |
Balbir Singh | cf475ad | 2008-04-29 01:00:16 -0700 | [diff] [blame] | 85 | extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); |
KOSAKI Motohiro | a433658 | 2011-06-15 15:08:13 -0700 | [diff] [blame] | 86 | extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm); |
Balbir Singh | cf475ad | 2008-04-29 01:00:16 -0700 | [diff] [blame] | 87 | |
Glauber Costa | e1aab16 | 2011-12-11 21:47:03 +0000 | [diff] [blame] | 88 | extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg); |
Glauber Costa | d1a4c0b | 2011-12-11 21:47:04 +0000 | [diff] [blame] | 89 | extern struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont); |
Glauber Costa | e1aab16 | 2011-12-11 21:47:03 +0000 | [diff] [blame] | 90 | |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 91 | static inline |
| 92 | int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup) |
| 93 | { |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 94 | struct mem_cgroup *memcg; |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 95 | rcu_read_lock(); |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 96 | memcg = mem_cgroup_from_task(rcu_dereference((mm)->owner)); |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 97 | rcu_read_unlock(); |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 98 | return cgroup == memcg; |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 99 | } |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 100 | |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 101 | extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg); |
Wu Fengguang | d324236 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 102 | |
KAMEZAWA Hiroyuki | e8589cc | 2008-07-25 01:47:10 -0700 | [diff] [blame] | 103 | extern int |
akpm@linux-foundation.org | ac39cf8 | 2010-05-26 14:42:46 -0700 | [diff] [blame] | 104 | mem_cgroup_prepare_migration(struct page *page, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 105 | struct page *newpage, struct mem_cgroup **memcgp, gfp_t gfp_mask); |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 106 | extern void mem_cgroup_end_migration(struct mem_cgroup *memcg, |
Daisuke Nishimura | 50de1dd | 2011-01-13 15:47:43 -0800 | [diff] [blame] | 107 | struct page *oldpage, struct page *newpage, bool migration_ok); |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 108 | |
Johannes Weiner | 5660048 | 2012-01-12 17:17:59 -0800 | [diff] [blame] | 109 | struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *, |
| 110 | struct mem_cgroup *, |
| 111 | struct mem_cgroup_reclaim_cookie *); |
| 112 | void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *); |
| 113 | |
KAMEZAWA Hiroyuki | 58ae83d | 2008-02-07 00:14:32 -0800 | [diff] [blame] | 114 | /* |
| 115 | * For memory reclaim. |
| 116 | */ |
Johannes Weiner | 9b27297 | 2011-11-02 13:38:23 -0700 | [diff] [blame] | 117 | int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg, |
| 118 | struct zone *zone); |
| 119 | int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg, |
| 120 | struct zone *zone); |
Ying Han | 889976d | 2011-05-26 16:25:33 -0700 | [diff] [blame] | 121 | int mem_cgroup_select_victim_node(struct mem_cgroup *memcg); |
Ying Han | 1bac180 | 2011-05-26 16:25:36 -0700 | [diff] [blame] | 122 | unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, |
KAMEZAWA Hiroyuki | bb2a0de | 2011-07-26 16:08:22 -0700 | [diff] [blame] | 123 | int nid, int zid, unsigned int lrumask); |
KOSAKI Motohiro | 3e2f41f | 2009-01-07 18:08:20 -0800 | [diff] [blame] | 124 | struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg, |
| 125 | struct zone *zone); |
| 126 | struct zone_reclaim_stat* |
| 127 | mem_cgroup_get_reclaim_stat_from_page(struct page *page); |
Balbir Singh | e222432 | 2009-04-02 16:57:39 -0700 | [diff] [blame] | 128 | extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, |
| 129 | struct task_struct *p); |
KAMEZAWA Hiroyuki | ab936cb | 2012-01-12 17:17:44 -0800 | [diff] [blame] | 130 | extern void mem_cgroup_replace_page_cache(struct page *oldpage, |
| 131 | struct page *newpage); |
KAMEZAWA Hiroyuki | 58ae83d | 2008-02-07 00:14:32 -0800 | [diff] [blame] | 132 | |
KAMEZAWA Hiroyuki | c077719 | 2009-01-07 18:07:57 -0800 | [diff] [blame] | 133 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP |
| 134 | extern int do_swap_account; |
| 135 | #endif |
Hirokazu Takahashi | f8d66542 | 2009-01-07 18:08:02 -0800 | [diff] [blame] | 136 | |
| 137 | static inline bool mem_cgroup_disabled(void) |
| 138 | { |
| 139 | if (mem_cgroup_subsys.disabled) |
| 140 | return true; |
| 141 | return false; |
| 142 | } |
| 143 | |
KAMEZAWA Hiroyuki | 89c06bd | 2012-03-21 16:34:25 -0700 | [diff] [blame^] | 144 | void __mem_cgroup_begin_update_page_stat(struct page *page, bool *locked, |
| 145 | unsigned long *flags); |
| 146 | |
| 147 | static inline void mem_cgroup_begin_update_page_stat(struct page *page, |
| 148 | bool *locked, unsigned long *flags) |
| 149 | { |
| 150 | if (mem_cgroup_disabled()) |
| 151 | return; |
| 152 | rcu_read_lock(); |
| 153 | *locked = false; |
| 154 | return __mem_cgroup_begin_update_page_stat(page, locked, flags); |
| 155 | } |
| 156 | |
| 157 | void __mem_cgroup_end_update_page_stat(struct page *page, |
| 158 | unsigned long *flags); |
| 159 | static inline void mem_cgroup_end_update_page_stat(struct page *page, |
| 160 | bool *locked, unsigned long *flags) |
| 161 | { |
| 162 | if (mem_cgroup_disabled()) |
| 163 | return; |
| 164 | if (*locked) |
| 165 | __mem_cgroup_end_update_page_stat(page, flags); |
| 166 | rcu_read_unlock(); |
| 167 | } |
| 168 | |
Greg Thelen | 2a7106f | 2011-01-13 15:47:37 -0800 | [diff] [blame] | 169 | void mem_cgroup_update_page_stat(struct page *page, |
| 170 | enum mem_cgroup_page_stat_item idx, |
| 171 | int val); |
| 172 | |
| 173 | static inline void mem_cgroup_inc_page_stat(struct page *page, |
| 174 | enum mem_cgroup_page_stat_item idx) |
| 175 | { |
| 176 | mem_cgroup_update_page_stat(page, idx, 1); |
| 177 | } |
| 178 | |
| 179 | static inline void mem_cgroup_dec_page_stat(struct page *page, |
| 180 | enum mem_cgroup_page_stat_item idx) |
| 181 | { |
| 182 | mem_cgroup_update_page_stat(page, idx, -1); |
| 183 | } |
| 184 | |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 185 | unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, |
Ying Han | 0ae5e89 | 2011-05-26 16:25:25 -0700 | [diff] [blame] | 186 | gfp_t gfp_mask, |
| 187 | unsigned long *total_scanned); |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 188 | u64 mem_cgroup_get_limit(struct mem_cgroup *memcg); |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 189 | |
Ying Han | 456f998 | 2011-05-26 16:25:38 -0700 | [diff] [blame] | 190 | void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx); |
KAMEZAWA Hiroyuki | ca3e021 | 2011-01-20 14:44:24 -0800 | [diff] [blame] | 191 | #ifdef CONFIG_TRANSPARENT_HUGEPAGE |
KAMEZAWA Hiroyuki | e94c8a9 | 2012-01-12 17:18:20 -0800 | [diff] [blame] | 192 | void mem_cgroup_split_huge_fixup(struct page *head); |
KAMEZAWA Hiroyuki | ca3e021 | 2011-01-20 14:44:24 -0800 | [diff] [blame] | 193 | #endif |
| 194 | |
Daisuke Nishimura | f212ad7 | 2011-03-23 16:42:25 -0700 | [diff] [blame] | 195 | #ifdef CONFIG_DEBUG_VM |
| 196 | bool mem_cgroup_bad_page_check(struct page *page); |
| 197 | void mem_cgroup_print_bad_page(struct page *page); |
| 198 | #endif |
Balbir Singh | 00f0b82 | 2008-03-04 14:28:39 -0800 | [diff] [blame] | 199 | #else /* CONFIG_CGROUP_MEM_RES_CTLR */ |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 200 | struct mem_cgroup; |
| 201 | |
| 202 | static inline int mem_cgroup_newpage_charge(struct page *page, |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 203 | struct mm_struct *mm, gfp_t gfp_mask) |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 204 | { |
| 205 | return 0; |
| 206 | } |
| 207 | |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 208 | static inline int mem_cgroup_cache_charge(struct page *page, |
| 209 | struct mm_struct *mm, gfp_t gfp_mask) |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 210 | { |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 211 | return 0; |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 212 | } |
| 213 | |
KAMEZAWA Hiroyuki | 8c7c6e34 | 2009-01-07 18:08:00 -0800 | [diff] [blame] | 214 | static inline int mem_cgroup_try_charge_swapin(struct mm_struct *mm, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 215 | struct page *page, gfp_t gfp_mask, struct mem_cgroup **memcgp) |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 216 | { |
| 217 | return 0; |
| 218 | } |
| 219 | |
| 220 | static inline void mem_cgroup_commit_charge_swapin(struct page *page, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 221 | struct mem_cgroup *memcg) |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 222 | { |
| 223 | } |
| 224 | |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 225 | static inline void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *memcg) |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 226 | { |
| 227 | } |
| 228 | |
KAMEZAWA Hiroyuki | 569b846 | 2009-12-15 16:47:03 -0800 | [diff] [blame] | 229 | static inline void mem_cgroup_uncharge_start(void) |
| 230 | { |
| 231 | } |
| 232 | |
| 233 | static inline void mem_cgroup_uncharge_end(void) |
| 234 | { |
| 235 | } |
| 236 | |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 237 | static inline void mem_cgroup_uncharge_page(struct page *page) |
| 238 | { |
| 239 | } |
| 240 | |
KAMEZAWA Hiroyuki | 69029cd | 2008-07-25 01:47:14 -0700 | [diff] [blame] | 241 | static inline void mem_cgroup_uncharge_cache_page(struct page *page) |
| 242 | { |
| 243 | } |
| 244 | |
Johannes Weiner | 925b767 | 2012-01-12 17:18:15 -0800 | [diff] [blame] | 245 | static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone, |
| 246 | struct mem_cgroup *memcg) |
| 247 | { |
| 248 | return &zone->lruvec; |
| 249 | } |
| 250 | |
| 251 | static inline struct lruvec *mem_cgroup_lru_add_list(struct zone *zone, |
| 252 | struct page *page, |
| 253 | enum lru_list lru) |
| 254 | { |
| 255 | return &zone->lruvec; |
| 256 | } |
| 257 | |
| 258 | static inline void mem_cgroup_lru_del_list(struct page *page, enum lru_list lru) |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 259 | { |
| 260 | } |
| 261 | |
Johannes Weiner | 925b767 | 2012-01-12 17:18:15 -0800 | [diff] [blame] | 262 | static inline void mem_cgroup_lru_del(struct page *page) |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 263 | { |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 264 | } |
| 265 | |
Johannes Weiner | 925b767 | 2012-01-12 17:18:15 -0800 | [diff] [blame] | 266 | static inline struct lruvec *mem_cgroup_lru_move_lists(struct zone *zone, |
| 267 | struct page *page, |
| 268 | enum lru_list from, |
| 269 | enum lru_list to) |
Minchan Kim | 3f58a82 | 2011-03-22 16:32:53 -0700 | [diff] [blame] | 270 | { |
Johannes Weiner | 925b767 | 2012-01-12 17:18:15 -0800 | [diff] [blame] | 271 | return &zone->lruvec; |
Balbir Singh | 66e1707 | 2008-02-07 00:13:56 -0800 | [diff] [blame] | 272 | } |
| 273 | |
Wu Fengguang | e42d9d5 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 274 | static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page) |
| 275 | { |
| 276 | return NULL; |
| 277 | } |
| 278 | |
KOSAKI Motohiro | a433658 | 2011-06-15 15:08:13 -0700 | [diff] [blame] | 279 | static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm) |
| 280 | { |
| 281 | return NULL; |
| 282 | } |
| 283 | |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 284 | static inline int mm_match_cgroup(struct mm_struct *mm, |
| 285 | struct mem_cgroup *memcg) |
Balbir Singh | bed7161 | 2008-02-07 00:14:01 -0800 | [diff] [blame] | 286 | { |
David Rientjes | 60c12b1 | 2008-02-09 00:10:15 -0800 | [diff] [blame] | 287 | return 1; |
Balbir Singh | bed7161 | 2008-02-07 00:14:01 -0800 | [diff] [blame] | 288 | } |
| 289 | |
David Rientjes | 4c4a221 | 2008-02-07 00:14:06 -0800 | [diff] [blame] | 290 | static inline int task_in_mem_cgroup(struct task_struct *task, |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 291 | const struct mem_cgroup *memcg) |
David Rientjes | 4c4a221 | 2008-02-07 00:14:06 -0800 | [diff] [blame] | 292 | { |
| 293 | return 1; |
| 294 | } |
| 295 | |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 296 | static inline struct cgroup_subsys_state |
| 297 | *mem_cgroup_css(struct mem_cgroup *memcg) |
Wu Fengguang | d324236 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 298 | { |
| 299 | return NULL; |
| 300 | } |
| 301 | |
KAMEZAWA Hiroyuki | e8589cc | 2008-07-25 01:47:10 -0700 | [diff] [blame] | 302 | static inline int |
akpm@linux-foundation.org | ac39cf8 | 2010-05-26 14:42:46 -0700 | [diff] [blame] | 303 | mem_cgroup_prepare_migration(struct page *page, struct page *newpage, |
Johannes Weiner | 72835c8 | 2012-01-12 17:18:32 -0800 | [diff] [blame] | 304 | struct mem_cgroup **memcgp, gfp_t gfp_mask) |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 305 | { |
| 306 | return 0; |
| 307 | } |
| 308 | |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 309 | static inline void mem_cgroup_end_migration(struct mem_cgroup *memcg, |
Daisuke Nishimura | 50de1dd | 2011-01-13 15:47:43 -0800 | [diff] [blame] | 310 | struct page *oldpage, struct page *newpage, bool migration_ok) |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 311 | { |
| 312 | } |
| 313 | |
Johannes Weiner | 5660048 | 2012-01-12 17:17:59 -0800 | [diff] [blame] | 314 | static inline struct mem_cgroup * |
| 315 | mem_cgroup_iter(struct mem_cgroup *root, |
| 316 | struct mem_cgroup *prev, |
| 317 | struct mem_cgroup_reclaim_cookie *reclaim) |
| 318 | { |
| 319 | return NULL; |
| 320 | } |
| 321 | |
| 322 | static inline void mem_cgroup_iter_break(struct mem_cgroup *root, |
| 323 | struct mem_cgroup *prev) |
| 324 | { |
| 325 | } |
| 326 | |
Hirokazu Takahashi | f8d66542 | 2009-01-07 18:08:02 -0800 | [diff] [blame] | 327 | static inline bool mem_cgroup_disabled(void) |
| 328 | { |
| 329 | return true; |
| 330 | } |
KAMEZAWA Hiroyuki | a636b32 | 2009-01-07 18:08:08 -0800 | [diff] [blame] | 331 | |
KOSAKI Motohiro | 14797e2 | 2009-01-07 18:08:18 -0800 | [diff] [blame] | 332 | static inline int |
Johannes Weiner | 9b27297 | 2011-11-02 13:38:23 -0700 | [diff] [blame] | 333 | mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg, struct zone *zone) |
KOSAKI Motohiro | 14797e2 | 2009-01-07 18:08:18 -0800 | [diff] [blame] | 334 | { |
| 335 | return 1; |
| 336 | } |
| 337 | |
Rik van Riel | 56e49d2 | 2009-06-16 15:32:28 -0700 | [diff] [blame] | 338 | static inline int |
Johannes Weiner | 9b27297 | 2011-11-02 13:38:23 -0700 | [diff] [blame] | 339 | mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg, struct zone *zone) |
Rik van Riel | 56e49d2 | 2009-06-16 15:32:28 -0700 | [diff] [blame] | 340 | { |
| 341 | return 1; |
| 342 | } |
| 343 | |
KOSAKI Motohiro | a3d8e05 | 2009-01-07 18:08:19 -0800 | [diff] [blame] | 344 | static inline unsigned long |
KAMEZAWA Hiroyuki | bb2a0de | 2011-07-26 16:08:22 -0700 | [diff] [blame] | 345 | mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid, |
| 346 | unsigned int lru_mask) |
KOSAKI Motohiro | a3d8e05 | 2009-01-07 18:08:19 -0800 | [diff] [blame] | 347 | { |
| 348 | return 0; |
| 349 | } |
| 350 | |
| 351 | |
KOSAKI Motohiro | 3e2f41f | 2009-01-07 18:08:20 -0800 | [diff] [blame] | 352 | static inline struct zone_reclaim_stat* |
| 353 | mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg, struct zone *zone) |
| 354 | { |
| 355 | return NULL; |
| 356 | } |
| 357 | |
| 358 | static inline struct zone_reclaim_stat* |
| 359 | mem_cgroup_get_reclaim_stat_from_page(struct page *page) |
| 360 | { |
| 361 | return NULL; |
| 362 | } |
| 363 | |
Balbir Singh | e222432 | 2009-04-02 16:57:39 -0700 | [diff] [blame] | 364 | static inline void |
| 365 | mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p) |
| 366 | { |
| 367 | } |
| 368 | |
KAMEZAWA Hiroyuki | 89c06bd | 2012-03-21 16:34:25 -0700 | [diff] [blame^] | 369 | static inline void mem_cgroup_begin_update_page_stat(struct page *page, |
| 370 | bool *locked, unsigned long *flags) |
| 371 | { |
| 372 | } |
| 373 | |
| 374 | static inline void mem_cgroup_end_update_page_stat(struct page *page, |
| 375 | bool *locked, unsigned long *flags) |
| 376 | { |
| 377 | } |
| 378 | |
Greg Thelen | 2a7106f | 2011-01-13 15:47:37 -0800 | [diff] [blame] | 379 | static inline void mem_cgroup_inc_page_stat(struct page *page, |
| 380 | enum mem_cgroup_page_stat_item idx) |
| 381 | { |
| 382 | } |
| 383 | |
| 384 | static inline void mem_cgroup_dec_page_stat(struct page *page, |
| 385 | enum mem_cgroup_page_stat_item idx) |
Balbir Singh | d69b042 | 2009-06-17 16:26:34 -0700 | [diff] [blame] | 386 | { |
| 387 | } |
| 388 | |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 389 | static inline |
| 390 | unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, |
Ying Han | 0ae5e89 | 2011-05-26 16:25:25 -0700 | [diff] [blame] | 391 | gfp_t gfp_mask, |
| 392 | unsigned long *total_scanned) |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 393 | { |
| 394 | return 0; |
| 395 | } |
| 396 | |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 397 | static inline |
Raghavendra K T | c0ff4b8 | 2011-11-02 13:38:15 -0700 | [diff] [blame] | 398 | u64 mem_cgroup_get_limit(struct mem_cgroup *memcg) |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 399 | { |
| 400 | return 0; |
| 401 | } |
| 402 | |
KAMEZAWA Hiroyuki | e94c8a9 | 2012-01-12 17:18:20 -0800 | [diff] [blame] | 403 | static inline void mem_cgroup_split_huge_fixup(struct page *head) |
KAMEZAWA Hiroyuki | ca3e021 | 2011-01-20 14:44:24 -0800 | [diff] [blame] | 404 | { |
| 405 | } |
| 406 | |
Ying Han | 456f998 | 2011-05-26 16:25:38 -0700 | [diff] [blame] | 407 | static inline |
| 408 | void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx) |
| 409 | { |
| 410 | } |
KAMEZAWA Hiroyuki | ab936cb | 2012-01-12 17:17:44 -0800 | [diff] [blame] | 411 | static inline void mem_cgroup_replace_page_cache(struct page *oldpage, |
| 412 | struct page *newpage) |
| 413 | { |
| 414 | } |
Hugh Dickins | 31a7923 | 2012-03-21 16:34:18 -0700 | [diff] [blame] | 415 | #endif /* CONFIG_CGROUP_MEM_RES_CTLR */ |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 416 | |
Daisuke Nishimura | f212ad7 | 2011-03-23 16:42:25 -0700 | [diff] [blame] | 417 | #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM) |
| 418 | static inline bool |
| 419 | mem_cgroup_bad_page_check(struct page *page) |
| 420 | { |
| 421 | return false; |
| 422 | } |
| 423 | |
| 424 | static inline void |
| 425 | mem_cgroup_print_bad_page(struct page *page) |
| 426 | { |
| 427 | } |
| 428 | #endif |
| 429 | |
Glauber Costa | e1aab16 | 2011-12-11 21:47:03 +0000 | [diff] [blame] | 430 | enum { |
| 431 | UNDER_LIMIT, |
| 432 | SOFT_LIMIT, |
| 433 | OVER_LIMIT, |
| 434 | }; |
| 435 | |
| 436 | struct sock; |
| 437 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM |
| 438 | void sock_update_memcg(struct sock *sk); |
| 439 | void sock_release_memcg(struct sock *sk); |
| 440 | #else |
| 441 | static inline void sock_update_memcg(struct sock *sk) |
| 442 | { |
| 443 | } |
| 444 | static inline void sock_release_memcg(struct sock *sk) |
| 445 | { |
| 446 | } |
| 447 | #endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */ |
Balbir Singh | 8cdea7c | 2008-02-07 00:13:50 -0800 | [diff] [blame] | 448 | #endif /* _LINUX_MEMCONTROL_H */ |
| 449 | |