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(nr_node_ids, 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 = min(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("count", 0440, entry, shrinker,
190 &shrinker_debugfs_count_fops);
191 debugfs_create_file("scan", 0220, entry, shrinker,
192 &shrinker_debugfs_scan_fops);
193 return 0;
194}
195
196int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...)
197{
198 const char *new, *old;
199 va_list ap;
200 int ret = 0;
201
202 va_start(ap, fmt);
203 new = kvasprintf_const(GFP_KERNEL, fmt, args: ap);
204 va_end(ap);
205
206 if (!new)
207 return -ENOMEM;
208
209 mutex_lock(&shrinker_mutex);
210
211 old = shrinker->name;
212 shrinker->name = new;
213
214 ret = debugfs_change_name(dentry: shrinker->debugfs_entry, fmt: "%s-%d",
215 shrinker->name, shrinker->debugfs_id);
216
217 if (ret) {
218 shrinker->name = old;
219 kfree_const(x: new);
220 } else {
221 kfree_const(x: old);
222 }
223 mutex_unlock(lock: &shrinker_mutex);
224
225 return ret;
226}
227EXPORT_SYMBOL(shrinker_debugfs_rename);
228
229struct dentry *shrinker_debugfs_detach(struct shrinker *shrinker,
230 int *debugfs_id)
231{
232 struct dentry *entry = shrinker->debugfs_entry;
233
234 lockdep_assert_held(&shrinker_mutex);
235
236 *debugfs_id = entry ? shrinker->debugfs_id : -1;
237 shrinker->debugfs_entry = NULL;
238
239 return entry;
240}
241
242void shrinker_debugfs_remove(struct dentry *debugfs_entry, int debugfs_id)
243{
244 debugfs_remove_recursive(dentry: debugfs_entry);
245 ida_free(&shrinker_debugfs_ida, id: debugfs_id);
246}
247
248static int __init shrinker_debugfs_init(void)
249{
250 struct shrinker *shrinker;
251 struct dentry *dentry;
252 int ret = 0;
253
254 dentry = debugfs_create_dir(name: "shrinker", NULL);
255 if (IS_ERR(ptr: dentry))
256 return PTR_ERR(ptr: dentry);
257 shrinker_debugfs_root = dentry;
258
259 /* Create debugfs entries for shrinkers registered at boot */
260 mutex_lock(&shrinker_mutex);
261 list_for_each_entry(shrinker, &shrinker_list, list)
262 if (!shrinker->debugfs_entry) {
263 ret = shrinker_debugfs_add(shrinker);
264 if (ret)
265 break;
266 }
267 mutex_unlock(lock: &shrinker_mutex);
268
269 return ret;
270}
271late_initcall(shrinker_debugfs_init);
272

source code of linux/mm/shrinker_debug.c

Morty Proxy This is a proxified and sanitized view of the page, visit original site.