linux/mm/shrinker.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/memcontrol.h>
#include <linux/rwsem.h>
#include <linux/shrinker.h>
#include <linux/rculist.h>
#include <trace/events/vmscan.h>

#include "internal.h"

LIST_HEAD(…);
DEFINE_MUTEX(…) …;

#ifdef CONFIG_MEMCG
static int shrinker_nr_max;

static inline int shrinker_unit_size(int nr_items)
{ … }

static inline void shrinker_unit_free(struct shrinker_info *info, int start)
{ … }

static inline int shrinker_unit_alloc(struct shrinker_info *new,
				       struct shrinker_info *old, int nid)
{ … }

void free_shrinker_info(struct mem_cgroup *memcg)
{ … }

int alloc_shrinker_info(struct mem_cgroup *memcg)
{ … }

static struct shrinker_info *shrinker_info_protected(struct mem_cgroup *memcg,
						     int nid)
{ … }

static int expand_one_shrinker_info(struct mem_cgroup *memcg, int new_size,
				    int old_size, int new_nr_max)
{ … }

static int expand_shrinker_info(int new_id)
{ … }

static inline int shrinker_id_to_index(int shrinker_id)
{ … }

static inline int shrinker_id_to_offset(int shrinker_id)
{ … }

static inline int calc_shrinker_id(int index, int offset)
{ … }

void set_shrinker_bit(struct mem_cgroup *memcg, int nid, int shrinker_id)
{ … }

static DEFINE_IDR(shrinker_idr);

static int shrinker_memcg_alloc(struct shrinker *shrinker)
{ … }

static void shrinker_memcg_remove(struct shrinker *shrinker)
{ … }

static long xchg_nr_deferred_memcg(int nid, struct shrinker *shrinker,
				   struct mem_cgroup *memcg)
{ … }

static long add_nr_deferred_memcg(long nr, int nid, struct shrinker *shrinker,
				  struct mem_cgroup *memcg)
{ … }

void reparent_shrinker_deferred(struct mem_cgroup *memcg)
{ … }
#else
static int shrinker_memcg_alloc(struct shrinker *shrinker)
{
	return -ENOSYS;
}

static void shrinker_memcg_remove(struct shrinker *shrinker)
{
}

static long xchg_nr_deferred_memcg(int nid, struct shrinker *shrinker,
				   struct mem_cgroup *memcg)
{
	return 0;
}

static long add_nr_deferred_memcg(long nr, int nid, struct shrinker *shrinker,
				  struct mem_cgroup *memcg)
{
	return 0;
}
#endif /* CONFIG_MEMCG */

static long xchg_nr_deferred(struct shrinker *shrinker,
			     struct shrink_control *sc)
{ … }


static long add_nr_deferred(long nr, struct shrinker *shrinker,
			    struct shrink_control *sc)
{ … }

#define SHRINK_BATCH …

static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
				    struct shrinker *shrinker, int priority)
{ … }

#ifdef CONFIG_MEMCG
static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
			struct mem_cgroup *memcg, int priority)
{ … }
#else /* !CONFIG_MEMCG */
static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
			struct mem_cgroup *memcg, int priority)
{
	return 0;
}
#endif /* CONFIG_MEMCG */

/**
 * shrink_slab - shrink slab caches
 * @gfp_mask: allocation context
 * @nid: node whose slab caches to target
 * @memcg: memory cgroup whose slab caches to target
 * @priority: the reclaim priority
 *
 * Call the shrink functions to age shrinkable caches.
 *
 * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
 * unaware shrinkers will receive a node id of 0 instead.
 *
 * @memcg specifies the memory cgroup to target. Unaware shrinkers
 * are called only if it is the root cgroup.
 *
 * @priority is sc->priority, we take the number of objects and >> by priority
 * in order to get the scan target.
 *
 * Returns the number of reclaimed slab objects.
 */
unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup *memcg,
			  int priority)
{ … }

struct shrinker *shrinker_alloc(unsigned int flags, const char *fmt, ...)
{ … }
EXPORT_SYMBOL_GPL(…);

void shrinker_register(struct shrinker *shrinker)
{ … }
EXPORT_SYMBOL_GPL(…);

static void shrinker_free_rcu_cb(struct rcu_head *head)
{ … }

void shrinker_free(struct shrinker *shrinker)
{ … }
EXPORT_SYMBOL_GPL(…);