Gitiles
Code Review Sign In
192.168.1.100 / T108 / e958203796650e3959a43708d67534bf36f4c83b / . / marvell / linux / fs / f2fs / shrinker.c
blob: dd3c3c7a90ec8f79b375624eac961405f6d399bb [file] [log] [blame]
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame^]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{
33 return atomic_read(&sbi->total_zombie_tree) +
34 atomic_read(&sbi->total_ext_node);
35}
36
37unsigned 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
73unsigned 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
124void 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
131void 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}