1// SPDX-License-Identifier: GPL-2.0
2#include <linux/idr.h>
3#include <linux/slab.h>
4#include <linux/debugfs.h>
5#include <linux/seq_file.h>
6#include <linux/shrinker.h>
7#include <linux/memcontrol.h>
8
9#include "internal.h"
10
11/* defined in vmscan.c */
12extern struct mutex shrinker_mutex;
13extern struct list_head shrinker_list;
14
15static DEFINE_IDA(shrinker_debugfs_ida);
16static struct dentry *shrinker_debugfs_root;
17
18static unsigned long shrinker_count_objects(struct shrinker *shrinker,
19 struct mem_cgroup *memcg,
20 unsigned long *count_per_node)
21{
22 unsigned long nr, total = 0;
23 int nid;
24
25 for_each_node(nid) {
26 if (nid == 0 || (shrinker->flags & SHRINKER_NUMA_AWARE)) {
27 struct shrink_control sc = {
28 .gfp_mask = GFP_KERNEL,
29 .nid = nid,
30 .memcg = memcg,
31 };
32
33 nr = shrinker->count_objects(shrinker, &sc);
34 if (nr == SHRINK_EMPTY)
35 nr = 0;
36 } else {
37 nr = 0;
38 }
39
40 count_per_node[nid] = nr;
41 total += nr;
42 }
43
44 return total;
45}
46
47static int shrinker_debugfs_count_show(struct seq_file *m, void *v)
48{
49 struct shrinker *shrinker = m->private;
50 unsigned long *count_per_node;
51 struct mem_cgroup *memcg;
52 unsigned long total;
53 bool memcg_aware;
54 int ret = 0, nid;
55
56 count_per_node = kcalloc(n: nr_node_ids, size: sizeof(unsigned long), GFP_KERNEL);
57 if (!count_per_node)
58 return -ENOMEM;
59
60 rcu_read_lock();
61
62 memcg_aware = shrinker->flags & SHRINKER_MEMCG_AWARE;
63
64 memcg = mem_cgroup_iter(NULL, NULL, NULL);
65 do {
66 if (memcg && !mem_cgroup_online(memcg))
67 continue;
68
69 total = shrinker_count_objects(shrinker,
70 memcg: memcg_aware ? memcg : NULL,
71 count_per_node);
72 if (total) {
73 seq_printf(m, fmt: "%lu", mem_cgroup_ino(memcg));
74 for_each_node(nid)
75 seq_printf(m, fmt: " %lu", count_per_node[nid]);
76 seq_putc(m, c: '\n');
77 }
78
79 if (!memcg_aware) {
80 mem_cgroup_iter_break(NULL, memcg);
81 break;
82 }
83
84 if (signal_pending(current)) {
85 mem_cgroup_iter_break(NULL, memcg);
86 ret = -EINTR;
87 break;
88 }
89 } while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);
90
91 rcu_read_unlock();
92
93 kfree(objp: count_per_node);
94 return ret;
95}
96DEFINE_SHOW_ATTRIBUTE(shrinker_debugfs_count);
97
98static int shrinker_debugfs_scan_open(struct inode *inode, struct file *file)
99{
100 file->private_data = inode->i_private;
101 return nonseekable_open(inode, filp: file);
102}
103
104static ssize_t shrinker_debugfs_scan_write(struct file *file,
105 const char __user *buf,
106 size_t size, loff_t *pos)
107{
108 struct shrinker *shrinker = file->private_data;
109 unsigned long nr_to_scan = 0, ino, read_len;
110 struct shrink_control sc = {
111 .gfp_mask = GFP_KERNEL,
112 };
113 struct mem_cgroup *memcg = NULL;
114 int nid;
115 char kbuf[72];
116
117 read_len = size < (sizeof(kbuf) - 1) ? size : (sizeof(kbuf) - 1);
118 if (copy_from_user(to: kbuf, from: buf, n: read_len))
119 return -EFAULT;
120 kbuf[read_len] = '\0';
121
122 if (sscanf(kbuf, "%lu %d %lu", &ino, &nid, &nr_to_scan) != 3)
123 return -EINVAL;
124
125 if (nid < 0 || nid >= nr_node_ids)
126 return -EINVAL;
127
128 if (nr_to_scan == 0)
129 return size;
130
131 if (shrinker->flags & SHRINKER_MEMCG_AWARE) {
132 memcg = mem_cgroup_get_from_ino(ino);
133 if (!memcg || IS_ERR(ptr: memcg))
134 return -ENOENT;
135
136 if (!mem_cgroup_online(memcg)) {
137 mem_cgroup_put(memcg);
138 return -ENOENT;
139 }
140 } else if (ino != 0) {
141 return -EINVAL;
142 }
143
144 sc.nid = nid;
145 sc.memcg = memcg;
146 sc.nr_to_scan = nr_to_scan;
147 sc.nr_scanned = nr_to_scan;
148
149 shrinker->scan_objects(shrinker, &sc);
150
151 mem_cgroup_put(memcg);
152
153 return size;
154}
155
156static const struct file_operations shrinker_debugfs_scan_fops = {
157 .owner = THIS_MODULE,
158 .open = shrinker_debugfs_scan_open,
159 .write = shrinker_debugfs_scan_write,
160};
161
162int shrinker_debugfs_add(struct shrinker *shrinker)
163{
164 struct dentry *entry;
165 char buf[128];
166 int id;
167
168 lockdep_assert_held(&shrinker_mutex);
169
170 /* debugfs isn't initialized yet, add debugfs entries later. */
171 if (!shrinker_debugfs_root)
172 return 0;
173
174 id = ida_alloc(ida: &shrinker_debugfs_ida, GFP_KERNEL);
175 if (id < 0)
176 return id;
177 shrinker->debugfs_id = id;
178
179 snprintf(buf, size: sizeof(buf), fmt: "%s-%d", shrinker->name, id);
180
181 /* create debugfs entry */
182 entry = debugfs_create_dir(name: buf, parent: shrinker_debugfs_root);
183 if (IS_ERR(ptr: entry)) {
184 ida_free(&shrinker_debugfs_ida, id);
185 return PTR_ERR(ptr: entry);
186 }
187 shrinker->debugfs_entry = entry;
188
189 debugfs_create_file(name: "count", mode: 0440, parent: entry, data: shrinker,
190 fops: &shrinker_debugfs_count_fops);
191 debugfs_create_file(name: "scan", mode: 0220, parent: entry, data: shrinker,
192 fops: &shrinker_debugfs_scan_fops);
193 return 0;
194}
195
196int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...)
197{
198 struct dentry *entry;
199 char buf[128];
200 const char *new, *old;
201 va_list ap;
202 int ret = 0;
203
204 va_start(ap, fmt);
205 new = kvasprintf_const(GFP_KERNEL, fmt, args: ap);
206 va_end(ap);
207
208 if (!new)
209 return -ENOMEM;
210
211 mutex_lock(&shrinker_mutex);
212
213 old = shrinker->name;
214 shrinker->name = new;
215
216 if (shrinker->debugfs_entry) {
217 snprintf(buf, size: sizeof(buf), fmt: "%s-%d", shrinker->name,
218 shrinker->debugfs_id);
219
220 entry = debugfs_rename(old_dir: shrinker_debugfs_root,
221 old_dentry: shrinker->debugfs_entry,
222 new_dir: shrinker_debugfs_root, new_name: buf);
223 if (IS_ERR(ptr: entry))
224 ret = PTR_ERR(ptr: entry);
225 else
226 shrinker->debugfs_entry = entry;
227 }
228
229 mutex_unlock(lock: &shrinker_mutex);
230
231 kfree_const(x: old);
232
233 return ret;
234}
235EXPORT_SYMBOL(shrinker_debugfs_rename);
236
237struct dentry *shrinker_debugfs_detach(struct shrinker *shrinker,
238 int *debugfs_id)
239{
240 struct dentry *entry = shrinker->debugfs_entry;
241
242 lockdep_assert_held(&shrinker_mutex);
243
244 *debugfs_id = entry ? shrinker->debugfs_id : -1;
245 shrinker->debugfs_entry = NULL;
246
247 return entry;
248}
249
250void shrinker_debugfs_remove(struct dentry *debugfs_entry, int debugfs_id)
251{
252 debugfs_remove_recursive(dentry: debugfs_entry);
253 ida_free(&shrinker_debugfs_ida, id: debugfs_id);
254}
255
256static int __init shrinker_debugfs_init(void)
257{
258 struct shrinker *shrinker;
259 struct dentry *dentry;
260 int ret = 0;
261
262 dentry = debugfs_create_dir(name: "shrinker", NULL);
263 if (IS_ERR(ptr: dentry))
264 return PTR_ERR(ptr: dentry);
265 shrinker_debugfs_root = dentry;
266
267 /* Create debugfs entries for shrinkers registered at boot */
268 mutex_lock(&shrinker_mutex);
269 list_for_each_entry(shrinker, &shrinker_list, list)
270 if (!shrinker->debugfs_entry) {
271 ret = shrinker_debugfs_add(shrinker);
272 if (ret)
273 break;
274 }
275 mutex_unlock(lock: &shrinker_mutex);
276
277 return ret;
278}
279late_initcall(shrinker_debugfs_init);
280

source code of linux/mm/shrinker_debug.c