1 files changed, 32 insertions, 27 deletions

diff --git a/fs/super.c b/fs/super.c
index eae088f6aaae..1facd2c282e5 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -36,8 +36,8 @@
 #include "internal.h"
 
 
-LIST_HEAD(super_blocks);
-DEFINE_SPINLOCK(sb_lock);
+static LIST_HEAD(super_blocks);
+static DEFINE_SPINLOCK(sb_lock);
 
 static char *sb_writers_name[SB_FREEZE_LEVELS] = {
         "sb_writers",
@@ -75,10 +75,10 @@ static unsigned long super_cache_scan(struct shrinker *shrink,
                 return SHRINK_STOP;
 
         if (sb->s_op->nr_cached_objects)
-                fs_objects = sb->s_op->nr_cached_objects(sb, sc->nid);
+                fs_objects = sb->s_op->nr_cached_objects(sb, sc);
 
-        inodes = list_lru_count_node(&sb->s_inode_lru, sc->nid);
-        dentries = list_lru_count_node(&sb->s_dentry_lru, sc->nid);
+        inodes = list_lru_shrink_count(&sb->s_inode_lru, sc);
+        dentries = list_lru_shrink_count(&sb->s_dentry_lru, sc);
         total_objects = dentries + inodes + fs_objects + 1;
         if (!total_objects)
                 total_objects = 1;
@@ -86,19 +86,23 @@ static unsigned long super_cache_scan(struct shrinker *shrink,
         /* proportion the scan between the caches */
         dentries = mult_frac(sc->nr_to_scan, dentries, total_objects);
         inodes = mult_frac(sc->nr_to_scan, inodes, total_objects);
+        fs_objects = mult_frac(sc->nr_to_scan, fs_objects, total_objects);
 
         /*
          * prune the dcache first as the icache is pinned by it, then
          * prune the icache, followed by the filesystem specific caches
+         *
+         * Ensure that we always scan at least one object - memcg kmem
+         * accounting uses this to fully empty the caches.
          */
-        freed = prune_dcache_sb(sb, dentries, sc->nid);
-        freed += prune_icache_sb(sb, inodes, sc->nid);
+        sc->nr_to_scan = dentries + 1;
+        freed = prune_dcache_sb(sb, sc);
+        sc->nr_to_scan = inodes + 1;
+        freed += prune_icache_sb(sb, sc);
 
         if (fs_objects) {
-                fs_objects = mult_frac(sc->nr_to_scan, fs_objects,
-                                                                total_objects);
-                freed += sb->s_op->free_cached_objects(sb, fs_objects,
-                                                       sc->nid);
+                sc->nr_to_scan = fs_objects + 1;
+                freed += sb->s_op->free_cached_objects(sb, sc);
         }
 
         drop_super(sb);
@@ -118,17 +122,14 @@ static unsigned long super_cache_count(struct shrinker *shrink,
          * scalability bottleneck. The counts could get updated
          * between super_cache_count and super_cache_scan anyway.
          * Call to super_cache_count with shrinker_rwsem held
-         * ensures the safety of call to list_lru_count_node() and
+         * ensures the safety of call to list_lru_shrink_count() and
          * s_op->nr_cached_objects().
          */
         if (sb->s_op && sb->s_op->nr_cached_objects)
-                total_objects = sb->s_op->nr_cached_objects(sb,
-                                                 sc->nid);
+                total_objects = sb->s_op->nr_cached_objects(sb, sc);
 
-        total_objects += list_lru_count_node(&sb->s_dentry_lru,
-                                                 sc->nid);
-        total_objects += list_lru_count_node(&sb->s_inode_lru,
-                                                 sc->nid);
+        total_objects += list_lru_shrink_count(&sb->s_dentry_lru, sc);
+        total_objects += list_lru_shrink_count(&sb->s_inode_lru, sc);
 
         total_objects = vfs_pressure_ratio(total_objects);
         return total_objects;
@@ -185,15 +186,15 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags)
         }
         init_waitqueue_head(&s->s_writers.wait);
         init_waitqueue_head(&s->s_writers.wait_unfrozen);
+        s->s_bdi = &noop_backing_dev_info;
         s->s_flags = flags;
-        s->s_bdi = &default_backing_dev_info;
         INIT_HLIST_NODE(&s->s_instances);
         INIT_HLIST_BL_HEAD(&s->s_anon);
         INIT_LIST_HEAD(&s->s_inodes);
 
-        if (list_lru_init(&s->s_dentry_lru))
+        if (list_lru_init_memcg(&s->s_dentry_lru))
                 goto fail;
-        if (list_lru_init(&s->s_inode_lru))
+        if (list_lru_init_memcg(&s->s_inode_lru))
                 goto fail;
 
         init_rwsem(&s->s_umount);
@@ -229,7 +230,7 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags)
         s->s_shrink.scan_objects = super_cache_scan;
         s->s_shrink.count_objects = super_cache_count;
         s->s_shrink.batch = 1024;
-        s->s_shrink.flags = SHRINKER_NUMA_AWARE;
+        s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE;
         return s;
 
 fail:
@@ -284,6 +285,14 @@ void deactivate_locked_super(struct super_block *s)
                 unregister_shrinker(&s->s_shrink);
                 fs->kill_sb(s);
 
+                /*
+                 * Since list_lru_destroy() may sleep, we cannot call it from
+                 * put_super(), where we hold the sb_lock. Therefore we destroy
+                 * the lru lists right now.
+                 */
+                list_lru_destroy(&s->s_dentry_lru);
+                list_lru_destroy(&s->s_inode_lru);
+
                 put_filesystem(fs);
                 put_super(s);
         } else {
@@ -863,10 +872,7 @@ EXPORT_SYMBOL(free_anon_bdev);
 
 int set_anon_super(struct super_block *s, void *data)
 {
-        int error = get_anon_bdev(&s->s_dev);
-        if (!error)
-                s->s_bdi = &noop_backing_dev_info;
-        return error;
+        return get_anon_bdev(&s->s_dev);
 }
 
 EXPORT_SYMBOL(set_anon_super);
@@ -1111,7 +1117,6 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
         sb = root->d_sb;
         BUG_ON(!sb);
         WARN_ON(!sb->s_bdi);
-        WARN_ON(sb->s_bdi == &default_backing_dev_info);
         sb->s_flags |= MS_BORN;
 
         error = security_sb_kern_mount(sb, flags, secdata);