Skip to contentSkip to conversation

mm-shrinkers-provide-shrinkers-with-names.patch removed from -mm tree

merged mm-stable Andrew Morton 1 participant 1 message Jul 4, 2022

lore
Share & tools
lore

Andrew Morton

author tree notice Applied
#0 lore raw

The quilt patch titled
Subject: mm: shrinkers: provide shrinkers with names
has been removed from the -mm tree. Its filename was
mm-shrinkers-provide-shrinkers-with-names.patch

This patch was dropped because it was merged into the mm-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

------------------------------------------------------
From: Roman Gushchin <[email protected]>
Subject: mm: shrinkers: provide shrinkers with names
Date: Tue, 31 May 2022 20:22:24 -0700

Currently shrinkers are anonymous objects. For debugging purposes they can be identified by count/scan function names, but it's not always
useful: e.g. for superblock's shrinkers it's nice to have at least an idea of to which superblock the shrinker belongs.

This commit adds names to shrinkers. register_shrinker() and prealloc_shrinker() functions are extended to take a format and arguments to master a name.

In some cases it's not possible to determine a good name at the time when a shrinker is allocated. For such cases shrinker_debugfs_rename() is provided.

The expected format is:

    <subsystem>-<shrinker_type>[:<instance>]-<id>

For some shrinkers an instance can be encoded as (MAJOR:MINOR) pair.

After this change the shrinker debugfs directory looks like:

  $ cd /sys/kernel/debug/shrinker/
  $ ls
    dquota-cache-16     sb-devpts-28     sb-proc-47       sb-tmpfs-42
    mm-shadow-18        sb-devtmpfs-5    sb-proc-48       sb-tmpfs-43
    mm-zspool:zram0-34  sb-hugetlbfs-17  sb-pstore-31     sb-tmpfs-44
    rcu-kfree-0         sb-hugetlbfs-33  sb-rootfs-2      sb-tmpfs-49
    sb-aio-20           sb-iomem-12      sb-securityfs-6  sb-tracefs-13
    sb-anon_inodefs-15  sb-mqueue-21     sb-selinuxfs-22  sb-xfs:vda1-36
    sb-bdev-3           sb-nsfs-4        sb-sockfs-8      sb-zsmalloc-19
    sb-bpf-32           sb-pipefs-14     sb-sysfs-26      thp-deferred_split-10
    sb-btrfs:vda2-24    sb-proc-25       sb-tmpfs-1       thp-zero-9
    sb-cgroup2-30       sb-proc-39       sb-tmpfs-27      xfs-buf:vda1-37
    sb-configfs-23      sb-proc-41       sb-tmpfs-29      xfs-inodegc:vda1-38
    sb-dax-11           sb-proc-45       sb-tmpfs-35
    sb-debugfs-7        sb-proc-46       sb-tmpfs-40

---

 arch/x86/kvm/mmu/mmu.c                           |    2 
 drivers/android/binder_alloc.c                   |    2 
 drivers/gpu/drm/i915/gem/i915_gem_shrinker.c     |    3 
 drivers/gpu/drm/msm/msm_gem_shrinker.c           |    2 
 drivers/gpu/drm/panfrost/panfrost_gem_shrinker.c |    2 
 drivers/gpu/drm/ttm/ttm_pool.c                   |    2 
 drivers/md/bcache/btree.c                        |    2 
 drivers/md/dm-bufio.c                            |    3 
 drivers/md/dm-zoned-metadata.c                   |    4 
 drivers/md/raid5.c                               |    2 
 drivers/misc/vmw_balloon.c                       |    2 
 drivers/virtio/virtio_balloon.c                  |    2 
 drivers/xen/xenbus/xenbus_probe_backend.c        |    2 
 fs/btrfs/super.c                                 |    2 
 fs/erofs/utils.c                                 |    2 
 fs/ext4/extents_status.c                         |    3 
 fs/f2fs/super.c                                  |    2 
 fs/gfs2/glock.c                                  |    2 
 fs/gfs2/main.c                                   |    2 
 fs/jbd2/journal.c                                |    3 
 fs/mbcache.c                                     |    2 
 fs/nfs/nfs42xattr.c                              |    7 -
 fs/nfs/super.c                                   |    2 
 fs/nfsd/filecache.c                              |    2 
 fs/nfsd/nfscache.c                               |    3 
 fs/quota/dquot.c                                 |    2 
 fs/super.c                                       |    6 +
 fs/ubifs/super.c                                 |    2 
 fs/xfs/xfs_buf.c                                 |    3 
 fs/xfs/xfs_icache.c                              |    2 
 fs/xfs/xfs_qm.c                                  |    3 
 include/linux/shrinker.h                         |   14 ++-
 kernel/rcu/tree.c                                |    2 
 mm/huge_memory.c                                 |    4 
 mm/shrinker_debug.c                              |   47 ++++++++++
 mm/vmscan.c                                      |   58 ++++++++++++-
 mm/workingset.c                                  |    2 
 mm/zsmalloc.c                                    |    3 
 net/sunrpc/auth.c                                |    2 
 39 files changed, 167 insertions(+), 45 deletions(-)
arch/x86/kvm/mmu/mmu.c renamed from arch/x86/kvm/mmu/mmu.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -6317,7 +6317,7 @@ int kvm_mmu_vendor_module_init(void)
 	if (percpu_counter_init(&kvm_total_used_mmu_pages, 0, GFP_KERNEL))
 		goto out;
 
-	ret = register_shrinker(&mmu_shrinker);
+	ret = register_shrinker(&mmu_shrinker, "x86-mmu");
 	if (ret)
 		goto out;
 
drivers/android/binder_alloc.c renamed from drivers/android/binder_alloc.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -1084,7 +1084,7 @@ int binder_alloc_shrinker_init(void)
 	int ret = list_lru_init(&binder_alloc_lru);
 
 	if (ret == 0) {
-		ret = register_shrinker(&binder_shrinker);
+		ret = register_shrinker(&binder_shrinker, "android-binder");
 		if (ret)
 			list_lru_destroy(&binder_alloc_lru);
 	}
drivers/gpu/drm/i915/gem/i915_gem_shrinker.c renamed from drivers/gpu/drm/i915/gem/i915_gem_shrinker.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -426,7 +426,8 @@ void i915_gem_driver_register__shrinker(
 	i915->mm.shrinker.count_objects = i915_gem_shrinker_count;
 	i915->mm.shrinker.seeks = DEFAULT_SEEKS;
 	i915->mm.shrinker.batch = 4096;
-	drm_WARN_ON(&i915->drm, register_shrinker(&i915->mm.shrinker));
+	drm_WARN_ON(&i915->drm, register_shrinker(&i915->mm.shrinker,
+						  "drm-i915_gem"));
 
 	i915->mm.oom_notifier.notifier_call = i915_gem_shrinker_oom;
 	drm_WARN_ON(&i915->drm, register_oom_notifier(&i915->mm.oom_notifier));
drivers/gpu/drm/msm/msm_gem_shrinker.c renamed from drivers/gpu/drm/msm/msm_gem_shrinker.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -221,7 +221,7 @@ void msm_gem_shrinker_init(struct drm_de
 	priv->shrinker.count_objects = msm_gem_shrinker_count;
 	priv->shrinker.scan_objects = msm_gem_shrinker_scan;
 	priv->shrinker.seeks = DEFAULT_SEEKS;
-	WARN_ON(register_shrinker(&priv->shrinker));
+	WARN_ON(register_shrinker(&priv->shrinker, "drm-msm_gem"));
 
 	priv->vmap_notifier.notifier_call = msm_gem_shrinker_vmap;
 	WARN_ON(register_vmap_purge_notifier(&priv->vmap_notifier));
drivers/gpu/drm/panfrost/panfrost_gem_shrinker.c renamed from drivers/gpu/drm/panfrost/panfrost_gem_shrinker.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -103,7 +103,7 @@ void panfrost_gem_shrinker_init(struct d
 	pfdev->shrinker.count_objects = panfrost_gem_shrinker_count;
 	pfdev->shrinker.scan_objects = panfrost_gem_shrinker_scan;
 	pfdev->shrinker.seeks = DEFAULT_SEEKS;
-	WARN_ON(register_shrinker(&pfdev->shrinker));
+	WARN_ON(register_shrinker(&pfdev->shrinker, "drm-panfrost"));
 }
 
 /**
drivers/gpu/drm/ttm/ttm_pool.c renamed from drivers/gpu/drm/ttm/ttm_pool.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -722,7 +722,7 @@ int ttm_pool_mgr_init(unsigned long num_
 	mm_shrinker.count_objects = ttm_pool_shrinker_count;
 	mm_shrinker.scan_objects = ttm_pool_shrinker_scan;
 	mm_shrinker.seeks = 1;
-	return register_shrinker(&mm_shrinker);
+	return register_shrinker(&mm_shrinker, "drm-ttm_pool");
 }
 
 /**
drivers/md/bcache/btree.c renamed from drivers/md/bcache/btree.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -812,7 +812,7 @@ int bch_btree_cache_alloc(struct cache_s
 	c->shrink.seeks = 4;
 	c->shrink.batch = c->btree_pages * 2;
 
-	if (register_shrinker(&c->shrink))
+	if (register_shrinker(&c->shrink, "md-bcache:%pU", c->set_uuid))
 		pr_warn("bcache: %s: could not register shrinker\n",
 				__func__);
 
drivers/md/dm-bufio.c renamed from drivers/md/dm-bufio.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -1806,7 +1806,8 @@ struct dm_bufio_client *dm_bufio_client_
 	c->shrinker.scan_objects = dm_bufio_shrink_scan;
 	c->shrinker.seeks = 1;
 	c->shrinker.batch = 0;
-	r = register_shrinker(&c->shrinker);
+	r = register_shrinker(&c->shrinker, "md-%s:(%u:%u)", slab_name,
+			      MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
 	if (r)
 		goto bad;
 
drivers/md/dm-zoned-metadata.c renamed from drivers/md/dm-zoned-metadata.c~mm-shrinkers-provide-shrinkers-with-names +3 -1
@@ -2944,7 +2944,9 @@ int dmz_ctr_metadata(struct dmz_dev *dev
 	zmd->mblk_shrinker.seeks = DEFAULT_SEEKS;
 
 	/* Metadata cache shrinker */
-	ret = register_shrinker(&zmd->mblk_shrinker);
+	ret = register_shrinker(&zmd->mblk_shrinker, "md-meta:(%u:%u)",
+				MAJOR(dev->bdev->bd_dev),
+				MINOR(dev->bdev->bd_dev));
 	if (ret) {
 		dmz_zmd_err(zmd, "Register metadata cache shrinker failed");
 		goto err;
drivers/md/raid5.c renamed from drivers/md/raid5.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -7414,7 +7414,7 @@ static struct r5conf *setup_conf(struct
 	conf->shrinker.count_objects = raid5_cache_count;
 	conf->shrinker.batch = 128;
 	conf->shrinker.flags = 0;
-	ret = register_shrinker(&conf->shrinker);
+	ret = register_shrinker(&conf->shrinker, "md-raid5:%s", mdname(mddev));
 	if (ret) {
 		pr_warn("md/raid:%s: couldn't register shrinker.\n",
 			mdname(mddev));
drivers/misc/vmw_balloon.c renamed from drivers/misc/vmw_balloon.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -1587,7 +1587,7 @@ static int vmballoon_register_shrinker(s
 	b->shrinker.count_objects = vmballoon_shrinker_count;
 	b->shrinker.seeks = DEFAULT_SEEKS;
 
-	r = register_shrinker(&b->shrinker);
+	r = register_shrinker(&b->shrinker, "vmw-balloon");
 
 	if (r == 0)
 		b->shrinker_registered = true;
drivers/virtio/virtio_balloon.c renamed from drivers/virtio/virtio_balloon.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -875,7 +875,7 @@ static int virtio_balloon_register_shrin
 	vb->shrinker.count_objects = virtio_balloon_shrinker_count;
 	vb->shrinker.seeks = DEFAULT_SEEKS;
 
-	return register_shrinker(&vb->shrinker);
+	return register_shrinker(&vb->shrinker, "virtio-balloon");
 }
 
 static int virtballoon_probe(struct virtio_device *vdev)
drivers/xen/xenbus/xenbus_probe_backend.c renamed from drivers/xen/xenbus/xenbus_probe_backend.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -305,7 +305,7 @@ static int __init xenbus_probe_backend_i
 
 	register_xenstore_notifier(&xenstore_notifier);
 
-	if (register_shrinker(&backend_memory_shrinker))
+	if (register_shrinker(&backend_memory_shrinker, "xen-backend"))
 		pr_warn("shrinker registration failed\n");
 
 	return 0;
fs/btrfs/super.c renamed from fs/btrfs/super.c~mm-shrinkers-provide-shrinkers-with-names +2 -0
@@ -1815,6 +1815,8 @@ static struct dentry *btrfs_mount_root(s
 			error = -EBUSY;
 	} else {
 		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
+		shrinker_debugfs_rename(&s->s_shrink, "sb-%s:%s", fs_type->name,
+					s->s_id);
 		btrfs_sb(s)->bdev_holder = fs_type;
 		if (!strstr(crc32c_impl(), "generic"))
 			set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
fs/erofs/utils.c renamed from fs/erofs/utils.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -282,7 +282,7 @@ static struct shrinker erofs_shrinker_in
 
 int __init erofs_init_shrinker(void)
 {
-	return register_shrinker(&erofs_shrinker_info);
+	return register_shrinker(&erofs_shrinker_info, "erofs-shrinker");
 }
 
 void erofs_exit_shrinker(void)
fs/ext4/extents_status.c renamed from fs/ext4/extents_status.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -1654,7 +1654,8 @@ int ext4_es_register_shrinker(struct ext
 	sbi->s_es_shrinker.scan_objects = ext4_es_scan;
 	sbi->s_es_shrinker.count_objects = ext4_es_count;
 	sbi->s_es_shrinker.seeks = DEFAULT_SEEKS;
-	err = register_shrinker(&sbi->s_es_shrinker);
+	err = register_shrinker(&sbi->s_es_shrinker, "ext4-es:%s",
+				sbi->s_sb->s_id);
 	if (err)
 		goto err4;
 
fs/f2fs/super.c renamed from fs/f2fs/super.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -4579,7 +4579,7 @@ static int __init init_f2fs_fs(void)
 	err = f2fs_init_sysfs();
 	if (err)
 		goto free_garbage_collection_cache;
-	err = register_shrinker(&f2fs_shrinker_info);
+	err = register_shrinker(&f2fs_shrinker_info, "f2fs-shrinker");
 	if (err)
 		goto free_sysfs;
 	err = register_filesystem(&f2fs_fs_type);
fs/gfs2/glock.c renamed from fs/gfs2/glock.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -2533,7 +2533,7 @@ int __init gfs2_glock_init(void)
 		return -ENOMEM;
 	}
 
-	ret = register_shrinker(&glock_shrinker);
+	ret = register_shrinker(&glock_shrinker, "gfs2-glock");
 	if (ret) {
 		destroy_workqueue(gfs2_delete_workqueue);
 		destroy_workqueue(glock_workqueue);
fs/gfs2/main.c renamed from fs/gfs2/main.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -148,7 +148,7 @@ static int __init init_gfs2_fs(void)
 	if (!gfs2_trans_cachep)
 		goto fail_cachep8;
 
-	error = register_shrinker(&gfs2_qd_shrinker);
+	error = register_shrinker(&gfs2_qd_shrinker, "gfs2-qd");
 	if (error)
 		goto fail_shrinker;
 
fs/jbd2/journal.c renamed from fs/jbd2/journal.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -1418,7 +1418,8 @@ static journal_t *journal_init_common(st
 	if (percpu_counter_init(&journal->j_checkpoint_jh_count, 0, GFP_KERNEL))
 		goto err_cleanup;
 
-	if (register_shrinker(&journal->j_shrinker)) {
+	if (register_shrinker(&journal->j_shrinker, "jbd2-journal:(%u:%u)",
+			      MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev))) {
 		percpu_counter_destroy(&journal->j_checkpoint_jh_count);
 		goto err_cleanup;
 	}
fs/mbcache.c renamed from fs/mbcache.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -367,7 +367,7 @@ struct mb_cache *mb_cache_create(int buc
 	cache->c_shrink.count_objects = mb_cache_count;
 	cache->c_shrink.scan_objects = mb_cache_scan;
 	cache->c_shrink.seeks = DEFAULT_SEEKS;
-	if (register_shrinker(&cache->c_shrink)) {
+	if (register_shrinker(&cache->c_shrink, "mbcache-shrinker")) {
 		kfree(cache->c_hash);
 		kfree(cache);
 		goto err_out;
fs/nfsd/filecache.c renamed from fs/nfsd/filecache.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -670,7 +670,7 @@ nfsd_file_cache_init(void)
 		goto out_err;
 	}
 
-	ret = register_shrinker(&nfsd_file_shrinker);
+	ret = register_shrinker(&nfsd_file_shrinker, "nfsd-filecache");
 	if (ret) {
 		pr_err("nfsd: failed to register nfsd_file_shrinker: %d\n", ret);
 		goto out_lru;
fs/nfsd/nfscache.c renamed from fs/nfsd/nfscache.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -176,7 +176,8 @@ int nfsd_reply_cache_init(struct nfsd_ne
 	nn->nfsd_reply_cache_shrinker.scan_objects = nfsd_reply_cache_scan;
 	nn->nfsd_reply_cache_shrinker.count_objects = nfsd_reply_cache_count;
 	nn->nfsd_reply_cache_shrinker.seeks = 1;
-	status = register_shrinker(&nn->nfsd_reply_cache_shrinker);
+	status = register_shrinker(&nn->nfsd_reply_cache_shrinker,
+				   "nfsd-reply:%s", nn->nfsd_name);
 	if (status)
 		goto out_stats_destroy;
 
fs/nfs/nfs42xattr.c renamed from fs/nfs/nfs42xattr.c~mm-shrinkers-provide-shrinkers-with-names +4 -3
@@ -1017,15 +1017,16 @@ int __init nfs4_xattr_cache_init(void)
 	if (ret)
 		goto out2;
 
-	ret = register_shrinker(&nfs4_xattr_cache_shrinker);
+	ret = register_shrinker(&nfs4_xattr_cache_shrinker, "nfs-xattr_cache");
 	if (ret)
 		goto out1;
 
-	ret = register_shrinker(&nfs4_xattr_entry_shrinker);
+	ret = register_shrinker(&nfs4_xattr_entry_shrinker, "nfs-xattr_entry");
 	if (ret)
 		goto out;
 
-	ret = register_shrinker(&nfs4_xattr_large_entry_shrinker);
+	ret = register_shrinker(&nfs4_xattr_large_entry_shrinker,
+				"nfs-xattr_large_entry");
 	if (!ret)
 		return 0;
 
fs/nfs/super.c renamed from fs/nfs/super.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -149,7 +149,7 @@ int __init register_nfs_fs(void)
 	ret = nfs_register_sysctl();
 	if (ret < 0)
 		goto error_2;
-	ret = register_shrinker(&acl_shrinker);
+	ret = register_shrinker(&acl_shrinker, "nfs-acl");
 	if (ret < 0)
 		goto error_3;
 #ifdef CONFIG_NFS_V4_2
fs/quota/dquot.c renamed from fs/quota/dquot.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -2995,7 +2995,7 @@ static int __init dquot_init(void)
 	pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
 		" %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
 
-	if (register_shrinker(&dqcache_shrinker))
+	if (register_shrinker(&dqcache_shrinker, "dquota-cache"))
 		panic("Cannot register dquot shrinker");
 
 	return 0;
fs/super.c renamed from fs/super.c~mm-shrinkers-provide-shrinkers-with-names +5 -1
@@ -265,7 +265,7 @@ static struct super_block *alloc_super(s
 	s->s_shrink.count_objects = super_cache_count;
 	s->s_shrink.batch = 1024;
 	s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE;
-	if (prealloc_shrinker(&s->s_shrink))
+	if (prealloc_shrinker(&s->s_shrink, "sb-%s", type->name))
 		goto fail;
 	if (list_lru_init_memcg(&s->s_dentry_lru, &s->s_shrink))
 		goto fail;
@@ -1288,6 +1288,8 @@ int get_tree_bdev(struct fs_context *fc,
 	} else {
 		s->s_mode = mode;
 		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
+		shrinker_debugfs_rename(&s->s_shrink, "sb-%s:%s",
+					fc->fs_type->name, s->s_id);
 		sb_set_blocksize(s, block_size(bdev));
 		error = fill_super(s, fc);
 		if (error) {
@@ -1363,6 +1365,8 @@ struct dentry *mount_bdev(struct file_sy
 	} else {
 		s->s_mode = mode;
 		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
+		shrinker_debugfs_rename(&s->s_shrink, "sb-%s:%s",
+					fs_type->name, s->s_id);
 		sb_set_blocksize(s, block_size(bdev));
 		error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
 		if (error) {
fs/ubifs/super.c renamed from fs/ubifs/super.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -2430,7 +2430,7 @@ static int __init ubifs_init(void)
 	if (!ubifs_inode_slab)
 		return -ENOMEM;
 
-	err = register_shrinker(&ubifs_shrinker_info);
+	err = register_shrinker(&ubifs_shrinker_info, "ubifs-slab");
 	if (err)
 		goto out_slab;
 
fs/xfs/xfs_buf.c renamed from fs/xfs/xfs_buf.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -1986,7 +1986,8 @@ xfs_alloc_buftarg(
 	btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
 	btp->bt_shrinker.seeks = DEFAULT_SEEKS;
 	btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
-	if (register_shrinker(&btp->bt_shrinker))
+	if (register_shrinker(&btp->bt_shrinker, "xfs-buf:%s",
+			      mp->m_super->s_id))
 		goto error_pcpu;
 	return btp;
 
fs/xfs/xfs_icache.c renamed from fs/xfs/xfs_icache.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -2201,5 +2201,5 @@ xfs_inodegc_register_shrinker(
 	shrink->flags = SHRINKER_NONSLAB;
 	shrink->batch = XFS_INODEGC_SHRINKER_BATCH;
 
-	return register_shrinker(shrink);
+	return register_shrinker(shrink, "xfs-inodegc:%s", mp->m_super->s_id);
 }
fs/xfs/xfs_qm.c renamed from fs/xfs/xfs_qm.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -677,7 +677,8 @@ xfs_qm_init_quotainfo(
 	qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
 	qinf->qi_shrinker.flags = SHRINKER_NUMA_AWARE;
 
-	error = register_shrinker(&qinf->qi_shrinker);
+	error = register_shrinker(&qinf->qi_shrinker, "xfs-qm:%s",
+				  mp->m_super->s_id);
 	if (error)
 		goto out_free_inos;
 
include/linux/shrinker.h renamed from include/linux/shrinker.h~mm-shrinkers-provide-shrinkers-with-names +12 -2
@@ -75,6 +75,7 @@ struct shrinker {
 #endif
 #ifdef CONFIG_SHRINKER_DEBUG
 	int debugfs_id;
+	const char *name;
 	struct dentry *debugfs_entry;
 #endif
 	/* objs pending delete, per node */
@@ -92,9 +93,11 @@ struct shrinker {
  */
 #define SHRINKER_NONSLAB	(1 << 3)
 
-extern int prealloc_shrinker(struct shrinker *shrinker);
+extern int __printf(2, 3) prealloc_shrinker(struct shrinker *shrinker,
+					    const char *fmt, ...);
 extern void register_shrinker_prepared(struct shrinker *shrinker);
-extern int register_shrinker(struct shrinker *shrinker);
+extern int __printf(2, 3) register_shrinker(struct shrinker *shrinker,
+					    const char *fmt, ...);
 extern void unregister_shrinker(struct shrinker *shrinker);
 extern void free_prealloced_shrinker(struct shrinker *shrinker);
 extern void synchronize_shrinkers(void);
@@ -102,6 +105,8 @@ extern void synchronize_shrinkers(void);
 #ifdef CONFIG_SHRINKER_DEBUG
 extern int shrinker_debugfs_add(struct shrinker *shrinker);
 extern void shrinker_debugfs_remove(struct shrinker *shrinker);
+extern int __printf(2, 3) shrinker_debugfs_rename(struct shrinker *shrinker,
+						  const char *fmt, ...);
 #else /* CONFIG_SHRINKER_DEBUG */
 static inline int shrinker_debugfs_add(struct shrinker *shrinker)
 {
@@ -110,5 +115,10 @@ static inline int shrinker_debugfs_add(s
 static inline void shrinker_debugfs_remove(struct shrinker *shrinker)
 {
 }
+static inline __printf(2, 3)
+int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...)
+{
+	return 0;
+}
 #endif /* CONFIG_SHRINKER_DEBUG */
 #endif /* _LINUX_SHRINKER_H */
kernel/rcu/tree.c renamed from kernel/rcu/tree.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -4884,7 +4884,7 @@ static void __init kfree_rcu_batch_init(
 		INIT_DELAYED_WORK(&krcp->page_cache_work, fill_page_cache_func);
 		krcp->initialized = true;
 	}
-	if (register_shrinker(&kfree_rcu_shrinker))
+	if (register_shrinker(&kfree_rcu_shrinker, "rcu-kfree"))
 		pr_err("Failed to register kfree_rcu() shrinker!\n");
 }
 
mm/huge_memory.c renamed from mm/huge_memory.c~mm-shrinkers-provide-shrinkers-with-names +2 -2
@@ -423,10 +423,10 @@ static int __init hugepage_init(void)
 	if (err)
 		goto err_slab;
 
-	err = register_shrinker(&huge_zero_page_shrinker);
+	err = register_shrinker(&huge_zero_page_shrinker, "thp-zero");
 	if (err)
 		goto err_hzp_shrinker;
-	err = register_shrinker(&deferred_split_shrinker);
+	err = register_shrinker(&deferred_split_shrinker, "thp-deferred_split");
 	if (err)
 		goto err_split_shrinker;
 
mm/shrinker_debug.c renamed from mm/shrinker_debug.c~mm-shrinkers-provide-shrinkers-with-names +45 -2

69 lines not on this page · raw message

mm/vmscan.c renamed from mm/vmscan.c~mm-shrinkers-provide-shrinkers-with-names +55 -3

85 lines not on this page · raw message

mm/workingset.c renamed from mm/workingset.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -625,7 +625,7 @@ static int __init workingset_init(void)
 	pr_info("workingset: timestamp_bits=%d max_order=%d bucket_order=%u\n",
 	       timestamp_bits, max_order, bucket_order);
 
-	ret = prealloc_shrinker(&workingset_shadow_shrinker);
+	ret = prealloc_shrinker(&workingset_shadow_shrinker, "mm-shadow");
 	if (ret)
 		goto err;
 	ret = __list_lru_init(&shadow_nodes, true, &shadow_nodes_key,
mm/zsmalloc.c renamed from mm/zsmalloc.c~mm-shrinkers-provide-shrinkers-with-names +2 -1
@@ -2217,7 +2217,8 @@ static int zs_register_shrinker(struct z
 	pool->shrinker.batch = 0;
 	pool->shrinker.seeks = DEFAULT_SEEKS;
 
-	return register_shrinker(&pool->shrinker);
+	return register_shrinker(&pool->shrinker, "mm-zspool:%s",
+				 pool->name);
 }
 
 /**
net/sunrpc/auth.c renamed from net/sunrpc/auth.c~mm-shrinkers-provide-shrinkers-with-names +1 -1
@@ -874,7 +874,7 @@ int __init rpcauth_init_module(void)
 	err = rpc_init_authunix();
 	if (err < 0)
 		goto out1;
-	err = register_shrinker(&rpc_cred_shrinker);
+	err = register_shrinker(&rpc_cred_shrinker, "sunrpc_cred");
 	if (err < 0)
 		goto out2;
 	return 0;

_

Patches currently in -mm which might be from [email protected] are

mm-docs-document-shrinker-debugfs.patch tools-add-memcg_shrinkerpy.patch mm-shrinkers-add-scan-interface-for-shrinker-debugfs.patch mm-memcontrol-do-not-miss-memcg_max-events-for-enforced-allocations.patch