mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-11 12:28:41 +08:00
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>
This commit is contained in:
Christoph Hellwig
Jan Kara
parent
49792c806d
commit
5dd4056db8
@ -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.
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
@ -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 *);
|
||||
|
||||
@ -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_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_alloc_inode(const struct inode *inode, qsize_t number);
|
||||
|
||||
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_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);
|
||||
if (!reserve)
|
||||
inode_sub_bytes(inode, number);
|
||||
}
|
||||
|
||||
static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
|
||||
{
|
||||
inode_add_bytes(inode, number);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
inode_add_bytes(inode, nr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
vfs_dq_alloc_space_nodirty(inode, nr);
|
||||
mark_inode_dirty(inode);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_alloc_space(inode, nr);
|
||||
}
|
||||
|
||||
static inline
|
||||
int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
#endif /* CONFIG_QUOTA */
|
||||
|
||||
static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
return __dquot_alloc_space(inode, nr, 1, 0);
|
||||
}
|
||||
|
||||
static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
|
||||
int ret;
|
||||
|
||||
ret = dquot_alloc_space_nodirty(inode, nr);
|
||||
if (!ret)
|
||||
mark_inode_dirty(inode);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
}
|
||||
|
||||
static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
|
||||
return dquot_alloc_space(inode, nr << inode->i_blkbits);
|
||||
}
|
||||
|
||||
static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
|
||||
return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
|
||||
}
|
||||
|
||||
static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
|
||||
int ret;
|
||||
|
||||
ret = dquot_prealloc_block_nodirty(inode, nr);
|
||||
if (!ret)
|
||||
mark_inode_dirty(inode);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline
|
||||
void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
|
||||
return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
|
||||
}
|
||||
|
||||
static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
int ret;
|
||||
|
||||
ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
if (!ret)
|
||||
mark_inode_dirty(inode);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
|
||||
static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
vfs_dq_free_space(inode, nr << inode->i_blkbits);
|
||||
__dquot_free_space(inode, nr, 0);
|
||||
}
|
||||
|
||||
static inline void dquot_free_space(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
dquot_free_space_nodirty(inode, nr);
|
||||
mark_inode_dirty(inode);
|
||||
}
|
||||
|
||||
static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
|
||||
}
|
||||
|
||||
static inline void dquot_free_block(struct inode *inode, qsize_t nr)
|
||||
{
|
||||
dquot_free_space(inode, nr << inode->i_blkbits);
|
||||
}
|
||||
|
||||
static inline void dquot_release_reservation_block(struct inode *inode,
|
||||
qsize_t nr)
|
||||
{
|
||||
__dquot_free_space(inode, nr << inode->i_blkbits, 1);
|
||||
}
|
||||
|
||||
#endif /* _LINUX_QUOTAOPS_ */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user