ext4: Add percpu dirty block accounting.

This patch adds dirty block accounting using percpu_counters.  Delayed
allocation block reservation is now done by updating dirty block
counter.  In a later patch we switch to non delalloc mode if the
filesystem free blocks is greater than 150% of total filesystem dirty
blocks

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Mingming Cao<cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 40 insertions, 22 deletions

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 57909882c084..edef0023e6e6 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -1605,26 +1605,38 @@ out:
 int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
                                                 ext4_fsblk_t nblocks)
 {
-        s64 free_blocks;
+        s64 free_blocks, dirty_blocks;
         ext4_fsblk_t root_blocks = 0;
         struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
+        struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
 
-        free_blocks = percpu_counter_read(fbc);
+        free_blocks  = percpu_counter_read_positive(fbc);
+        dirty_blocks = percpu_counter_read_positive(dbc);
 
         if (!capable(CAP_SYS_RESOURCE) &&
                 sbi->s_resuid != current->fsuid &&
                 (sbi->s_resgid == 0 || !in_group_p(sbi->s_resgid)))
                 root_blocks = ext4_r_blocks_count(sbi->s_es);
 
-        if (free_blocks - (nblocks + root_blocks) < EXT4_FREEBLOCKS_WATERMARK)
-                free_blocks = percpu_counter_sum(&sbi->s_freeblocks_counter);
-
-        if (free_blocks < (root_blocks + nblocks))
+        if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
+                                                EXT4_FREEBLOCKS_WATERMARK) {
+                free_blocks  = percpu_counter_sum(fbc);
+                dirty_blocks = percpu_counter_sum(dbc);
+                if (dirty_blocks < 0) {
+                        printk(KERN_CRIT "Dirty block accounting "
+                                        "went wrong %lld\n",
+                                        dirty_blocks);
+                }
+        }
+        /* Check whether we have space after
+         * accounting for current dirty blocks
+         */
+        if (free_blocks < ((s64)(root_blocks + nblocks) + dirty_blocks))
                 /* we don't have free space */
                 return -ENOSPC;
 
-        /* reduce fs free blocks counter */
-        percpu_counter_sub(fbc, nblocks);
+        /* Add the blocks to nblocks */
+        percpu_counter_add(dbc, nblocks);
         return 0;
 }
 
@@ -1640,23 +1652,28 @@ int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
 ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi,
                                                 ext4_fsblk_t nblocks)
 {
-        ext4_fsblk_t free_blocks;
+        ext4_fsblk_t free_blocks, dirty_blocks;
         ext4_fsblk_t root_blocks = 0;
+        struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
+        struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
 
-        free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
+        free_blocks  = percpu_counter_read_positive(fbc);
+        dirty_blocks = percpu_counter_read_positive(dbc);
 
         if (!capable(CAP_SYS_RESOURCE) &&
                 sbi->s_resuid != current->fsuid &&
                 (sbi->s_resgid == 0 || !in_group_p(sbi->s_resgid)))
                 root_blocks = ext4_r_blocks_count(sbi->s_es);
 
-        if (free_blocks - (nblocks + root_blocks) < EXT4_FREEBLOCKS_WATERMARK)
-                free_blocks = percpu_counter_sum_positive(&sbi->s_freeblocks_counter);
-
-        if (free_blocks <= root_blocks)
+        if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
+                                                EXT4_FREEBLOCKS_WATERMARK) {
+                free_blocks  = percpu_counter_sum_positive(fbc);
+                dirty_blocks = percpu_counter_sum_positive(dbc);
+        }
+        if (free_blocks <= (root_blocks + dirty_blocks))
                 /* we don't have free space */
                 return 0;
-        if (free_blocks - root_blocks < nblocks)
+        if (free_blocks - (root_blocks + dirty_blocks) < nblocks)
                 return free_blocks - root_blocks;
         return nblocks;
 }
@@ -1943,13 +1960,14 @@ allocated:
         le16_add_cpu(&gdp->bg_free_blocks_count, -num);
         gdp->bg_checksum = ext4_group_desc_csum(sbi, group_no, gdp);
         spin_unlock(sb_bgl_lock(sbi, group_no));
-        if (!EXT4_I(inode)->i_delalloc_reserved_flag && (*count != num)) {
-                /*
-                 * we allocated less blocks than we
-                 * claimed. Add the difference back.
-                 */
-                percpu_counter_add(&sbi->s_freeblocks_counter, *count - num);
-        }
+        percpu_counter_sub(&sbi->s_freeblocks_counter, num);
+        /*
+         * Now reduce the dirty block count also. Should not go negative
+         */
+        if (!EXT4_I(inode)->i_delalloc_reserved_flag)
+                percpu_counter_sub(&sbi->s_dirtyblocks_counter, *count);
+        else
+                percpu_counter_sub(&sbi->s_dirtyblocks_counter, num);
         if (sbi->s_log_groups_per_flex) {
                 ext4_group_t flex_group = ext4_flex_group(sbi, group_no);
                 spin_lock(sb_bgl_lock(sbi, flex_group));