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