4 files changed, 35 insertions, 22 deletions

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 722329cac98f..c2f41b4d00b9 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -1427,21 +1427,22 @@ __acquires(&lru_lock)
  * gfs2_dispose_glock_lru() above.
  */
 
-static void gfs2_scan_glock_lru(int nr)
+static long gfs2_scan_glock_lru(int nr)
 {
         struct gfs2_glock *gl;
         LIST_HEAD(skipped);
         LIST_HEAD(dispose);
+        long freed = 0;
 
         spin_lock(&lru_lock);
-        while(nr && !list_empty(&lru_list)) {
+        while ((nr-- >= 0) && !list_empty(&lru_list)) {
                 gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);
 
                 /* Test for being demotable */
                 if (!test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {
                         list_move(&gl->gl_lru, &dispose);
                         atomic_dec(&lru_count);
-                        nr--;
+                        freed++;
                         continue;
                 }
 
@@ -1451,23 +1452,28 @@ static void gfs2_scan_glock_lru(int nr)
         if (!list_empty(&dispose))
                 gfs2_dispose_glock_lru(&dispose);
         spin_unlock(&lru_lock);
+
+        return freed;
 }
 
-static int gfs2_shrink_glock_memory(struct shrinker *shrink,
-                                    struct shrink_control *sc)
+static unsigned long gfs2_glock_shrink_scan(struct shrinker *shrink,
+                                            struct shrink_control *sc)
 {
-        if (sc->nr_to_scan) {
-                if (!(sc->gfp_mask & __GFP_FS))
-                        return -1;
-                gfs2_scan_glock_lru(sc->nr_to_scan);
-        }
+        if (!(sc->gfp_mask & __GFP_FS))
+                return SHRINK_STOP;
+        return gfs2_scan_glock_lru(sc->nr_to_scan);
+}
 
-        return (atomic_read(&lru_count) / 100) * sysctl_vfs_cache_pressure;
+static unsigned long gfs2_glock_shrink_count(struct shrinker *shrink,
+                                             struct shrink_control *sc)
+{
+        return vfs_pressure_ratio(atomic_read(&lru_count));
 }
 
 static struct shrinker glock_shrinker = {
-        .shrink = gfs2_shrink_glock_memory,
         .seeks = DEFAULT_SEEKS,
+        .count_objects = gfs2_glock_shrink_count,
+        .scan_objects = gfs2_glock_shrink_scan,
 };
 
 /**
diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index 7b0f5043cf24..351586e24e30 100644
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -32,7 +32,8 @@
 struct workqueue_struct *gfs2_control_wq;
 
 static struct shrinker qd_shrinker = {
-        .shrink = gfs2_shrink_qd_memory,
+        .count_objects = gfs2_qd_shrink_count,
+        .scan_objects = gfs2_qd_shrink_scan,
         .seeks = DEFAULT_SEEKS,
 };
 
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 3768c2f40e43..db441359ee8c 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -75,17 +75,16 @@ static LIST_HEAD(qd_lru_list);
 static atomic_t qd_lru_count = ATOMIC_INIT(0);
 static DEFINE_SPINLOCK(qd_lru_lock);
 
-int gfs2_shrink_qd_memory(struct shrinker *shrink, struct shrink_control *sc)
+unsigned long gfs2_qd_shrink_scan(struct shrinker *shrink,
+                                  struct shrink_control *sc)
 {
         struct gfs2_quota_data *qd;
         struct gfs2_sbd *sdp;
         int nr_to_scan = sc->nr_to_scan;
-
-        if (nr_to_scan == 0)
-                goto out;
+        long freed = 0;
 
         if (!(sc->gfp_mask & __GFP_FS))
-                return -1;
+                return SHRINK_STOP;
 
         spin_lock(&qd_lru_lock);
         while (nr_to_scan && !list_empty(&qd_lru_list)) {
@@ -110,11 +109,16 @@ int gfs2_shrink_qd_memory(struct shrinker *shrink, struct shrink_control *sc)
                 kmem_cache_free(gfs2_quotad_cachep, qd);
                 spin_lock(&qd_lru_lock);
                 nr_to_scan--;
+                freed++;
         }
         spin_unlock(&qd_lru_lock);
+        return freed;
+}
 
-out:
-        return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;
+unsigned long gfs2_qd_shrink_count(struct shrinker *shrink,
+                                   struct shrink_control *sc)
+{
+        return vfs_pressure_ratio(atomic_read(&qd_lru_count));
 }
 
 static u64 qd2index(struct gfs2_quota_data *qd)
diff --git a/fs/gfs2/quota.h b/fs/gfs2/quota.h
index 4f5e6e44ed83..0f64d9deb1b0 100644
--- a/fs/gfs2/quota.h
+++ b/fs/gfs2/quota.h
@@ -53,8 +53,10 @@ static inline int gfs2_quota_lock_check(struct gfs2_inode *ip)
         return ret;
 }
 
-extern int gfs2_shrink_qd_memory(struct shrinker *shrink,
-                                 struct shrink_control *sc);
+extern unsigned long gfs2_qd_shrink_count(struct shrinker *shrink,
+                                          struct shrink_control *sc);
+extern unsigned long gfs2_qd_shrink_scan(struct shrinker *shrink,
+                                         struct shrink_control *sc);
 extern const struct quotactl_ops gfs2_quotactl_ops;
 
 #endif /* __QUOTA_DOT_H__ */