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