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 = min(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);