ext4: rename ext4_has_free_blocks() to ext4_has_free_clusters()

Rename the function so it is more clear what is going on.  Also rename
the various variables so it's clearer what's happening.

Also fix a missing blocks to cluster conversion when reading the
number of reserved blocks for root.

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

3 files changed, 27 insertions, 26 deletions

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index af0c5357e35a..f6dba4505f1c 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -403,42 +403,43 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
 }
 
 /**
- * ext4_has_free_blocks()
+ * ext4_has_free_clusters()
  * @sbi:        in-core super block structure.
- * @nblocks:    number of needed blocks
+ * @nclusters:  number of needed blocks
+ * @flags:      flags from ext4_mb_new_blocks()
  *
- * Check if filesystem has nblocks free & available for allocation.
+ * Check if filesystem has nclusters free & available for allocation.
  * On success return 1, return 0 on failure.
  */
-static int ext4_has_free_blocks(struct ext4_sb_info *sbi,
-                                s64 nblocks, unsigned int flags)
+static int ext4_has_free_clusters(struct ext4_sb_info *sbi,
+                                  s64 nclusters, unsigned int flags)
 {
-        s64 free_blocks, dirty_blocks, root_blocks;
+        s64 free_clusters, dirty_clusters, root_clusters;
         struct percpu_counter *fcc = &sbi->s_freeclusters_counter;
-        struct percpu_counter *dbc = &sbi->s_dirtyclusters_counter;
+        struct percpu_counter *dcc = &sbi->s_dirtyclusters_counter;
 
-        free_blocks  = percpu_counter_read_positive(fcc);
-        dirty_blocks = percpu_counter_read_positive(dbc);
-        root_blocks = ext4_r_blocks_count(sbi->s_es);
+        free_clusters  = percpu_counter_read_positive(fcc);
+        dirty_clusters = percpu_counter_read_positive(dcc);
+        root_clusters = EXT4_B2C(sbi, ext4_r_blocks_count(sbi->s_es));
 
-        if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
-                                                EXT4_FREEBLOCKS_WATERMARK) {
-                free_blocks  = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc));
-                dirty_blocks = percpu_counter_sum_positive(dbc);
+        if (free_clusters - (nclusters + root_clusters + dirty_clusters) <
+                                        EXT4_FREECLUSTERS_WATERMARK) {
+                free_clusters  = EXT4_C2B(sbi, percpu_counter_sum_positive(fcc));
+                dirty_clusters = percpu_counter_sum_positive(dcc);
         }
-        /* Check whether we have space after
-         * accounting for current dirty blocks & root reserved blocks.
+        /* Check whether we have space after accounting for current
+         * dirty clusters & root reserved clusters.
          */
-        if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))
+        if (free_clusters >= ((root_clusters + nclusters) + dirty_clusters))
                 return 1;
 
-        /* Hm, nope.  Are (enough) root reserved blocks available? */
+        /* Hm, nope.  Are (enough) root reserved clusters available? */
         if (sbi->s_resuid == current_fsuid() ||
             ((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
             capable(CAP_SYS_RESOURCE) ||
                 (flags & EXT4_MB_USE_ROOT_BLOCKS)) {
 
-                if (free_blocks >= (nblocks + dirty_blocks))
+                if (free_clusters >= (nclusters + dirty_clusters))
                         return 1;
         }
 
@@ -448,7 +449,7 @@ static int ext4_has_free_blocks(struct ext4_sb_info *sbi,
 int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
                              s64 nclusters, unsigned int flags)
 {
-        if (ext4_has_free_blocks(sbi, nclusters, flags)) {
+        if (ext4_has_free_clusters(sbi, nclusters, flags)) {
                 percpu_counter_add(&sbi->s_dirtyclusters_counter, nclusters);
                 return 0;
         } else
@@ -469,7 +470,7 @@ int ext4_claim_free_clusters(struct ext4_sb_info *sbi,
  */
 int ext4_should_retry_alloc(struct super_block *sb, int *retries)
 {
-        if (!ext4_has_free_blocks(EXT4_SB(sb), 1, 0) ||
+        if (!ext4_has_free_clusters(EXT4_SB(sb), 1, 0) ||
             (*retries)++ > 3 ||
             !EXT4_SB(sb)->s_journal)
                 return 0;
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index f97638634e34..21ea65d8bd46 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2103,13 +2103,13 @@ do {								\
 } while (0)
 
 #ifdef CONFIG_SMP
-/* Each CPU can accumulate percpu_counter_batch blocks in their local
- * counters. So we need to make sure we have free blocks more
+/* Each CPU can accumulate percpu_counter_batch clusters in their local
+ * counters. So we need to make sure we have free clusters more
  * than percpu_counter_batch  * nr_cpu_ids. Also add a window of 4 times.
  */
-#define EXT4_FREEBLOCKS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))
+#define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))
 #else
-#define EXT4_FREEBLOCKS_WATERMARK 0
+#define EXT4_FREECLUSTERS_WATERMARK 0
 #endif
 
 static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 557c34ffa05b..88dc63a01756 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2255,7 +2255,7 @@ static int ext4_nonda_switch(struct super_block *sb)
                 percpu_counter_read_positive(&sbi->s_freeclusters_counter));
         dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
         if (2 * free_blocks < 3 * dirty_blocks ||
-                free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) {
+                free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
                 /*
                  * free block count is less than 150% of dirty blocks
                  * or free blocks is less than watermark