1// SPDX-License-Identifier: GPL-2.0
  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>
  8 */
  9#include <linux/fs.h>
 10#include <linux/f2fs_fs.h>
 11
 12#include "f2fs.h"
 13#include "node.h"
 14
 15static LIST_HEAD(f2fs_list);
 16static DEFINE_SPINLOCK(f2fs_list_lock);
 17static unsigned int shrinker_run_no;
 18
 19static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
 20{
 21	long count = NM_I(sbi)->nat_cnt - NM_I(sbi)->dirty_nat_cnt;
 22
 23	return count > 0 ? count : 0;
 24}
 25
 26static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
 27{
 28	long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;
 29
 30	return count > 0 ? count : 0;
 31}
 32
 33static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi)
 34{
 35	return atomic_read(&sbi->total_zombie_tree) +
 36				atomic_read(&sbi->total_ext_node);
 37}
 38
 39unsigned long f2fs_shrink_count(struct shrinker *shrink,
 40				struct shrink_control *sc)
 41{
 42	struct f2fs_sb_info *sbi;
 43	struct list_head *p;
 44	unsigned long count = 0;
 45
 46	spin_lock(&f2fs_list_lock);
 47	p = f2fs_list.next;
 48	while (p != &f2fs_list) {
 49		sbi = list_entry(p, struct f2fs_sb_info, s_list);
 50
 51		/* stop f2fs_put_super */
 52		if (!mutex_trylock(&sbi->umount_mutex)) {
 53			p = p->next;
 54			continue;
 55		}
 56		spin_unlock(&f2fs_list_lock);
 57
 58		/* count extent cache entries */
 59		count += __count_extent_cache(sbi);
 60
 61		/* shrink clean nat cache entries */
 62		count += __count_nat_entries(sbi);
 63
 64		/* count free nids cache entries */
 65		count += __count_free_nids(sbi);
 66
 67		spin_lock(&f2fs_list_lock);
 68		p = p->next;
 69		mutex_unlock(&sbi->umount_mutex);
 70	}
 71	spin_unlock(&f2fs_list_lock);
 72	return count;
 73}
 74
 75unsigned long f2fs_shrink_scan(struct shrinker *shrink,
 76				struct shrink_control *sc)
 77{
 78	unsigned long nr = sc->nr_to_scan;
 79	struct f2fs_sb_info *sbi;
 80	struct list_head *p;
 81	unsigned int run_no;
 82	unsigned long freed = 0;
 83
 84	spin_lock(&f2fs_list_lock);
 85	do {
 86		run_no = ++shrinker_run_no;
 87	} while (run_no == 0);
 88	p = f2fs_list.next;
 89	while (p != &f2fs_list) {
 90		sbi = list_entry(p, struct f2fs_sb_info, s_list);
 91
 92		if (sbi->shrinker_run_no == run_no)
 93			break;
 94
 95		/* stop f2fs_put_super */
 96		if (!mutex_trylock(&sbi->umount_mutex)) {
 97			p = p->next;
 98			continue;
 99		}
100		spin_unlock(&f2fs_list_lock);
101
102		sbi->shrinker_run_no = run_no;
103
104		/* shrink extent cache entries */
105		freed += f2fs_shrink_extent_tree(sbi, nr >> 1);
106
107		/* shrink clean nat cache entries */
108		if (freed < nr)
109			freed += f2fs_try_to_free_nats(sbi, nr - freed);
110
111		/* shrink free nids cache entries */
112		if (freed < nr)
113			freed += f2fs_try_to_free_nids(sbi, nr - freed);
114
115		spin_lock(&f2fs_list_lock);
116		p = p->next;
117		list_move_tail(&sbi->s_list, &f2fs_list);
118		mutex_unlock(&sbi->umount_mutex);
119		if (freed >= nr)
120			break;
121	}
122	spin_unlock(&f2fs_list_lock);
123	return freed;
124}
125
126void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
127{
128	spin_lock(&f2fs_list_lock);
129	list_add_tail(&sbi->s_list, &f2fs_list);
130	spin_unlock(&f2fs_list_lock);
131}
132
133void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
134{
135	f2fs_shrink_extent_tree(sbi, __count_extent_cache(sbi));
136
137	spin_lock(&f2fs_list_lock);
138	list_del_init(&sbi->s_list);
139	spin_unlock(&f2fs_list_lock);
140}