memcontrol.h 16 KB
Newer Older
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>
 *
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 28
struct mem_cgroup;
struct page_cgroup;
29 30
struct page;
struct mm_struct;
31
struct kmem_cache;
32

33 34 35 36 37 38 39 40 41 42 43 44
/*
 * 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 */
45
	MEM_CGROUP_STAT_WRITEBACK,	/* # of pages under writeback */
46 47
	MEM_CGROUP_STAT_SWAP,		/* # of pages, swapped out */
	MEM_CGROUP_STAT_NSTATS,
48 49
};

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

Andrew Morton's avatar
Andrew Morton committed
56
#ifdef CONFIG_MEMCG
57 58 59 60 61
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);
62 63

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

/* For coalescing uncharge for reducing memcg' overhead*/
extern void mem_cgroup_uncharge_start(void);
extern void mem_cgroup_uncharge_end(void);

70
extern void mem_cgroup_uncharge_page(struct page *page);
71
extern void mem_cgroup_uncharge_cache_page(struct page *page);
72

73 74
bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
				  struct mem_cgroup *memcg);
75 76
bool task_in_mem_cgroup(struct task_struct *task,
			const struct mem_cgroup *memcg);
77

78
extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
79 80
extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);

Glauber Costa's avatar
Glauber Costa committed
81
extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
82
extern struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css);
Glauber Costa's avatar
Glauber Costa committed
83

84
static inline
85
bool mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *memcg)
86
{
87 88
	struct mem_cgroup *task_memcg;
	bool match;
89

90
	rcu_read_lock();
91 92
	task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
	match = __mem_cgroup_same_or_subtree(memcg, task_memcg);
93
	rcu_read_unlock();
94
	return match;
95
}
96

97
extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
98

99 100 101
extern void
mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
			     struct mem_cgroup **memcgp);
102
extern void mem_cgroup_end_migration(struct mem_cgroup *memcg,
103
	struct page *oldpage, struct page *newpage, bool migration_ok);
104

105 106 107
struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
				   struct mem_cgroup *,
				   struct mem_cgroup_reclaim_cookie *);
108 109
void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);

110 111 112
/*
 * For memory reclaim.
 */
113
int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec);
114
int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
115
unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list);
116
void mem_cgroup_update_lru_size(struct lruvec *, enum lru_list, int);
117 118
extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
					struct task_struct *p);
119 120
extern void mem_cgroup_replace_page_cache(struct page *oldpage,
					struct page *newpage);
121

122
static inline void mem_cgroup_oom_enable(void)
123
{
124 125
	WARN_ON(current->memcg_oom.may_oom);
	current->memcg_oom.may_oom = 1;
126 127
}

128
static inline void mem_cgroup_oom_disable(void)
129
{
130 131
	WARN_ON(!current->memcg_oom.may_oom);
	current->memcg_oom.may_oom = 0;
132 133
}

134 135
static inline bool task_in_memcg_oom(struct task_struct *p)
{
136
	return p->memcg_oom.memcg;
137 138
}

139
bool mem_cgroup_oom_synchronize(bool wait);
140

Andrew Morton's avatar
Andrew Morton committed
141
#ifdef CONFIG_MEMCG_SWAP
142 143
extern int do_swap_account;
#endif
144 145 146

static inline bool mem_cgroup_disabled(void)
{
147
	if (memory_cgrp_subsys.disabled)
148 149 150 151
		return true;
	return false;
}

152 153 154
void __mem_cgroup_begin_update_page_stat(struct page *page, bool *locked,
					 unsigned long *flags);

155 156
extern atomic_t memcg_moving;

157 158 159 160 161 162 163
static inline void mem_cgroup_begin_update_page_stat(struct page *page,
					bool *locked, unsigned long *flags)
{
	if (mem_cgroup_disabled())
		return;
	rcu_read_lock();
	*locked = false;
164 165
	if (atomic_read(&memcg_moving))
		__mem_cgroup_begin_update_page_stat(page, locked, flags);
166 167 168 169 170 171 172 173 174 175 176 177 178 179
}

void __mem_cgroup_end_update_page_stat(struct page *page,
				unsigned long *flags);
static inline void mem_cgroup_end_update_page_stat(struct page *page,
					bool *locked, unsigned long *flags)
{
	if (mem_cgroup_disabled())
		return;
	if (*locked)
		__mem_cgroup_end_update_page_stat(page, flags);
	rcu_read_unlock();
}

180
void mem_cgroup_update_page_stat(struct page *page,
181
				 enum mem_cgroup_stat_index idx,
182 183 184
				 int val);

static inline void mem_cgroup_inc_page_stat(struct page *page,
185
					    enum mem_cgroup_stat_index idx)
186 187 188 189 190
{
	mem_cgroup_update_page_stat(page, idx, 1);
}

static inline void mem_cgroup_dec_page_stat(struct page *page,
191
					    enum mem_cgroup_stat_index idx)
192 193 194 195
{
	mem_cgroup_update_page_stat(page, idx, -1);
}

196 197 198
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
						gfp_t gfp_mask,
						unsigned long *total_scanned);
199

200 201 202 203 204 205 206 207
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);
}
208
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
209
void mem_cgroup_split_huge_fixup(struct page *head);
210 211
#endif

212 213 214 215
#ifdef CONFIG_DEBUG_VM
bool mem_cgroup_bad_page_check(struct page *page);
void mem_cgroup_print_bad_page(struct page *page);
#endif
Andrew Morton's avatar
Andrew Morton committed
216
#else /* CONFIG_MEMCG */
217 218
struct mem_cgroup;

219 220 221
static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
					gfp_t gfp_mask,
					struct mem_cgroup **memcgp)
222
{
223
	*memcgp = NULL;
224 225 226
	return 0;
}

227 228 229
static inline void mem_cgroup_commit_charge(struct page *page,
					    struct mem_cgroup *memcg,
					    bool lrucare)
230 231 232
{
}

233 234
static inline void mem_cgroup_cancel_charge(struct page *page,
					    struct mem_cgroup *memcg)
235 236 237
{
}

238 239 240 241 242 243 244 245
static inline void mem_cgroup_uncharge_start(void)
{
}

static inline void mem_cgroup_uncharge_end(void)
{
}

246 247 248 249
static inline void mem_cgroup_uncharge_page(struct page *page)
{
}

250 251 252 253
static inline void mem_cgroup_uncharge_cache_page(struct page *page)
{
}

254 255
static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
						    struct mem_cgroup *memcg)
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
256
{
257
	return &zone->lruvec;
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
258 259
}

260 261
static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
						    struct zone *zone)
262
{
263
	return &zone->lruvec;
264 265
}

266 267 268 269 270
static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
{
	return NULL;
}

271
static inline bool mm_match_cgroup(struct mm_struct *mm,
272
		struct mem_cgroup *memcg)
273
{
274
	return true;
275 276
}

277 278
static inline bool task_in_mem_cgroup(struct task_struct *task,
				      const struct mem_cgroup *memcg)
279
{
280
	return true;
281 282
}

283 284
static inline struct cgroup_subsys_state
		*mem_cgroup_css(struct mem_cgroup *memcg)
285 286 287 288
{
	return NULL;
}

289
static inline void
290
mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
291
			     struct mem_cgroup **memcgp)
292 293 294
{
}

295
static inline void mem_cgroup_end_migration(struct mem_cgroup *memcg,
296
		struct page *oldpage, struct page *newpage, bool migration_ok)
297 298 299
{
}

300 301 302 303 304 305 306 307 308 309 310 311 312
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)
{
}

313 314 315 316
static inline bool mem_cgroup_disabled(void)
{
	return true;
}
317

318
static inline int
319
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
320 321 322 323
{
	return 1;
}

324
static inline unsigned long
325
mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
326 327 328 329
{
	return 0;
}

330 331 332
static inline void
mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
			      int increment)
KOSAKI Motohiro's avatar
KOSAKI Motohiro committed
333 334 335
{
}

336 337 338 339 340
static inline void
mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
{
}

341 342 343 344 345 346 347 348 349 350
static inline void mem_cgroup_begin_update_page_stat(struct page *page,
					bool *locked, unsigned long *flags)
{
}

static inline void mem_cgroup_end_update_page_stat(struct page *page,
					bool *locked, unsigned long *flags)
{
}

351
static inline void mem_cgroup_oom_enable(void)
352 353 354
{
}

355
static inline void mem_cgroup_oom_disable(void)
356 357 358
{
}

359 360 361 362 363
static inline bool task_in_memcg_oom(struct task_struct *p)
{
	return false;
}

364
static inline bool mem_cgroup_oom_synchronize(bool wait)
365 366 367 368
{
	return false;
}

369
static inline void mem_cgroup_inc_page_stat(struct page *page,
370
					    enum mem_cgroup_stat_index idx)
371 372 373 374
{
}

static inline void mem_cgroup_dec_page_stat(struct page *page,
375
					    enum mem_cgroup_stat_index idx)
376 377 378
{
}

379
static inline
380 381 382
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
					    gfp_t gfp_mask,
					    unsigned long *total_scanned)
383
{
384
	return 0;
385 386
}

387
static inline void mem_cgroup_split_huge_fixup(struct page *head)
388 389 390
{
}

391 392 393 394
static inline
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
{
}
395 396 397 398
static inline void mem_cgroup_replace_page_cache(struct page *oldpage,
				struct page *newpage)
{
}
Andrew Morton's avatar
Andrew Morton committed
399
#endif /* CONFIG_MEMCG */
400

Andrew Morton's avatar
Andrew Morton committed
401
#if !defined(CONFIG_MEMCG) || !defined(CONFIG_DEBUG_VM)
402 403 404 405 406 407 408 409 410 411 412 413
static inline bool
mem_cgroup_bad_page_check(struct page *page)
{
	return false;
}

static inline void
mem_cgroup_print_bad_page(struct page *page)
{
}
#endif

Glauber Costa's avatar
Glauber Costa committed
414 415 416 417 418 419 420
enum {
	UNDER_LIMIT,
	SOFT_LIMIT,
	OVER_LIMIT,
};

struct sock;
421
#if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
Glauber Costa's avatar
Glauber Costa committed
422 423 424 425 426 427 428 429 430
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)
{
}
431
#endif /* CONFIG_INET && CONFIG_MEMCG_KMEM */
432 433

#ifdef CONFIG_MEMCG_KMEM
434
extern struct static_key memcg_kmem_enabled_key;
435 436

extern int memcg_limited_groups_array_size;
437 438 439 440 441 442

/*
 * 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
 */
443
#define for_each_memcg_cache_index(_idx)	\
444
	for ((_idx) = 0; (_idx) < memcg_limited_groups_array_size; (_idx)++)
445

446 447
static inline bool memcg_kmem_enabled(void)
{
448
	return static_key_false(&memcg_kmem_enabled_key);
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
}

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

468
int memcg_cache_id(struct mem_cgroup *memcg);
469

470 471 472
int memcg_alloc_cache_params(struct mem_cgroup *memcg, struct kmem_cache *s,
			     struct kmem_cache *root_cache);
void memcg_free_cache_params(struct kmem_cache *s);
473

474 475
int memcg_update_cache_size(struct kmem_cache *s, int num_groups);
void memcg_update_array_size(int num_groups);
476 477 478 479

struct kmem_cache *
__memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp);

480 481
int __memcg_charge_slab(struct kmem_cache *cachep, gfp_t gfp, int order);
void __memcg_uncharge_slab(struct kmem_cache *cachep, int order);
482

483
int __memcg_cleanup_cache_params(struct kmem_cache *s);
Glauber Costa's avatar
Glauber Costa committed
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
/**
 * 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
	 * unaccounted. We could in theory charge it with
	 * res_counter_charge_nofail, but we hope those allocations are rare,
	 * and won't be worth the trouble.
	 */
Vladimir Davydov's avatar
Vladimir Davydov committed
510
	if (gfp & __GFP_NOFAIL)
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
		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.
 *
 * there is no need to specify memcg here, since it is embedded in page_cgroup
 */
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
 * charges. Otherwise, it will commit the memcg given by @memcg to the
 * corresponding page_cgroup.
 */
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);
}

554 555 556 557 558
/**
 * memcg_kmem_get_cache: selects the correct per-memcg cache for allocation
 * @cachep: the original global kmem cache
 * @gfp: allocation flags.
 *
559
 * All memory allocated from a per-memcg cache is charged to the owner memcg.
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
 */
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;

	return __memcg_kmem_get_cache(cachep, gfp);
}
575
#else
576 577 578
#define for_each_memcg_cache_index(_idx)	\
	for (; NULL; )

579 580 581 582 583
static inline bool memcg_kmem_enabled(void)
{
	return false;
}

584 585 586 587 588 589 590 591 592 593 594 595 596 597
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)
{
}
598 599 600 601 602 603

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

604 605
static inline int memcg_alloc_cache_params(struct mem_cgroup *memcg,
		struct kmem_cache *s, struct kmem_cache *root_cache)
606 607 608 609
{
	return 0;
}

610 611 612 613
static inline void memcg_free_cache_params(struct kmem_cache *s)
{
}

614 615 616 617 618
static inline struct kmem_cache *
memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
{
	return cachep;
}
619
#endif /* CONFIG_MEMCG_KMEM */
620 621
#endif /* _LINUX_MEMCONTROL_H */