memcontrol.h 14.0 KB
Newer Older
B
Balbir Singh 已提交
1 2 3 4 5
/* memcontrol.h - Memory Controller
 *
 * Copyright IBM Corporation, 2007
 * Author Balbir Singh <balbir@linux.vnet.ibm.com>
 *
6 7 8
 * Copyright 2007 OpenVZ SWsoft Inc
 * Author: Pavel Emelianov <xemul@openvz.org>
 *
B
Balbir Singh 已提交
9 10 11 12 13 14 15 16 17 18 19 20 21
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#ifndef _LINUX_MEMCONTROL_H
#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 29
struct page;
struct mm_struct;
30
struct kmem_cache;
31

S
Sha Zhengju 已提交
32 33 34 35 36 37 38 39 40 41 42 43
/*
 * The corresponding mem_cgroup_stat_names is defined in mm/memcontrol.c,
 * These two lists should keep in accord with each other.
 */
enum mem_cgroup_stat_index {
	/*
	 * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
	 */
	MEM_CGROUP_STAT_CACHE,		/* # of pages charged as cache */
	MEM_CGROUP_STAT_RSS,		/* # of pages charged as anon rss */
	MEM_CGROUP_STAT_RSS_HUGE,	/* # of pages charged as anon huge */
	MEM_CGROUP_STAT_FILE_MAPPED,	/* # of pages charged as file rss */
44
	MEM_CGROUP_STAT_WRITEBACK,	/* # of pages under writeback */
S
Sha Zhengju 已提交
45 46
	MEM_CGROUP_STAT_SWAP,		/* # of pages, swapped out */
	MEM_CGROUP_STAT_NSTATS,
47 48
};

49 50 51 52 53 54
struct mem_cgroup_reclaim_cookie {
	struct zone *zone;
	int priority;
	unsigned int generation;
};

A
Andrew Morton 已提交
55
#ifdef CONFIG_MEMCG
56 57 58 59 60
int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
			  gfp_t gfp_mask, struct mem_cgroup **memcgp);
void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
			      bool lrucare);
void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg);
61
void mem_cgroup_uncharge(struct page *page);
62
void mem_cgroup_uncharge_list(struct list_head *page_list);
63

64 65
void mem_cgroup_migrate(struct page *oldpage, struct page *newpage,
			bool lrucare);
66

67 68
struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *);
struct lruvec *mem_cgroup_page_lruvec(struct page *, struct zone *);
69

70 71 72
bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
			      struct mem_cgroup *root);
bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg);
73

74
extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
75 76
extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);

G
Glauber Costa 已提交
77
extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
78
extern struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css);
G
Glauber Costa 已提交
79

80 81
static inline bool mm_match_cgroup(struct mm_struct *mm,
				   struct mem_cgroup *memcg)
82
{
83
	struct mem_cgroup *task_memcg;
84
	bool match = false;
85

86
	rcu_read_lock();
87
	task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
88
	if (task_memcg)
89
		match = mem_cgroup_is_descendant(task_memcg, memcg);
90
	rcu_read_unlock();
91
	return match;
92
}
93

94
extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
95

96 97 98
struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
				   struct mem_cgroup *,
				   struct mem_cgroup_reclaim_cookie *);
99 100
void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);

101 102 103
/*
 * For memory reclaim.
 */
104
int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec);
105
bool mem_cgroup_lruvec_online(struct lruvec *lruvec);
106
int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
107
unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list);
108
void mem_cgroup_update_lru_size(struct lruvec *, enum lru_list, int);
109 110
extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
					struct task_struct *p);
111

112
static inline void mem_cgroup_oom_enable(void)
113
{
114 115
	WARN_ON(current->memcg_oom.may_oom);
	current->memcg_oom.may_oom = 1;
116 117
}

118
static inline void mem_cgroup_oom_disable(void)
119
{
120 121
	WARN_ON(!current->memcg_oom.may_oom);
	current->memcg_oom.may_oom = 0;
122 123
}

124 125
static inline bool task_in_memcg_oom(struct task_struct *p)
{
126
	return p->memcg_oom.memcg;
127 128
}

129
bool mem_cgroup_oom_synchronize(bool wait);
130

A
Andrew Morton 已提交
131
#ifdef CONFIG_MEMCG_SWAP
132 133
extern int do_swap_account;
#endif
134 135 136

static inline bool mem_cgroup_disabled(void)
{
137
	if (memory_cgrp_subsys.disabled)
138 139 140 141
		return true;
	return false;
}

142
struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page);
143 144
void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
				 enum mem_cgroup_stat_index idx, int val);
145
void mem_cgroup_end_page_stat(struct mem_cgroup *memcg);
146 147

static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
S
Sha Zhengju 已提交
148
					    enum mem_cgroup_stat_index idx)
149
{
150
	mem_cgroup_update_page_stat(memcg, idx, 1);
151 152
}

153
static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
S
Sha Zhengju 已提交
154
					    enum mem_cgroup_stat_index idx)
155
{
156
	mem_cgroup_update_page_stat(memcg, idx, -1);
157 158
}

159 160 161
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
						gfp_t gfp_mask,
						unsigned long *total_scanned);
D
David Rientjes 已提交
162

163 164 165 166 167 168 169 170
void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx);
static inline void mem_cgroup_count_vm_event(struct mm_struct *mm,
					     enum vm_event_item idx)
{
	if (mem_cgroup_disabled())
		return;
	__mem_cgroup_count_vm_event(mm, idx);
}
171
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
172
void mem_cgroup_split_huge_fixup(struct page *head);
173 174
#endif

A
Andrew Morton 已提交
175
#else /* CONFIG_MEMCG */
176 177
struct mem_cgroup;

178 179 180
static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
					gfp_t gfp_mask,
					struct mem_cgroup **memcgp)
181
{
182
	*memcgp = NULL;
183 184 185
	return 0;
}

186 187 188
static inline void mem_cgroup_commit_charge(struct page *page,
					    struct mem_cgroup *memcg,
					    bool lrucare)
189 190 191
{
}

192 193
static inline void mem_cgroup_cancel_charge(struct page *page,
					    struct mem_cgroup *memcg)
194 195 196
{
}

197
static inline void mem_cgroup_uncharge(struct page *page)
198 199 200
{
}

201
static inline void mem_cgroup_uncharge_list(struct list_head *page_list)
202 203 204
{
}

205 206 207
static inline void mem_cgroup_migrate(struct page *oldpage,
				      struct page *newpage,
				      bool lrucare)
208 209 210
{
}

211 212
static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
						    struct mem_cgroup *memcg)
K
KAMEZAWA Hiroyuki 已提交
213
{
214
	return &zone->lruvec;
K
KAMEZAWA Hiroyuki 已提交
215 216
}

217 218
static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
						    struct zone *zone)
219
{
220
	return &zone->lruvec;
221 222
}

223 224 225 226 227
static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
{
	return NULL;
}

228
static inline bool mm_match_cgroup(struct mm_struct *mm,
229
		struct mem_cgroup *memcg)
230
{
231
	return true;
232 233
}

234 235
static inline bool task_in_mem_cgroup(struct task_struct *task,
				      const struct mem_cgroup *memcg)
236
{
237
	return true;
238 239
}

240 241
static inline struct cgroup_subsys_state
		*mem_cgroup_css(struct mem_cgroup *memcg)
242 243 244 245
{
	return NULL;
}

246 247 248 249 250 251 252 253 254 255 256 257 258
static inline struct mem_cgroup *
mem_cgroup_iter(struct mem_cgroup *root,
		struct mem_cgroup *prev,
		struct mem_cgroup_reclaim_cookie *reclaim)
{
	return NULL;
}

static inline void mem_cgroup_iter_break(struct mem_cgroup *root,
					 struct mem_cgroup *prev)
{
}

259 260 261 262
static inline bool mem_cgroup_disabled(void)
{
	return true;
}
263

264
static inline int
265
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
266 267 268 269
{
	return 1;
}

270 271 272 273 274
static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
{
	return true;
}

275
static inline unsigned long
276
mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
277 278 279 280
{
	return 0;
}

281 282 283
static inline void
mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
			      int increment)
K
KOSAKI Motohiro 已提交
284 285 286
{
}

287 288 289 290 291
static inline void
mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
{
}

292
static inline struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page)
293
{
294
	return NULL;
295 296
}

297
static inline void mem_cgroup_end_page_stat(struct mem_cgroup *memcg)
298 299 300
{
}

301
static inline void mem_cgroup_oom_enable(void)
302 303 304
{
}

305
static inline void mem_cgroup_oom_disable(void)
306 307 308
{
}

309 310 311 312 313
static inline bool task_in_memcg_oom(struct task_struct *p)
{
	return false;
}

314
static inline bool mem_cgroup_oom_synchronize(bool wait)
315 316 317 318
{
	return false;
}

319
static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
S
Sha Zhengju 已提交
320
					    enum mem_cgroup_stat_index idx)
321 322 323
{
}

324
static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
S
Sha Zhengju 已提交
325
					    enum mem_cgroup_stat_index idx)
326 327 328
{
}

329
static inline
330 331 332
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
					    gfp_t gfp_mask,
					    unsigned long *total_scanned)
333
{
334
	return 0;
335 336
}

337
static inline void mem_cgroup_split_huge_fixup(struct page *head)
338 339 340
{
}

341 342 343 344
static inline
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
{
}
A
Andrew Morton 已提交
345
#endif /* CONFIG_MEMCG */
346

G
Glauber Costa 已提交
347 348 349 350 351 352 353
enum {
	UNDER_LIMIT,
	SOFT_LIMIT,
	OVER_LIMIT,
};

struct sock;
354
#if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
G
Glauber Costa 已提交
355 356 357 358 359 360 361 362 363
void sock_update_memcg(struct sock *sk);
void sock_release_memcg(struct sock *sk);
#else
static inline void sock_update_memcg(struct sock *sk)
{
}
static inline void sock_release_memcg(struct sock *sk)
{
}
364
#endif /* CONFIG_INET && CONFIG_MEMCG_KMEM */
365 366

#ifdef CONFIG_MEMCG_KMEM
367
extern struct static_key memcg_kmem_enabled_key;
368 369

extern int memcg_limited_groups_array_size;
370 371 372 373 374 375

/*
 * Helper macro to loop through all memcg-specific caches. Callers must still
 * check if the cache is valid (it is either valid or NULL).
 * the slab_mutex must be held when looping through those caches
 */
376
#define for_each_memcg_cache_index(_idx)	\
377
	for ((_idx) = 0; (_idx) < memcg_limited_groups_array_size; (_idx)++)
378

379 380
static inline bool memcg_kmem_enabled(void)
{
381
	return static_key_false(&memcg_kmem_enabled_key);
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
}

/*
 * In general, we'll do everything in our power to not incur in any overhead
 * for non-memcg users for the kmem functions. Not even a function call, if we
 * can avoid it.
 *
 * Therefore, we'll inline all those functions so that in the best case, we'll
 * see that kmemcg is off for everybody and proceed quickly.  If it is on,
 * we'll still do most of the flag checking inline. We check a lot of
 * conditions, but because they are pretty simple, they are expected to be
 * fast.
 */
bool __memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg,
					int order);
void __memcg_kmem_commit_charge(struct page *page,
				       struct mem_cgroup *memcg, int order);
void __memcg_kmem_uncharge_pages(struct page *page, int order);

401
int memcg_cache_id(struct mem_cgroup *memcg);
402

403
void memcg_update_array_size(int num_groups);
404

405 406
struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep);
void __memcg_kmem_put_cache(struct kmem_cache *cachep);
407

408 409 410
int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp,
		      unsigned long nr_pages);
void memcg_uncharge_kmem(struct mem_cgroup *memcg, unsigned long nr_pages);
411

412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
/**
 * memcg_kmem_newpage_charge: verify if a new kmem allocation is allowed.
 * @gfp: the gfp allocation flags.
 * @memcg: a pointer to the memcg this was charged against.
 * @order: allocation order.
 *
 * returns true if the memcg where the current task belongs can hold this
 * allocation.
 *
 * We return true automatically if this allocation is not to be accounted to
 * any memcg.
 */
static inline bool
memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
{
	if (!memcg_kmem_enabled())
		return true;

	/*
	 * __GFP_NOFAIL allocations will move on even if charging is not
	 * possible. Therefore we don't even try, and have this allocation
433 434
	 * unaccounted. We could in theory charge it forcibly, but we hope
	 * those allocations are rare, and won't be worth the trouble.
435
	 */
V
Vladimir Davydov 已提交
436
	if (gfp & __GFP_NOFAIL)
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
		return true;
	if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD))
		return true;

	/* If the test is dying, just let it go. */
	if (unlikely(fatal_signal_pending(current)))
		return true;

	return __memcg_kmem_newpage_charge(gfp, memcg, order);
}

/**
 * memcg_kmem_uncharge_pages: uncharge pages from memcg
 * @page: pointer to struct page being freed
 * @order: allocation order.
 */
static inline void
memcg_kmem_uncharge_pages(struct page *page, int order)
{
	if (memcg_kmem_enabled())
		__memcg_kmem_uncharge_pages(page, order);
}

/**
 * memcg_kmem_commit_charge: embeds correct memcg in a page
 * @page: pointer to struct page recently allocated
 * @memcg: the memcg structure we charged against
 * @order: allocation order.
 *
 * Needs to be called after memcg_kmem_newpage_charge, regardless of success or
 * failure of the allocation. if @page is NULL, this function will revert the
468
 * charges. Otherwise, it will commit @page to @memcg.
469 470 471 472 473 474 475 476
 */
static inline void
memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
{
	if (memcg_kmem_enabled() && memcg)
		__memcg_kmem_commit_charge(page, memcg, order);
}

477 478 479 480 481
/**
 * memcg_kmem_get_cache: selects the correct per-memcg cache for allocation
 * @cachep: the original global kmem cache
 * @gfp: allocation flags.
 *
482
 * All memory allocated from a per-memcg cache is charged to the owner memcg.
483 484 485 486 487 488 489 490 491 492 493 494 495
 */
static __always_inline struct kmem_cache *
memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
{
	if (!memcg_kmem_enabled())
		return cachep;
	if (gfp & __GFP_NOFAIL)
		return cachep;
	if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD))
		return cachep;
	if (unlikely(fatal_signal_pending(current)))
		return cachep;

496
	return __memcg_kmem_get_cache(cachep);
497
}
498 499 500 501 502 503

static __always_inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
{
	if (memcg_kmem_enabled())
		__memcg_kmem_put_cache(cachep);
}
504
#else
505 506 507
#define for_each_memcg_cache_index(_idx)	\
	for (; NULL; )

508 509 510 511 512
static inline bool memcg_kmem_enabled(void)
{
	return false;
}

513 514 515 516 517 518 519 520 521 522 523 524 525 526
static inline bool
memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
{
	return true;
}

static inline void memcg_kmem_uncharge_pages(struct page *page, int order)
{
}

static inline void
memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
{
}
527 528 529 530 531 532

static inline int memcg_cache_id(struct mem_cgroup *memcg)
{
	return -1;
}

533 534 535 536 537
static inline struct kmem_cache *
memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
{
	return cachep;
}
538 539 540 541

static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
{
}
542
#endif /* CONFIG_MEMCG_KMEM */
B
Balbir Singh 已提交
543 544
#endif /* _LINUX_MEMCONTROL_H */