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	return NM_I(sbi)->nat_cnt[RECLAIMABLE_NAT];
22}
23
24static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
25{
26	long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;
27
28	return count > 0 ? count : 0;
29}
30
31static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi,
32					enum extent_type type)
33{
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);
38}
39
40unsigned 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
59		/* count read extent cache entries */
60		count += __count_extent_cache(sbi, EX_READ);
61
62		/* count block age extent cache entries */
63		count += __count_extent_cache(sbi, EX_BLOCK_AGE);
64
65		/* count clean nat cache entries */
66		count += __count_nat_entries(sbi);
67
68		/* count free nids cache entries */
69		count += __count_free_nids(sbi);
70
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
79unsigned 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
108		/* shrink extent cache entries */
109		freed += f2fs_shrink_age_extent_tree(sbi, nr >> 2);
110
111		/* shrink read extent cache entries */
112		freed += f2fs_shrink_read_extent_tree(sbi, nr >> 2);
113
114		/* shrink clean nat cache entries */
115		if (freed < nr)
116			freed += f2fs_try_to_free_nats(sbi, nr - freed);
117
118		/* shrink free nids cache entries */
119		if (freed < nr)
120			freed += f2fs_try_to_free_nids(sbi, nr - freed);
121
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
133void 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
140void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
141{
142	f2fs_shrink_read_extent_tree(sbi, __count_extent_cache(sbi, EX_READ));
143	f2fs_shrink_age_extent_tree(sbi,
144				__count_extent_cache(sbi, EX_BLOCK_AGE));
145
146	spin_lock(&f2fs_list_lock);
147	list_del_init(&sbi->s_list);
148	spin_unlock(&f2fs_list_lock);
149}
150