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 #include <linux/srcu.h> 9 10 /* defined in vmscan.c */ 11 extern struct mutex shrinker_mutex; 12 extern struct list_head shrinker_list; 13 extern struct srcu_struct shrinker_srcu; 14 15 static DEFINE_IDA(shrinker_debugfs_ida); 16 static struct dentry *shrinker_debugfs_root; 17 18 static 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 47 static 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, srcu_idx; 55 56 count_per_node = kcalloc(nr_node_ids, sizeof(unsigned long), GFP_KERNEL); 57 if (!count_per_node) 58 return -ENOMEM; 59 60 srcu_idx = srcu_read_lock(&shrinker_srcu); 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 srcu_read_unlock(&shrinker_srcu, srcu_idx); 92 93 kfree(count_per_node); 94 return ret; 95 } 96 DEFINE_SHOW_ATTRIBUTE(shrinker_debugfs_count); 97 98 static 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 104 static 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, srcu_idx; 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 srcu_idx = srcu_read_lock(&shrinker_srcu); 145 146 sc.nid = nid; 147 sc.memcg = memcg; 148 sc.nr_to_scan = nr_to_scan; 149 sc.nr_scanned = nr_to_scan; 150 151 shrinker->scan_objects(shrinker, &sc); 152 153 srcu_read_unlock(&shrinker_srcu, srcu_idx); 154 mem_cgroup_put(memcg); 155 156 return size; 157 } 158 159 static const struct file_operations shrinker_debugfs_scan_fops = { 160 .owner = THIS_MODULE, 161 .open = shrinker_debugfs_scan_open, 162 .write = shrinker_debugfs_scan_write, 163 }; 164 165 int shrinker_debugfs_add(struct shrinker *shrinker) 166 { 167 struct dentry *entry; 168 char buf[128]; 169 int id; 170 171 lockdep_assert_held(&shrinker_mutex); 172 173 /* debugfs isn't initialized yet, add debugfs entries later. */ 174 if (!shrinker_debugfs_root) 175 return 0; 176 177 id = ida_alloc(&shrinker_debugfs_ida, GFP_KERNEL); 178 if (id < 0) 179 return id; 180 shrinker->debugfs_id = id; 181 182 snprintf(buf, sizeof(buf), "%s-%d", shrinker->name, id); 183 184 /* create debugfs entry */ 185 entry = debugfs_create_dir(buf, shrinker_debugfs_root); 186 if (IS_ERR(entry)) { 187 ida_free(&shrinker_debugfs_ida, id); 188 return PTR_ERR(entry); 189 } 190 shrinker->debugfs_entry = entry; 191 192 debugfs_create_file("count", 0440, entry, shrinker, 193 &shrinker_debugfs_count_fops); 194 debugfs_create_file("scan", 0220, entry, shrinker, 195 &shrinker_debugfs_scan_fops); 196 return 0; 197 } 198 199 int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...) 200 { 201 struct dentry *entry; 202 char buf[128]; 203 const char *new, *old; 204 va_list ap; 205 int ret = 0; 206 207 va_start(ap, fmt); 208 new = kvasprintf_const(GFP_KERNEL, fmt, ap); 209 va_end(ap); 210 211 if (!new) 212 return -ENOMEM; 213 214 mutex_lock(&shrinker_mutex); 215 216 old = shrinker->name; 217 shrinker->name = new; 218 219 if (shrinker->debugfs_entry) { 220 snprintf(buf, sizeof(buf), "%s-%d", shrinker->name, 221 shrinker->debugfs_id); 222 223 entry = debugfs_rename(shrinker_debugfs_root, 224 shrinker->debugfs_entry, 225 shrinker_debugfs_root, buf); 226 if (IS_ERR(entry)) 227 ret = PTR_ERR(entry); 228 else 229 shrinker->debugfs_entry = entry; 230 } 231 232 mutex_unlock(&shrinker_mutex); 233 234 kfree_const(old); 235 236 return ret; 237 } 238 EXPORT_SYMBOL(shrinker_debugfs_rename); 239 240 struct dentry *shrinker_debugfs_detach(struct shrinker *shrinker, 241 int *debugfs_id) 242 { 243 struct dentry *entry = shrinker->debugfs_entry; 244 245 lockdep_assert_held(&shrinker_mutex); 246 247 kfree_const(shrinker->name); 248 shrinker->name = NULL; 249 250 *debugfs_id = entry ? shrinker->debugfs_id : -1; 251 shrinker->debugfs_entry = NULL; 252 253 return entry; 254 } 255 256 void shrinker_debugfs_remove(struct dentry *debugfs_entry, int debugfs_id) 257 { 258 debugfs_remove_recursive(debugfs_entry); 259 ida_free(&shrinker_debugfs_ida, debugfs_id); 260 } 261 262 static int __init shrinker_debugfs_init(void) 263 { 264 struct shrinker *shrinker; 265 struct dentry *dentry; 266 int ret = 0; 267 268 dentry = debugfs_create_dir("shrinker", NULL); 269 if (IS_ERR(dentry)) 270 return PTR_ERR(dentry); 271 shrinker_debugfs_root = dentry; 272 273 /* Create debugfs entries for shrinkers registered at boot */ 274 mutex_lock(&shrinker_mutex); 275 list_for_each_entry(shrinker, &shrinker_list, list) 276 if (!shrinker->debugfs_entry) { 277 ret = shrinker_debugfs_add(shrinker); 278 if (ret) 279 break; 280 } 281 mutex_unlock(&shrinker_mutex); 282 283 return ret; 284 } 285 late_initcall(shrinker_debugfs_init); 286