[linux-block.git] / fs / f2fs / shrinker.c

// SPDX-License-Identifier: GPL-2.0
/*
 * f2fs shrinker support
 *   the basic infra was copied from fs/ubifs/shrinker.c
 *
 * Copyright (c) 2015 Motorola Mobility
 * Copyright (c) 2015 Jaegeuk Kim <jaegeuk@kernel.org>
 */
#include <linux/fs.h>
#include <linux/f2fs_fs.h>

#include "f2fs.h"
#include "node.h"

static LIST_HEAD(f2fs_list);
static DEFINE_SPINLOCK(f2fs_list_lock);
static unsigned int shrinker_run_no;

static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
{
	return NM_I(sbi)->nat_cnt[RECLAIMABLE_NAT];
}

static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
{
	long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;

	return count > 0 ? count : 0;
}

static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi,
					enum extent_type type)
{
	struct extent_tree_info *eti = &sbi->extent_tree[type];

	return atomic_read(&eti->total_zombie_tree) +
				atomic_read(&eti->total_ext_node);
}

unsigned long f2fs_shrink_count(struct shrinker *shrink,
				struct shrink_control *sc)
{
	struct f2fs_sb_info *sbi;
	struct list_head *p;
	unsigned long count = 0;

	spin_lock(&f2fs_list_lock);
	p = f2fs_list.next;
	while (p != &f2fs_list) {
		sbi = list_entry(p, struct f2fs_sb_info, s_list);

		/* stop f2fs_put_super */
		if (!mutex_trylock(&sbi->umount_mutex)) {
			p = p->next;
			continue;
		}
		spin_unlock(&f2fs_list_lock);

		/* count read extent cache entries */
		count += __count_extent_cache(sbi, EX_READ);

		/* count block age extent cache entries */
		count += __count_extent_cache(sbi, EX_BLOCK_AGE);

		/* count clean nat cache entries */
		count += __count_nat_entries(sbi);

		/* count free nids cache entries */
		count += __count_free_nids(sbi);

		spin_lock(&f2fs_list_lock);
		p = p->next;
		mutex_unlock(&sbi->umount_mutex);
	}
	spin_unlock(&f2fs_list_lock);
	return count;
}

unsigned long f2fs_shrink_scan(struct shrinker *shrink,
				struct shrink_control *sc)
{
	unsigned long nr = sc->nr_to_scan;
	struct f2fs_sb_info *sbi;
	struct list_head *p;
	unsigned int run_no;
	unsigned long freed = 0;

	spin_lock(&f2fs_list_lock);
	do {
		run_no = ++shrinker_run_no;
	} while (run_no == 0);
	p = f2fs_list.next;
	while (p != &f2fs_list) {
		sbi = list_entry(p, struct f2fs_sb_info, s_list);

		if (sbi->shrinker_run_no == run_no)
			break;

		/* stop f2fs_put_super */
		if (!mutex_trylock(&sbi->umount_mutex)) {
			p = p->next;
			continue;
		}
		spin_unlock(&f2fs_list_lock);

		sbi->shrinker_run_no = run_no;

		/* shrink extent cache entries */
		freed += f2fs_shrink_age_extent_tree(sbi, nr >> 2);

		/* shrink read extent cache entries */
		freed += f2fs_shrink_read_extent_tree(sbi, nr >> 2);

		/* shrink clean nat cache entries */
		if (freed < nr)
			freed += f2fs_try_to_free_nats(sbi, nr - freed);

		/* shrink free nids cache entries */
		if (freed < nr)
			freed += f2fs_try_to_free_nids(sbi, nr - freed);

		spin_lock(&f2fs_list_lock);
		p = p->next;
		list_move_tail(&sbi->s_list, &f2fs_list);
		mutex_unlock(&sbi->umount_mutex);
		if (freed >= nr)
			break;
	}
	spin_unlock(&f2fs_list_lock);
	return freed;
}

void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
{
	spin_lock(&f2fs_list_lock);
	list_add_tail(&sbi->s_list, &f2fs_list);
	spin_unlock(&f2fs_list_lock);
}

void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
{
	f2fs_shrink_read_extent_tree(sbi, __count_extent_cache(sbi, EX_READ));
	f2fs_shrink_age_extent_tree(sbi,
				__count_extent_cache(sbi, EX_BLOCK_AGE));

	spin_lock(&f2fs_list_lock);
	list_del_init(&sbi->s_list);
	spin_unlock(&f2fs_list_lock);
}
Commit	Line	Data
7c1a000d	1	// SPDX-License-Identifier: GPL-2.0
2658e50d JK	2	/*
	3	* f2fs shrinker support
	4	* the basic infra was copied from fs/ubifs/shrinker.c
	5	*
	6	* Copyright (c) 2015 Motorola Mobility
	7	* Copyright (c) 2015 Jaegeuk Kim <jaegeuk@kernel.org>
2658e50d JK	8	*/
	9	#include <linux/fs.h>
	10	#include <linux/f2fs_fs.h>
	11
	12	#include "f2fs.h"
ad4edb83	13	#include "node.h"
2658e50d JK	14
	15	static LIST_HEAD(f2fs_list);
	16	static DEFINE_SPINLOCK(f2fs_list_lock);
	17	static unsigned int shrinker_run_no;
	18
1b38dc8e JK	19	static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
1b38dc8e JK	20	{
a95ba66a	21	return NM_I(sbi)->nat_cnt[RECLAIMABLE_NAT];
1b38dc8e JK	22	}
1b38dc8e JK	23
31696580 CY	24	static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
31696580 CY	25	{
9a4ffdf5	26	long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;
02110a4f CY	27
02110a4f CY	28	return count > 0 ? count : 0;
31696580 CY	29	}
31696580 CY	30
e7547dac JK	31	static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi,
e7547dac JK	32	enum extent_type type)
554df79e	33	{
e7547dac JK	34	struct extent_tree_info *eti = &sbi->extent_tree[type];
	35
	36	return atomic_read(&eti->total_zombie_tree) +
	37	atomic_read(&eti->total_ext_node);
554df79e JK	38	}
554df79e JK	39
2658e50d JK	40	unsigned long f2fs_shrink_count(struct shrinker *shrink,
	41	struct shrink_control *sc)
	42	{
	43	struct f2fs_sb_info *sbi;
	44	struct list_head *p;
	45	unsigned long count = 0;
	46
	47	spin_lock(&f2fs_list_lock);
	48	p = f2fs_list.next;
	49	while (p != &f2fs_list) {
	50	sbi = list_entry(p, struct f2fs_sb_info, s_list);
	51
	52	/* stop f2fs_put_super */
	53	if (!mutex_trylock(&sbi->umount_mutex)) {
	54	p = p->next;
	55	continue;
	56	}
	57	spin_unlock(&f2fs_list_lock);
	58
e7547dac JK	59	/* count read extent cache entries */
e7547dac JK	60	count += __count_extent_cache(sbi, EX_READ);
554df79e	61
71644dff JK	62	/* count block age extent cache entries */
	63	count += __count_extent_cache(sbi, EX_BLOCK_AGE);
	64
7a88ddb5	65	/* count clean nat cache entries */
1b38dc8e	66	count += __count_nat_entries(sbi);
2658e50d	67
31696580 CY	68	/* count free nids cache entries */
	69	count += __count_free_nids(sbi);
	70
2658e50d JK	71	spin_lock(&f2fs_list_lock);
	72	p = p->next;
	73	mutex_unlock(&sbi->umount_mutex);
	74	}
	75	spin_unlock(&f2fs_list_lock);
	76	return count;
	77	}
	78
	79	unsigned long f2fs_shrink_scan(struct shrinker *shrink,
	80	struct shrink_control *sc)
	81	{
	82	unsigned long nr = sc->nr_to_scan;
	83	struct f2fs_sb_info *sbi;
	84	struct list_head *p;
	85	unsigned int run_no;
	86	unsigned long freed = 0;
	87
	88	spin_lock(&f2fs_list_lock);
	89	do {
	90	run_no = ++shrinker_run_no;
	91	} while (run_no == 0);
	92	p = f2fs_list.next;
	93	while (p != &f2fs_list) {
	94	sbi = list_entry(p, struct f2fs_sb_info, s_list);
	95
	96	if (sbi->shrinker_run_no == run_no)
	97	break;
	98
	99	/* stop f2fs_put_super */
	100	if (!mutex_trylock(&sbi->umount_mutex)) {
	101	p = p->next;
	102	continue;
	103	}
	104	spin_unlock(&f2fs_list_lock);
	105
	106	sbi->shrinker_run_no = run_no;
	107
71644dff JK	108	/* shrink extent cache entries */
	109	freed += f2fs_shrink_age_extent_tree(sbi, nr >> 2);
	110
e7547dac	111	/* shrink read extent cache entries */
71644dff	112	freed += f2fs_shrink_read_extent_tree(sbi, nr >> 2);
554df79e	113
1b38dc8e	114	/* shrink clean nat cache entries */
554df79e	115	if (freed < nr)
4d57b86d	116	freed += f2fs_try_to_free_nats(sbi, nr - freed);
2658e50d	117
31696580 CY	118	/* shrink free nids cache entries */
31696580 CY	119	if (freed < nr)
4d57b86d	120	freed += f2fs_try_to_free_nids(sbi, nr - freed);
31696580	121
2658e50d JK	122	spin_lock(&f2fs_list_lock);
	123	p = p->next;
	124	list_move_tail(&sbi->s_list, &f2fs_list);
	125	mutex_unlock(&sbi->umount_mutex);
	126	if (freed >= nr)
	127	break;
	128	}
	129	spin_unlock(&f2fs_list_lock);
	130	return freed;
	131	}
	132
	133	void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
	134	{
	135	spin_lock(&f2fs_list_lock);
	136	list_add_tail(&sbi->s_list, &f2fs_list);
	137	spin_unlock(&f2fs_list_lock);
	138	}
	139
	140	void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
	141	{
e7547dac	142	f2fs_shrink_read_extent_tree(sbi, __count_extent_cache(sbi, EX_READ));
71644dff JK	143	f2fs_shrink_age_extent_tree(sbi,
71644dff JK	144	__count_extent_cache(sbi, EX_BLOCK_AGE));
3e72f721	145
2658e50d	146	spin_lock(&f2fs_list_lock);
e4589fa5	147	list_del_init(&sbi->s_list);
2658e50d JK	148	spin_unlock(&f2fs_list_lock);
2658e50d JK	149	}