git.baikalelectronics.ru Git

1 /* memcontrol.h - Memory Controller

2 *

3 * Copyright IBM Corporation, 2007

4 * Author Balbir Singh <balbir@linux.vnet.ibm.com>

5 *

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 */

20 #ifndef _LINUX_MEMCONTROL_H

21 #define _LINUX_MEMCONTROL_H

22 #include <linux/cgroup.h>

23 #include <linux/vm_event_item.h>

25 struct mem_cgroup;

26 struct page_cgroup;

27 struct page;

28 struct mm_struct;

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 };

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 isolate_mode_t mode,

39 struct zone *z,

40 struct mem_cgroup *mem_cont,

41 int active, int file);

43 #ifdef CONFIG_CGROUP_MEM_RES_CTLR

44 /*

45 * All "charge" functions with gfp_mask should use GFP_KERNEL or

46 * (gfp_mask & GFP_RECLAIM_MASK). In current implementatin, memcg doesn't

47 * alloc memory but reclaims memory from all available zones. So, "where I want

48 * memory from" bits of gfp_mask has no meaning. So any bits of that field is

49 * available but adding a rule is better. charge functions' gfp_mask should

50 * be set to GFP_KERNEL or gfp_mask & GFP_RECLAIM_MASK for avoiding ambiguous

51 * codes.

52 * (Of course, if memcg does memory allocation in future, GFP_KERNEL is sane.)

53 */

55 extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm,

56 gfp_t gfp_mask);

57 /* for swap handling */

58 extern int mem_cgroup_try_charge_swapin(struct mm_struct *mm,

59 struct page *page, gfp_t mask, struct mem_cgroup **ptr);

60 extern void mem_cgroup_commit_charge_swapin(struct page *page,

61 struct mem_cgroup *ptr);

62 extern void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *ptr);

64 extern int mem_cgroup_cache_charge(struct page *page, struct mm_struct *mm,

65 gfp_t gfp_mask);

66 extern void mem_cgroup_add_lru_list(struct page *page, enum lru_list lru);

67 extern void mem_cgroup_del_lru_list(struct page *page, enum lru_list lru);

68 extern void mem_cgroup_rotate_reclaimable_page(struct page *page);

69 extern void mem_cgroup_rotate_lru_list(struct page *page, enum lru_list lru);

70 extern void mem_cgroup_del_lru(struct page *page);

71 extern void mem_cgroup_move_lists(struct page *page,

72 enum lru_list from, enum lru_list to);

74 /* For coalescing uncharge for reducing memcg' overhead*/

75 extern void mem_cgroup_uncharge_start(void);

76 extern void mem_cgroup_uncharge_end(void);

78 extern void mem_cgroup_uncharge_page(struct page *page);

79 extern void mem_cgroup_uncharge_cache_page(struct page *page);

81 extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask);

82 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *memcg);

84 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);

85 extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);

86 extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm);

88 extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);

89 extern struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont);

91 static inline

92 int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup)

93 {

94 struct mem_cgroup *memcg;

95 rcu_read_lock();

96 memcg = mem_cgroup_from_task(rcu_dereference((mm)->owner));

97 rcu_read_unlock();

98 return cgroup == memcg;

99 }

100

101 extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);

102

103 extern int

104 mem_cgroup_prepare_migration(struct page *page,

105 struct page *newpage, struct mem_cgroup **ptr, gfp_t gfp_mask);

106 extern void mem_cgroup_end_migration(struct mem_cgroup *memcg,

107 struct page *oldpage, struct page *newpage, bool migration_ok);

108

109 /*

110 * For memory reclaim.

111 */

112 int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg,

113 struct zone *zone);

114 int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg,

115 struct zone *zone);

116 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);

117 unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg,

118 int nid, int zid, unsigned int lrumask);

119 struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,

120 struct zone *zone);

121 struct zone_reclaim_stat*

122 mem_cgroup_get_reclaim_stat_from_page(struct page *page);

123 extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,

124 struct task_struct *p);

125

126 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP

127 extern int do_swap_account;

128 #endif

129

130 static inline bool mem_cgroup_disabled(void)

131 {

132 if (mem_cgroup_subsys.disabled)

133 return true;

134 return false;

135 }

136

137 void mem_cgroup_update_page_stat(struct page *page,

138 enum mem_cgroup_page_stat_item idx,

139 int val);

140

141 static inline void mem_cgroup_inc_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

147 static inline void mem_cgroup_dec_page_stat(struct page *page,

148 enum mem_cgroup_page_stat_item idx)

149 {

150 mem_cgroup_update_page_stat(page, idx, -1);

151 }

152

153 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,

154 gfp_t gfp_mask,

155 unsigned long *total_scanned);

156 u64 mem_cgroup_get_limit(struct mem_cgroup *memcg);

157

158 void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx);

159 #ifdef CONFIG_TRANSPARENT_HUGEPAGE

160 void mem_cgroup_split_huge_fixup(struct page *head, struct page *tail);

161 #endif

162

163 #ifdef CONFIG_DEBUG_VM

164 bool mem_cgroup_bad_page_check(struct page *page);

165 void mem_cgroup_print_bad_page(struct page *page);

166 #endif

167 #else /* CONFIG_CGROUP_MEM_RES_CTLR */

168 struct mem_cgroup;

169

170 static inline int mem_cgroup_newpage_charge(struct page *page,

171 struct mm_struct *mm, gfp_t gfp_mask)

172 {

173 return 0;

174 }

175

176 static inline int mem_cgroup_cache_charge(struct page *page,

177 struct mm_struct *mm, gfp_t gfp_mask)

178 {

179 return 0;

180 }

181

182 static inline int mem_cgroup_try_charge_swapin(struct mm_struct *mm,

183 struct page *page, gfp_t gfp_mask, struct mem_cgroup **ptr)

184 {

185 return 0;

186 }

187

188 static inline void mem_cgroup_commit_charge_swapin(struct page *page,

189 struct mem_cgroup *ptr)

190 {

191 }

192

193 static inline void mem_cgroup_cancel_charge_swapin(struct mem_cgroup *ptr)

194 {

195 }

196

197 static inline void mem_cgroup_uncharge_start(void)

198 {

199 }

200

201 static inline void mem_cgroup_uncharge_end(void)

202 {

203 }

204

205 static inline void mem_cgroup_uncharge_page(struct page *page)

206 {

207 }

208

209 static inline void mem_cgroup_uncharge_cache_page(struct page *page)

210 {

211 }

212

213 static inline void mem_cgroup_add_lru_list(struct page *page, int lru)

214 {

215 }

216

217 static inline void mem_cgroup_del_lru_list(struct page *page, int lru)

218 {

219 return ;

220 }

221

222 static inline void mem_cgroup_rotate_reclaimable_page(struct page *page)

223 {

224 return ;

225 }

226

227 static inline void mem_cgroup_rotate_lru_list(struct page *page, int lru)

228 {

229 return ;

230 }

231

232 static inline void mem_cgroup_del_lru(struct page *page)

233 {

234 return ;

235 }

236

237 static inline void

238 mem_cgroup_move_lists(struct page *page, enum lru_list from, enum lru_list to)

239 {

240 }

241

242 static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)

243 {

244 return NULL;

245 }

246

247 static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)

248 {

249 return NULL;

250 }

251

252 static inline int mm_match_cgroup(struct mm_struct *mm,

253 struct mem_cgroup *memcg)

254 {

255 return 1;

256 }

257

258 static inline int task_in_mem_cgroup(struct task_struct *task,

259 const struct mem_cgroup *memcg)

260 {

261 return 1;

262 }

263

264 static inline struct cgroup_subsys_state

265 *mem_cgroup_css(struct mem_cgroup *memcg)

266 {

267 return NULL;

268 }

269

270 static inline int

271 mem_cgroup_prepare_migration(struct page *page, struct page *newpage,

272 struct mem_cgroup **ptr, gfp_t gfp_mask)

273 {

274 return 0;

275 }

276

277 static inline void mem_cgroup_end_migration(struct mem_cgroup *memcg,

278 struct page *oldpage, struct page *newpage, bool migration_ok)

279 {

280 }

281

282 static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *memcg)

283 {

284 return 0;

285 }

286

287 static inline void mem_cgroup_note_reclaim_priority(struct mem_cgroup *memcg,

288 int priority)

289 {

290 }

291

292 static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *memcg,

293 int priority)

294 {

295 }

296

297 static inline bool mem_cgroup_disabled(void)

298 {

299 return true;

300 }

301

302 static inline int

303 mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg, struct zone *zone)

304 {

305 return 1;

306 }

307

308 static inline int

309 mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg, struct zone *zone)

310 {

311 return 1;

312 }

313

314 static inline unsigned long

315 mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,

316 unsigned int lru_mask)

317 {

318 return 0;

319 }

320

321

322 static inline struct zone_reclaim_stat*

323 mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg, struct zone *zone)

324 {

325 return NULL;

326 }

327

328 static inline struct zone_reclaim_stat*

329 mem_cgroup_get_reclaim_stat_from_page(struct page *page)

330 {

331 return NULL;

332 }

333

334 static inline void

335 mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)

336 {

337 }

338

339 static inline void mem_cgroup_inc_page_stat(struct page *page,

340 enum mem_cgroup_page_stat_item idx)

341 {

342 }

343

344 static inline void mem_cgroup_dec_page_stat(struct page *page,

345 enum mem_cgroup_page_stat_item idx)

346 {

347 }

348

349 static inline

350 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,

351 gfp_t gfp_mask,

352 unsigned long *total_scanned)

353 {

354 return 0;

355 }

356

357 static inline

358 u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)

359 {

360 return 0;

361 }

362

363 static inline void mem_cgroup_split_huge_fixup(struct page *head,

364 struct page *tail)

365 {

366 }

367

368 static inline

369 void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)

370 {

371 }

372 #endif /* CONFIG_CGROUP_MEM_CONT */

373

374 #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM)

375 static inline bool

376 mem_cgroup_bad_page_check(struct page *page)

377 {

378 return false;

379 }

380

381 static inline void

382 mem_cgroup_print_bad_page(struct page *page)

383 {

384 }

385 #endif

386

387 #ifdef CONFIG_INET

388 enum {

389 UNDER_LIMIT,

390 SOFT_LIMIT,

391 OVER_LIMIT,

392 };

393

394 struct sock;

395 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM

396 void sock_update_memcg(struct sock *sk);

397 void sock_release_memcg(struct sock *sk);

398 #else

399 static inline void sock_update_memcg(struct sock *sk)

400 {

401 }

402 static inline void sock_release_memcg(struct sock *sk)

403 {

404 }

405 #endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */

406 #endif /* CONFIG_INET */

407 #endif /* _LINUX_MEMCONTROL_H */

408