dquot: cleanup space allocation / freeing routines

Get rid of the alloc_space, free_space, reserve_space, claim_space and
release_rsv dquot operations - they are always called from the filesystem
and if a filesystem really needs their own (which none currently does)
it can just call into it's own routine directly.

Move shared logic into the common __dquot_alloc_space,
dquot_claim_space_nodirty and __dquot_free_space low-level methods,
and rationalize the wrappers around it to move as much as possible
code into the common block for CONFIG_QUOTA vs not.  Also rename
all these helpers to be named dquot_* instead of vfs_dq_*.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jan Kara <jack@suse.cz>

4 files changed, 18 insertions, 21 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index e11952404e02..9f607ea411c8 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1093,9 +1093,9 @@ void ext4_da_update_reserve_space(struct inode *inode,
 
         /* Update quota subsystem */
         if (quota_claim) {
-                vfs_dq_claim_block(inode, used);
+                dquot_claim_block(inode, used);
                 if (mdb_free)
-                        vfs_dq_release_reservation_block(inode, mdb_free);
+                        dquot_release_reservation_block(inode, mdb_free);
         } else {
                 /*
                  * We did fallocate with an offset that is already delayed
@@ -1106,8 +1106,8 @@ void ext4_da_update_reserve_space(struct inode *inode,
                  * that
                  */
                 if (allocated_meta_blocks)
-                        vfs_dq_claim_block(inode, allocated_meta_blocks);
-                vfs_dq_release_reservation_block(inode, mdb_free + used);
+                        dquot_claim_block(inode, allocated_meta_blocks);
+                dquot_release_reservation_block(inode, mdb_free + used);
         }
 
         /*
@@ -1836,6 +1836,7 @@ static int ext4_da_reserve_space(struct inode *inode, sector_t lblock)
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
         struct ext4_inode_info *ei = EXT4_I(inode);
         unsigned long md_needed, md_reserved;
+        int ret;
 
         /*
          * recalculate the amount of metadata blocks to reserve
@@ -1853,11 +1854,12 @@ repeat:
          * later. Real quota accounting is done at pages writeout
          * time.
          */
-        if (vfs_dq_reserve_block(inode, md_needed + 1))
-                return -EDQUOT;
+        ret = dquot_reserve_block(inode, md_needed + 1);
+        if (ret)
+                return ret;
 
         if (ext4_claim_free_blocks(sbi, md_needed + 1)) {
-                vfs_dq_release_reservation_block(inode, md_needed + 1);
+                dquot_release_reservation_block(inode, md_needed + 1);
                 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
                         yield();
                         goto repeat;
@@ -1914,7 +1916,7 @@ static void ext4_da_release_space(struct inode *inode, int to_free)
 
         spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
 
-        vfs_dq_release_reservation_block(inode, to_free);
+        dquot_release_reservation_block(inode, to_free);
 }
 
 static void ext4_da_page_release_reservation(struct page *page,
@@ -5641,7 +5643,7 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
  * i_size has been changed by generic_commit_write() and we thus need
  * to include the updated inode in the current transaction.
  *
- * Also, vfs_dq_alloc_block() will always dirty the inode when blocks
+ * Also, dquot_alloc_block() will always dirty the inode when blocks
  * are allocated to the file.
  *
  * If the inode is marked synchronous, we don't honour that here - doing
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index d34afad3e137..0b905781e8e6 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -4254,7 +4254,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
                         return 0;
                 }
                 reserv_blks = ar->len;
-                while (ar->len && vfs_dq_alloc_block(ar->inode, ar->len)) {
+                while (ar->len && dquot_alloc_block(ar->inode, ar->len)) {
                         ar->flags |= EXT4_MB_HINT_NOPREALLOC;
                         ar->len--;
                 }
@@ -4331,7 +4331,7 @@ out2:
         kmem_cache_free(ext4_ac_cachep, ac);
 out1:
         if (inquota && ar->len < inquota)
-                vfs_dq_free_block(ar->inode, inquota - ar->len);
+                dquot_free_block(ar->inode, inquota - ar->len);
 out3:
         if (!ar->len) {
                 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag)
@@ -4646,7 +4646,7 @@ do_more:
         sb->s_dirt = 1;
 error_return:
         if (freed)
-                vfs_dq_free_block(inode, freed);
+                dquot_free_block(inode, freed);
         brelse(bitmap_bh);
         ext4_std_error(sb, err);
         if (ac)
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 735c20d5fd56..fa8f4deda652 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1014,15 +1014,10 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
 static const struct dquot_operations ext4_quota_operations = {
         .initialize     = dquot_initialize,
         .drop           = dquot_drop,
-        .alloc_space    = dquot_alloc_space,
-        .reserve_space  = dquot_reserve_space,
-        .claim_space    = dquot_claim_space,
-        .release_rsv    = dquot_release_reserved_space,
 #ifdef CONFIG_QUOTA
         .get_reserved_space = ext4_get_reserved_space,
 #endif
         .alloc_inode    = dquot_alloc_inode,
-        .free_space     = dquot_free_space,
         .free_inode     = dquot_free_inode,
         .transfer       = dquot_transfer,
         .write_dquot    = ext4_write_dquot,
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index f3a2f7ed45aa..ab3a95ee5e7e 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -494,7 +494,7 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode,
                 error = ext4_handle_dirty_metadata(handle, inode, bh);
                 if (IS_SYNC(inode))
                         ext4_handle_sync(handle);
-                vfs_dq_free_block(inode, 1);
+                dquot_free_block(inode, 1);
                 ea_bdebug(bh, "refcount now=%d; releasing",
                           le32_to_cpu(BHDR(bh)->h_refcount));
                 if (ce)
@@ -787,8 +787,8 @@ inserted:
                         else {
                                 /* The old block is released after updating
                                    the inode. */
-                                error = -EDQUOT;
-                                if (vfs_dq_alloc_block(inode, 1))
+                                error = dquot_alloc_block(inode, 1);
+                                if (error)
                                         goto cleanup;
                                 error = ext4_journal_get_write_access(handle,
                                                                       new_bh);
@@ -876,7 +876,7 @@ cleanup:
         return error;
 
 cleanup_dquot:
-        vfs_dq_free_block(inode, 1);
+        dquot_free_block(inode, 1);
         goto cleanup;
 
 bad_block: