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