mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 16:16:39 +07:00
d2973697b3
The memcg control knobs indicate the highest possible value using the symbolic name "infinity", which is long and awkward to type. Switch to the string "max", which is just as descriptive but shorter and sweeter. This changes a user interface, so do it before the release and before the development flag is dropped from the default hierarchy. Signed-off-by: Johannes Weiner <hannes@cmpxchg.org> Cc: Michal Hocko <mhocko@suse.cz> Cc: Tejun Heo <tj@kernel.org> Cc: Vladimir Davydov <vdavydov@parallels.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
5928 lines
150 KiB
C
5928 lines
150 KiB
C
/* memcontrol.c - 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>
|
|
*
|
|
* Memory thresholds
|
|
* Copyright (C) 2009 Nokia Corporation
|
|
* Author: Kirill A. Shutemov
|
|
*
|
|
* Kernel Memory Controller
|
|
* Copyright (C) 2012 Parallels Inc. and Google Inc.
|
|
* Authors: Glauber Costa and Suleiman Souhlal
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <linux/page_counter.h>
|
|
#include <linux/memcontrol.h>
|
|
#include <linux/cgroup.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/hugetlb.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/page-flags.h>
|
|
#include <linux/backing-dev.h>
|
|
#include <linux/bit_spinlock.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/limits.h>
|
|
#include <linux/export.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/rbtree.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/swap.h>
|
|
#include <linux/swapops.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/eventfd.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/sort.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/vmpressure.h>
|
|
#include <linux/mm_inline.h>
|
|
#include <linux/swap_cgroup.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/oom.h>
|
|
#include <linux/lockdep.h>
|
|
#include <linux/file.h>
|
|
#include "internal.h"
|
|
#include <net/sock.h>
|
|
#include <net/ip.h>
|
|
#include <net/tcp_memcontrol.h>
|
|
#include "slab.h"
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <trace/events/vmscan.h>
|
|
|
|
struct cgroup_subsys memory_cgrp_subsys __read_mostly;
|
|
EXPORT_SYMBOL(memory_cgrp_subsys);
|
|
|
|
#define MEM_CGROUP_RECLAIM_RETRIES 5
|
|
static struct mem_cgroup *root_mem_cgroup __read_mostly;
|
|
|
|
/* Whether the swap controller is active */
|
|
#ifdef CONFIG_MEMCG_SWAP
|
|
int do_swap_account __read_mostly;
|
|
#else
|
|
#define do_swap_account 0
|
|
#endif
|
|
|
|
static const char * const mem_cgroup_stat_names[] = {
|
|
"cache",
|
|
"rss",
|
|
"rss_huge",
|
|
"mapped_file",
|
|
"writeback",
|
|
"swap",
|
|
};
|
|
|
|
static const char * const mem_cgroup_events_names[] = {
|
|
"pgpgin",
|
|
"pgpgout",
|
|
"pgfault",
|
|
"pgmajfault",
|
|
};
|
|
|
|
static const char * const mem_cgroup_lru_names[] = {
|
|
"inactive_anon",
|
|
"active_anon",
|
|
"inactive_file",
|
|
"active_file",
|
|
"unevictable",
|
|
};
|
|
|
|
/*
|
|
* Per memcg event counter is incremented at every pagein/pageout. With THP,
|
|
* it will be incremated by the number of pages. This counter is used for
|
|
* for trigger some periodic events. This is straightforward and better
|
|
* than using jiffies etc. to handle periodic memcg event.
|
|
*/
|
|
enum mem_cgroup_events_target {
|
|
MEM_CGROUP_TARGET_THRESH,
|
|
MEM_CGROUP_TARGET_SOFTLIMIT,
|
|
MEM_CGROUP_TARGET_NUMAINFO,
|
|
MEM_CGROUP_NTARGETS,
|
|
};
|
|
#define THRESHOLDS_EVENTS_TARGET 128
|
|
#define SOFTLIMIT_EVENTS_TARGET 1024
|
|
#define NUMAINFO_EVENTS_TARGET 1024
|
|
|
|
struct mem_cgroup_stat_cpu {
|
|
long count[MEM_CGROUP_STAT_NSTATS];
|
|
unsigned long events[MEMCG_NR_EVENTS];
|
|
unsigned long nr_page_events;
|
|
unsigned long targets[MEM_CGROUP_NTARGETS];
|
|
};
|
|
|
|
struct reclaim_iter {
|
|
struct mem_cgroup *position;
|
|
/* scan generation, increased every round-trip */
|
|
unsigned int generation;
|
|
};
|
|
|
|
/*
|
|
* per-zone information in memory controller.
|
|
*/
|
|
struct mem_cgroup_per_zone {
|
|
struct lruvec lruvec;
|
|
unsigned long lru_size[NR_LRU_LISTS];
|
|
|
|
struct reclaim_iter iter[DEF_PRIORITY + 1];
|
|
|
|
struct rb_node tree_node; /* RB tree node */
|
|
unsigned long usage_in_excess;/* Set to the value by which */
|
|
/* the soft limit is exceeded*/
|
|
bool on_tree;
|
|
struct mem_cgroup *memcg; /* Back pointer, we cannot */
|
|
/* use container_of */
|
|
};
|
|
|
|
struct mem_cgroup_per_node {
|
|
struct mem_cgroup_per_zone zoneinfo[MAX_NR_ZONES];
|
|
};
|
|
|
|
/*
|
|
* Cgroups above their limits are maintained in a RB-Tree, independent of
|
|
* their hierarchy representation
|
|
*/
|
|
|
|
struct mem_cgroup_tree_per_zone {
|
|
struct rb_root rb_root;
|
|
spinlock_t lock;
|
|
};
|
|
|
|
struct mem_cgroup_tree_per_node {
|
|
struct mem_cgroup_tree_per_zone rb_tree_per_zone[MAX_NR_ZONES];
|
|
};
|
|
|
|
struct mem_cgroup_tree {
|
|
struct mem_cgroup_tree_per_node *rb_tree_per_node[MAX_NUMNODES];
|
|
};
|
|
|
|
static struct mem_cgroup_tree soft_limit_tree __read_mostly;
|
|
|
|
struct mem_cgroup_threshold {
|
|
struct eventfd_ctx *eventfd;
|
|
unsigned long threshold;
|
|
};
|
|
|
|
/* For threshold */
|
|
struct mem_cgroup_threshold_ary {
|
|
/* An array index points to threshold just below or equal to usage. */
|
|
int current_threshold;
|
|
/* Size of entries[] */
|
|
unsigned int size;
|
|
/* Array of thresholds */
|
|
struct mem_cgroup_threshold entries[0];
|
|
};
|
|
|
|
struct mem_cgroup_thresholds {
|
|
/* Primary thresholds array */
|
|
struct mem_cgroup_threshold_ary *primary;
|
|
/*
|
|
* Spare threshold array.
|
|
* This is needed to make mem_cgroup_unregister_event() "never fail".
|
|
* It must be able to store at least primary->size - 1 entries.
|
|
*/
|
|
struct mem_cgroup_threshold_ary *spare;
|
|
};
|
|
|
|
/* for OOM */
|
|
struct mem_cgroup_eventfd_list {
|
|
struct list_head list;
|
|
struct eventfd_ctx *eventfd;
|
|
};
|
|
|
|
/*
|
|
* cgroup_event represents events which userspace want to receive.
|
|
*/
|
|
struct mem_cgroup_event {
|
|
/*
|
|
* memcg which the event belongs to.
|
|
*/
|
|
struct mem_cgroup *memcg;
|
|
/*
|
|
* eventfd to signal userspace about the event.
|
|
*/
|
|
struct eventfd_ctx *eventfd;
|
|
/*
|
|
* Each of these stored in a list by the cgroup.
|
|
*/
|
|
struct list_head list;
|
|
/*
|
|
* register_event() callback will be used to add new userspace
|
|
* waiter for changes related to this event. Use eventfd_signal()
|
|
* on eventfd to send notification to userspace.
|
|
*/
|
|
int (*register_event)(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, const char *args);
|
|
/*
|
|
* unregister_event() callback will be called when userspace closes
|
|
* the eventfd or on cgroup removing. This callback must be set,
|
|
* if you want provide notification functionality.
|
|
*/
|
|
void (*unregister_event)(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd);
|
|
/*
|
|
* All fields below needed to unregister event when
|
|
* userspace closes eventfd.
|
|
*/
|
|
poll_table pt;
|
|
wait_queue_head_t *wqh;
|
|
wait_queue_t wait;
|
|
struct work_struct remove;
|
|
};
|
|
|
|
static void mem_cgroup_threshold(struct mem_cgroup *memcg);
|
|
static void mem_cgroup_oom_notify(struct mem_cgroup *memcg);
|
|
|
|
/*
|
|
* The memory controller data structure. The memory controller controls both
|
|
* page cache and RSS per cgroup. We would eventually like to provide
|
|
* statistics based on the statistics developed by Rik Van Riel for clock-pro,
|
|
* to help the administrator determine what knobs to tune.
|
|
*
|
|
* TODO: Add a water mark for the memory controller. Reclaim will begin when
|
|
* we hit the water mark. May be even add a low water mark, such that
|
|
* no reclaim occurs from a cgroup at it's low water mark, this is
|
|
* a feature that will be implemented much later in the future.
|
|
*/
|
|
struct mem_cgroup {
|
|
struct cgroup_subsys_state css;
|
|
|
|
/* Accounted resources */
|
|
struct page_counter memory;
|
|
struct page_counter memsw;
|
|
struct page_counter kmem;
|
|
|
|
/* Normal memory consumption range */
|
|
unsigned long low;
|
|
unsigned long high;
|
|
|
|
unsigned long soft_limit;
|
|
|
|
/* vmpressure notifications */
|
|
struct vmpressure vmpressure;
|
|
|
|
/* css_online() has been completed */
|
|
int initialized;
|
|
|
|
/*
|
|
* Should the accounting and control be hierarchical, per subtree?
|
|
*/
|
|
bool use_hierarchy;
|
|
|
|
bool oom_lock;
|
|
atomic_t under_oom;
|
|
atomic_t oom_wakeups;
|
|
|
|
int swappiness;
|
|
/* OOM-Killer disable */
|
|
int oom_kill_disable;
|
|
|
|
/* protect arrays of thresholds */
|
|
struct mutex thresholds_lock;
|
|
|
|
/* thresholds for memory usage. RCU-protected */
|
|
struct mem_cgroup_thresholds thresholds;
|
|
|
|
/* thresholds for mem+swap usage. RCU-protected */
|
|
struct mem_cgroup_thresholds memsw_thresholds;
|
|
|
|
/* For oom notifier event fd */
|
|
struct list_head oom_notify;
|
|
|
|
/*
|
|
* Should we move charges of a task when a task is moved into this
|
|
* mem_cgroup ? And what type of charges should we move ?
|
|
*/
|
|
unsigned long move_charge_at_immigrate;
|
|
/*
|
|
* set > 0 if pages under this cgroup are moving to other cgroup.
|
|
*/
|
|
atomic_t moving_account;
|
|
/* taken only while moving_account > 0 */
|
|
spinlock_t move_lock;
|
|
struct task_struct *move_lock_task;
|
|
unsigned long move_lock_flags;
|
|
/*
|
|
* percpu counter.
|
|
*/
|
|
struct mem_cgroup_stat_cpu __percpu *stat;
|
|
/*
|
|
* used when a cpu is offlined or other synchronizations
|
|
* See mem_cgroup_read_stat().
|
|
*/
|
|
struct mem_cgroup_stat_cpu nocpu_base;
|
|
spinlock_t pcp_counter_lock;
|
|
|
|
#if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
|
|
struct cg_proto tcp_mem;
|
|
#endif
|
|
#if defined(CONFIG_MEMCG_KMEM)
|
|
/* Index in the kmem_cache->memcg_params.memcg_caches array */
|
|
int kmemcg_id;
|
|
bool kmem_acct_activated;
|
|
bool kmem_acct_active;
|
|
#endif
|
|
|
|
int last_scanned_node;
|
|
#if MAX_NUMNODES > 1
|
|
nodemask_t scan_nodes;
|
|
atomic_t numainfo_events;
|
|
atomic_t numainfo_updating;
|
|
#endif
|
|
|
|
/* List of events which userspace want to receive */
|
|
struct list_head event_list;
|
|
spinlock_t event_list_lock;
|
|
|
|
struct mem_cgroup_per_node *nodeinfo[0];
|
|
/* WARNING: nodeinfo must be the last member here */
|
|
};
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
bool memcg_kmem_is_active(struct mem_cgroup *memcg)
|
|
{
|
|
return memcg->kmem_acct_active;
|
|
}
|
|
#endif
|
|
|
|
/* Stuffs for move charges at task migration. */
|
|
/*
|
|
* Types of charges to be moved.
|
|
*/
|
|
#define MOVE_ANON 0x1U
|
|
#define MOVE_FILE 0x2U
|
|
#define MOVE_MASK (MOVE_ANON | MOVE_FILE)
|
|
|
|
/* "mc" and its members are protected by cgroup_mutex */
|
|
static struct move_charge_struct {
|
|
spinlock_t lock; /* for from, to */
|
|
struct mem_cgroup *from;
|
|
struct mem_cgroup *to;
|
|
unsigned long flags;
|
|
unsigned long precharge;
|
|
unsigned long moved_charge;
|
|
unsigned long moved_swap;
|
|
struct task_struct *moving_task; /* a task moving charges */
|
|
wait_queue_head_t waitq; /* a waitq for other context */
|
|
} mc = {
|
|
.lock = __SPIN_LOCK_UNLOCKED(mc.lock),
|
|
.waitq = __WAIT_QUEUE_HEAD_INITIALIZER(mc.waitq),
|
|
};
|
|
|
|
/*
|
|
* Maximum loops in mem_cgroup_hierarchical_reclaim(), used for soft
|
|
* limit reclaim to prevent infinite loops, if they ever occur.
|
|
*/
|
|
#define MEM_CGROUP_MAX_RECLAIM_LOOPS 100
|
|
#define MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS 2
|
|
|
|
enum charge_type {
|
|
MEM_CGROUP_CHARGE_TYPE_CACHE = 0,
|
|
MEM_CGROUP_CHARGE_TYPE_ANON,
|
|
MEM_CGROUP_CHARGE_TYPE_SWAPOUT, /* for accounting swapcache */
|
|
MEM_CGROUP_CHARGE_TYPE_DROP, /* a page was unused swap cache */
|
|
NR_CHARGE_TYPE,
|
|
};
|
|
|
|
/* for encoding cft->private value on file */
|
|
enum res_type {
|
|
_MEM,
|
|
_MEMSWAP,
|
|
_OOM_TYPE,
|
|
_KMEM,
|
|
};
|
|
|
|
#define MEMFILE_PRIVATE(x, val) ((x) << 16 | (val))
|
|
#define MEMFILE_TYPE(val) ((val) >> 16 & 0xffff)
|
|
#define MEMFILE_ATTR(val) ((val) & 0xffff)
|
|
/* Used for OOM nofiier */
|
|
#define OOM_CONTROL (0)
|
|
|
|
/*
|
|
* The memcg_create_mutex will be held whenever a new cgroup is created.
|
|
* As a consequence, any change that needs to protect against new child cgroups
|
|
* appearing has to hold it as well.
|
|
*/
|
|
static DEFINE_MUTEX(memcg_create_mutex);
|
|
|
|
struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
|
|
{
|
|
return s ? container_of(s, struct mem_cgroup, css) : NULL;
|
|
}
|
|
|
|
/* Some nice accessors for the vmpressure. */
|
|
struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg)
|
|
{
|
|
if (!memcg)
|
|
memcg = root_mem_cgroup;
|
|
return &memcg->vmpressure;
|
|
}
|
|
|
|
struct cgroup_subsys_state *vmpressure_to_css(struct vmpressure *vmpr)
|
|
{
|
|
return &container_of(vmpr, struct mem_cgroup, vmpressure)->css;
|
|
}
|
|
|
|
static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
|
|
{
|
|
return (memcg == root_mem_cgroup);
|
|
}
|
|
|
|
/*
|
|
* We restrict the id in the range of [1, 65535], so it can fit into
|
|
* an unsigned short.
|
|
*/
|
|
#define MEM_CGROUP_ID_MAX USHRT_MAX
|
|
|
|
static inline unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
|
|
{
|
|
return memcg->css.id;
|
|
}
|
|
|
|
static inline struct mem_cgroup *mem_cgroup_from_id(unsigned short id)
|
|
{
|
|
struct cgroup_subsys_state *css;
|
|
|
|
css = css_from_id(id, &memory_cgrp_subsys);
|
|
return mem_cgroup_from_css(css);
|
|
}
|
|
|
|
/* Writing them here to avoid exposing memcg's inner layout */
|
|
#if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
|
|
|
|
void sock_update_memcg(struct sock *sk)
|
|
{
|
|
if (mem_cgroup_sockets_enabled) {
|
|
struct mem_cgroup *memcg;
|
|
struct cg_proto *cg_proto;
|
|
|
|
BUG_ON(!sk->sk_prot->proto_cgroup);
|
|
|
|
/* Socket cloning can throw us here with sk_cgrp already
|
|
* filled. It won't however, necessarily happen from
|
|
* process context. So the test for root memcg given
|
|
* the current task's memcg won't help us in this case.
|
|
*
|
|
* Respecting the original socket's memcg is a better
|
|
* decision in this case.
|
|
*/
|
|
if (sk->sk_cgrp) {
|
|
BUG_ON(mem_cgroup_is_root(sk->sk_cgrp->memcg));
|
|
css_get(&sk->sk_cgrp->memcg->css);
|
|
return;
|
|
}
|
|
|
|
rcu_read_lock();
|
|
memcg = mem_cgroup_from_task(current);
|
|
cg_proto = sk->sk_prot->proto_cgroup(memcg);
|
|
if (!mem_cgroup_is_root(memcg) &&
|
|
memcg_proto_active(cg_proto) &&
|
|
css_tryget_online(&memcg->css)) {
|
|
sk->sk_cgrp = cg_proto;
|
|
}
|
|
rcu_read_unlock();
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(sock_update_memcg);
|
|
|
|
void sock_release_memcg(struct sock *sk)
|
|
{
|
|
if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
|
|
struct mem_cgroup *memcg;
|
|
WARN_ON(!sk->sk_cgrp->memcg);
|
|
memcg = sk->sk_cgrp->memcg;
|
|
css_put(&sk->sk_cgrp->memcg->css);
|
|
}
|
|
}
|
|
|
|
struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
|
|
{
|
|
if (!memcg || mem_cgroup_is_root(memcg))
|
|
return NULL;
|
|
|
|
return &memcg->tcp_mem;
|
|
}
|
|
EXPORT_SYMBOL(tcp_proto_cgroup);
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
/*
|
|
* This will be the memcg's index in each cache's ->memcg_params.memcg_caches.
|
|
* The main reason for not using cgroup id for this:
|
|
* this works better in sparse environments, where we have a lot of memcgs,
|
|
* but only a few kmem-limited. Or also, if we have, for instance, 200
|
|
* memcgs, and none but the 200th is kmem-limited, we'd have to have a
|
|
* 200 entry array for that.
|
|
*
|
|
* The current size of the caches array is stored in memcg_nr_cache_ids. It
|
|
* will double each time we have to increase it.
|
|
*/
|
|
static DEFINE_IDA(memcg_cache_ida);
|
|
int memcg_nr_cache_ids;
|
|
|
|
/* Protects memcg_nr_cache_ids */
|
|
static DECLARE_RWSEM(memcg_cache_ids_sem);
|
|
|
|
void memcg_get_cache_ids(void)
|
|
{
|
|
down_read(&memcg_cache_ids_sem);
|
|
}
|
|
|
|
void memcg_put_cache_ids(void)
|
|
{
|
|
up_read(&memcg_cache_ids_sem);
|
|
}
|
|
|
|
/*
|
|
* MIN_SIZE is different than 1, because we would like to avoid going through
|
|
* the alloc/free process all the time. In a small machine, 4 kmem-limited
|
|
* cgroups is a reasonable guess. In the future, it could be a parameter or
|
|
* tunable, but that is strictly not necessary.
|
|
*
|
|
* MAX_SIZE should be as large as the number of cgrp_ids. Ideally, we could get
|
|
* this constant directly from cgroup, but it is understandable that this is
|
|
* better kept as an internal representation in cgroup.c. In any case, the
|
|
* cgrp_id space is not getting any smaller, and we don't have to necessarily
|
|
* increase ours as well if it increases.
|
|
*/
|
|
#define MEMCG_CACHES_MIN_SIZE 4
|
|
#define MEMCG_CACHES_MAX_SIZE MEM_CGROUP_ID_MAX
|
|
|
|
/*
|
|
* A lot of the calls to the cache allocation functions are expected to be
|
|
* inlined by the compiler. Since the calls to memcg_kmem_get_cache are
|
|
* conditional to this static branch, we'll have to allow modules that does
|
|
* kmem_cache_alloc and the such to see this symbol as well
|
|
*/
|
|
struct static_key memcg_kmem_enabled_key;
|
|
EXPORT_SYMBOL(memcg_kmem_enabled_key);
|
|
|
|
#endif /* CONFIG_MEMCG_KMEM */
|
|
|
|
static struct mem_cgroup_per_zone *
|
|
mem_cgroup_zone_zoneinfo(struct mem_cgroup *memcg, struct zone *zone)
|
|
{
|
|
int nid = zone_to_nid(zone);
|
|
int zid = zone_idx(zone);
|
|
|
|
return &memcg->nodeinfo[nid]->zoneinfo[zid];
|
|
}
|
|
|
|
struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg)
|
|
{
|
|
return &memcg->css;
|
|
}
|
|
|
|
static struct mem_cgroup_per_zone *
|
|
mem_cgroup_page_zoneinfo(struct mem_cgroup *memcg, struct page *page)
|
|
{
|
|
int nid = page_to_nid(page);
|
|
int zid = page_zonenum(page);
|
|
|
|
return &memcg->nodeinfo[nid]->zoneinfo[zid];
|
|
}
|
|
|
|
static struct mem_cgroup_tree_per_zone *
|
|
soft_limit_tree_node_zone(int nid, int zid)
|
|
{
|
|
return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
|
|
}
|
|
|
|
static struct mem_cgroup_tree_per_zone *
|
|
soft_limit_tree_from_page(struct page *page)
|
|
{
|
|
int nid = page_to_nid(page);
|
|
int zid = page_zonenum(page);
|
|
|
|
return &soft_limit_tree.rb_tree_per_node[nid]->rb_tree_per_zone[zid];
|
|
}
|
|
|
|
static void __mem_cgroup_insert_exceeded(struct mem_cgroup_per_zone *mz,
|
|
struct mem_cgroup_tree_per_zone *mctz,
|
|
unsigned long new_usage_in_excess)
|
|
{
|
|
struct rb_node **p = &mctz->rb_root.rb_node;
|
|
struct rb_node *parent = NULL;
|
|
struct mem_cgroup_per_zone *mz_node;
|
|
|
|
if (mz->on_tree)
|
|
return;
|
|
|
|
mz->usage_in_excess = new_usage_in_excess;
|
|
if (!mz->usage_in_excess)
|
|
return;
|
|
while (*p) {
|
|
parent = *p;
|
|
mz_node = rb_entry(parent, struct mem_cgroup_per_zone,
|
|
tree_node);
|
|
if (mz->usage_in_excess < mz_node->usage_in_excess)
|
|
p = &(*p)->rb_left;
|
|
/*
|
|
* We can't avoid mem cgroups that are over their soft
|
|
* limit by the same amount
|
|
*/
|
|
else if (mz->usage_in_excess >= mz_node->usage_in_excess)
|
|
p = &(*p)->rb_right;
|
|
}
|
|
rb_link_node(&mz->tree_node, parent, p);
|
|
rb_insert_color(&mz->tree_node, &mctz->rb_root);
|
|
mz->on_tree = true;
|
|
}
|
|
|
|
static void __mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
|
|
struct mem_cgroup_tree_per_zone *mctz)
|
|
{
|
|
if (!mz->on_tree)
|
|
return;
|
|
rb_erase(&mz->tree_node, &mctz->rb_root);
|
|
mz->on_tree = false;
|
|
}
|
|
|
|
static void mem_cgroup_remove_exceeded(struct mem_cgroup_per_zone *mz,
|
|
struct mem_cgroup_tree_per_zone *mctz)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&mctz->lock, flags);
|
|
__mem_cgroup_remove_exceeded(mz, mctz);
|
|
spin_unlock_irqrestore(&mctz->lock, flags);
|
|
}
|
|
|
|
static unsigned long soft_limit_excess(struct mem_cgroup *memcg)
|
|
{
|
|
unsigned long nr_pages = page_counter_read(&memcg->memory);
|
|
unsigned long soft_limit = ACCESS_ONCE(memcg->soft_limit);
|
|
unsigned long excess = 0;
|
|
|
|
if (nr_pages > soft_limit)
|
|
excess = nr_pages - soft_limit;
|
|
|
|
return excess;
|
|
}
|
|
|
|
static void mem_cgroup_update_tree(struct mem_cgroup *memcg, struct page *page)
|
|
{
|
|
unsigned long excess;
|
|
struct mem_cgroup_per_zone *mz;
|
|
struct mem_cgroup_tree_per_zone *mctz;
|
|
|
|
mctz = soft_limit_tree_from_page(page);
|
|
/*
|
|
* Necessary to update all ancestors when hierarchy is used.
|
|
* because their event counter is not touched.
|
|
*/
|
|
for (; memcg; memcg = parent_mem_cgroup(memcg)) {
|
|
mz = mem_cgroup_page_zoneinfo(memcg, page);
|
|
excess = soft_limit_excess(memcg);
|
|
/*
|
|
* We have to update the tree if mz is on RB-tree or
|
|
* mem is over its softlimit.
|
|
*/
|
|
if (excess || mz->on_tree) {
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&mctz->lock, flags);
|
|
/* if on-tree, remove it */
|
|
if (mz->on_tree)
|
|
__mem_cgroup_remove_exceeded(mz, mctz);
|
|
/*
|
|
* Insert again. mz->usage_in_excess will be updated.
|
|
* If excess is 0, no tree ops.
|
|
*/
|
|
__mem_cgroup_insert_exceeded(mz, mctz, excess);
|
|
spin_unlock_irqrestore(&mctz->lock, flags);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void mem_cgroup_remove_from_trees(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup_tree_per_zone *mctz;
|
|
struct mem_cgroup_per_zone *mz;
|
|
int nid, zid;
|
|
|
|
for_each_node(nid) {
|
|
for (zid = 0; zid < MAX_NR_ZONES; zid++) {
|
|
mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
|
|
mctz = soft_limit_tree_node_zone(nid, zid);
|
|
mem_cgroup_remove_exceeded(mz, mctz);
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct mem_cgroup_per_zone *
|
|
__mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
|
|
{
|
|
struct rb_node *rightmost = NULL;
|
|
struct mem_cgroup_per_zone *mz;
|
|
|
|
retry:
|
|
mz = NULL;
|
|
rightmost = rb_last(&mctz->rb_root);
|
|
if (!rightmost)
|
|
goto done; /* Nothing to reclaim from */
|
|
|
|
mz = rb_entry(rightmost, struct mem_cgroup_per_zone, tree_node);
|
|
/*
|
|
* Remove the node now but someone else can add it back,
|
|
* we will to add it back at the end of reclaim to its correct
|
|
* position in the tree.
|
|
*/
|
|
__mem_cgroup_remove_exceeded(mz, mctz);
|
|
if (!soft_limit_excess(mz->memcg) ||
|
|
!css_tryget_online(&mz->memcg->css))
|
|
goto retry;
|
|
done:
|
|
return mz;
|
|
}
|
|
|
|
static struct mem_cgroup_per_zone *
|
|
mem_cgroup_largest_soft_limit_node(struct mem_cgroup_tree_per_zone *mctz)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
|
|
spin_lock_irq(&mctz->lock);
|
|
mz = __mem_cgroup_largest_soft_limit_node(mctz);
|
|
spin_unlock_irq(&mctz->lock);
|
|
return mz;
|
|
}
|
|
|
|
/*
|
|
* Implementation Note: reading percpu statistics for memcg.
|
|
*
|
|
* Both of vmstat[] and percpu_counter has threshold and do periodic
|
|
* synchronization to implement "quick" read. There are trade-off between
|
|
* reading cost and precision of value. Then, we may have a chance to implement
|
|
* a periodic synchronizion of counter in memcg's counter.
|
|
*
|
|
* But this _read() function is used for user interface now. The user accounts
|
|
* memory usage by memory cgroup and he _always_ requires exact value because
|
|
* he accounts memory. Even if we provide quick-and-fuzzy read, we always
|
|
* have to visit all online cpus and make sum. So, for now, unnecessary
|
|
* synchronization is not implemented. (just implemented for cpu hotplug)
|
|
*
|
|
* If there are kernel internal actions which can make use of some not-exact
|
|
* value, and reading all cpu value can be performance bottleneck in some
|
|
* common workload, threashold and synchonization as vmstat[] should be
|
|
* implemented.
|
|
*/
|
|
static long mem_cgroup_read_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
long val = 0;
|
|
int cpu;
|
|
|
|
get_online_cpus();
|
|
for_each_online_cpu(cpu)
|
|
val += per_cpu(memcg->stat->count[idx], cpu);
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
spin_lock(&memcg->pcp_counter_lock);
|
|
val += memcg->nocpu_base.count[idx];
|
|
spin_unlock(&memcg->pcp_counter_lock);
|
|
#endif
|
|
put_online_cpus();
|
|
return val;
|
|
}
|
|
|
|
static unsigned long mem_cgroup_read_events(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_events_index idx)
|
|
{
|
|
unsigned long val = 0;
|
|
int cpu;
|
|
|
|
get_online_cpus();
|
|
for_each_online_cpu(cpu)
|
|
val += per_cpu(memcg->stat->events[idx], cpu);
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
spin_lock(&memcg->pcp_counter_lock);
|
|
val += memcg->nocpu_base.events[idx];
|
|
spin_unlock(&memcg->pcp_counter_lock);
|
|
#endif
|
|
put_online_cpus();
|
|
return val;
|
|
}
|
|
|
|
static void mem_cgroup_charge_statistics(struct mem_cgroup *memcg,
|
|
struct page *page,
|
|
int nr_pages)
|
|
{
|
|
/*
|
|
* Here, RSS means 'mapped anon' and anon's SwapCache. Shmem/tmpfs is
|
|
* counted as CACHE even if it's on ANON LRU.
|
|
*/
|
|
if (PageAnon(page))
|
|
__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS],
|
|
nr_pages);
|
|
else
|
|
__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_CACHE],
|
|
nr_pages);
|
|
|
|
if (PageTransHuge(page))
|
|
__this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
|
|
nr_pages);
|
|
|
|
/* pagein of a big page is an event. So, ignore page size */
|
|
if (nr_pages > 0)
|
|
__this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGIN]);
|
|
else {
|
|
__this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT]);
|
|
nr_pages = -nr_pages; /* for event */
|
|
}
|
|
|
|
__this_cpu_add(memcg->stat->nr_page_events, nr_pages);
|
|
}
|
|
|
|
unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
|
|
mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
|
|
return mz->lru_size[lru];
|
|
}
|
|
|
|
static unsigned long mem_cgroup_node_nr_lru_pages(struct mem_cgroup *memcg,
|
|
int nid,
|
|
unsigned int lru_mask)
|
|
{
|
|
unsigned long nr = 0;
|
|
int zid;
|
|
|
|
VM_BUG_ON((unsigned)nid >= nr_node_ids);
|
|
|
|
for (zid = 0; zid < MAX_NR_ZONES; zid++) {
|
|
struct mem_cgroup_per_zone *mz;
|
|
enum lru_list lru;
|
|
|
|
for_each_lru(lru) {
|
|
if (!(BIT(lru) & lru_mask))
|
|
continue;
|
|
mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
|
|
nr += mz->lru_size[lru];
|
|
}
|
|
}
|
|
return nr;
|
|
}
|
|
|
|
static unsigned long mem_cgroup_nr_lru_pages(struct mem_cgroup *memcg,
|
|
unsigned int lru_mask)
|
|
{
|
|
unsigned long nr = 0;
|
|
int nid;
|
|
|
|
for_each_node_state(nid, N_MEMORY)
|
|
nr += mem_cgroup_node_nr_lru_pages(memcg, nid, lru_mask);
|
|
return nr;
|
|
}
|
|
|
|
static bool mem_cgroup_event_ratelimit(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_events_target target)
|
|
{
|
|
unsigned long val, next;
|
|
|
|
val = __this_cpu_read(memcg->stat->nr_page_events);
|
|
next = __this_cpu_read(memcg->stat->targets[target]);
|
|
/* from time_after() in jiffies.h */
|
|
if ((long)next - (long)val < 0) {
|
|
switch (target) {
|
|
case MEM_CGROUP_TARGET_THRESH:
|
|
next = val + THRESHOLDS_EVENTS_TARGET;
|
|
break;
|
|
case MEM_CGROUP_TARGET_SOFTLIMIT:
|
|
next = val + SOFTLIMIT_EVENTS_TARGET;
|
|
break;
|
|
case MEM_CGROUP_TARGET_NUMAINFO:
|
|
next = val + NUMAINFO_EVENTS_TARGET;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
__this_cpu_write(memcg->stat->targets[target], next);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Check events in order.
|
|
*
|
|
*/
|
|
static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
|
|
{
|
|
/* threshold event is triggered in finer grain than soft limit */
|
|
if (unlikely(mem_cgroup_event_ratelimit(memcg,
|
|
MEM_CGROUP_TARGET_THRESH))) {
|
|
bool do_softlimit;
|
|
bool do_numainfo __maybe_unused;
|
|
|
|
do_softlimit = mem_cgroup_event_ratelimit(memcg,
|
|
MEM_CGROUP_TARGET_SOFTLIMIT);
|
|
#if MAX_NUMNODES > 1
|
|
do_numainfo = mem_cgroup_event_ratelimit(memcg,
|
|
MEM_CGROUP_TARGET_NUMAINFO);
|
|
#endif
|
|
mem_cgroup_threshold(memcg);
|
|
if (unlikely(do_softlimit))
|
|
mem_cgroup_update_tree(memcg, page);
|
|
#if MAX_NUMNODES > 1
|
|
if (unlikely(do_numainfo))
|
|
atomic_inc(&memcg->numainfo_events);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
|
|
{
|
|
/*
|
|
* mm_update_next_owner() may clear mm->owner to NULL
|
|
* if it races with swapoff, page migration, etc.
|
|
* So this can be called with p == NULL.
|
|
*/
|
|
if (unlikely(!p))
|
|
return NULL;
|
|
|
|
return mem_cgroup_from_css(task_css(p, memory_cgrp_id));
|
|
}
|
|
|
|
static struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
|
|
{
|
|
struct mem_cgroup *memcg = NULL;
|
|
|
|
rcu_read_lock();
|
|
do {
|
|
/*
|
|
* Page cache insertions can happen withou an
|
|
* actual mm context, e.g. during disk probing
|
|
* on boot, loopback IO, acct() writes etc.
|
|
*/
|
|
if (unlikely(!mm))
|
|
memcg = root_mem_cgroup;
|
|
else {
|
|
memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
|
|
if (unlikely(!memcg))
|
|
memcg = root_mem_cgroup;
|
|
}
|
|
} while (!css_tryget_online(&memcg->css));
|
|
rcu_read_unlock();
|
|
return memcg;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_iter - iterate over memory cgroup hierarchy
|
|
* @root: hierarchy root
|
|
* @prev: previously returned memcg, NULL on first invocation
|
|
* @reclaim: cookie for shared reclaim walks, NULL for full walks
|
|
*
|
|
* Returns references to children of the hierarchy below @root, or
|
|
* @root itself, or %NULL after a full round-trip.
|
|
*
|
|
* Caller must pass the return value in @prev on subsequent
|
|
* invocations for reference counting, or use mem_cgroup_iter_break()
|
|
* to cancel a hierarchy walk before the round-trip is complete.
|
|
*
|
|
* Reclaimers can specify a zone and a priority level in @reclaim to
|
|
* divide up the memcgs in the hierarchy among all concurrent
|
|
* reclaimers operating on the same zone and priority.
|
|
*/
|
|
struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *root,
|
|
struct mem_cgroup *prev,
|
|
struct mem_cgroup_reclaim_cookie *reclaim)
|
|
{
|
|
struct reclaim_iter *uninitialized_var(iter);
|
|
struct cgroup_subsys_state *css = NULL;
|
|
struct mem_cgroup *memcg = NULL;
|
|
struct mem_cgroup *pos = NULL;
|
|
|
|
if (mem_cgroup_disabled())
|
|
return NULL;
|
|
|
|
if (!root)
|
|
root = root_mem_cgroup;
|
|
|
|
if (prev && !reclaim)
|
|
pos = prev;
|
|
|
|
if (!root->use_hierarchy && root != root_mem_cgroup) {
|
|
if (prev)
|
|
goto out;
|
|
return root;
|
|
}
|
|
|
|
rcu_read_lock();
|
|
|
|
if (reclaim) {
|
|
struct mem_cgroup_per_zone *mz;
|
|
|
|
mz = mem_cgroup_zone_zoneinfo(root, reclaim->zone);
|
|
iter = &mz->iter[reclaim->priority];
|
|
|
|
if (prev && reclaim->generation != iter->generation)
|
|
goto out_unlock;
|
|
|
|
do {
|
|
pos = ACCESS_ONCE(iter->position);
|
|
/*
|
|
* A racing update may change the position and
|
|
* put the last reference, hence css_tryget(),
|
|
* or retry to see the updated position.
|
|
*/
|
|
} while (pos && !css_tryget(&pos->css));
|
|
}
|
|
|
|
if (pos)
|
|
css = &pos->css;
|
|
|
|
for (;;) {
|
|
css = css_next_descendant_pre(css, &root->css);
|
|
if (!css) {
|
|
/*
|
|
* Reclaimers share the hierarchy walk, and a
|
|
* new one might jump in right at the end of
|
|
* the hierarchy - make sure they see at least
|
|
* one group and restart from the beginning.
|
|
*/
|
|
if (!prev)
|
|
continue;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Verify the css and acquire a reference. The root
|
|
* is provided by the caller, so we know it's alive
|
|
* and kicking, and don't take an extra reference.
|
|
*/
|
|
memcg = mem_cgroup_from_css(css);
|
|
|
|
if (css == &root->css)
|
|
break;
|
|
|
|
if (css_tryget(css)) {
|
|
/*
|
|
* Make sure the memcg is initialized:
|
|
* mem_cgroup_css_online() orders the the
|
|
* initialization against setting the flag.
|
|
*/
|
|
if (smp_load_acquire(&memcg->initialized))
|
|
break;
|
|
|
|
css_put(css);
|
|
}
|
|
|
|
memcg = NULL;
|
|
}
|
|
|
|
if (reclaim) {
|
|
if (cmpxchg(&iter->position, pos, memcg) == pos) {
|
|
if (memcg)
|
|
css_get(&memcg->css);
|
|
if (pos)
|
|
css_put(&pos->css);
|
|
}
|
|
|
|
/*
|
|
* pairs with css_tryget when dereferencing iter->position
|
|
* above.
|
|
*/
|
|
if (pos)
|
|
css_put(&pos->css);
|
|
|
|
if (!memcg)
|
|
iter->generation++;
|
|
else if (!prev)
|
|
reclaim->generation = iter->generation;
|
|
}
|
|
|
|
out_unlock:
|
|
rcu_read_unlock();
|
|
out:
|
|
if (prev && prev != root)
|
|
css_put(&prev->css);
|
|
|
|
return memcg;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_iter_break - abort a hierarchy walk prematurely
|
|
* @root: hierarchy root
|
|
* @prev: last visited hierarchy member as returned by mem_cgroup_iter()
|
|
*/
|
|
void mem_cgroup_iter_break(struct mem_cgroup *root,
|
|
struct mem_cgroup *prev)
|
|
{
|
|
if (!root)
|
|
root = root_mem_cgroup;
|
|
if (prev && prev != root)
|
|
css_put(&prev->css);
|
|
}
|
|
|
|
/*
|
|
* Iteration constructs for visiting all cgroups (under a tree). If
|
|
* loops are exited prematurely (break), mem_cgroup_iter_break() must
|
|
* be used for reference counting.
|
|
*/
|
|
#define for_each_mem_cgroup_tree(iter, root) \
|
|
for (iter = mem_cgroup_iter(root, NULL, NULL); \
|
|
iter != NULL; \
|
|
iter = mem_cgroup_iter(root, iter, NULL))
|
|
|
|
#define for_each_mem_cgroup(iter) \
|
|
for (iter = mem_cgroup_iter(NULL, NULL, NULL); \
|
|
iter != NULL; \
|
|
iter = mem_cgroup_iter(NULL, iter, NULL))
|
|
|
|
void __mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
|
|
rcu_read_lock();
|
|
memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
|
|
if (unlikely(!memcg))
|
|
goto out;
|
|
|
|
switch (idx) {
|
|
case PGFAULT:
|
|
this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGFAULT]);
|
|
break;
|
|
case PGMAJFAULT:
|
|
this_cpu_inc(memcg->stat->events[MEM_CGROUP_EVENTS_PGMAJFAULT]);
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
out:
|
|
rcu_read_unlock();
|
|
}
|
|
EXPORT_SYMBOL(__mem_cgroup_count_vm_event);
|
|
|
|
/**
|
|
* mem_cgroup_zone_lruvec - get the lru list vector for a zone and memcg
|
|
* @zone: zone of the wanted lruvec
|
|
* @memcg: memcg of the wanted lruvec
|
|
*
|
|
* Returns the lru list vector holding pages for the given @zone and
|
|
* @mem. This can be the global zone lruvec, if the memory controller
|
|
* is disabled.
|
|
*/
|
|
struct lruvec *mem_cgroup_zone_lruvec(struct zone *zone,
|
|
struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
struct lruvec *lruvec;
|
|
|
|
if (mem_cgroup_disabled()) {
|
|
lruvec = &zone->lruvec;
|
|
goto out;
|
|
}
|
|
|
|
mz = mem_cgroup_zone_zoneinfo(memcg, zone);
|
|
lruvec = &mz->lruvec;
|
|
out:
|
|
/*
|
|
* Since a node can be onlined after the mem_cgroup was created,
|
|
* we have to be prepared to initialize lruvec->zone here;
|
|
* and if offlined then reonlined, we need to reinitialize it.
|
|
*/
|
|
if (unlikely(lruvec->zone != zone))
|
|
lruvec->zone = zone;
|
|
return lruvec;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_page_lruvec - return lruvec for isolating/putting an LRU page
|
|
* @page: the page
|
|
* @zone: zone of the page
|
|
*
|
|
* This function is only safe when following the LRU page isolation
|
|
* and putback protocol: the LRU lock must be held, and the page must
|
|
* either be PageLRU() or the caller must have isolated/allocated it.
|
|
*/
|
|
struct lruvec *mem_cgroup_page_lruvec(struct page *page, struct zone *zone)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
struct mem_cgroup *memcg;
|
|
struct lruvec *lruvec;
|
|
|
|
if (mem_cgroup_disabled()) {
|
|
lruvec = &zone->lruvec;
|
|
goto out;
|
|
}
|
|
|
|
memcg = page->mem_cgroup;
|
|
/*
|
|
* Swapcache readahead pages are added to the LRU - and
|
|
* possibly migrated - before they are charged.
|
|
*/
|
|
if (!memcg)
|
|
memcg = root_mem_cgroup;
|
|
|
|
mz = mem_cgroup_page_zoneinfo(memcg, page);
|
|
lruvec = &mz->lruvec;
|
|
out:
|
|
/*
|
|
* Since a node can be onlined after the mem_cgroup was created,
|
|
* we have to be prepared to initialize lruvec->zone here;
|
|
* and if offlined then reonlined, we need to reinitialize it.
|
|
*/
|
|
if (unlikely(lruvec->zone != zone))
|
|
lruvec->zone = zone;
|
|
return lruvec;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_update_lru_size - account for adding or removing an lru page
|
|
* @lruvec: mem_cgroup per zone lru vector
|
|
* @lru: index of lru list the page is sitting on
|
|
* @nr_pages: positive when adding or negative when removing
|
|
*
|
|
* This function must be called when a page is added to or removed from an
|
|
* lru list.
|
|
*/
|
|
void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
|
|
int nr_pages)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
unsigned long *lru_size;
|
|
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
|
|
mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
|
|
lru_size = mz->lru_size + lru;
|
|
*lru_size += nr_pages;
|
|
VM_BUG_ON((long)(*lru_size) < 0);
|
|
}
|
|
|
|
bool mem_cgroup_is_descendant(struct mem_cgroup *memcg, struct mem_cgroup *root)
|
|
{
|
|
if (root == memcg)
|
|
return true;
|
|
if (!root->use_hierarchy)
|
|
return false;
|
|
return cgroup_is_descendant(memcg->css.cgroup, root->css.cgroup);
|
|
}
|
|
|
|
bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *task_memcg;
|
|
struct task_struct *p;
|
|
bool ret;
|
|
|
|
p = find_lock_task_mm(task);
|
|
if (p) {
|
|
task_memcg = get_mem_cgroup_from_mm(p->mm);
|
|
task_unlock(p);
|
|
} else {
|
|
/*
|
|
* All threads may have already detached their mm's, but the oom
|
|
* killer still needs to detect if they have already been oom
|
|
* killed to prevent needlessly killing additional tasks.
|
|
*/
|
|
rcu_read_lock();
|
|
task_memcg = mem_cgroup_from_task(task);
|
|
css_get(&task_memcg->css);
|
|
rcu_read_unlock();
|
|
}
|
|
ret = mem_cgroup_is_descendant(task_memcg, memcg);
|
|
css_put(&task_memcg->css);
|
|
return ret;
|
|
}
|
|
|
|
int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
|
|
{
|
|
unsigned long inactive_ratio;
|
|
unsigned long inactive;
|
|
unsigned long active;
|
|
unsigned long gb;
|
|
|
|
inactive = mem_cgroup_get_lru_size(lruvec, LRU_INACTIVE_ANON);
|
|
active = mem_cgroup_get_lru_size(lruvec, LRU_ACTIVE_ANON);
|
|
|
|
gb = (inactive + active) >> (30 - PAGE_SHIFT);
|
|
if (gb)
|
|
inactive_ratio = int_sqrt(10 * gb);
|
|
else
|
|
inactive_ratio = 1;
|
|
|
|
return inactive * inactive_ratio < active;
|
|
}
|
|
|
|
bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
|
|
{
|
|
struct mem_cgroup_per_zone *mz;
|
|
struct mem_cgroup *memcg;
|
|
|
|
if (mem_cgroup_disabled())
|
|
return true;
|
|
|
|
mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
|
|
memcg = mz->memcg;
|
|
|
|
return !!(memcg->css.flags & CSS_ONLINE);
|
|
}
|
|
|
|
#define mem_cgroup_from_counter(counter, member) \
|
|
container_of(counter, struct mem_cgroup, member)
|
|
|
|
/**
|
|
* mem_cgroup_margin - calculate chargeable space of a memory cgroup
|
|
* @memcg: the memory cgroup
|
|
*
|
|
* Returns the maximum amount of memory @mem can be charged with, in
|
|
* pages.
|
|
*/
|
|
static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
|
|
{
|
|
unsigned long margin = 0;
|
|
unsigned long count;
|
|
unsigned long limit;
|
|
|
|
count = page_counter_read(&memcg->memory);
|
|
limit = ACCESS_ONCE(memcg->memory.limit);
|
|
if (count < limit)
|
|
margin = limit - count;
|
|
|
|
if (do_swap_account) {
|
|
count = page_counter_read(&memcg->memsw);
|
|
limit = ACCESS_ONCE(memcg->memsw.limit);
|
|
if (count <= limit)
|
|
margin = min(margin, limit - count);
|
|
}
|
|
|
|
return margin;
|
|
}
|
|
|
|
int mem_cgroup_swappiness(struct mem_cgroup *memcg)
|
|
{
|
|
/* root ? */
|
|
if (mem_cgroup_disabled() || !memcg->css.parent)
|
|
return vm_swappiness;
|
|
|
|
return memcg->swappiness;
|
|
}
|
|
|
|
/*
|
|
* A routine for checking "mem" is under move_account() or not.
|
|
*
|
|
* Checking a cgroup is mc.from or mc.to or under hierarchy of
|
|
* moving cgroups. This is for waiting at high-memory pressure
|
|
* caused by "move".
|
|
*/
|
|
static bool mem_cgroup_under_move(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *from;
|
|
struct mem_cgroup *to;
|
|
bool ret = false;
|
|
/*
|
|
* Unlike task_move routines, we access mc.to, mc.from not under
|
|
* mutual exclusion by cgroup_mutex. Here, we take spinlock instead.
|
|
*/
|
|
spin_lock(&mc.lock);
|
|
from = mc.from;
|
|
to = mc.to;
|
|
if (!from)
|
|
goto unlock;
|
|
|
|
ret = mem_cgroup_is_descendant(from, memcg) ||
|
|
mem_cgroup_is_descendant(to, memcg);
|
|
unlock:
|
|
spin_unlock(&mc.lock);
|
|
return ret;
|
|
}
|
|
|
|
static bool mem_cgroup_wait_acct_move(struct mem_cgroup *memcg)
|
|
{
|
|
if (mc.moving_task && current != mc.moving_task) {
|
|
if (mem_cgroup_under_move(memcg)) {
|
|
DEFINE_WAIT(wait);
|
|
prepare_to_wait(&mc.waitq, &wait, TASK_INTERRUPTIBLE);
|
|
/* moving charge context might have finished. */
|
|
if (mc.moving_task)
|
|
schedule();
|
|
finish_wait(&mc.waitq, &wait);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#define K(x) ((x) << (PAGE_SHIFT-10))
|
|
/**
|
|
* mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.
|
|
* @memcg: The memory cgroup that went over limit
|
|
* @p: Task that is going to be killed
|
|
*
|
|
* NOTE: @memcg and @p's mem_cgroup can be different when hierarchy is
|
|
* enabled
|
|
*/
|
|
void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
|
|
{
|
|
/* oom_info_lock ensures that parallel ooms do not interleave */
|
|
static DEFINE_MUTEX(oom_info_lock);
|
|
struct mem_cgroup *iter;
|
|
unsigned int i;
|
|
|
|
if (!p)
|
|
return;
|
|
|
|
mutex_lock(&oom_info_lock);
|
|
rcu_read_lock();
|
|
|
|
pr_info("Task in ");
|
|
pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
|
|
pr_cont(" killed as a result of limit of ");
|
|
pr_cont_cgroup_path(memcg->css.cgroup);
|
|
pr_cont("\n");
|
|
|
|
rcu_read_unlock();
|
|
|
|
pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
|
|
K((u64)page_counter_read(&memcg->memory)),
|
|
K((u64)memcg->memory.limit), memcg->memory.failcnt);
|
|
pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
|
|
K((u64)page_counter_read(&memcg->memsw)),
|
|
K((u64)memcg->memsw.limit), memcg->memsw.failcnt);
|
|
pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
|
|
K((u64)page_counter_read(&memcg->kmem)),
|
|
K((u64)memcg->kmem.limit), memcg->kmem.failcnt);
|
|
|
|
for_each_mem_cgroup_tree(iter, memcg) {
|
|
pr_info("Memory cgroup stats for ");
|
|
pr_cont_cgroup_path(iter->css.cgroup);
|
|
pr_cont(":");
|
|
|
|
for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
|
|
if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
|
|
continue;
|
|
pr_cont(" %s:%ldKB", mem_cgroup_stat_names[i],
|
|
K(mem_cgroup_read_stat(iter, i)));
|
|
}
|
|
|
|
for (i = 0; i < NR_LRU_LISTS; i++)
|
|
pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
|
|
K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
|
|
|
|
pr_cont("\n");
|
|
}
|
|
mutex_unlock(&oom_info_lock);
|
|
}
|
|
|
|
/*
|
|
* This function returns the number of memcg under hierarchy tree. Returns
|
|
* 1(self count) if no children.
|
|
*/
|
|
static int mem_cgroup_count_children(struct mem_cgroup *memcg)
|
|
{
|
|
int num = 0;
|
|
struct mem_cgroup *iter;
|
|
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
num++;
|
|
return num;
|
|
}
|
|
|
|
/*
|
|
* Return the memory (and swap, if configured) limit for a memcg.
|
|
*/
|
|
static unsigned long mem_cgroup_get_limit(struct mem_cgroup *memcg)
|
|
{
|
|
unsigned long limit;
|
|
|
|
limit = memcg->memory.limit;
|
|
if (mem_cgroup_swappiness(memcg)) {
|
|
unsigned long memsw_limit;
|
|
|
|
memsw_limit = memcg->memsw.limit;
|
|
limit = min(limit + total_swap_pages, memsw_limit);
|
|
}
|
|
return limit;
|
|
}
|
|
|
|
static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
|
|
int order)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
unsigned long chosen_points = 0;
|
|
unsigned long totalpages;
|
|
unsigned int points = 0;
|
|
struct task_struct *chosen = NULL;
|
|
|
|
/*
|
|
* If current has a pending SIGKILL or is exiting, then automatically
|
|
* select it. The goal is to allow it to allocate so that it may
|
|
* quickly exit and free its memory.
|
|
*/
|
|
if (fatal_signal_pending(current) || task_will_free_mem(current)) {
|
|
mark_tsk_oom_victim(current);
|
|
return;
|
|
}
|
|
|
|
check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
|
|
totalpages = mem_cgroup_get_limit(memcg) ? : 1;
|
|
for_each_mem_cgroup_tree(iter, memcg) {
|
|
struct css_task_iter it;
|
|
struct task_struct *task;
|
|
|
|
css_task_iter_start(&iter->css, &it);
|
|
while ((task = css_task_iter_next(&it))) {
|
|
switch (oom_scan_process_thread(task, totalpages, NULL,
|
|
false)) {
|
|
case OOM_SCAN_SELECT:
|
|
if (chosen)
|
|
put_task_struct(chosen);
|
|
chosen = task;
|
|
chosen_points = ULONG_MAX;
|
|
get_task_struct(chosen);
|
|
/* fall through */
|
|
case OOM_SCAN_CONTINUE:
|
|
continue;
|
|
case OOM_SCAN_ABORT:
|
|
css_task_iter_end(&it);
|
|
mem_cgroup_iter_break(memcg, iter);
|
|
if (chosen)
|
|
put_task_struct(chosen);
|
|
return;
|
|
case OOM_SCAN_OK:
|
|
break;
|
|
};
|
|
points = oom_badness(task, memcg, NULL, totalpages);
|
|
if (!points || points < chosen_points)
|
|
continue;
|
|
/* Prefer thread group leaders for display purposes */
|
|
if (points == chosen_points &&
|
|
thread_group_leader(chosen))
|
|
continue;
|
|
|
|
if (chosen)
|
|
put_task_struct(chosen);
|
|
chosen = task;
|
|
chosen_points = points;
|
|
get_task_struct(chosen);
|
|
}
|
|
css_task_iter_end(&it);
|
|
}
|
|
|
|
if (!chosen)
|
|
return;
|
|
points = chosen_points * 1000 / totalpages;
|
|
oom_kill_process(chosen, gfp_mask, order, points, totalpages, memcg,
|
|
NULL, "Memory cgroup out of memory");
|
|
}
|
|
|
|
#if MAX_NUMNODES > 1
|
|
|
|
/**
|
|
* test_mem_cgroup_node_reclaimable
|
|
* @memcg: the target memcg
|
|
* @nid: the node ID to be checked.
|
|
* @noswap : specify true here if the user wants flle only information.
|
|
*
|
|
* This function returns whether the specified memcg contains any
|
|
* reclaimable pages on a node. Returns true if there are any reclaimable
|
|
* pages in the node.
|
|
*/
|
|
static bool test_mem_cgroup_node_reclaimable(struct mem_cgroup *memcg,
|
|
int nid, bool noswap)
|
|
{
|
|
if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_FILE))
|
|
return true;
|
|
if (noswap || !total_swap_pages)
|
|
return false;
|
|
if (mem_cgroup_node_nr_lru_pages(memcg, nid, LRU_ALL_ANON))
|
|
return true;
|
|
return false;
|
|
|
|
}
|
|
|
|
/*
|
|
* Always updating the nodemask is not very good - even if we have an empty
|
|
* list or the wrong list here, we can start from some node and traverse all
|
|
* nodes based on the zonelist. So update the list loosely once per 10 secs.
|
|
*
|
|
*/
|
|
static void mem_cgroup_may_update_nodemask(struct mem_cgroup *memcg)
|
|
{
|
|
int nid;
|
|
/*
|
|
* numainfo_events > 0 means there was at least NUMAINFO_EVENTS_TARGET
|
|
* pagein/pageout changes since the last update.
|
|
*/
|
|
if (!atomic_read(&memcg->numainfo_events))
|
|
return;
|
|
if (atomic_inc_return(&memcg->numainfo_updating) > 1)
|
|
return;
|
|
|
|
/* make a nodemask where this memcg uses memory from */
|
|
memcg->scan_nodes = node_states[N_MEMORY];
|
|
|
|
for_each_node_mask(nid, node_states[N_MEMORY]) {
|
|
|
|
if (!test_mem_cgroup_node_reclaimable(memcg, nid, false))
|
|
node_clear(nid, memcg->scan_nodes);
|
|
}
|
|
|
|
atomic_set(&memcg->numainfo_events, 0);
|
|
atomic_set(&memcg->numainfo_updating, 0);
|
|
}
|
|
|
|
/*
|
|
* Selecting a node where we start reclaim from. Because what we need is just
|
|
* reducing usage counter, start from anywhere is O,K. Considering
|
|
* memory reclaim from current node, there are pros. and cons.
|
|
*
|
|
* Freeing memory from current node means freeing memory from a node which
|
|
* we'll use or we've used. So, it may make LRU bad. And if several threads
|
|
* hit limits, it will see a contention on a node. But freeing from remote
|
|
* node means more costs for memory reclaim because of memory latency.
|
|
*
|
|
* Now, we use round-robin. Better algorithm is welcomed.
|
|
*/
|
|
int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
|
|
{
|
|
int node;
|
|
|
|
mem_cgroup_may_update_nodemask(memcg);
|
|
node = memcg->last_scanned_node;
|
|
|
|
node = next_node(node, memcg->scan_nodes);
|
|
if (node == MAX_NUMNODES)
|
|
node = first_node(memcg->scan_nodes);
|
|
/*
|
|
* We call this when we hit limit, not when pages are added to LRU.
|
|
* No LRU may hold pages because all pages are UNEVICTABLE or
|
|
* memcg is too small and all pages are not on LRU. In that case,
|
|
* we use curret node.
|
|
*/
|
|
if (unlikely(node == MAX_NUMNODES))
|
|
node = numa_node_id();
|
|
|
|
memcg->last_scanned_node = node;
|
|
return node;
|
|
}
|
|
#else
|
|
int mem_cgroup_select_victim_node(struct mem_cgroup *memcg)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int mem_cgroup_soft_reclaim(struct mem_cgroup *root_memcg,
|
|
struct zone *zone,
|
|
gfp_t gfp_mask,
|
|
unsigned long *total_scanned)
|
|
{
|
|
struct mem_cgroup *victim = NULL;
|
|
int total = 0;
|
|
int loop = 0;
|
|
unsigned long excess;
|
|
unsigned long nr_scanned;
|
|
struct mem_cgroup_reclaim_cookie reclaim = {
|
|
.zone = zone,
|
|
.priority = 0,
|
|
};
|
|
|
|
excess = soft_limit_excess(root_memcg);
|
|
|
|
while (1) {
|
|
victim = mem_cgroup_iter(root_memcg, victim, &reclaim);
|
|
if (!victim) {
|
|
loop++;
|
|
if (loop >= 2) {
|
|
/*
|
|
* If we have not been able to reclaim
|
|
* anything, it might because there are
|
|
* no reclaimable pages under this hierarchy
|
|
*/
|
|
if (!total)
|
|
break;
|
|
/*
|
|
* We want to do more targeted reclaim.
|
|
* excess >> 2 is not to excessive so as to
|
|
* reclaim too much, nor too less that we keep
|
|
* coming back to reclaim from this cgroup
|
|
*/
|
|
if (total >= (excess >> 2) ||
|
|
(loop > MEM_CGROUP_MAX_RECLAIM_LOOPS))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
total += mem_cgroup_shrink_node_zone(victim, gfp_mask, false,
|
|
zone, &nr_scanned);
|
|
*total_scanned += nr_scanned;
|
|
if (!soft_limit_excess(root_memcg))
|
|
break;
|
|
}
|
|
mem_cgroup_iter_break(root_memcg, victim);
|
|
return total;
|
|
}
|
|
|
|
#ifdef CONFIG_LOCKDEP
|
|
static struct lockdep_map memcg_oom_lock_dep_map = {
|
|
.name = "memcg_oom_lock",
|
|
};
|
|
#endif
|
|
|
|
static DEFINE_SPINLOCK(memcg_oom_lock);
|
|
|
|
/*
|
|
* Check OOM-Killer is already running under our hierarchy.
|
|
* If someone is running, return false.
|
|
*/
|
|
static bool mem_cgroup_oom_trylock(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *iter, *failed = NULL;
|
|
|
|
spin_lock(&memcg_oom_lock);
|
|
|
|
for_each_mem_cgroup_tree(iter, memcg) {
|
|
if (iter->oom_lock) {
|
|
/*
|
|
* this subtree of our hierarchy is already locked
|
|
* so we cannot give a lock.
|
|
*/
|
|
failed = iter;
|
|
mem_cgroup_iter_break(memcg, iter);
|
|
break;
|
|
} else
|
|
iter->oom_lock = true;
|
|
}
|
|
|
|
if (failed) {
|
|
/*
|
|
* OK, we failed to lock the whole subtree so we have
|
|
* to clean up what we set up to the failing subtree
|
|
*/
|
|
for_each_mem_cgroup_tree(iter, memcg) {
|
|
if (iter == failed) {
|
|
mem_cgroup_iter_break(memcg, iter);
|
|
break;
|
|
}
|
|
iter->oom_lock = false;
|
|
}
|
|
} else
|
|
mutex_acquire(&memcg_oom_lock_dep_map, 0, 1, _RET_IP_);
|
|
|
|
spin_unlock(&memcg_oom_lock);
|
|
|
|
return !failed;
|
|
}
|
|
|
|
static void mem_cgroup_oom_unlock(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
|
|
spin_lock(&memcg_oom_lock);
|
|
mutex_release(&memcg_oom_lock_dep_map, 1, _RET_IP_);
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
iter->oom_lock = false;
|
|
spin_unlock(&memcg_oom_lock);
|
|
}
|
|
|
|
static void mem_cgroup_mark_under_oom(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
atomic_inc(&iter->under_oom);
|
|
}
|
|
|
|
static void mem_cgroup_unmark_under_oom(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
|
|
/*
|
|
* When a new child is created while the hierarchy is under oom,
|
|
* mem_cgroup_oom_lock() may not be called. We have to use
|
|
* atomic_add_unless() here.
|
|
*/
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
atomic_add_unless(&iter->under_oom, -1, 0);
|
|
}
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(memcg_oom_waitq);
|
|
|
|
struct oom_wait_info {
|
|
struct mem_cgroup *memcg;
|
|
wait_queue_t wait;
|
|
};
|
|
|
|
static int memcg_oom_wake_function(wait_queue_t *wait,
|
|
unsigned mode, int sync, void *arg)
|
|
{
|
|
struct mem_cgroup *wake_memcg = (struct mem_cgroup *)arg;
|
|
struct mem_cgroup *oom_wait_memcg;
|
|
struct oom_wait_info *oom_wait_info;
|
|
|
|
oom_wait_info = container_of(wait, struct oom_wait_info, wait);
|
|
oom_wait_memcg = oom_wait_info->memcg;
|
|
|
|
if (!mem_cgroup_is_descendant(wake_memcg, oom_wait_memcg) &&
|
|
!mem_cgroup_is_descendant(oom_wait_memcg, wake_memcg))
|
|
return 0;
|
|
return autoremove_wake_function(wait, mode, sync, arg);
|
|
}
|
|
|
|
static void memcg_wakeup_oom(struct mem_cgroup *memcg)
|
|
{
|
|
atomic_inc(&memcg->oom_wakeups);
|
|
/* for filtering, pass "memcg" as argument. */
|
|
__wake_up(&memcg_oom_waitq, TASK_NORMAL, 0, memcg);
|
|
}
|
|
|
|
static void memcg_oom_recover(struct mem_cgroup *memcg)
|
|
{
|
|
if (memcg && atomic_read(&memcg->under_oom))
|
|
memcg_wakeup_oom(memcg);
|
|
}
|
|
|
|
static void mem_cgroup_oom(struct mem_cgroup *memcg, gfp_t mask, int order)
|
|
{
|
|
if (!current->memcg_oom.may_oom)
|
|
return;
|
|
/*
|
|
* We are in the middle of the charge context here, so we
|
|
* don't want to block when potentially sitting on a callstack
|
|
* that holds all kinds of filesystem and mm locks.
|
|
*
|
|
* Also, the caller may handle a failed allocation gracefully
|
|
* (like optional page cache readahead) and so an OOM killer
|
|
* invocation might not even be necessary.
|
|
*
|
|
* That's why we don't do anything here except remember the
|
|
* OOM context and then deal with it at the end of the page
|
|
* fault when the stack is unwound, the locks are released,
|
|
* and when we know whether the fault was overall successful.
|
|
*/
|
|
css_get(&memcg->css);
|
|
current->memcg_oom.memcg = memcg;
|
|
current->memcg_oom.gfp_mask = mask;
|
|
current->memcg_oom.order = order;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_oom_synchronize - complete memcg OOM handling
|
|
* @handle: actually kill/wait or just clean up the OOM state
|
|
*
|
|
* This has to be called at the end of a page fault if the memcg OOM
|
|
* handler was enabled.
|
|
*
|
|
* Memcg supports userspace OOM handling where failed allocations must
|
|
* sleep on a waitqueue until the userspace task resolves the
|
|
* situation. Sleeping directly in the charge context with all kinds
|
|
* of locks held is not a good idea, instead we remember an OOM state
|
|
* in the task and mem_cgroup_oom_synchronize() has to be called at
|
|
* the end of the page fault to complete the OOM handling.
|
|
*
|
|
* Returns %true if an ongoing memcg OOM situation was detected and
|
|
* completed, %false otherwise.
|
|
*/
|
|
bool mem_cgroup_oom_synchronize(bool handle)
|
|
{
|
|
struct mem_cgroup *memcg = current->memcg_oom.memcg;
|
|
struct oom_wait_info owait;
|
|
bool locked;
|
|
|
|
/* OOM is global, do not handle */
|
|
if (!memcg)
|
|
return false;
|
|
|
|
if (!handle || oom_killer_disabled)
|
|
goto cleanup;
|
|
|
|
owait.memcg = memcg;
|
|
owait.wait.flags = 0;
|
|
owait.wait.func = memcg_oom_wake_function;
|
|
owait.wait.private = current;
|
|
INIT_LIST_HEAD(&owait.wait.task_list);
|
|
|
|
prepare_to_wait(&memcg_oom_waitq, &owait.wait, TASK_KILLABLE);
|
|
mem_cgroup_mark_under_oom(memcg);
|
|
|
|
locked = mem_cgroup_oom_trylock(memcg);
|
|
|
|
if (locked)
|
|
mem_cgroup_oom_notify(memcg);
|
|
|
|
if (locked && !memcg->oom_kill_disable) {
|
|
mem_cgroup_unmark_under_oom(memcg);
|
|
finish_wait(&memcg_oom_waitq, &owait.wait);
|
|
mem_cgroup_out_of_memory(memcg, current->memcg_oom.gfp_mask,
|
|
current->memcg_oom.order);
|
|
} else {
|
|
schedule();
|
|
mem_cgroup_unmark_under_oom(memcg);
|
|
finish_wait(&memcg_oom_waitq, &owait.wait);
|
|
}
|
|
|
|
if (locked) {
|
|
mem_cgroup_oom_unlock(memcg);
|
|
/*
|
|
* There is no guarantee that an OOM-lock contender
|
|
* sees the wakeups triggered by the OOM kill
|
|
* uncharges. Wake any sleepers explicitely.
|
|
*/
|
|
memcg_oom_recover(memcg);
|
|
}
|
|
cleanup:
|
|
current->memcg_oom.memcg = NULL;
|
|
css_put(&memcg->css);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_begin_page_stat - begin a page state statistics transaction
|
|
* @page: page that is going to change accounted state
|
|
*
|
|
* This function must mark the beginning of an accounted page state
|
|
* change to prevent double accounting when the page is concurrently
|
|
* being moved to another memcg:
|
|
*
|
|
* memcg = mem_cgroup_begin_page_stat(page);
|
|
* if (TestClearPageState(page))
|
|
* mem_cgroup_update_page_stat(memcg, state, -1);
|
|
* mem_cgroup_end_page_stat(memcg);
|
|
*/
|
|
struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
unsigned long flags;
|
|
|
|
/*
|
|
* The RCU lock is held throughout the transaction. The fast
|
|
* path can get away without acquiring the memcg->move_lock
|
|
* because page moving starts with an RCU grace period.
|
|
*
|
|
* The RCU lock also protects the memcg from being freed when
|
|
* the page state that is going to change is the only thing
|
|
* preventing the page from being uncharged.
|
|
* E.g. end-writeback clearing PageWriteback(), which allows
|
|
* migration to go ahead and uncharge the page before the
|
|
* account transaction might be complete.
|
|
*/
|
|
rcu_read_lock();
|
|
|
|
if (mem_cgroup_disabled())
|
|
return NULL;
|
|
again:
|
|
memcg = page->mem_cgroup;
|
|
if (unlikely(!memcg))
|
|
return NULL;
|
|
|
|
if (atomic_read(&memcg->moving_account) <= 0)
|
|
return memcg;
|
|
|
|
spin_lock_irqsave(&memcg->move_lock, flags);
|
|
if (memcg != page->mem_cgroup) {
|
|
spin_unlock_irqrestore(&memcg->move_lock, flags);
|
|
goto again;
|
|
}
|
|
|
|
/*
|
|
* When charge migration first begins, we can have locked and
|
|
* unlocked page stat updates happening concurrently. Track
|
|
* the task who has the lock for mem_cgroup_end_page_stat().
|
|
*/
|
|
memcg->move_lock_task = current;
|
|
memcg->move_lock_flags = flags;
|
|
|
|
return memcg;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_end_page_stat - finish a page state statistics transaction
|
|
* @memcg: the memcg that was accounted against
|
|
*/
|
|
void mem_cgroup_end_page_stat(struct mem_cgroup *memcg)
|
|
{
|
|
if (memcg && memcg->move_lock_task == current) {
|
|
unsigned long flags = memcg->move_lock_flags;
|
|
|
|
memcg->move_lock_task = NULL;
|
|
memcg->move_lock_flags = 0;
|
|
|
|
spin_unlock_irqrestore(&memcg->move_lock, flags);
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_update_page_stat - update page state statistics
|
|
* @memcg: memcg to account against
|
|
* @idx: page state item to account
|
|
* @val: number of pages (positive or negative)
|
|
*
|
|
* See mem_cgroup_begin_page_stat() for locking requirements.
|
|
*/
|
|
void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx, int val)
|
|
{
|
|
VM_BUG_ON(!rcu_read_lock_held());
|
|
|
|
if (memcg)
|
|
this_cpu_add(memcg->stat->count[idx], val);
|
|
}
|
|
|
|
/*
|
|
* size of first charge trial. "32" comes from vmscan.c's magic value.
|
|
* TODO: maybe necessary to use big numbers in big irons.
|
|
*/
|
|
#define CHARGE_BATCH 32U
|
|
struct memcg_stock_pcp {
|
|
struct mem_cgroup *cached; /* this never be root cgroup */
|
|
unsigned int nr_pages;
|
|
struct work_struct work;
|
|
unsigned long flags;
|
|
#define FLUSHING_CACHED_CHARGE 0
|
|
};
|
|
static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock);
|
|
static DEFINE_MUTEX(percpu_charge_mutex);
|
|
|
|
/**
|
|
* consume_stock: Try to consume stocked charge on this cpu.
|
|
* @memcg: memcg to consume from.
|
|
* @nr_pages: how many pages to charge.
|
|
*
|
|
* The charges will only happen if @memcg matches the current cpu's memcg
|
|
* stock, and at least @nr_pages are available in that stock. Failure to
|
|
* service an allocation will refill the stock.
|
|
*
|
|
* returns true if successful, false otherwise.
|
|
*/
|
|
static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
|
|
{
|
|
struct memcg_stock_pcp *stock;
|
|
bool ret = false;
|
|
|
|
if (nr_pages > CHARGE_BATCH)
|
|
return ret;
|
|
|
|
stock = &get_cpu_var(memcg_stock);
|
|
if (memcg == stock->cached && stock->nr_pages >= nr_pages) {
|
|
stock->nr_pages -= nr_pages;
|
|
ret = true;
|
|
}
|
|
put_cpu_var(memcg_stock);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Returns stocks cached in percpu and reset cached information.
|
|
*/
|
|
static void drain_stock(struct memcg_stock_pcp *stock)
|
|
{
|
|
struct mem_cgroup *old = stock->cached;
|
|
|
|
if (stock->nr_pages) {
|
|
page_counter_uncharge(&old->memory, stock->nr_pages);
|
|
if (do_swap_account)
|
|
page_counter_uncharge(&old->memsw, stock->nr_pages);
|
|
css_put_many(&old->css, stock->nr_pages);
|
|
stock->nr_pages = 0;
|
|
}
|
|
stock->cached = NULL;
|
|
}
|
|
|
|
/*
|
|
* This must be called under preempt disabled or must be called by
|
|
* a thread which is pinned to local cpu.
|
|
*/
|
|
static void drain_local_stock(struct work_struct *dummy)
|
|
{
|
|
struct memcg_stock_pcp *stock = this_cpu_ptr(&memcg_stock);
|
|
drain_stock(stock);
|
|
clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
|
|
}
|
|
|
|
/*
|
|
* Cache charges(val) to local per_cpu area.
|
|
* This will be consumed by consume_stock() function, later.
|
|
*/
|
|
static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages)
|
|
{
|
|
struct memcg_stock_pcp *stock = &get_cpu_var(memcg_stock);
|
|
|
|
if (stock->cached != memcg) { /* reset if necessary */
|
|
drain_stock(stock);
|
|
stock->cached = memcg;
|
|
}
|
|
stock->nr_pages += nr_pages;
|
|
put_cpu_var(memcg_stock);
|
|
}
|
|
|
|
/*
|
|
* Drains all per-CPU charge caches for given root_memcg resp. subtree
|
|
* of the hierarchy under it.
|
|
*/
|
|
static void drain_all_stock(struct mem_cgroup *root_memcg)
|
|
{
|
|
int cpu, curcpu;
|
|
|
|
/* If someone's already draining, avoid adding running more workers. */
|
|
if (!mutex_trylock(&percpu_charge_mutex))
|
|
return;
|
|
/* Notify other cpus that system-wide "drain" is running */
|
|
get_online_cpus();
|
|
curcpu = get_cpu();
|
|
for_each_online_cpu(cpu) {
|
|
struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
|
|
struct mem_cgroup *memcg;
|
|
|
|
memcg = stock->cached;
|
|
if (!memcg || !stock->nr_pages)
|
|
continue;
|
|
if (!mem_cgroup_is_descendant(memcg, root_memcg))
|
|
continue;
|
|
if (!test_and_set_bit(FLUSHING_CACHED_CHARGE, &stock->flags)) {
|
|
if (cpu == curcpu)
|
|
drain_local_stock(&stock->work);
|
|
else
|
|
schedule_work_on(cpu, &stock->work);
|
|
}
|
|
}
|
|
put_cpu();
|
|
put_online_cpus();
|
|
mutex_unlock(&percpu_charge_mutex);
|
|
}
|
|
|
|
/*
|
|
* This function drains percpu counter value from DEAD cpu and
|
|
* move it to local cpu. Note that this function can be preempted.
|
|
*/
|
|
static void mem_cgroup_drain_pcp_counter(struct mem_cgroup *memcg, int cpu)
|
|
{
|
|
int i;
|
|
|
|
spin_lock(&memcg->pcp_counter_lock);
|
|
for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
|
|
long x = per_cpu(memcg->stat->count[i], cpu);
|
|
|
|
per_cpu(memcg->stat->count[i], cpu) = 0;
|
|
memcg->nocpu_base.count[i] += x;
|
|
}
|
|
for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
|
|
unsigned long x = per_cpu(memcg->stat->events[i], cpu);
|
|
|
|
per_cpu(memcg->stat->events[i], cpu) = 0;
|
|
memcg->nocpu_base.events[i] += x;
|
|
}
|
|
spin_unlock(&memcg->pcp_counter_lock);
|
|
}
|
|
|
|
static int memcg_cpu_hotplug_callback(struct notifier_block *nb,
|
|
unsigned long action,
|
|
void *hcpu)
|
|
{
|
|
int cpu = (unsigned long)hcpu;
|
|
struct memcg_stock_pcp *stock;
|
|
struct mem_cgroup *iter;
|
|
|
|
if (action == CPU_ONLINE)
|
|
return NOTIFY_OK;
|
|
|
|
if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
|
|
return NOTIFY_OK;
|
|
|
|
for_each_mem_cgroup(iter)
|
|
mem_cgroup_drain_pcp_counter(iter, cpu);
|
|
|
|
stock = &per_cpu(memcg_stock, cpu);
|
|
drain_stock(stock);
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,
|
|
unsigned int nr_pages)
|
|
{
|
|
unsigned int batch = max(CHARGE_BATCH, nr_pages);
|
|
int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
|
|
struct mem_cgroup *mem_over_limit;
|
|
struct page_counter *counter;
|
|
unsigned long nr_reclaimed;
|
|
bool may_swap = true;
|
|
bool drained = false;
|
|
int ret = 0;
|
|
|
|
if (mem_cgroup_is_root(memcg))
|
|
goto done;
|
|
retry:
|
|
if (consume_stock(memcg, nr_pages))
|
|
goto done;
|
|
|
|
if (!do_swap_account ||
|
|
!page_counter_try_charge(&memcg->memsw, batch, &counter)) {
|
|
if (!page_counter_try_charge(&memcg->memory, batch, &counter))
|
|
goto done_restock;
|
|
if (do_swap_account)
|
|
page_counter_uncharge(&memcg->memsw, batch);
|
|
mem_over_limit = mem_cgroup_from_counter(counter, memory);
|
|
} else {
|
|
mem_over_limit = mem_cgroup_from_counter(counter, memsw);
|
|
may_swap = false;
|
|
}
|
|
|
|
if (batch > nr_pages) {
|
|
batch = nr_pages;
|
|
goto retry;
|
|
}
|
|
|
|
/*
|
|
* Unlike in global OOM situations, memcg is not in a physical
|
|
* memory shortage. Allow dying and OOM-killed tasks to
|
|
* bypass the last charges so that they can exit quickly and
|
|
* free their memory.
|
|
*/
|
|
if (unlikely(test_thread_flag(TIF_MEMDIE) ||
|
|
fatal_signal_pending(current) ||
|
|
current->flags & PF_EXITING))
|
|
goto bypass;
|
|
|
|
if (unlikely(task_in_memcg_oom(current)))
|
|
goto nomem;
|
|
|
|
if (!(gfp_mask & __GFP_WAIT))
|
|
goto nomem;
|
|
|
|
mem_cgroup_events(mem_over_limit, MEMCG_MAX, 1);
|
|
|
|
nr_reclaimed = try_to_free_mem_cgroup_pages(mem_over_limit, nr_pages,
|
|
gfp_mask, may_swap);
|
|
|
|
if (mem_cgroup_margin(mem_over_limit) >= nr_pages)
|
|
goto retry;
|
|
|
|
if (!drained) {
|
|
drain_all_stock(mem_over_limit);
|
|
drained = true;
|
|
goto retry;
|
|
}
|
|
|
|
if (gfp_mask & __GFP_NORETRY)
|
|
goto nomem;
|
|
/*
|
|
* Even though the limit is exceeded at this point, reclaim
|
|
* may have been able to free some pages. Retry the charge
|
|
* before killing the task.
|
|
*
|
|
* Only for regular pages, though: huge pages are rather
|
|
* unlikely to succeed so close to the limit, and we fall back
|
|
* to regular pages anyway in case of failure.
|
|
*/
|
|
if (nr_reclaimed && nr_pages <= (1 << PAGE_ALLOC_COSTLY_ORDER))
|
|
goto retry;
|
|
/*
|
|
* At task move, charge accounts can be doubly counted. So, it's
|
|
* better to wait until the end of task_move if something is going on.
|
|
*/
|
|
if (mem_cgroup_wait_acct_move(mem_over_limit))
|
|
goto retry;
|
|
|
|
if (nr_retries--)
|
|
goto retry;
|
|
|
|
if (gfp_mask & __GFP_NOFAIL)
|
|
goto bypass;
|
|
|
|
if (fatal_signal_pending(current))
|
|
goto bypass;
|
|
|
|
mem_cgroup_events(mem_over_limit, MEMCG_OOM, 1);
|
|
|
|
mem_cgroup_oom(mem_over_limit, gfp_mask, get_order(nr_pages));
|
|
nomem:
|
|
if (!(gfp_mask & __GFP_NOFAIL))
|
|
return -ENOMEM;
|
|
bypass:
|
|
return -EINTR;
|
|
|
|
done_restock:
|
|
css_get_many(&memcg->css, batch);
|
|
if (batch > nr_pages)
|
|
refill_stock(memcg, batch - nr_pages);
|
|
/*
|
|
* If the hierarchy is above the normal consumption range,
|
|
* make the charging task trim their excess contribution.
|
|
*/
|
|
do {
|
|
if (page_counter_read(&memcg->memory) <= memcg->high)
|
|
continue;
|
|
mem_cgroup_events(memcg, MEMCG_HIGH, 1);
|
|
try_to_free_mem_cgroup_pages(memcg, nr_pages, gfp_mask, true);
|
|
} while ((memcg = parent_mem_cgroup(memcg)));
|
|
done:
|
|
return ret;
|
|
}
|
|
|
|
static void cancel_charge(struct mem_cgroup *memcg, unsigned int nr_pages)
|
|
{
|
|
if (mem_cgroup_is_root(memcg))
|
|
return;
|
|
|
|
page_counter_uncharge(&memcg->memory, nr_pages);
|
|
if (do_swap_account)
|
|
page_counter_uncharge(&memcg->memsw, nr_pages);
|
|
|
|
css_put_many(&memcg->css, nr_pages);
|
|
}
|
|
|
|
/*
|
|
* A helper function to get mem_cgroup from ID. must be called under
|
|
* rcu_read_lock(). The caller is responsible for calling
|
|
* css_tryget_online() if the mem_cgroup is used for charging. (dropping
|
|
* refcnt from swap can be called against removed memcg.)
|
|
*/
|
|
static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
|
|
{
|
|
/* ID 0 is unused ID */
|
|
if (!id)
|
|
return NULL;
|
|
return mem_cgroup_from_id(id);
|
|
}
|
|
|
|
/*
|
|
* try_get_mem_cgroup_from_page - look up page's memcg association
|
|
* @page: the page
|
|
*
|
|
* Look up, get a css reference, and return the memcg that owns @page.
|
|
*
|
|
* The page must be locked to prevent racing with swap-in and page
|
|
* cache charges. If coming from an unlocked page table, the caller
|
|
* must ensure the page is on the LRU or this can race with charging.
|
|
*/
|
|
struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
unsigned short id;
|
|
swp_entry_t ent;
|
|
|
|
VM_BUG_ON_PAGE(!PageLocked(page), page);
|
|
|
|
memcg = page->mem_cgroup;
|
|
if (memcg) {
|
|
if (!css_tryget_online(&memcg->css))
|
|
memcg = NULL;
|
|
} else if (PageSwapCache(page)) {
|
|
ent.val = page_private(page);
|
|
id = lookup_swap_cgroup_id(ent);
|
|
rcu_read_lock();
|
|
memcg = mem_cgroup_lookup(id);
|
|
if (memcg && !css_tryget_online(&memcg->css))
|
|
memcg = NULL;
|
|
rcu_read_unlock();
|
|
}
|
|
return memcg;
|
|
}
|
|
|
|
static void lock_page_lru(struct page *page, int *isolated)
|
|
{
|
|
struct zone *zone = page_zone(page);
|
|
|
|
spin_lock_irq(&zone->lru_lock);
|
|
if (PageLRU(page)) {
|
|
struct lruvec *lruvec;
|
|
|
|
lruvec = mem_cgroup_page_lruvec(page, zone);
|
|
ClearPageLRU(page);
|
|
del_page_from_lru_list(page, lruvec, page_lru(page));
|
|
*isolated = 1;
|
|
} else
|
|
*isolated = 0;
|
|
}
|
|
|
|
static void unlock_page_lru(struct page *page, int isolated)
|
|
{
|
|
struct zone *zone = page_zone(page);
|
|
|
|
if (isolated) {
|
|
struct lruvec *lruvec;
|
|
|
|
lruvec = mem_cgroup_page_lruvec(page, zone);
|
|
VM_BUG_ON_PAGE(PageLRU(page), page);
|
|
SetPageLRU(page);
|
|
add_page_to_lru_list(page, lruvec, page_lru(page));
|
|
}
|
|
spin_unlock_irq(&zone->lru_lock);
|
|
}
|
|
|
|
static void commit_charge(struct page *page, struct mem_cgroup *memcg,
|
|
bool lrucare)
|
|
{
|
|
int isolated;
|
|
|
|
VM_BUG_ON_PAGE(page->mem_cgroup, page);
|
|
|
|
/*
|
|
* In some cases, SwapCache and FUSE(splice_buf->radixtree), the page
|
|
* may already be on some other mem_cgroup's LRU. Take care of it.
|
|
*/
|
|
if (lrucare)
|
|
lock_page_lru(page, &isolated);
|
|
|
|
/*
|
|
* Nobody should be changing or seriously looking at
|
|
* page->mem_cgroup at this point:
|
|
*
|
|
* - the page is uncharged
|
|
*
|
|
* - the page is off-LRU
|
|
*
|
|
* - an anonymous fault has exclusive page access, except for
|
|
* a locked page table
|
|
*
|
|
* - a page cache insertion, a swapin fault, or a migration
|
|
* have the page locked
|
|
*/
|
|
page->mem_cgroup = memcg;
|
|
|
|
if (lrucare)
|
|
unlock_page_lru(page, isolated);
|
|
}
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp,
|
|
unsigned long nr_pages)
|
|
{
|
|
struct page_counter *counter;
|
|
int ret = 0;
|
|
|
|
ret = page_counter_try_charge(&memcg->kmem, nr_pages, &counter);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = try_charge(memcg, gfp, nr_pages);
|
|
if (ret == -EINTR) {
|
|
/*
|
|
* try_charge() chose to bypass to root due to OOM kill or
|
|
* fatal signal. Since our only options are to either fail
|
|
* the allocation or charge it to this cgroup, do it as a
|
|
* temporary condition. But we can't fail. From a kmem/slab
|
|
* perspective, the cache has already been selected, by
|
|
* mem_cgroup_kmem_get_cache(), so it is too late to change
|
|
* our minds.
|
|
*
|
|
* This condition will only trigger if the task entered
|
|
* memcg_charge_kmem in a sane state, but was OOM-killed
|
|
* during try_charge() above. Tasks that were already dying
|
|
* when the allocation triggers should have been already
|
|
* directed to the root cgroup in memcontrol.h
|
|
*/
|
|
page_counter_charge(&memcg->memory, nr_pages);
|
|
if (do_swap_account)
|
|
page_counter_charge(&memcg->memsw, nr_pages);
|
|
css_get_many(&memcg->css, nr_pages);
|
|
ret = 0;
|
|
} else if (ret)
|
|
page_counter_uncharge(&memcg->kmem, nr_pages);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void memcg_uncharge_kmem(struct mem_cgroup *memcg, unsigned long nr_pages)
|
|
{
|
|
page_counter_uncharge(&memcg->memory, nr_pages);
|
|
if (do_swap_account)
|
|
page_counter_uncharge(&memcg->memsw, nr_pages);
|
|
|
|
page_counter_uncharge(&memcg->kmem, nr_pages);
|
|
|
|
css_put_many(&memcg->css, nr_pages);
|
|
}
|
|
|
|
/*
|
|
* helper for acessing a memcg's index. It will be used as an index in the
|
|
* child cache array in kmem_cache, and also to derive its name. This function
|
|
* will return -1 when this is not a kmem-limited memcg.
|
|
*/
|
|
int memcg_cache_id(struct mem_cgroup *memcg)
|
|
{
|
|
return memcg ? memcg->kmemcg_id : -1;
|
|
}
|
|
|
|
static int memcg_alloc_cache_id(void)
|
|
{
|
|
int id, size;
|
|
int err;
|
|
|
|
id = ida_simple_get(&memcg_cache_ida,
|
|
0, MEMCG_CACHES_MAX_SIZE, GFP_KERNEL);
|
|
if (id < 0)
|
|
return id;
|
|
|
|
if (id < memcg_nr_cache_ids)
|
|
return id;
|
|
|
|
/*
|
|
* There's no space for the new id in memcg_caches arrays,
|
|
* so we have to grow them.
|
|
*/
|
|
down_write(&memcg_cache_ids_sem);
|
|
|
|
size = 2 * (id + 1);
|
|
if (size < MEMCG_CACHES_MIN_SIZE)
|
|
size = MEMCG_CACHES_MIN_SIZE;
|
|
else if (size > MEMCG_CACHES_MAX_SIZE)
|
|
size = MEMCG_CACHES_MAX_SIZE;
|
|
|
|
err = memcg_update_all_caches(size);
|
|
if (!err)
|
|
err = memcg_update_all_list_lrus(size);
|
|
if (!err)
|
|
memcg_nr_cache_ids = size;
|
|
|
|
up_write(&memcg_cache_ids_sem);
|
|
|
|
if (err) {
|
|
ida_simple_remove(&memcg_cache_ida, id);
|
|
return err;
|
|
}
|
|
return id;
|
|
}
|
|
|
|
static void memcg_free_cache_id(int id)
|
|
{
|
|
ida_simple_remove(&memcg_cache_ida, id);
|
|
}
|
|
|
|
struct memcg_kmem_cache_create_work {
|
|
struct mem_cgroup *memcg;
|
|
struct kmem_cache *cachep;
|
|
struct work_struct work;
|
|
};
|
|
|
|
static void memcg_kmem_cache_create_func(struct work_struct *w)
|
|
{
|
|
struct memcg_kmem_cache_create_work *cw =
|
|
container_of(w, struct memcg_kmem_cache_create_work, work);
|
|
struct mem_cgroup *memcg = cw->memcg;
|
|
struct kmem_cache *cachep = cw->cachep;
|
|
|
|
memcg_create_kmem_cache(memcg, cachep);
|
|
|
|
css_put(&memcg->css);
|
|
kfree(cw);
|
|
}
|
|
|
|
/*
|
|
* Enqueue the creation of a per-memcg kmem_cache.
|
|
*/
|
|
static void __memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
|
|
struct kmem_cache *cachep)
|
|
{
|
|
struct memcg_kmem_cache_create_work *cw;
|
|
|
|
cw = kmalloc(sizeof(*cw), GFP_NOWAIT);
|
|
if (!cw)
|
|
return;
|
|
|
|
css_get(&memcg->css);
|
|
|
|
cw->memcg = memcg;
|
|
cw->cachep = cachep;
|
|
INIT_WORK(&cw->work, memcg_kmem_cache_create_func);
|
|
|
|
schedule_work(&cw->work);
|
|
}
|
|
|
|
static void memcg_schedule_kmem_cache_create(struct mem_cgroup *memcg,
|
|
struct kmem_cache *cachep)
|
|
{
|
|
/*
|
|
* We need to stop accounting when we kmalloc, because if the
|
|
* corresponding kmalloc cache is not yet created, the first allocation
|
|
* in __memcg_schedule_kmem_cache_create will recurse.
|
|
*
|
|
* However, it is better to enclose the whole function. Depending on
|
|
* the debugging options enabled, INIT_WORK(), for instance, can
|
|
* trigger an allocation. This too, will make us recurse. Because at
|
|
* this point we can't allow ourselves back into memcg_kmem_get_cache,
|
|
* the safest choice is to do it like this, wrapping the whole function.
|
|
*/
|
|
current->memcg_kmem_skip_account = 1;
|
|
__memcg_schedule_kmem_cache_create(memcg, cachep);
|
|
current->memcg_kmem_skip_account = 0;
|
|
}
|
|
|
|
/*
|
|
* Return the kmem_cache we're supposed to use for a slab allocation.
|
|
* We try to use the current memcg's version of the cache.
|
|
*
|
|
* If the cache does not exist yet, if we are the first user of it,
|
|
* we either create it immediately, if possible, or create it asynchronously
|
|
* in a workqueue.
|
|
* In the latter case, we will let the current allocation go through with
|
|
* the original cache.
|
|
*
|
|
* Can't be called in interrupt context or from kernel threads.
|
|
* This function needs to be called with rcu_read_lock() held.
|
|
*/
|
|
struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
struct kmem_cache *memcg_cachep;
|
|
int kmemcg_id;
|
|
|
|
VM_BUG_ON(!is_root_cache(cachep));
|
|
|
|
if (current->memcg_kmem_skip_account)
|
|
return cachep;
|
|
|
|
memcg = get_mem_cgroup_from_mm(current->mm);
|
|
kmemcg_id = ACCESS_ONCE(memcg->kmemcg_id);
|
|
if (kmemcg_id < 0)
|
|
goto out;
|
|
|
|
memcg_cachep = cache_from_memcg_idx(cachep, kmemcg_id);
|
|
if (likely(memcg_cachep))
|
|
return memcg_cachep;
|
|
|
|
/*
|
|
* If we are in a safe context (can wait, and not in interrupt
|
|
* context), we could be be predictable and return right away.
|
|
* This would guarantee that the allocation being performed
|
|
* already belongs in the new cache.
|
|
*
|
|
* However, there are some clashes that can arrive from locking.
|
|
* For instance, because we acquire the slab_mutex while doing
|
|
* memcg_create_kmem_cache, this means no further allocation
|
|
* could happen with the slab_mutex held. So it's better to
|
|
* defer everything.
|
|
*/
|
|
memcg_schedule_kmem_cache_create(memcg, cachep);
|
|
out:
|
|
css_put(&memcg->css);
|
|
return cachep;
|
|
}
|
|
|
|
void __memcg_kmem_put_cache(struct kmem_cache *cachep)
|
|
{
|
|
if (!is_root_cache(cachep))
|
|
css_put(&cachep->memcg_params.memcg->css);
|
|
}
|
|
|
|
/*
|
|
* We need to verify if the allocation against current->mm->owner's memcg is
|
|
* possible for the given order. But the page is not allocated yet, so we'll
|
|
* need a further commit step to do the final arrangements.
|
|
*
|
|
* It is possible for the task to switch cgroups in this mean time, so at
|
|
* commit time, we can't rely on task conversion any longer. We'll then use
|
|
* the handle argument to return to the caller which cgroup we should commit
|
|
* against. We could also return the memcg directly and avoid the pointer
|
|
* passing, but a boolean return value gives better semantics considering
|
|
* the compiled-out case as well.
|
|
*
|
|
* Returning true means the allocation is possible.
|
|
*/
|
|
bool
|
|
__memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **_memcg, int order)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
int ret;
|
|
|
|
*_memcg = NULL;
|
|
|
|
memcg = get_mem_cgroup_from_mm(current->mm);
|
|
|
|
if (!memcg_kmem_is_active(memcg)) {
|
|
css_put(&memcg->css);
|
|
return true;
|
|
}
|
|
|
|
ret = memcg_charge_kmem(memcg, gfp, 1 << order);
|
|
if (!ret)
|
|
*_memcg = memcg;
|
|
|
|
css_put(&memcg->css);
|
|
return (ret == 0);
|
|
}
|
|
|
|
void __memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg,
|
|
int order)
|
|
{
|
|
VM_BUG_ON(mem_cgroup_is_root(memcg));
|
|
|
|
/* The page allocation failed. Revert */
|
|
if (!page) {
|
|
memcg_uncharge_kmem(memcg, 1 << order);
|
|
return;
|
|
}
|
|
page->mem_cgroup = memcg;
|
|
}
|
|
|
|
void __memcg_kmem_uncharge_pages(struct page *page, int order)
|
|
{
|
|
struct mem_cgroup *memcg = page->mem_cgroup;
|
|
|
|
if (!memcg)
|
|
return;
|
|
|
|
VM_BUG_ON_PAGE(mem_cgroup_is_root(memcg), page);
|
|
|
|
memcg_uncharge_kmem(memcg, 1 << order);
|
|
page->mem_cgroup = NULL;
|
|
}
|
|
|
|
struct mem_cgroup *__mem_cgroup_from_kmem(void *ptr)
|
|
{
|
|
struct mem_cgroup *memcg = NULL;
|
|
struct kmem_cache *cachep;
|
|
struct page *page;
|
|
|
|
page = virt_to_head_page(ptr);
|
|
if (PageSlab(page)) {
|
|
cachep = page->slab_cache;
|
|
if (!is_root_cache(cachep))
|
|
memcg = cachep->memcg_params.memcg;
|
|
} else
|
|
/* page allocated by alloc_kmem_pages */
|
|
memcg = page->mem_cgroup;
|
|
|
|
return memcg;
|
|
}
|
|
#endif /* CONFIG_MEMCG_KMEM */
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
|
|
/*
|
|
* Because tail pages are not marked as "used", set it. We're under
|
|
* zone->lru_lock, 'splitting on pmd' and compound_lock.
|
|
* charge/uncharge will be never happen and move_account() is done under
|
|
* compound_lock(), so we don't have to take care of races.
|
|
*/
|
|
void mem_cgroup_split_huge_fixup(struct page *head)
|
|
{
|
|
int i;
|
|
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
|
|
for (i = 1; i < HPAGE_PMD_NR; i++)
|
|
head[i].mem_cgroup = head->mem_cgroup;
|
|
|
|
__this_cpu_sub(head->mem_cgroup->stat->count[MEM_CGROUP_STAT_RSS_HUGE],
|
|
HPAGE_PMD_NR);
|
|
}
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|
|
|
|
/**
|
|
* mem_cgroup_move_account - move account of the page
|
|
* @page: the page
|
|
* @nr_pages: number of regular pages (>1 for huge pages)
|
|
* @from: mem_cgroup which the page is moved from.
|
|
* @to: mem_cgroup which the page is moved to. @from != @to.
|
|
*
|
|
* The caller must confirm following.
|
|
* - page is not on LRU (isolate_page() is useful.)
|
|
* - compound_lock is held when nr_pages > 1
|
|
*
|
|
* This function doesn't do "charge" to new cgroup and doesn't do "uncharge"
|
|
* from old cgroup.
|
|
*/
|
|
static int mem_cgroup_move_account(struct page *page,
|
|
unsigned int nr_pages,
|
|
struct mem_cgroup *from,
|
|
struct mem_cgroup *to)
|
|
{
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
VM_BUG_ON(from == to);
|
|
VM_BUG_ON_PAGE(PageLRU(page), page);
|
|
/*
|
|
* The page is isolated from LRU. So, collapse function
|
|
* will not handle this page. But page splitting can happen.
|
|
* Do this check under compound_page_lock(). The caller should
|
|
* hold it.
|
|
*/
|
|
ret = -EBUSY;
|
|
if (nr_pages > 1 && !PageTransHuge(page))
|
|
goto out;
|
|
|
|
/*
|
|
* Prevent mem_cgroup_migrate() from looking at page->mem_cgroup
|
|
* of its source page while we change it: page migration takes
|
|
* both pages off the LRU, but page cache replacement doesn't.
|
|
*/
|
|
if (!trylock_page(page))
|
|
goto out;
|
|
|
|
ret = -EINVAL;
|
|
if (page->mem_cgroup != from)
|
|
goto out_unlock;
|
|
|
|
spin_lock_irqsave(&from->move_lock, flags);
|
|
|
|
if (!PageAnon(page) && page_mapped(page)) {
|
|
__this_cpu_sub(from->stat->count[MEM_CGROUP_STAT_FILE_MAPPED],
|
|
nr_pages);
|
|
__this_cpu_add(to->stat->count[MEM_CGROUP_STAT_FILE_MAPPED],
|
|
nr_pages);
|
|
}
|
|
|
|
if (PageWriteback(page)) {
|
|
__this_cpu_sub(from->stat->count[MEM_CGROUP_STAT_WRITEBACK],
|
|
nr_pages);
|
|
__this_cpu_add(to->stat->count[MEM_CGROUP_STAT_WRITEBACK],
|
|
nr_pages);
|
|
}
|
|
|
|
/*
|
|
* It is safe to change page->mem_cgroup here because the page
|
|
* is referenced, charged, and isolated - we can't race with
|
|
* uncharging, charging, migration, or LRU putback.
|
|
*/
|
|
|
|
/* caller should have done css_get */
|
|
page->mem_cgroup = to;
|
|
spin_unlock_irqrestore(&from->move_lock, flags);
|
|
|
|
ret = 0;
|
|
|
|
local_irq_disable();
|
|
mem_cgroup_charge_statistics(to, page, nr_pages);
|
|
memcg_check_events(to, page);
|
|
mem_cgroup_charge_statistics(from, page, -nr_pages);
|
|
memcg_check_events(from, page);
|
|
local_irq_enable();
|
|
out_unlock:
|
|
unlock_page(page);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_MEMCG_SWAP
|
|
static void mem_cgroup_swap_statistics(struct mem_cgroup *memcg,
|
|
bool charge)
|
|
{
|
|
int val = (charge) ? 1 : -1;
|
|
this_cpu_add(memcg->stat->count[MEM_CGROUP_STAT_SWAP], val);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_move_swap_account - move swap charge and swap_cgroup's record.
|
|
* @entry: swap entry to be moved
|
|
* @from: mem_cgroup which the entry is moved from
|
|
* @to: mem_cgroup which the entry is moved to
|
|
*
|
|
* It succeeds only when the swap_cgroup's record for this entry is the same
|
|
* as the mem_cgroup's id of @from.
|
|
*
|
|
* Returns 0 on success, -EINVAL on failure.
|
|
*
|
|
* The caller must have charged to @to, IOW, called page_counter_charge() about
|
|
* both res and memsw, and called css_get().
|
|
*/
|
|
static int mem_cgroup_move_swap_account(swp_entry_t entry,
|
|
struct mem_cgroup *from, struct mem_cgroup *to)
|
|
{
|
|
unsigned short old_id, new_id;
|
|
|
|
old_id = mem_cgroup_id(from);
|
|
new_id = mem_cgroup_id(to);
|
|
|
|
if (swap_cgroup_cmpxchg(entry, old_id, new_id) == old_id) {
|
|
mem_cgroup_swap_statistics(from, false);
|
|
mem_cgroup_swap_statistics(to, true);
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
#else
|
|
static inline int mem_cgroup_move_swap_account(swp_entry_t entry,
|
|
struct mem_cgroup *from, struct mem_cgroup *to)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
#endif
|
|
|
|
static DEFINE_MUTEX(memcg_limit_mutex);
|
|
|
|
static int mem_cgroup_resize_limit(struct mem_cgroup *memcg,
|
|
unsigned long limit)
|
|
{
|
|
unsigned long curusage;
|
|
unsigned long oldusage;
|
|
bool enlarge = false;
|
|
int retry_count;
|
|
int ret;
|
|
|
|
/*
|
|
* For keeping hierarchical_reclaim simple, how long we should retry
|
|
* is depends on callers. We set our retry-count to be function
|
|
* of # of children which we should visit in this loop.
|
|
*/
|
|
retry_count = MEM_CGROUP_RECLAIM_RETRIES *
|
|
mem_cgroup_count_children(memcg);
|
|
|
|
oldusage = page_counter_read(&memcg->memory);
|
|
|
|
do {
|
|
if (signal_pending(current)) {
|
|
ret = -EINTR;
|
|
break;
|
|
}
|
|
|
|
mutex_lock(&memcg_limit_mutex);
|
|
if (limit > memcg->memsw.limit) {
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
if (limit > memcg->memory.limit)
|
|
enlarge = true;
|
|
ret = page_counter_limit(&memcg->memory, limit);
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
|
|
if (!ret)
|
|
break;
|
|
|
|
try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL, true);
|
|
|
|
curusage = page_counter_read(&memcg->memory);
|
|
/* Usage is reduced ? */
|
|
if (curusage >= oldusage)
|
|
retry_count--;
|
|
else
|
|
oldusage = curusage;
|
|
} while (retry_count);
|
|
|
|
if (!ret && enlarge)
|
|
memcg_oom_recover(memcg);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int mem_cgroup_resize_memsw_limit(struct mem_cgroup *memcg,
|
|
unsigned long limit)
|
|
{
|
|
unsigned long curusage;
|
|
unsigned long oldusage;
|
|
bool enlarge = false;
|
|
int retry_count;
|
|
int ret;
|
|
|
|
/* see mem_cgroup_resize_res_limit */
|
|
retry_count = MEM_CGROUP_RECLAIM_RETRIES *
|
|
mem_cgroup_count_children(memcg);
|
|
|
|
oldusage = page_counter_read(&memcg->memsw);
|
|
|
|
do {
|
|
if (signal_pending(current)) {
|
|
ret = -EINTR;
|
|
break;
|
|
}
|
|
|
|
mutex_lock(&memcg_limit_mutex);
|
|
if (limit < memcg->memory.limit) {
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
if (limit > memcg->memsw.limit)
|
|
enlarge = true;
|
|
ret = page_counter_limit(&memcg->memsw, limit);
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
|
|
if (!ret)
|
|
break;
|
|
|
|
try_to_free_mem_cgroup_pages(memcg, 1, GFP_KERNEL, false);
|
|
|
|
curusage = page_counter_read(&memcg->memsw);
|
|
/* Usage is reduced ? */
|
|
if (curusage >= oldusage)
|
|
retry_count--;
|
|
else
|
|
oldusage = curusage;
|
|
} while (retry_count);
|
|
|
|
if (!ret && enlarge)
|
|
memcg_oom_recover(memcg);
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
|
|
gfp_t gfp_mask,
|
|
unsigned long *total_scanned)
|
|
{
|
|
unsigned long nr_reclaimed = 0;
|
|
struct mem_cgroup_per_zone *mz, *next_mz = NULL;
|
|
unsigned long reclaimed;
|
|
int loop = 0;
|
|
struct mem_cgroup_tree_per_zone *mctz;
|
|
unsigned long excess;
|
|
unsigned long nr_scanned;
|
|
|
|
if (order > 0)
|
|
return 0;
|
|
|
|
mctz = soft_limit_tree_node_zone(zone_to_nid(zone), zone_idx(zone));
|
|
/*
|
|
* This loop can run a while, specially if mem_cgroup's continuously
|
|
* keep exceeding their soft limit and putting the system under
|
|
* pressure
|
|
*/
|
|
do {
|
|
if (next_mz)
|
|
mz = next_mz;
|
|
else
|
|
mz = mem_cgroup_largest_soft_limit_node(mctz);
|
|
if (!mz)
|
|
break;
|
|
|
|
nr_scanned = 0;
|
|
reclaimed = mem_cgroup_soft_reclaim(mz->memcg, zone,
|
|
gfp_mask, &nr_scanned);
|
|
nr_reclaimed += reclaimed;
|
|
*total_scanned += nr_scanned;
|
|
spin_lock_irq(&mctz->lock);
|
|
__mem_cgroup_remove_exceeded(mz, mctz);
|
|
|
|
/*
|
|
* If we failed to reclaim anything from this memory cgroup
|
|
* it is time to move on to the next cgroup
|
|
*/
|
|
next_mz = NULL;
|
|
if (!reclaimed)
|
|
next_mz = __mem_cgroup_largest_soft_limit_node(mctz);
|
|
|
|
excess = soft_limit_excess(mz->memcg);
|
|
/*
|
|
* One school of thought says that we should not add
|
|
* back the node to the tree if reclaim returns 0.
|
|
* But our reclaim could return 0, simply because due
|
|
* to priority we are exposing a smaller subset of
|
|
* memory to reclaim from. Consider this as a longer
|
|
* term TODO.
|
|
*/
|
|
/* If excess == 0, no tree ops */
|
|
__mem_cgroup_insert_exceeded(mz, mctz, excess);
|
|
spin_unlock_irq(&mctz->lock);
|
|
css_put(&mz->memcg->css);
|
|
loop++;
|
|
/*
|
|
* Could not reclaim anything and there are no more
|
|
* mem cgroups to try or we seem to be looping without
|
|
* reclaiming anything.
|
|
*/
|
|
if (!nr_reclaimed &&
|
|
(next_mz == NULL ||
|
|
loop > MEM_CGROUP_MAX_SOFT_LIMIT_RECLAIM_LOOPS))
|
|
break;
|
|
} while (!nr_reclaimed);
|
|
if (next_mz)
|
|
css_put(&next_mz->memcg->css);
|
|
return nr_reclaimed;
|
|
}
|
|
|
|
/*
|
|
* Test whether @memcg has children, dead or alive. Note that this
|
|
* function doesn't care whether @memcg has use_hierarchy enabled and
|
|
* returns %true if there are child csses according to the cgroup
|
|
* hierarchy. Testing use_hierarchy is the caller's responsiblity.
|
|
*/
|
|
static inline bool memcg_has_children(struct mem_cgroup *memcg)
|
|
{
|
|
bool ret;
|
|
|
|
/*
|
|
* The lock does not prevent addition or deletion of children, but
|
|
* it prevents a new child from being initialized based on this
|
|
* parent in css_online(), so it's enough to decide whether
|
|
* hierarchically inherited attributes can still be changed or not.
|
|
*/
|
|
lockdep_assert_held(&memcg_create_mutex);
|
|
|
|
rcu_read_lock();
|
|
ret = css_next_child(NULL, &memcg->css);
|
|
rcu_read_unlock();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Reclaims as many pages from the given memcg as possible and moves
|
|
* the rest to the parent.
|
|
*
|
|
* Caller is responsible for holding css reference for memcg.
|
|
*/
|
|
static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
|
|
{
|
|
int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
|
|
|
|
/* we call try-to-free pages for make this cgroup empty */
|
|
lru_add_drain_all();
|
|
/* try to free all pages in this cgroup */
|
|
while (nr_retries && page_counter_read(&memcg->memory)) {
|
|
int progress;
|
|
|
|
if (signal_pending(current))
|
|
return -EINTR;
|
|
|
|
progress = try_to_free_mem_cgroup_pages(memcg, 1,
|
|
GFP_KERNEL, true);
|
|
if (!progress) {
|
|
nr_retries--;
|
|
/* maybe some writeback is necessary */
|
|
congestion_wait(BLK_RW_ASYNC, HZ/10);
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t mem_cgroup_force_empty_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes,
|
|
loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
|
|
if (mem_cgroup_is_root(memcg))
|
|
return -EINVAL;
|
|
return mem_cgroup_force_empty(memcg) ?: nbytes;
|
|
}
|
|
|
|
static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
|
|
struct cftype *cft)
|
|
{
|
|
return mem_cgroup_from_css(css)->use_hierarchy;
|
|
}
|
|
|
|
static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
|
|
struct cftype *cft, u64 val)
|
|
{
|
|
int retval = 0;
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
struct mem_cgroup *parent_memcg = mem_cgroup_from_css(memcg->css.parent);
|
|
|
|
mutex_lock(&memcg_create_mutex);
|
|
|
|
if (memcg->use_hierarchy == val)
|
|
goto out;
|
|
|
|
/*
|
|
* If parent's use_hierarchy is set, we can't make any modifications
|
|
* in the child subtrees. If it is unset, then the change can
|
|
* occur, provided the current cgroup has no children.
|
|
*
|
|
* For the root cgroup, parent_mem is NULL, we allow value to be
|
|
* set if there are no children.
|
|
*/
|
|
if ((!parent_memcg || !parent_memcg->use_hierarchy) &&
|
|
(val == 1 || val == 0)) {
|
|
if (!memcg_has_children(memcg))
|
|
memcg->use_hierarchy = val;
|
|
else
|
|
retval = -EBUSY;
|
|
} else
|
|
retval = -EINVAL;
|
|
|
|
out:
|
|
mutex_unlock(&memcg_create_mutex);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static unsigned long tree_stat(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_stat_index idx)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
long val = 0;
|
|
|
|
/* Per-cpu values can be negative, use a signed accumulator */
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
val += mem_cgroup_read_stat(iter, idx);
|
|
|
|
if (val < 0) /* race ? */
|
|
val = 0;
|
|
return val;
|
|
}
|
|
|
|
static inline u64 mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
|
|
{
|
|
u64 val;
|
|
|
|
if (mem_cgroup_is_root(memcg)) {
|
|
val = tree_stat(memcg, MEM_CGROUP_STAT_CACHE);
|
|
val += tree_stat(memcg, MEM_CGROUP_STAT_RSS);
|
|
if (swap)
|
|
val += tree_stat(memcg, MEM_CGROUP_STAT_SWAP);
|
|
} else {
|
|
if (!swap)
|
|
val = page_counter_read(&memcg->memory);
|
|
else
|
|
val = page_counter_read(&memcg->memsw);
|
|
}
|
|
return val << PAGE_SHIFT;
|
|
}
|
|
|
|
enum {
|
|
RES_USAGE,
|
|
RES_LIMIT,
|
|
RES_MAX_USAGE,
|
|
RES_FAILCNT,
|
|
RES_SOFT_LIMIT,
|
|
};
|
|
|
|
static u64 mem_cgroup_read_u64(struct cgroup_subsys_state *css,
|
|
struct cftype *cft)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
struct page_counter *counter;
|
|
|
|
switch (MEMFILE_TYPE(cft->private)) {
|
|
case _MEM:
|
|
counter = &memcg->memory;
|
|
break;
|
|
case _MEMSWAP:
|
|
counter = &memcg->memsw;
|
|
break;
|
|
case _KMEM:
|
|
counter = &memcg->kmem;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
switch (MEMFILE_ATTR(cft->private)) {
|
|
case RES_USAGE:
|
|
if (counter == &memcg->memory)
|
|
return mem_cgroup_usage(memcg, false);
|
|
if (counter == &memcg->memsw)
|
|
return mem_cgroup_usage(memcg, true);
|
|
return (u64)page_counter_read(counter) * PAGE_SIZE;
|
|
case RES_LIMIT:
|
|
return (u64)counter->limit * PAGE_SIZE;
|
|
case RES_MAX_USAGE:
|
|
return (u64)counter->watermark * PAGE_SIZE;
|
|
case RES_FAILCNT:
|
|
return counter->failcnt;
|
|
case RES_SOFT_LIMIT:
|
|
return (u64)memcg->soft_limit * PAGE_SIZE;
|
|
default:
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
static int memcg_activate_kmem(struct mem_cgroup *memcg,
|
|
unsigned long nr_pages)
|
|
{
|
|
int err = 0;
|
|
int memcg_id;
|
|
|
|
BUG_ON(memcg->kmemcg_id >= 0);
|
|
BUG_ON(memcg->kmem_acct_activated);
|
|
BUG_ON(memcg->kmem_acct_active);
|
|
|
|
/*
|
|
* For simplicity, we won't allow this to be disabled. It also can't
|
|
* be changed if the cgroup has children already, or if tasks had
|
|
* already joined.
|
|
*
|
|
* If tasks join before we set the limit, a person looking at
|
|
* kmem.usage_in_bytes will have no way to determine when it took
|
|
* place, which makes the value quite meaningless.
|
|
*
|
|
* After it first became limited, changes in the value of the limit are
|
|
* of course permitted.
|
|
*/
|
|
mutex_lock(&memcg_create_mutex);
|
|
if (cgroup_has_tasks(memcg->css.cgroup) ||
|
|
(memcg->use_hierarchy && memcg_has_children(memcg)))
|
|
err = -EBUSY;
|
|
mutex_unlock(&memcg_create_mutex);
|
|
if (err)
|
|
goto out;
|
|
|
|
memcg_id = memcg_alloc_cache_id();
|
|
if (memcg_id < 0) {
|
|
err = memcg_id;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* We couldn't have accounted to this cgroup, because it hasn't got
|
|
* activated yet, so this should succeed.
|
|
*/
|
|
err = page_counter_limit(&memcg->kmem, nr_pages);
|
|
VM_BUG_ON(err);
|
|
|
|
static_key_slow_inc(&memcg_kmem_enabled_key);
|
|
/*
|
|
* A memory cgroup is considered kmem-active as soon as it gets
|
|
* kmemcg_id. Setting the id after enabling static branching will
|
|
* guarantee no one starts accounting before all call sites are
|
|
* patched.
|
|
*/
|
|
memcg->kmemcg_id = memcg_id;
|
|
memcg->kmem_acct_activated = true;
|
|
memcg->kmem_acct_active = true;
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static int memcg_update_kmem_limit(struct mem_cgroup *memcg,
|
|
unsigned long limit)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&memcg_limit_mutex);
|
|
if (!memcg_kmem_is_active(memcg))
|
|
ret = memcg_activate_kmem(memcg, limit);
|
|
else
|
|
ret = page_counter_limit(&memcg->kmem, limit);
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
return ret;
|
|
}
|
|
|
|
static int memcg_propagate_kmem(struct mem_cgroup *memcg)
|
|
{
|
|
int ret = 0;
|
|
struct mem_cgroup *parent = parent_mem_cgroup(memcg);
|
|
|
|
if (!parent)
|
|
return 0;
|
|
|
|
mutex_lock(&memcg_limit_mutex);
|
|
/*
|
|
* If the parent cgroup is not kmem-active now, it cannot be activated
|
|
* after this point, because it has at least one child already.
|
|
*/
|
|
if (memcg_kmem_is_active(parent))
|
|
ret = memcg_activate_kmem(memcg, PAGE_COUNTER_MAX);
|
|
mutex_unlock(&memcg_limit_mutex);
|
|
return ret;
|
|
}
|
|
#else
|
|
static int memcg_update_kmem_limit(struct mem_cgroup *memcg,
|
|
unsigned long limit)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
#endif /* CONFIG_MEMCG_KMEM */
|
|
|
|
/*
|
|
* The user of this function is...
|
|
* RES_LIMIT.
|
|
*/
|
|
static ssize_t mem_cgroup_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
unsigned long nr_pages;
|
|
int ret;
|
|
|
|
buf = strstrip(buf);
|
|
ret = page_counter_memparse(buf, "-1", &nr_pages);
|
|
if (ret)
|
|
return ret;
|
|
|
|
switch (MEMFILE_ATTR(of_cft(of)->private)) {
|
|
case RES_LIMIT:
|
|
if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
switch (MEMFILE_TYPE(of_cft(of)->private)) {
|
|
case _MEM:
|
|
ret = mem_cgroup_resize_limit(memcg, nr_pages);
|
|
break;
|
|
case _MEMSWAP:
|
|
ret = mem_cgroup_resize_memsw_limit(memcg, nr_pages);
|
|
break;
|
|
case _KMEM:
|
|
ret = memcg_update_kmem_limit(memcg, nr_pages);
|
|
break;
|
|
}
|
|
break;
|
|
case RES_SOFT_LIMIT:
|
|
memcg->soft_limit = nr_pages;
|
|
ret = 0;
|
|
break;
|
|
}
|
|
return ret ?: nbytes;
|
|
}
|
|
|
|
static ssize_t mem_cgroup_reset(struct kernfs_open_file *of, char *buf,
|
|
size_t nbytes, loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
struct page_counter *counter;
|
|
|
|
switch (MEMFILE_TYPE(of_cft(of)->private)) {
|
|
case _MEM:
|
|
counter = &memcg->memory;
|
|
break;
|
|
case _MEMSWAP:
|
|
counter = &memcg->memsw;
|
|
break;
|
|
case _KMEM:
|
|
counter = &memcg->kmem;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
switch (MEMFILE_ATTR(of_cft(of)->private)) {
|
|
case RES_MAX_USAGE:
|
|
page_counter_reset_watermark(counter);
|
|
break;
|
|
case RES_FAILCNT:
|
|
counter->failcnt = 0;
|
|
break;
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
|
|
struct cftype *cft)
|
|
{
|
|
return mem_cgroup_from_css(css)->move_charge_at_immigrate;
|
|
}
|
|
|
|
#ifdef CONFIG_MMU
|
|
static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
|
|
struct cftype *cft, u64 val)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
if (val & ~MOVE_MASK)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* No kind of locking is needed in here, because ->can_attach() will
|
|
* check this value once in the beginning of the process, and then carry
|
|
* on with stale data. This means that changes to this value will only
|
|
* affect task migrations starting after the change.
|
|
*/
|
|
memcg->move_charge_at_immigrate = val;
|
|
return 0;
|
|
}
|
|
#else
|
|
static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
|
|
struct cftype *cft, u64 val)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_NUMA
|
|
static int memcg_numa_stat_show(struct seq_file *m, void *v)
|
|
{
|
|
struct numa_stat {
|
|
const char *name;
|
|
unsigned int lru_mask;
|
|
};
|
|
|
|
static const struct numa_stat stats[] = {
|
|
{ "total", LRU_ALL },
|
|
{ "file", LRU_ALL_FILE },
|
|
{ "anon", LRU_ALL_ANON },
|
|
{ "unevictable", BIT(LRU_UNEVICTABLE) },
|
|
};
|
|
const struct numa_stat *stat;
|
|
int nid;
|
|
unsigned long nr;
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
|
|
for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
|
|
nr = mem_cgroup_nr_lru_pages(memcg, stat->lru_mask);
|
|
seq_printf(m, "%s=%lu", stat->name, nr);
|
|
for_each_node_state(nid, N_MEMORY) {
|
|
nr = mem_cgroup_node_nr_lru_pages(memcg, nid,
|
|
stat->lru_mask);
|
|
seq_printf(m, " N%d=%lu", nid, nr);
|
|
}
|
|
seq_putc(m, '\n');
|
|
}
|
|
|
|
for (stat = stats; stat < stats + ARRAY_SIZE(stats); stat++) {
|
|
struct mem_cgroup *iter;
|
|
|
|
nr = 0;
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
nr += mem_cgroup_nr_lru_pages(iter, stat->lru_mask);
|
|
seq_printf(m, "hierarchical_%s=%lu", stat->name, nr);
|
|
for_each_node_state(nid, N_MEMORY) {
|
|
nr = 0;
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
nr += mem_cgroup_node_nr_lru_pages(
|
|
iter, nid, stat->lru_mask);
|
|
seq_printf(m, " N%d=%lu", nid, nr);
|
|
}
|
|
seq_putc(m, '\n');
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_NUMA */
|
|
|
|
static int memcg_stat_show(struct seq_file *m, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
unsigned long memory, memsw;
|
|
struct mem_cgroup *mi;
|
|
unsigned int i;
|
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_stat_names) !=
|
|
MEM_CGROUP_STAT_NSTATS);
|
|
BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_events_names) !=
|
|
MEM_CGROUP_EVENTS_NSTATS);
|
|
BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_lru_names) != NR_LRU_LISTS);
|
|
|
|
for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
|
|
if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
|
|
continue;
|
|
seq_printf(m, "%s %ld\n", mem_cgroup_stat_names[i],
|
|
mem_cgroup_read_stat(memcg, i) * PAGE_SIZE);
|
|
}
|
|
|
|
for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++)
|
|
seq_printf(m, "%s %lu\n", mem_cgroup_events_names[i],
|
|
mem_cgroup_read_events(memcg, i));
|
|
|
|
for (i = 0; i < NR_LRU_LISTS; i++)
|
|
seq_printf(m, "%s %lu\n", mem_cgroup_lru_names[i],
|
|
mem_cgroup_nr_lru_pages(memcg, BIT(i)) * PAGE_SIZE);
|
|
|
|
/* Hierarchical information */
|
|
memory = memsw = PAGE_COUNTER_MAX;
|
|
for (mi = memcg; mi; mi = parent_mem_cgroup(mi)) {
|
|
memory = min(memory, mi->memory.limit);
|
|
memsw = min(memsw, mi->memsw.limit);
|
|
}
|
|
seq_printf(m, "hierarchical_memory_limit %llu\n",
|
|
(u64)memory * PAGE_SIZE);
|
|
if (do_swap_account)
|
|
seq_printf(m, "hierarchical_memsw_limit %llu\n",
|
|
(u64)memsw * PAGE_SIZE);
|
|
|
|
for (i = 0; i < MEM_CGROUP_STAT_NSTATS; i++) {
|
|
long long val = 0;
|
|
|
|
if (i == MEM_CGROUP_STAT_SWAP && !do_swap_account)
|
|
continue;
|
|
for_each_mem_cgroup_tree(mi, memcg)
|
|
val += mem_cgroup_read_stat(mi, i) * PAGE_SIZE;
|
|
seq_printf(m, "total_%s %lld\n", mem_cgroup_stat_names[i], val);
|
|
}
|
|
|
|
for (i = 0; i < MEM_CGROUP_EVENTS_NSTATS; i++) {
|
|
unsigned long long val = 0;
|
|
|
|
for_each_mem_cgroup_tree(mi, memcg)
|
|
val += mem_cgroup_read_events(mi, i);
|
|
seq_printf(m, "total_%s %llu\n",
|
|
mem_cgroup_events_names[i], val);
|
|
}
|
|
|
|
for (i = 0; i < NR_LRU_LISTS; i++) {
|
|
unsigned long long val = 0;
|
|
|
|
for_each_mem_cgroup_tree(mi, memcg)
|
|
val += mem_cgroup_nr_lru_pages(mi, BIT(i)) * PAGE_SIZE;
|
|
seq_printf(m, "total_%s %llu\n", mem_cgroup_lru_names[i], val);
|
|
}
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
{
|
|
int nid, zid;
|
|
struct mem_cgroup_per_zone *mz;
|
|
struct zone_reclaim_stat *rstat;
|
|
unsigned long recent_rotated[2] = {0, 0};
|
|
unsigned long recent_scanned[2] = {0, 0};
|
|
|
|
for_each_online_node(nid)
|
|
for (zid = 0; zid < MAX_NR_ZONES; zid++) {
|
|
mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
|
|
rstat = &mz->lruvec.reclaim_stat;
|
|
|
|
recent_rotated[0] += rstat->recent_rotated[0];
|
|
recent_rotated[1] += rstat->recent_rotated[1];
|
|
recent_scanned[0] += rstat->recent_scanned[0];
|
|
recent_scanned[1] += rstat->recent_scanned[1];
|
|
}
|
|
seq_printf(m, "recent_rotated_anon %lu\n", recent_rotated[0]);
|
|
seq_printf(m, "recent_rotated_file %lu\n", recent_rotated[1]);
|
|
seq_printf(m, "recent_scanned_anon %lu\n", recent_scanned[0]);
|
|
seq_printf(m, "recent_scanned_file %lu\n", recent_scanned[1]);
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
|
|
struct cftype *cft)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
return mem_cgroup_swappiness(memcg);
|
|
}
|
|
|
|
static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
|
|
struct cftype *cft, u64 val)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
if (val > 100)
|
|
return -EINVAL;
|
|
|
|
if (css->parent)
|
|
memcg->swappiness = val;
|
|
else
|
|
vm_swappiness = val;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __mem_cgroup_threshold(struct mem_cgroup *memcg, bool swap)
|
|
{
|
|
struct mem_cgroup_threshold_ary *t;
|
|
unsigned long usage;
|
|
int i;
|
|
|
|
rcu_read_lock();
|
|
if (!swap)
|
|
t = rcu_dereference(memcg->thresholds.primary);
|
|
else
|
|
t = rcu_dereference(memcg->memsw_thresholds.primary);
|
|
|
|
if (!t)
|
|
goto unlock;
|
|
|
|
usage = mem_cgroup_usage(memcg, swap);
|
|
|
|
/*
|
|
* current_threshold points to threshold just below or equal to usage.
|
|
* If it's not true, a threshold was crossed after last
|
|
* call of __mem_cgroup_threshold().
|
|
*/
|
|
i = t->current_threshold;
|
|
|
|
/*
|
|
* Iterate backward over array of thresholds starting from
|
|
* current_threshold and check if a threshold is crossed.
|
|
* If none of thresholds below usage is crossed, we read
|
|
* only one element of the array here.
|
|
*/
|
|
for (; i >= 0 && unlikely(t->entries[i].threshold > usage); i--)
|
|
eventfd_signal(t->entries[i].eventfd, 1);
|
|
|
|
/* i = current_threshold + 1 */
|
|
i++;
|
|
|
|
/*
|
|
* Iterate forward over array of thresholds starting from
|
|
* current_threshold+1 and check if a threshold is crossed.
|
|
* If none of thresholds above usage is crossed, we read
|
|
* only one element of the array here.
|
|
*/
|
|
for (; i < t->size && unlikely(t->entries[i].threshold <= usage); i++)
|
|
eventfd_signal(t->entries[i].eventfd, 1);
|
|
|
|
/* Update current_threshold */
|
|
t->current_threshold = i - 1;
|
|
unlock:
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
static void mem_cgroup_threshold(struct mem_cgroup *memcg)
|
|
{
|
|
while (memcg) {
|
|
__mem_cgroup_threshold(memcg, false);
|
|
if (do_swap_account)
|
|
__mem_cgroup_threshold(memcg, true);
|
|
|
|
memcg = parent_mem_cgroup(memcg);
|
|
}
|
|
}
|
|
|
|
static int compare_thresholds(const void *a, const void *b)
|
|
{
|
|
const struct mem_cgroup_threshold *_a = a;
|
|
const struct mem_cgroup_threshold *_b = b;
|
|
|
|
if (_a->threshold > _b->threshold)
|
|
return 1;
|
|
|
|
if (_a->threshold < _b->threshold)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mem_cgroup_oom_notify_cb(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup_eventfd_list *ev;
|
|
|
|
spin_lock(&memcg_oom_lock);
|
|
|
|
list_for_each_entry(ev, &memcg->oom_notify, list)
|
|
eventfd_signal(ev->eventfd, 1);
|
|
|
|
spin_unlock(&memcg_oom_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
|
|
{
|
|
struct mem_cgroup *iter;
|
|
|
|
for_each_mem_cgroup_tree(iter, memcg)
|
|
mem_cgroup_oom_notify_cb(iter);
|
|
}
|
|
|
|
static int __mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, const char *args, enum res_type type)
|
|
{
|
|
struct mem_cgroup_thresholds *thresholds;
|
|
struct mem_cgroup_threshold_ary *new;
|
|
unsigned long threshold;
|
|
unsigned long usage;
|
|
int i, size, ret;
|
|
|
|
ret = page_counter_memparse(args, "-1", &threshold);
|
|
if (ret)
|
|
return ret;
|
|
|
|
mutex_lock(&memcg->thresholds_lock);
|
|
|
|
if (type == _MEM) {
|
|
thresholds = &memcg->thresholds;
|
|
usage = mem_cgroup_usage(memcg, false);
|
|
} else if (type == _MEMSWAP) {
|
|
thresholds = &memcg->memsw_thresholds;
|
|
usage = mem_cgroup_usage(memcg, true);
|
|
} else
|
|
BUG();
|
|
|
|
/* Check if a threshold crossed before adding a new one */
|
|
if (thresholds->primary)
|
|
__mem_cgroup_threshold(memcg, type == _MEMSWAP);
|
|
|
|
size = thresholds->primary ? thresholds->primary->size + 1 : 1;
|
|
|
|
/* Allocate memory for new array of thresholds */
|
|
new = kmalloc(sizeof(*new) + size * sizeof(struct mem_cgroup_threshold),
|
|
GFP_KERNEL);
|
|
if (!new) {
|
|
ret = -ENOMEM;
|
|
goto unlock;
|
|
}
|
|
new->size = size;
|
|
|
|
/* Copy thresholds (if any) to new array */
|
|
if (thresholds->primary) {
|
|
memcpy(new->entries, thresholds->primary->entries, (size - 1) *
|
|
sizeof(struct mem_cgroup_threshold));
|
|
}
|
|
|
|
/* Add new threshold */
|
|
new->entries[size - 1].eventfd = eventfd;
|
|
new->entries[size - 1].threshold = threshold;
|
|
|
|
/* Sort thresholds. Registering of new threshold isn't time-critical */
|
|
sort(new->entries, size, sizeof(struct mem_cgroup_threshold),
|
|
compare_thresholds, NULL);
|
|
|
|
/* Find current threshold */
|
|
new->current_threshold = -1;
|
|
for (i = 0; i < size; i++) {
|
|
if (new->entries[i].threshold <= usage) {
|
|
/*
|
|
* new->current_threshold will not be used until
|
|
* rcu_assign_pointer(), so it's safe to increment
|
|
* it here.
|
|
*/
|
|
++new->current_threshold;
|
|
} else
|
|
break;
|
|
}
|
|
|
|
/* Free old spare buffer and save old primary buffer as spare */
|
|
kfree(thresholds->spare);
|
|
thresholds->spare = thresholds->primary;
|
|
|
|
rcu_assign_pointer(thresholds->primary, new);
|
|
|
|
/* To be sure that nobody uses thresholds */
|
|
synchronize_rcu();
|
|
|
|
unlock:
|
|
mutex_unlock(&memcg->thresholds_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int mem_cgroup_usage_register_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, const char *args)
|
|
{
|
|
return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEM);
|
|
}
|
|
|
|
static int memsw_cgroup_usage_register_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, const char *args)
|
|
{
|
|
return __mem_cgroup_usage_register_event(memcg, eventfd, args, _MEMSWAP);
|
|
}
|
|
|
|
static void __mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, enum res_type type)
|
|
{
|
|
struct mem_cgroup_thresholds *thresholds;
|
|
struct mem_cgroup_threshold_ary *new;
|
|
unsigned long usage;
|
|
int i, j, size;
|
|
|
|
mutex_lock(&memcg->thresholds_lock);
|
|
|
|
if (type == _MEM) {
|
|
thresholds = &memcg->thresholds;
|
|
usage = mem_cgroup_usage(memcg, false);
|
|
} else if (type == _MEMSWAP) {
|
|
thresholds = &memcg->memsw_thresholds;
|
|
usage = mem_cgroup_usage(memcg, true);
|
|
} else
|
|
BUG();
|
|
|
|
if (!thresholds->primary)
|
|
goto unlock;
|
|
|
|
/* Check if a threshold crossed before removing */
|
|
__mem_cgroup_threshold(memcg, type == _MEMSWAP);
|
|
|
|
/* Calculate new number of threshold */
|
|
size = 0;
|
|
for (i = 0; i < thresholds->primary->size; i++) {
|
|
if (thresholds->primary->entries[i].eventfd != eventfd)
|
|
size++;
|
|
}
|
|
|
|
new = thresholds->spare;
|
|
|
|
/* Set thresholds array to NULL if we don't have thresholds */
|
|
if (!size) {
|
|
kfree(new);
|
|
new = NULL;
|
|
goto swap_buffers;
|
|
}
|
|
|
|
new->size = size;
|
|
|
|
/* Copy thresholds and find current threshold */
|
|
new->current_threshold = -1;
|
|
for (i = 0, j = 0; i < thresholds->primary->size; i++) {
|
|
if (thresholds->primary->entries[i].eventfd == eventfd)
|
|
continue;
|
|
|
|
new->entries[j] = thresholds->primary->entries[i];
|
|
if (new->entries[j].threshold <= usage) {
|
|
/*
|
|
* new->current_threshold will not be used
|
|
* until rcu_assign_pointer(), so it's safe to increment
|
|
* it here.
|
|
*/
|
|
++new->current_threshold;
|
|
}
|
|
j++;
|
|
}
|
|
|
|
swap_buffers:
|
|
/* Swap primary and spare array */
|
|
thresholds->spare = thresholds->primary;
|
|
/* If all events are unregistered, free the spare array */
|
|
if (!new) {
|
|
kfree(thresholds->spare);
|
|
thresholds->spare = NULL;
|
|
}
|
|
|
|
rcu_assign_pointer(thresholds->primary, new);
|
|
|
|
/* To be sure that nobody uses thresholds */
|
|
synchronize_rcu();
|
|
unlock:
|
|
mutex_unlock(&memcg->thresholds_lock);
|
|
}
|
|
|
|
static void mem_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd)
|
|
{
|
|
return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEM);
|
|
}
|
|
|
|
static void memsw_cgroup_usage_unregister_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd)
|
|
{
|
|
return __mem_cgroup_usage_unregister_event(memcg, eventfd, _MEMSWAP);
|
|
}
|
|
|
|
static int mem_cgroup_oom_register_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd, const char *args)
|
|
{
|
|
struct mem_cgroup_eventfd_list *event;
|
|
|
|
event = kmalloc(sizeof(*event), GFP_KERNEL);
|
|
if (!event)
|
|
return -ENOMEM;
|
|
|
|
spin_lock(&memcg_oom_lock);
|
|
|
|
event->eventfd = eventfd;
|
|
list_add(&event->list, &memcg->oom_notify);
|
|
|
|
/* already in OOM ? */
|
|
if (atomic_read(&memcg->under_oom))
|
|
eventfd_signal(eventfd, 1);
|
|
spin_unlock(&memcg_oom_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void mem_cgroup_oom_unregister_event(struct mem_cgroup *memcg,
|
|
struct eventfd_ctx *eventfd)
|
|
{
|
|
struct mem_cgroup_eventfd_list *ev, *tmp;
|
|
|
|
spin_lock(&memcg_oom_lock);
|
|
|
|
list_for_each_entry_safe(ev, tmp, &memcg->oom_notify, list) {
|
|
if (ev->eventfd == eventfd) {
|
|
list_del(&ev->list);
|
|
kfree(ev);
|
|
}
|
|
}
|
|
|
|
spin_unlock(&memcg_oom_lock);
|
|
}
|
|
|
|
static int mem_cgroup_oom_control_read(struct seq_file *sf, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(sf));
|
|
|
|
seq_printf(sf, "oom_kill_disable %d\n", memcg->oom_kill_disable);
|
|
seq_printf(sf, "under_oom %d\n", (bool)atomic_read(&memcg->under_oom));
|
|
return 0;
|
|
}
|
|
|
|
static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
|
|
struct cftype *cft, u64 val)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
/* cannot set to root cgroup and only 0 and 1 are allowed */
|
|
if (!css->parent || !((val == 0) || (val == 1)))
|
|
return -EINVAL;
|
|
|
|
memcg->oom_kill_disable = val;
|
|
if (!val)
|
|
memcg_oom_recover(memcg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
static int memcg_init_kmem(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
|
|
{
|
|
int ret;
|
|
|
|
ret = memcg_propagate_kmem(memcg);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return mem_cgroup_sockets_init(memcg, ss);
|
|
}
|
|
|
|
static void memcg_deactivate_kmem(struct mem_cgroup *memcg)
|
|
{
|
|
struct cgroup_subsys_state *css;
|
|
struct mem_cgroup *parent, *child;
|
|
int kmemcg_id;
|
|
|
|
if (!memcg->kmem_acct_active)
|
|
return;
|
|
|
|
/*
|
|
* Clear the 'active' flag before clearing memcg_caches arrays entries.
|
|
* Since we take the slab_mutex in memcg_deactivate_kmem_caches(), it
|
|
* guarantees no cache will be created for this cgroup after we are
|
|
* done (see memcg_create_kmem_cache()).
|
|
*/
|
|
memcg->kmem_acct_active = false;
|
|
|
|
memcg_deactivate_kmem_caches(memcg);
|
|
|
|
kmemcg_id = memcg->kmemcg_id;
|
|
BUG_ON(kmemcg_id < 0);
|
|
|
|
parent = parent_mem_cgroup(memcg);
|
|
if (!parent)
|
|
parent = root_mem_cgroup;
|
|
|
|
/*
|
|
* Change kmemcg_id of this cgroup and all its descendants to the
|
|
* parent's id, and then move all entries from this cgroup's list_lrus
|
|
* to ones of the parent. After we have finished, all list_lrus
|
|
* corresponding to this cgroup are guaranteed to remain empty. The
|
|
* ordering is imposed by list_lru_node->lock taken by
|
|
* memcg_drain_all_list_lrus().
|
|
*/
|
|
css_for_each_descendant_pre(css, &memcg->css) {
|
|
child = mem_cgroup_from_css(css);
|
|
BUG_ON(child->kmemcg_id != kmemcg_id);
|
|
child->kmemcg_id = parent->kmemcg_id;
|
|
if (!memcg->use_hierarchy)
|
|
break;
|
|
}
|
|
memcg_drain_all_list_lrus(kmemcg_id, parent->kmemcg_id);
|
|
|
|
memcg_free_cache_id(kmemcg_id);
|
|
}
|
|
|
|
static void memcg_destroy_kmem(struct mem_cgroup *memcg)
|
|
{
|
|
if (memcg->kmem_acct_activated) {
|
|
memcg_destroy_kmem_caches(memcg);
|
|
static_key_slow_dec(&memcg_kmem_enabled_key);
|
|
WARN_ON(page_counter_read(&memcg->kmem));
|
|
}
|
|
mem_cgroup_sockets_destroy(memcg);
|
|
}
|
|
#else
|
|
static int memcg_init_kmem(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void memcg_deactivate_kmem(struct mem_cgroup *memcg)
|
|
{
|
|
}
|
|
|
|
static void memcg_destroy_kmem(struct mem_cgroup *memcg)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* DO NOT USE IN NEW FILES.
|
|
*
|
|
* "cgroup.event_control" implementation.
|
|
*
|
|
* This is way over-engineered. It tries to support fully configurable
|
|
* events for each user. Such level of flexibility is completely
|
|
* unnecessary especially in the light of the planned unified hierarchy.
|
|
*
|
|
* Please deprecate this and replace with something simpler if at all
|
|
* possible.
|
|
*/
|
|
|
|
/*
|
|
* Unregister event and free resources.
|
|
*
|
|
* Gets called from workqueue.
|
|
*/
|
|
static void memcg_event_remove(struct work_struct *work)
|
|
{
|
|
struct mem_cgroup_event *event =
|
|
container_of(work, struct mem_cgroup_event, remove);
|
|
struct mem_cgroup *memcg = event->memcg;
|
|
|
|
remove_wait_queue(event->wqh, &event->wait);
|
|
|
|
event->unregister_event(memcg, event->eventfd);
|
|
|
|
/* Notify userspace the event is going away. */
|
|
eventfd_signal(event->eventfd, 1);
|
|
|
|
eventfd_ctx_put(event->eventfd);
|
|
kfree(event);
|
|
css_put(&memcg->css);
|
|
}
|
|
|
|
/*
|
|
* Gets called on POLLHUP on eventfd when user closes it.
|
|
*
|
|
* Called with wqh->lock held and interrupts disabled.
|
|
*/
|
|
static int memcg_event_wake(wait_queue_t *wait, unsigned mode,
|
|
int sync, void *key)
|
|
{
|
|
struct mem_cgroup_event *event =
|
|
container_of(wait, struct mem_cgroup_event, wait);
|
|
struct mem_cgroup *memcg = event->memcg;
|
|
unsigned long flags = (unsigned long)key;
|
|
|
|
if (flags & POLLHUP) {
|
|
/*
|
|
* If the event has been detached at cgroup removal, we
|
|
* can simply return knowing the other side will cleanup
|
|
* for us.
|
|
*
|
|
* We can't race against event freeing since the other
|
|
* side will require wqh->lock via remove_wait_queue(),
|
|
* which we hold.
|
|
*/
|
|
spin_lock(&memcg->event_list_lock);
|
|
if (!list_empty(&event->list)) {
|
|
list_del_init(&event->list);
|
|
/*
|
|
* We are in atomic context, but cgroup_event_remove()
|
|
* may sleep, so we have to call it in workqueue.
|
|
*/
|
|
schedule_work(&event->remove);
|
|
}
|
|
spin_unlock(&memcg->event_list_lock);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void memcg_event_ptable_queue_proc(struct file *file,
|
|
wait_queue_head_t *wqh, poll_table *pt)
|
|
{
|
|
struct mem_cgroup_event *event =
|
|
container_of(pt, struct mem_cgroup_event, pt);
|
|
|
|
event->wqh = wqh;
|
|
add_wait_queue(wqh, &event->wait);
|
|
}
|
|
|
|
/*
|
|
* DO NOT USE IN NEW FILES.
|
|
*
|
|
* Parse input and register new cgroup event handler.
|
|
*
|
|
* Input must be in format '<event_fd> <control_fd> <args>'.
|
|
* Interpretation of args is defined by control file implementation.
|
|
*/
|
|
static ssize_t memcg_write_event_control(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off)
|
|
{
|
|
struct cgroup_subsys_state *css = of_css(of);
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
struct mem_cgroup_event *event;
|
|
struct cgroup_subsys_state *cfile_css;
|
|
unsigned int efd, cfd;
|
|
struct fd efile;
|
|
struct fd cfile;
|
|
const char *name;
|
|
char *endp;
|
|
int ret;
|
|
|
|
buf = strstrip(buf);
|
|
|
|
efd = simple_strtoul(buf, &endp, 10);
|
|
if (*endp != ' ')
|
|
return -EINVAL;
|
|
buf = endp + 1;
|
|
|
|
cfd = simple_strtoul(buf, &endp, 10);
|
|
if ((*endp != ' ') && (*endp != '\0'))
|
|
return -EINVAL;
|
|
buf = endp + 1;
|
|
|
|
event = kzalloc(sizeof(*event), GFP_KERNEL);
|
|
if (!event)
|
|
return -ENOMEM;
|
|
|
|
event->memcg = memcg;
|
|
INIT_LIST_HEAD(&event->list);
|
|
init_poll_funcptr(&event->pt, memcg_event_ptable_queue_proc);
|
|
init_waitqueue_func_entry(&event->wait, memcg_event_wake);
|
|
INIT_WORK(&event->remove, memcg_event_remove);
|
|
|
|
efile = fdget(efd);
|
|
if (!efile.file) {
|
|
ret = -EBADF;
|
|
goto out_kfree;
|
|
}
|
|
|
|
event->eventfd = eventfd_ctx_fileget(efile.file);
|
|
if (IS_ERR(event->eventfd)) {
|
|
ret = PTR_ERR(event->eventfd);
|
|
goto out_put_efile;
|
|
}
|
|
|
|
cfile = fdget(cfd);
|
|
if (!cfile.file) {
|
|
ret = -EBADF;
|
|
goto out_put_eventfd;
|
|
}
|
|
|
|
/* the process need read permission on control file */
|
|
/* AV: shouldn't we check that it's been opened for read instead? */
|
|
ret = inode_permission(file_inode(cfile.file), MAY_READ);
|
|
if (ret < 0)
|
|
goto out_put_cfile;
|
|
|
|
/*
|
|
* Determine the event callbacks and set them in @event. This used
|
|
* to be done via struct cftype but cgroup core no longer knows
|
|
* about these events. The following is crude but the whole thing
|
|
* is for compatibility anyway.
|
|
*
|
|
* DO NOT ADD NEW FILES.
|
|
*/
|
|
name = cfile.file->f_path.dentry->d_name.name;
|
|
|
|
if (!strcmp(name, "memory.usage_in_bytes")) {
|
|
event->register_event = mem_cgroup_usage_register_event;
|
|
event->unregister_event = mem_cgroup_usage_unregister_event;
|
|
} else if (!strcmp(name, "memory.oom_control")) {
|
|
event->register_event = mem_cgroup_oom_register_event;
|
|
event->unregister_event = mem_cgroup_oom_unregister_event;
|
|
} else if (!strcmp(name, "memory.pressure_level")) {
|
|
event->register_event = vmpressure_register_event;
|
|
event->unregister_event = vmpressure_unregister_event;
|
|
} else if (!strcmp(name, "memory.memsw.usage_in_bytes")) {
|
|
event->register_event = memsw_cgroup_usage_register_event;
|
|
event->unregister_event = memsw_cgroup_usage_unregister_event;
|
|
} else {
|
|
ret = -EINVAL;
|
|
goto out_put_cfile;
|
|
}
|
|
|
|
/*
|
|
* Verify @cfile should belong to @css. Also, remaining events are
|
|
* automatically removed on cgroup destruction but the removal is
|
|
* asynchronous, so take an extra ref on @css.
|
|
*/
|
|
cfile_css = css_tryget_online_from_dir(cfile.file->f_path.dentry->d_parent,
|
|
&memory_cgrp_subsys);
|
|
ret = -EINVAL;
|
|
if (IS_ERR(cfile_css))
|
|
goto out_put_cfile;
|
|
if (cfile_css != css) {
|
|
css_put(cfile_css);
|
|
goto out_put_cfile;
|
|
}
|
|
|
|
ret = event->register_event(memcg, event->eventfd, buf);
|
|
if (ret)
|
|
goto out_put_css;
|
|
|
|
efile.file->f_op->poll(efile.file, &event->pt);
|
|
|
|
spin_lock(&memcg->event_list_lock);
|
|
list_add(&event->list, &memcg->event_list);
|
|
spin_unlock(&memcg->event_list_lock);
|
|
|
|
fdput(cfile);
|
|
fdput(efile);
|
|
|
|
return nbytes;
|
|
|
|
out_put_css:
|
|
css_put(css);
|
|
out_put_cfile:
|
|
fdput(cfile);
|
|
out_put_eventfd:
|
|
eventfd_ctx_put(event->eventfd);
|
|
out_put_efile:
|
|
fdput(efile);
|
|
out_kfree:
|
|
kfree(event);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct cftype mem_cgroup_legacy_files[] = {
|
|
{
|
|
.name = "usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEM, RES_USAGE),
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "max_usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEM, RES_MAX_USAGE),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "limit_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEM, RES_LIMIT),
|
|
.write = mem_cgroup_write,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "soft_limit_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
|
|
.write = mem_cgroup_write,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "failcnt",
|
|
.private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "stat",
|
|
.seq_show = memcg_stat_show,
|
|
},
|
|
{
|
|
.name = "force_empty",
|
|
.write = mem_cgroup_force_empty_write,
|
|
},
|
|
{
|
|
.name = "use_hierarchy",
|
|
.write_u64 = mem_cgroup_hierarchy_write,
|
|
.read_u64 = mem_cgroup_hierarchy_read,
|
|
},
|
|
{
|
|
.name = "cgroup.event_control", /* XXX: for compat */
|
|
.write = memcg_write_event_control,
|
|
.flags = CFTYPE_NO_PREFIX,
|
|
.mode = S_IWUGO,
|
|
},
|
|
{
|
|
.name = "swappiness",
|
|
.read_u64 = mem_cgroup_swappiness_read,
|
|
.write_u64 = mem_cgroup_swappiness_write,
|
|
},
|
|
{
|
|
.name = "move_charge_at_immigrate",
|
|
.read_u64 = mem_cgroup_move_charge_read,
|
|
.write_u64 = mem_cgroup_move_charge_write,
|
|
},
|
|
{
|
|
.name = "oom_control",
|
|
.seq_show = mem_cgroup_oom_control_read,
|
|
.write_u64 = mem_cgroup_oom_control_write,
|
|
.private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL),
|
|
},
|
|
{
|
|
.name = "pressure_level",
|
|
},
|
|
#ifdef CONFIG_NUMA
|
|
{
|
|
.name = "numa_stat",
|
|
.seq_show = memcg_numa_stat_show,
|
|
},
|
|
#endif
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
{
|
|
.name = "kmem.limit_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_KMEM, RES_LIMIT),
|
|
.write = mem_cgroup_write,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "kmem.usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_KMEM, RES_USAGE),
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "kmem.failcnt",
|
|
.private = MEMFILE_PRIVATE(_KMEM, RES_FAILCNT),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "kmem.max_usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_KMEM, RES_MAX_USAGE),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
#ifdef CONFIG_SLABINFO
|
|
{
|
|
.name = "kmem.slabinfo",
|
|
.seq_start = slab_start,
|
|
.seq_next = slab_next,
|
|
.seq_stop = slab_stop,
|
|
.seq_show = memcg_slab_show,
|
|
},
|
|
#endif
|
|
#endif
|
|
{ }, /* terminate */
|
|
};
|
|
|
|
static int alloc_mem_cgroup_per_zone_info(struct mem_cgroup *memcg, int node)
|
|
{
|
|
struct mem_cgroup_per_node *pn;
|
|
struct mem_cgroup_per_zone *mz;
|
|
int zone, tmp = node;
|
|
/*
|
|
* This routine is called against possible nodes.
|
|
* But it's BUG to call kmalloc() against offline node.
|
|
*
|
|
* TODO: this routine can waste much memory for nodes which will
|
|
* never be onlined. It's better to use memory hotplug callback
|
|
* function.
|
|
*/
|
|
if (!node_state(node, N_NORMAL_MEMORY))
|
|
tmp = -1;
|
|
pn = kzalloc_node(sizeof(*pn), GFP_KERNEL, tmp);
|
|
if (!pn)
|
|
return 1;
|
|
|
|
for (zone = 0; zone < MAX_NR_ZONES; zone++) {
|
|
mz = &pn->zoneinfo[zone];
|
|
lruvec_init(&mz->lruvec);
|
|
mz->usage_in_excess = 0;
|
|
mz->on_tree = false;
|
|
mz->memcg = memcg;
|
|
}
|
|
memcg->nodeinfo[node] = pn;
|
|
return 0;
|
|
}
|
|
|
|
static void free_mem_cgroup_per_zone_info(struct mem_cgroup *memcg, int node)
|
|
{
|
|
kfree(memcg->nodeinfo[node]);
|
|
}
|
|
|
|
static struct mem_cgroup *mem_cgroup_alloc(void)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
size_t size;
|
|
|
|
size = sizeof(struct mem_cgroup);
|
|
size += nr_node_ids * sizeof(struct mem_cgroup_per_node *);
|
|
|
|
memcg = kzalloc(size, GFP_KERNEL);
|
|
if (!memcg)
|
|
return NULL;
|
|
|
|
memcg->stat = alloc_percpu(struct mem_cgroup_stat_cpu);
|
|
if (!memcg->stat)
|
|
goto out_free;
|
|
spin_lock_init(&memcg->pcp_counter_lock);
|
|
return memcg;
|
|
|
|
out_free:
|
|
kfree(memcg);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* At destroying mem_cgroup, references from swap_cgroup can remain.
|
|
* (scanning all at force_empty is too costly...)
|
|
*
|
|
* Instead of clearing all references at force_empty, we remember
|
|
* the number of reference from swap_cgroup and free mem_cgroup when
|
|
* it goes down to 0.
|
|
*
|
|
* Removal of cgroup itself succeeds regardless of refs from swap.
|
|
*/
|
|
|
|
static void __mem_cgroup_free(struct mem_cgroup *memcg)
|
|
{
|
|
int node;
|
|
|
|
mem_cgroup_remove_from_trees(memcg);
|
|
|
|
for_each_node(node)
|
|
free_mem_cgroup_per_zone_info(memcg, node);
|
|
|
|
free_percpu(memcg->stat);
|
|
kfree(memcg);
|
|
}
|
|
|
|
/*
|
|
* Returns the parent mem_cgroup in memcgroup hierarchy with hierarchy enabled.
|
|
*/
|
|
struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
|
|
{
|
|
if (!memcg->memory.parent)
|
|
return NULL;
|
|
return mem_cgroup_from_counter(memcg->memory.parent, memory);
|
|
}
|
|
EXPORT_SYMBOL(parent_mem_cgroup);
|
|
|
|
static struct cgroup_subsys_state * __ref
|
|
mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
long error = -ENOMEM;
|
|
int node;
|
|
|
|
memcg = mem_cgroup_alloc();
|
|
if (!memcg)
|
|
return ERR_PTR(error);
|
|
|
|
for_each_node(node)
|
|
if (alloc_mem_cgroup_per_zone_info(memcg, node))
|
|
goto free_out;
|
|
|
|
/* root ? */
|
|
if (parent_css == NULL) {
|
|
root_mem_cgroup = memcg;
|
|
page_counter_init(&memcg->memory, NULL);
|
|
memcg->high = PAGE_COUNTER_MAX;
|
|
memcg->soft_limit = PAGE_COUNTER_MAX;
|
|
page_counter_init(&memcg->memsw, NULL);
|
|
page_counter_init(&memcg->kmem, NULL);
|
|
}
|
|
|
|
memcg->last_scanned_node = MAX_NUMNODES;
|
|
INIT_LIST_HEAD(&memcg->oom_notify);
|
|
memcg->move_charge_at_immigrate = 0;
|
|
mutex_init(&memcg->thresholds_lock);
|
|
spin_lock_init(&memcg->move_lock);
|
|
vmpressure_init(&memcg->vmpressure);
|
|
INIT_LIST_HEAD(&memcg->event_list);
|
|
spin_lock_init(&memcg->event_list_lock);
|
|
#ifdef CONFIG_MEMCG_KMEM
|
|
memcg->kmemcg_id = -1;
|
|
#endif
|
|
|
|
return &memcg->css;
|
|
|
|
free_out:
|
|
__mem_cgroup_free(memcg);
|
|
return ERR_PTR(error);
|
|
}
|
|
|
|
static int
|
|
mem_cgroup_css_online(struct cgroup_subsys_state *css)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
struct mem_cgroup *parent = mem_cgroup_from_css(css->parent);
|
|
int ret;
|
|
|
|
if (css->id > MEM_CGROUP_ID_MAX)
|
|
return -ENOSPC;
|
|
|
|
if (!parent)
|
|
return 0;
|
|
|
|
mutex_lock(&memcg_create_mutex);
|
|
|
|
memcg->use_hierarchy = parent->use_hierarchy;
|
|
memcg->oom_kill_disable = parent->oom_kill_disable;
|
|
memcg->swappiness = mem_cgroup_swappiness(parent);
|
|
|
|
if (parent->use_hierarchy) {
|
|
page_counter_init(&memcg->memory, &parent->memory);
|
|
memcg->high = PAGE_COUNTER_MAX;
|
|
memcg->soft_limit = PAGE_COUNTER_MAX;
|
|
page_counter_init(&memcg->memsw, &parent->memsw);
|
|
page_counter_init(&memcg->kmem, &parent->kmem);
|
|
|
|
/*
|
|
* No need to take a reference to the parent because cgroup
|
|
* core guarantees its existence.
|
|
*/
|
|
} else {
|
|
page_counter_init(&memcg->memory, NULL);
|
|
memcg->high = PAGE_COUNTER_MAX;
|
|
memcg->soft_limit = PAGE_COUNTER_MAX;
|
|
page_counter_init(&memcg->memsw, NULL);
|
|
page_counter_init(&memcg->kmem, NULL);
|
|
/*
|
|
* Deeper hierachy with use_hierarchy == false doesn't make
|
|
* much sense so let cgroup subsystem know about this
|
|
* unfortunate state in our controller.
|
|
*/
|
|
if (parent != root_mem_cgroup)
|
|
memory_cgrp_subsys.broken_hierarchy = true;
|
|
}
|
|
mutex_unlock(&memcg_create_mutex);
|
|
|
|
ret = memcg_init_kmem(memcg, &memory_cgrp_subsys);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* Make sure the memcg is initialized: mem_cgroup_iter()
|
|
* orders reading memcg->initialized against its callers
|
|
* reading the memcg members.
|
|
*/
|
|
smp_store_release(&memcg->initialized, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
struct mem_cgroup_event *event, *tmp;
|
|
|
|
/*
|
|
* Unregister events and notify userspace.
|
|
* Notify userspace about cgroup removing only after rmdir of cgroup
|
|
* directory to avoid race between userspace and kernelspace.
|
|
*/
|
|
spin_lock(&memcg->event_list_lock);
|
|
list_for_each_entry_safe(event, tmp, &memcg->event_list, list) {
|
|
list_del_init(&event->list);
|
|
schedule_work(&event->remove);
|
|
}
|
|
spin_unlock(&memcg->event_list_lock);
|
|
|
|
vmpressure_cleanup(&memcg->vmpressure);
|
|
|
|
memcg_deactivate_kmem(memcg);
|
|
}
|
|
|
|
static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
memcg_destroy_kmem(memcg);
|
|
__mem_cgroup_free(memcg);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_css_reset - reset the states of a mem_cgroup
|
|
* @css: the target css
|
|
*
|
|
* Reset the states of the mem_cgroup associated with @css. This is
|
|
* invoked when the userland requests disabling on the default hierarchy
|
|
* but the memcg is pinned through dependency. The memcg should stop
|
|
* applying policies and should revert to the vanilla state as it may be
|
|
* made visible again.
|
|
*
|
|
* The current implementation only resets the essential configurations.
|
|
* This needs to be expanded to cover all the visible parts.
|
|
*/
|
|
static void mem_cgroup_css_reset(struct cgroup_subsys_state *css)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
|
|
mem_cgroup_resize_limit(memcg, PAGE_COUNTER_MAX);
|
|
mem_cgroup_resize_memsw_limit(memcg, PAGE_COUNTER_MAX);
|
|
memcg_update_kmem_limit(memcg, PAGE_COUNTER_MAX);
|
|
memcg->low = 0;
|
|
memcg->high = PAGE_COUNTER_MAX;
|
|
memcg->soft_limit = PAGE_COUNTER_MAX;
|
|
}
|
|
|
|
#ifdef CONFIG_MMU
|
|
/* Handlers for move charge at task migration. */
|
|
static int mem_cgroup_do_precharge(unsigned long count)
|
|
{
|
|
int ret;
|
|
|
|
/* Try a single bulk charge without reclaim first */
|
|
ret = try_charge(mc.to, GFP_KERNEL & ~__GFP_WAIT, count);
|
|
if (!ret) {
|
|
mc.precharge += count;
|
|
return ret;
|
|
}
|
|
if (ret == -EINTR) {
|
|
cancel_charge(root_mem_cgroup, count);
|
|
return ret;
|
|
}
|
|
|
|
/* Try charges one by one with reclaim */
|
|
while (count--) {
|
|
ret = try_charge(mc.to, GFP_KERNEL & ~__GFP_NORETRY, 1);
|
|
/*
|
|
* In case of failure, any residual charges against
|
|
* mc.to will be dropped by mem_cgroup_clear_mc()
|
|
* later on. However, cancel any charges that are
|
|
* bypassed to root right away or they'll be lost.
|
|
*/
|
|
if (ret == -EINTR)
|
|
cancel_charge(root_mem_cgroup, 1);
|
|
if (ret)
|
|
return ret;
|
|
mc.precharge++;
|
|
cond_resched();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* get_mctgt_type - get target type of moving charge
|
|
* @vma: the vma the pte to be checked belongs
|
|
* @addr: the address corresponding to the pte to be checked
|
|
* @ptent: the pte to be checked
|
|
* @target: the pointer the target page or swap ent will be stored(can be NULL)
|
|
*
|
|
* Returns
|
|
* 0(MC_TARGET_NONE): if the pte is not a target for move charge.
|
|
* 1(MC_TARGET_PAGE): if the page corresponding to this pte is a target for
|
|
* move charge. if @target is not NULL, the page is stored in target->page
|
|
* with extra refcnt got(Callers should handle it).
|
|
* 2(MC_TARGET_SWAP): if the swap entry corresponding to this pte is a
|
|
* target for charge migration. if @target is not NULL, the entry is stored
|
|
* in target->ent.
|
|
*
|
|
* Called with pte lock held.
|
|
*/
|
|
union mc_target {
|
|
struct page *page;
|
|
swp_entry_t ent;
|
|
};
|
|
|
|
enum mc_target_type {
|
|
MC_TARGET_NONE = 0,
|
|
MC_TARGET_PAGE,
|
|
MC_TARGET_SWAP,
|
|
};
|
|
|
|
static struct page *mc_handle_present_pte(struct vm_area_struct *vma,
|
|
unsigned long addr, pte_t ptent)
|
|
{
|
|
struct page *page = vm_normal_page(vma, addr, ptent);
|
|
|
|
if (!page || !page_mapped(page))
|
|
return NULL;
|
|
if (PageAnon(page)) {
|
|
if (!(mc.flags & MOVE_ANON))
|
|
return NULL;
|
|
} else {
|
|
if (!(mc.flags & MOVE_FILE))
|
|
return NULL;
|
|
}
|
|
if (!get_page_unless_zero(page))
|
|
return NULL;
|
|
|
|
return page;
|
|
}
|
|
|
|
#ifdef CONFIG_SWAP
|
|
static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
|
|
unsigned long addr, pte_t ptent, swp_entry_t *entry)
|
|
{
|
|
struct page *page = NULL;
|
|
swp_entry_t ent = pte_to_swp_entry(ptent);
|
|
|
|
if (!(mc.flags & MOVE_ANON) || non_swap_entry(ent))
|
|
return NULL;
|
|
/*
|
|
* Because lookup_swap_cache() updates some statistics counter,
|
|
* we call find_get_page() with swapper_space directly.
|
|
*/
|
|
page = find_get_page(swap_address_space(ent), ent.val);
|
|
if (do_swap_account)
|
|
entry->val = ent.val;
|
|
|
|
return page;
|
|
}
|
|
#else
|
|
static struct page *mc_handle_swap_pte(struct vm_area_struct *vma,
|
|
unsigned long addr, pte_t ptent, swp_entry_t *entry)
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static struct page *mc_handle_file_pte(struct vm_area_struct *vma,
|
|
unsigned long addr, pte_t ptent, swp_entry_t *entry)
|
|
{
|
|
struct page *page = NULL;
|
|
struct address_space *mapping;
|
|
pgoff_t pgoff;
|
|
|
|
if (!vma->vm_file) /* anonymous vma */
|
|
return NULL;
|
|
if (!(mc.flags & MOVE_FILE))
|
|
return NULL;
|
|
|
|
mapping = vma->vm_file->f_mapping;
|
|
pgoff = linear_page_index(vma, addr);
|
|
|
|
/* page is moved even if it's not RSS of this task(page-faulted). */
|
|
#ifdef CONFIG_SWAP
|
|
/* shmem/tmpfs may report page out on swap: account for that too. */
|
|
if (shmem_mapping(mapping)) {
|
|
page = find_get_entry(mapping, pgoff);
|
|
if (radix_tree_exceptional_entry(page)) {
|
|
swp_entry_t swp = radix_to_swp_entry(page);
|
|
if (do_swap_account)
|
|
*entry = swp;
|
|
page = find_get_page(swap_address_space(swp), swp.val);
|
|
}
|
|
} else
|
|
page = find_get_page(mapping, pgoff);
|
|
#else
|
|
page = find_get_page(mapping, pgoff);
|
|
#endif
|
|
return page;
|
|
}
|
|
|
|
static enum mc_target_type get_mctgt_type(struct vm_area_struct *vma,
|
|
unsigned long addr, pte_t ptent, union mc_target *target)
|
|
{
|
|
struct page *page = NULL;
|
|
enum mc_target_type ret = MC_TARGET_NONE;
|
|
swp_entry_t ent = { .val = 0 };
|
|
|
|
if (pte_present(ptent))
|
|
page = mc_handle_present_pte(vma, addr, ptent);
|
|
else if (is_swap_pte(ptent))
|
|
page = mc_handle_swap_pte(vma, addr, ptent, &ent);
|
|
else if (pte_none(ptent))
|
|
page = mc_handle_file_pte(vma, addr, ptent, &ent);
|
|
|
|
if (!page && !ent.val)
|
|
return ret;
|
|
if (page) {
|
|
/*
|
|
* Do only loose check w/o serialization.
|
|
* mem_cgroup_move_account() checks the page is valid or
|
|
* not under LRU exclusion.
|
|
*/
|
|
if (page->mem_cgroup == mc.from) {
|
|
ret = MC_TARGET_PAGE;
|
|
if (target)
|
|
target->page = page;
|
|
}
|
|
if (!ret || !target)
|
|
put_page(page);
|
|
}
|
|
/* There is a swap entry and a page doesn't exist or isn't charged */
|
|
if (ent.val && !ret &&
|
|
mem_cgroup_id(mc.from) == lookup_swap_cgroup_id(ent)) {
|
|
ret = MC_TARGET_SWAP;
|
|
if (target)
|
|
target->ent = ent;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
/*
|
|
* We don't consider swapping or file mapped pages because THP does not
|
|
* support them for now.
|
|
* Caller should make sure that pmd_trans_huge(pmd) is true.
|
|
*/
|
|
static enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
|
|
unsigned long addr, pmd_t pmd, union mc_target *target)
|
|
{
|
|
struct page *page = NULL;
|
|
enum mc_target_type ret = MC_TARGET_NONE;
|
|
|
|
page = pmd_page(pmd);
|
|
VM_BUG_ON_PAGE(!page || !PageHead(page), page);
|
|
if (!(mc.flags & MOVE_ANON))
|
|
return ret;
|
|
if (page->mem_cgroup == mc.from) {
|
|
ret = MC_TARGET_PAGE;
|
|
if (target) {
|
|
get_page(page);
|
|
target->page = page;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
#else
|
|
static inline enum mc_target_type get_mctgt_type_thp(struct vm_area_struct *vma,
|
|
unsigned long addr, pmd_t pmd, union mc_target *target)
|
|
{
|
|
return MC_TARGET_NONE;
|
|
}
|
|
#endif
|
|
|
|
static int mem_cgroup_count_precharge_pte_range(pmd_t *pmd,
|
|
unsigned long addr, unsigned long end,
|
|
struct mm_walk *walk)
|
|
{
|
|
struct vm_area_struct *vma = walk->vma;
|
|
pte_t *pte;
|
|
spinlock_t *ptl;
|
|
|
|
if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
|
|
if (get_mctgt_type_thp(vma, addr, *pmd, NULL) == MC_TARGET_PAGE)
|
|
mc.precharge += HPAGE_PMD_NR;
|
|
spin_unlock(ptl);
|
|
return 0;
|
|
}
|
|
|
|
if (pmd_trans_unstable(pmd))
|
|
return 0;
|
|
pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
|
|
for (; addr != end; pte++, addr += PAGE_SIZE)
|
|
if (get_mctgt_type(vma, addr, *pte, NULL))
|
|
mc.precharge++; /* increment precharge temporarily */
|
|
pte_unmap_unlock(pte - 1, ptl);
|
|
cond_resched();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned long mem_cgroup_count_precharge(struct mm_struct *mm)
|
|
{
|
|
unsigned long precharge;
|
|
|
|
struct mm_walk mem_cgroup_count_precharge_walk = {
|
|
.pmd_entry = mem_cgroup_count_precharge_pte_range,
|
|
.mm = mm,
|
|
};
|
|
down_read(&mm->mmap_sem);
|
|
walk_page_range(0, ~0UL, &mem_cgroup_count_precharge_walk);
|
|
up_read(&mm->mmap_sem);
|
|
|
|
precharge = mc.precharge;
|
|
mc.precharge = 0;
|
|
|
|
return precharge;
|
|
}
|
|
|
|
static int mem_cgroup_precharge_mc(struct mm_struct *mm)
|
|
{
|
|
unsigned long precharge = mem_cgroup_count_precharge(mm);
|
|
|
|
VM_BUG_ON(mc.moving_task);
|
|
mc.moving_task = current;
|
|
return mem_cgroup_do_precharge(precharge);
|
|
}
|
|
|
|
/* cancels all extra charges on mc.from and mc.to, and wakes up all waiters. */
|
|
static void __mem_cgroup_clear_mc(void)
|
|
{
|
|
struct mem_cgroup *from = mc.from;
|
|
struct mem_cgroup *to = mc.to;
|
|
|
|
/* we must uncharge all the leftover precharges from mc.to */
|
|
if (mc.precharge) {
|
|
cancel_charge(mc.to, mc.precharge);
|
|
mc.precharge = 0;
|
|
}
|
|
/*
|
|
* we didn't uncharge from mc.from at mem_cgroup_move_account(), so
|
|
* we must uncharge here.
|
|
*/
|
|
if (mc.moved_charge) {
|
|
cancel_charge(mc.from, mc.moved_charge);
|
|
mc.moved_charge = 0;
|
|
}
|
|
/* we must fixup refcnts and charges */
|
|
if (mc.moved_swap) {
|
|
/* uncharge swap account from the old cgroup */
|
|
if (!mem_cgroup_is_root(mc.from))
|
|
page_counter_uncharge(&mc.from->memsw, mc.moved_swap);
|
|
|
|
/*
|
|
* we charged both to->memory and to->memsw, so we
|
|
* should uncharge to->memory.
|
|
*/
|
|
if (!mem_cgroup_is_root(mc.to))
|
|
page_counter_uncharge(&mc.to->memory, mc.moved_swap);
|
|
|
|
css_put_many(&mc.from->css, mc.moved_swap);
|
|
|
|
/* we've already done css_get(mc.to) */
|
|
mc.moved_swap = 0;
|
|
}
|
|
memcg_oom_recover(from);
|
|
memcg_oom_recover(to);
|
|
wake_up_all(&mc.waitq);
|
|
}
|
|
|
|
static void mem_cgroup_clear_mc(void)
|
|
{
|
|
/*
|
|
* we must clear moving_task before waking up waiters at the end of
|
|
* task migration.
|
|
*/
|
|
mc.moving_task = NULL;
|
|
__mem_cgroup_clear_mc();
|
|
spin_lock(&mc.lock);
|
|
mc.from = NULL;
|
|
mc.to = NULL;
|
|
spin_unlock(&mc.lock);
|
|
}
|
|
|
|
static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
struct task_struct *p = cgroup_taskset_first(tset);
|
|
int ret = 0;
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
|
|
unsigned long move_flags;
|
|
|
|
/*
|
|
* We are now commited to this value whatever it is. Changes in this
|
|
* tunable will only affect upcoming migrations, not the current one.
|
|
* So we need to save it, and keep it going.
|
|
*/
|
|
move_flags = ACCESS_ONCE(memcg->move_charge_at_immigrate);
|
|
if (move_flags) {
|
|
struct mm_struct *mm;
|
|
struct mem_cgroup *from = mem_cgroup_from_task(p);
|
|
|
|
VM_BUG_ON(from == memcg);
|
|
|
|
mm = get_task_mm(p);
|
|
if (!mm)
|
|
return 0;
|
|
/* We move charges only when we move a owner of the mm */
|
|
if (mm->owner == p) {
|
|
VM_BUG_ON(mc.from);
|
|
VM_BUG_ON(mc.to);
|
|
VM_BUG_ON(mc.precharge);
|
|
VM_BUG_ON(mc.moved_charge);
|
|
VM_BUG_ON(mc.moved_swap);
|
|
|
|
spin_lock(&mc.lock);
|
|
mc.from = from;
|
|
mc.to = memcg;
|
|
mc.flags = move_flags;
|
|
spin_unlock(&mc.lock);
|
|
/* We set mc.moving_task later */
|
|
|
|
ret = mem_cgroup_precharge_mc(mm);
|
|
if (ret)
|
|
mem_cgroup_clear_mc();
|
|
}
|
|
mmput(mm);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
if (mc.to)
|
|
mem_cgroup_clear_mc();
|
|
}
|
|
|
|
static int mem_cgroup_move_charge_pte_range(pmd_t *pmd,
|
|
unsigned long addr, unsigned long end,
|
|
struct mm_walk *walk)
|
|
{
|
|
int ret = 0;
|
|
struct vm_area_struct *vma = walk->vma;
|
|
pte_t *pte;
|
|
spinlock_t *ptl;
|
|
enum mc_target_type target_type;
|
|
union mc_target target;
|
|
struct page *page;
|
|
|
|
/*
|
|
* We don't take compound_lock() here but no race with splitting thp
|
|
* happens because:
|
|
* - if pmd_trans_huge_lock() returns 1, the relevant thp is not
|
|
* under splitting, which means there's no concurrent thp split,
|
|
* - if another thread runs into split_huge_page() just after we
|
|
* entered this if-block, the thread must wait for page table lock
|
|
* to be unlocked in __split_huge_page_splitting(), where the main
|
|
* part of thp split is not executed yet.
|
|
*/
|
|
if (pmd_trans_huge_lock(pmd, vma, &ptl) == 1) {
|
|
if (mc.precharge < HPAGE_PMD_NR) {
|
|
spin_unlock(ptl);
|
|
return 0;
|
|
}
|
|
target_type = get_mctgt_type_thp(vma, addr, *pmd, &target);
|
|
if (target_type == MC_TARGET_PAGE) {
|
|
page = target.page;
|
|
if (!isolate_lru_page(page)) {
|
|
if (!mem_cgroup_move_account(page, HPAGE_PMD_NR,
|
|
mc.from, mc.to)) {
|
|
mc.precharge -= HPAGE_PMD_NR;
|
|
mc.moved_charge += HPAGE_PMD_NR;
|
|
}
|
|
putback_lru_page(page);
|
|
}
|
|
put_page(page);
|
|
}
|
|
spin_unlock(ptl);
|
|
return 0;
|
|
}
|
|
|
|
if (pmd_trans_unstable(pmd))
|
|
return 0;
|
|
retry:
|
|
pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
|
|
for (; addr != end; addr += PAGE_SIZE) {
|
|
pte_t ptent = *(pte++);
|
|
swp_entry_t ent;
|
|
|
|
if (!mc.precharge)
|
|
break;
|
|
|
|
switch (get_mctgt_type(vma, addr, ptent, &target)) {
|
|
case MC_TARGET_PAGE:
|
|
page = target.page;
|
|
if (isolate_lru_page(page))
|
|
goto put;
|
|
if (!mem_cgroup_move_account(page, 1, mc.from, mc.to)) {
|
|
mc.precharge--;
|
|
/* we uncharge from mc.from later. */
|
|
mc.moved_charge++;
|
|
}
|
|
putback_lru_page(page);
|
|
put: /* get_mctgt_type() gets the page */
|
|
put_page(page);
|
|
break;
|
|
case MC_TARGET_SWAP:
|
|
ent = target.ent;
|
|
if (!mem_cgroup_move_swap_account(ent, mc.from, mc.to)) {
|
|
mc.precharge--;
|
|
/* we fixup refcnts and charges later. */
|
|
mc.moved_swap++;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pte_unmap_unlock(pte - 1, ptl);
|
|
cond_resched();
|
|
|
|
if (addr != end) {
|
|
/*
|
|
* We have consumed all precharges we got in can_attach().
|
|
* We try charge one by one, but don't do any additional
|
|
* charges to mc.to if we have failed in charge once in attach()
|
|
* phase.
|
|
*/
|
|
ret = mem_cgroup_do_precharge(1);
|
|
if (!ret)
|
|
goto retry;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void mem_cgroup_move_charge(struct mm_struct *mm)
|
|
{
|
|
struct mm_walk mem_cgroup_move_charge_walk = {
|
|
.pmd_entry = mem_cgroup_move_charge_pte_range,
|
|
.mm = mm,
|
|
};
|
|
|
|
lru_add_drain_all();
|
|
/*
|
|
* Signal mem_cgroup_begin_page_stat() to take the memcg's
|
|
* move_lock while we're moving its pages to another memcg.
|
|
* Then wait for already started RCU-only updates to finish.
|
|
*/
|
|
atomic_inc(&mc.from->moving_account);
|
|
synchronize_rcu();
|
|
retry:
|
|
if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
|
|
/*
|
|
* Someone who are holding the mmap_sem might be waiting in
|
|
* waitq. So we cancel all extra charges, wake up all waiters,
|
|
* and retry. Because we cancel precharges, we might not be able
|
|
* to move enough charges, but moving charge is a best-effort
|
|
* feature anyway, so it wouldn't be a big problem.
|
|
*/
|
|
__mem_cgroup_clear_mc();
|
|
cond_resched();
|
|
goto retry;
|
|
}
|
|
/*
|
|
* When we have consumed all precharges and failed in doing
|
|
* additional charge, the page walk just aborts.
|
|
*/
|
|
walk_page_range(0, ~0UL, &mem_cgroup_move_charge_walk);
|
|
up_read(&mm->mmap_sem);
|
|
atomic_dec(&mc.from->moving_account);
|
|
}
|
|
|
|
static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
struct task_struct *p = cgroup_taskset_first(tset);
|
|
struct mm_struct *mm = get_task_mm(p);
|
|
|
|
if (mm) {
|
|
if (mc.to)
|
|
mem_cgroup_move_charge(mm);
|
|
mmput(mm);
|
|
}
|
|
if (mc.to)
|
|
mem_cgroup_clear_mc();
|
|
}
|
|
#else /* !CONFIG_MMU */
|
|
static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
return 0;
|
|
}
|
|
static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
}
|
|
static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Cgroup retains root cgroups across [un]mount cycles making it necessary
|
|
* to verify whether we're attached to the default hierarchy on each mount
|
|
* attempt.
|
|
*/
|
|
static void mem_cgroup_bind(struct cgroup_subsys_state *root_css)
|
|
{
|
|
/*
|
|
* use_hierarchy is forced on the default hierarchy. cgroup core
|
|
* guarantees that @root doesn't have any children, so turning it
|
|
* on for the root memcg is enough.
|
|
*/
|
|
if (cgroup_on_dfl(root_css->cgroup))
|
|
mem_cgroup_from_css(root_css)->use_hierarchy = true;
|
|
}
|
|
|
|
static u64 memory_current_read(struct cgroup_subsys_state *css,
|
|
struct cftype *cft)
|
|
{
|
|
return mem_cgroup_usage(mem_cgroup_from_css(css), false);
|
|
}
|
|
|
|
static int memory_low_show(struct seq_file *m, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
unsigned long low = ACCESS_ONCE(memcg->low);
|
|
|
|
if (low == PAGE_COUNTER_MAX)
|
|
seq_puts(m, "max\n");
|
|
else
|
|
seq_printf(m, "%llu\n", (u64)low * PAGE_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t memory_low_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
unsigned long low;
|
|
int err;
|
|
|
|
buf = strstrip(buf);
|
|
err = page_counter_memparse(buf, "max", &low);
|
|
if (err)
|
|
return err;
|
|
|
|
memcg->low = low;
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
static int memory_high_show(struct seq_file *m, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
unsigned long high = ACCESS_ONCE(memcg->high);
|
|
|
|
if (high == PAGE_COUNTER_MAX)
|
|
seq_puts(m, "max\n");
|
|
else
|
|
seq_printf(m, "%llu\n", (u64)high * PAGE_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t memory_high_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
unsigned long high;
|
|
int err;
|
|
|
|
buf = strstrip(buf);
|
|
err = page_counter_memparse(buf, "max", &high);
|
|
if (err)
|
|
return err;
|
|
|
|
memcg->high = high;
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
static int memory_max_show(struct seq_file *m, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
unsigned long max = ACCESS_ONCE(memcg->memory.limit);
|
|
|
|
if (max == PAGE_COUNTER_MAX)
|
|
seq_puts(m, "max\n");
|
|
else
|
|
seq_printf(m, "%llu\n", (u64)max * PAGE_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t memory_max_write(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
|
|
unsigned long max;
|
|
int err;
|
|
|
|
buf = strstrip(buf);
|
|
err = page_counter_memparse(buf, "max", &max);
|
|
if (err)
|
|
return err;
|
|
|
|
err = mem_cgroup_resize_limit(memcg, max);
|
|
if (err)
|
|
return err;
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
static int memory_events_show(struct seq_file *m, void *v)
|
|
{
|
|
struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
|
|
|
|
seq_printf(m, "low %lu\n", mem_cgroup_read_events(memcg, MEMCG_LOW));
|
|
seq_printf(m, "high %lu\n", mem_cgroup_read_events(memcg, MEMCG_HIGH));
|
|
seq_printf(m, "max %lu\n", mem_cgroup_read_events(memcg, MEMCG_MAX));
|
|
seq_printf(m, "oom %lu\n", mem_cgroup_read_events(memcg, MEMCG_OOM));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct cftype memory_files[] = {
|
|
{
|
|
.name = "current",
|
|
.read_u64 = memory_current_read,
|
|
},
|
|
{
|
|
.name = "low",
|
|
.flags = CFTYPE_NOT_ON_ROOT,
|
|
.seq_show = memory_low_show,
|
|
.write = memory_low_write,
|
|
},
|
|
{
|
|
.name = "high",
|
|
.flags = CFTYPE_NOT_ON_ROOT,
|
|
.seq_show = memory_high_show,
|
|
.write = memory_high_write,
|
|
},
|
|
{
|
|
.name = "max",
|
|
.flags = CFTYPE_NOT_ON_ROOT,
|
|
.seq_show = memory_max_show,
|
|
.write = memory_max_write,
|
|
},
|
|
{
|
|
.name = "events",
|
|
.flags = CFTYPE_NOT_ON_ROOT,
|
|
.seq_show = memory_events_show,
|
|
},
|
|
{ } /* terminate */
|
|
};
|
|
|
|
struct cgroup_subsys memory_cgrp_subsys = {
|
|
.css_alloc = mem_cgroup_css_alloc,
|
|
.css_online = mem_cgroup_css_online,
|
|
.css_offline = mem_cgroup_css_offline,
|
|
.css_free = mem_cgroup_css_free,
|
|
.css_reset = mem_cgroup_css_reset,
|
|
.can_attach = mem_cgroup_can_attach,
|
|
.cancel_attach = mem_cgroup_cancel_attach,
|
|
.attach = mem_cgroup_move_task,
|
|
.bind = mem_cgroup_bind,
|
|
.dfl_cftypes = memory_files,
|
|
.legacy_cftypes = mem_cgroup_legacy_files,
|
|
.early_init = 0,
|
|
};
|
|
|
|
/**
|
|
* mem_cgroup_events - count memory events against a cgroup
|
|
* @memcg: the memory cgroup
|
|
* @idx: the event index
|
|
* @nr: the number of events to account for
|
|
*/
|
|
void mem_cgroup_events(struct mem_cgroup *memcg,
|
|
enum mem_cgroup_events_index idx,
|
|
unsigned int nr)
|
|
{
|
|
this_cpu_add(memcg->stat->events[idx], nr);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_low - check if memory consumption is below the normal range
|
|
* @root: the highest ancestor to consider
|
|
* @memcg: the memory cgroup to check
|
|
*
|
|
* Returns %true if memory consumption of @memcg, and that of all
|
|
* configurable ancestors up to @root, is below the normal range.
|
|
*/
|
|
bool mem_cgroup_low(struct mem_cgroup *root, struct mem_cgroup *memcg)
|
|
{
|
|
if (mem_cgroup_disabled())
|
|
return false;
|
|
|
|
/*
|
|
* The toplevel group doesn't have a configurable range, so
|
|
* it's never low when looked at directly, and it is not
|
|
* considered an ancestor when assessing the hierarchy.
|
|
*/
|
|
|
|
if (memcg == root_mem_cgroup)
|
|
return false;
|
|
|
|
if (page_counter_read(&memcg->memory) >= memcg->low)
|
|
return false;
|
|
|
|
while (memcg != root) {
|
|
memcg = parent_mem_cgroup(memcg);
|
|
|
|
if (memcg == root_mem_cgroup)
|
|
break;
|
|
|
|
if (page_counter_read(&memcg->memory) >= memcg->low)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_try_charge - try charging a page
|
|
* @page: page to charge
|
|
* @mm: mm context of the victim
|
|
* @gfp_mask: reclaim mode
|
|
* @memcgp: charged memcg return
|
|
*
|
|
* Try to charge @page to the memcg that @mm belongs to, reclaiming
|
|
* pages according to @gfp_mask if necessary.
|
|
*
|
|
* Returns 0 on success, with *@memcgp pointing to the charged memcg.
|
|
* Otherwise, an error code is returned.
|
|
*
|
|
* After page->mapping has been set up, the caller must finalize the
|
|
* charge with mem_cgroup_commit_charge(). Or abort the transaction
|
|
* with mem_cgroup_cancel_charge() in case page instantiation fails.
|
|
*/
|
|
int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
|
|
gfp_t gfp_mask, struct mem_cgroup **memcgp)
|
|
{
|
|
struct mem_cgroup *memcg = NULL;
|
|
unsigned int nr_pages = 1;
|
|
int ret = 0;
|
|
|
|
if (mem_cgroup_disabled())
|
|
goto out;
|
|
|
|
if (PageSwapCache(page)) {
|
|
/*
|
|
* Every swap fault against a single page tries to charge the
|
|
* page, bail as early as possible. shmem_unuse() encounters
|
|
* already charged pages, too. The USED bit is protected by
|
|
* the page lock, which serializes swap cache removal, which
|
|
* in turn serializes uncharging.
|
|
*/
|
|
if (page->mem_cgroup)
|
|
goto out;
|
|
}
|
|
|
|
if (PageTransHuge(page)) {
|
|
nr_pages <<= compound_order(page);
|
|
VM_BUG_ON_PAGE(!PageTransHuge(page), page);
|
|
}
|
|
|
|
if (do_swap_account && PageSwapCache(page))
|
|
memcg = try_get_mem_cgroup_from_page(page);
|
|
if (!memcg)
|
|
memcg = get_mem_cgroup_from_mm(mm);
|
|
|
|
ret = try_charge(memcg, gfp_mask, nr_pages);
|
|
|
|
css_put(&memcg->css);
|
|
|
|
if (ret == -EINTR) {
|
|
memcg = root_mem_cgroup;
|
|
ret = 0;
|
|
}
|
|
out:
|
|
*memcgp = memcg;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_commit_charge - commit a page charge
|
|
* @page: page to charge
|
|
* @memcg: memcg to charge the page to
|
|
* @lrucare: page might be on LRU already
|
|
*
|
|
* Finalize a charge transaction started by mem_cgroup_try_charge(),
|
|
* after page->mapping has been set up. This must happen atomically
|
|
* as part of the page instantiation, i.e. under the page table lock
|
|
* for anonymous pages, under the page lock for page and swap cache.
|
|
*
|
|
* In addition, the page must not be on the LRU during the commit, to
|
|
* prevent racing with task migration. If it might be, use @lrucare.
|
|
*
|
|
* Use mem_cgroup_cancel_charge() to cancel the transaction instead.
|
|
*/
|
|
void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
|
|
bool lrucare)
|
|
{
|
|
unsigned int nr_pages = 1;
|
|
|
|
VM_BUG_ON_PAGE(!page->mapping, page);
|
|
VM_BUG_ON_PAGE(PageLRU(page) && !lrucare, page);
|
|
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
/*
|
|
* Swap faults will attempt to charge the same page multiple
|
|
* times. But reuse_swap_page() might have removed the page
|
|
* from swapcache already, so we can't check PageSwapCache().
|
|
*/
|
|
if (!memcg)
|
|
return;
|
|
|
|
commit_charge(page, memcg, lrucare);
|
|
|
|
if (PageTransHuge(page)) {
|
|
nr_pages <<= compound_order(page);
|
|
VM_BUG_ON_PAGE(!PageTransHuge(page), page);
|
|
}
|
|
|
|
local_irq_disable();
|
|
mem_cgroup_charge_statistics(memcg, page, nr_pages);
|
|
memcg_check_events(memcg, page);
|
|
local_irq_enable();
|
|
|
|
if (do_swap_account && PageSwapCache(page)) {
|
|
swp_entry_t entry = { .val = page_private(page) };
|
|
/*
|
|
* The swap entry might not get freed for a long time,
|
|
* let's not wait for it. The page already received a
|
|
* memory+swap charge, drop the swap entry duplicate.
|
|
*/
|
|
mem_cgroup_uncharge_swap(entry);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_cancel_charge - cancel a page charge
|
|
* @page: page to charge
|
|
* @memcg: memcg to charge the page to
|
|
*
|
|
* Cancel a charge transaction started by mem_cgroup_try_charge().
|
|
*/
|
|
void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg)
|
|
{
|
|
unsigned int nr_pages = 1;
|
|
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
/*
|
|
* Swap faults will attempt to charge the same page multiple
|
|
* times. But reuse_swap_page() might have removed the page
|
|
* from swapcache already, so we can't check PageSwapCache().
|
|
*/
|
|
if (!memcg)
|
|
return;
|
|
|
|
if (PageTransHuge(page)) {
|
|
nr_pages <<= compound_order(page);
|
|
VM_BUG_ON_PAGE(!PageTransHuge(page), page);
|
|
}
|
|
|
|
cancel_charge(memcg, nr_pages);
|
|
}
|
|
|
|
static void uncharge_batch(struct mem_cgroup *memcg, unsigned long pgpgout,
|
|
unsigned long nr_anon, unsigned long nr_file,
|
|
unsigned long nr_huge, struct page *dummy_page)
|
|
{
|
|
unsigned long nr_pages = nr_anon + nr_file;
|
|
unsigned long flags;
|
|
|
|
if (!mem_cgroup_is_root(memcg)) {
|
|
page_counter_uncharge(&memcg->memory, nr_pages);
|
|
if (do_swap_account)
|
|
page_counter_uncharge(&memcg->memsw, nr_pages);
|
|
memcg_oom_recover(memcg);
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
__this_cpu_sub(memcg->stat->count[MEM_CGROUP_STAT_RSS], nr_anon);
|
|
__this_cpu_sub(memcg->stat->count[MEM_CGROUP_STAT_CACHE], nr_file);
|
|
__this_cpu_sub(memcg->stat->count[MEM_CGROUP_STAT_RSS_HUGE], nr_huge);
|
|
__this_cpu_add(memcg->stat->events[MEM_CGROUP_EVENTS_PGPGOUT], pgpgout);
|
|
__this_cpu_add(memcg->stat->nr_page_events, nr_pages);
|
|
memcg_check_events(memcg, dummy_page);
|
|
local_irq_restore(flags);
|
|
|
|
if (!mem_cgroup_is_root(memcg))
|
|
css_put_many(&memcg->css, nr_pages);
|
|
}
|
|
|
|
static void uncharge_list(struct list_head *page_list)
|
|
{
|
|
struct mem_cgroup *memcg = NULL;
|
|
unsigned long nr_anon = 0;
|
|
unsigned long nr_file = 0;
|
|
unsigned long nr_huge = 0;
|
|
unsigned long pgpgout = 0;
|
|
struct list_head *next;
|
|
struct page *page;
|
|
|
|
next = page_list->next;
|
|
do {
|
|
unsigned int nr_pages = 1;
|
|
|
|
page = list_entry(next, struct page, lru);
|
|
next = page->lru.next;
|
|
|
|
VM_BUG_ON_PAGE(PageLRU(page), page);
|
|
VM_BUG_ON_PAGE(page_count(page), page);
|
|
|
|
if (!page->mem_cgroup)
|
|
continue;
|
|
|
|
/*
|
|
* Nobody should be changing or seriously looking at
|
|
* page->mem_cgroup at this point, we have fully
|
|
* exclusive access to the page.
|
|
*/
|
|
|
|
if (memcg != page->mem_cgroup) {
|
|
if (memcg) {
|
|
uncharge_batch(memcg, pgpgout, nr_anon, nr_file,
|
|
nr_huge, page);
|
|
pgpgout = nr_anon = nr_file = nr_huge = 0;
|
|
}
|
|
memcg = page->mem_cgroup;
|
|
}
|
|
|
|
if (PageTransHuge(page)) {
|
|
nr_pages <<= compound_order(page);
|
|
VM_BUG_ON_PAGE(!PageTransHuge(page), page);
|
|
nr_huge += nr_pages;
|
|
}
|
|
|
|
if (PageAnon(page))
|
|
nr_anon += nr_pages;
|
|
else
|
|
nr_file += nr_pages;
|
|
|
|
page->mem_cgroup = NULL;
|
|
|
|
pgpgout++;
|
|
} while (next != page_list);
|
|
|
|
if (memcg)
|
|
uncharge_batch(memcg, pgpgout, nr_anon, nr_file,
|
|
nr_huge, page);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_uncharge - uncharge a page
|
|
* @page: page to uncharge
|
|
*
|
|
* Uncharge a page previously charged with mem_cgroup_try_charge() and
|
|
* mem_cgroup_commit_charge().
|
|
*/
|
|
void mem_cgroup_uncharge(struct page *page)
|
|
{
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
|
|
/* Don't touch page->lru of any random page, pre-check: */
|
|
if (!page->mem_cgroup)
|
|
return;
|
|
|
|
INIT_LIST_HEAD(&page->lru);
|
|
uncharge_list(&page->lru);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_uncharge_list - uncharge a list of page
|
|
* @page_list: list of pages to uncharge
|
|
*
|
|
* Uncharge a list of pages previously charged with
|
|
* mem_cgroup_try_charge() and mem_cgroup_commit_charge().
|
|
*/
|
|
void mem_cgroup_uncharge_list(struct list_head *page_list)
|
|
{
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
|
|
if (!list_empty(page_list))
|
|
uncharge_list(page_list);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_migrate - migrate a charge to another page
|
|
* @oldpage: currently charged page
|
|
* @newpage: page to transfer the charge to
|
|
* @lrucare: either or both pages might be on the LRU already
|
|
*
|
|
* Migrate the charge from @oldpage to @newpage.
|
|
*
|
|
* Both pages must be locked, @newpage->mapping must be set up.
|
|
*/
|
|
void mem_cgroup_migrate(struct page *oldpage, struct page *newpage,
|
|
bool lrucare)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
int isolated;
|
|
|
|
VM_BUG_ON_PAGE(!PageLocked(oldpage), oldpage);
|
|
VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
|
|
VM_BUG_ON_PAGE(!lrucare && PageLRU(oldpage), oldpage);
|
|
VM_BUG_ON_PAGE(!lrucare && PageLRU(newpage), newpage);
|
|
VM_BUG_ON_PAGE(PageAnon(oldpage) != PageAnon(newpage), newpage);
|
|
VM_BUG_ON_PAGE(PageTransHuge(oldpage) != PageTransHuge(newpage),
|
|
newpage);
|
|
|
|
if (mem_cgroup_disabled())
|
|
return;
|
|
|
|
/* Page cache replacement: new page already charged? */
|
|
if (newpage->mem_cgroup)
|
|
return;
|
|
|
|
/*
|
|
* Swapcache readahead pages can get migrated before being
|
|
* charged, and migration from compaction can happen to an
|
|
* uncharged page when the PFN walker finds a page that
|
|
* reclaim just put back on the LRU but has not released yet.
|
|
*/
|
|
memcg = oldpage->mem_cgroup;
|
|
if (!memcg)
|
|
return;
|
|
|
|
if (lrucare)
|
|
lock_page_lru(oldpage, &isolated);
|
|
|
|
oldpage->mem_cgroup = NULL;
|
|
|
|
if (lrucare)
|
|
unlock_page_lru(oldpage, isolated);
|
|
|
|
commit_charge(newpage, memcg, lrucare);
|
|
}
|
|
|
|
/*
|
|
* subsys_initcall() for memory controller.
|
|
*
|
|
* Some parts like hotcpu_notifier() have to be initialized from this context
|
|
* because of lock dependencies (cgroup_lock -> cpu hotplug) but basically
|
|
* everything that doesn't depend on a specific mem_cgroup structure should
|
|
* be initialized from here.
|
|
*/
|
|
static int __init mem_cgroup_init(void)
|
|
{
|
|
int cpu, node;
|
|
|
|
hotcpu_notifier(memcg_cpu_hotplug_callback, 0);
|
|
|
|
for_each_possible_cpu(cpu)
|
|
INIT_WORK(&per_cpu_ptr(&memcg_stock, cpu)->work,
|
|
drain_local_stock);
|
|
|
|
for_each_node(node) {
|
|
struct mem_cgroup_tree_per_node *rtpn;
|
|
int zone;
|
|
|
|
rtpn = kzalloc_node(sizeof(*rtpn), GFP_KERNEL,
|
|
node_online(node) ? node : NUMA_NO_NODE);
|
|
|
|
for (zone = 0; zone < MAX_NR_ZONES; zone++) {
|
|
struct mem_cgroup_tree_per_zone *rtpz;
|
|
|
|
rtpz = &rtpn->rb_tree_per_zone[zone];
|
|
rtpz->rb_root = RB_ROOT;
|
|
spin_lock_init(&rtpz->lock);
|
|
}
|
|
soft_limit_tree.rb_tree_per_node[node] = rtpn;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
subsys_initcall(mem_cgroup_init);
|
|
|
|
#ifdef CONFIG_MEMCG_SWAP
|
|
/**
|
|
* mem_cgroup_swapout - transfer a memsw charge to swap
|
|
* @page: page whose memsw charge to transfer
|
|
* @entry: swap entry to move the charge to
|
|
*
|
|
* Transfer the memsw charge of @page to @entry.
|
|
*/
|
|
void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
unsigned short oldid;
|
|
|
|
VM_BUG_ON_PAGE(PageLRU(page), page);
|
|
VM_BUG_ON_PAGE(page_count(page), page);
|
|
|
|
if (!do_swap_account)
|
|
return;
|
|
|
|
memcg = page->mem_cgroup;
|
|
|
|
/* Readahead page, never charged */
|
|
if (!memcg)
|
|
return;
|
|
|
|
oldid = swap_cgroup_record(entry, mem_cgroup_id(memcg));
|
|
VM_BUG_ON_PAGE(oldid, page);
|
|
mem_cgroup_swap_statistics(memcg, true);
|
|
|
|
page->mem_cgroup = NULL;
|
|
|
|
if (!mem_cgroup_is_root(memcg))
|
|
page_counter_uncharge(&memcg->memory, 1);
|
|
|
|
/* XXX: caller holds IRQ-safe mapping->tree_lock */
|
|
VM_BUG_ON(!irqs_disabled());
|
|
|
|
mem_cgroup_charge_statistics(memcg, page, -1);
|
|
memcg_check_events(memcg, page);
|
|
}
|
|
|
|
/**
|
|
* mem_cgroup_uncharge_swap - uncharge a swap entry
|
|
* @entry: swap entry to uncharge
|
|
*
|
|
* Drop the memsw charge associated with @entry.
|
|
*/
|
|
void mem_cgroup_uncharge_swap(swp_entry_t entry)
|
|
{
|
|
struct mem_cgroup *memcg;
|
|
unsigned short id;
|
|
|
|
if (!do_swap_account)
|
|
return;
|
|
|
|
id = swap_cgroup_record(entry, 0);
|
|
rcu_read_lock();
|
|
memcg = mem_cgroup_lookup(id);
|
|
if (memcg) {
|
|
if (!mem_cgroup_is_root(memcg))
|
|
page_counter_uncharge(&memcg->memsw, 1);
|
|
mem_cgroup_swap_statistics(memcg, false);
|
|
css_put(&memcg->css);
|
|
}
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
/* for remember boot option*/
|
|
#ifdef CONFIG_MEMCG_SWAP_ENABLED
|
|
static int really_do_swap_account __initdata = 1;
|
|
#else
|
|
static int really_do_swap_account __initdata;
|
|
#endif
|
|
|
|
static int __init enable_swap_account(char *s)
|
|
{
|
|
if (!strcmp(s, "1"))
|
|
really_do_swap_account = 1;
|
|
else if (!strcmp(s, "0"))
|
|
really_do_swap_account = 0;
|
|
return 1;
|
|
}
|
|
__setup("swapaccount=", enable_swap_account);
|
|
|
|
static struct cftype memsw_cgroup_files[] = {
|
|
{
|
|
.name = "memsw.usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEMSWAP, RES_USAGE),
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "memsw.max_usage_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEMSWAP, RES_MAX_USAGE),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "memsw.limit_in_bytes",
|
|
.private = MEMFILE_PRIVATE(_MEMSWAP, RES_LIMIT),
|
|
.write = mem_cgroup_write,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{
|
|
.name = "memsw.failcnt",
|
|
.private = MEMFILE_PRIVATE(_MEMSWAP, RES_FAILCNT),
|
|
.write = mem_cgroup_reset,
|
|
.read_u64 = mem_cgroup_read_u64,
|
|
},
|
|
{ }, /* terminate */
|
|
};
|
|
|
|
static int __init mem_cgroup_swap_init(void)
|
|
{
|
|
if (!mem_cgroup_disabled() && really_do_swap_account) {
|
|
do_swap_account = 1;
|
|
WARN_ON(cgroup_add_legacy_cftypes(&memory_cgrp_subsys,
|
|
memsw_cgroup_files));
|
|
}
|
|
return 0;
|
|
}
|
|
subsys_initcall(mem_cgroup_swap_init);
|
|
|
|
#endif /* CONFIG_MEMCG_SWAP */
|