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