ext4: Add percpu dirty block accounting.

[mirror_ubuntu-bionic-kernel.git] / fs / ext4 / balloc.c

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 57909882c0846e6dad354566e59d9d905fd698a0..edef0023e6e604d9764aa82068c41e3f59b81e44 100644 (file)
--- 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));