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 | 8b25c6d | 2010-05-24 14:32:40 -0700 | [diff] [blame] | 35 | extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan, |
| 36 | struct list_head *dst, |
| 37 | unsigned long *scanned, int order, |
| 38 | int mode, struct zone *z, |
| 39 | struct mem_cgroup *mem_cont, |
| 40 | int active, int file); |
| 41 | |
Balbir Singh | 00f0b82 | 2008-03-04 14:28:39 -0800 | [diff] [blame] | 42 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR |
KAMEZAWA Hiroyuki | 2c26fdd | 2009-01-07 18:08:10 -0800 | [diff] [blame] | 43 | /* |
| 44 | * All "charge" functions with gfp_mask should use GFP_KERNEL or |
| 45 | * (gfp_mask & GFP_RECLAIM_MASK). In current implementatin, memcg doesn't |
| 46 | * alloc memory but reclaims memory from all available zones. So, "where I want |
| 47 | * memory from" bits of gfp_mask has no meaning. So any bits of that field is |
| 48 | * available but adding a rule is better. charge functions' gfp_mask should |
| 49 | * be set to GFP_KERNEL or gfp_mask & GFP_RECLAIM_MASK for avoiding ambiguous |
| 50 | * codes. |
| 51 | * (Of course, if memcg does memory allocation in future, GFP_KERNEL is sane.) |
| 52 | */ |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 53 | |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 54 | 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] | 55 | gfp_t gfp_mask); |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 56 | /* for swap handling */ |
KAMEZAWA Hiroyuki | 8c7c6e34 | 2009-01-07 18:08:00 -0800 | [diff] [blame] | 57 | extern int mem_cgroup_try_charge_swapin(struct mm_struct *mm, |
| 58 | struct page *page, gfp_t mask, struct mem_cgroup **ptr); |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 59 | extern void mem_cgroup_commit_charge_swapin(struct page *page, |
| 60 | struct mem_cgroup *ptr); |
| 61 | extern void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *ptr); |
| 62 | |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 63 | extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm, |
| 64 | gfp_t gfp_mask); |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 65 | extern void mem_cgroup_add_lru_list(struct page *page, enum lru_list lru); |
| 66 | extern void mem_cgroup_del_lru_list(struct page *page, enum lru_list lru); |
Minchan Kim | 3f58a82 | 2011-03-22 16:32:53 -0700 | [diff] [blame] | 67 | extern void mem_cgroup_rotate_reclaimable_page(struct page *page); |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 68 | extern void mem_cgroup_rotate_lru_list(struct page *page, enum lru_list lru); |
| 69 | extern void mem_cgroup_del_lru(struct page *page); |
| 70 | extern void mem_cgroup_move_lists(struct page *page, |
| 71 | enum lru_list from, enum lru_list to); |
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 | |
Pavel Emelianov | c7ba5c9 | 2008-02-07 00:13:58 -0800 | [diff] [blame] | 80 | extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask); |
David Rientjes | 4c4a221 | 2008-02-07 00:14:06 -0800 | [diff] [blame] | 81 | int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem); |
David Rientjes | 3062fc6 | 2008-02-07 00:14:03 -0800 | [diff] [blame] | 82 | |
Wu Fengguang | e42d9d5 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 83 | 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] | 84 | extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); |
KOSAKI Motohiro | a433658 | 2011-06-15 15:08:13 -0700 | [diff] [blame] | 85 | 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] | 86 | |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 87 | static inline |
| 88 | int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup) |
| 89 | { |
| 90 | struct mem_cgroup *mem; |
| 91 | rcu_read_lock(); |
KAMEZAWA Hiroyuki | e638c13 | 2009-04-21 12:24:41 -0700 | [diff] [blame] | 92 | mem = mem_cgroup_from_task(rcu_dereference((mm)->owner)); |
Lai Jiangshan | 2e4d409 | 2009-01-07 18:08:07 -0800 | [diff] [blame] | 93 | rcu_read_unlock(); |
| 94 | return cgroup == mem; |
| 95 | } |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 96 | |
Wu Fengguang | d324236 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 97 | extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem); |
| 98 | |
KAMEZAWA Hiroyuki | e8589cc | 2008-07-25 01:47:10 -0700 | [diff] [blame] | 99 | extern int |
akpm@linux-foundation.org | ac39cf8 | 2010-05-26 14:42:46 -0700 | [diff] [blame] | 100 | mem_cgroup_prepare_migration(struct page *page, |
Miklos Szeredi | ef6a3c6 | 2011-03-22 16:30:52 -0700 | [diff] [blame] | 101 | struct page *newpage, struct mem_cgroup **ptr, gfp_t gfp_mask); |
KAMEZAWA Hiroyuki | 01b1ae6 | 2009-01-07 18:07:50 -0800 | [diff] [blame] | 102 | extern void mem_cgroup_end_migration(struct mem_cgroup *mem, |
Daisuke Nishimura | 50de1dd | 2011-01-13 15:47:43 -0800 | [diff] [blame] | 103 | struct page *oldpage, struct page *newpage, bool migration_ok); |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 104 | |
KAMEZAWA Hiroyuki | 58ae83d | 2008-02-07 00:14:32 -0800 | [diff] [blame] | 105 | /* |
| 106 | * For memory reclaim. |
| 107 | */ |
KOSAKI Motohiro | c772be9 | 2009-01-07 18:08:25 -0800 | [diff] [blame] | 108 | int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg); |
Rik van Riel | 56e49d2 | 2009-06-16 15:32:28 -0700 | [diff] [blame] | 109 | int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg); |
Ying Han | 889976d | 2011-05-26 16:25:33 -0700 | [diff] [blame] | 110 | int mem_cgroup_select_victim_node(struct mem_cgroup *memcg); |
Ying Han | 1bac180 | 2011-05-26 16:25:36 -0700 | [diff] [blame] | 111 | unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, |
KAMEZAWA Hiroyuki | bb2a0de | 2011-07-26 16:08:22 -0700 | [diff] [blame] | 112 | int nid, int zid, unsigned int lrumask); |
KOSAKI Motohiro | 3e2f41f | 2009-01-07 18:08:20 -0800 | [diff] [blame] | 113 | struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg, |
| 114 | struct zone *zone); |
| 115 | struct zone_reclaim_stat* |
| 116 | mem_cgroup_get_reclaim_stat_from_page(struct page *page); |
Balbir Singh | e222432 | 2009-04-02 16:57:39 -0700 | [diff] [blame] | 117 | extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, |
| 118 | struct task_struct *p); |
KAMEZAWA Hiroyuki | 58ae83d | 2008-02-07 00:14:32 -0800 | [diff] [blame] | 119 | |
KAMEZAWA Hiroyuki | c077719 | 2009-01-07 18:07:57 -0800 | [diff] [blame] | 120 | #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP |
| 121 | extern int do_swap_account; |
| 122 | #endif |
Hirokazu Takahashi | f8d66542 | 2009-01-07 18:08:02 -0800 | [diff] [blame] | 123 | |
| 124 | static inline bool mem_cgroup_disabled(void) |
| 125 | { |
| 126 | if (mem_cgroup_subsys.disabled) |
| 127 | return true; |
| 128 | return false; |
| 129 | } |
| 130 | |
Greg Thelen | 2a7106f | 2011-01-13 15:47:37 -0800 | [diff] [blame] | 131 | void mem_cgroup_update_page_stat(struct page *page, |
| 132 | enum mem_cgroup_page_stat_item idx, |
| 133 | int val); |
| 134 | |
| 135 | static inline void mem_cgroup_inc_page_stat(struct page *page, |
| 136 | enum mem_cgroup_page_stat_item idx) |
| 137 | { |
| 138 | mem_cgroup_update_page_stat(page, idx, 1); |
| 139 | } |
| 140 | |
| 141 | static inline void mem_cgroup_dec_page_stat(struct page *page, |
| 142 | enum mem_cgroup_page_stat_item idx) |
| 143 | { |
| 144 | mem_cgroup_update_page_stat(page, idx, -1); |
| 145 | } |
| 146 | |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 147 | unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, |
Ying Han | 0ae5e89 | 2011-05-26 16:25:25 -0700 | [diff] [blame] | 148 | gfp_t gfp_mask, |
| 149 | unsigned long *total_scanned); |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 150 | u64 mem_cgroup_get_limit(struct mem_cgroup *mem); |
| 151 | |
Ying Han | 456f998 | 2011-05-26 16:25:38 -0700 | [diff] [blame] | 152 | 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] | 153 | #ifdef CONFIG_TRANSPARENT_HUGEPAGE |
| 154 | void mem_cgroup_split_huge_fixup(struct page *head, struct page *tail); |
| 155 | #endif |
| 156 | |
Daisuke Nishimura | f212ad7 | 2011-03-23 16:42:25 -0700 | [diff] [blame] | 157 | #ifdef CONFIG_DEBUG_VM |
| 158 | bool mem_cgroup_bad_page_check(struct page *page); |
| 159 | void mem_cgroup_print_bad_page(struct page *page); |
| 160 | #endif |
Balbir Singh | 00f0b82 | 2008-03-04 14:28:39 -0800 | [diff] [blame] | 161 | #else /* CONFIG_CGROUP_MEM_RES_CTLR */ |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 162 | struct mem_cgroup; |
| 163 | |
| 164 | static inline int mem_cgroup_newpage_charge(struct page *page, |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 165 | struct mm_struct *mm, gfp_t gfp_mask) |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 166 | { |
| 167 | return 0; |
| 168 | } |
| 169 | |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 170 | static inline int mem_cgroup_cache_charge(struct page *page, |
| 171 | struct mm_struct *mm, gfp_t gfp_mask) |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 172 | { |
Hugh Dickins | 8289546 | 2008-03-04 14:29:08 -0800 | [diff] [blame] | 173 | return 0; |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 174 | } |
| 175 | |
KAMEZAWA Hiroyuki | 8c7c6e34 | 2009-01-07 18:08:00 -0800 | [diff] [blame] | 176 | static inline int mem_cgroup_try_charge_swapin(struct mm_struct *mm, |
| 177 | struct page *page, gfp_t gfp_mask, struct mem_cgroup **ptr) |
KAMEZAWA Hiroyuki | 7a81b88 | 2009-01-07 18:07:48 -0800 | [diff] [blame] | 178 | { |
| 179 | return 0; |
| 180 | } |
| 181 | |
| 182 | static inline void mem_cgroup_commit_charge_swapin(struct page *page, |
| 183 | struct mem_cgroup *ptr) |
| 184 | { |
| 185 | } |
| 186 | |
| 187 | static inline void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *ptr) |
| 188 | { |
| 189 | } |
| 190 | |
KAMEZAWA Hiroyuki | 569b846 | 2009-12-15 16:47:03 -0800 | [diff] [blame] | 191 | static inline void mem_cgroup_uncharge_start(void) |
| 192 | { |
| 193 | } |
| 194 | |
| 195 | static inline void mem_cgroup_uncharge_end(void) |
| 196 | { |
| 197 | } |
| 198 | |
Balbir Singh | 8a9f3cc | 2008-02-07 00:13:53 -0800 | [diff] [blame] | 199 | static inline void mem_cgroup_uncharge_page(struct page *page) |
| 200 | { |
| 201 | } |
| 202 | |
KAMEZAWA Hiroyuki | 69029cd | 2008-07-25 01:47:14 -0700 | [diff] [blame] | 203 | static inline void mem_cgroup_uncharge_cache_page(struct page *page) |
| 204 | { |
| 205 | } |
| 206 | |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 207 | static inline void mem_cgroup_add_lru_list(struct page *page, int lru) |
| 208 | { |
| 209 | } |
| 210 | |
| 211 | static inline void mem_cgroup_del_lru_list(struct page *page, int lru) |
| 212 | { |
| 213 | return ; |
| 214 | } |
| 215 | |
Eric Dumazet | 67954fe | 2011-04-14 15:21:52 -0700 | [diff] [blame] | 216 | static inline void mem_cgroup_rotate_reclaimable_page(struct page *page) |
Minchan Kim | 3f58a82 | 2011-03-22 16:32:53 -0700 | [diff] [blame] | 217 | { |
| 218 | return ; |
| 219 | } |
| 220 | |
KAMEZAWA Hiroyuki | 08e552c | 2009-01-07 18:08:01 -0800 | [diff] [blame] | 221 | static inline void mem_cgroup_rotate_lru_list(struct page *page, int lru) |
| 222 | { |
| 223 | return ; |
| 224 | } |
| 225 | |
| 226 | static inline void mem_cgroup_del_lru(struct page *page) |
| 227 | { |
| 228 | return ; |
| 229 | } |
| 230 | |
| 231 | static inline void |
| 232 | mem_cgroup_move_lists(struct page *page, enum lru_list from, enum lru_list to) |
Balbir Singh | 66e1707 | 2008-02-07 00:13:56 -0800 | [diff] [blame] | 233 | { |
| 234 | } |
| 235 | |
Wu Fengguang | e42d9d5 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 236 | static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page) |
| 237 | { |
| 238 | return NULL; |
| 239 | } |
| 240 | |
KOSAKI Motohiro | a433658 | 2011-06-15 15:08:13 -0700 | [diff] [blame] | 241 | static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm) |
| 242 | { |
| 243 | return NULL; |
| 244 | } |
| 245 | |
Hugh Dickins | bd845e3 | 2008-03-04 14:29:01 -0800 | [diff] [blame] | 246 | static inline int mm_match_cgroup(struct mm_struct *mm, struct mem_cgroup *mem) |
Balbir Singh | bed7161 | 2008-02-07 00:14:01 -0800 | [diff] [blame] | 247 | { |
David Rientjes | 60c12b1 | 2008-02-09 00:10:15 -0800 | [diff] [blame] | 248 | return 1; |
Balbir Singh | bed7161 | 2008-02-07 00:14:01 -0800 | [diff] [blame] | 249 | } |
| 250 | |
David Rientjes | 4c4a221 | 2008-02-07 00:14:06 -0800 | [diff] [blame] | 251 | static inline int task_in_mem_cgroup(struct task_struct *task, |
| 252 | const struct mem_cgroup *mem) |
| 253 | { |
| 254 | return 1; |
| 255 | } |
| 256 | |
Wu Fengguang | d324236 | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 257 | static inline struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem) |
| 258 | { |
| 259 | return NULL; |
| 260 | } |
| 261 | |
KAMEZAWA Hiroyuki | e8589cc | 2008-07-25 01:47:10 -0700 | [diff] [blame] | 262 | static inline int |
akpm@linux-foundation.org | ac39cf8 | 2010-05-26 14:42:46 -0700 | [diff] [blame] | 263 | mem_cgroup_prepare_migration(struct page *page, struct page *newpage, |
Miklos Szeredi | ef6a3c6 | 2011-03-22 16:30:52 -0700 | [diff] [blame] | 264 | struct mem_cgroup **ptr, gfp_t gfp_mask) |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 265 | { |
| 266 | return 0; |
| 267 | } |
| 268 | |
KAMEZAWA Hiroyuki | 01b1ae6 | 2009-01-07 18:07:50 -0800 | [diff] [blame] | 269 | static inline void mem_cgroup_end_migration(struct mem_cgroup *mem, |
Daisuke Nishimura | 50de1dd | 2011-01-13 15:47:43 -0800 | [diff] [blame] | 270 | struct page *oldpage, struct page *newpage, bool migration_ok) |
KAMEZAWA Hiroyuki | ae41be3 | 2008-02-07 00:14:10 -0800 | [diff] [blame] | 271 | { |
| 272 | } |
| 273 | |
KAMEZAWA Hiroyuki | 6c48a1d | 2008-02-07 00:14:34 -0800 | [diff] [blame] | 274 | static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem) |
| 275 | { |
| 276 | return 0; |
| 277 | } |
| 278 | |
| 279 | static inline void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem, |
| 280 | int priority) |
| 281 | { |
| 282 | } |
| 283 | |
| 284 | static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem, |
| 285 | int priority) |
| 286 | { |
| 287 | } |
| 288 | |
Hirokazu Takahashi | f8d66542 | 2009-01-07 18:08:02 -0800 | [diff] [blame] | 289 | static inline bool mem_cgroup_disabled(void) |
| 290 | { |
| 291 | return true; |
| 292 | } |
KAMEZAWA Hiroyuki | a636b32 | 2009-01-07 18:08:08 -0800 | [diff] [blame] | 293 | |
KOSAKI Motohiro | 14797e2 | 2009-01-07 18:08:18 -0800 | [diff] [blame] | 294 | static inline int |
KOSAKI Motohiro | c772be9 | 2009-01-07 18:08:25 -0800 | [diff] [blame] | 295 | mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg) |
KOSAKI Motohiro | 14797e2 | 2009-01-07 18:08:18 -0800 | [diff] [blame] | 296 | { |
| 297 | return 1; |
| 298 | } |
| 299 | |
Rik van Riel | 56e49d2 | 2009-06-16 15:32:28 -0700 | [diff] [blame] | 300 | static inline int |
| 301 | mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg) |
| 302 | { |
| 303 | return 1; |
| 304 | } |
| 305 | |
KOSAKI Motohiro | a3d8e05 | 2009-01-07 18:08:19 -0800 | [diff] [blame] | 306 | static inline unsigned long |
KAMEZAWA Hiroyuki | bb2a0de | 2011-07-26 16:08:22 -0700 | [diff] [blame] | 307 | mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid, |
| 308 | unsigned int lru_mask) |
KOSAKI Motohiro | a3d8e05 | 2009-01-07 18:08:19 -0800 | [diff] [blame] | 309 | { |
| 310 | return 0; |
| 311 | } |
| 312 | |
| 313 | |
KOSAKI Motohiro | 3e2f41f | 2009-01-07 18:08:20 -0800 | [diff] [blame] | 314 | static inline struct zone_reclaim_stat* |
| 315 | mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg, struct zone *zone) |
| 316 | { |
| 317 | return NULL; |
| 318 | } |
| 319 | |
| 320 | static inline struct zone_reclaim_stat* |
| 321 | mem_cgroup_get_reclaim_stat_from_page(struct page *page) |
| 322 | { |
| 323 | return NULL; |
| 324 | } |
| 325 | |
Balbir Singh | e222432 | 2009-04-02 16:57:39 -0700 | [diff] [blame] | 326 | static inline void |
| 327 | mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p) |
| 328 | { |
| 329 | } |
| 330 | |
Greg Thelen | 2a7106f | 2011-01-13 15:47:37 -0800 | [diff] [blame] | 331 | static inline void mem_cgroup_inc_page_stat(struct page *page, |
| 332 | enum mem_cgroup_page_stat_item idx) |
| 333 | { |
| 334 | } |
| 335 | |
| 336 | static inline void mem_cgroup_dec_page_stat(struct page *page, |
| 337 | enum mem_cgroup_page_stat_item idx) |
Balbir Singh | d69b042 | 2009-06-17 16:26:34 -0700 | [diff] [blame] | 338 | { |
| 339 | } |
| 340 | |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 341 | static inline |
| 342 | unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order, |
Ying Han | 0ae5e89 | 2011-05-26 16:25:25 -0700 | [diff] [blame] | 343 | gfp_t gfp_mask, |
| 344 | unsigned long *total_scanned) |
Balbir Singh | 4e41695 | 2009-09-23 15:56:39 -0700 | [diff] [blame] | 345 | { |
| 346 | return 0; |
| 347 | } |
| 348 | |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 349 | static inline |
| 350 | u64 mem_cgroup_get_limit(struct mem_cgroup *mem) |
| 351 | { |
| 352 | return 0; |
| 353 | } |
| 354 | |
KAMEZAWA Hiroyuki | ca3e021 | 2011-01-20 14:44:24 -0800 | [diff] [blame] | 355 | static inline void mem_cgroup_split_huge_fixup(struct page *head, |
| 356 | struct page *tail) |
| 357 | { |
| 358 | } |
| 359 | |
Ying Han | 456f998 | 2011-05-26 16:25:38 -0700 | [diff] [blame] | 360 | static inline |
| 361 | void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx) |
| 362 | { |
| 363 | } |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 364 | #endif /* CONFIG_CGROUP_MEM_CONT */ |
| 365 | |
Daisuke Nishimura | f212ad7 | 2011-03-23 16:42:25 -0700 | [diff] [blame] | 366 | #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM) |
| 367 | static inline bool |
| 368 | mem_cgroup_bad_page_check(struct page *page) |
| 369 | { |
| 370 | return false; |
| 371 | } |
| 372 | |
| 373 | static inline void |
| 374 | mem_cgroup_print_bad_page(struct page *page) |
| 375 | { |
| 376 | } |
| 377 | #endif |
| 378 | |
Balbir Singh | 8cdea7c | 2008-02-07 00:13:50 -0800 | [diff] [blame] | 379 | #endif /* _LINUX_MEMCONTROL_H */ |
| 380 | |