dquot: cleanup space allocation / freeing routines
Christoph Hellwig [Wed, 3 Mar 2010 14:05:00 +0000 (09:05 -0500)]
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>

29 files changed:
Documentation/filesystems/Locking
fs/ext2/balloc.c
fs/ext2/xattr.c
fs/ext3/balloc.c
fs/ext3/inode.c
fs/ext3/super.c
fs/ext3/xattr.c
fs/ext4/inode.c
fs/ext4/mballoc.c
fs/ext4/super.c
fs/ext4/xattr.c
fs/jfs/jfs_dtree.c
fs/jfs/jfs_extent.c
fs/jfs/jfs_xtree.c
fs/jfs/xattr.c
fs/ocfs2/alloc.c
fs/ocfs2/aops.c
fs/ocfs2/dir.c
fs/ocfs2/file.c
fs/ocfs2/namei.c
fs/ocfs2/quota_global.c
fs/quota/dquot.c
fs/reiserfs/bitmap.c
fs/reiserfs/stree.c
fs/reiserfs/super.c
fs/udf/balloc.c
fs/ufs/balloc.c
include/linux/quota.h
include/linux/quotaops.h

index 18b9d0c..1192fde 100644 (file)
@@ -462,9 +462,7 @@ in sys_read() and friends.
 prototypes:
        int (*initialize) (struct inode *, int);
        int (*drop) (struct inode *);
-       int (*alloc_space) (struct inode *, qsize_t, int);
        int (*alloc_inode) (const struct inode *, unsigned long);
-       int (*free_space) (struct inode *, qsize_t);
        int (*free_inode) (const struct inode *, unsigned long);
        int (*transfer) (struct inode *, struct iattr *);
        int (*write_dquot) (struct dquot *);
@@ -481,9 +479,7 @@ What filesystem should expect from the generic quota functions:
                FS recursion    Held locks when called
 initialize:    yes             maybe dqonoff_sem
 drop:          yes             -
-alloc_space:   ->mark_dirty()  -
 alloc_inode:   ->mark_dirty()  -
-free_space:    ->mark_dirty()  -
 free_inode:    ->mark_dirty()  -
 transfer:      yes             -
 write_dquot:   yes             dqonoff_sem or dqptr_sem
@@ -495,7 +491,7 @@ write_info: yes             dqonoff_sem
 FS recursion means calling ->quota_read() and ->quota_write() from superblock
 operations.
 
-->alloc_space(), ->alloc_inode(), ->free_space(), ->free_inode() are called
+->alloc_inode(), ->free_inode() are called
 only directly by the filesystem and do not call any fs functions only
 the ->mark_dirty() operation.
 
index 7f8d2e5..1d081f0 100644 (file)
@@ -570,7 +570,7 @@ do_more:
 error_return:
        brelse(bitmap_bh);
        release_blocks(sb, freed);
-       vfs_dq_free_block(inode, freed);
+       dquot_free_block(inode, freed);
 }
 
 /**
@@ -1236,6 +1236,7 @@ ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
        unsigned short windowsz = 0;
        unsigned long ngroups;
        unsigned long num = *count;
+       int ret;
 
        *errp = -ENOSPC;
        sb = inode->i_sb;
@@ -1247,8 +1248,9 @@ ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
        /*
         * Check quota for allocation of this block.
         */
-       if (vfs_dq_alloc_block(inode, num)) {
-               *errp = -EDQUOT;
+       ret = dquot_alloc_block(inode, num);
+       if (ret) {
+               *errp = ret;
                return 0;
        }
 
@@ -1409,7 +1411,7 @@ allocated:
 
        *errp = 0;
        brelse(bitmap_bh);
-       vfs_dq_free_block(inode, *count-num);
+       dquot_free_block(inode, *count-num);
        *count = num;
        return ret_block;
 
@@ -1420,7 +1422,7 @@ out:
         * Undo the block allocation
         */
        if (!performed_allocation)
-               vfs_dq_free_block(inode, *count);
+               dquot_free_block(inode, *count);
        brelse(bitmap_bh);
        return 0;
 }
index 904f006..e44dc92 100644 (file)
@@ -644,8 +644,8 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                                   the inode.  */
                                ea_bdebug(new_bh, "reusing block");
 
-                               error = -EDQUOT;
-                               if (vfs_dq_alloc_block(inode, 1)) {
+                               error = dquot_alloc_block(inode, 1);
+                               if (error) {
                                        unlock_buffer(new_bh);
                                        goto cleanup;
                                }
@@ -702,7 +702,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                 * as if nothing happened and cleanup the unused block */
                if (error && error != -ENOSPC) {
                        if (new_bh && new_bh != old_bh)
-                               vfs_dq_free_block(inode, 1);
+                               dquot_free_block(inode, 1);
                        goto cleanup;
                }
        } else
@@ -734,7 +734,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                        le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
                        if (ce)
                                mb_cache_entry_release(ce);
-                       vfs_dq_free_block(inode, 1);
+                       dquot_free_block(inode, 1);
                        mark_buffer_dirty(old_bh);
                        ea_bdebug(old_bh, "refcount now=%d",
                                le32_to_cpu(HDR(old_bh)->h_refcount));
@@ -797,7 +797,7 @@ ext2_xattr_delete_inode(struct inode *inode)
                mark_buffer_dirty(bh);
                if (IS_SYNC(inode))
                        sync_dirty_buffer(bh);
-               vfs_dq_free_block(inode, 1);
+               dquot_free_block(inode, 1);
        }
        EXT2_I(inode)->i_file_acl = 0;
 
index 27967f9..161da2d 100644 (file)
@@ -676,7 +676,7 @@ void ext3_free_blocks(handle_t *handle, struct inode *inode,
        }
        ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
        if (dquot_freed_blocks)
-               vfs_dq_free_block(inode, dquot_freed_blocks);
+               dquot_free_block(inode, dquot_freed_blocks);
        return;
 }
 
@@ -1502,8 +1502,9 @@ ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
        /*
         * Check quota for allocation of this block.
         */
-       if (vfs_dq_alloc_block(inode, num)) {
-               *errp = -EDQUOT;
+       err = dquot_alloc_block(inode, num);
+       if (err) {
+               *errp = err;
                return 0;
        }
 
@@ -1713,7 +1714,7 @@ allocated:
 
        *errp = 0;
        brelse(bitmap_bh);
-       vfs_dq_free_block(inode, *count-num);
+       dquot_free_block(inode, *count-num);
        *count = num;
        return ret_block;
 
@@ -1728,7 +1729,7 @@ out:
         * Undo the block allocation
         */
        if (!performed_allocation)
-               vfs_dq_free_block(inode, *count);
+               dquot_free_block(inode, *count);
        brelse(bitmap_bh);
        return 0;
 }
index eda9121..20f02d6 100644 (file)
@@ -3336,7 +3336,7 @@ int ext3_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_space() will always dirty the inode when blocks
+ * Also, dquot_alloc_space() 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
index 5c54e5f..8c13910 100644 (file)
@@ -752,9 +752,7 @@ static ssize_t ext3_quota_write(struct super_block *sb, int type,
 static const struct dquot_operations ext3_quota_operations = {
        .initialize     = dquot_initialize,
        .drop           = dquot_drop,
-       .alloc_space    = dquot_alloc_space,
        .alloc_inode    = dquot_alloc_inode,
-       .free_space     = dquot_free_space,
        .free_inode     = dquot_free_inode,
        .transfer       = dquot_transfer,
        .write_dquot    = ext3_write_dquot,
index 2d2fb2a..534a94c 100644 (file)
@@ -500,7 +500,7 @@ ext3_xattr_release_block(handle_t *handle, struct inode *inode,
                error = ext3_journal_dirty_metadata(handle, bh);
                if (IS_SYNC(inode))
                        handle->h_sync = 1;
-               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)
@@ -775,8 +775,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 = ext3_journal_get_write_access(handle,
                                                                      new_bh);
@@ -850,7 +850,7 @@ cleanup:
        return error;
 
 cleanup_dquot:
-       vfs_dq_free_block(inode, 1);
+       dquot_free_block(inode, 1);
        goto cleanup;
 
 bad_block:
index e119524..9f607ea 100644 (file)
@@ -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
index d34afad..0b90578 100644 (file)
@@ -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)
index 735c20d..fa8f4de 100644 (file)
@@ -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,
index f3a2f7e..ab3a95e 100644 (file)
@@ -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:
index 925871e..0e4623b 100644 (file)
@@ -381,10 +381,10 @@ static u32 add_index(tid_t tid, struct inode *ip, s64 bn, int slot)
                 * It's time to move the inline table to an external
                 * page and begin to build the xtree
                 */
-               if (vfs_dq_alloc_block(ip, sbi->nbperpage))
+               if (dquot_alloc_block(ip, sbi->nbperpage))
                        goto clean_up;
                if (dbAlloc(ip, 0, sbi->nbperpage, &xaddr)) {
-                       vfs_dq_free_block(ip, sbi->nbperpage);
+                       dquot_free_block(ip, sbi->nbperpage);
                        goto clean_up;
                }
 
@@ -408,7 +408,7 @@ static u32 add_index(tid_t tid, struct inode *ip, s64 bn, int slot)
                        memcpy(&jfs_ip->i_dirtable, temp_table,
                               sizeof (temp_table));
                        dbFree(ip, xaddr, sbi->nbperpage);
-                       vfs_dq_free_block(ip, sbi->nbperpage);
+                       dquot_free_block(ip, sbi->nbperpage);
                        goto clean_up;
                }
                ip->i_size = PSIZE;
@@ -1027,10 +1027,9 @@ static int dtSplitUp(tid_t tid,
                        n = xlen;
 
                /* Allocate blocks to quota. */
-               if (vfs_dq_alloc_block(ip, n)) {
-                       rc = -EDQUOT;
+               rc = dquot_alloc_block(ip, n);
+               if (rc)
                        goto extendOut;
-               }
                quota_allocation += n;
 
                if ((rc = dbReAlloc(sbi->ipbmap, xaddr, (s64) xlen,
@@ -1308,7 +1307,7 @@ static int dtSplitUp(tid_t tid,
 
        /* Rollback quota allocation */
        if (rc && quota_allocation)
-               vfs_dq_free_block(ip, quota_allocation);
+               dquot_free_block(ip, quota_allocation);
 
       dtSplitUp_Exit:
 
@@ -1369,9 +1368,10 @@ static int dtSplitPage(tid_t tid, struct inode *ip, struct dtsplit * split,
                return -EIO;
 
        /* Allocate blocks to quota. */
-       if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
+       rc = dquot_alloc_block(ip, lengthPXD(pxd));
+       if (rc) {
                release_metapage(rmp);
-               return -EDQUOT;
+               return rc;
        }
 
        jfs_info("dtSplitPage: ip:0x%p smp:0x%p rmp:0x%p", ip, smp, rmp);
@@ -1892,6 +1892,7 @@ static int dtSplitRoot(tid_t tid,
        struct dt_lock *dtlck;
        struct tlock *tlck;
        struct lv *lv;
+       int rc;
 
        /* get split root page */
        smp = split->mp;
@@ -1916,9 +1917,10 @@ static int dtSplitRoot(tid_t tid,
        rp = rmp->data;
 
        /* Allocate blocks to quota. */
-       if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
+       rc = dquot_alloc_block(ip, lengthPXD(pxd));
+       if (rc) {
                release_metapage(rmp);
-               return -EDQUOT;
+               return rc;
        }
 
        BT_MARK_DIRTY(rmp, ip);
@@ -2287,7 +2289,7 @@ static int dtDeleteUp(tid_t tid, struct inode *ip,
        xlen = lengthPXD(&fp->header.self);
 
        /* Free quota allocation. */
-       vfs_dq_free_block(ip, xlen);
+       dquot_free_block(ip, xlen);
 
        /* free/invalidate its buffer page */
        discard_metapage(fmp);
@@ -2363,7 +2365,7 @@ static int dtDeleteUp(tid_t tid, struct inode *ip,
                                xlen = lengthPXD(&p->header.self);
 
                                /* Free quota allocation */
-                               vfs_dq_free_block(ip, xlen);
+                               dquot_free_block(ip, xlen);
 
                                /* free/invalidate its buffer page */
                                discard_metapage(mp);
index 41d6045..5d3bbd1 100644 (file)
@@ -141,10 +141,11 @@ extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
        }
 
        /* Allocate blocks to quota. */
-       if (vfs_dq_alloc_block(ip, nxlen)) {
+       rc = dquot_alloc_block(ip, nxlen);
+       if (rc) {
                dbFree(ip, nxaddr, (s64) nxlen);
                mutex_unlock(&JFS_IP(ip)->commit_mutex);
-               return -EDQUOT;
+               return rc;
        }
 
        /* determine the value of the extent flag */
@@ -164,7 +165,7 @@ extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
         */
        if (rc) {
                dbFree(ip, nxaddr, nxlen);
-               vfs_dq_free_block(ip, nxlen);
+               dquot_free_block(ip, nxlen);
                mutex_unlock(&JFS_IP(ip)->commit_mutex);
                return (rc);
        }
@@ -256,10 +257,11 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
                goto exit;
 
        /* Allocat blocks to quota. */
-       if (vfs_dq_alloc_block(ip, nxlen)) {
+       rc = dquot_alloc_block(ip, nxlen);
+       if (rc) {
                dbFree(ip, nxaddr, (s64) nxlen);
                mutex_unlock(&JFS_IP(ip)->commit_mutex);
-               return -EDQUOT;
+               return rc;
        }
 
        delta = nxlen - xlen;
@@ -297,7 +299,7 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
                /* extend the extent */
                if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
                        dbFree(ip, xaddr + xlen, delta);
-                       vfs_dq_free_block(ip, nxlen);
+                       dquot_free_block(ip, nxlen);
                        goto exit;
                }
        } else {
@@ -308,7 +310,7 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
                 */
                if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
                        dbFree(ip, nxaddr, nxlen);
-                       vfs_dq_free_block(ip, nxlen);
+                       dquot_free_block(ip, nxlen);
                        goto exit;
                }
        }
index d654a64..6c50871 100644 (file)
@@ -585,10 +585,10 @@ int xtInsert(tid_t tid,           /* transaction id */
                        hint = addressXAD(xad) + lengthXAD(xad) - 1;
                } else
                        hint = 0;
-               if ((rc = vfs_dq_alloc_block(ip, xlen)))
+               if ((rc = dquot_alloc_block(ip, xlen)))
                        goto out;
                if ((rc = dbAlloc(ip, hint, (s64) xlen, &xaddr))) {
-                       vfs_dq_free_block(ip, xlen);
+                       dquot_free_block(ip, xlen);
                        goto out;
                }
        }
@@ -617,7 +617,7 @@ int xtInsert(tid_t tid,             /* transaction id */
                        /* undo data extent allocation */
                        if (*xaddrp == 0) {
                                dbFree(ip, xaddr, (s64) xlen);
-                               vfs_dq_free_block(ip, xlen);
+                               dquot_free_block(ip, xlen);
                        }
                        return rc;
                }
@@ -985,10 +985,9 @@ xtSplitPage(tid_t tid, struct inode *ip,
        rbn = addressPXD(pxd);
 
        /* Allocate blocks to quota. */
-       if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
-               rc = -EDQUOT;
+       rc = dquot_alloc_block(ip, lengthPXD(pxd));
+       if (rc)
                goto clean_up;
-       }
 
        quota_allocation += lengthPXD(pxd);
 
@@ -1195,7 +1194,7 @@ xtSplitPage(tid_t tid, struct inode *ip,
 
        /* Rollback quota allocation. */
        if (quota_allocation)
-               vfs_dq_free_block(ip, quota_allocation);
+               dquot_free_block(ip, quota_allocation);
 
        return (rc);
 }
@@ -1235,6 +1234,7 @@ xtSplitRoot(tid_t tid,
        struct pxdlist *pxdlist;
        struct tlock *tlck;
        struct xtlock *xtlck;
+       int rc;
 
        sp = &JFS_IP(ip)->i_xtroot;
 
@@ -1252,9 +1252,10 @@ xtSplitRoot(tid_t tid,
                return -EIO;
 
        /* Allocate blocks to quota. */
-       if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
+       rc = dquot_alloc_block(ip, lengthPXD(pxd));
+       if (rc) {
                release_metapage(rmp);
-               return -EDQUOT;
+               return rc;
        }
 
        jfs_info("xtSplitRoot: ip:0x%p rmp:0x%p", ip, rmp);
@@ -3680,7 +3681,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
                ip->i_size = newsize;
 
        /* update quota allocation to reflect freed blocks */
-       vfs_dq_free_block(ip, nfreed);
+       dquot_free_block(ip, nfreed);
 
        /*
         * free tlock of invalidated pages
index fad3645..1f594ab 100644 (file)
@@ -260,14 +260,14 @@ static int ea_write(struct inode *ip, struct jfs_ea_list *ealist, int size,
        nblocks = (size + (sb->s_blocksize - 1)) >> sb->s_blocksize_bits;
 
        /* Allocate new blocks to quota. */
-       if (vfs_dq_alloc_block(ip, nblocks)) {
-               return -EDQUOT;
-       }
+       rc = dquot_alloc_block(ip, nblocks);
+       if (rc)
+               return rc;
 
        rc = dbAlloc(ip, INOHINT(ip), nblocks, &blkno);
        if (rc) {
                /*Rollback quota allocation. */
-               vfs_dq_free_block(ip, nblocks);
+               dquot_free_block(ip, nblocks);
                return rc;
        }
 
@@ -332,7 +332,7 @@ static int ea_write(struct inode *ip, struct jfs_ea_list *ealist, int size,
 
       failed:
        /* Rollback quota allocation. */
-       vfs_dq_free_block(ip, nblocks);
+       dquot_free_block(ip, nblocks);
 
        dbFree(ip, blkno, nblocks);
        return rc;
@@ -538,7 +538,8 @@ static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
 
        if (blocks_needed > current_blocks) {
                /* Allocate new blocks to quota. */
-               if (vfs_dq_alloc_block(inode, blocks_needed))
+               rc = dquot_alloc_block(inode, blocks_needed);
+               if (rc)
                        return -EDQUOT;
 
                quota_allocation = blocks_needed;
@@ -602,7 +603,7 @@ static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
       clean_up:
        /* Rollback quota allocation */
        if (quota_allocation)
-               vfs_dq_free_block(inode, quota_allocation);
+               dquot_free_block(inode, quota_allocation);
 
        return (rc);
 }
@@ -677,7 +678,7 @@ static int ea_put(tid_t tid, struct inode *inode, struct ea_buffer *ea_buf,
 
        /* If old blocks exist, they must be removed from quota allocation. */
        if (old_blocks)
-               vfs_dq_free_block(inode, old_blocks);
+               dquot_free_block(inode, old_blocks);
 
        inode->i_ctime = CURRENT_TIME;
 
index d17bdc7..20538dd 100644 (file)
@@ -5712,7 +5712,7 @@ int ocfs2_remove_btree_range(struct inode *inode,
                goto out;
        }
 
-       vfs_dq_free_space_nodirty(inode,
+       dquot_free_space_nodirty(inode,
                                  ocfs2_clusters_to_bytes(inode->i_sb, len));
 
        ret = ocfs2_remove_extent(handle, et, cpos, len, meta_ac, dealloc);
@@ -6935,7 +6935,7 @@ static int ocfs2_do_truncate(struct ocfs2_super *osb,
                goto bail;
        }
 
-       vfs_dq_free_space_nodirty(inode,
+       dquot_free_space_nodirty(inode,
                        ocfs2_clusters_to_bytes(osb->sb, clusters_to_del));
        spin_lock(&OCFS2_I(inode)->ip_lock);
        OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters) -
@@ -7300,11 +7300,10 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
                unsigned int page_end;
                u64 phys;
 
-               if (vfs_dq_alloc_space_nodirty(inode,
-                                      ocfs2_clusters_to_bytes(osb->sb, 1))) {
-                       ret = -EDQUOT;
+               ret = dquot_alloc_space_nodirty(inode,
+                                      ocfs2_clusters_to_bytes(osb->sb, 1));
+               if (ret)
                        goto out_commit;
-               }
                did_quota = 1;
 
                ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off,
@@ -7380,7 +7379,7 @@ int ocfs2_convert_inline_data_to_extents(struct inode *inode,
 
 out_commit:
        if (ret < 0 && did_quota)
-               vfs_dq_free_space_nodirty(inode,
+               dquot_free_space_nodirty(inode,
                                          ocfs2_clusters_to_bytes(osb->sb, 1));
 
        ocfs2_commit_trans(osb, handle);
index 7e9df11..7d04c17 100644 (file)
@@ -1763,10 +1763,11 @@ int ocfs2_write_begin_nolock(struct address_space *mapping,
 
        wc->w_handle = handle;
 
-       if (clusters_to_alloc && vfs_dq_alloc_space_nodirty(inode,
-                       ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc))) {
-               ret = -EDQUOT;
-               goto out_commit;
+       if (clusters_to_alloc) {
+               ret = dquot_alloc_space_nodirty(inode,
+                       ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
+               if (ret)
+                       goto out_commit;
        }
        /*
         * We don't want this to fail in ocfs2_write_end(), so do it
@@ -1809,7 +1810,7 @@ success:
        return 0;
 out_quota:
        if (clusters_to_alloc)
-               vfs_dq_free_space(inode,
+               dquot_free_space(inode,
                          ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
 out_commit:
        ocfs2_commit_trans(osb, handle);
index 28c3ec2..a63ea4d 100644 (file)
@@ -2964,12 +2964,10 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
                goto out;
        }
 
-       if (vfs_dq_alloc_space_nodirty(dir,
-                               ocfs2_clusters_to_bytes(osb->sb,
-                                                       alloc + dx_alloc))) {
-               ret = -EDQUOT;
+       ret = dquot_alloc_space_nodirty(dir,
+               ocfs2_clusters_to_bytes(osb->sb, alloc + dx_alloc));
+       if (ret)
                goto out_commit;
-       }
        did_quota = 1;
 
        if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
@@ -3178,7 +3176,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
 
 out_commit:
        if (ret < 0 && did_quota)
-               vfs_dq_free_space_nodirty(dir, bytes_allocated);
+               dquot_free_space_nodirty(dir, bytes_allocated);
 
        ocfs2_commit_trans(osb, handle);
 
@@ -3221,11 +3219,10 @@ static int ocfs2_do_extend_dir(struct super_block *sb,
        if (extend) {
                u32 offset = OCFS2_I(dir)->ip_clusters;
 
-               if (vfs_dq_alloc_space_nodirty(dir,
-                                       ocfs2_clusters_to_bytes(sb, 1))) {
-                       status = -EDQUOT;
+               status = dquot_alloc_space_nodirty(dir,
+                                       ocfs2_clusters_to_bytes(sb, 1));
+               if (status)
                        goto bail;
-               }
                did_quota = 1;
 
                status = ocfs2_add_inode_data(OCFS2_SB(sb), dir, &offset,
@@ -3254,7 +3251,7 @@ static int ocfs2_do_extend_dir(struct super_block *sb,
        status = 0;
 bail:
        if (did_quota && status < 0)
-               vfs_dq_free_space_nodirty(dir, ocfs2_clusters_to_bytes(sb, 1));
+               dquot_free_space_nodirty(dir, ocfs2_clusters_to_bytes(sb, 1));
        mlog_exit(status);
        return status;
 }
@@ -3889,11 +3886,10 @@ static int ocfs2_dx_dir_rebalance(struct ocfs2_super *osb, struct inode *dir,
                goto out;
        }
 
-       if (vfs_dq_alloc_space_nodirty(dir,
-                                      ocfs2_clusters_to_bytes(dir->i_sb, 1))) {
-               ret = -EDQUOT;
+       ret = dquot_alloc_space_nodirty(dir,
+                                      ocfs2_clusters_to_bytes(dir->i_sb, 1));
+       if (ret)
                goto out_commit;
-       }
        did_quota = 1;
 
        ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), dx_leaf_bh,
@@ -3983,7 +3979,7 @@ static int ocfs2_dx_dir_rebalance(struct ocfs2_super *osb, struct inode *dir,
 
 out_commit:
        if (ret < 0 && did_quota)
-               vfs_dq_free_space_nodirty(dir,
+               dquot_free_space_nodirty(dir,
                                ocfs2_clusters_to_bytes(dir->i_sb, 1));
 
        ocfs2_commit_trans(osb, handle);
@@ -4165,11 +4161,10 @@ static int ocfs2_expand_inline_dx_root(struct inode *dir,
                goto out;
        }
 
-       if (vfs_dq_alloc_space_nodirty(dir,
-                                      ocfs2_clusters_to_bytes(osb->sb, 1))) {
-               ret = -EDQUOT;
+       ret = dquot_alloc_space_nodirty(dir,
+                                      ocfs2_clusters_to_bytes(osb->sb, 1));
+       if (ret)
                goto out_commit;
-       }
        did_quota = 1;
 
        /*
@@ -4229,7 +4224,7 @@ static int ocfs2_expand_inline_dx_root(struct inode *dir,
 
 out_commit:
        if (ret < 0 && did_quota)
-               vfs_dq_free_space_nodirty(dir,
+               dquot_free_space_nodirty(dir,
                                          ocfs2_clusters_to_bytes(dir->i_sb, 1));
 
        ocfs2_commit_trans(osb, handle);
index 558ce03..6cf3d8d 100644 (file)
@@ -629,11 +629,10 @@ restart_all:
        }
 
 restarted_transaction:
-       if (vfs_dq_alloc_space_nodirty(inode, ocfs2_clusters_to_bytes(osb->sb,
-           clusters_to_add))) {
-               status = -EDQUOT;
+       status = dquot_alloc_space_nodirty(inode,
+                       ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
+       if (status)
                goto leave;
-       }
        did_quota = 1;
 
        /* reserve a write to the file entry early on - that we if we
@@ -674,7 +673,7 @@ restarted_transaction:
        clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters);
        spin_unlock(&OCFS2_I(inode)->ip_lock);
        /* Release unused quota reservation */
-       vfs_dq_free_space(inode,
+       dquot_free_space(inode,
                        ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
        did_quota = 0;
 
@@ -710,7 +709,7 @@ restarted_transaction:
 
 leave:
        if (status < 0 && did_quota)
-               vfs_dq_free_space(inode,
+               dquot_free_space(inode,
                        ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
        if (handle) {
                ocfs2_commit_trans(osb, handle);
index 50fb26a..13adaa1 100644 (file)
@@ -1716,11 +1716,10 @@ static int ocfs2_symlink(struct inode *dir,
                u32 offset = 0;
 
                inode->i_op = &ocfs2_symlink_inode_operations;
-               if (vfs_dq_alloc_space_nodirty(inode,
-                   ocfs2_clusters_to_bytes(osb->sb, 1))) {
-                       status = -EDQUOT;
+               status = dquot_alloc_space_nodirty(inode,
+                   ocfs2_clusters_to_bytes(osb->sb, 1));
+               if (status)
                        goto bail;
-               }
                did_quota = 1;
                status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
                                              new_fe_bh,
@@ -1788,7 +1787,7 @@ static int ocfs2_symlink(struct inode *dir,
        d_instantiate(dentry, inode);
 bail:
        if (status < 0 && did_quota)
-               vfs_dq_free_space_nodirty(inode,
+               dquot_free_space_nodirty(inode,
                                        ocfs2_clusters_to_bytes(osb->sb, 1));
        if (status < 0 && did_quota_inode)
                vfs_dq_free_inode(inode);
index b437dc0..aa66fb2 100644 (file)
@@ -853,9 +853,7 @@ static void ocfs2_destroy_dquot(struct dquot *dquot)
 const struct dquot_operations ocfs2_quota_operations = {
        .initialize     = dquot_initialize,
        .drop           = dquot_drop,
-       .alloc_space    = dquot_alloc_space,
        .alloc_inode    = dquot_alloc_inode,
-       .free_space     = dquot_free_space,
        .free_inode     = dquot_free_inode,
        .transfer       = dquot_transfer,
        .write_dquot    = ocfs2_write_dquot,
index 10d021d..baf202c 100644 (file)
@@ -1464,28 +1464,29 @@ static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
 }
 
 /*
- * Following four functions update i_blocks+i_bytes fields and
- * quota information (together with appropriate checks)
- * NOTE: We absolutely rely on the fact that caller dirties
- * the inode (usually macros in quotaops.h care about this) and
- * holds a handle for the current transaction so that dquot write and
- * inode write go into the same transaction.
+ * This functions updates i_blocks+i_bytes fields and quota information
+ * (together with appropriate checks).
+ *
+ * NOTE: We absolutely rely on the fact that caller dirties the inode
+ * (usually helpers in quotaops.h care about this) and holds a handle for
+ * the current transaction so that dquot write and inode write go into the
+ * same transaction.
  */
 
 /*
  * This operation can block, but only after everything is updated
  */
 int __dquot_alloc_space(struct inode *inode, qsize_t number,
-                       int warn, int reserve)
+               int warn, int reserve)
 {
-       int cnt, ret = QUOTA_OK;
+       int cnt, ret = 0;
        char warntype[MAXQUOTAS];
 
        /*
         * First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex
         */
-       if (IS_NOQUOTA(inode)) {
+       if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
                inode_incr_space(inode, number, reserve);
                goto out;
        }
@@ -1498,9 +1499,9 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number,
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
                if (!inode->i_dquot[cnt])
                        continue;
-               if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt)
-                   == NO_QUOTA) {
-                       ret = NO_QUOTA;
+               if (check_bdq(inode->i_dquot[cnt], number, !warn, warntype+cnt)
+                               == NO_QUOTA) {
+                       ret = -EDQUOT;
                        spin_unlock(&dq_data_lock);
                        goto out_flush_warn;
                }
@@ -1525,18 +1526,7 @@ out_flush_warn:
 out:
        return ret;
 }
-
-int dquot_alloc_space(struct inode *inode, qsize_t number, int warn)
-{
-       return __dquot_alloc_space(inode, number, warn, 0);
-}
-EXPORT_SYMBOL(dquot_alloc_space);
-
-int dquot_reserve_space(struct inode *inode, qsize_t number, int warn)
-{
-       return __dquot_alloc_space(inode, number, warn, 1);
-}
-EXPORT_SYMBOL(dquot_reserve_space);
+EXPORT_SYMBOL(__dquot_alloc_space);
 
 /*
  * This operation can block, but only after everything is updated
@@ -1578,14 +1568,16 @@ warn_put_all:
 }
 EXPORT_SYMBOL(dquot_alloc_inode);
 
-int dquot_claim_space(struct inode *inode, qsize_t number)
+/*
+ * Convert in-memory reserved quotas to real consumed quotas
+ */
+int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 {
        int cnt;
-       int ret = QUOTA_OK;
 
-       if (IS_NOQUOTA(inode)) {
+       if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
                inode_claim_rsv_space(inode, number);
-               goto out;
+               return 0;
        }
 
        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
@@ -1601,24 +1593,23 @@ int dquot_claim_space(struct inode *inode, qsize_t number)
        spin_unlock(&dq_data_lock);
        mark_all_dquot_dirty(inode->i_dquot);
        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-out:
-       return ret;
+       return 0;
 }
-EXPORT_SYMBOL(dquot_claim_space);
+EXPORT_SYMBOL(dquot_claim_space_nodirty);
 
 /*
  * This operation can block, but only after everything is updated
  */
-int __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
+void __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
 {
        unsigned int cnt;
        char warntype[MAXQUOTAS];
 
        /* First test before acquiring mutex - solves deadlocks when we
          * re-enter the quota code and are already holding the mutex */
-       if (IS_NOQUOTA(inode)) {
+       if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
                inode_decr_space(inode, number, reserve);
-               return QUOTA_OK;
+               return;
        }
 
        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
@@ -1641,24 +1632,8 @@ int __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
 out_unlock:
        flush_warnings(inode->i_dquot, warntype);
        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-       return QUOTA_OK;
-}
-
-int dquot_free_space(struct inode *inode, qsize_t number)
-{
-       return  __dquot_free_space(inode, number, 0);
-}
-EXPORT_SYMBOL(dquot_free_space);
-
-/*
- * Release reserved quota space
- */
-void dquot_release_reserved_space(struct inode *inode, qsize_t number)
-{
-       __dquot_free_space(inode, number, 1);
-
 }
-EXPORT_SYMBOL(dquot_release_reserved_space);
+EXPORT_SYMBOL(__dquot_free_space);
 
 /*
  * This operation can block, but only after everything is updated
@@ -1840,9 +1815,7 @@ EXPORT_SYMBOL(dquot_commit_info);
 const struct dquot_operations dquot_operations = {
        .initialize     = dquot_initialize,
        .drop           = dquot_drop,
-       .alloc_space    = dquot_alloc_space,
        .alloc_inode    = dquot_alloc_inode,
-       .free_space     = dquot_free_space,
        .free_inode     = dquot_free_inode,
        .transfer       = dquot_transfer,
        .write_dquot    = dquot_commit,
index 65c8727..dc014f7 100644 (file)
@@ -425,7 +425,7 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
 
        journal_mark_dirty(th, s, sbh);
        if (for_unformatted)
-               vfs_dq_free_block_nodirty(inode, 1);
+               dquot_free_block_nodirty(inode, 1);
 }
 
 void reiserfs_free_block(struct reiserfs_transaction_handle *th,
@@ -1049,7 +1049,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
                               amount_needed, hint->inode->i_uid);
 #endif
                quota_ret =
-                   vfs_dq_alloc_block_nodirty(hint->inode, amount_needed);
+                   dquot_alloc_block_nodirty(hint->inode, amount_needed);
                if (quota_ret)  /* Quota exceeded? */
                        return QUOTA_EXCEEDED;
                if (hint->preallocate && hint->prealloc_size) {
@@ -1058,7 +1058,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
                                       "reiserquota: allocating (prealloc) %d blocks id=%u",
                                       hint->prealloc_size, hint->inode->i_uid);
 #endif
-                       quota_ret = vfs_dq_prealloc_block_nodirty(hint->inode,
+                       quota_ret = dquot_prealloc_block_nodirty(hint->inode,
                                                         hint->prealloc_size);
                        if (quota_ret)
                                hint->preallocate = hint->prealloc_size = 0;
@@ -1092,7 +1092,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
                                               hint->inode->i_uid);
 #endif
                                /* Free not allocated blocks */
-                               vfs_dq_free_block_nodirty(hint->inode,
+                               dquot_free_block_nodirty(hint->inode,
                                        amount_needed + hint->prealloc_size -
                                        nr_allocated);
                        }
@@ -1125,7 +1125,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
                               REISERFS_I(hint->inode)->i_prealloc_count,
                               hint->inode->i_uid);
 #endif
-               vfs_dq_free_block_nodirty(hint->inode, amount_needed +
+               dquot_free_block_nodirty(hint->inode, amount_needed +
                                         hint->prealloc_size - nr_allocated -
                                         REISERFS_I(hint->inode)->
                                         i_prealloc_count);
index 5fa7118..313d39d 100644 (file)
@@ -1299,7 +1299,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
                       "reiserquota delete_item(): freeing %u, id=%u type=%c",
                       quota_cut_bytes, inode->i_uid, head2type(&s_ih));
 #endif
-       vfs_dq_free_space_nodirty(inode, quota_cut_bytes);
+       dquot_free_space_nodirty(inode, quota_cut_bytes);
 
        /* Return deleted body length */
        return ret_value;
@@ -1383,7 +1383,7 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
                                               quota_cut_bytes, inode->i_uid,
                                               key2type(key));
 #endif
-                               vfs_dq_free_space_nodirty(inode,
+                               dquot_free_space_nodirty(inode,
                                                         quota_cut_bytes);
                        }
                        break;
@@ -1733,7 +1733,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
                       "reiserquota cut_from_item(): freeing %u id=%u type=%c",
                       quota_cut_bytes, inode->i_uid, '?');
 #endif
-       vfs_dq_free_space_nodirty(inode, quota_cut_bytes);
+       dquot_free_space_nodirty(inode, quota_cut_bytes);
        return ret_value;
 }
 
@@ -1968,9 +1968,10 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct tree
                       key2type(&(key->on_disk_key)));
 #endif
 
-       if (vfs_dq_alloc_space_nodirty(inode, pasted_size)) {
+       retval = dquot_alloc_space_nodirty(inode, pasted_size);
+       if (retval) {
                pathrelse(search_path);
-               return -EDQUOT;
+               return retval;
        }
        init_tb_struct(th, &s_paste_balance, th->t_super, search_path,
                       pasted_size);
@@ -2024,7 +2025,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct tree
                       pasted_size, inode->i_uid,
                       key2type(&(key->on_disk_key)));
 #endif
-       vfs_dq_free_space_nodirty(inode, pasted_size);
+       dquot_free_space_nodirty(inode, pasted_size);
        return retval;
 }
 
@@ -2062,9 +2063,10 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
 #endif
                /* We can't dirty inode here. It would be immediately written but
                 * appropriate stat item isn't inserted yet... */
-               if (vfs_dq_alloc_space_nodirty(inode, quota_bytes)) {
+               retval = dquot_alloc_space_nodirty(inode, quota_bytes);
+               if (retval) {
                        pathrelse(path);
-                       return -EDQUOT;
+                       return retval;
                }
        }
        init_tb_struct(th, &s_ins_balance, th->t_super, path,
@@ -2113,6 +2115,6 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
                       quota_bytes, inode->i_uid, head2type(ih));
 #endif
        if (inode)
-               vfs_dq_free_space_nodirty(inode, quota_bytes);
+               dquot_free_space_nodirty(inode, quota_bytes);
        return retval;
 }
index b4a7dd0..ea4a77e 100644 (file)
@@ -618,9 +618,7 @@ static int reiserfs_quota_on(struct super_block *, int, int, char *, int);
 static const struct dquot_operations reiserfs_quota_operations = {
        .initialize = dquot_initialize,
        .drop = dquot_drop,
-       .alloc_space = dquot_alloc_space,
        .alloc_inode = dquot_alloc_inode,
-       .free_space = dquot_free_space,
        .free_inode = dquot_free_inode,
        .transfer = dquot_transfer,
        .write_dquot = reiserfs_write_dquot,
index 82372e3..e2ff180 100644 (file)
@@ -208,7 +208,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
                                        ((char *)bh->b_data)[(bit + i) >> 3]);
                        } else {
                                if (inode)
-                                       vfs_dq_free_block(inode, 1);
+                                       dquot_free_block(inode, 1);
                                udf_add_free_space(sb, sbi->s_partition, 1);
                        }
                }
@@ -260,11 +260,11 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
                while (bit < (sb->s_blocksize << 3) && block_count > 0) {
                        if (!udf_test_bit(bit, bh->b_data))
                                goto out;
-                       else if (vfs_dq_prealloc_block(inode, 1))
+                       else if (dquot_prealloc_block(inode, 1))
                                goto out;
                        else if (!udf_clear_bit(bit, bh->b_data)) {
                                udf_debug("bit already cleared for block %d\n", bit);
-                               vfs_dq_free_block(inode, 1);
+                               dquot_free_block(inode, 1);
                                goto out;
                        }
                        block_count--;
@@ -390,10 +390,14 @@ got_block:
        /*
         * Check quota for allocation of this block.
         */
-       if (inode && vfs_dq_alloc_block(inode, 1)) {
-               mutex_unlock(&sbi->s_alloc_mutex);
-               *err = -EDQUOT;
-               return 0;
+       if (inode) {
+               int ret = dquot_alloc_block(inode, 1);
+
+               if (ret) {
+                       mutex_unlock(&sbi->s_alloc_mutex);
+                       *err = ret;
+                       return 0;
+               }
        }
 
        newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
@@ -449,7 +453,7 @@ static void udf_table_free_blocks(struct super_block *sb,
        /* We do this up front - There are some error conditions that
           could occure, but.. oh well */
        if (inode)
-               vfs_dq_free_block(inode, count);
+               dquot_free_block(inode, count);
        udf_add_free_space(sb, sbi->s_partition, count);
 
        start = bloc->logicalBlockNum + offset;
@@ -694,7 +698,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
                epos.offset -= adsize;
 
                alloc_count = (elen >> sb->s_blocksize_bits);
-               if (inode && vfs_dq_prealloc_block(inode,
+               if (inode && dquot_prealloc_block(inode,
                        alloc_count > block_count ? block_count : alloc_count))
                        alloc_count = 0;
                else if (alloc_count > block_count) {
@@ -797,12 +801,13 @@ static int udf_table_new_block(struct super_block *sb,
        newblock = goal_eloc.logicalBlockNum;
        goal_eloc.logicalBlockNum++;
        goal_elen -= sb->s_blocksize;
-
-       if (inode && vfs_dq_alloc_block(inode, 1)) {
-               brelse(goal_epos.bh);
-               mutex_unlock(&sbi->s_alloc_mutex);
-               *err = -EDQUOT;
-               return 0;
+       if (inode) {
+               *err = dquot_alloc_block(inode, 1);
+               if (*err) {
+                       brelse(goal_epos.bh);
+                       mutex_unlock(&sbi->s_alloc_mutex);
+                       return 0;
+               }
        }
 
        if (goal_elen)
index 54c16ec..5cfa4d8 100644 (file)
@@ -85,7 +85,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
                                   "bit already cleared for fragment %u", i);
        }
        
-       vfs_dq_free_block(inode, count);
+       dquot_free_block(inode, count);
 
        
        fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
@@ -195,7 +195,7 @@ do_more:
                ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
                if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                        ufs_clusteracct (sb, ucpi, blkno, 1);
-               vfs_dq_free_block(inode, uspi->s_fpb);
+               dquot_free_block(inode, uspi->s_fpb);
 
                fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
                uspi->cs_total.cs_nbfree++;
@@ -511,6 +511,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
        struct ufs_cg_private_info * ucpi;
        struct ufs_cylinder_group * ucg;
        unsigned cgno, fragno, fragoff, count, fragsize, i;
+       int ret;
        
        UFSD("ENTER, fragment %llu, oldcount %u, newcount %u\n",
             (unsigned long long)fragment, oldcount, newcount);
@@ -556,8 +557,9 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
                fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
        for (i = oldcount; i < newcount; i++)
                ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i);
-       if (vfs_dq_alloc_block(inode, count)) {
-               *err = -EDQUOT;
+       ret = dquot_alloc_block(inode, count);
+       if (ret) {
+               *err = ret;
                return 0;
        }
 
@@ -596,6 +598,7 @@ static u64 ufs_alloc_fragments(struct inode *inode, unsigned cgno,
        struct ufs_cylinder_group * ucg;
        unsigned oldcg, i, j, k, allocsize;
        u64 result;
+       int ret;
        
        UFSD("ENTER, ino %lu, cgno %u, goal %llu, count %u\n",
             inode->i_ino, cgno, (unsigned long long)goal, count);
@@ -664,7 +667,7 @@ cg_found:
                for (i = count; i < uspi->s_fpb; i++)
                        ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
                i = uspi->s_fpb - count;
-               vfs_dq_free_block(inode, i);
+               dquot_free_block(inode, i);
 
                fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
                uspi->cs_total.cs_nffree += i;
@@ -676,8 +679,9 @@ cg_found:
        result = ufs_bitmap_search (sb, ucpi, goal, allocsize);
        if (result == INVBLOCK)
                return 0;
-       if (vfs_dq_alloc_block(inode, count)) {
-               *err = -EDQUOT;
+       ret = dquot_alloc_block(inode, count);
+       if (ret) {
+               *err = ret;
                return 0;
        }
        for (i = 0; i < count; i++)
@@ -714,6 +718,7 @@ static u64 ufs_alloccg_block(struct inode *inode,
        struct ufs_super_block_first * usb1;
        struct ufs_cylinder_group * ucg;
        u64 result, blkno;
+       int ret;
 
        UFSD("ENTER, goal %llu\n", (unsigned long long)goal);
 
@@ -747,8 +752,9 @@ gotit:
        ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
        if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                ufs_clusteracct (sb, ucpi, blkno, -1);
-       if (vfs_dq_alloc_block(inode, uspi->s_fpb)) {
-               *err = -EDQUOT;
+       ret = dquot_alloc_block(inode, uspi->s_fpb);
+       if (ret) {
+               *err = ret;
                return INVBLOCK;
        }
 
index edf34f2..1b14ad2 100644 (file)
@@ -297,9 +297,7 @@ struct quota_format_ops {
 struct dquot_operations {
        int (*initialize) (struct inode *, int);
        int (*drop) (struct inode *);
-       int (*alloc_space) (struct inode *, qsize_t, int);
        int (*alloc_inode) (const struct inode *, qsize_t);
-       int (*free_space) (struct inode *, qsize_t);
        int (*free_inode) (const struct inode *, qsize_t);
        int (*transfer) (struct inode *, qid_t *, unsigned long);
        int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
@@ -309,12 +307,6 @@ struct dquot_operations {
        int (*release_dquot) (struct dquot *);          /* Quota is going to be deleted from disk */
        int (*mark_dirty) (struct dquot *);             /* Dquot is marked dirty */
        int (*write_info) (struct super_block *, int);  /* Write of quota "superblock" */
-       /* reserve quota for delayed block allocation */
-       int (*reserve_space) (struct inode *, qsize_t, int);
-       /* claim reserved quota for delayed alloc */
-       int (*claim_space) (struct inode *, qsize_t);
-       /* release rsved quota for delayed alloc */
-       void (*release_rsv) (struct inode *, qsize_t);
        /* get reserved quota for delayed alloc, value returned is managed by
         * quota code only */
        qsize_t *(*get_reserved_space) (struct inode *);
index e1cae20..47e8568 100644 (file)
@@ -33,14 +33,13 @@ int dquot_scan_active(struct super_block *sb,
 struct dquot *dquot_alloc(struct super_block *sb, int type);
 void dquot_destroy(struct dquot *dquot);
 
-int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
-int dquot_alloc_inode(const struct inode *inode, qsize_t number);
+int __dquot_alloc_space(struct inode *inode, qsize_t number,
+               int warn, int reserve);
+void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
 
-int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
-int dquot_claim_space(struct inode *inode, qsize_t number);
-void dquot_release_reserved_space(struct inode *inode, qsize_t number);
+int dquot_alloc_inode(const struct inode *inode, qsize_t number);
 
-int dquot_free_space(struct inode *inode, qsize_t number);
+int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
 int dquot_free_inode(const struct inode *inode, qsize_t number);
 
 int dquot_transfer(struct inode *inode, qid_t *chid, unsigned long mask);
@@ -149,60 +148,6 @@ static inline void vfs_dq_init(struct inode *inode)
                inode->i_sb->dq_op->initialize(inode, -1);
 }
 
-/* The following allocation/freeing/transfer functions *must* be called inside
- * a transaction (deadlocks possible otherwise) */
-static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb)) {
-               /* Used space is updated in alloc_space() */
-               if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
-                       return 1;
-       }
-       else
-               inode_add_bytes(inode, nr);
-       return 0;
-}
-
-static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
-{
-       int ret;
-        if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
-               mark_inode_dirty(inode);
-       return ret;
-}
-
-static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb)) {
-               /* Used space is updated in alloc_space() */
-               if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
-                       return 1;
-       }
-       else
-               inode_add_bytes(inode, nr);
-       return 0;
-}
-
-static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
-{
-       int ret;
-       if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
-               mark_inode_dirty(inode);
-       return ret;
-}
-
-static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb)) {
-               /* Used space is updated in alloc_space() */
-               if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
-                       return 1;
-       }
-       else
-               inode_add_rsv_space(inode, nr);
-       return 0;
-}
-
 static inline int vfs_dq_alloc_inode(struct inode *inode)
 {
        if (sb_any_quota_active(inode->i_sb)) {
@@ -213,47 +158,6 @@ static inline int vfs_dq_alloc_inode(struct inode *inode)
        return 0;
 }
 
-/*
- * Convert in-memory reserved quotas to real consumed quotas
- */
-static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb)) {
-               if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
-                       return 1;
-       } else
-               inode_claim_rsv_space(inode, nr);
-
-       mark_inode_dirty(inode);
-       return 0;
-}
-
-/*
- * Release reserved (in-memory) quotas
- */
-static inline
-void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb))
-               inode->i_sb->dq_op->release_rsv(inode, nr);
-       else
-               inode_sub_rsv_space(inode, nr);
-}
-
-static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
-{
-       if (sb_any_quota_active(inode->i_sb))
-               inode->i_sb->dq_op->free_space(inode, nr);
-       else
-               inode_sub_bytes(inode, nr);
-}
-
-static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
-{
-       vfs_dq_free_space_nodirty(inode, nr);
-       mark_inode_dirty(inode);
-}
-
 static inline void vfs_dq_free_inode(struct inode *inode)
 {
        if (sb_any_quota_active(inode->i_sb))
@@ -351,105 +255,109 @@ static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
        return 0;
 }
 
-static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
+               int warn, int reserve)
 {
-       inode_add_bytes(inode, nr);
+       if (!reserve)
+               inode_add_bytes(inode, number);
        return 0;
 }
 
-static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
+static inline void __dquot_free_space(struct inode *inode, qsize_t number,
+               int reserve)
 {
-       vfs_dq_prealloc_space_nodirty(inode, nr);
-       mark_inode_dirty(inode);
-       return 0;
+       if (!reserve)
+               inode_sub_bytes(inode, number);
 }
 
-static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 {
-       inode_add_bytes(inode, nr);
+       inode_add_bytes(inode, number);
        return 0;
 }
 
-static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
+#endif /* CONFIG_QUOTA */
+
+static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 {
-       vfs_dq_alloc_space_nodirty(inode, nr);
-       mark_inode_dirty(inode);
-       return 0;
+       return __dquot_alloc_space(inode, nr, 1, 0);
 }
 
-static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 {
-       return 0;
+       int ret;
+
+       ret = dquot_alloc_space_nodirty(inode, nr);
+       if (!ret)
+               mark_inode_dirty(inode);
+       return ret;
 }
 
-static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 {
-       return vfs_dq_alloc_space(inode, nr);
+       return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 }
 
-static inline
-int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 {
-       return 0;
+       return dquot_alloc_space(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 {
-       inode_sub_bytes(inode, nr);
+       return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
 }
 
-static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
+static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 {
-       vfs_dq_free_space_nodirty(inode, nr);
-       mark_inode_dirty(inode);
-}      
-
-#endif /* CONFIG_QUOTA */
+       int ret;
 
-static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
-{
-       return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
+       ret = dquot_prealloc_block_nodirty(inode, nr);
+       if (!ret)
+               mark_inode_dirty(inode);
+       return ret;
 }
 
-static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
+static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 {
-       return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
+       return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
 }
 
-static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 {
-       return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
-}
+       int ret;
 
-static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
-{
-       return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
+       ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
+       if (!ret)
+               mark_inode_dirty(inode);
+       return ret;
 }
 
-static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 {
-       return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
+       __dquot_free_space(inode, nr, 0);
 }
 
-static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 {
-       return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
+       dquot_free_space_nodirty(inode, nr);
+       mark_inode_dirty(inode);
 }
 
-static inline
-void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 {
-       vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
+       dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
+static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 {
-       vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
+       dquot_free_space(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
+static inline void dquot_release_reservation_block(struct inode *inode,
+               qsize_t nr)
 {
-       vfs_dq_free_space(inode, nr << inode->i_blkbits);
+       __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 }
 
 #endif /* _LINUX_QUOTAOPS_ */