include/linux/memcontrol.h

   1 /* memcontrol.h - Memory Controller
   2  *
   3  * Copyright IBM Corporation, 2007
   4  * Author Balbir Singh <balbir@linux.vnet.ibm.com>
   5  *
   6  * Copyright 2007 OpenVZ SWsoft Inc
   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  */
  19
  20 #ifndef _LINUX_MEMCONTROL_H
  21 #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 struct page;
  29 struct mm_struct;
  30 struct kmem_cache;
  31
  32 /*
  33  * The corresponding mem_cgroup_stat_names is defined in mm/memcontrol.c,
  34  * These two lists should keep in accord with each other.
  35  */
  36 enum mem_cgroup_stat_index {
  37         /*
  38          * For MEM_CONTAINER_TYPE_ALL, usage = pagecache + rss.
  39          */
  40         MEM_CGROUP_STAT_CACHE,          /* # of pages charged as cache */
  41         MEM_CGROUP_STAT_RSS,            /* # of pages charged as anon rss */
  42         MEM_CGROUP_STAT_RSS_HUGE,       /* # of pages charged as anon huge */
  43         MEM_CGROUP_STAT_FILE_MAPPED,    /* # of pages charged as file rss */
  44         MEM_CGROUP_STAT_WRITEBACK,      /* # of pages under writeback */
  45         MEM_CGROUP_STAT_SWAP,           /* # of pages, swapped out */
  46         MEM_CGROUP_STAT_NSTATS,
  47 };
  48
  49 struct mem_cgroup_reclaim_cookie {
  50         struct zone *zone;
  51         int priority;
  52         unsigned int generation;
  53 };
  54
  55 #ifdef CONFIG_MEMCG
  56 int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
  57                           gfp_t gfp_mask, struct mem_cgroup **memcgp);
  58 void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
  59                               bool lrucare);
  60 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 void mem_cgroup_migrate(struct page *oldpage, struct page *newpage,
  65                         bool lrucare);
  66
  67 struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *);
  68 struct lruvec *mem_cgroup_page_lruvec(struct page *, struct zone *);
  69
  70 bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
  71                               struct mem_cgroup *root);
  72 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 extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
  76
  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);
  79
  80 static inline bool mm_match_cgroup(struct mm_struct *mm,
  81                                    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 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
  97                                    struct mem_cgroup *,
  98                                    struct mem_cgroup_reclaim_cookie *);
  99 void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
 100
 101 /*
 102  * For memory reclaim.
 103  */
 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 extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
 110                                         struct task_struct *p);
 111
 112 static inline void mem_cgroup_oom_enable(void)
 113 {
 114         WARN_ON(current->memcg_oom.may_oom);
 115         current->memcg_oom.may_oom = 1;
 116 }
 117
 118 static inline void mem_cgroup_oom_disable(void)
 119 {
 120         WARN_ON(!current->memcg_oom.may_oom);
 121         current->memcg_oom.may_oom = 0;
 122 }
 123
 124 static inline bool task_in_memcg_oom(struct task_struct *p)
 125 {
 126         return p->memcg_oom.memcg;
 127 }
 128
 129 bool mem_cgroup_oom_synchronize(bool wait);
 130
 131 #ifdef CONFIG_MEMCG_SWAP
 132 extern int do_swap_account;
 133 #endif
 134
 135 static inline bool mem_cgroup_disabled(void)
 136 {
 137         if (memory_cgrp_subsys.disabled)
 138                 return true;
 139         return false;
 140 }
 141
 142 struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page);
 143 void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
 144                                  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,
 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,
 154                                             enum mem_cgroup_stat_index idx)
 155 {
 156         mem_cgroup_update_page_stat(memcg, idx, -1);
 157 }
 158
 159 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
 160                                                 gfp_t gfp_mask,
 161                                                 unsigned long *total_scanned);
 162
 163 void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx);
 164 static inline void mem_cgroup_count_vm_event(struct mm_struct *mm,
 165                                              enum vm_event_item idx)
 166 {
 167         if (mem_cgroup_disabled())
 168                 return;
 169         __mem_cgroup_count_vm_event(mm, idx);
 170 }
 171 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 172 void mem_cgroup_split_huge_fixup(struct page *head);
 173 #endif
 174
 175 #else /* CONFIG_MEMCG */
 176 struct mem_cgroup;
 177
 178 static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
 179                                         gfp_t gfp_mask,
 180                                         struct mem_cgroup **memcgp)
 181 {
 182         *memcgp = NULL;
 183         return 0;
 184 }
 185
 186 static inline void mem_cgroup_commit_charge(struct page *page,
 187                                             struct mem_cgroup *memcg,
 188                                             bool lrucare)
 189 {
 190 }
 191
 192 static inline void mem_cgroup_cancel_charge(struct page *page,
 193                                             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 static inline void mem_cgroup_migrate(struct page *oldpage,
 206                                       struct page *newpage,
 207                                       bool lrucare)
 208 {
 209 }
 210
 211 static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
 212                                                     struct mem_cgroup *memcg)
 213 {
 214         return &zone->lruvec;
 215 }
 216
 217 static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
 218                                                     struct zone *zone)
 219 {
 220         return &zone->lruvec;
 221 }
 222
 223 static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
 224 {
 225         return NULL;
 226 }
 227
 228 static inline bool mm_match_cgroup(struct mm_struct *mm,
 229                 struct mem_cgroup *memcg)
 230 {
 231         return true;
 232 }
 233
 234 static inline bool task_in_mem_cgroup(struct task_struct *task,
 235                                       const struct mem_cgroup *memcg)
 236 {
 237         return true;
 238 }
 239
 240 static inline struct cgroup_subsys_state
 241                 *mem_cgroup_css(struct mem_cgroup *memcg)
 242 {
 243         return NULL;
 244 }
 245
 246 static inline struct mem_cgroup *
 247 mem_cgroup_iter(struct mem_cgroup *root,
 248                 struct mem_cgroup *prev,
 249                 struct mem_cgroup_reclaim_cookie *reclaim)
 250 {
 251         return NULL;
 252 }
 253
 254 static inline void mem_cgroup_iter_break(struct mem_cgroup *root,
 255                                          struct mem_cgroup *prev)
 256 {
 257 }
 258
 259 static inline bool mem_cgroup_disabled(void)
 260 {
 261         return true;
 262 }
 263
 264 static inline int
 265 mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
 266 {
 267         return 1;
 268 }
 269
 270 static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
 271 {
 272         return true;
 273 }
 274
 275 static inline unsigned long
 276 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
 277 {
 278         return 0;
 279 }
 280
 281 static inline void
 282 mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
 283                               int increment)
 284 {
 285 }
 286
 287 static inline void
 288 mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 289 {
 290 }
 291
 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 static inline bool task_in_memcg_oom(struct task_struct *p)
 310 {
 311         return false;
 312 }
 313
 314 static inline bool mem_cgroup_oom_synchronize(bool wait)
 315 {
 316         return false;
 317 }
 318
 319 static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
 320                                             enum mem_cgroup_stat_index idx)
 321 {
 322 }
 323
 324 static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
 325                                             enum mem_cgroup_stat_index idx)
 326 {
 327 }
 328
 329 static inline
 330 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
 331                                             gfp_t gfp_mask,
 332                                             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 static inline
 342 void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
 343 {
 344 }
 345 #endif /* CONFIG_MEMCG */
 346
 347 enum {
 348         UNDER_LIMIT,
 349         SOFT_LIMIT,
 350         OVER_LIMIT,
 351 };
 352
 353 struct sock;
 354 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
 355 void sock_update_memcg(struct sock *sk);
 356 void sock_release_memcg(struct sock *sk);
 357 #else
 358 static inline void sock_update_memcg(struct sock *sk)
 359 {
 360 }
 361 static inline void sock_release_memcg(struct sock *sk)
 362 {
 363 }
 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  * Helper macro to loop through all memcg-specific caches. Callers must still
 373  * check if the cache is valid (it is either valid or NULL).
 374  * the slab_mutex must be held when looping through those caches
 375  */
 376 #define for_each_memcg_cache_index(_idx)        \
 377         for ((_idx) = 0; (_idx) < memcg_limited_groups_array_size; (_idx)++)
 378
 379 static inline bool memcg_kmem_enabled(void)
 380 {
 381         return static_key_false(&memcg_kmem_enabled_key);
 382 }
 383
 384 /*
 385  * In general, we'll do everything in our power to not incur in any overhead
 386  * for non-memcg users for the kmem functions. Not even a function call, if we
 387  * can avoid it.
 388  *
 389  * Therefore, we'll inline all those functions so that in the best case, we'll
 390  * see that kmemcg is off for everybody and proceed quickly.  If it is on,
 391  * we'll still do most of the flag checking inline. We check a lot of
 392  * conditions, but because they are pretty simple, they are expected to be
 393  * fast.
 394  */
 395 bool __memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg,
 396                                         int order);
 397 void __memcg_kmem_commit_charge(struct page *page,
 398                                        struct mem_cgroup *memcg, int order);
 399 void __memcg_kmem_uncharge_pages(struct page *page, int order);
 400
 401 int memcg_cache_id(struct mem_cgroup *memcg);
 402
 403 void memcg_update_array_size(int num_groups);
 404
 405 struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep);
 406 void __memcg_kmem_put_cache(struct kmem_cache *cachep);
 407
 408 int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp,
 409                       unsigned long nr_pages);
 410 void memcg_uncharge_kmem(struct mem_cgroup *memcg, unsigned long nr_pages);
 411
 412 /**
 413  * memcg_kmem_newpage_charge: verify if a new kmem allocation is allowed.
 414  * @gfp: the gfp allocation flags.
 415  * @memcg: a pointer to the memcg this was charged against.
 416  * @order: allocation order.
 417  *
 418  * returns true if the memcg where the current task belongs can hold this
 419  * allocation.
 420  *
 421  * We return true automatically if this allocation is not to be accounted to
 422  * any memcg.
 423  */
 424 static inline bool
 425 memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
 426 {
 427         if (!memcg_kmem_enabled())
 428                 return true;
 429
 430         /*
 431          * __GFP_NOFAIL allocations will move on even if charging is not
 432          * possible. Therefore we don't even try, and have this allocation
 433          * unaccounted. We could in theory charge it forcibly, but we hope
 434          * those allocations are rare, and won't be worth the trouble.
 435          */
 436         if (gfp & __GFP_NOFAIL)
 437                 return true;
 438         if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD))
 439                 return true;
 440
 441         /* If the test is dying, just let it go. */
 442         if (unlikely(fatal_signal_pending(current)))
 443                 return true;
 444
 445         return __memcg_kmem_newpage_charge(gfp, memcg, order);
 446 }
 447
 448 /**
 449  * memcg_kmem_uncharge_pages: uncharge pages from memcg
 450  * @page: pointer to struct page being freed
 451  * @order: allocation order.
 452  */
 453 static inline void
 454 memcg_kmem_uncharge_pages(struct page *page, int order)
 455 {
 456         if (memcg_kmem_enabled())
 457                 __memcg_kmem_uncharge_pages(page, order);
 458 }
 459
 460 /**
 461  * memcg_kmem_commit_charge: embeds correct memcg in a page
 462  * @page: pointer to struct page recently allocated
 463  * @memcg: the memcg structure we charged against
 464  * @order: allocation order.
 465  *
 466  * Needs to be called after memcg_kmem_newpage_charge, regardless of success or
 467  * failure of the allocation. if @page is NULL, this function will revert the
 468  * charges. Otherwise, it will commit @page to @memcg.
 469  */
 470 static inline void
 471 memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
 472 {
 473         if (memcg_kmem_enabled() && memcg)
 474                 __memcg_kmem_commit_charge(page, memcg, order);
 475 }
 476
 477 /**
 478  * memcg_kmem_get_cache: selects the correct per-memcg cache for allocation
 479  * @cachep: the original global kmem cache
 480  * @gfp: allocation flags.
 481  *
 482  * All memory allocated from a per-memcg cache is charged to the owner memcg.
 483  */
 484 static __always_inline struct kmem_cache *
 485 memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
 486 {
 487         if (!memcg_kmem_enabled())
 488                 return cachep;
 489         if (gfp & __GFP_NOFAIL)
 490                 return cachep;
 491         if (in_interrupt() || (!current->mm) || (current->flags & PF_KTHREAD))
 492                 return cachep;
 493         if (unlikely(fatal_signal_pending(current)))
 494                 return cachep;
 495
 496         return __memcg_kmem_get_cache(cachep);
 497 }
 498
 499 static __always_inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
 500 {
 501         if (memcg_kmem_enabled())
 502                 __memcg_kmem_put_cache(cachep);
 503 }
 504 #else
 505 #define for_each_memcg_cache_index(_idx)        \
 506         for (; NULL; )
 507
 508 static inline bool memcg_kmem_enabled(void)
 509 {
 510         return false;
 511 }
 512
 513 static inline bool
 514 memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
 515 {
 516         return true;
 517 }
 518
 519 static inline void memcg_kmem_uncharge_pages(struct page *page, int order)
 520 {
 521 }
 522
 523 static inline void
 524 memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
 525 {
 526 }
 527
 528 static inline int memcg_cache_id(struct mem_cgroup *memcg)
 529 {
 530         return -1;
 531 }
 532
 533 static inline struct kmem_cache *
 534 memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
 535 {
 536         return cachep;
 537 }
 538
 539 static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
 540 {
 541 }
 542 #endif /* CONFIG_MEMCG_KMEM */
 543 #endif /* _LINUX_MEMCONTROL_H */
 544