8f4fc071b1
Not all kmem allocations should be accounted to memcg. The following patch gives an example when accounting of a certain type of allocations to memcg can effectively result in a memory leak. This patch adds the __GFP_NOACCOUNT flag which if passed to kmalloc and friends will force the allocation to go through the root cgroup. It will be used by the next patch. Note, since in case of kmemleak enabled each kmalloc implies yet another allocation from the kmemleak_object cache, we add __GFP_NOACCOUNT to gfp_kmemleak_mask. Alternatively, we could introduce a per kmem cache flag disabling accounting for all allocations of a particular kind, but (a) we would not be able to bypass accounting for kmalloc then and (b) a kmem cache with this flag set could not be merged with a kmem cache without this flag, which would increase the number of global caches and therefore fragmentation even if the memory cgroup controller is not used. Despite its generic name, currently __GFP_NOACCOUNT disables accounting only for kmem allocations while user page allocations are always charged. To catch abusing of this flag, a warning is issued on an attempt of passing it to mem_cgroup_try_charge. Signed-off-by: Vladimir Davydov <vdavydov@parallels.com> Cc: Tejun Heo <tj@kernel.org> Cc: Johannes Weiner <hannes@cmpxchg.org> Cc: Michal Hocko <mhocko@suse.cz> Cc: Christoph Lameter <cl@linux.com> Cc: Pekka Enberg <penberg@kernel.org> Cc: David Rientjes <rientjes@google.com> Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com> Cc: Greg Thelen <gthelen@google.com> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Cc: <stable@vger.kernel.org> [4.0.x] Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
610 lines
15 KiB
C
610 lines
15 KiB
C
/* memcontrol.h - Memory Controller
|
|
*
|
|
* Copyright IBM Corporation, 2007
|
|
* Author Balbir Singh <balbir@linux.vnet.ibm.com>
|
|
*
|
|
* Copyright 2007 OpenVZ SWsoft Inc
|
|
* Author: Pavel Emelianov <xemul@openvz.org>
|
|
*
|
|
* 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
|
|
#include <linux/cgroup.h>
|
|
#include <linux/vm_event_item.h>
|
|
#include <linux/hardirq.h>
|
|
#include <linux/jump_label.h>
|
|
|
|
struct mem_cgroup;
|
|
struct page;
|
|
struct mm_struct;
|
|
struct kmem_cache;
|
|
|
|
/*
|
|
* 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 */
|
|
MEM_CGROUP_STAT_WRITEBACK, /* # of pages under writeback */
|
|
MEM_CGROUP_STAT_SWAP, /* # of pages, swapped out */
|
|
MEM_CGROUP_STAT_NSTATS,
|
|
};
|
|
|
|
struct mem_cgroup_reclaim_cookie {
|
|
struct zone *zone;
|
|
int priority;
|
|
unsigned int generation;
|
|
};
|
|
|
|
enum mem_cgroup_events_index {
|
|
MEM_CGROUP_EVENTS_PGPGIN, /* # of pages paged in */
|
|
MEM_CGROUP_EVENTS_PGPGOUT, /* # of pages paged out */
|
|
MEM_CGROUP_EVENTS_PGFAULT, /* # of page-faults */
|
|
MEM_CGROUP_EVENTS_PGMAJFAULT, /* # of major page-faults */
|
|
MEM_CGROUP_EVENTS_NSTATS,
|
|
/* default hierarchy events */
|
|
MEMCG_LOW = MEM_CGROUP_EVENTS_NSTATS,
|
|
MEMCG_HIGH,
|
|
MEMCG_MAX,
|
|
MEMCG_OOM,
|
|
MEMCG_NR_EVENTS,
|
|
};
|
|
|
|
#ifdef CONFIG_MEMCG
|
|
void mem_cgroup_events(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_events_index idx,
|
|
unsigned int nr);
|
|
|
|
bool mem_cgroup_low(struct mem_cgroup *root, struct mem_cgroup *memcg);
|
|
|
|
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);
|
|
void mem_cgroup_uncharge(struct page *page);
|
|
void mem_cgroup_uncharge_list(struct list_head *page_list);
|
|
|
|
void mem_cgroup_migrate(struct page *oldpage, struct page *newpage,
|
|
bool lrucare);
|
|
|
|
struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *);
|
|
struct lruvec *mem_cgroup_page_lruvec(struct page *, struct zone *);
|
|
|
|
bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
|
|
struct mem_cgroup *root);
|
|
bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg);
|
|
|
|
extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
|
|
extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
|
|
|
|
extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
|
|
extern struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css);
|
|
|
|
static inline bool mm_match_cgroup(struct mm_struct *mm,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *task_memcg;
|
|
bool match = false;
|
|
|
|
rcu_read_lock();
|
|
task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
|
|
if (task_memcg)
|
|
match = mem_cgroup_is_descendant(task_memcg, memcg);
|
|
rcu_read_unlock();
|
|
return match;
|
|
}
|
|
|
|
extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
|
|
|
|
struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
|
|
struct mem_cgroup *,
|
|
struct mem_cgroup_reclaim_cookie *);
|
|
void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
|
|
|
|
/*
|
|
* For memory reclaim.
|
|
*/
|
|
int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec);
|
|
bool mem_cgroup_lruvec_online(struct lruvec *lruvec);
|
|
int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
|
|
unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list);
|
|
void mem_cgroup_update_lru_size(struct lruvec *, enum lru_list, int);
|
|
extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
|
|
struct task_struct *p);
|
|
|
|
static inline void mem_cgroup_oom_enable(void)
|
|
{
|
|
WARN_ON(current->memcg_oom.may_oom);
|
|
current->memcg_oom.may_oom = 1;
|
|
}
|
|
|
|
static inline void mem_cgroup_oom_disable(void)
|
|
{
|
|
WARN_ON(!current->memcg_oom.may_oom);
|
|
current->memcg_oom.may_oom = 0;
|
|
}
|
|
|
|
static inline bool task_in_memcg_oom(struct task_struct *p)
|
|
{
|
|
return p->memcg_oom.memcg;
|
|
}
|
|
|
|
bool mem_cgroup_oom_synchronize(bool wait);
|
|
|
|
#ifdef CONFIG_MEMCG_SWAP
|
|
extern int do_swap_account;
|
|
#endif
|
|
|
|
static inline bool mem_cgroup_disabled(void)
|
|
{
|
|
if (memory_cgrp_subsys.disabled)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page);
|
|
void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx, int val);
|
|
void mem_cgroup_end_page_stat(struct mem_cgroup *memcg);
|
|
|
|
static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
mem_cgroup_update_page_stat(memcg, idx, 1);
|
|
}
|
|
|
|
static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
mem_cgroup_update_page_stat(memcg, idx, -1);
|
|
}
|
|
|
|
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
|
|
gfp_t gfp_mask,
|
|
unsigned long *total_scanned);
|
|
|
|
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);
|
|
}
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
void mem_cgroup_split_huge_fixup(struct page *head);
|
|
#endif
|
|
|
|
#else /* CONFIG_MEMCG */
|
|
struct mem_cgroup;
|
|
|
|
static inline void mem_cgroup_events(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_events_index idx,
|
|
unsigned int nr)
|
|
{
|
|
}
|
|
|
|
static inline bool mem_cgroup_low(struct mem_cgroup *root,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
|
|
gfp_t gfp_mask,
|
|
struct mem_cgroup **memcgp)
|
|
{
|
|
*memcgp = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static inline void mem_cgroup_commit_charge(struct page *page,
|
|
struct mem_cgroup *memcg,
|
|
bool lrucare)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_cancel_charge(struct page *page,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_uncharge(struct page *page)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_uncharge_list(struct list_head *page_list)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_migrate(struct page *oldpage,
|
|
struct page *newpage,
|
|
bool lrucare)
|
|
{
|
|
}
|
|
|
|
static inline struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
return &zone->lruvec;
|
|
}
|
|
|
|
static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
|
|
struct zone *zone)
|
|
{
|
|
return &zone->lruvec;
|
|
}
|
|
|
|
static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline bool mm_match_cgroup(struct mm_struct *mm,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static inline bool task_in_mem_cgroup(struct task_struct *task,
|
|
const struct mem_cgroup *memcg)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static inline struct cgroup_subsys_state
|
|
*mem_cgroup_css(struct mem_cgroup *memcg)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
static inline bool mem_cgroup_disabled(void)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static inline int
|
|
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
static inline unsigned long
|
|
mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void
|
|
mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
|
|
int increment)
|
|
{
|
|
}
|
|
|
|
static inline void
|
|
mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
|
|
{
|
|
}
|
|
|
|
static inline struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline void mem_cgroup_end_page_stat(struct mem_cgroup *memcg)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_oom_enable(void)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_oom_disable(void)
|
|
{
|
|
}
|
|
|
|
static inline bool task_in_memcg_oom(struct task_struct *p)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline bool mem_cgroup_oom_synchronize(bool wait)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
}
|
|
|
|
static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
|
|
gfp_t gfp_mask,
|
|
unsigned long *total_scanned)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void mem_cgroup_split_huge_fixup(struct page *head)
|
|
{
|
|
}
|
|
|
|
static inline
|
|
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
|
|
{
|
|
}
|
|
#endif /* CONFIG_MEMCG */
|
|
|
|
enum {
|
|
UNDER_LIMIT,
|
|
SOFT_LIMIT,
|
|
OVER_LIMIT,
|
|
};
|
|
|
|
struct sock;
|
|
#if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
|
|
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)
|
|
{
|
|
}
|
|
#endif /* CONFIG_INET && CONFIG_MEMCG_KMEM */
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
extern struct static_key memcg_kmem_enabled_key;
|
|
|
|
extern int memcg_nr_cache_ids;
|
|
extern void memcg_get_cache_ids(void);
|
|
extern void memcg_put_cache_ids(void);
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
#define for_each_memcg_cache_index(_idx) \
|
|
for ((_idx) = 0; (_idx) < memcg_nr_cache_ids; (_idx)++)
|
|
|
|
static inline bool memcg_kmem_enabled(void)
|
|
{
|
|
return static_key_false(&memcg_kmem_enabled_key);
|
|
}
|
|
|
|
bool memcg_kmem_is_active(struct mem_cgroup *memcg);
|
|
|
|
/*
|
|
* 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);
|
|
|
|
int memcg_cache_id(struct mem_cgroup *memcg);
|
|
|
|
struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep);
|
|
void __memcg_kmem_put_cache(struct kmem_cache *cachep);
|
|
|
|
struct mem_cgroup *__mem_cgroup_from_kmem(void *ptr);
|
|
|
|
int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp,
|
|
unsigned long nr_pages);
|
|
void memcg_uncharge_kmem(struct mem_cgroup *memcg, unsigned long nr_pages);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
if (gfp & __GFP_NOACCOUNT)
|
|
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 forcibly, but we hope
|
|
* those allocations are rare, and won't be worth the trouble.
|
|
*/
|
|
if (gfp & __GFP_NOFAIL)
|
|
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.
|
|
*/
|
|
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 @page to @memcg.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* memcg_kmem_get_cache: selects the correct per-memcg cache for allocation
|
|
* @cachep: the original global kmem cache
|
|
* @gfp: allocation flags.
|
|
*
|
|
* All memory allocated from a per-memcg cache is charged to the owner memcg.
|
|
*/
|
|
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_NOACCOUNT)
|
|
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);
|
|
}
|
|
|
|
static __always_inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
|
|
{
|
|
if (memcg_kmem_enabled())
|
|
__memcg_kmem_put_cache(cachep);
|
|
}
|
|
|
|
static __always_inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
|
|
{
|
|
if (!memcg_kmem_enabled())
|
|
return NULL;
|
|
return __mem_cgroup_from_kmem(ptr);
|
|
}
|
|
#else
|
|
#define for_each_memcg_cache_index(_idx) \
|
|
for (; NULL; )
|
|
|
|
static inline bool memcg_kmem_enabled(void)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline bool memcg_kmem_is_active(struct mem_cgroup *memcg)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
static inline int memcg_cache_id(struct mem_cgroup *memcg)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static inline void memcg_get_cache_ids(void)
|
|
{
|
|
}
|
|
|
|
static inline void memcg_put_cache_ids(void)
|
|
{
|
|
}
|
|
|
|
static inline struct kmem_cache *
|
|
memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
|
|
{
|
|
return cachep;
|
|
}
|
|
|
|
static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
|
|
{
|
|
}
|
|
|
|
static inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif /* CONFIG_MEMCG_KMEM */
|
|
#endif /* _LINUX_MEMCONTROL_H */
|
|
|