mm/shrinker_debug.c

   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 */
  12 extern struct mutex shrinker_mutex;
  13 extern struct list_head shrinker_list;
  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;
  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 }
  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;
 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
 156 static 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
 162 int 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
 196 int 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 }
 235 EXPORT_SYMBOL(shrinker_debugfs_rename);
 236
 237 struct 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
 250 void 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
 256 static 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 }
 279 late_initcall(shrinker_debugfs_init);