[mirror_ubuntu-hirsute-kernel.git] / fs / f2fs / shrinker.c

/*
 * 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>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#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 - NM_I(sbi)->dirty_nat_cnt;
}

static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
{
	if (NM_I(sbi)->nid_cnt[FREE_NID_LIST] > MAX_FREE_NIDS)
		return NM_I(sbi)->nid_cnt[FREE_NID_LIST] - MAX_FREE_NIDS;
	return 0;
}

static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi)
{
	return atomic_read(&sbi->total_zombie_tree) +
				atomic_read(&sbi->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 extent cache entries */
		count += __count_extent_cache(sbi);

		/* shrink 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_extent_tree(sbi, nr >> 1);

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

		/* shrink free nids cache entries */
		if (freed < nr)
			freed += 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_extent_tree(sbi, __count_extent_cache(sbi));

	spin_lock(&f2fs_list_lock);
	list_del(&sbi->s_list);
	spin_unlock(&f2fs_list_lock);
}
Commit	Line	Data
2658e50d JK	1	/*
	2	* f2fs shrinker support
	3	* the basic infra was copied from fs/ubifs/shrinker.c
	4	*
	5	* Copyright (c) 2015 Motorola Mobility
	6	* Copyright (c) 2015 Jaegeuk Kim <jaegeuk@kernel.org>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12	#include <linux/fs.h>
	13	#include <linux/f2fs_fs.h>
	14
	15	#include "f2fs.h"
ad4edb83	16	#include "node.h"
2658e50d JK	17
	18	static LIST_HEAD(f2fs_list);
	19	static DEFINE_SPINLOCK(f2fs_list_lock);
	20	static unsigned int shrinker_run_no;
	21
1b38dc8e JK	22	static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
	23	{
	24	return NM_I(sbi)->nat_cnt - NM_I(sbi)->dirty_nat_cnt;
	25	}
	26
31696580 CY	27	static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
31696580 CY	28	{
b8559dc2 CY	29	if (NM_I(sbi)->nid_cnt[FREE_NID_LIST] > MAX_FREE_NIDS)
b8559dc2 CY	30	return NM_I(sbi)->nid_cnt[FREE_NID_LIST] - MAX_FREE_NIDS;
31696580 CY	31	return 0;
	32	}
	33
554df79e JK	34	static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi)
554df79e JK	35	{
74fd8d99	36	return atomic_read(&sbi->total_zombie_tree) +
7441ccef	37	atomic_read(&sbi->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
554df79e JK	59	/* count extent cache entries */
	60	count += __count_extent_cache(sbi);
	61
1b38dc8e JK	62	/* shrink clean nat cache entries */
1b38dc8e JK	63	count += __count_nat_entries(sbi);
2658e50d	64
31696580 CY	65	/* count free nids cache entries */
	66	count += __count_free_nids(sbi);
	67
2658e50d JK	68	spin_lock(&f2fs_list_lock);
	69	p = p->next;
	70	mutex_unlock(&sbi->umount_mutex);
	71	}
	72	spin_unlock(&f2fs_list_lock);
	73	return count;
	74	}
	75
	76	unsigned long f2fs_shrink_scan(struct shrinker *shrink,
	77	struct shrink_control *sc)
	78	{
	79	unsigned long nr = sc->nr_to_scan;
	80	struct f2fs_sb_info *sbi;
	81	struct list_head *p;
	82	unsigned int run_no;
	83	unsigned long freed = 0;
	84
	85	spin_lock(&f2fs_list_lock);
	86	do {
	87	run_no = ++shrinker_run_no;
	88	} while (run_no == 0);
	89	p = f2fs_list.next;
	90	while (p != &f2fs_list) {
	91	sbi = list_entry(p, struct f2fs_sb_info, s_list);
	92
	93	if (sbi->shrinker_run_no == run_no)
	94	break;
	95
	96	/* stop f2fs_put_super */
	97	if (!mutex_trylock(&sbi->umount_mutex)) {
	98	p = p->next;
	99	continue;
	100	}
	101	spin_unlock(&f2fs_list_lock);
	102
	103	sbi->shrinker_run_no = run_no;
	104
554df79e JK	105	/* shrink extent cache entries */
	106	freed += f2fs_shrink_extent_tree(sbi, nr >> 1);
	107
1b38dc8e	108	/* shrink clean nat cache entries */
554df79e JK	109	if (freed < nr)
554df79e JK	110	freed += try_to_free_nats(sbi, nr - freed);
2658e50d	111
31696580 CY	112	/* shrink free nids cache entries */
	113	if (freed < nr)
	114	freed += try_to_free_nids(sbi, nr - freed);
	115
2658e50d JK	116	spin_lock(&f2fs_list_lock);
	117	p = p->next;
	118	list_move_tail(&sbi->s_list, &f2fs_list);
	119	mutex_unlock(&sbi->umount_mutex);
	120	if (freed >= nr)
	121	break;
	122	}
	123	spin_unlock(&f2fs_list_lock);
	124	return freed;
	125	}
	126
	127	void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
	128	{
	129	spin_lock(&f2fs_list_lock);
	130	list_add_tail(&sbi->s_list, &f2fs_list);
	131	spin_unlock(&f2fs_list_lock);
	132	}
	133
	134	void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
	135	{
3e72f721 JK	136	f2fs_shrink_extent_tree(sbi, __count_extent_cache(sbi));
3e72f721 JK	137
2658e50d JK	138	spin_lock(&f2fs_list_lock);
	139	list_del(&sbi->s_list);
	140	spin_unlock(&f2fs_list_lock);
	141	}