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_aware ? memcg : NULL,
71					       count_per_node);
72		if (total) {
73			seq_printf(m, "%lu", mem_cgroup_ino(memcg));
74			for_each_node(nid)
75				seq_printf(m, " %lu", count_per_node[nid]);
76			seq_putc(m, '\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(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, 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(kbuf, buf, 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(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(&shrinker_debugfs_ida, GFP_KERNEL);
175	if (id < 0)
176		return id;
177	shrinker->debugfs_id = id;
178
179	snprintf(buf, sizeof(buf), "%s-%d", shrinker->name, id);
180
181	/* create debugfs entry */
182	entry = debugfs_create_dir(buf, shrinker_debugfs_root);
183	if (IS_ERR(entry)) {
184		ida_free(&shrinker_debugfs_ida, id);
185		return PTR_ERR(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	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, 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, sizeof(buf), "%s-%d", shrinker->name,
218			 shrinker->debugfs_id);
219
220		entry = debugfs_rename(shrinker_debugfs_root,
221				       shrinker->debugfs_entry,
222				       shrinker_debugfs_root, buf);
223		if (IS_ERR(entry))
224			ret = PTR_ERR(entry);
225		else
226			shrinker->debugfs_entry = entry;
227	}
228
229	mutex_unlock(&shrinker_mutex);
230
231	kfree_const(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(debugfs_entry);
253	ida_free(&shrinker_debugfs_ida, 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("shrinker", NULL);
263	if (IS_ERR(dentry))
264		return PTR_ERR(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(&shrinker_mutex);
276
277	return ret;
278}
279late_initcall(shrinker_debugfs_init);
280