projects/linux·blob master · refs

247 lines · 5.7 KiB

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 <[email protected]>
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 ?: SHRINK_EMPTY;
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 if (freed < nr)
113 freed += f2fs_shrink_read_extent_tree(sbi, nr >> 2);
114
115 /* shrink clean nat cache entries */
116 if (freed < nr)
117 freed += f2fs_try_to_free_nats(sbi, nr - freed);
118
119 /* shrink free nids cache entries */
120 if (freed < nr)
121 freed += f2fs_try_to_free_nids(sbi, nr - freed);
122
123 spin_lock(&f2fs_list_lock);
124 p = p->next;
125 list_move_tail(&sbi->s_list, &f2fs_list);
126 mutex_unlock(&sbi->umount_mutex);
127 if (freed >= nr)
128 break;
129 }
130 spin_unlock(&f2fs_list_lock);
131 return freed;
132}
133
134unsigned int f2fs_donate_files(void)
135{
136 struct f2fs_sb_info *sbi;
137 struct list_head *p;
138 unsigned int donate_files = 0;
139
140 spin_lock(&f2fs_list_lock);
141 p = f2fs_list.next;
142 while (p != &f2fs_list) {
143 sbi = list_entry(p, struct f2fs_sb_info, s_list);
144
145 /* stop f2fs_put_super */
146 if (!mutex_trylock(&sbi->umount_mutex)) {
147 p = p->next;
148 continue;
149 }
150 spin_unlock(&f2fs_list_lock);
151
152 donate_files += sbi->donate_files;
153
154 spin_lock(&f2fs_list_lock);
155 p = p->next;
156 mutex_unlock(&sbi->umount_mutex);
157 }
158 spin_unlock(&f2fs_list_lock);
159
160 return donate_files;
161}
162
163static unsigned int do_reclaim_caches(struct f2fs_sb_info *sbi,
164 unsigned int reclaim_caches_kb)
165{
166 struct inode *inode;
167 struct f2fs_inode_info *fi;
168 unsigned int nfiles = sbi->donate_files;
169 pgoff_t npages = reclaim_caches_kb >> (PAGE_SHIFT - 10);
170
171 while (npages && nfiles--) {
172 pgoff_t len;
173
174 spin_lock(&sbi->inode_lock[DONATE_INODE]);
175 if (list_empty(&sbi->inode_list[DONATE_INODE])) {
176 spin_unlock(&sbi->inode_lock[DONATE_INODE]);
177 break;
178 }
179 fi = list_first_entry(&sbi->inode_list[DONATE_INODE],
180 struct f2fs_inode_info, gdonate_list);
181 list_move_tail(&fi->gdonate_list, &sbi->inode_list[DONATE_INODE]);
182 inode = igrab(&fi->vfs_inode);
183 spin_unlock(&sbi->inode_lock[DONATE_INODE]);
184
185 if (!inode)
186 continue;
187
188 inode_lock(inode);
189 if (!is_inode_flag_set(inode, FI_DONATE_FINISHED)) {
190 len = fi->donate_end - fi->donate_start + 1;
191 npages = npages < len ? 0 : npages - len;
192
193 invalidate_inode_pages2_range(inode->i_mapping,
194 fi->donate_start, fi->donate_end);
195 set_inode_flag(inode, FI_DONATE_FINISHED);
196 }
197 inode_unlock(inode);
198
199 iput(inode);
200 cond_resched();
201 }
202 return npages << (PAGE_SHIFT - 10);
203}
204
205void f2fs_reclaim_caches(unsigned int reclaim_caches_kb)
206{
207 struct f2fs_sb_info *sbi;
208 struct list_head *p;
209
210 spin_lock(&f2fs_list_lock);
211 p = f2fs_list.next;
212 while (p != &f2fs_list && reclaim_caches_kb) {
213 sbi = list_entry(p, struct f2fs_sb_info, s_list);
214
215 /* stop f2fs_put_super */
216 if (!mutex_trylock(&sbi->umount_mutex)) {
217 p = p->next;
218 continue;
219 }
220 spin_unlock(&f2fs_list_lock);
221
222 reclaim_caches_kb = do_reclaim_caches(sbi, reclaim_caches_kb);
223
224 spin_lock(&f2fs_list_lock);
225 p = p->next;
226 mutex_unlock(&sbi->umount_mutex);
227 }
228 spin_unlock(&f2fs_list_lock);
229}
230
231void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
232{
233 spin_lock(&f2fs_list_lock);
234 list_add_tail(&sbi->s_list, &f2fs_list);
235 spin_unlock(&f2fs_list_lock);
236}
237
238void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
239{
240 f2fs_shrink_read_extent_tree(sbi, __count_extent_cache(sbi, EX_READ));
241 f2fs_shrink_age_extent_tree(sbi,
242 __count_extent_cache(sbi, EX_BLOCK_AGE));
243
244 spin_lock(&f2fs_list_lock);
245 list_del_init(&sbi->s_list);
246 spin_unlock(&f2fs_list_lock);
247}