aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--fs/Kconfig56
-rw-r--r--fs/Makefile6
-rw-r--r--fs/attr.c3
-rw-r--r--fs/ext2/balloc.c8
-rw-r--r--fs/ext2/ialloc.c10
-rw-r--r--fs/ext2/inode.c2
-rw-r--r--fs/ext2/super.c1
-rw-r--r--fs/ext2/xattr.c8
-rw-r--r--fs/ext3/balloc.c8
-rw-r--r--fs/ext3/ialloc.c12
-rw-r--r--fs/ext3/inode.c6
-rw-r--r--fs/ext3/namei.c6
-rw-r--r--fs/ext3/super.c48
-rw-r--r--fs/ext3/xattr.c6
-rw-r--r--fs/ext4/balloc.c2
-rw-r--r--fs/ext4/ext4.h2
-rw-r--r--fs/ext4/ialloc.c12
-rw-r--r--fs/ext4/inode.c40
-rw-r--r--fs/ext4/mballoc.c46
-rw-r--r--fs/ext4/namei.c6
-rw-r--r--fs/ext4/super.c54
-rw-r--r--fs/ext4/xattr.c6
-rw-r--r--fs/inode.c4
-rw-r--r--fs/jfs/acl.c2
-rw-r--r--fs/jfs/inode.c6
-rw-r--r--fs/jfs/jfs_dtree.c18
-rw-r--r--fs/jfs/jfs_extent.c10
-rw-r--r--fs/jfs/jfs_inode.c4
-rw-r--r--fs/jfs/jfs_xtree.c14
-rw-r--r--fs/jfs/namei.c6
-rw-r--r--fs/jfs/xattr.c12
-rw-r--r--fs/namei.c22
-rw-r--r--fs/nfsd/vfs.c4
-rw-r--r--fs/open.c2
-rw-r--r--fs/quota/Kconfig59
-rw-r--r--fs/quota/Makefile14
-rw-r--r--fs/quota/dquot.c (renamed from fs/dquot.c)562
-rw-r--r--fs/quota/quota.c (renamed from fs/quota.c)37
-rw-r--r--fs/quota/quota_tree.c (renamed from fs/quota_tree.c)132
-rw-r--r--fs/quota/quota_tree.h (renamed from fs/quota_tree.h)0
-rw-r--r--fs/quota/quota_v1.c (renamed from fs/quota_v1.c)48
-rw-r--r--fs/quota/quota_v2.c (renamed from fs/quota_v2.c)3
-rw-r--r--fs/quota/quotaio_v1.h (renamed from fs/quotaio_v1.h)0
-rw-r--r--fs/quota/quotaio_v2.h (renamed from fs/quotaio_v2.h)0
-rw-r--r--fs/ramfs/file-nommu.c6
-rw-r--r--fs/reiserfs/bitmap.c14
-rw-r--r--fs/reiserfs/inode.c10
-rw-r--r--fs/reiserfs/namei.c6
-rw-r--r--fs/reiserfs/stree.c14
-rw-r--r--fs/reiserfs/super.c60
-rw-r--r--fs/super.c8
-rw-r--r--fs/sync.c2
-rw-r--r--fs/udf/balloc.c14
-rw-r--r--fs/udf/ialloc.c8
-rw-r--r--fs/ufs/balloc.c12
-rw-r--r--fs/ufs/ialloc.c8
-rw-r--r--include/linux/quota.h11
-rw-r--r--include/linux/quotaops.h119
58 files changed, 902 insertions, 697 deletions
diff --git a/fs/Kconfig b/fs/Kconfig
index 93945dd0b1ae..cef8b18ceaa3 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -56,61 +56,7 @@ endif # BLOCK
56 56
57source "fs/notify/Kconfig" 57source "fs/notify/Kconfig"
58 58
59config QUOTA 59source "fs/quota/Kconfig"
60 bool "Quota support"
61 help
62 If you say Y here, you will be able to set per user limits for disk
63 usage (also called disk quotas). Currently, it works for the
64 ext2, ext3, and reiserfs file system. ext3 also supports journalled
65 quotas for which you don't need to run quotacheck(8) after an unclean
66 shutdown.
67 For further details, read the Quota mini-HOWTO, available from
68 <http://www.tldp.org/docs.html#howto>, or the documentation provided
69 with the quota tools. Probably the quota support is only useful for
70 multi user systems. If unsure, say N.
71
72config QUOTA_NETLINK_INTERFACE
73 bool "Report quota messages through netlink interface"
74 depends on QUOTA && NET
75 help
76 If you say Y here, quota warnings (about exceeding softlimit, reaching
77 hardlimit, etc.) will be reported through netlink interface. If unsure,
78 say Y.
79
80config PRINT_QUOTA_WARNING
81 bool "Print quota warnings to console (OBSOLETE)"
82 depends on QUOTA
83 default y
84 help
85 If you say Y here, quota warnings (about exceeding softlimit, reaching
86 hardlimit, etc.) will be printed to the process' controlling terminal.
87 Note that this behavior is currently deprecated and may go away in
88 future. Please use notification via netlink socket instead.
89
90# Generic support for tree structured quota files. Seleted when needed.
91config QUOTA_TREE
92 tristate
93
94config QFMT_V1
95 tristate "Old quota format support"
96 depends on QUOTA
97 help
98 This quota format was (is) used by kernels earlier than 2.4.22. If
99 you have quota working and you don't want to convert to new quota
100 format say Y here.
101
102config QFMT_V2
103 tristate "Quota format v2 support"
104 depends on QUOTA
105 select QUOTA_TREE
106 help
107 This quota format allows using quotas with 32-bit UIDs/GIDs. If you
108 need this functionality say Y here.
109
110config QUOTACTL
111 bool
112 depends on XFS_QUOTA || QUOTA
113 default y
114 60
115source "fs/autofs/Kconfig" 61source "fs/autofs/Kconfig"
116source "fs/autofs4/Kconfig" 62source "fs/autofs4/Kconfig"
diff --git a/fs/Makefile b/fs/Makefile
index dc20db348679..6e82a307bcd4 100644
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -51,11 +51,7 @@ obj-$(CONFIG_FS_POSIX_ACL) += posix_acl.o xattr_acl.o
51obj-$(CONFIG_NFS_COMMON) += nfs_common/ 51obj-$(CONFIG_NFS_COMMON) += nfs_common/
52obj-$(CONFIG_GENERIC_ACL) += generic_acl.o 52obj-$(CONFIG_GENERIC_ACL) += generic_acl.o
53 53
54obj-$(CONFIG_QUOTA) += dquot.o 54obj-y += quota/
55obj-$(CONFIG_QFMT_V1) += quota_v1.o
56obj-$(CONFIG_QFMT_V2) += quota_v2.o
57obj-$(CONFIG_QUOTA_TREE) += quota_tree.o
58obj-$(CONFIG_QUOTACTL) += quota.o
59 55
60obj-$(CONFIG_PROC_FS) += proc/ 56obj-$(CONFIG_PROC_FS) += proc/
61obj-y += partitions/ 57obj-y += partitions/
diff --git a/fs/attr.c b/fs/attr.c
index f4360192a938..9fe1b1bd30a8 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -173,7 +173,8 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
173 if (!error) { 173 if (!error) {
174 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) || 174 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
175 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) 175 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid))
176 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0; 176 error = vfs_dq_transfer(inode, attr) ?
177 -EDQUOT : 0;
177 if (!error) 178 if (!error)
178 error = inode_setattr(inode, attr); 179 error = inode_setattr(inode, attr);
179 } 180 }
diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index 4a29d6376081..7f8d2e5a7ea6 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -570,7 +570,7 @@ do_more:
570error_return: 570error_return:
571 brelse(bitmap_bh); 571 brelse(bitmap_bh);
572 release_blocks(sb, freed); 572 release_blocks(sb, freed);
573 DQUOT_FREE_BLOCK(inode, freed); 573 vfs_dq_free_block(inode, freed);
574} 574}
575 575
576/** 576/**
@@ -1247,7 +1247,7 @@ ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
1247 /* 1247 /*
1248 * Check quota for allocation of this block. 1248 * Check quota for allocation of this block.
1249 */ 1249 */
1250 if (DQUOT_ALLOC_BLOCK(inode, num)) { 1250 if (vfs_dq_alloc_block(inode, num)) {
1251 *errp = -EDQUOT; 1251 *errp = -EDQUOT;
1252 return 0; 1252 return 0;
1253 } 1253 }
@@ -1409,7 +1409,7 @@ allocated:
1409 1409
1410 *errp = 0; 1410 *errp = 0;
1411 brelse(bitmap_bh); 1411 brelse(bitmap_bh);
1412 DQUOT_FREE_BLOCK(inode, *count-num); 1412 vfs_dq_free_block(inode, *count-num);
1413 *count = num; 1413 *count = num;
1414 return ret_block; 1414 return ret_block;
1415 1415
@@ -1420,7 +1420,7 @@ out:
1420 * Undo the block allocation 1420 * Undo the block allocation
1421 */ 1421 */
1422 if (!performed_allocation) 1422 if (!performed_allocation)
1423 DQUOT_FREE_BLOCK(inode, *count); 1423 vfs_dq_free_block(inode, *count);
1424 brelse(bitmap_bh); 1424 brelse(bitmap_bh);
1425 return 0; 1425 return 0;
1426} 1426}
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 66321a877e74..15387c9c17d8 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -121,8 +121,8 @@ void ext2_free_inode (struct inode * inode)
121 if (!is_bad_inode(inode)) { 121 if (!is_bad_inode(inode)) {
122 /* Quota is already initialized in iput() */ 122 /* Quota is already initialized in iput() */
123 ext2_xattr_delete_inode(inode); 123 ext2_xattr_delete_inode(inode);
124 DQUOT_FREE_INODE(inode); 124 vfs_dq_free_inode(inode);
125 DQUOT_DROP(inode); 125 vfs_dq_drop(inode);
126 } 126 }
127 127
128 es = EXT2_SB(sb)->s_es; 128 es = EXT2_SB(sb)->s_es;
@@ -586,7 +586,7 @@ got:
586 goto fail_drop; 586 goto fail_drop;
587 } 587 }
588 588
589 if (DQUOT_ALLOC_INODE(inode)) { 589 if (vfs_dq_alloc_inode(inode)) {
590 err = -EDQUOT; 590 err = -EDQUOT;
591 goto fail_drop; 591 goto fail_drop;
592 } 592 }
@@ -605,10 +605,10 @@ got:
605 return inode; 605 return inode;
606 606
607fail_free_drop: 607fail_free_drop:
608 DQUOT_FREE_INODE(inode); 608 vfs_dq_free_inode(inode);
609 609
610fail_drop: 610fail_drop:
611 DQUOT_DROP(inode); 611 vfs_dq_drop(inode);
612 inode->i_flags |= S_NOQUOTA; 612 inode->i_flags |= S_NOQUOTA;
613 inode->i_nlink = 0; 613 inode->i_nlink = 0;
614 unlock_new_inode(inode); 614 unlock_new_inode(inode);
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 23fff2f87783..b43b95563663 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1444,7 +1444,7 @@ int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
1444 return error; 1444 return error;
1445 if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) || 1445 if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
1446 (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) { 1446 (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
1447 error = DQUOT_TRANSFER(inode, iattr) ? -EDQUOT : 0; 1447 error = vfs_dq_transfer(inode, iattr) ? -EDQUOT : 0;
1448 if (error) 1448 if (error)
1449 return error; 1449 return error;
1450 } 1450 }
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 7c6e3606f0ec..f983225266dc 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1331,6 +1331,7 @@ static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
1331 sb->s_blocksize - offset : toread; 1331 sb->s_blocksize - offset : toread;
1332 1332
1333 tmp_bh.b_state = 0; 1333 tmp_bh.b_state = 0;
1334 tmp_bh.b_size = sb->s_blocksize;
1334 err = ext2_get_block(inode, blk, &tmp_bh, 0); 1335 err = ext2_get_block(inode, blk, &tmp_bh, 0);
1335 if (err < 0) 1336 if (err < 0)
1336 return err; 1337 return err;
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 987a5261cc2e..7913531ec6d5 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -642,7 +642,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
642 ea_bdebug(new_bh, "reusing block"); 642 ea_bdebug(new_bh, "reusing block");
643 643
644 error = -EDQUOT; 644 error = -EDQUOT;
645 if (DQUOT_ALLOC_BLOCK(inode, 1)) { 645 if (vfs_dq_alloc_block(inode, 1)) {
646 unlock_buffer(new_bh); 646 unlock_buffer(new_bh);
647 goto cleanup; 647 goto cleanup;
648 } 648 }
@@ -699,7 +699,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
699 * as if nothing happened and cleanup the unused block */ 699 * as if nothing happened and cleanup the unused block */
700 if (error && error != -ENOSPC) { 700 if (error && error != -ENOSPC) {
701 if (new_bh && new_bh != old_bh) 701 if (new_bh && new_bh != old_bh)
702 DQUOT_FREE_BLOCK(inode, 1); 702 vfs_dq_free_block(inode, 1);
703 goto cleanup; 703 goto cleanup;
704 } 704 }
705 } else 705 } else
@@ -731,7 +731,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
731 le32_add_cpu(&HDR(old_bh)->h_refcount, -1); 731 le32_add_cpu(&HDR(old_bh)->h_refcount, -1);
732 if (ce) 732 if (ce)
733 mb_cache_entry_release(ce); 733 mb_cache_entry_release(ce);
734 DQUOT_FREE_BLOCK(inode, 1); 734 vfs_dq_free_block(inode, 1);
735 mark_buffer_dirty(old_bh); 735 mark_buffer_dirty(old_bh);
736 ea_bdebug(old_bh, "refcount now=%d", 736 ea_bdebug(old_bh, "refcount now=%d",
737 le32_to_cpu(HDR(old_bh)->h_refcount)); 737 le32_to_cpu(HDR(old_bh)->h_refcount));
@@ -794,7 +794,7 @@ ext2_xattr_delete_inode(struct inode *inode)
794 mark_buffer_dirty(bh); 794 mark_buffer_dirty(bh);
795 if (IS_SYNC(inode)) 795 if (IS_SYNC(inode))
796 sync_dirty_buffer(bh); 796 sync_dirty_buffer(bh);
797 DQUOT_FREE_BLOCK(inode, 1); 797 vfs_dq_free_block(inode, 1);
798 } 798 }
799 EXT2_I(inode)->i_file_acl = 0; 799 EXT2_I(inode)->i_file_acl = 0;
800 800
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index 0dbf1c048475..225202db8974 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -676,7 +676,7 @@ void ext3_free_blocks(handle_t *handle, struct inode *inode,
676 } 676 }
677 ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks); 677 ext3_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
678 if (dquot_freed_blocks) 678 if (dquot_freed_blocks)
679 DQUOT_FREE_BLOCK(inode, dquot_freed_blocks); 679 vfs_dq_free_block(inode, dquot_freed_blocks);
680 return; 680 return;
681} 681}
682 682
@@ -1502,7 +1502,7 @@ ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
1502 /* 1502 /*
1503 * Check quota for allocation of this block. 1503 * Check quota for allocation of this block.
1504 */ 1504 */
1505 if (DQUOT_ALLOC_BLOCK(inode, num)) { 1505 if (vfs_dq_alloc_block(inode, num)) {
1506 *errp = -EDQUOT; 1506 *errp = -EDQUOT;
1507 return 0; 1507 return 0;
1508 } 1508 }
@@ -1714,7 +1714,7 @@ allocated:
1714 1714
1715 *errp = 0; 1715 *errp = 0;
1716 brelse(bitmap_bh); 1716 brelse(bitmap_bh);
1717 DQUOT_FREE_BLOCK(inode, *count-num); 1717 vfs_dq_free_block(inode, *count-num);
1718 *count = num; 1718 *count = num;
1719 return ret_block; 1719 return ret_block;
1720 1720
@@ -1729,7 +1729,7 @@ out:
1729 * Undo the block allocation 1729 * Undo the block allocation
1730 */ 1730 */
1731 if (!performed_allocation) 1731 if (!performed_allocation)
1732 DQUOT_FREE_BLOCK(inode, *count); 1732 vfs_dq_free_block(inode, *count);
1733 brelse(bitmap_bh); 1733 brelse(bitmap_bh);
1734 return 0; 1734 return 0;
1735} 1735}
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 8de6c720e510..dd13d60d524b 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -123,10 +123,10 @@ void ext3_free_inode (handle_t *handle, struct inode * inode)
123 * Note: we must free any quota before locking the superblock, 123 * Note: we must free any quota before locking the superblock,
124 * as writing the quota to disk may need the lock as well. 124 * as writing the quota to disk may need the lock as well.
125 */ 125 */
126 DQUOT_INIT(inode); 126 vfs_dq_init(inode);
127 ext3_xattr_delete_inode(handle, inode); 127 ext3_xattr_delete_inode(handle, inode);
128 DQUOT_FREE_INODE(inode); 128 vfs_dq_free_inode(inode);
129 DQUOT_DROP(inode); 129 vfs_dq_drop(inode);
130 130
131 is_directory = S_ISDIR(inode->i_mode); 131 is_directory = S_ISDIR(inode->i_mode);
132 132
@@ -589,7 +589,7 @@ got:
589 sizeof(struct ext3_inode) - EXT3_GOOD_OLD_INODE_SIZE : 0; 589 sizeof(struct ext3_inode) - EXT3_GOOD_OLD_INODE_SIZE : 0;
590 590
591 ret = inode; 591 ret = inode;
592 if(DQUOT_ALLOC_INODE(inode)) { 592 if (vfs_dq_alloc_inode(inode)) {
593 err = -EDQUOT; 593 err = -EDQUOT;
594 goto fail_drop; 594 goto fail_drop;
595 } 595 }
@@ -620,10 +620,10 @@ really_out:
620 return ret; 620 return ret;
621 621
622fail_free_drop: 622fail_free_drop:
623 DQUOT_FREE_INODE(inode); 623 vfs_dq_free_inode(inode);
624 624
625fail_drop: 625fail_drop:
626 DQUOT_DROP(inode); 626 vfs_dq_drop(inode);
627 inode->i_flags |= S_NOQUOTA; 627 inode->i_flags |= S_NOQUOTA;
628 inode->i_nlink = 0; 628 inode->i_nlink = 0;
629 unlock_new_inode(inode); 629 unlock_new_inode(inode);
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 05e5c2e5c0d7..4a09ff169870 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -3063,7 +3063,7 @@ int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3063 error = PTR_ERR(handle); 3063 error = PTR_ERR(handle);
3064 goto err_out; 3064 goto err_out;
3065 } 3065 }
3066 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0; 3066 error = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
3067 if (error) { 3067 if (error) {
3068 ext3_journal_stop(handle); 3068 ext3_journal_stop(handle);
3069 return error; 3069 return error;
@@ -3154,7 +3154,7 @@ static int ext3_writepage_trans_blocks(struct inode *inode)
3154 ret = 2 * (bpp + indirects) + 2; 3154 ret = 2 * (bpp + indirects) + 2;
3155 3155
3156#ifdef CONFIG_QUOTA 3156#ifdef CONFIG_QUOTA
3157 /* We know that structure was already allocated during DQUOT_INIT so 3157 /* We know that structure was already allocated during vfs_dq_init so
3158 * we will be updating only the data blocks + inodes */ 3158 * we will be updating only the data blocks + inodes */
3159 ret += 2*EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb); 3159 ret += 2*EXT3_QUOTA_TRANS_BLOCKS(inode->i_sb);
3160#endif 3160#endif
@@ -3245,7 +3245,7 @@ int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3245 * i_size has been changed by generic_commit_write() and we thus need 3245 * i_size has been changed by generic_commit_write() and we thus need
3246 * to include the updated inode in the current transaction. 3246 * to include the updated inode in the current transaction.
3247 * 3247 *
3248 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks 3248 * Also, vfs_dq_alloc_space() will always dirty the inode when blocks
3249 * are allocated to the file. 3249 * are allocated to the file.
3250 * 3250 *
3251 * If the inode is marked synchronous, we don't honour that here - doing 3251 * If the inode is marked synchronous, we don't honour that here - doing
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 4db4ffa1edad..e2fc63cbba8b 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -2049,7 +2049,7 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
2049 2049
2050 /* Initialize quotas before so that eventual writes go in 2050 /* Initialize quotas before so that eventual writes go in
2051 * separate transaction */ 2051 * separate transaction */
2052 DQUOT_INIT(dentry->d_inode); 2052 vfs_dq_init(dentry->d_inode);
2053 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); 2053 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
2054 if (IS_ERR(handle)) 2054 if (IS_ERR(handle))
2055 return PTR_ERR(handle); 2055 return PTR_ERR(handle);
@@ -2108,7 +2108,7 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
2108 2108
2109 /* Initialize quotas before so that eventual writes go 2109 /* Initialize quotas before so that eventual writes go
2110 * in separate transaction */ 2110 * in separate transaction */
2111 DQUOT_INIT(dentry->d_inode); 2111 vfs_dq_init(dentry->d_inode);
2112 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); 2112 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
2113 if (IS_ERR(handle)) 2113 if (IS_ERR(handle))
2114 return PTR_ERR(handle); 2114 return PTR_ERR(handle);
@@ -2272,7 +2272,7 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
2272 /* Initialize quotas before so that eventual writes go 2272 /* Initialize quotas before so that eventual writes go
2273 * in separate transaction */ 2273 * in separate transaction */
2274 if (new_dentry->d_inode) 2274 if (new_dentry->d_inode)
2275 DQUOT_INIT(new_dentry->d_inode); 2275 vfs_dq_init(new_dentry->d_inode);
2276 handle = ext3_journal_start(old_dir, 2 * 2276 handle = ext3_journal_start(old_dir, 2 *
2277 EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) + 2277 EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) +
2278 EXT3_INDEX_EXTRA_TRANS_BLOCKS + 2); 2278 EXT3_INDEX_EXTRA_TRANS_BLOCKS + 2);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 4a970411a458..9e5b8e387e1e 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -707,8 +707,6 @@ static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
707#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group") 707#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
708#define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA)) 708#define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
709 709
710static int ext3_dquot_initialize(struct inode *inode, int type);
711static int ext3_dquot_drop(struct inode *inode);
712static int ext3_write_dquot(struct dquot *dquot); 710static int ext3_write_dquot(struct dquot *dquot);
713static int ext3_acquire_dquot(struct dquot *dquot); 711static int ext3_acquire_dquot(struct dquot *dquot);
714static int ext3_release_dquot(struct dquot *dquot); 712static int ext3_release_dquot(struct dquot *dquot);
@@ -723,8 +721,8 @@ static ssize_t ext3_quota_write(struct super_block *sb, int type,
723 const char *data, size_t len, loff_t off); 721 const char *data, size_t len, loff_t off);
724 722
725static struct dquot_operations ext3_quota_operations = { 723static struct dquot_operations ext3_quota_operations = {
726 .initialize = ext3_dquot_initialize, 724 .initialize = dquot_initialize,
727 .drop = ext3_dquot_drop, 725 .drop = dquot_drop,
728 .alloc_space = dquot_alloc_space, 726 .alloc_space = dquot_alloc_space,
729 .alloc_inode = dquot_alloc_inode, 727 .alloc_inode = dquot_alloc_inode,
730 .free_space = dquot_free_space, 728 .free_space = dquot_free_space,
@@ -1438,7 +1436,7 @@ static void ext3_orphan_cleanup (struct super_block * sb,
1438 } 1436 }
1439 1437
1440 list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan); 1438 list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
1441 DQUOT_INIT(inode); 1439 vfs_dq_init(inode);
1442 if (inode->i_nlink) { 1440 if (inode->i_nlink) {
1443 printk(KERN_DEBUG 1441 printk(KERN_DEBUG
1444 "%s: truncating inode %lu to %Ld bytes\n", 1442 "%s: truncating inode %lu to %Ld bytes\n",
@@ -2702,7 +2700,7 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
2702 * Process 1 Process 2 2700 * Process 1 Process 2
2703 * ext3_create() quota_sync() 2701 * ext3_create() quota_sync()
2704 * journal_start() write_dquot() 2702 * journal_start() write_dquot()
2705 * DQUOT_INIT() down(dqio_mutex) 2703 * vfs_dq_init() down(dqio_mutex)
2706 * down(dqio_mutex) journal_start() 2704 * down(dqio_mutex) journal_start()
2707 * 2705 *
2708 */ 2706 */
@@ -2714,44 +2712,6 @@ static inline struct inode *dquot_to_inode(struct dquot *dquot)
2714 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type]; 2712 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
2715} 2713}
2716 2714
2717static int ext3_dquot_initialize(struct inode *inode, int type)
2718{
2719 handle_t *handle;
2720 int ret, err;
2721
2722 /* We may create quota structure so we need to reserve enough blocks */
2723 handle = ext3_journal_start(inode, 2*EXT3_QUOTA_INIT_BLOCKS(inode->i_sb));
2724 if (IS_ERR(handle))
2725 return PTR_ERR(handle);
2726 ret = dquot_initialize(inode, type);
2727 err = ext3_journal_stop(handle);
2728 if (!ret)
2729 ret = err;
2730 return ret;
2731}
2732
2733static int ext3_dquot_drop(struct inode *inode)
2734{
2735 handle_t *handle;
2736 int ret, err;
2737
2738 /* We may delete quota structure so we need to reserve enough blocks */
2739 handle = ext3_journal_start(inode, 2*EXT3_QUOTA_DEL_BLOCKS(inode->i_sb));
2740 if (IS_ERR(handle)) {
2741 /*
2742 * We call dquot_drop() anyway to at least release references
2743 * to quota structures so that umount does not hang.
2744 */
2745 dquot_drop(inode);
2746 return PTR_ERR(handle);
2747 }
2748 ret = dquot_drop(inode);
2749 err = ext3_journal_stop(handle);
2750 if (!ret)
2751 ret = err;
2752 return ret;
2753}
2754
2755static int ext3_write_dquot(struct dquot *dquot) 2715static int ext3_write_dquot(struct dquot *dquot)
2756{ 2716{
2757 int ret, err; 2717 int ret, err;
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index 175414ac2210..83b7be849bd5 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -498,7 +498,7 @@ ext3_xattr_release_block(handle_t *handle, struct inode *inode,
498 error = ext3_journal_dirty_metadata(handle, bh); 498 error = ext3_journal_dirty_metadata(handle, bh);
499 if (IS_SYNC(inode)) 499 if (IS_SYNC(inode))
500 handle->h_sync = 1; 500 handle->h_sync = 1;
501 DQUOT_FREE_BLOCK(inode, 1); 501 vfs_dq_free_block(inode, 1);
502 ea_bdebug(bh, "refcount now=%d; releasing", 502 ea_bdebug(bh, "refcount now=%d; releasing",
503 le32_to_cpu(BHDR(bh)->h_refcount)); 503 le32_to_cpu(BHDR(bh)->h_refcount));
504 if (ce) 504 if (ce)
@@ -774,7 +774,7 @@ inserted:
774 /* The old block is released after updating 774 /* The old block is released after updating
775 the inode. */ 775 the inode. */
776 error = -EDQUOT; 776 error = -EDQUOT;
777 if (DQUOT_ALLOC_BLOCK(inode, 1)) 777 if (vfs_dq_alloc_block(inode, 1))
778 goto cleanup; 778 goto cleanup;
779 error = ext3_journal_get_write_access(handle, 779 error = ext3_journal_get_write_access(handle,
780 new_bh); 780 new_bh);
@@ -848,7 +848,7 @@ cleanup:
848 return error; 848 return error;
849 849
850cleanup_dquot: 850cleanup_dquot:
851 DQUOT_FREE_BLOCK(inode, 1); 851 vfs_dq_free_block(inode, 1);
852 goto cleanup; 852 goto cleanup;
853 853
854bad_block: 854bad_block:
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index de9459b4cb94..38f40d55899c 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -536,7 +536,7 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
536 ext4_mb_free_blocks(handle, inode, block, count, 536 ext4_mb_free_blocks(handle, inode, block, count,
537 metadata, &dquot_freed_blocks); 537 metadata, &dquot_freed_blocks);
538 if (dquot_freed_blocks) 538 if (dquot_freed_blocks)
539 DQUOT_FREE_BLOCK(inode, dquot_freed_blocks); 539 vfs_dq_free_block(inode, dquot_freed_blocks);
540 return; 540 return;
541} 541}
542 542
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index b0c87dce66a3..6083bb38057b 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -20,6 +20,7 @@
20#include <linux/blkdev.h> 20#include <linux/blkdev.h>
21#include <linux/magic.h> 21#include <linux/magic.h>
22#include <linux/jbd2.h> 22#include <linux/jbd2.h>
23#include <linux/quota.h>
23#include "ext4_i.h" 24#include "ext4_i.h"
24 25
25/* 26/*
@@ -1098,6 +1099,7 @@ extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
1098extern int ext4_block_truncate_page(handle_t *handle, 1099extern int ext4_block_truncate_page(handle_t *handle,
1099 struct address_space *mapping, loff_t from); 1100 struct address_space *mapping, loff_t from);
1100extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page); 1101extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page);
1102extern qsize_t ext4_get_reserved_space(struct inode *inode);
1101 1103
1102/* ioctl.c */ 1104/* ioctl.c */
1103extern long ext4_ioctl(struct file *, unsigned int, unsigned long); 1105extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 2d2b3585ee91..fb51b40e3e8f 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -220,10 +220,10 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
220 * Note: we must free any quota before locking the superblock, 220 * Note: we must free any quota before locking the superblock,
221 * as writing the quota to disk may need the lock as well. 221 * as writing the quota to disk may need the lock as well.
222 */ 222 */
223 DQUOT_INIT(inode); 223 vfs_dq_init(inode);
224 ext4_xattr_delete_inode(handle, inode); 224 ext4_xattr_delete_inode(handle, inode);
225 DQUOT_FREE_INODE(inode); 225 vfs_dq_free_inode(inode);
226 DQUOT_DROP(inode); 226 vfs_dq_drop(inode);
227 227
228 is_directory = S_ISDIR(inode->i_mode); 228 is_directory = S_ISDIR(inode->i_mode);
229 229
@@ -915,7 +915,7 @@ got:
915 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize; 915 ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
916 916
917 ret = inode; 917 ret = inode;
918 if (DQUOT_ALLOC_INODE(inode)) { 918 if (vfs_dq_alloc_inode(inode)) {
919 err = -EDQUOT; 919 err = -EDQUOT;
920 goto fail_drop; 920 goto fail_drop;
921 } 921 }
@@ -956,10 +956,10 @@ really_out:
956 return ret; 956 return ret;
957 957
958fail_free_drop: 958fail_free_drop:
959 DQUOT_FREE_INODE(inode); 959 vfs_dq_free_inode(inode);
960 960
961fail_drop: 961fail_drop:
962 DQUOT_DROP(inode); 962 vfs_dq_drop(inode);
963 inode->i_flags |= S_NOQUOTA; 963 inode->i_flags |= S_NOQUOTA;
964 inode->i_nlink = 0; 964 inode->i_nlink = 0;
965 unlock_new_inode(inode); 965 unlock_new_inode(inode);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index c7fed5b18745..71d3ecd5db79 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -975,6 +975,17 @@ out:
975 return err; 975 return err;
976} 976}
977 977
978qsize_t ext4_get_reserved_space(struct inode *inode)
979{
980 unsigned long long total;
981
982 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
983 total = EXT4_I(inode)->i_reserved_data_blocks +
984 EXT4_I(inode)->i_reserved_meta_blocks;
985 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
986
987 return total;
988}
978/* 989/*
979 * Calculate the number of metadata blocks need to reserve 990 * Calculate the number of metadata blocks need to reserve
980 * to allocate @blocks for non extent file based file 991 * to allocate @blocks for non extent file based file
@@ -1036,8 +1047,14 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
1036 /* update per-inode reservations */ 1047 /* update per-inode reservations */
1037 BUG_ON(used > EXT4_I(inode)->i_reserved_data_blocks); 1048 BUG_ON(used > EXT4_I(inode)->i_reserved_data_blocks);
1038 EXT4_I(inode)->i_reserved_data_blocks -= used; 1049 EXT4_I(inode)->i_reserved_data_blocks -= used;
1039
1040 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1050 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1051
1052 /*
1053 * free those over-booking quota for metadata blocks
1054 */
1055
1056 if (mdb_free)
1057 vfs_dq_release_reservation_block(inode, mdb_free);
1041} 1058}
1042 1059
1043/* 1060/*
@@ -1553,8 +1570,8 @@ static int ext4_journalled_write_end(struct file *file,
1553static int ext4_da_reserve_space(struct inode *inode, int nrblocks) 1570static int ext4_da_reserve_space(struct inode *inode, int nrblocks)
1554{ 1571{
1555 int retries = 0; 1572 int retries = 0;
1556 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 1573 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1557 unsigned long md_needed, mdblocks, total = 0; 1574 unsigned long md_needed, mdblocks, total = 0;
1558 1575
1559 /* 1576 /*
1560 * recalculate the amount of metadata blocks to reserve 1577 * recalculate the amount of metadata blocks to reserve
@@ -1570,12 +1587,23 @@ repeat:
1570 md_needed = mdblocks - EXT4_I(inode)->i_reserved_meta_blocks; 1587 md_needed = mdblocks - EXT4_I(inode)->i_reserved_meta_blocks;
1571 total = md_needed + nrblocks; 1588 total = md_needed + nrblocks;
1572 1589
1590 /*
1591 * Make quota reservation here to prevent quota overflow
1592 * later. Real quota accounting is done at pages writeout
1593 * time.
1594 */
1595 if (vfs_dq_reserve_block(inode, total)) {
1596 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1597 return -EDQUOT;
1598 }
1599
1573 if (ext4_claim_free_blocks(sbi, total)) { 1600 if (ext4_claim_free_blocks(sbi, total)) {
1574 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1601 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1575 if (ext4_should_retry_alloc(inode->i_sb, &retries)) { 1602 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
1576 yield(); 1603 yield();
1577 goto repeat; 1604 goto repeat;
1578 } 1605 }
1606 vfs_dq_release_reservation_block(inode, total);
1579 return -ENOSPC; 1607 return -ENOSPC;
1580 } 1608 }
1581 EXT4_I(inode)->i_reserved_data_blocks += nrblocks; 1609 EXT4_I(inode)->i_reserved_data_blocks += nrblocks;
@@ -1629,6 +1657,8 @@ static void ext4_da_release_space(struct inode *inode, int to_free)
1629 BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks); 1657 BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1630 EXT4_I(inode)->i_reserved_meta_blocks = mdb; 1658 EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1631 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock); 1659 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1660
1661 vfs_dq_release_reservation_block(inode, release);
1632} 1662}
1633 1663
1634static void ext4_da_page_release_reservation(struct page *page, 1664static void ext4_da_page_release_reservation(struct page *page,
@@ -4612,7 +4642,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4612 error = PTR_ERR(handle); 4642 error = PTR_ERR(handle);
4613 goto err_out; 4643 goto err_out;
4614 } 4644 }
4615 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0; 4645 error = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
4616 if (error) { 4646 if (error) {
4617 ext4_journal_stop(handle); 4647 ext4_journal_stop(handle);
4618 return error; 4648 return error;
@@ -4991,7 +5021,7 @@ int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4991 * i_size has been changed by generic_commit_write() and we thus need 5021 * i_size has been changed by generic_commit_write() and we thus need
4992 * to include the updated inode in the current transaction. 5022 * to include the updated inode in the current transaction.
4993 * 5023 *
4994 * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks 5024 * Also, vfs_dq_alloc_block() will always dirty the inode when blocks
4995 * are allocated to the file. 5025 * are allocated to the file.
4996 * 5026 *
4997 * If the inode is marked synchronous, we don't honour that here - doing 5027 * If the inode is marked synchronous, we don't honour that here - doing
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 9f61e62f435f..b038188bd039 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -3086,9 +3086,12 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
3086 if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED)) 3086 if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED))
3087 /* release all the reserved blocks if non delalloc */ 3087 /* release all the reserved blocks if non delalloc */
3088 percpu_counter_sub(&sbi->s_dirtyblocks_counter, reserv_blks); 3088 percpu_counter_sub(&sbi->s_dirtyblocks_counter, reserv_blks);
3089 else 3089 else {
3090 percpu_counter_sub(&sbi->s_dirtyblocks_counter, 3090 percpu_counter_sub(&sbi->s_dirtyblocks_counter,
3091 ac->ac_b_ex.fe_len); 3091 ac->ac_b_ex.fe_len);
3092 /* convert reserved quota blocks to real quota blocks */
3093 vfs_dq_claim_block(ac->ac_inode, ac->ac_b_ex.fe_len);
3094 }
3092 3095
3093 if (sbi->s_log_groups_per_flex) { 3096 if (sbi->s_log_groups_per_flex) {
3094 ext4_group_t flex_group = ext4_flex_group(sbi, 3097 ext4_group_t flex_group = ext4_flex_group(sbi,
@@ -4544,7 +4547,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
4544 struct ext4_sb_info *sbi; 4547 struct ext4_sb_info *sbi;
4545 struct super_block *sb; 4548 struct super_block *sb;
4546 ext4_fsblk_t block = 0; 4549 ext4_fsblk_t block = 0;
4547 unsigned int inquota; 4550 unsigned int inquota = 0;
4548 unsigned int reserv_blks = 0; 4551 unsigned int reserv_blks = 0;
4549 4552
4550 sb = ar->inode->i_sb; 4553 sb = ar->inode->i_sb;
@@ -4562,9 +4565,17 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
4562 (unsigned long long) ar->pleft, 4565 (unsigned long long) ar->pleft,
4563 (unsigned long long) ar->pright); 4566 (unsigned long long) ar->pright);
4564 4567
4565 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag) { 4568 /*
4566 /* 4569 * For delayed allocation, we could skip the ENOSPC and
4567 * With delalloc we already reserved the blocks 4570 * EDQUOT check, as blocks and quotas have been already
4571 * reserved when data being copied into pagecache.
4572 */
4573 if (EXT4_I(ar->inode)->i_delalloc_reserved_flag)
4574 ar->flags |= EXT4_MB_DELALLOC_RESERVED;
4575 else {
4576 /* Without delayed allocation we need to verify
4577 * there is enough free blocks to do block allocation
4578 * and verify allocation doesn't exceed the quota limits.
4568 */ 4579 */
4569 while (ar->len && ext4_claim_free_blocks(sbi, ar->len)) { 4580 while (ar->len && ext4_claim_free_blocks(sbi, ar->len)) {
4570 /* let others to free the space */ 4581 /* let others to free the space */
@@ -4576,19 +4587,16 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
4576 return 0; 4587 return 0;
4577 } 4588 }
4578 reserv_blks = ar->len; 4589 reserv_blks = ar->len;
4590 while (ar->len && vfs_dq_alloc_block(ar->inode, ar->len)) {
4591 ar->flags |= EXT4_MB_HINT_NOPREALLOC;
4592 ar->len--;
4593 }
4594 inquota = ar->len;
4595 if (ar->len == 0) {
4596 *errp = -EDQUOT;
4597 goto out3;
4598 }
4579 } 4599 }
4580 while (ar->len && DQUOT_ALLOC_BLOCK(ar->inode, ar->len)) {
4581 ar->flags |= EXT4_MB_HINT_NOPREALLOC;
4582 ar->len--;
4583 }
4584 if (ar->len == 0) {
4585 *errp = -EDQUOT;
4586 goto out3;
4587 }
4588 inquota = ar->len;
4589
4590 if (EXT4_I(ar->inode)->i_delalloc_reserved_flag)
4591 ar->flags |= EXT4_MB_DELALLOC_RESERVED;
4592 4600
4593 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS); 4601 ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
4594 if (!ac) { 4602 if (!ac) {
@@ -4654,8 +4662,8 @@ repeat:
4654out2: 4662out2:
4655 kmem_cache_free(ext4_ac_cachep, ac); 4663 kmem_cache_free(ext4_ac_cachep, ac);
4656out1: 4664out1:
4657 if (ar->len < inquota) 4665 if (inquota && ar->len < inquota)
4658 DQUOT_FREE_BLOCK(ar->inode, inquota - ar->len); 4666 vfs_dq_free_block(ar->inode, inquota - ar->len);
4659out3: 4667out3:
4660 if (!ar->len) { 4668 if (!ar->len) {
4661 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag) 4669 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag)
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index ba702bd7910d..83410244d3ee 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2092,7 +2092,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2092 2092
2093 /* Initialize quotas before so that eventual writes go in 2093 /* Initialize quotas before so that eventual writes go in
2094 * separate transaction */ 2094 * separate transaction */
2095 DQUOT_INIT(dentry->d_inode); 2095 vfs_dq_init(dentry->d_inode);
2096 handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2096 handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
2097 if (IS_ERR(handle)) 2097 if (IS_ERR(handle))
2098 return PTR_ERR(handle); 2098 return PTR_ERR(handle);
@@ -2151,7 +2151,7 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
2151 2151
2152 /* Initialize quotas before so that eventual writes go 2152 /* Initialize quotas before so that eventual writes go
2153 * in separate transaction */ 2153 * in separate transaction */
2154 DQUOT_INIT(dentry->d_inode); 2154 vfs_dq_init(dentry->d_inode);
2155 handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb)); 2155 handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
2156 if (IS_ERR(handle)) 2156 if (IS_ERR(handle))
2157 return PTR_ERR(handle); 2157 return PTR_ERR(handle);
@@ -2318,7 +2318,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
2318 /* Initialize quotas before so that eventual writes go 2318 /* Initialize quotas before so that eventual writes go
2319 * in separate transaction */ 2319 * in separate transaction */
2320 if (new_dentry->d_inode) 2320 if (new_dentry->d_inode)
2321 DQUOT_INIT(new_dentry->d_inode); 2321 vfs_dq_init(new_dentry->d_inode);
2322 handle = ext4_journal_start(old_dir, 2 * 2322 handle = ext4_journal_start(old_dir, 2 *
2323 EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) + 2323 EXT4_DATA_TRANS_BLOCKS(old_dir->i_sb) +
2324 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2); 2324 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 39d1993cfa13..f7371a6a923d 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -926,8 +926,6 @@ static int bdev_try_to_free_page(struct super_block *sb, struct page *page, gfp_
926#define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group") 926#define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group")
927#define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA)) 927#define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
928 928
929static int ext4_dquot_initialize(struct inode *inode, int type);
930static int ext4_dquot_drop(struct inode *inode);
931static int ext4_write_dquot(struct dquot *dquot); 929static int ext4_write_dquot(struct dquot *dquot);
932static int ext4_acquire_dquot(struct dquot *dquot); 930static int ext4_acquire_dquot(struct dquot *dquot);
933static int ext4_release_dquot(struct dquot *dquot); 931static int ext4_release_dquot(struct dquot *dquot);
@@ -942,9 +940,13 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
942 const char *data, size_t len, loff_t off); 940 const char *data, size_t len, loff_t off);
943 941
944static struct dquot_operations ext4_quota_operations = { 942static struct dquot_operations ext4_quota_operations = {
945 .initialize = ext4_dquot_initialize, 943 .initialize = dquot_initialize,
946 .drop = ext4_dquot_drop, 944 .drop = dquot_drop,
947 .alloc_space = dquot_alloc_space, 945 .alloc_space = dquot_alloc_space,
946 .reserve_space = dquot_reserve_space,
947 .claim_space = dquot_claim_space,
948 .release_rsv = dquot_release_reserved_space,
949 .get_reserved_space = ext4_get_reserved_space,
948 .alloc_inode = dquot_alloc_inode, 950 .alloc_inode = dquot_alloc_inode,
949 .free_space = dquot_free_space, 951 .free_space = dquot_free_space,
950 .free_inode = dquot_free_inode, 952 .free_inode = dquot_free_inode,
@@ -1802,7 +1804,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
1802 } 1804 }
1803 1805
1804 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan); 1806 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
1805 DQUOT_INIT(inode); 1807 vfs_dq_init(inode);
1806 if (inode->i_nlink) { 1808 if (inode->i_nlink) {
1807 printk(KERN_DEBUG 1809 printk(KERN_DEBUG
1808 "%s: truncating inode %lu to %lld bytes\n", 1810 "%s: truncating inode %lu to %lld bytes\n",
@@ -3367,8 +3369,8 @@ static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
3367 * is locked for write. Otherwise the are possible deadlocks: 3369 * is locked for write. Otherwise the are possible deadlocks:
3368 * Process 1 Process 2 3370 * Process 1 Process 2
3369 * ext4_create() quota_sync() 3371 * ext4_create() quota_sync()
3370 * jbd2_journal_start() write_dquot() 3372 * jbd2_journal_start() write_dquot()
3371 * DQUOT_INIT() down(dqio_mutex) 3373 * vfs_dq_init() down(dqio_mutex)
3372 * down(dqio_mutex) jbd2_journal_start() 3374 * down(dqio_mutex) jbd2_journal_start()
3373 * 3375 *
3374 */ 3376 */
@@ -3380,44 +3382,6 @@ static inline struct inode *dquot_to_inode(struct dquot *dquot)
3380 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type]; 3382 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
3381} 3383}
3382 3384
3383static int ext4_dquot_initialize(struct inode *inode, int type)
3384{
3385 handle_t *handle;
3386 int ret, err;
3387
3388 /* We may create quota structure so we need to reserve enough blocks */
3389 handle = ext4_journal_start(inode, 2*EXT4_QUOTA_INIT_BLOCKS(inode->i_sb));
3390 if (IS_ERR(handle))
3391 return PTR_ERR(handle);
3392 ret = dquot_initialize(inode, type);
3393 err = ext4_journal_stop(handle);
3394 if (!ret)
3395 ret = err;
3396 return ret;
3397}
3398
3399static int ext4_dquot_drop(struct inode *inode)
3400{
3401 handle_t *handle;
3402 int ret, err;
3403
3404 /* We may delete quota structure so we need to reserve enough blocks */
3405 handle = ext4_journal_start(inode, 2*EXT4_QUOTA_DEL_BLOCKS(inode->i_sb));
3406 if (IS_ERR(handle)) {
3407 /*
3408 * We call dquot_drop() anyway to at least release references
3409 * to quota structures so that umount does not hang.
3410 */
3411 dquot_drop(inode);
3412 return PTR_ERR(handle);
3413 }
3414 ret = dquot_drop(inode);
3415 err = ext4_journal_stop(handle);
3416 if (!ret)
3417 ret = err;
3418 return ret;
3419}
3420
3421static int ext4_write_dquot(struct dquot *dquot) 3385static int ext4_write_dquot(struct dquot *dquot)
3422{ 3386{
3423 int ret, err; 3387 int ret, err;
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 157ce6589c54..62b31c246994 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -490,7 +490,7 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode,
490 error = ext4_handle_dirty_metadata(handle, inode, bh); 490 error = ext4_handle_dirty_metadata(handle, inode, bh);
491 if (IS_SYNC(inode)) 491 if (IS_SYNC(inode))
492 ext4_handle_sync(handle); 492 ext4_handle_sync(handle);
493 DQUOT_FREE_BLOCK(inode, 1); 493 vfs_dq_free_block(inode, 1);
494 ea_bdebug(bh, "refcount now=%d; releasing", 494 ea_bdebug(bh, "refcount now=%d; releasing",
495 le32_to_cpu(BHDR(bh)->h_refcount)); 495 le32_to_cpu(BHDR(bh)->h_refcount));
496 if (ce) 496 if (ce)
@@ -784,7 +784,7 @@ inserted:
784 /* The old block is released after updating 784 /* The old block is released after updating
785 the inode. */ 785 the inode. */
786 error = -EDQUOT; 786 error = -EDQUOT;
787 if (DQUOT_ALLOC_BLOCK(inode, 1)) 787 if (vfs_dq_alloc_block(inode, 1))
788 goto cleanup; 788 goto cleanup;
789 error = ext4_journal_get_write_access(handle, 789 error = ext4_journal_get_write_access(handle,
790 new_bh); 790 new_bh);
@@ -860,7 +860,7 @@ cleanup:
860 return error; 860 return error;
861 861
862cleanup_dquot: 862cleanup_dquot:
863 DQUOT_FREE_BLOCK(inode, 1); 863 vfs_dq_free_block(inode, 1);
864 goto cleanup; 864 goto cleanup;
865 865
866bad_block: 866bad_block:
diff --git a/fs/inode.c b/fs/inode.c
index 643ac43e5a5c..29df4a297449 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -294,7 +294,7 @@ void clear_inode(struct inode *inode)
294 BUG_ON(!(inode->i_state & I_FREEING)); 294 BUG_ON(!(inode->i_state & I_FREEING));
295 BUG_ON(inode->i_state & I_CLEAR); 295 BUG_ON(inode->i_state & I_CLEAR);
296 inode_sync_wait(inode); 296 inode_sync_wait(inode);
297 DQUOT_DROP(inode); 297 vfs_dq_drop(inode);
298 if (inode->i_sb->s_op->clear_inode) 298 if (inode->i_sb->s_op->clear_inode)
299 inode->i_sb->s_op->clear_inode(inode); 299 inode->i_sb->s_op->clear_inode(inode);
300 if (S_ISBLK(inode->i_mode) && inode->i_bdev) 300 if (S_ISBLK(inode->i_mode) && inode->i_bdev)
@@ -1168,7 +1168,7 @@ void generic_delete_inode(struct inode *inode)
1168 if (op->delete_inode) { 1168 if (op->delete_inode) {
1169 void (*delete)(struct inode *) = op->delete_inode; 1169 void (*delete)(struct inode *) = op->delete_inode;
1170 if (!is_bad_inode(inode)) 1170 if (!is_bad_inode(inode))
1171 DQUOT_INIT(inode); 1171 vfs_dq_init(inode);
1172 /* Filesystems implementing their own 1172 /* Filesystems implementing their own
1173 * s_op->delete_inode are required to call 1173 * s_op->delete_inode are required to call
1174 * truncate_inode_pages and clear_inode() 1174 * truncate_inode_pages and clear_inode()
diff --git a/fs/jfs/acl.c b/fs/jfs/acl.c
index d3e5c33665de..a166c1669e82 100644
--- a/fs/jfs/acl.c
+++ b/fs/jfs/acl.c
@@ -233,7 +233,7 @@ int jfs_setattr(struct dentry *dentry, struct iattr *iattr)
233 233
234 if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) || 234 if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
235 (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) { 235 (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
236 if (DQUOT_TRANSFER(inode, iattr)) 236 if (vfs_dq_transfer(inode, iattr))
237 return -EDQUOT; 237 return -EDQUOT;
238 } 238 }
239 239
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index b00ee9f05a06..b2ae190a77ba 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -158,9 +158,9 @@ void jfs_delete_inode(struct inode *inode)
158 /* 158 /*
159 * Free the inode from the quota allocation. 159 * Free the inode from the quota allocation.
160 */ 160 */
161 DQUOT_INIT(inode); 161 vfs_dq_init(inode);
162 DQUOT_FREE_INODE(inode); 162 vfs_dq_free_inode(inode);
163 DQUOT_DROP(inode); 163 vfs_dq_drop(inode);
164 } 164 }
165 165
166 clear_inode(inode); 166 clear_inode(inode);
diff --git a/fs/jfs/jfs_dtree.c b/fs/jfs/jfs_dtree.c
index 4dcc05819998..925871e9887b 100644
--- a/fs/jfs/jfs_dtree.c
+++ b/fs/jfs/jfs_dtree.c
@@ -381,10 +381,10 @@ static u32 add_index(tid_t tid, struct inode *ip, s64 bn, int slot)
381 * It's time to move the inline table to an external 381 * It's time to move the inline table to an external
382 * page and begin to build the xtree 382 * page and begin to build the xtree
383 */ 383 */
384 if (DQUOT_ALLOC_BLOCK(ip, sbi->nbperpage)) 384 if (vfs_dq_alloc_block(ip, sbi->nbperpage))
385 goto clean_up; 385 goto clean_up;
386 if (dbAlloc(ip, 0, sbi->nbperpage, &xaddr)) { 386 if (dbAlloc(ip, 0, sbi->nbperpage, &xaddr)) {
387 DQUOT_FREE_BLOCK(ip, sbi->nbperpage); 387 vfs_dq_free_block(ip, sbi->nbperpage);
388 goto clean_up; 388 goto clean_up;
389 } 389 }
390 390
@@ -408,7 +408,7 @@ static u32 add_index(tid_t tid, struct inode *ip, s64 bn, int slot)
408 memcpy(&jfs_ip->i_dirtable, temp_table, 408 memcpy(&jfs_ip->i_dirtable, temp_table,
409 sizeof (temp_table)); 409 sizeof (temp_table));
410 dbFree(ip, xaddr, sbi->nbperpage); 410 dbFree(ip, xaddr, sbi->nbperpage);
411 DQUOT_FREE_BLOCK(ip, sbi->nbperpage); 411 vfs_dq_free_block(ip, sbi->nbperpage);
412 goto clean_up; 412 goto clean_up;
413 } 413 }
414 ip->i_size = PSIZE; 414 ip->i_size = PSIZE;
@@ -1027,7 +1027,7 @@ static int dtSplitUp(tid_t tid,
1027 n = xlen; 1027 n = xlen;
1028 1028
1029 /* Allocate blocks to quota. */ 1029 /* Allocate blocks to quota. */
1030 if (DQUOT_ALLOC_BLOCK(ip, n)) { 1030 if (vfs_dq_alloc_block(ip, n)) {
1031 rc = -EDQUOT; 1031 rc = -EDQUOT;
1032 goto extendOut; 1032 goto extendOut;
1033 } 1033 }
@@ -1308,7 +1308,7 @@ static int dtSplitUp(tid_t tid,
1308 1308
1309 /* Rollback quota allocation */ 1309 /* Rollback quota allocation */
1310 if (rc && quota_allocation) 1310 if (rc && quota_allocation)
1311 DQUOT_FREE_BLOCK(ip, quota_allocation); 1311 vfs_dq_free_block(ip, quota_allocation);
1312 1312
1313 dtSplitUp_Exit: 1313 dtSplitUp_Exit:
1314 1314
@@ -1369,7 +1369,7 @@ static int dtSplitPage(tid_t tid, struct inode *ip, struct dtsplit * split,
1369 return -EIO; 1369 return -EIO;
1370 1370
1371 /* Allocate blocks to quota. */ 1371 /* Allocate blocks to quota. */
1372 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) { 1372 if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
1373 release_metapage(rmp); 1373 release_metapage(rmp);
1374 return -EDQUOT; 1374 return -EDQUOT;
1375 } 1375 }
@@ -1916,7 +1916,7 @@ static int dtSplitRoot(tid_t tid,
1916 rp = rmp->data; 1916 rp = rmp->data;
1917 1917
1918 /* Allocate blocks to quota. */ 1918 /* Allocate blocks to quota. */
1919 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) { 1919 if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
1920 release_metapage(rmp); 1920 release_metapage(rmp);
1921 return -EDQUOT; 1921 return -EDQUOT;
1922 } 1922 }
@@ -2287,7 +2287,7 @@ static int dtDeleteUp(tid_t tid, struct inode *ip,
2287 xlen = lengthPXD(&fp->header.self); 2287 xlen = lengthPXD(&fp->header.self);
2288 2288
2289 /* Free quota allocation. */ 2289 /* Free quota allocation. */
2290 DQUOT_FREE_BLOCK(ip, xlen); 2290 vfs_dq_free_block(ip, xlen);
2291 2291
2292 /* free/invalidate its buffer page */ 2292 /* free/invalidate its buffer page */
2293 discard_metapage(fmp); 2293 discard_metapage(fmp);
@@ -2363,7 +2363,7 @@ static int dtDeleteUp(tid_t tid, struct inode *ip,
2363 xlen = lengthPXD(&p->header.self); 2363 xlen = lengthPXD(&p->header.self);
2364 2364
2365 /* Free quota allocation */ 2365 /* Free quota allocation */
2366 DQUOT_FREE_BLOCK(ip, xlen); 2366 vfs_dq_free_block(ip, xlen);
2367 2367
2368 /* free/invalidate its buffer page */ 2368 /* free/invalidate its buffer page */
2369 discard_metapage(mp); 2369 discard_metapage(mp);
diff --git a/fs/jfs/jfs_extent.c b/fs/jfs/jfs_extent.c
index 7ae1e3281de9..169802ea07f9 100644
--- a/fs/jfs/jfs_extent.c
+++ b/fs/jfs/jfs_extent.c
@@ -141,7 +141,7 @@ extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
141 } 141 }
142 142
143 /* Allocate blocks to quota. */ 143 /* Allocate blocks to quota. */
144 if (DQUOT_ALLOC_BLOCK(ip, nxlen)) { 144 if (vfs_dq_alloc_block(ip, nxlen)) {
145 dbFree(ip, nxaddr, (s64) nxlen); 145 dbFree(ip, nxaddr, (s64) nxlen);
146 mutex_unlock(&JFS_IP(ip)->commit_mutex); 146 mutex_unlock(&JFS_IP(ip)->commit_mutex);
147 return -EDQUOT; 147 return -EDQUOT;
@@ -164,7 +164,7 @@ extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
164 */ 164 */
165 if (rc) { 165 if (rc) {
166 dbFree(ip, nxaddr, nxlen); 166 dbFree(ip, nxaddr, nxlen);
167 DQUOT_FREE_BLOCK(ip, nxlen); 167 vfs_dq_free_block(ip, nxlen);
168 mutex_unlock(&JFS_IP(ip)->commit_mutex); 168 mutex_unlock(&JFS_IP(ip)->commit_mutex);
169 return (rc); 169 return (rc);
170 } 170 }
@@ -256,7 +256,7 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
256 goto exit; 256 goto exit;
257 257
258 /* Allocat blocks to quota. */ 258 /* Allocat blocks to quota. */
259 if (DQUOT_ALLOC_BLOCK(ip, nxlen)) { 259 if (vfs_dq_alloc_block(ip, nxlen)) {
260 dbFree(ip, nxaddr, (s64) nxlen); 260 dbFree(ip, nxaddr, (s64) nxlen);
261 mutex_unlock(&JFS_IP(ip)->commit_mutex); 261 mutex_unlock(&JFS_IP(ip)->commit_mutex);
262 return -EDQUOT; 262 return -EDQUOT;
@@ -297,7 +297,7 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
297 /* extend the extent */ 297 /* extend the extent */
298 if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) { 298 if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
299 dbFree(ip, xaddr + xlen, delta); 299 dbFree(ip, xaddr + xlen, delta);
300 DQUOT_FREE_BLOCK(ip, nxlen); 300 vfs_dq_free_block(ip, nxlen);
301 goto exit; 301 goto exit;
302 } 302 }
303 } else { 303 } else {
@@ -308,7 +308,7 @@ int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
308 */ 308 */
309 if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) { 309 if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
310 dbFree(ip, nxaddr, nxlen); 310 dbFree(ip, nxaddr, nxlen);
311 DQUOT_FREE_BLOCK(ip, nxlen); 311 vfs_dq_free_block(ip, nxlen);
312 goto exit; 312 goto exit;
313 } 313 }
314 } 314 }
diff --git a/fs/jfs/jfs_inode.c b/fs/jfs/jfs_inode.c
index d4d142c2edd4..dc0e02159ac9 100644
--- a/fs/jfs/jfs_inode.c
+++ b/fs/jfs/jfs_inode.c
@@ -116,7 +116,7 @@ struct inode *ialloc(struct inode *parent, umode_t mode)
116 /* 116 /*
117 * Allocate inode to quota. 117 * Allocate inode to quota.
118 */ 118 */
119 if (DQUOT_ALLOC_INODE(inode)) { 119 if (vfs_dq_alloc_inode(inode)) {
120 rc = -EDQUOT; 120 rc = -EDQUOT;
121 goto fail_drop; 121 goto fail_drop;
122 } 122 }
@@ -162,7 +162,7 @@ struct inode *ialloc(struct inode *parent, umode_t mode)
162 return inode; 162 return inode;
163 163
164fail_drop: 164fail_drop:
165 DQUOT_DROP(inode); 165 vfs_dq_drop(inode);
166 inode->i_flags |= S_NOQUOTA; 166 inode->i_flags |= S_NOQUOTA;
167fail_unlock: 167fail_unlock:
168 inode->i_nlink = 0; 168 inode->i_nlink = 0;
diff --git a/fs/jfs/jfs_xtree.c b/fs/jfs/jfs_xtree.c
index ae3acafb447b..a27e26c90568 100644
--- a/fs/jfs/jfs_xtree.c
+++ b/fs/jfs/jfs_xtree.c
@@ -846,10 +846,10 @@ int xtInsert(tid_t tid, /* transaction id */
846 hint = addressXAD(xad) + lengthXAD(xad) - 1; 846 hint = addressXAD(xad) + lengthXAD(xad) - 1;
847 } else 847 } else
848 hint = 0; 848 hint = 0;
849 if ((rc = DQUOT_ALLOC_BLOCK(ip, xlen))) 849 if ((rc = vfs_dq_alloc_block(ip, xlen)))
850 goto out; 850 goto out;
851 if ((rc = dbAlloc(ip, hint, (s64) xlen, &xaddr))) { 851 if ((rc = dbAlloc(ip, hint, (s64) xlen, &xaddr))) {
852 DQUOT_FREE_BLOCK(ip, xlen); 852 vfs_dq_free_block(ip, xlen);
853 goto out; 853 goto out;
854 } 854 }
855 } 855 }
@@ -878,7 +878,7 @@ int xtInsert(tid_t tid, /* transaction id */
878 /* undo data extent allocation */ 878 /* undo data extent allocation */
879 if (*xaddrp == 0) { 879 if (*xaddrp == 0) {
880 dbFree(ip, xaddr, (s64) xlen); 880 dbFree(ip, xaddr, (s64) xlen);
881 DQUOT_FREE_BLOCK(ip, xlen); 881 vfs_dq_free_block(ip, xlen);
882 } 882 }
883 return rc; 883 return rc;
884 } 884 }
@@ -1246,7 +1246,7 @@ xtSplitPage(tid_t tid, struct inode *ip,
1246 rbn = addressPXD(pxd); 1246 rbn = addressPXD(pxd);
1247 1247
1248 /* Allocate blocks to quota. */ 1248 /* Allocate blocks to quota. */
1249 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) { 1249 if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
1250 rc = -EDQUOT; 1250 rc = -EDQUOT;
1251 goto clean_up; 1251 goto clean_up;
1252 } 1252 }
@@ -1456,7 +1456,7 @@ xtSplitPage(tid_t tid, struct inode *ip,
1456 1456
1457 /* Rollback quota allocation. */ 1457 /* Rollback quota allocation. */
1458 if (quota_allocation) 1458 if (quota_allocation)
1459 DQUOT_FREE_BLOCK(ip, quota_allocation); 1459 vfs_dq_free_block(ip, quota_allocation);
1460 1460
1461 return (rc); 1461 return (rc);
1462} 1462}
@@ -1513,7 +1513,7 @@ xtSplitRoot(tid_t tid,
1513 return -EIO; 1513 return -EIO;
1514 1514
1515 /* Allocate blocks to quota. */ 1515 /* Allocate blocks to quota. */
1516 if (DQUOT_ALLOC_BLOCK(ip, lengthPXD(pxd))) { 1516 if (vfs_dq_alloc_block(ip, lengthPXD(pxd))) {
1517 release_metapage(rmp); 1517 release_metapage(rmp);
1518 return -EDQUOT; 1518 return -EDQUOT;
1519 } 1519 }
@@ -3941,7 +3941,7 @@ s64 xtTruncate(tid_t tid, struct inode *ip, s64 newsize, int flag)
3941 ip->i_size = newsize; 3941 ip->i_size = newsize;
3942 3942
3943 /* update quota allocation to reflect freed blocks */ 3943 /* update quota allocation to reflect freed blocks */
3944 DQUOT_FREE_BLOCK(ip, nfreed); 3944 vfs_dq_free_block(ip, nfreed);
3945 3945
3946 /* 3946 /*
3947 * free tlock of invalidated pages 3947 * free tlock of invalidated pages
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index b4de56b851e4..9feaa04555d2 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -356,7 +356,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
356 jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name); 356 jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
357 357
358 /* Init inode for quota operations. */ 358 /* Init inode for quota operations. */
359 DQUOT_INIT(ip); 359 vfs_dq_init(ip);
360 360
361 /* directory must be empty to be removed */ 361 /* directory must be empty to be removed */
362 if (!dtEmpty(ip)) { 362 if (!dtEmpty(ip)) {
@@ -483,7 +483,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
483 jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name); 483 jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
484 484
485 /* Init inode for quota operations. */ 485 /* Init inode for quota operations. */
486 DQUOT_INIT(ip); 486 vfs_dq_init(ip);
487 487
488 if ((rc = get_UCSname(&dname, dentry))) 488 if ((rc = get_UCSname(&dname, dentry)))
489 goto out; 489 goto out;
@@ -1136,7 +1136,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1136 } else if (new_ip) { 1136 } else if (new_ip) {
1137 IWRITE_LOCK(new_ip, RDWRLOCK_NORMAL); 1137 IWRITE_LOCK(new_ip, RDWRLOCK_NORMAL);
1138 /* Init inode for quota operations. */ 1138 /* Init inode for quota operations. */
1139 DQUOT_INIT(new_ip); 1139 vfs_dq_init(new_ip);
1140 } 1140 }
1141 1141
1142 /* 1142 /*
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index 9b7f2cdaae0a..61dfa8173ebc 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -260,14 +260,14 @@ static int ea_write(struct inode *ip, struct jfs_ea_list *ealist, int size,
260 nblocks = (size + (sb->s_blocksize - 1)) >> sb->s_blocksize_bits; 260 nblocks = (size + (sb->s_blocksize - 1)) >> sb->s_blocksize_bits;
261 261
262 /* Allocate new blocks to quota. */ 262 /* Allocate new blocks to quota. */
263 if (DQUOT_ALLOC_BLOCK(ip, nblocks)) { 263 if (vfs_dq_alloc_block(ip, nblocks)) {
264 return -EDQUOT; 264 return -EDQUOT;
265 } 265 }
266 266
267 rc = dbAlloc(ip, INOHINT(ip), nblocks, &blkno); 267 rc = dbAlloc(ip, INOHINT(ip), nblocks, &blkno);
268 if (rc) { 268 if (rc) {
269 /*Rollback quota allocation. */ 269 /*Rollback quota allocation. */
270 DQUOT_FREE_BLOCK(ip, nblocks); 270 vfs_dq_free_block(ip, nblocks);
271 return rc; 271 return rc;
272 } 272 }
273 273
@@ -332,7 +332,7 @@ static int ea_write(struct inode *ip, struct jfs_ea_list *ealist, int size,
332 332
333 failed: 333 failed:
334 /* Rollback quota allocation. */ 334 /* Rollback quota allocation. */
335 DQUOT_FREE_BLOCK(ip, nblocks); 335 vfs_dq_free_block(ip, nblocks);
336 336
337 dbFree(ip, blkno, nblocks); 337 dbFree(ip, blkno, nblocks);
338 return rc; 338 return rc;
@@ -538,7 +538,7 @@ static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
538 538
539 if (blocks_needed > current_blocks) { 539 if (blocks_needed > current_blocks) {
540 /* Allocate new blocks to quota. */ 540 /* Allocate new blocks to quota. */
541 if (DQUOT_ALLOC_BLOCK(inode, blocks_needed)) 541 if (vfs_dq_alloc_block(inode, blocks_needed))
542 return -EDQUOT; 542 return -EDQUOT;
543 543
544 quota_allocation = blocks_needed; 544 quota_allocation = blocks_needed;
@@ -602,7 +602,7 @@ static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
602 clean_up: 602 clean_up:
603 /* Rollback quota allocation */ 603 /* Rollback quota allocation */
604 if (quota_allocation) 604 if (quota_allocation)
605 DQUOT_FREE_BLOCK(inode, quota_allocation); 605 vfs_dq_free_block(inode, quota_allocation);
606 606
607 return (rc); 607 return (rc);
608} 608}
@@ -677,7 +677,7 @@ static int ea_put(tid_t tid, struct inode *inode, struct ea_buffer *ea_buf,
677 677
678 /* If old blocks exist, they must be removed from quota allocation. */ 678 /* If old blocks exist, they must be removed from quota allocation. */
679 if (old_blocks) 679 if (old_blocks)
680 DQUOT_FREE_BLOCK(inode, old_blocks); 680 vfs_dq_free_block(inode, old_blocks);
681 681
682 inode->i_ctime = CURRENT_TIME; 682 inode->i_ctime = CURRENT_TIME;
683 683
diff --git a/fs/namei.c b/fs/namei.c
index 199317642ad6..1928197b3874 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1473,7 +1473,7 @@ int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1473 error = security_inode_create(dir, dentry, mode); 1473 error = security_inode_create(dir, dentry, mode);
1474 if (error) 1474 if (error)
1475 return error; 1475 return error;
1476 DQUOT_INIT(dir); 1476 vfs_dq_init(dir);
1477 error = dir->i_op->create(dir, dentry, mode, nd); 1477 error = dir->i_op->create(dir, dentry, mode, nd);
1478 if (!error) 1478 if (!error)
1479 fsnotify_create(dir, dentry); 1479 fsnotify_create(dir, dentry);
@@ -1552,7 +1552,7 @@ int may_open(struct path *path, int acc_mode, int flag)
1552 error = security_path_truncate(path, 0, 1552 error = security_path_truncate(path, 0,
1553 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN); 1553 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
1554 if (!error) { 1554 if (!error) {
1555 DQUOT_INIT(inode); 1555 vfs_dq_init(inode);
1556 1556
1557 error = do_truncate(dentry, 0, 1557 error = do_truncate(dentry, 0,
1558 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN, 1558 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
@@ -1563,7 +1563,7 @@ int may_open(struct path *path, int acc_mode, int flag)
1563 return error; 1563 return error;
1564 } else 1564 } else
1565 if (flag & FMODE_WRITE) 1565 if (flag & FMODE_WRITE)
1566 DQUOT_INIT(inode); 1566 vfs_dq_init(inode);
1567 1567
1568 return 0; 1568 return 0;
1569} 1569}
@@ -1946,7 +1946,7 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
1946 if (error) 1946 if (error)
1947 return error; 1947 return error;
1948 1948
1949 DQUOT_INIT(dir); 1949 vfs_dq_init(dir);
1950 error = dir->i_op->mknod(dir, dentry, mode, dev); 1950 error = dir->i_op->mknod(dir, dentry, mode, dev);
1951 if (!error) 1951 if (!error)
1952 fsnotify_create(dir, dentry); 1952 fsnotify_create(dir, dentry);
@@ -2045,7 +2045,7 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2045 if (error) 2045 if (error)
2046 return error; 2046 return error;
2047 2047
2048 DQUOT_INIT(dir); 2048 vfs_dq_init(dir);
2049 error = dir->i_op->mkdir(dir, dentry, mode); 2049 error = dir->i_op->mkdir(dir, dentry, mode);
2050 if (!error) 2050 if (!error)
2051 fsnotify_mkdir(dir, dentry); 2051 fsnotify_mkdir(dir, dentry);
@@ -2131,7 +2131,7 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2131 if (!dir->i_op->rmdir) 2131 if (!dir->i_op->rmdir)
2132 return -EPERM; 2132 return -EPERM;
2133 2133
2134 DQUOT_INIT(dir); 2134 vfs_dq_init(dir);
2135 2135
2136 mutex_lock(&dentry->d_inode->i_mutex); 2136 mutex_lock(&dentry->d_inode->i_mutex);
2137 dentry_unhash(dentry); 2137 dentry_unhash(dentry);
@@ -2218,7 +2218,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry)
2218 if (!dir->i_op->unlink) 2218 if (!dir->i_op->unlink)
2219 return -EPERM; 2219 return -EPERM;
2220 2220
2221 DQUOT_INIT(dir); 2221 vfs_dq_init(dir);
2222 2222
2223 mutex_lock(&dentry->d_inode->i_mutex); 2223 mutex_lock(&dentry->d_inode->i_mutex);
2224 if (d_mountpoint(dentry)) 2224 if (d_mountpoint(dentry))
@@ -2329,7 +2329,7 @@ int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2329 if (error) 2329 if (error)
2330 return error; 2330 return error;
2331 2331
2332 DQUOT_INIT(dir); 2332 vfs_dq_init(dir);
2333 error = dir->i_op->symlink(dir, dentry, oldname); 2333 error = dir->i_op->symlink(dir, dentry, oldname);
2334 if (!error) 2334 if (!error)
2335 fsnotify_create(dir, dentry); 2335 fsnotify_create(dir, dentry);
@@ -2413,7 +2413,7 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
2413 return error; 2413 return error;
2414 2414
2415 mutex_lock(&inode->i_mutex); 2415 mutex_lock(&inode->i_mutex);
2416 DQUOT_INIT(dir); 2416 vfs_dq_init(dir);
2417 error = dir->i_op->link(old_dentry, dir, new_dentry); 2417 error = dir->i_op->link(old_dentry, dir, new_dentry);
2418 mutex_unlock(&inode->i_mutex); 2418 mutex_unlock(&inode->i_mutex);
2419 if (!error) 2419 if (!error)
@@ -2612,8 +2612,8 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2612 if (!old_dir->i_op->rename) 2612 if (!old_dir->i_op->rename)
2613 return -EPERM; 2613 return -EPERM;
2614 2614
2615 DQUOT_INIT(old_dir); 2615 vfs_dq_init(old_dir);
2616 DQUOT_INIT(new_dir); 2616 vfs_dq_init(new_dir);
2617 2617
2618 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 2618 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2619 2619
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index c165a6403df0..78376b6c0236 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -356,7 +356,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
356 put_write_access(inode); 356 put_write_access(inode);
357 goto out_nfserr; 357 goto out_nfserr;
358 } 358 }
359 DQUOT_INIT(inode); 359 vfs_dq_init(inode);
360 } 360 }
361 361
362 /* sanitize the mode change */ 362 /* sanitize the mode change */
@@ -723,7 +723,7 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
723 else 723 else
724 flags = O_WRONLY|O_LARGEFILE; 724 flags = O_WRONLY|O_LARGEFILE;
725 725
726 DQUOT_INIT(inode); 726 vfs_dq_init(inode);
727 } 727 }
728 *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt), 728 *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt),
729 flags, cred); 729 flags, cred);
diff --git a/fs/open.c b/fs/open.c
index a3a78ceb2a2b..75b61677daaf 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -273,7 +273,7 @@ static long do_sys_truncate(const char __user *pathname, loff_t length)
273 if (!error) 273 if (!error)
274 error = security_path_truncate(&path, length, 0); 274 error = security_path_truncate(&path, length, 0);
275 if (!error) { 275 if (!error) {
276 DQUOT_INIT(inode); 276 vfs_dq_init(inode);
277 error = do_truncate(path.dentry, length, 0, NULL); 277 error = do_truncate(path.dentry, length, 0, NULL);
278 } 278 }
279 279
diff --git a/fs/quota/Kconfig b/fs/quota/Kconfig
new file mode 100644
index 000000000000..8047e01ef46b
--- /dev/null
+++ b/fs/quota/Kconfig
@@ -0,0 +1,59 @@
1#
2# Quota configuration
3#
4
5config QUOTA
6 bool "Quota support"
7 help
8 If you say Y here, you will be able to set per user limits for disk
9 usage (also called disk quotas). Currently, it works for the
10 ext2, ext3, and reiserfs file system. ext3 also supports journalled
11 quotas for which you don't need to run quotacheck(8) after an unclean
12 shutdown.
13 For further details, read the Quota mini-HOWTO, available from
14 <http://www.tldp.org/docs.html#howto>, or the documentation provided
15 with the quota tools. Probably the quota support is only useful for
16 multi user systems. If unsure, say N.
17
18config QUOTA_NETLINK_INTERFACE
19 bool "Report quota messages through netlink interface"
20 depends on QUOTA && NET
21 help
22 If you say Y here, quota warnings (about exceeding softlimit, reaching
23 hardlimit, etc.) will be reported through netlink interface. If unsure,
24 say Y.
25
26config PRINT_QUOTA_WARNING
27 bool "Print quota warnings to console (OBSOLETE)"
28 depends on QUOTA
29 default y
30 help
31 If you say Y here, quota warnings (about exceeding softlimit, reaching
32 hardlimit, etc.) will be printed to the process' controlling terminal.
33 Note that this behavior is currently deprecated and may go away in
34 future. Please use notification via netlink socket instead.
35
36# Generic support for tree structured quota files. Selected when needed.
37config QUOTA_TREE
38 tristate
39
40config QFMT_V1
41 tristate "Old quota format support"
42 depends on QUOTA
43 help
44 This quota format was (is) used by kernels earlier than 2.4.22. If
45 you have quota working and you don't want to convert to new quota
46 format say Y here.
47
48config QFMT_V2
49 tristate "Quota format v2 support"
50 depends on QUOTA
51 select QUOTA_TREE
52 help
53 This quota format allows using quotas with 32-bit UIDs/GIDs. If you
54 need this functionality say Y here.
55
56config QUOTACTL
57 bool
58 depends on XFS_QUOTA || QUOTA
59 default y
diff --git a/fs/quota/Makefile b/fs/quota/Makefile
new file mode 100644
index 000000000000..385a0831cc99
--- /dev/null
+++ b/fs/quota/Makefile
@@ -0,0 +1,14 @@
1#
2# Makefile for the Linux filesystems.
3#
4# 14 Sep 2000, Christoph Hellwig <hch@infradead.org>
5# Rewritten to use lists instead of if-statements.
6#
7
8obj-y :=
9
10obj-$(CONFIG_QUOTA) += dquot.o
11obj-$(CONFIG_QFMT_V1) += quota_v1.o
12obj-$(CONFIG_QFMT_V2) += quota_v2.o
13obj-$(CONFIG_QUOTA_TREE) += quota_tree.o
14obj-$(CONFIG_QUOTACTL) += quota.o
diff --git a/fs/dquot.c b/fs/quota/dquot.c
index d6add0bf5ad3..eb938015bd91 100644
--- a/fs/dquot.c
+++ b/fs/quota/dquot.c
@@ -129,9 +129,10 @@
129 * i_mutex on quota files is special (it's below dqio_mutex) 129 * i_mutex on quota files is special (it's below dqio_mutex)
130 */ 130 */
131 131
132static DEFINE_SPINLOCK(dq_list_lock); 132static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
133static DEFINE_SPINLOCK(dq_state_lock); 133static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
134DEFINE_SPINLOCK(dq_data_lock); 134__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
135EXPORT_SYMBOL(dq_data_lock);
135 136
136static char *quotatypes[] = INITQFNAMES; 137static char *quotatypes[] = INITQFNAMES;
137static struct quota_format_type *quota_formats; /* List of registered formats */ 138static struct quota_format_type *quota_formats; /* List of registered formats */
@@ -148,35 +149,46 @@ int register_quota_format(struct quota_format_type *fmt)
148 spin_unlock(&dq_list_lock); 149 spin_unlock(&dq_list_lock);
149 return 0; 150 return 0;
150} 151}
152EXPORT_SYMBOL(register_quota_format);
151 153
152void unregister_quota_format(struct quota_format_type *fmt) 154void unregister_quota_format(struct quota_format_type *fmt)
153{ 155{
154 struct quota_format_type **actqf; 156 struct quota_format_type **actqf;
155 157
156 spin_lock(&dq_list_lock); 158 spin_lock(&dq_list_lock);
157 for (actqf = &quota_formats; *actqf && *actqf != fmt; actqf = &(*actqf)->qf_next); 159 for (actqf = &quota_formats; *actqf && *actqf != fmt;
160 actqf = &(*actqf)->qf_next)
161 ;
158 if (*actqf) 162 if (*actqf)
159 *actqf = (*actqf)->qf_next; 163 *actqf = (*actqf)->qf_next;
160 spin_unlock(&dq_list_lock); 164 spin_unlock(&dq_list_lock);
161} 165}
166EXPORT_SYMBOL(unregister_quota_format);
162 167
163static struct quota_format_type *find_quota_format(int id) 168static struct quota_format_type *find_quota_format(int id)
164{ 169{
165 struct quota_format_type *actqf; 170 struct quota_format_type *actqf;
166 171
167 spin_lock(&dq_list_lock); 172 spin_lock(&dq_list_lock);
168 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 173 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
174 actqf = actqf->qf_next)
175 ;
169 if (!actqf || !try_module_get(actqf->qf_owner)) { 176 if (!actqf || !try_module_get(actqf->qf_owner)) {
170 int qm; 177 int qm;
171 178
172 spin_unlock(&dq_list_lock); 179 spin_unlock(&dq_list_lock);
173 180
174 for (qm = 0; module_names[qm].qm_fmt_id && module_names[qm].qm_fmt_id != id; qm++); 181 for (qm = 0; module_names[qm].qm_fmt_id &&
175 if (!module_names[qm].qm_fmt_id || request_module(module_names[qm].qm_mod_name)) 182 module_names[qm].qm_fmt_id != id; qm++)
183 ;
184 if (!module_names[qm].qm_fmt_id ||
185 request_module(module_names[qm].qm_mod_name))
176 return NULL; 186 return NULL;
177 187
178 spin_lock(&dq_list_lock); 188 spin_lock(&dq_list_lock);
179 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; actqf = actqf->qf_next); 189 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
190 actqf = actqf->qf_next)
191 ;
180 if (actqf && !try_module_get(actqf->qf_owner)) 192 if (actqf && !try_module_get(actqf->qf_owner))
181 actqf = NULL; 193 actqf = NULL;
182 } 194 }
@@ -215,6 +227,7 @@ static unsigned int dq_hash_bits, dq_hash_mask;
215static struct hlist_head *dquot_hash; 227static struct hlist_head *dquot_hash;
216 228
217struct dqstats dqstats; 229struct dqstats dqstats;
230EXPORT_SYMBOL(dqstats);
218 231
219static inline unsigned int 232static inline unsigned int
220hashfn(const struct super_block *sb, unsigned int id, int type) 233hashfn(const struct super_block *sb, unsigned int id, int type)
@@ -230,7 +243,8 @@ hashfn(const struct super_block *sb, unsigned int id, int type)
230 */ 243 */
231static inline void insert_dquot_hash(struct dquot *dquot) 244static inline void insert_dquot_hash(struct dquot *dquot)
232{ 245{
233 struct hlist_head *head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type); 246 struct hlist_head *head;
247 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type);
234 hlist_add_head(&dquot->dq_hash, head); 248 hlist_add_head(&dquot->dq_hash, head);
235} 249}
236 250
@@ -239,17 +253,19 @@ static inline void remove_dquot_hash(struct dquot *dquot)
239 hlist_del_init(&dquot->dq_hash); 253 hlist_del_init(&dquot->dq_hash);
240} 254}
241 255
242static inline struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, unsigned int id, int type) 256static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
257 unsigned int id, int type)
243{ 258{
244 struct hlist_node *node; 259 struct hlist_node *node;
245 struct dquot *dquot; 260 struct dquot *dquot;
246 261
247 hlist_for_each (node, dquot_hash+hashent) { 262 hlist_for_each (node, dquot_hash+hashent) {
248 dquot = hlist_entry(node, struct dquot, dq_hash); 263 dquot = hlist_entry(node, struct dquot, dq_hash);
249 if (dquot->dq_sb == sb && dquot->dq_id == id && dquot->dq_type == type) 264 if (dquot->dq_sb == sb && dquot->dq_id == id &&
265 dquot->dq_type == type)
250 return dquot; 266 return dquot;
251 } 267 }
252 return NODQUOT; 268 return NULL;
253} 269}
254 270
255/* Add a dquot to the tail of the free list */ 271/* Add a dquot to the tail of the free list */
@@ -309,6 +325,7 @@ int dquot_mark_dquot_dirty(struct dquot *dquot)
309 spin_unlock(&dq_list_lock); 325 spin_unlock(&dq_list_lock);
310 return 0; 326 return 0;
311} 327}
328EXPORT_SYMBOL(dquot_mark_dquot_dirty);
312 329
313/* This function needs dq_list_lock */ 330/* This function needs dq_list_lock */
314static inline int clear_dquot_dirty(struct dquot *dquot) 331static inline int clear_dquot_dirty(struct dquot *dquot)
@@ -345,8 +362,10 @@ int dquot_acquire(struct dquot *dquot)
345 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 362 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
346 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 363 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
347 /* Write the info if needed */ 364 /* Write the info if needed */
348 if (info_dirty(&dqopt->info[dquot->dq_type])) 365 if (info_dirty(&dqopt->info[dquot->dq_type])) {
349 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 366 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
367 dquot->dq_sb, dquot->dq_type);
368 }
350 if (ret < 0) 369 if (ret < 0)
351 goto out_iolock; 370 goto out_iolock;
352 if (ret2 < 0) { 371 if (ret2 < 0) {
@@ -360,6 +379,7 @@ out_iolock:
360 mutex_unlock(&dquot->dq_lock); 379 mutex_unlock(&dquot->dq_lock);
361 return ret; 380 return ret;
362} 381}
382EXPORT_SYMBOL(dquot_acquire);
363 383
364/* 384/*
365 * Write dquot to disk 385 * Write dquot to disk
@@ -380,8 +400,10 @@ int dquot_commit(struct dquot *dquot)
380 * => we have better not writing it */ 400 * => we have better not writing it */
381 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 401 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
382 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot); 402 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
383 if (info_dirty(&dqopt->info[dquot->dq_type])) 403 if (info_dirty(&dqopt->info[dquot->dq_type])) {
384 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 404 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
405 dquot->dq_sb, dquot->dq_type);
406 }
385 if (ret >= 0) 407 if (ret >= 0)
386 ret = ret2; 408 ret = ret2;
387 } 409 }
@@ -389,6 +411,7 @@ out_sem:
389 mutex_unlock(&dqopt->dqio_mutex); 411 mutex_unlock(&dqopt->dqio_mutex);
390 return ret; 412 return ret;
391} 413}
414EXPORT_SYMBOL(dquot_commit);
392 415
393/* 416/*
394 * Release dquot 417 * Release dquot
@@ -406,8 +429,10 @@ int dquot_release(struct dquot *dquot)
406 if (dqopt->ops[dquot->dq_type]->release_dqblk) { 429 if (dqopt->ops[dquot->dq_type]->release_dqblk) {
407 ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot); 430 ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
408 /* Write the info */ 431 /* Write the info */
409 if (info_dirty(&dqopt->info[dquot->dq_type])) 432 if (info_dirty(&dqopt->info[dquot->dq_type])) {
410 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(dquot->dq_sb, dquot->dq_type); 433 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
434 dquot->dq_sb, dquot->dq_type);
435 }
411 if (ret >= 0) 436 if (ret >= 0)
412 ret = ret2; 437 ret = ret2;
413 } 438 }
@@ -417,6 +442,7 @@ out_dqlock:
417 mutex_unlock(&dquot->dq_lock); 442 mutex_unlock(&dquot->dq_lock);
418 return ret; 443 return ret;
419} 444}
445EXPORT_SYMBOL(dquot_release);
420 446
421void dquot_destroy(struct dquot *dquot) 447void dquot_destroy(struct dquot *dquot)
422{ 448{
@@ -516,6 +542,7 @@ out:
516 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 542 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
517 return ret; 543 return ret;
518} 544}
545EXPORT_SYMBOL(dquot_scan_active);
519 546
520int vfs_quota_sync(struct super_block *sb, int type) 547int vfs_quota_sync(struct super_block *sb, int type)
521{ 548{
@@ -533,7 +560,8 @@ int vfs_quota_sync(struct super_block *sb, int type)
533 spin_lock(&dq_list_lock); 560 spin_lock(&dq_list_lock);
534 dirty = &dqopt->info[cnt].dqi_dirty_list; 561 dirty = &dqopt->info[cnt].dqi_dirty_list;
535 while (!list_empty(dirty)) { 562 while (!list_empty(dirty)) {
536 dquot = list_first_entry(dirty, struct dquot, dq_dirty); 563 dquot = list_first_entry(dirty, struct dquot,
564 dq_dirty);
537 /* Dirty and inactive can be only bad dquot... */ 565 /* Dirty and inactive can be only bad dquot... */
538 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 566 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
539 clear_dquot_dirty(dquot); 567 clear_dquot_dirty(dquot);
@@ -563,6 +591,7 @@ int vfs_quota_sync(struct super_block *sb, int type)
563 591
564 return 0; 592 return 0;
565} 593}
594EXPORT_SYMBOL(vfs_quota_sync);
566 595
567/* Free unused dquots from cache */ 596/* Free unused dquots from cache */
568static void prune_dqcache(int count) 597static void prune_dqcache(int count)
@@ -672,6 +701,7 @@ we_slept:
672 put_dquot_last(dquot); 701 put_dquot_last(dquot);
673 spin_unlock(&dq_list_lock); 702 spin_unlock(&dq_list_lock);
674} 703}
704EXPORT_SYMBOL(dqput);
675 705
676struct dquot *dquot_alloc(struct super_block *sb, int type) 706struct dquot *dquot_alloc(struct super_block *sb, int type)
677{ 707{
@@ -685,7 +715,7 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
685 715
686 dquot = sb->dq_op->alloc_dquot(sb, type); 716 dquot = sb->dq_op->alloc_dquot(sb, type);
687 if(!dquot) 717 if(!dquot)
688 return NODQUOT; 718 return NULL;
689 719
690 mutex_init(&dquot->dq_lock); 720 mutex_init(&dquot->dq_lock);
691 INIT_LIST_HEAD(&dquot->dq_free); 721 INIT_LIST_HEAD(&dquot->dq_free);
@@ -711,10 +741,10 @@ static struct dquot *get_empty_dquot(struct super_block *sb, int type)
711struct dquot *dqget(struct super_block *sb, unsigned int id, int type) 741struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
712{ 742{
713 unsigned int hashent = hashfn(sb, id, type); 743 unsigned int hashent = hashfn(sb, id, type);
714 struct dquot *dquot = NODQUOT, *empty = NODQUOT; 744 struct dquot *dquot = NULL, *empty = NULL;
715 745
716 if (!sb_has_quota_active(sb, type)) 746 if (!sb_has_quota_active(sb, type))
717 return NODQUOT; 747 return NULL;
718we_slept: 748we_slept:
719 spin_lock(&dq_list_lock); 749 spin_lock(&dq_list_lock);
720 spin_lock(&dq_state_lock); 750 spin_lock(&dq_state_lock);
@@ -725,15 +755,17 @@ we_slept:
725 } 755 }
726 spin_unlock(&dq_state_lock); 756 spin_unlock(&dq_state_lock);
727 757
728 if ((dquot = find_dquot(hashent, sb, id, type)) == NODQUOT) { 758 dquot = find_dquot(hashent, sb, id, type);
729 if (empty == NODQUOT) { 759 if (!dquot) {
760 if (!empty) {
730 spin_unlock(&dq_list_lock); 761 spin_unlock(&dq_list_lock);
731 if ((empty = get_empty_dquot(sb, type)) == NODQUOT) 762 empty = get_empty_dquot(sb, type);
763 if (!empty)
732 schedule(); /* Try to wait for a moment... */ 764 schedule(); /* Try to wait for a moment... */
733 goto we_slept; 765 goto we_slept;
734 } 766 }
735 dquot = empty; 767 dquot = empty;
736 empty = NODQUOT; 768 empty = NULL;
737 dquot->dq_id = id; 769 dquot->dq_id = id;
738 /* all dquots go on the inuse_list */ 770 /* all dquots go on the inuse_list */
739 put_inuse(dquot); 771 put_inuse(dquot);
@@ -749,13 +781,14 @@ we_slept:
749 dqstats.lookups++; 781 dqstats.lookups++;
750 spin_unlock(&dq_list_lock); 782 spin_unlock(&dq_list_lock);
751 } 783 }
752 /* Wait for dq_lock - after this we know that either dquot_release() is already 784 /* Wait for dq_lock - after this we know that either dquot_release() is
753 * finished or it will be canceled due to dq_count > 1 test */ 785 * already finished or it will be canceled due to dq_count > 1 test */
754 wait_on_dquot(dquot); 786 wait_on_dquot(dquot);
755 /* Read the dquot and instantiate it (everything done only if needed) */ 787 /* Read the dquot / allocate space in quota file */
756 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && sb->dq_op->acquire_dquot(dquot) < 0) { 788 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
789 sb->dq_op->acquire_dquot(dquot) < 0) {
757 dqput(dquot); 790 dqput(dquot);
758 dquot = NODQUOT; 791 dquot = NULL;
759 goto out; 792 goto out;
760 } 793 }
761#ifdef __DQUOT_PARANOIA 794#ifdef __DQUOT_PARANOIA
@@ -767,6 +800,7 @@ out:
767 800
768 return dquot; 801 return dquot;
769} 802}
803EXPORT_SYMBOL(dqget);
770 804
771static int dqinit_needed(struct inode *inode, int type) 805static int dqinit_needed(struct inode *inode, int type)
772{ 806{
@@ -775,9 +809,9 @@ static int dqinit_needed(struct inode *inode, int type)
775 if (IS_NOQUOTA(inode)) 809 if (IS_NOQUOTA(inode))
776 return 0; 810 return 0;
777 if (type != -1) 811 if (type != -1)
778 return inode->i_dquot[type] == NODQUOT; 812 return !inode->i_dquot[type];
779 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 813 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
780 if (inode->i_dquot[cnt] == NODQUOT) 814 if (!inode->i_dquot[cnt])
781 return 1; 815 return 1;
782 return 0; 816 return 0;
783} 817}
@@ -813,7 +847,10 @@ static void add_dquot_ref(struct super_block *sb, int type)
813 iput(old_inode); 847 iput(old_inode);
814} 848}
815 849
816/* Return 0 if dqput() won't block (note that 1 doesn't necessarily mean blocking) */ 850/*
851 * Return 0 if dqput() won't block.
852 * (note that 1 doesn't necessarily mean blocking)
853 */
817static inline int dqput_blocks(struct dquot *dquot) 854static inline int dqput_blocks(struct dquot *dquot)
818{ 855{
819 if (atomic_read(&dquot->dq_count) <= 1) 856 if (atomic_read(&dquot->dq_count) <= 1)
@@ -821,22 +858,27 @@ static inline int dqput_blocks(struct dquot *dquot)
821 return 0; 858 return 0;
822} 859}
823 860
824/* Remove references to dquots from inode - add dquot to list for freeing if needed */ 861/*
825/* We can't race with anybody because we hold dqptr_sem for writing... */ 862 * Remove references to dquots from inode and add dquot to list for freeing
863 * if we have the last referece to dquot
864 * We can't race with anybody because we hold dqptr_sem for writing...
865 */
826static int remove_inode_dquot_ref(struct inode *inode, int type, 866static int remove_inode_dquot_ref(struct inode *inode, int type,
827 struct list_head *tofree_head) 867 struct list_head *tofree_head)
828{ 868{
829 struct dquot *dquot = inode->i_dquot[type]; 869 struct dquot *dquot = inode->i_dquot[type];
830 870
831 inode->i_dquot[type] = NODQUOT; 871 inode->i_dquot[type] = NULL;
832 if (dquot != NODQUOT) { 872 if (dquot) {
833 if (dqput_blocks(dquot)) { 873 if (dqput_blocks(dquot)) {
834#ifdef __DQUOT_PARANOIA 874#ifdef __DQUOT_PARANOIA
835 if (atomic_read(&dquot->dq_count) != 1) 875 if (atomic_read(&dquot->dq_count) != 1)
836 printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count)); 876 printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count));
837#endif 877#endif
838 spin_lock(&dq_list_lock); 878 spin_lock(&dq_list_lock);
839 list_add(&dquot->dq_free, tofree_head); /* As dquot must have currently users it can't be on the free list... */ 879 /* As dquot must have currently users it can't be on
880 * the free list... */
881 list_add(&dquot->dq_free, tofree_head);
840 spin_unlock(&dq_list_lock); 882 spin_unlock(&dq_list_lock);
841 return 1; 883 return 1;
842 } 884 }
@@ -846,19 +888,22 @@ static int remove_inode_dquot_ref(struct inode *inode, int type,
846 return 0; 888 return 0;
847} 889}
848 890
849/* Free list of dquots - called from inode.c */ 891/*
850/* dquots are removed from inodes, no new references can be got so we are the only ones holding reference */ 892 * Free list of dquots
893 * Dquots are removed from inodes and no new references can be got so we are
894 * the only ones holding reference
895 */
851static void put_dquot_list(struct list_head *tofree_head) 896static void put_dquot_list(struct list_head *tofree_head)
852{ 897{
853 struct list_head *act_head; 898 struct list_head *act_head;
854 struct dquot *dquot; 899 struct dquot *dquot;
855 900
856 act_head = tofree_head->next; 901 act_head = tofree_head->next;
857 /* So now we have dquots on the list... Just free them */
858 while (act_head != tofree_head) { 902 while (act_head != tofree_head) {
859 dquot = list_entry(act_head, struct dquot, dq_free); 903 dquot = list_entry(act_head, struct dquot, dq_free);
860 act_head = act_head->next; 904 act_head = act_head->next;
861 list_del_init(&dquot->dq_free); /* Remove dquot from the list so we won't have problems... */ 905 /* Remove dquot from the list so we won't have problems... */
906 list_del_init(&dquot->dq_free);
862 dqput(dquot); 907 dqput(dquot);
863 } 908 }
864} 909}
@@ -899,7 +944,29 @@ static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
899 dquot->dq_dqb.dqb_curspace += number; 944 dquot->dq_dqb.dqb_curspace += number;
900} 945}
901 946
902static inline void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 947static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
948{
949 dquot->dq_dqb.dqb_rsvspace += number;
950}
951
952/*
953 * Claim reserved quota space
954 */
955static void dquot_claim_reserved_space(struct dquot *dquot,
956 qsize_t number)
957{
958 WARN_ON(dquot->dq_dqb.dqb_rsvspace < number);
959 dquot->dq_dqb.dqb_curspace += number;
960 dquot->dq_dqb.dqb_rsvspace -= number;
961}
962
963static inline
964void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
965{
966 dquot->dq_dqb.dqb_rsvspace -= number;
967}
968
969static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
903{ 970{
904 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 971 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
905 dquot->dq_dqb.dqb_curinodes >= number) 972 dquot->dq_dqb.dqb_curinodes >= number)
@@ -911,7 +978,7 @@ static inline void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
911 clear_bit(DQ_INODES_B, &dquot->dq_flags); 978 clear_bit(DQ_INODES_B, &dquot->dq_flags);
912} 979}
913 980
914static inline void dquot_decr_space(struct dquot *dquot, qsize_t number) 981static void dquot_decr_space(struct dquot *dquot, qsize_t number)
915{ 982{
916 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 983 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
917 dquot->dq_dqb.dqb_curspace >= number) 984 dquot->dq_dqb.dqb_curspace >= number)
@@ -938,7 +1005,7 @@ static int warning_issued(struct dquot *dquot, const int warntype)
938#ifdef CONFIG_PRINT_QUOTA_WARNING 1005#ifdef CONFIG_PRINT_QUOTA_WARNING
939static int flag_print_warnings = 1; 1006static int flag_print_warnings = 1;
940 1007
941static inline int need_print_warning(struct dquot *dquot) 1008static int need_print_warning(struct dquot *dquot)
942{ 1009{
943 if (!flag_print_warnings) 1010 if (!flag_print_warnings)
944 return 0; 1011 return 0;
@@ -1065,13 +1132,17 @@ err_out:
1065 kfree_skb(skb); 1132 kfree_skb(skb);
1066} 1133}
1067#endif 1134#endif
1068 1135/*
1069static inline void flush_warnings(struct dquot * const *dquots, char *warntype) 1136 * Write warnings to the console and send warning messages over netlink.
1137 *
1138 * Note that this function can sleep.
1139 */
1140static void flush_warnings(struct dquot *const *dquots, char *warntype)
1070{ 1141{
1071 int i; 1142 int i;
1072 1143
1073 for (i = 0; i < MAXQUOTAS; i++) 1144 for (i = 0; i < MAXQUOTAS; i++)
1074 if (dquots[i] != NODQUOT && warntype[i] != QUOTA_NL_NOWARN && 1145 if (dquots[i] && warntype[i] != QUOTA_NL_NOWARN &&
1075 !warning_issued(dquots[i], warntype[i])) { 1146 !warning_issued(dquots[i], warntype[i])) {
1076#ifdef CONFIG_PRINT_QUOTA_WARNING 1147#ifdef CONFIG_PRINT_QUOTA_WARNING
1077 print_warning(dquots[i], warntype[i]); 1148 print_warning(dquots[i], warntype[i]);
@@ -1082,42 +1153,47 @@ static inline void flush_warnings(struct dquot * const *dquots, char *warntype)
1082 } 1153 }
1083} 1154}
1084 1155
1085static inline char ignore_hardlimit(struct dquot *dquot) 1156static int ignore_hardlimit(struct dquot *dquot)
1086{ 1157{
1087 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type]; 1158 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
1088 1159
1089 return capable(CAP_SYS_RESOURCE) && 1160 return capable(CAP_SYS_RESOURCE) &&
1090 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || !(info->dqi_flags & V1_DQF_RSQUASH)); 1161 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1162 !(info->dqi_flags & V1_DQF_RSQUASH));
1091} 1163}
1092 1164
1093/* needs dq_data_lock */ 1165/* needs dq_data_lock */
1094static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype) 1166static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype)
1095{ 1167{
1168 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1169
1096 *warntype = QUOTA_NL_NOWARN; 1170 *warntype = QUOTA_NL_NOWARN;
1097 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1171 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
1098 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1172 test_bit(DQ_FAKE_B, &dquot->dq_flags))
1099 return QUOTA_OK; 1173 return QUOTA_OK;
1100 1174
1101 if (dquot->dq_dqb.dqb_ihardlimit && 1175 if (dquot->dq_dqb.dqb_ihardlimit &&
1102 (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_ihardlimit && 1176 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
1103 !ignore_hardlimit(dquot)) { 1177 !ignore_hardlimit(dquot)) {
1104 *warntype = QUOTA_NL_IHARDWARN; 1178 *warntype = QUOTA_NL_IHARDWARN;
1105 return NO_QUOTA; 1179 return NO_QUOTA;
1106 } 1180 }
1107 1181
1108 if (dquot->dq_dqb.dqb_isoftlimit && 1182 if (dquot->dq_dqb.dqb_isoftlimit &&
1109 (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1183 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1110 dquot->dq_dqb.dqb_itime && get_seconds() >= dquot->dq_dqb.dqb_itime && 1184 dquot->dq_dqb.dqb_itime &&
1185 get_seconds() >= dquot->dq_dqb.dqb_itime &&
1111 !ignore_hardlimit(dquot)) { 1186 !ignore_hardlimit(dquot)) {
1112 *warntype = QUOTA_NL_ISOFTLONGWARN; 1187 *warntype = QUOTA_NL_ISOFTLONGWARN;
1113 return NO_QUOTA; 1188 return NO_QUOTA;
1114 } 1189 }
1115 1190
1116 if (dquot->dq_dqb.dqb_isoftlimit && 1191 if (dquot->dq_dqb.dqb_isoftlimit &&
1117 (dquot->dq_dqb.dqb_curinodes + inodes) > dquot->dq_dqb.dqb_isoftlimit && 1192 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1118 dquot->dq_dqb.dqb_itime == 0) { 1193 dquot->dq_dqb.dqb_itime == 0) {
1119 *warntype = QUOTA_NL_ISOFTWARN; 1194 *warntype = QUOTA_NL_ISOFTWARN;
1120 dquot->dq_dqb.dqb_itime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace; 1195 dquot->dq_dqb.dqb_itime = get_seconds() +
1196 sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
1121 } 1197 }
1122 1198
1123 return QUOTA_OK; 1199 return QUOTA_OK;
@@ -1126,13 +1202,19 @@ static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype)
1126/* needs dq_data_lock */ 1202/* needs dq_data_lock */
1127static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype) 1203static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype)
1128{ 1204{
1205 qsize_t tspace;
1206 struct super_block *sb = dquot->dq_sb;
1207
1129 *warntype = QUOTA_NL_NOWARN; 1208 *warntype = QUOTA_NL_NOWARN;
1130 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) || 1209 if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
1131 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1210 test_bit(DQ_FAKE_B, &dquot->dq_flags))
1132 return QUOTA_OK; 1211 return QUOTA_OK;
1133 1212
1213 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1214 + space;
1215
1134 if (dquot->dq_dqb.dqb_bhardlimit && 1216 if (dquot->dq_dqb.dqb_bhardlimit &&
1135 dquot->dq_dqb.dqb_curspace + space > dquot->dq_dqb.dqb_bhardlimit && 1217 tspace > dquot->dq_dqb.dqb_bhardlimit &&
1136 !ignore_hardlimit(dquot)) { 1218 !ignore_hardlimit(dquot)) {
1137 if (!prealloc) 1219 if (!prealloc)
1138 *warntype = QUOTA_NL_BHARDWARN; 1220 *warntype = QUOTA_NL_BHARDWARN;
@@ -1140,8 +1222,9 @@ static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *war
1140 } 1222 }
1141 1223
1142 if (dquot->dq_dqb.dqb_bsoftlimit && 1224 if (dquot->dq_dqb.dqb_bsoftlimit &&
1143 dquot->dq_dqb.dqb_curspace + space > dquot->dq_dqb.dqb_bsoftlimit && 1225 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1144 dquot->dq_dqb.dqb_btime && get_seconds() >= dquot->dq_dqb.dqb_btime && 1226 dquot->dq_dqb.dqb_btime &&
1227 get_seconds() >= dquot->dq_dqb.dqb_btime &&
1145 !ignore_hardlimit(dquot)) { 1228 !ignore_hardlimit(dquot)) {
1146 if (!prealloc) 1229 if (!prealloc)
1147 *warntype = QUOTA_NL_BSOFTLONGWARN; 1230 *warntype = QUOTA_NL_BSOFTLONGWARN;
@@ -1149,11 +1232,12 @@ static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *war
1149 } 1232 }
1150 1233
1151 if (dquot->dq_dqb.dqb_bsoftlimit && 1234 if (dquot->dq_dqb.dqb_bsoftlimit &&
1152 dquot->dq_dqb.dqb_curspace + space > dquot->dq_dqb.dqb_bsoftlimit && 1235 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1153 dquot->dq_dqb.dqb_btime == 0) { 1236 dquot->dq_dqb.dqb_btime == 0) {
1154 if (!prealloc) { 1237 if (!prealloc) {
1155 *warntype = QUOTA_NL_BSOFTWARN; 1238 *warntype = QUOTA_NL_BSOFTWARN;
1156 dquot->dq_dqb.dqb_btime = get_seconds() + sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_bgrace; 1239 dquot->dq_dqb.dqb_btime = get_seconds() +
1240 sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
1157 } 1241 }
1158 else 1242 else
1159 /* 1243 /*
@@ -1168,15 +1252,18 @@ static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *war
1168 1252
1169static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1253static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1170{ 1254{
1255 qsize_t newinodes;
1256
1171 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1257 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1172 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1258 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1173 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type)) 1259 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
1174 return QUOTA_NL_NOWARN; 1260 return QUOTA_NL_NOWARN;
1175 1261
1176 if (dquot->dq_dqb.dqb_curinodes - inodes <= dquot->dq_dqb.dqb_isoftlimit) 1262 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1263 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1177 return QUOTA_NL_ISOFTBELOW; 1264 return QUOTA_NL_ISOFTBELOW;
1178 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1265 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
1179 dquot->dq_dqb.dqb_curinodes - inodes < dquot->dq_dqb.dqb_ihardlimit) 1266 newinodes < dquot->dq_dqb.dqb_ihardlimit)
1180 return QUOTA_NL_IHARDBELOW; 1267 return QUOTA_NL_IHARDBELOW;
1181 return QUOTA_NL_NOWARN; 1268 return QUOTA_NL_NOWARN;
1182} 1269}
@@ -1203,7 +1290,7 @@ int dquot_initialize(struct inode *inode, int type)
1203{ 1290{
1204 unsigned int id = 0; 1291 unsigned int id = 0;
1205 int cnt, ret = 0; 1292 int cnt, ret = 0;
1206 struct dquot *got[MAXQUOTAS] = { NODQUOT, NODQUOT }; 1293 struct dquot *got[MAXQUOTAS] = { NULL, NULL };
1207 struct super_block *sb = inode->i_sb; 1294 struct super_block *sb = inode->i_sb;
1208 1295
1209 /* First test before acquiring mutex - solves deadlocks when we 1296 /* First test before acquiring mutex - solves deadlocks when we
@@ -1236,9 +1323,9 @@ int dquot_initialize(struct inode *inode, int type)
1236 /* Avoid races with quotaoff() */ 1323 /* Avoid races with quotaoff() */
1237 if (!sb_has_quota_active(sb, cnt)) 1324 if (!sb_has_quota_active(sb, cnt))
1238 continue; 1325 continue;
1239 if (inode->i_dquot[cnt] == NODQUOT) { 1326 if (!inode->i_dquot[cnt]) {
1240 inode->i_dquot[cnt] = got[cnt]; 1327 inode->i_dquot[cnt] = got[cnt];
1241 got[cnt] = NODQUOT; 1328 got[cnt] = NULL;
1242 } 1329 }
1243 } 1330 }
1244out_err: 1331out_err:
@@ -1248,6 +1335,7 @@ out_err:
1248 dqput(got[cnt]); 1335 dqput(got[cnt]);
1249 return ret; 1336 return ret;
1250} 1337}
1338EXPORT_SYMBOL(dquot_initialize);
1251 1339
1252/* 1340/*
1253 * Release all quotas referenced by inode 1341 * Release all quotas referenced by inode
@@ -1260,7 +1348,7 @@ int dquot_drop(struct inode *inode)
1260 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1348 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1261 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1349 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1262 put[cnt] = inode->i_dquot[cnt]; 1350 put[cnt] = inode->i_dquot[cnt];
1263 inode->i_dquot[cnt] = NODQUOT; 1351 inode->i_dquot[cnt] = NULL;
1264 } 1352 }
1265 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1353 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1266 1354
@@ -1268,6 +1356,7 @@ int dquot_drop(struct inode *inode)
1268 dqput(put[cnt]); 1356 dqput(put[cnt]);
1269 return 0; 1357 return 0;
1270} 1358}
1359EXPORT_SYMBOL(dquot_drop);
1271 1360
1272/* Wrapper to remove references to quota structures from inode */ 1361/* Wrapper to remove references to quota structures from inode */
1273void vfs_dq_drop(struct inode *inode) 1362void vfs_dq_drop(struct inode *inode)
@@ -1284,12 +1373,13 @@ void vfs_dq_drop(struct inode *inode)
1284 * must assure that nobody can come after the DQUOT_DROP and 1373 * must assure that nobody can come after the DQUOT_DROP and
1285 * add quota pointers back anyway */ 1374 * add quota pointers back anyway */
1286 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1375 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1287 if (inode->i_dquot[cnt] != NODQUOT) 1376 if (inode->i_dquot[cnt])
1288 break; 1377 break;
1289 if (cnt < MAXQUOTAS) 1378 if (cnt < MAXQUOTAS)
1290 inode->i_sb->dq_op->drop(inode); 1379 inode->i_sb->dq_op->drop(inode);
1291 } 1380 }
1292} 1381}
1382EXPORT_SYMBOL(vfs_dq_drop);
1293 1383
1294/* 1384/*
1295 * Following four functions update i_blocks+i_bytes fields and 1385 * Following four functions update i_blocks+i_bytes fields and
@@ -1303,51 +1393,93 @@ void vfs_dq_drop(struct inode *inode)
1303/* 1393/*
1304 * This operation can block, but only after everything is updated 1394 * This operation can block, but only after everything is updated
1305 */ 1395 */
1306int dquot_alloc_space(struct inode *inode, qsize_t number, int warn) 1396int __dquot_alloc_space(struct inode *inode, qsize_t number,
1397 int warn, int reserve)
1307{ 1398{
1308 int cnt, ret = NO_QUOTA; 1399 int cnt, ret = QUOTA_OK;
1309 char warntype[MAXQUOTAS]; 1400 char warntype[MAXQUOTAS];
1310 1401
1311 /* First test before acquiring mutex - solves deadlocks when we
1312 * re-enter the quota code and are already holding the mutex */
1313 if (IS_NOQUOTA(inode)) {
1314out_add:
1315 inode_add_bytes(inode, number);
1316 return QUOTA_OK;
1317 }
1318 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1402 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1319 warntype[cnt] = QUOTA_NL_NOWARN; 1403 warntype[cnt] = QUOTA_NL_NOWARN;
1320 1404
1321 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1322 if (IS_NOQUOTA(inode)) { /* Now we can do reliable test... */
1323 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1324 goto out_add;
1325 }
1326 spin_lock(&dq_data_lock); 1405 spin_lock(&dq_data_lock);
1327 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1406 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1328 if (inode->i_dquot[cnt] == NODQUOT) 1407 if (!inode->i_dquot[cnt])
1329 continue; 1408 continue;
1330 if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt) == NO_QUOTA) 1409 if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt)
1331 goto warn_put_all; 1410 == NO_QUOTA) {
1411 ret = NO_QUOTA;
1412 goto out_unlock;
1413 }
1332 } 1414 }
1333 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1415 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1334 if (inode->i_dquot[cnt] == NODQUOT) 1416 if (!inode->i_dquot[cnt])
1335 continue; 1417 continue;
1336 dquot_incr_space(inode->i_dquot[cnt], number); 1418 if (reserve)
1419 dquot_resv_space(inode->i_dquot[cnt], number);
1420 else
1421 dquot_incr_space(inode->i_dquot[cnt], number);
1337 } 1422 }
1338 inode_add_bytes(inode, number); 1423 if (!reserve)
1339 ret = QUOTA_OK; 1424 inode_add_bytes(inode, number);
1340warn_put_all: 1425out_unlock:
1341 spin_unlock(&dq_data_lock); 1426 spin_unlock(&dq_data_lock);
1342 if (ret == QUOTA_OK)
1343 /* Dirtify all the dquots - this can block when journalling */
1344 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1345 if (inode->i_dquot[cnt])
1346 mark_dquot_dirty(inode->i_dquot[cnt]);
1347 flush_warnings(inode->i_dquot, warntype); 1427 flush_warnings(inode->i_dquot, warntype);
1428 return ret;
1429}
1430
1431int dquot_alloc_space(struct inode *inode, qsize_t number, int warn)
1432{
1433 int cnt, ret = QUOTA_OK;
1434
1435 /*
1436 * First test before acquiring mutex - solves deadlocks when we
1437 * re-enter the quota code and are already holding the mutex
1438 */
1439 if (IS_NOQUOTA(inode)) {
1440 inode_add_bytes(inode, number);
1441 goto out;
1442 }
1443
1444 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1445 if (IS_NOQUOTA(inode)) {
1446 inode_add_bytes(inode, number);
1447 goto out_unlock;
1448 }
1449
1450 ret = __dquot_alloc_space(inode, number, warn, 0);
1451 if (ret == NO_QUOTA)
1452 goto out_unlock;
1453
1454 /* Dirtify all the dquots - this can block when journalling */
1455 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1456 if (inode->i_dquot[cnt])
1457 mark_dquot_dirty(inode->i_dquot[cnt]);
1458out_unlock:
1459 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1460out:
1461 return ret;
1462}
1463EXPORT_SYMBOL(dquot_alloc_space);
1464
1465int dquot_reserve_space(struct inode *inode, qsize_t number, int warn)
1466{
1467 int ret = QUOTA_OK;
1468
1469 if (IS_NOQUOTA(inode))
1470 goto out;
1471
1472 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1473 if (IS_NOQUOTA(inode))
1474 goto out_unlock;
1475
1476 ret = __dquot_alloc_space(inode, number, warn, 1);
1477out_unlock:
1348 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1478 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1479out:
1349 return ret; 1480 return ret;
1350} 1481}
1482EXPORT_SYMBOL(dquot_reserve_space);
1351 1483
1352/* 1484/*
1353 * This operation can block, but only after everything is updated 1485 * This operation can block, but only after everything is updated
@@ -1370,14 +1502,15 @@ int dquot_alloc_inode(const struct inode *inode, qsize_t number)
1370 } 1502 }
1371 spin_lock(&dq_data_lock); 1503 spin_lock(&dq_data_lock);
1372 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1504 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1373 if (inode->i_dquot[cnt] == NODQUOT) 1505 if (!inode->i_dquot[cnt])
1374 continue; 1506 continue;
1375 if (check_idq(inode->i_dquot[cnt], number, warntype+cnt) == NO_QUOTA) 1507 if (check_idq(inode->i_dquot[cnt], number, warntype+cnt)
1508 == NO_QUOTA)
1376 goto warn_put_all; 1509 goto warn_put_all;
1377 } 1510 }
1378 1511
1379 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1512 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1380 if (inode->i_dquot[cnt] == NODQUOT) 1513 if (!inode->i_dquot[cnt])
1381 continue; 1514 continue;
1382 dquot_incr_inodes(inode->i_dquot[cnt], number); 1515 dquot_incr_inodes(inode->i_dquot[cnt], number);
1383 } 1516 }
@@ -1393,6 +1526,73 @@ warn_put_all:
1393 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1526 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1394 return ret; 1527 return ret;
1395} 1528}
1529EXPORT_SYMBOL(dquot_alloc_inode);
1530
1531int dquot_claim_space(struct inode *inode, qsize_t number)
1532{
1533 int cnt;
1534 int ret = QUOTA_OK;
1535
1536 if (IS_NOQUOTA(inode)) {
1537 inode_add_bytes(inode, number);
1538 goto out;
1539 }
1540
1541 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1542 if (IS_NOQUOTA(inode)) {
1543 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1544 inode_add_bytes(inode, number);
1545 goto out;
1546 }
1547
1548 spin_lock(&dq_data_lock);
1549 /* Claim reserved quotas to allocated quotas */
1550 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1551 if (inode->i_dquot[cnt])
1552 dquot_claim_reserved_space(inode->i_dquot[cnt],
1553 number);
1554 }
1555 /* Update inode bytes */
1556 inode_add_bytes(inode, number);
1557 spin_unlock(&dq_data_lock);
1558 /* Dirtify all the dquots - this can block when journalling */
1559 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1560 if (inode->i_dquot[cnt])
1561 mark_dquot_dirty(inode->i_dquot[cnt]);
1562 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1563out:
1564 return ret;
1565}
1566EXPORT_SYMBOL(dquot_claim_space);
1567
1568/*
1569 * Release reserved quota space
1570 */
1571void dquot_release_reserved_space(struct inode *inode, qsize_t number)
1572{
1573 int cnt;
1574
1575 if (IS_NOQUOTA(inode))
1576 goto out;
1577
1578 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1579 if (IS_NOQUOTA(inode))
1580 goto out_unlock;
1581
1582 spin_lock(&dq_data_lock);
1583 /* Release reserved dquots */
1584 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1585 if (inode->i_dquot[cnt])
1586 dquot_free_reserved_space(inode->i_dquot[cnt], number);
1587 }
1588 spin_unlock(&dq_data_lock);
1589
1590out_unlock:
1591 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1592out:
1593 return;
1594}
1595EXPORT_SYMBOL(dquot_release_reserved_space);
1396 1596
1397/* 1597/*
1398 * This operation can block, but only after everything is updated 1598 * This operation can block, but only after everything is updated
@@ -1418,7 +1618,7 @@ out_sub:
1418 } 1618 }
1419 spin_lock(&dq_data_lock); 1619 spin_lock(&dq_data_lock);
1420 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1620 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1421 if (inode->i_dquot[cnt] == NODQUOT) 1621 if (!inode->i_dquot[cnt])
1422 continue; 1622 continue;
1423 warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number); 1623 warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
1424 dquot_decr_space(inode->i_dquot[cnt], number); 1624 dquot_decr_space(inode->i_dquot[cnt], number);
@@ -1433,6 +1633,7 @@ out_sub:
1433 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1633 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1434 return QUOTA_OK; 1634 return QUOTA_OK;
1435} 1635}
1636EXPORT_SYMBOL(dquot_free_space);
1436 1637
1437/* 1638/*
1438 * This operation can block, but only after everything is updated 1639 * This operation can block, but only after everything is updated
@@ -1455,7 +1656,7 @@ int dquot_free_inode(const struct inode *inode, qsize_t number)
1455 } 1656 }
1456 spin_lock(&dq_data_lock); 1657 spin_lock(&dq_data_lock);
1457 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1658 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1458 if (inode->i_dquot[cnt] == NODQUOT) 1659 if (!inode->i_dquot[cnt])
1459 continue; 1660 continue;
1460 warntype[cnt] = info_idq_free(inode->i_dquot[cnt], number); 1661 warntype[cnt] = info_idq_free(inode->i_dquot[cnt], number);
1461 dquot_decr_inodes(inode->i_dquot[cnt], number); 1662 dquot_decr_inodes(inode->i_dquot[cnt], number);
@@ -1469,6 +1670,20 @@ int dquot_free_inode(const struct inode *inode, qsize_t number)
1469 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1670 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1470 return QUOTA_OK; 1671 return QUOTA_OK;
1471} 1672}
1673EXPORT_SYMBOL(dquot_free_inode);
1674
1675/*
1676 * call back function, get reserved quota space from underlying fs
1677 */
1678qsize_t dquot_get_reserved_space(struct inode *inode)
1679{
1680 qsize_t reserved_space = 0;
1681
1682 if (sb_any_quota_active(inode->i_sb) &&
1683 inode->i_sb->dq_op->get_reserved_space)
1684 reserved_space = inode->i_sb->dq_op->get_reserved_space(inode);
1685 return reserved_space;
1686}
1472 1687
1473/* 1688/*
1474 * Transfer the number of inode and blocks from one diskquota to an other. 1689 * Transfer the number of inode and blocks from one diskquota to an other.
@@ -1478,7 +1693,8 @@ int dquot_free_inode(const struct inode *inode, qsize_t number)
1478 */ 1693 */
1479int dquot_transfer(struct inode *inode, struct iattr *iattr) 1694int dquot_transfer(struct inode *inode, struct iattr *iattr)
1480{ 1695{
1481 qsize_t space; 1696 qsize_t space, cur_space;
1697 qsize_t rsv_space = 0;
1482 struct dquot *transfer_from[MAXQUOTAS]; 1698 struct dquot *transfer_from[MAXQUOTAS];
1483 struct dquot *transfer_to[MAXQUOTAS]; 1699 struct dquot *transfer_to[MAXQUOTAS];
1484 int cnt, ret = QUOTA_OK; 1700 int cnt, ret = QUOTA_OK;
@@ -1493,22 +1709,16 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
1493 return QUOTA_OK; 1709 return QUOTA_OK;
1494 /* Initialize the arrays */ 1710 /* Initialize the arrays */
1495 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1711 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1496 transfer_from[cnt] = NODQUOT; 1712 transfer_from[cnt] = NULL;
1497 transfer_to[cnt] = NODQUOT; 1713 transfer_to[cnt] = NULL;
1498 warntype_to[cnt] = QUOTA_NL_NOWARN; 1714 warntype_to[cnt] = QUOTA_NL_NOWARN;
1499 switch (cnt) {
1500 case USRQUOTA:
1501 if (!chuid)
1502 continue;
1503 transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_uid, cnt);
1504 break;
1505 case GRPQUOTA:
1506 if (!chgid)
1507 continue;
1508 transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_gid, cnt);
1509 break;
1510 }
1511 } 1715 }
1716 if (chuid)
1717 transfer_to[USRQUOTA] = dqget(inode->i_sb, iattr->ia_uid,
1718 USRQUOTA);
1719 if (chgid)
1720 transfer_to[GRPQUOTA] = dqget(inode->i_sb, iattr->ia_gid,
1721 GRPQUOTA);
1512 1722
1513 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1723 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1514 /* Now recheck reliably when holding dqptr_sem */ 1724 /* Now recheck reliably when holding dqptr_sem */
@@ -1517,10 +1727,12 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
1517 goto put_all; 1727 goto put_all;
1518 } 1728 }
1519 spin_lock(&dq_data_lock); 1729 spin_lock(&dq_data_lock);
1520 space = inode_get_bytes(inode); 1730 cur_space = inode_get_bytes(inode);
1731 rsv_space = dquot_get_reserved_space(inode);
1732 space = cur_space + rsv_space;
1521 /* Build the transfer_from list and check the limits */ 1733 /* Build the transfer_from list and check the limits */
1522 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1734 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1523 if (transfer_to[cnt] == NODQUOT) 1735 if (!transfer_to[cnt])
1524 continue; 1736 continue;
1525 transfer_from[cnt] = inode->i_dquot[cnt]; 1737 transfer_from[cnt] = inode->i_dquot[cnt];
1526 if (check_idq(transfer_to[cnt], 1, warntype_to + cnt) == 1738 if (check_idq(transfer_to[cnt], 1, warntype_to + cnt) ==
@@ -1536,7 +1748,7 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
1536 /* 1748 /*
1537 * Skip changes for same uid or gid or for turned off quota-type. 1749 * Skip changes for same uid or gid or for turned off quota-type.
1538 */ 1750 */
1539 if (transfer_to[cnt] == NODQUOT) 1751 if (!transfer_to[cnt])
1540 continue; 1752 continue;
1541 1753
1542 /* Due to IO error we might not have transfer_from[] structure */ 1754 /* Due to IO error we might not have transfer_from[] structure */
@@ -1546,11 +1758,14 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
1546 warntype_from_space[cnt] = 1758 warntype_from_space[cnt] =
1547 info_bdq_free(transfer_from[cnt], space); 1759 info_bdq_free(transfer_from[cnt], space);
1548 dquot_decr_inodes(transfer_from[cnt], 1); 1760 dquot_decr_inodes(transfer_from[cnt], 1);
1549 dquot_decr_space(transfer_from[cnt], space); 1761 dquot_decr_space(transfer_from[cnt], cur_space);
1762 dquot_free_reserved_space(transfer_from[cnt],
1763 rsv_space);
1550 } 1764 }
1551 1765
1552 dquot_incr_inodes(transfer_to[cnt], 1); 1766 dquot_incr_inodes(transfer_to[cnt], 1);
1553 dquot_incr_space(transfer_to[cnt], space); 1767 dquot_incr_space(transfer_to[cnt], cur_space);
1768 dquot_resv_space(transfer_to[cnt], rsv_space);
1554 1769
1555 inode->i_dquot[cnt] = transfer_to[cnt]; 1770 inode->i_dquot[cnt] = transfer_to[cnt];
1556 } 1771 }
@@ -1564,7 +1779,7 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
1564 if (transfer_to[cnt]) { 1779 if (transfer_to[cnt]) {
1565 mark_dquot_dirty(transfer_to[cnt]); 1780 mark_dquot_dirty(transfer_to[cnt]);
1566 /* The reference we got is transferred to the inode */ 1781 /* The reference we got is transferred to the inode */
1567 transfer_to[cnt] = NODQUOT; 1782 transfer_to[cnt] = NULL;
1568 } 1783 }
1569 } 1784 }
1570warn_put_all: 1785warn_put_all:
@@ -1582,10 +1797,11 @@ over_quota:
1582 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1797 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1583 /* Clear dquot pointers we don't want to dqput() */ 1798 /* Clear dquot pointers we don't want to dqput() */
1584 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1799 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1585 transfer_from[cnt] = NODQUOT; 1800 transfer_from[cnt] = NULL;
1586 ret = NO_QUOTA; 1801 ret = NO_QUOTA;
1587 goto warn_put_all; 1802 goto warn_put_all;
1588} 1803}
1804EXPORT_SYMBOL(dquot_transfer);
1589 1805
1590/* Wrapper for transferring ownership of an inode */ 1806/* Wrapper for transferring ownership of an inode */
1591int vfs_dq_transfer(struct inode *inode, struct iattr *iattr) 1807int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
@@ -1597,7 +1813,7 @@ int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
1597 } 1813 }
1598 return 0; 1814 return 0;
1599} 1815}
1600 1816EXPORT_SYMBOL(vfs_dq_transfer);
1601 1817
1602/* 1818/*
1603 * Write info of quota file to disk 1819 * Write info of quota file to disk
@@ -1612,6 +1828,7 @@ int dquot_commit_info(struct super_block *sb, int type)
1612 mutex_unlock(&dqopt->dqio_mutex); 1828 mutex_unlock(&dqopt->dqio_mutex);
1613 return ret; 1829 return ret;
1614} 1830}
1831EXPORT_SYMBOL(dquot_commit_info);
1615 1832
1616/* 1833/*
1617 * Definitions of diskquota operations. 1834 * Definitions of diskquota operations.
@@ -1697,8 +1914,8 @@ int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)
1697 drop_dquot_ref(sb, cnt); 1914 drop_dquot_ref(sb, cnt);
1698 invalidate_dquots(sb, cnt); 1915 invalidate_dquots(sb, cnt);
1699 /* 1916 /*
1700 * Now all dquots should be invalidated, all writes done so we should be only 1917 * Now all dquots should be invalidated, all writes done so we
1701 * users of the info. No locks needed. 1918 * should be only users of the info. No locks needed.
1702 */ 1919 */
1703 if (info_dirty(&dqopt->info[cnt])) 1920 if (info_dirty(&dqopt->info[cnt]))
1704 sb->dq_op->write_info(sb, cnt); 1921 sb->dq_op->write_info(sb, cnt);
@@ -1736,10 +1953,12 @@ int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)
1736 /* If quota was reenabled in the meantime, we have 1953 /* If quota was reenabled in the meantime, we have
1737 * nothing to do */ 1954 * nothing to do */
1738 if (!sb_has_quota_loaded(sb, cnt)) { 1955 if (!sb_has_quota_loaded(sb, cnt)) {
1739 mutex_lock_nested(&toputinode[cnt]->i_mutex, I_MUTEX_QUOTA); 1956 mutex_lock_nested(&toputinode[cnt]->i_mutex,
1957 I_MUTEX_QUOTA);
1740 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 1958 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
1741 S_NOATIME | S_NOQUOTA); 1959 S_NOATIME | S_NOQUOTA);
1742 truncate_inode_pages(&toputinode[cnt]->i_data, 0); 1960 truncate_inode_pages(&toputinode[cnt]->i_data,
1961 0);
1743 mutex_unlock(&toputinode[cnt]->i_mutex); 1962 mutex_unlock(&toputinode[cnt]->i_mutex);
1744 mark_inode_dirty(toputinode[cnt]); 1963 mark_inode_dirty(toputinode[cnt]);
1745 } 1964 }
@@ -1764,13 +1983,14 @@ put_inodes:
1764 } 1983 }
1765 return ret; 1984 return ret;
1766} 1985}
1986EXPORT_SYMBOL(vfs_quota_disable);
1767 1987
1768int vfs_quota_off(struct super_block *sb, int type, int remount) 1988int vfs_quota_off(struct super_block *sb, int type, int remount)
1769{ 1989{
1770 return vfs_quota_disable(sb, type, remount ? DQUOT_SUSPENDED : 1990 return vfs_quota_disable(sb, type, remount ? DQUOT_SUSPENDED :
1771 (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED)); 1991 (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED));
1772} 1992}
1773 1993EXPORT_SYMBOL(vfs_quota_off);
1774/* 1994/*
1775 * Turn quotas on on a device 1995 * Turn quotas on on a device
1776 */ 1996 */
@@ -1828,7 +2048,8 @@ static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
1828 * possible) Also nobody should write to the file - we use 2048 * possible) Also nobody should write to the file - we use
1829 * special IO operations which ignore the immutable bit. */ 2049 * special IO operations which ignore the immutable bit. */
1830 down_write(&dqopt->dqptr_sem); 2050 down_write(&dqopt->dqptr_sem);
1831 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | S_NOQUOTA); 2051 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2052 S_NOQUOTA);
1832 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2053 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
1833 up_write(&dqopt->dqptr_sem); 2054 up_write(&dqopt->dqptr_sem);
1834 sb->dq_op->drop(inode); 2055 sb->dq_op->drop(inode);
@@ -1847,7 +2068,8 @@ static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
1847 dqopt->info[type].dqi_fmt_id = format_id; 2068 dqopt->info[type].dqi_fmt_id = format_id;
1848 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2069 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
1849 mutex_lock(&dqopt->dqio_mutex); 2070 mutex_lock(&dqopt->dqio_mutex);
1850 if ((error = dqopt->ops[type]->read_file_info(sb, type)) < 0) { 2071 error = dqopt->ops[type]->read_file_info(sb, type);
2072 if (error < 0) {
1851 mutex_unlock(&dqopt->dqio_mutex); 2073 mutex_unlock(&dqopt->dqio_mutex);
1852 goto out_file_init; 2074 goto out_file_init;
1853 } 2075 }
@@ -1927,6 +2149,7 @@ int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
1927 DQUOT_LIMITS_ENABLED); 2149 DQUOT_LIMITS_ENABLED);
1928 return error; 2150 return error;
1929} 2151}
2152EXPORT_SYMBOL(vfs_quota_on_path);
1930 2153
1931int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name, 2154int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name,
1932 int remount) 2155 int remount)
@@ -1944,6 +2167,7 @@ int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name,
1944 } 2167 }
1945 return error; 2168 return error;
1946} 2169}
2170EXPORT_SYMBOL(vfs_quota_on);
1947 2171
1948/* 2172/*
1949 * More powerful function for turning on quotas allowing setting 2173 * More powerful function for turning on quotas allowing setting
@@ -1990,6 +2214,7 @@ out_lock:
1990load_quota: 2214load_quota:
1991 return vfs_load_quota_inode(inode, type, format_id, flags); 2215 return vfs_load_quota_inode(inode, type, format_id, flags);
1992} 2216}
2217EXPORT_SYMBOL(vfs_quota_enable);
1993 2218
1994/* 2219/*
1995 * This function is used when filesystem needs to initialize quotas 2220 * This function is used when filesystem needs to initialize quotas
@@ -2019,6 +2244,7 @@ out:
2019 dput(dentry); 2244 dput(dentry);
2020 return error; 2245 return error;
2021} 2246}
2247EXPORT_SYMBOL(vfs_quota_on_mount);
2022 2248
2023/* Wrapper to turn on quotas when remounting rw */ 2249/* Wrapper to turn on quotas when remounting rw */
2024int vfs_dq_quota_on_remount(struct super_block *sb) 2250int vfs_dq_quota_on_remount(struct super_block *sb)
@@ -2035,6 +2261,7 @@ int vfs_dq_quota_on_remount(struct super_block *sb)
2035 } 2261 }
2036 return ret; 2262 return ret;
2037} 2263}
2264EXPORT_SYMBOL(vfs_dq_quota_on_remount);
2038 2265
2039static inline qsize_t qbtos(qsize_t blocks) 2266static inline qsize_t qbtos(qsize_t blocks)
2040{ 2267{
@@ -2054,7 +2281,7 @@ static void do_get_dqblk(struct dquot *dquot, struct if_dqblk *di)
2054 spin_lock(&dq_data_lock); 2281 spin_lock(&dq_data_lock);
2055 di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit); 2282 di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit);
2056 di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit); 2283 di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit);
2057 di->dqb_curspace = dm->dqb_curspace; 2284 di->dqb_curspace = dm->dqb_curspace + dm->dqb_rsvspace;
2058 di->dqb_ihardlimit = dm->dqb_ihardlimit; 2285 di->dqb_ihardlimit = dm->dqb_ihardlimit;
2059 di->dqb_isoftlimit = dm->dqb_isoftlimit; 2286 di->dqb_isoftlimit = dm->dqb_isoftlimit;
2060 di->dqb_curinodes = dm->dqb_curinodes; 2287 di->dqb_curinodes = dm->dqb_curinodes;
@@ -2064,18 +2291,20 @@ static void do_get_dqblk(struct dquot *dquot, struct if_dqblk *di)
2064 spin_unlock(&dq_data_lock); 2291 spin_unlock(&dq_data_lock);
2065} 2292}
2066 2293
2067int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2294int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
2295 struct if_dqblk *di)
2068{ 2296{
2069 struct dquot *dquot; 2297 struct dquot *dquot;
2070 2298
2071 dquot = dqget(sb, id, type); 2299 dquot = dqget(sb, id, type);
2072 if (dquot == NODQUOT) 2300 if (!dquot)
2073 return -ESRCH; 2301 return -ESRCH;
2074 do_get_dqblk(dquot, di); 2302 do_get_dqblk(dquot, di);
2075 dqput(dquot); 2303 dqput(dquot);
2076 2304
2077 return 0; 2305 return 0;
2078} 2306}
2307EXPORT_SYMBOL(vfs_get_dqblk);
2079 2308
2080/* Generic routine for setting common part of quota structure */ 2309/* Generic routine for setting common part of quota structure */
2081static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di) 2310static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
@@ -2094,7 +2323,7 @@ static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
2094 2323
2095 spin_lock(&dq_data_lock); 2324 spin_lock(&dq_data_lock);
2096 if (di->dqb_valid & QIF_SPACE) { 2325 if (di->dqb_valid & QIF_SPACE) {
2097 dm->dqb_curspace = di->dqb_curspace; 2326 dm->dqb_curspace = di->dqb_curspace - dm->dqb_rsvspace;
2098 check_blim = 1; 2327 check_blim = 1;
2099 __set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2328 __set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
2100 } 2329 }
@@ -2127,22 +2356,25 @@ static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
2127 } 2356 }
2128 2357
2129 if (check_blim) { 2358 if (check_blim) {
2130 if (!dm->dqb_bsoftlimit || dm->dqb_curspace < dm->dqb_bsoftlimit) { 2359 if (!dm->dqb_bsoftlimit ||
2360 dm->dqb_curspace < dm->dqb_bsoftlimit) {
2131 dm->dqb_btime = 0; 2361 dm->dqb_btime = 0;
2132 clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2362 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
2133 } 2363 } else if (!(di->dqb_valid & QIF_BTIME))
2134 else if (!(di->dqb_valid & QIF_BTIME)) /* Set grace only if user hasn't provided his own... */ 2364 /* Set grace only if user hasn't provided his own... */
2135 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2365 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
2136 } 2366 }
2137 if (check_ilim) { 2367 if (check_ilim) {
2138 if (!dm->dqb_isoftlimit || dm->dqb_curinodes < dm->dqb_isoftlimit) { 2368 if (!dm->dqb_isoftlimit ||
2369 dm->dqb_curinodes < dm->dqb_isoftlimit) {
2139 dm->dqb_itime = 0; 2370 dm->dqb_itime = 0;
2140 clear_bit(DQ_INODES_B, &dquot->dq_flags); 2371 clear_bit(DQ_INODES_B, &dquot->dq_flags);
2141 } 2372 } else if (!(di->dqb_valid & QIF_ITIME))
2142 else if (!(di->dqb_valid & QIF_ITIME)) /* Set grace only if user hasn't provided his own... */ 2373 /* Set grace only if user hasn't provided his own... */
2143 dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2374 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
2144 } 2375 }
2145 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || dm->dqb_isoftlimit) 2376 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2377 dm->dqb_isoftlimit)
2146 clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2378 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2147 else 2379 else
2148 set_bit(DQ_FAKE_B, &dquot->dq_flags); 2380 set_bit(DQ_FAKE_B, &dquot->dq_flags);
@@ -2152,7 +2384,8 @@ static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
2152 return 0; 2384 return 0;
2153} 2385}
2154 2386
2155int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) 2387int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
2388 struct if_dqblk *di)
2156{ 2389{
2157 struct dquot *dquot; 2390 struct dquot *dquot;
2158 int rc; 2391 int rc;
@@ -2167,6 +2400,7 @@ int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *d
2167out: 2400out:
2168 return rc; 2401 return rc;
2169} 2402}
2403EXPORT_SYMBOL(vfs_set_dqblk);
2170 2404
2171/* Generic routine for getting common part of quota file information */ 2405/* Generic routine for getting common part of quota file information */
2172int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2406int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
@@ -2188,6 +2422,7 @@ int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2188 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2422 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2189 return 0; 2423 return 0;
2190} 2424}
2425EXPORT_SYMBOL(vfs_get_dqinfo);
2191 2426
2192/* Generic routine for setting common part of quota file information */ 2427/* Generic routine for setting common part of quota file information */
2193int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2428int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
@@ -2207,7 +2442,8 @@ int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2207 if (ii->dqi_valid & IIF_IGRACE) 2442 if (ii->dqi_valid & IIF_IGRACE)
2208 mi->dqi_igrace = ii->dqi_igrace; 2443 mi->dqi_igrace = ii->dqi_igrace;
2209 if (ii->dqi_valid & IIF_FLAGS) 2444 if (ii->dqi_valid & IIF_FLAGS)
2210 mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) | (ii->dqi_flags & DQF_MASK); 2445 mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) |
2446 (ii->dqi_flags & DQF_MASK);
2211 spin_unlock(&dq_data_lock); 2447 spin_unlock(&dq_data_lock);
2212 mark_info_dirty(sb, type); 2448 mark_info_dirty(sb, type);
2213 /* Force write to disk */ 2449 /* Force write to disk */
@@ -2216,6 +2452,7 @@ out:
2216 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2452 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2217 return err; 2453 return err;
2218} 2454}
2455EXPORT_SYMBOL(vfs_set_dqinfo);
2219 2456
2220struct quotactl_ops vfs_quotactl_ops = { 2457struct quotactl_ops vfs_quotactl_ops = {
2221 .quota_on = vfs_quota_on, 2458 .quota_on = vfs_quota_on,
@@ -2365,43 +2602,10 @@ static int __init dquot_init(void)
2365 2602
2366#ifdef CONFIG_QUOTA_NETLINK_INTERFACE 2603#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
2367 if (genl_register_family(&quota_genl_family) != 0) 2604 if (genl_register_family(&quota_genl_family) != 0)
2368 printk(KERN_ERR "VFS: Failed to create quota netlink interface.\n"); 2605 printk(KERN_ERR
2606 "VFS: Failed to create quota netlink interface.\n");
2369#endif 2607#endif
2370 2608
2371 return 0; 2609 return 0;
2372} 2610}
2373module_init(dquot_init); 2611module_init(dquot_init);
2374
2375EXPORT_SYMBOL(register_quota_format);
2376EXPORT_SYMBOL(unregister_quota_format);
2377EXPORT_SYMBOL(dqstats);
2378EXPORT_SYMBOL(dq_data_lock);
2379EXPORT_SYMBOL(vfs_quota_enable);
2380EXPORT_SYMBOL(vfs_quota_on);
2381EXPORT_SYMBOL(vfs_quota_on_path);
2382EXPORT_SYMBOL(vfs_quota_on_mount);
2383EXPORT_SYMBOL(vfs_quota_disable);
2384EXPORT_SYMBOL(vfs_quota_off);
2385EXPORT_SYMBOL(dquot_scan_active);
2386EXPORT_SYMBOL(vfs_quota_sync);
2387EXPORT_SYMBOL(vfs_get_dqinfo);
2388EXPORT_SYMBOL(vfs_set_dqinfo);
2389EXPORT_SYMBOL(vfs_get_dqblk);
2390EXPORT_SYMBOL(vfs_set_dqblk);
2391EXPORT_SYMBOL(dquot_commit);
2392EXPORT_SYMBOL(dquot_commit_info);
2393EXPORT_SYMBOL(dquot_acquire);
2394EXPORT_SYMBOL(dquot_release);
2395EXPORT_SYMBOL(dquot_mark_dquot_dirty);
2396EXPORT_SYMBOL(dquot_initialize);
2397EXPORT_SYMBOL(dquot_drop);
2398EXPORT_SYMBOL(vfs_dq_drop);
2399EXPORT_SYMBOL(dqget);
2400EXPORT_SYMBOL(dqput);
2401EXPORT_SYMBOL(dquot_alloc_space);
2402EXPORT_SYMBOL(dquot_alloc_inode);
2403EXPORT_SYMBOL(dquot_free_space);
2404EXPORT_SYMBOL(dquot_free_inode);
2405EXPORT_SYMBOL(dquot_transfer);
2406EXPORT_SYMBOL(vfs_dq_transfer);
2407EXPORT_SYMBOL(vfs_dq_quota_on_remount);
diff --git a/fs/quota.c b/fs/quota/quota.c
index d76ada914f98..b7f5a468f076 100644
--- a/fs/quota.c
+++ b/fs/quota/quota.c
@@ -20,7 +20,8 @@
20#include <linux/types.h> 20#include <linux/types.h>
21 21
22/* Check validity of generic quotactl commands */ 22/* Check validity of generic quotactl commands */
23static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 23static int generic_quotactl_valid(struct super_block *sb, int type, int cmd,
24 qid_t id)
24{ 25{
25 if (type >= MAXQUOTAS) 26 if (type >= MAXQUOTAS)
26 return -EINVAL; 27 return -EINVAL;
@@ -72,7 +73,8 @@ static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid
72 case Q_SETINFO: 73 case Q_SETINFO:
73 case Q_SETQUOTA: 74 case Q_SETQUOTA:
74 case Q_GETQUOTA: 75 case Q_GETQUOTA:
75 /* This is just informative test so we are satisfied without a lock */ 76 /* This is just an informative test so we are satisfied
77 * without the lock */
76 if (!sb_has_quota_active(sb, type)) 78 if (!sb_has_quota_active(sb, type))
77 return -ESRCH; 79 return -ESRCH;
78 } 80 }
@@ -92,7 +94,8 @@ static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid
92} 94}
93 95
94/* Check validity of XFS Quota Manager commands */ 96/* Check validity of XFS Quota Manager commands */
95static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 97static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd,
98 qid_t id)
96{ 99{
97 if (type >= XQM_MAXQUOTAS) 100 if (type >= XQM_MAXQUOTAS)
98 return -EINVAL; 101 return -EINVAL;
@@ -142,7 +145,8 @@ static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t i
142 return 0; 145 return 0;
143} 146}
144 147
145static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 148static int check_quotactl_valid(struct super_block *sb, int type, int cmd,
149 qid_t id)
146{ 150{
147 int error; 151 int error;
148 152
@@ -180,7 +184,8 @@ static void quota_sync_sb(struct super_block *sb, int type)
180 continue; 184 continue;
181 if (!sb_has_quota_active(sb, cnt)) 185 if (!sb_has_quota_active(sb, cnt))
182 continue; 186 continue;
183 mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex, I_MUTEX_QUOTA); 187 mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
188 I_MUTEX_QUOTA);
184 truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0); 189 truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
185 mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex); 190 mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
186 } 191 }
@@ -200,14 +205,15 @@ void sync_dquots(struct super_block *sb, int type)
200 spin_lock(&sb_lock); 205 spin_lock(&sb_lock);
201restart: 206restart:
202 list_for_each_entry(sb, &super_blocks, s_list) { 207 list_for_each_entry(sb, &super_blocks, s_list) {
203 /* This test just improves performance so it needn't be reliable... */ 208 /* This test just improves performance so it needn't be
209 * reliable... */
204 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 210 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
205 if (type != -1 && type != cnt) 211 if (type != -1 && type != cnt)
206 continue; 212 continue;
207 if (!sb_has_quota_active(sb, cnt)) 213 if (!sb_has_quota_active(sb, cnt))
208 continue; 214 continue;
209 if (!info_dirty(&sb_dqopt(sb)->info[cnt]) && 215 if (!info_dirty(&sb_dqopt(sb)->info[cnt]) &&
210 list_empty(&sb_dqopt(sb)->info[cnt].dqi_dirty_list)) 216 list_empty(&sb_dqopt(sb)->info[cnt].dqi_dirty_list))
211 continue; 217 continue;
212 break; 218 break;
213 } 219 }
@@ -227,7 +233,8 @@ restart:
227} 233}
228 234
229/* Copy parameters and call proper function */ 235/* Copy parameters and call proper function */
230static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void __user *addr) 236static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
237 void __user *addr)
231{ 238{
232 int ret; 239 int ret;
233 240
@@ -235,7 +242,8 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void
235 case Q_QUOTAON: { 242 case Q_QUOTAON: {
236 char *pathname; 243 char *pathname;
237 244
238 if (IS_ERR(pathname = getname(addr))) 245 pathname = getname(addr);
246 if (IS_ERR(pathname))
239 return PTR_ERR(pathname); 247 return PTR_ERR(pathname);
240 ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0); 248 ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0);
241 putname(pathname); 249 putname(pathname);
@@ -261,7 +269,8 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void
261 case Q_GETINFO: { 269 case Q_GETINFO: {
262 struct if_dqinfo info; 270 struct if_dqinfo info;
263 271
264 if ((ret = sb->s_qcop->get_info(sb, type, &info))) 272 ret = sb->s_qcop->get_info(sb, type, &info);
273 if (ret)
265 return ret; 274 return ret;
266 if (copy_to_user(addr, &info, sizeof(info))) 275 if (copy_to_user(addr, &info, sizeof(info)))
267 return -EFAULT; 276 return -EFAULT;
@@ -277,7 +286,8 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void
277 case Q_GETQUOTA: { 286 case Q_GETQUOTA: {
278 struct if_dqblk idq; 287 struct if_dqblk idq;
279 288
280 if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq))) 289 ret = sb->s_qcop->get_dqblk(sb, type, id, &idq);
290 if (ret)
281 return ret; 291 return ret;
282 if (copy_to_user(addr, &idq, sizeof(idq))) 292 if (copy_to_user(addr, &idq, sizeof(idq)))
283 return -EFAULT; 293 return -EFAULT;
@@ -322,7 +332,8 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void
322 case Q_XGETQUOTA: { 332 case Q_XGETQUOTA: {
323 struct fs_disk_quota fdq; 333 struct fs_disk_quota fdq;
324 334
325 if ((ret = sb->s_qcop->get_xquota(sb, type, id, &fdq))) 335 ret = sb->s_qcop->get_xquota(sb, type, id, &fdq);
336 if (ret)
326 return ret; 337 return ret;
327 if (copy_to_user(addr, &fdq, sizeof(fdq))) 338 if (copy_to_user(addr, &fdq, sizeof(fdq)))
328 return -EFAULT; 339 return -EFAULT;
@@ -341,7 +352,7 @@ static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void
341 * look up a superblock on which quota ops will be performed 352 * look up a superblock on which quota ops will be performed
342 * - use the name of a block device to find the superblock thereon 353 * - use the name of a block device to find the superblock thereon
343 */ 354 */
344static inline struct super_block *quotactl_block(const char __user *special) 355static struct super_block *quotactl_block(const char __user *special)
345{ 356{
346#ifdef CONFIG_BLOCK 357#ifdef CONFIG_BLOCK
347 struct block_device *bdev; 358 struct block_device *bdev;
diff --git a/fs/quota_tree.c b/fs/quota/quota_tree.c
index 953404c95b17..f81f4bcfb178 100644
--- a/fs/quota_tree.c
+++ b/fs/quota/quota_tree.c
@@ -22,8 +22,6 @@ MODULE_LICENSE("GPL");
22 22
23#define __QUOTA_QT_PARANOIA 23#define __QUOTA_QT_PARANOIA
24 24
25typedef char *dqbuf_t;
26
27static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth) 25static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth)
28{ 26{
29 unsigned int epb = info->dqi_usable_bs >> 2; 27 unsigned int epb = info->dqi_usable_bs >> 2;
@@ -35,46 +33,42 @@ static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth)
35} 33}
36 34
37/* Number of entries in one blocks */ 35/* Number of entries in one blocks */
38static inline int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info) 36static int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info)
39{ 37{
40 return (info->dqi_usable_bs - sizeof(struct qt_disk_dqdbheader)) 38 return (info->dqi_usable_bs - sizeof(struct qt_disk_dqdbheader))
41 / info->dqi_entry_size; 39 / info->dqi_entry_size;
42} 40}
43 41
44static dqbuf_t getdqbuf(size_t size) 42static char *getdqbuf(size_t size)
45{ 43{
46 dqbuf_t buf = kmalloc(size, GFP_NOFS); 44 char *buf = kmalloc(size, GFP_NOFS);
47 if (!buf) 45 if (!buf)
48 printk(KERN_WARNING "VFS: Not enough memory for quota buffers.\n"); 46 printk(KERN_WARNING
47 "VFS: Not enough memory for quota buffers.\n");
49 return buf; 48 return buf;
50} 49}
51 50
52static inline void freedqbuf(dqbuf_t buf) 51static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf)
53{
54 kfree(buf);
55}
56
57static inline ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, dqbuf_t buf)
58{ 52{
59 struct super_block *sb = info->dqi_sb; 53 struct super_block *sb = info->dqi_sb;
60 54
61 memset(buf, 0, info->dqi_usable_bs); 55 memset(buf, 0, info->dqi_usable_bs);
62 return sb->s_op->quota_read(sb, info->dqi_type, (char *)buf, 56 return sb->s_op->quota_read(sb, info->dqi_type, buf,
63 info->dqi_usable_bs, blk << info->dqi_blocksize_bits); 57 info->dqi_usable_bs, blk << info->dqi_blocksize_bits);
64} 58}
65 59
66static inline ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, dqbuf_t buf) 60static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf)
67{ 61{
68 struct super_block *sb = info->dqi_sb; 62 struct super_block *sb = info->dqi_sb;
69 63
70 return sb->s_op->quota_write(sb, info->dqi_type, (char *)buf, 64 return sb->s_op->quota_write(sb, info->dqi_type, buf,
71 info->dqi_usable_bs, blk << info->dqi_blocksize_bits); 65 info->dqi_usable_bs, blk << info->dqi_blocksize_bits);
72} 66}
73 67
74/* Remove empty block from list and return it */ 68/* Remove empty block from list and return it */
75static int get_free_dqblk(struct qtree_mem_dqinfo *info) 69static int get_free_dqblk(struct qtree_mem_dqinfo *info)
76{ 70{
77 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 71 char *buf = getdqbuf(info->dqi_usable_bs);
78 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 72 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
79 int ret, blk; 73 int ret, blk;
80 74
@@ -98,12 +92,12 @@ static int get_free_dqblk(struct qtree_mem_dqinfo *info)
98 mark_info_dirty(info->dqi_sb, info->dqi_type); 92 mark_info_dirty(info->dqi_sb, info->dqi_type);
99 ret = blk; 93 ret = blk;
100out_buf: 94out_buf:
101 freedqbuf(buf); 95 kfree(buf);
102 return ret; 96 return ret;
103} 97}
104 98
105/* Insert empty block to the list */ 99/* Insert empty block to the list */
106static int put_free_dqblk(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) 100static int put_free_dqblk(struct qtree_mem_dqinfo *info, char *buf, uint blk)
107{ 101{
108 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 102 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
109 int err; 103 int err;
@@ -120,9 +114,10 @@ static int put_free_dqblk(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk)
120} 114}
121 115
122/* Remove given block from the list of blocks with free entries */ 116/* Remove given block from the list of blocks with free entries */
123static int remove_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) 117static int remove_free_dqentry(struct qtree_mem_dqinfo *info, char *buf,
118 uint blk)
124{ 119{
125 dqbuf_t tmpbuf = getdqbuf(info->dqi_usable_bs); 120 char *tmpbuf = getdqbuf(info->dqi_usable_bs);
126 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 121 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
127 uint nextblk = le32_to_cpu(dh->dqdh_next_free); 122 uint nextblk = le32_to_cpu(dh->dqdh_next_free);
128 uint prevblk = le32_to_cpu(dh->dqdh_prev_free); 123 uint prevblk = le32_to_cpu(dh->dqdh_prev_free);
@@ -153,21 +148,24 @@ static int remove_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint
153 info->dqi_free_entry = nextblk; 148 info->dqi_free_entry = nextblk;
154 mark_info_dirty(info->dqi_sb, info->dqi_type); 149 mark_info_dirty(info->dqi_sb, info->dqi_type);
155 } 150 }
156 freedqbuf(tmpbuf); 151 kfree(tmpbuf);
157 dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0); 152 dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0);
158 /* No matter whether write succeeds block is out of list */ 153 /* No matter whether write succeeds block is out of list */
159 if (write_blk(info, blk, buf) < 0) 154 if (write_blk(info, blk, buf) < 0)
160 printk(KERN_ERR "VFS: Can't write block (%u) with free entries.\n", blk); 155 printk(KERN_ERR
156 "VFS: Can't write block (%u) with free entries.\n",
157 blk);
161 return 0; 158 return 0;
162out_buf: 159out_buf:
163 freedqbuf(tmpbuf); 160 kfree(tmpbuf);
164 return err; 161 return err;
165} 162}
166 163
167/* Insert given block to the beginning of list with free entries */ 164/* Insert given block to the beginning of list with free entries */
168static int insert_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) 165static int insert_free_dqentry(struct qtree_mem_dqinfo *info, char *buf,
166 uint blk)
169{ 167{
170 dqbuf_t tmpbuf = getdqbuf(info->dqi_usable_bs); 168 char *tmpbuf = getdqbuf(info->dqi_usable_bs);
171 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 169 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
172 int err; 170 int err;
173 171
@@ -188,12 +186,12 @@ static int insert_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint
188 if (err < 0) 186 if (err < 0)
189 goto out_buf; 187 goto out_buf;
190 } 188 }
191 freedqbuf(tmpbuf); 189 kfree(tmpbuf);
192 info->dqi_free_entry = blk; 190 info->dqi_free_entry = blk;
193 mark_info_dirty(info->dqi_sb, info->dqi_type); 191 mark_info_dirty(info->dqi_sb, info->dqi_type);
194 return 0; 192 return 0;
195out_buf: 193out_buf:
196 freedqbuf(tmpbuf); 194 kfree(tmpbuf);
197 return err; 195 return err;
198} 196}
199 197
@@ -215,7 +213,7 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
215{ 213{
216 uint blk, i; 214 uint blk, i;
217 struct qt_disk_dqdbheader *dh; 215 struct qt_disk_dqdbheader *dh;
218 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 216 char *buf = getdqbuf(info->dqi_usable_bs);
219 char *ddquot; 217 char *ddquot;
220 218
221 *err = 0; 219 *err = 0;
@@ -233,11 +231,12 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
233 blk = get_free_dqblk(info); 231 blk = get_free_dqblk(info);
234 if ((int)blk < 0) { 232 if ((int)blk < 0) {
235 *err = blk; 233 *err = blk;
236 freedqbuf(buf); 234 kfree(buf);
237 return 0; 235 return 0;
238 } 236 }
239 memset(buf, 0, info->dqi_usable_bs); 237 memset(buf, 0, info->dqi_usable_bs);
240 /* This is enough as block is already zeroed and entry list is empty... */ 238 /* This is enough as the block is already zeroed and the entry
239 * list is empty... */
241 info->dqi_free_entry = blk; 240 info->dqi_free_entry = blk;
242 mark_info_dirty(dquot->dq_sb, dquot->dq_type); 241 mark_info_dirty(dquot->dq_sb, dquot->dq_type);
243 } 242 }
@@ -253,9 +252,12 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
253 } 252 }
254 le16_add_cpu(&dh->dqdh_entries, 1); 253 le16_add_cpu(&dh->dqdh_entries, 1);
255 /* Find free structure in block */ 254 /* Find free structure in block */
256 for (i = 0, ddquot = ((char *)buf) + sizeof(struct qt_disk_dqdbheader); 255 ddquot = buf + sizeof(struct qt_disk_dqdbheader);
257 i < qtree_dqstr_in_blk(info) && !qtree_entry_unused(info, ddquot); 256 for (i = 0; i < qtree_dqstr_in_blk(info); i++) {
258 i++, ddquot += info->dqi_entry_size); 257 if (qtree_entry_unused(info, ddquot))
258 break;
259 ddquot += info->dqi_entry_size;
260 }
259#ifdef __QUOTA_QT_PARANOIA 261#ifdef __QUOTA_QT_PARANOIA
260 if (i == qtree_dqstr_in_blk(info)) { 262 if (i == qtree_dqstr_in_blk(info)) {
261 printk(KERN_ERR "VFS: find_free_dqentry(): Data block full " 263 printk(KERN_ERR "VFS: find_free_dqentry(): Data block full "
@@ -273,10 +275,10 @@ static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
273 dquot->dq_off = (blk << info->dqi_blocksize_bits) + 275 dquot->dq_off = (blk << info->dqi_blocksize_bits) +
274 sizeof(struct qt_disk_dqdbheader) + 276 sizeof(struct qt_disk_dqdbheader) +
275 i * info->dqi_entry_size; 277 i * info->dqi_entry_size;
276 freedqbuf(buf); 278 kfree(buf);
277 return blk; 279 return blk;
278out_buf: 280out_buf:
279 freedqbuf(buf); 281 kfree(buf);
280 return 0; 282 return 0;
281} 283}
282 284
@@ -284,7 +286,7 @@ out_buf:
284static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, 286static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
285 uint *treeblk, int depth) 287 uint *treeblk, int depth)
286{ 288{
287 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 289 char *buf = getdqbuf(info->dqi_usable_bs);
288 int ret = 0, newson = 0, newact = 0; 290 int ret = 0, newson = 0, newact = 0;
289 __le32 *ref; 291 __le32 *ref;
290 uint newblk; 292 uint newblk;
@@ -333,7 +335,7 @@ static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
333 put_free_dqblk(info, buf, *treeblk); 335 put_free_dqblk(info, buf, *treeblk);
334 } 336 }
335out_buf: 337out_buf:
336 freedqbuf(buf); 338 kfree(buf);
337 return ret; 339 return ret;
338} 340}
339 341
@@ -346,14 +348,15 @@ static inline int dq_insert_tree(struct qtree_mem_dqinfo *info,
346} 348}
347 349
348/* 350/*
349 * We don't have to be afraid of deadlocks as we never have quotas on quota files... 351 * We don't have to be afraid of deadlocks as we never have quotas on quota
352 * files...
350 */ 353 */
351int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 354int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
352{ 355{
353 int type = dquot->dq_type; 356 int type = dquot->dq_type;
354 struct super_block *sb = dquot->dq_sb; 357 struct super_block *sb = dquot->dq_sb;
355 ssize_t ret; 358 ssize_t ret;
356 dqbuf_t ddquot = getdqbuf(info->dqi_entry_size); 359 char *ddquot = getdqbuf(info->dqi_entry_size);
357 360
358 if (!ddquot) 361 if (!ddquot)
359 return -ENOMEM; 362 return -ENOMEM;
@@ -364,15 +367,15 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
364 if (ret < 0) { 367 if (ret < 0) {
365 printk(KERN_ERR "VFS: Error %zd occurred while " 368 printk(KERN_ERR "VFS: Error %zd occurred while "
366 "creating quota.\n", ret); 369 "creating quota.\n", ret);
367 freedqbuf(ddquot); 370 kfree(ddquot);
368 return ret; 371 return ret;
369 } 372 }
370 } 373 }
371 spin_lock(&dq_data_lock); 374 spin_lock(&dq_data_lock);
372 info->dqi_ops->mem2disk_dqblk(ddquot, dquot); 375 info->dqi_ops->mem2disk_dqblk(ddquot, dquot);
373 spin_unlock(&dq_data_lock); 376 spin_unlock(&dq_data_lock);
374 ret = sb->s_op->quota_write(sb, type, (char *)ddquot, 377 ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size,
375 info->dqi_entry_size, dquot->dq_off); 378 dquot->dq_off);
376 if (ret != info->dqi_entry_size) { 379 if (ret != info->dqi_entry_size) {
377 printk(KERN_WARNING "VFS: dquota write failed on dev %s\n", 380 printk(KERN_WARNING "VFS: dquota write failed on dev %s\n",
378 sb->s_id); 381 sb->s_id);
@@ -382,7 +385,7 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
382 ret = 0; 385 ret = 0;
383 } 386 }
384 dqstats.writes++; 387 dqstats.writes++;
385 freedqbuf(ddquot); 388 kfree(ddquot);
386 389
387 return ret; 390 return ret;
388} 391}
@@ -393,7 +396,7 @@ static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
393 uint blk) 396 uint blk)
394{ 397{
395 struct qt_disk_dqdbheader *dh; 398 struct qt_disk_dqdbheader *dh;
396 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 399 char *buf = getdqbuf(info->dqi_usable_bs);
397 int ret = 0; 400 int ret = 0;
398 401
399 if (!buf) 402 if (!buf)
@@ -444,7 +447,7 @@ static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
444 } 447 }
445 dquot->dq_off = 0; /* Quota is now unattached */ 448 dquot->dq_off = 0; /* Quota is now unattached */
446out_buf: 449out_buf:
447 freedqbuf(buf); 450 kfree(buf);
448 return ret; 451 return ret;
449} 452}
450 453
@@ -452,7 +455,7 @@ out_buf:
452static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, 455static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
453 uint *blk, int depth) 456 uint *blk, int depth)
454{ 457{
455 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 458 char *buf = getdqbuf(info->dqi_usable_bs);
456 int ret = 0; 459 int ret = 0;
457 uint newblk; 460 uint newblk;
458 __le32 *ref = (__le32 *)buf; 461 __le32 *ref = (__le32 *)buf;
@@ -475,9 +478,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
475 int i; 478 int i;
476 ref[get_index(info, dquot->dq_id, depth)] = cpu_to_le32(0); 479 ref[get_index(info, dquot->dq_id, depth)] = cpu_to_le32(0);
477 /* Block got empty? */ 480 /* Block got empty? */
478 for (i = 0; 481 for (i = 0; i < (info->dqi_usable_bs >> 2) && !ref[i]; i++)
479 i < (info->dqi_usable_bs >> 2) && !ref[i]; 482 ;
480 i++);
481 /* Don't put the root block into the free block list */ 483 /* Don't put the root block into the free block list */
482 if (i == (info->dqi_usable_bs >> 2) 484 if (i == (info->dqi_usable_bs >> 2)
483 && *blk != QT_TREEOFF) { 485 && *blk != QT_TREEOFF) {
@@ -491,7 +493,7 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
491 } 493 }
492 } 494 }
493out_buf: 495out_buf:
494 freedqbuf(buf); 496 kfree(buf);
495 return ret; 497 return ret;
496} 498}
497 499
@@ -510,7 +512,7 @@ EXPORT_SYMBOL(qtree_delete_dquot);
510static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, 512static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
511 struct dquot *dquot, uint blk) 513 struct dquot *dquot, uint blk)
512{ 514{
513 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 515 char *buf = getdqbuf(info->dqi_usable_bs);
514 loff_t ret = 0; 516 loff_t ret = 0;
515 int i; 517 int i;
516 char *ddquot; 518 char *ddquot;
@@ -522,9 +524,12 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
522 printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk); 524 printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
523 goto out_buf; 525 goto out_buf;
524 } 526 }
525 for (i = 0, ddquot = ((char *)buf) + sizeof(struct qt_disk_dqdbheader); 527 ddquot = buf + sizeof(struct qt_disk_dqdbheader);
526 i < qtree_dqstr_in_blk(info) && !info->dqi_ops->is_id(ddquot, dquot); 528 for (i = 0; i < qtree_dqstr_in_blk(info); i++) {
527 i++, ddquot += info->dqi_entry_size); 529 if (info->dqi_ops->is_id(ddquot, dquot))
530 break;
531 ddquot += info->dqi_entry_size;
532 }
528 if (i == qtree_dqstr_in_blk(info)) { 533 if (i == qtree_dqstr_in_blk(info)) {
529 printk(KERN_ERR "VFS: Quota for id %u referenced " 534 printk(KERN_ERR "VFS: Quota for id %u referenced "
530 "but not present.\n", dquot->dq_id); 535 "but not present.\n", dquot->dq_id);
@@ -535,7 +540,7 @@ static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
535 qt_disk_dqdbheader) + i * info->dqi_entry_size; 540 qt_disk_dqdbheader) + i * info->dqi_entry_size;
536 } 541 }
537out_buf: 542out_buf:
538 freedqbuf(buf); 543 kfree(buf);
539 return ret; 544 return ret;
540} 545}
541 546
@@ -543,7 +548,7 @@ out_buf:
543static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info, 548static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info,
544 struct dquot *dquot, uint blk, int depth) 549 struct dquot *dquot, uint blk, int depth)
545{ 550{
546 dqbuf_t buf = getdqbuf(info->dqi_usable_bs); 551 char *buf = getdqbuf(info->dqi_usable_bs);
547 loff_t ret = 0; 552 loff_t ret = 0;
548 __le32 *ref = (__le32 *)buf; 553 __le32 *ref = (__le32 *)buf;
549 554
@@ -563,7 +568,7 @@ static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info,
563 else 568 else
564 ret = find_block_dqentry(info, dquot, blk); 569 ret = find_block_dqentry(info, dquot, blk);
565out_buf: 570out_buf:
566 freedqbuf(buf); 571 kfree(buf);
567 return ret; 572 return ret;
568} 573}
569 574
@@ -579,7 +584,7 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
579 int type = dquot->dq_type; 584 int type = dquot->dq_type;
580 struct super_block *sb = dquot->dq_sb; 585 struct super_block *sb = dquot->dq_sb;
581 loff_t offset; 586 loff_t offset;
582 dqbuf_t ddquot; 587 char *ddquot;
583 int ret = 0; 588 int ret = 0;
584 589
585#ifdef __QUOTA_QT_PARANOIA 590#ifdef __QUOTA_QT_PARANOIA
@@ -607,8 +612,8 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
607 ddquot = getdqbuf(info->dqi_entry_size); 612 ddquot = getdqbuf(info->dqi_entry_size);
608 if (!ddquot) 613 if (!ddquot)
609 return -ENOMEM; 614 return -ENOMEM;
610 ret = sb->s_op->quota_read(sb, type, (char *)ddquot, 615 ret = sb->s_op->quota_read(sb, type, ddquot, info->dqi_entry_size,
611 info->dqi_entry_size, dquot->dq_off); 616 dquot->dq_off);
612 if (ret != info->dqi_entry_size) { 617 if (ret != info->dqi_entry_size) {
613 if (ret >= 0) 618 if (ret >= 0)
614 ret = -EIO; 619 ret = -EIO;
@@ -616,7 +621,7 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
616 "structure for id %u.\n", dquot->dq_id); 621 "structure for id %u.\n", dquot->dq_id);
617 set_bit(DQ_FAKE_B, &dquot->dq_flags); 622 set_bit(DQ_FAKE_B, &dquot->dq_flags);
618 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk)); 623 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
619 freedqbuf(ddquot); 624 kfree(ddquot);
620 goto out; 625 goto out;
621 } 626 }
622 spin_lock(&dq_data_lock); 627 spin_lock(&dq_data_lock);
@@ -627,7 +632,7 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
627 !dquot->dq_dqb.dqb_isoftlimit) 632 !dquot->dq_dqb.dqb_isoftlimit)
628 set_bit(DQ_FAKE_B, &dquot->dq_flags); 633 set_bit(DQ_FAKE_B, &dquot->dq_flags);
629 spin_unlock(&dq_data_lock); 634 spin_unlock(&dq_data_lock);
630 freedqbuf(ddquot); 635 kfree(ddquot);
631out: 636out:
632 dqstats.reads++; 637 dqstats.reads++;
633 return ret; 638 return ret;
@@ -638,7 +643,8 @@ EXPORT_SYMBOL(qtree_read_dquot);
638 * the only one operating on dquot (thanks to dq_lock) */ 643 * the only one operating on dquot (thanks to dq_lock) */
639int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 644int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
640{ 645{
641 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) && !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace)) 646 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) &&
647 !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace))
642 return qtree_delete_dquot(info, dquot); 648 return qtree_delete_dquot(info, dquot);
643 return 0; 649 return 0;
644} 650}
diff --git a/fs/quota_tree.h b/fs/quota/quota_tree.h
index a1ab8db81a51..a1ab8db81a51 100644
--- a/fs/quota_tree.h
+++ b/fs/quota/quota_tree.h
diff --git a/fs/quota_v1.c b/fs/quota/quota_v1.c
index b4af1c69ad16..0edcf42b1778 100644
--- a/fs/quota_v1.c
+++ b/fs/quota/quota_v1.c
@@ -62,11 +62,14 @@ static int v1_read_dqblk(struct dquot *dquot)
62 62
63 /* Set structure to 0s in case read fails/is after end of file */ 63 /* Set structure to 0s in case read fails/is after end of file */
64 memset(&dqblk, 0, sizeof(struct v1_disk_dqblk)); 64 memset(&dqblk, 0, sizeof(struct v1_disk_dqblk));
65 dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type, (char *)&dqblk, sizeof(struct v1_disk_dqblk), v1_dqoff(dquot->dq_id)); 65 dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type, (char *)&dqblk,
66 sizeof(struct v1_disk_dqblk), v1_dqoff(dquot->dq_id));
66 67
67 v1_disk2mem_dqblk(&dquot->dq_dqb, &dqblk); 68 v1_disk2mem_dqblk(&dquot->dq_dqb, &dqblk);
68 if (dquot->dq_dqb.dqb_bhardlimit == 0 && dquot->dq_dqb.dqb_bsoftlimit == 0 && 69 if (dquot->dq_dqb.dqb_bhardlimit == 0 &&
69 dquot->dq_dqb.dqb_ihardlimit == 0 && dquot->dq_dqb.dqb_isoftlimit == 0) 70 dquot->dq_dqb.dqb_bsoftlimit == 0 &&
71 dquot->dq_dqb.dqb_ihardlimit == 0 &&
72 dquot->dq_dqb.dqb_isoftlimit == 0)
70 set_bit(DQ_FAKE_B, &dquot->dq_flags); 73 set_bit(DQ_FAKE_B, &dquot->dq_flags);
71 dqstats.reads++; 74 dqstats.reads++;
72 75
@@ -81,13 +84,16 @@ static int v1_commit_dqblk(struct dquot *dquot)
81 84
82 v1_mem2disk_dqblk(&dqblk, &dquot->dq_dqb); 85 v1_mem2disk_dqblk(&dqblk, &dquot->dq_dqb);
83 if (dquot->dq_id == 0) { 86 if (dquot->dq_id == 0) {
84 dqblk.dqb_btime = sb_dqopt(dquot->dq_sb)->info[type].dqi_bgrace; 87 dqblk.dqb_btime =
85 dqblk.dqb_itime = sb_dqopt(dquot->dq_sb)->info[type].dqi_igrace; 88 sb_dqopt(dquot->dq_sb)->info[type].dqi_bgrace;
89 dqblk.dqb_itime =
90 sb_dqopt(dquot->dq_sb)->info[type].dqi_igrace;
86 } 91 }
87 ret = 0; 92 ret = 0;
88 if (sb_dqopt(dquot->dq_sb)->files[type]) 93 if (sb_dqopt(dquot->dq_sb)->files[type])
89 ret = dquot->dq_sb->s_op->quota_write(dquot->dq_sb, type, (char *)&dqblk, 94 ret = dquot->dq_sb->s_op->quota_write(dquot->dq_sb, type,
90 sizeof(struct v1_disk_dqblk), v1_dqoff(dquot->dq_id)); 95 (char *)&dqblk, sizeof(struct v1_disk_dqblk),
96 v1_dqoff(dquot->dq_id));
91 if (ret != sizeof(struct v1_disk_dqblk)) { 97 if (ret != sizeof(struct v1_disk_dqblk)) {
92 printk(KERN_WARNING "VFS: dquota write failed on dev %s\n", 98 printk(KERN_WARNING "VFS: dquota write failed on dev %s\n",
93 dquot->dq_sb->s_id); 99 dquot->dq_sb->s_id);
@@ -130,15 +136,20 @@ static int v1_check_quota_file(struct super_block *sb, int type)
130 return 0; 136 return 0;
131 blocks = isize >> BLOCK_SIZE_BITS; 137 blocks = isize >> BLOCK_SIZE_BITS;
132 off = isize & (BLOCK_SIZE - 1); 138 off = isize & (BLOCK_SIZE - 1);
133 if ((blocks % sizeof(struct v1_disk_dqblk) * BLOCK_SIZE + off) % sizeof(struct v1_disk_dqblk)) 139 if ((blocks % sizeof(struct v1_disk_dqblk) * BLOCK_SIZE + off) %
140 sizeof(struct v1_disk_dqblk))
134 return 0; 141 return 0;
135 /* Doublecheck whether we didn't get file with new format - with old quotactl() this could happen */ 142 /* Doublecheck whether we didn't get file with new format - with old
136 size = sb->s_op->quota_read(sb, type, (char *)&dqhead, sizeof(struct v2_disk_dqheader), 0); 143 * quotactl() this could happen */
144 size = sb->s_op->quota_read(sb, type, (char *)&dqhead,
145 sizeof(struct v2_disk_dqheader), 0);
137 if (size != sizeof(struct v2_disk_dqheader)) 146 if (size != sizeof(struct v2_disk_dqheader))
138 return 1; /* Probably not new format */ 147 return 1; /* Probably not new format */
139 if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type]) 148 if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type])
140 return 1; /* Definitely not new format */ 149 return 1; /* Definitely not new format */
141 printk(KERN_INFO "VFS: %s: Refusing to turn on old quota format on given file. It probably contains newer quota format.\n", sb->s_id); 150 printk(KERN_INFO
151 "VFS: %s: Refusing to turn on old quota format on given file."
152 " It probably contains newer quota format.\n", sb->s_id);
142 return 0; /* Seems like a new format file -> refuse it */ 153 return 0; /* Seems like a new format file -> refuse it */
143} 154}
144 155
@@ -148,7 +159,9 @@ static int v1_read_file_info(struct super_block *sb, int type)
148 struct v1_disk_dqblk dqblk; 159 struct v1_disk_dqblk dqblk;
149 int ret; 160 int ret;
150 161
151 if ((ret = sb->s_op->quota_read(sb, type, (char *)&dqblk, sizeof(struct v1_disk_dqblk), v1_dqoff(0))) != sizeof(struct v1_disk_dqblk)) { 162 ret = sb->s_op->quota_read(sb, type, (char *)&dqblk,
163 sizeof(struct v1_disk_dqblk), v1_dqoff(0));
164 if (ret != sizeof(struct v1_disk_dqblk)) {
152 if (ret >= 0) 165 if (ret >= 0)
153 ret = -EIO; 166 ret = -EIO;
154 goto out; 167 goto out;
@@ -157,8 +170,10 @@ static int v1_read_file_info(struct super_block *sb, int type)
157 /* limits are stored as unsigned 32-bit data */ 170 /* limits are stored as unsigned 32-bit data */
158 dqopt->info[type].dqi_maxblimit = 0xffffffff; 171 dqopt->info[type].dqi_maxblimit = 0xffffffff;
159 dqopt->info[type].dqi_maxilimit = 0xffffffff; 172 dqopt->info[type].dqi_maxilimit = 0xffffffff;
160 dqopt->info[type].dqi_igrace = dqblk.dqb_itime ? dqblk.dqb_itime : MAX_IQ_TIME; 173 dqopt->info[type].dqi_igrace =
161 dqopt->info[type].dqi_bgrace = dqblk.dqb_btime ? dqblk.dqb_btime : MAX_DQ_TIME; 174 dqblk.dqb_itime ? dqblk.dqb_itime : MAX_IQ_TIME;
175 dqopt->info[type].dqi_bgrace =
176 dqblk.dqb_btime ? dqblk.dqb_btime : MAX_DQ_TIME;
162out: 177out:
163 return ret; 178 return ret;
164} 179}
@@ -170,8 +185,9 @@ static int v1_write_file_info(struct super_block *sb, int type)
170 int ret; 185 int ret;
171 186
172 dqopt->info[type].dqi_flags &= ~DQF_INFO_DIRTY; 187 dqopt->info[type].dqi_flags &= ~DQF_INFO_DIRTY;
173 if ((ret = sb->s_op->quota_read(sb, type, (char *)&dqblk, 188 ret = sb->s_op->quota_read(sb, type, (char *)&dqblk,
174 sizeof(struct v1_disk_dqblk), v1_dqoff(0))) != sizeof(struct v1_disk_dqblk)) { 189 sizeof(struct v1_disk_dqblk), v1_dqoff(0));
190 if (ret != sizeof(struct v1_disk_dqblk)) {
175 if (ret >= 0) 191 if (ret >= 0)
176 ret = -EIO; 192 ret = -EIO;
177 goto out; 193 goto out;
diff --git a/fs/quota_v2.c b/fs/quota/quota_v2.c
index b618b563635c..a5475fb1ae44 100644
--- a/fs/quota_v2.c
+++ b/fs/quota/quota_v2.c
@@ -54,7 +54,8 @@ static int v2_check_quota_file(struct super_block *sb, int type)
54 static const uint quota_magics[] = V2_INITQMAGICS; 54 static const uint quota_magics[] = V2_INITQMAGICS;
55 static const uint quota_versions[] = V2_INITQVERSIONS; 55 static const uint quota_versions[] = V2_INITQVERSIONS;
56 56
57 size = sb->s_op->quota_read(sb, type, (char *)&dqhead, sizeof(struct v2_disk_dqheader), 0); 57 size = sb->s_op->quota_read(sb, type, (char *)&dqhead,
58 sizeof(struct v2_disk_dqheader), 0);
58 if (size != sizeof(struct v2_disk_dqheader)) { 59 if (size != sizeof(struct v2_disk_dqheader)) {
59 printk("quota_v2: failed read expected=%zd got=%zd\n", 60 printk("quota_v2: failed read expected=%zd got=%zd\n",
60 sizeof(struct v2_disk_dqheader), size); 61 sizeof(struct v2_disk_dqheader), size);
diff --git a/fs/quotaio_v1.h b/fs/quota/quotaio_v1.h
index 746654b5de70..746654b5de70 100644
--- a/fs/quotaio_v1.h
+++ b/fs/quota/quotaio_v1.h
diff --git a/fs/quotaio_v2.h b/fs/quota/quotaio_v2.h
index 530fe580685c..530fe580685c 100644
--- a/fs/quotaio_v2.h
+++ b/fs/quota/quotaio_v2.h
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index 5d7c7ececa64..995ef1d6686c 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -18,7 +18,6 @@
18#include <linux/string.h> 18#include <linux/string.h>
19#include <linux/backing-dev.h> 19#include <linux/backing-dev.h>
20#include <linux/ramfs.h> 20#include <linux/ramfs.h>
21#include <linux/quotaops.h>
22#include <linux/pagevec.h> 21#include <linux/pagevec.h>
23#include <linux/mman.h> 22#include <linux/mman.h>
24 23
@@ -205,11 +204,6 @@ static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia)
205 if (ret) 204 if (ret)
206 return ret; 205 return ret;
207 206
208 /* by providing our own setattr() method, we skip this quotaism */
209 if ((old_ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
210 (old_ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid))
211 ret = DQUOT_TRANSFER(inode, ia) ? -EDQUOT : 0;
212
213 /* pick out size-changing events */ 207 /* pick out size-changing events */
214 if (ia->ia_valid & ATTR_SIZE) { 208 if (ia->ia_valid & ATTR_SIZE) {
215 loff_t size = i_size_read(inode); 209 loff_t size = i_size_read(inode);
diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index 4646caa60455..f32d1425cc9f 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -430,7 +430,7 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
430 430
431 journal_mark_dirty(th, s, sbh); 431 journal_mark_dirty(th, s, sbh);
432 if (for_unformatted) 432 if (for_unformatted)
433 DQUOT_FREE_BLOCK_NODIRTY(inode, 1); 433 vfs_dq_free_block_nodirty(inode, 1);
434} 434}
435 435
436void reiserfs_free_block(struct reiserfs_transaction_handle *th, 436void reiserfs_free_block(struct reiserfs_transaction_handle *th,
@@ -1055,7 +1055,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
1055 amount_needed, hint->inode->i_uid); 1055 amount_needed, hint->inode->i_uid);
1056#endif 1056#endif
1057 quota_ret = 1057 quota_ret =
1058 DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode, amount_needed); 1058 vfs_dq_alloc_block_nodirty(hint->inode, amount_needed);
1059 if (quota_ret) /* Quota exceeded? */ 1059 if (quota_ret) /* Quota exceeded? */
1060 return QUOTA_EXCEEDED; 1060 return QUOTA_EXCEEDED;
1061 if (hint->preallocate && hint->prealloc_size) { 1061 if (hint->preallocate && hint->prealloc_size) {
@@ -1064,8 +1064,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
1064 "reiserquota: allocating (prealloc) %d blocks id=%u", 1064 "reiserquota: allocating (prealloc) %d blocks id=%u",
1065 hint->prealloc_size, hint->inode->i_uid); 1065 hint->prealloc_size, hint->inode->i_uid);
1066#endif 1066#endif
1067 quota_ret = 1067 quota_ret = vfs_dq_prealloc_block_nodirty(hint->inode,
1068 DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode,
1069 hint->prealloc_size); 1068 hint->prealloc_size);
1070 if (quota_ret) 1069 if (quota_ret)
1071 hint->preallocate = hint->prealloc_size = 0; 1070 hint->preallocate = hint->prealloc_size = 0;
@@ -1098,7 +1097,10 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
1098 nr_allocated, 1097 nr_allocated,
1099 hint->inode->i_uid); 1098 hint->inode->i_uid);
1100#endif 1099#endif
1101 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed + hint->prealloc_size - nr_allocated); /* Free not allocated blocks */ 1100 /* Free not allocated blocks */
1101 vfs_dq_free_block_nodirty(hint->inode,
1102 amount_needed + hint->prealloc_size -
1103 nr_allocated);
1102 } 1104 }
1103 while (nr_allocated--) 1105 while (nr_allocated--)
1104 reiserfs_free_block(hint->th, hint->inode, 1106 reiserfs_free_block(hint->th, hint->inode,
@@ -1129,7 +1131,7 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
1129 REISERFS_I(hint->inode)->i_prealloc_count, 1131 REISERFS_I(hint->inode)->i_prealloc_count,
1130 hint->inode->i_uid); 1132 hint->inode->i_uid);
1131#endif 1133#endif
1132 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed + 1134 vfs_dq_free_block_nodirty(hint->inode, amount_needed +
1133 hint->prealloc_size - nr_allocated - 1135 hint->prealloc_size - nr_allocated -
1134 REISERFS_I(hint->inode)-> 1136 REISERFS_I(hint->inode)->
1135 i_prealloc_count); 1137 i_prealloc_count);
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 55fce92cdf18..823227a7662a 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -53,7 +53,7 @@ void reiserfs_delete_inode(struct inode *inode)
53 * after delete_object so that quota updates go into the same transaction as 53 * after delete_object so that quota updates go into the same transaction as
54 * stat data deletion */ 54 * stat data deletion */
55 if (!err) 55 if (!err)
56 DQUOT_FREE_INODE(inode); 56 vfs_dq_free_inode(inode);
57 57
58 if (journal_end(&th, inode->i_sb, jbegin_count)) 58 if (journal_end(&th, inode->i_sb, jbegin_count))
59 goto out; 59 goto out;
@@ -1763,7 +1763,7 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1763 1763
1764 BUG_ON(!th->t_trans_id); 1764 BUG_ON(!th->t_trans_id);
1765 1765
1766 if (DQUOT_ALLOC_INODE(inode)) { 1766 if (vfs_dq_alloc_inode(inode)) {
1767 err = -EDQUOT; 1767 err = -EDQUOT;
1768 goto out_end_trans; 1768 goto out_end_trans;
1769 } 1769 }
@@ -1947,12 +1947,12 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1947 INODE_PKEY(inode)->k_objectid = 0; 1947 INODE_PKEY(inode)->k_objectid = 0;
1948 1948
1949 /* Quota change must be inside a transaction for journaling */ 1949 /* Quota change must be inside a transaction for journaling */
1950 DQUOT_FREE_INODE(inode); 1950 vfs_dq_free_inode(inode);
1951 1951
1952 out_end_trans: 1952 out_end_trans:
1953 journal_end(th, th->t_super, th->t_blocks_allocated); 1953 journal_end(th, th->t_super, th->t_blocks_allocated);
1954 /* Drop can be outside and it needs more credits so it's better to have it outside */ 1954 /* Drop can be outside and it needs more credits so it's better to have it outside */
1955 DQUOT_DROP(inode); 1955 vfs_dq_drop(inode);
1956 inode->i_flags |= S_NOQUOTA; 1956 inode->i_flags |= S_NOQUOTA;
1957 make_bad_inode(inode); 1957 make_bad_inode(inode);
1958 1958
@@ -3119,7 +3119,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
3119 if (error) 3119 if (error)
3120 goto out; 3120 goto out;
3121 error = 3121 error =
3122 DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0; 3122 vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
3123 if (error) { 3123 if (error) {
3124 journal_end(&th, inode->i_sb, 3124 journal_end(&th, inode->i_sb,
3125 jbegin_count); 3125 jbegin_count);
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 738967f6c8ee..639d635d9d4b 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -555,7 +555,7 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
555*/ 555*/
556static int drop_new_inode(struct inode *inode) 556static int drop_new_inode(struct inode *inode)
557{ 557{
558 DQUOT_DROP(inode); 558 vfs_dq_drop(inode);
559 make_bad_inode(inode); 559 make_bad_inode(inode);
560 inode->i_flags |= S_NOQUOTA; 560 inode->i_flags |= S_NOQUOTA;
561 iput(inode); 561 iput(inode);
@@ -563,7 +563,7 @@ static int drop_new_inode(struct inode *inode)
563} 563}
564 564
565/* utility function that does setup for reiserfs_new_inode. 565/* utility function that does setup for reiserfs_new_inode.
566** DQUOT_INIT needs lots of credits so it's better to have it 566** vfs_dq_init needs lots of credits so it's better to have it
567** outside of a transaction, so we had to pull some bits of 567** outside of a transaction, so we had to pull some bits of
568** reiserfs_new_inode out into this func. 568** reiserfs_new_inode out into this func.
569*/ 569*/
@@ -586,7 +586,7 @@ static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
586 } else { 586 } else {
587 inode->i_gid = current_fsgid(); 587 inode->i_gid = current_fsgid();
588 } 588 }
589 DQUOT_INIT(inode); 589 vfs_dq_init(inode);
590 return 0; 590 return 0;
591} 591}
592 592
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index abbc64dcc8d4..73aaa33f6735 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -1297,7 +1297,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
1297 "reiserquota delete_item(): freeing %u, id=%u type=%c", 1297 "reiserquota delete_item(): freeing %u, id=%u type=%c",
1298 quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih)); 1298 quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih));
1299#endif 1299#endif
1300 DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes); 1300 vfs_dq_free_space_nodirty(p_s_inode, quota_cut_bytes);
1301 1301
1302 /* Return deleted body length */ 1302 /* Return deleted body length */
1303 return n_ret_value; 1303 return n_ret_value;
@@ -1383,7 +1383,7 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
1383 quota_cut_bytes, inode->i_uid, 1383 quota_cut_bytes, inode->i_uid,
1384 key2type(key)); 1384 key2type(key));
1385#endif 1385#endif
1386 DQUOT_FREE_SPACE_NODIRTY(inode, 1386 vfs_dq_free_space_nodirty(inode,
1387 quota_cut_bytes); 1387 quota_cut_bytes);
1388 } 1388 }
1389 break; 1389 break;
@@ -1734,7 +1734,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
1734 "reiserquota cut_from_item(): freeing %u id=%u type=%c", 1734 "reiserquota cut_from_item(): freeing %u id=%u type=%c",
1735 quota_cut_bytes, p_s_inode->i_uid, '?'); 1735 quota_cut_bytes, p_s_inode->i_uid, '?');
1736#endif 1736#endif
1737 DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes); 1737 vfs_dq_free_space_nodirty(p_s_inode, quota_cut_bytes);
1738 return n_ret_value; 1738 return n_ret_value;
1739} 1739}
1740 1740
@@ -1971,7 +1971,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct tree
1971 key2type(&(p_s_key->on_disk_key))); 1971 key2type(&(p_s_key->on_disk_key)));
1972#endif 1972#endif
1973 1973
1974 if (DQUOT_ALLOC_SPACE_NODIRTY(inode, n_pasted_size)) { 1974 if (vfs_dq_alloc_space_nodirty(inode, n_pasted_size)) {
1975 pathrelse(p_s_search_path); 1975 pathrelse(p_s_search_path);
1976 return -EDQUOT; 1976 return -EDQUOT;
1977 } 1977 }
@@ -2027,7 +2027,7 @@ int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct tree
2027 n_pasted_size, inode->i_uid, 2027 n_pasted_size, inode->i_uid,
2028 key2type(&(p_s_key->on_disk_key))); 2028 key2type(&(p_s_key->on_disk_key)));
2029#endif 2029#endif
2030 DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size); 2030 vfs_dq_free_space_nodirty(inode, n_pasted_size);
2031 return retval; 2031 return retval;
2032} 2032}
2033 2033
@@ -2060,7 +2060,7 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath
2060#endif 2060#endif
2061 /* We can't dirty inode here. It would be immediately written but 2061 /* We can't dirty inode here. It would be immediately written but
2062 * appropriate stat item isn't inserted yet... */ 2062 * appropriate stat item isn't inserted yet... */
2063 if (DQUOT_ALLOC_SPACE_NODIRTY(inode, quota_bytes)) { 2063 if (vfs_dq_alloc_space_nodirty(inode, quota_bytes)) {
2064 pathrelse(p_s_path); 2064 pathrelse(p_s_path);
2065 return -EDQUOT; 2065 return -EDQUOT;
2066 } 2066 }
@@ -2112,6 +2112,6 @@ int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath
2112 quota_bytes, inode->i_uid, head2type(p_s_ih)); 2112 quota_bytes, inode->i_uid, head2type(p_s_ih));
2113#endif 2113#endif
2114 if (inode) 2114 if (inode)
2115 DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes); 2115 vfs_dq_free_space_nodirty(inode, quota_bytes);
2116 return retval; 2116 return retval;
2117} 2117}
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index f3c820b75829..5dbafb739401 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -250,7 +250,7 @@ static int finish_unfinished(struct super_block *s)
250 retval = remove_save_link_only(s, &save_link_key, 0); 250 retval = remove_save_link_only(s, &save_link_key, 0);
251 continue; 251 continue;
252 } 252 }
253 DQUOT_INIT(inode); 253 vfs_dq_init(inode);
254 254
255 if (truncate && S_ISDIR(inode->i_mode)) { 255 if (truncate && S_ISDIR(inode->i_mode)) {
256 /* We got a truncate request for a dir which is impossible. 256 /* We got a truncate request for a dir which is impossible.
@@ -629,8 +629,6 @@ static const struct super_operations reiserfs_sops = {
629#ifdef CONFIG_QUOTA 629#ifdef CONFIG_QUOTA
630#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group") 630#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
631 631
632static int reiserfs_dquot_initialize(struct inode *, int);
633static int reiserfs_dquot_drop(struct inode *);
634static int reiserfs_write_dquot(struct dquot *); 632static int reiserfs_write_dquot(struct dquot *);
635static int reiserfs_acquire_dquot(struct dquot *); 633static int reiserfs_acquire_dquot(struct dquot *);
636static int reiserfs_release_dquot(struct dquot *); 634static int reiserfs_release_dquot(struct dquot *);
@@ -639,8 +637,8 @@ static int reiserfs_write_info(struct super_block *, int);
639static int reiserfs_quota_on(struct super_block *, int, int, char *, int); 637static int reiserfs_quota_on(struct super_block *, int, int, char *, int);
640 638
641static struct dquot_operations reiserfs_quota_operations = { 639static struct dquot_operations reiserfs_quota_operations = {
642 .initialize = reiserfs_dquot_initialize, 640 .initialize = dquot_initialize,
643 .drop = reiserfs_dquot_drop, 641 .drop = dquot_drop,
644 .alloc_space = dquot_alloc_space, 642 .alloc_space = dquot_alloc_space,
645 .alloc_inode = dquot_alloc_inode, 643 .alloc_inode = dquot_alloc_inode,
646 .free_space = dquot_free_space, 644 .free_space = dquot_free_space,
@@ -1896,58 +1894,6 @@ static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1896} 1894}
1897 1895
1898#ifdef CONFIG_QUOTA 1896#ifdef CONFIG_QUOTA
1899static int reiserfs_dquot_initialize(struct inode *inode, int type)
1900{
1901 struct reiserfs_transaction_handle th;
1902 int ret, err;
1903
1904 /* We may create quota structure so we need to reserve enough blocks */
1905 reiserfs_write_lock(inode->i_sb);
1906 ret =
1907 journal_begin(&th, inode->i_sb,
1908 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1909 if (ret)
1910 goto out;
1911 ret = dquot_initialize(inode, type);
1912 err =
1913 journal_end(&th, inode->i_sb,
1914 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));
1915 if (!ret && err)
1916 ret = err;
1917 out:
1918 reiserfs_write_unlock(inode->i_sb);
1919 return ret;
1920}
1921
1922static int reiserfs_dquot_drop(struct inode *inode)
1923{
1924 struct reiserfs_transaction_handle th;
1925 int ret, err;
1926
1927 /* We may delete quota structure so we need to reserve enough blocks */
1928 reiserfs_write_lock(inode->i_sb);
1929 ret =
1930 journal_begin(&th, inode->i_sb,
1931 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1932 if (ret) {
1933 /*
1934 * We call dquot_drop() anyway to at least release references
1935 * to quota structures so that umount does not hang.
1936 */
1937 dquot_drop(inode);
1938 goto out;
1939 }
1940 ret = dquot_drop(inode);
1941 err =
1942 journal_end(&th, inode->i_sb,
1943 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));
1944 if (!ret && err)
1945 ret = err;
1946 out:
1947 reiserfs_write_unlock(inode->i_sb);
1948 return ret;
1949}
1950
1951static int reiserfs_write_dquot(struct dquot *dquot) 1897static int reiserfs_write_dquot(struct dquot *dquot)
1952{ 1898{
1953 struct reiserfs_transaction_handle th; 1899 struct reiserfs_transaction_handle th;
diff --git a/fs/super.c b/fs/super.c
index dd4acb158b5e..49d0bd32a5a7 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -197,7 +197,7 @@ void deactivate_super(struct super_block *s)
197 if (atomic_dec_and_lock(&s->s_active, &sb_lock)) { 197 if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
198 s->s_count -= S_BIAS-1; 198 s->s_count -= S_BIAS-1;
199 spin_unlock(&sb_lock); 199 spin_unlock(&sb_lock);
200 DQUOT_OFF(s, 0); 200 vfs_dq_off(s, 0);
201 down_write(&s->s_umount); 201 down_write(&s->s_umount);
202 fs->kill_sb(s); 202 fs->kill_sb(s);
203 put_filesystem(fs); 203 put_filesystem(fs);
@@ -266,7 +266,7 @@ EXPORT_SYMBOL(unlock_super);
266void __fsync_super(struct super_block *sb) 266void __fsync_super(struct super_block *sb)
267{ 267{
268 sync_inodes_sb(sb, 0); 268 sync_inodes_sb(sb, 0);
269 DQUOT_SYNC(sb); 269 vfs_dq_sync(sb);
270 lock_super(sb); 270 lock_super(sb);
271 if (sb->s_dirt && sb->s_op->write_super) 271 if (sb->s_dirt && sb->s_op->write_super)
272 sb->s_op->write_super(sb); 272 sb->s_op->write_super(sb);
@@ -655,7 +655,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
655 mark_files_ro(sb); 655 mark_files_ro(sb);
656 else if (!fs_may_remount_ro(sb)) 656 else if (!fs_may_remount_ro(sb))
657 return -EBUSY; 657 return -EBUSY;
658 retval = DQUOT_OFF(sb, 1); 658 retval = vfs_dq_off(sb, 1);
659 if (retval < 0 && retval != -ENOSYS) 659 if (retval < 0 && retval != -ENOSYS)
660 return -EBUSY; 660 return -EBUSY;
661 } 661 }
@@ -670,7 +670,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
670 } 670 }
671 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK); 671 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
672 if (remount_rw) 672 if (remount_rw)
673 DQUOT_ON_REMOUNT(sb); 673 vfs_dq_quota_on_remount(sb);
674 return 0; 674 return 0;
675} 675}
676 676
diff --git a/fs/sync.c b/fs/sync.c
index ec95a69d17aa..7abc65fbf21d 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -25,7 +25,7 @@ static void do_sync(unsigned long wait)
25{ 25{
26 wakeup_pdflush(0); 26 wakeup_pdflush(0);
27 sync_inodes(0); /* All mappings, inodes and their blockdevs */ 27 sync_inodes(0); /* All mappings, inodes and their blockdevs */
28 DQUOT_SYNC(NULL); 28 vfs_dq_sync(NULL);
29 sync_supers(); /* Write the superblocks */ 29 sync_supers(); /* Write the superblocks */
30 sync_filesystems(0); /* Start syncing the filesystems */ 30 sync_filesystems(0); /* Start syncing the filesystems */
31 sync_filesystems(wait); /* Waitingly sync the filesystems */ 31 sync_filesystems(wait); /* Waitingly sync the filesystems */
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index 1b809bd494bd..2bb788a2acb1 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -206,7 +206,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
206 ((char *)bh->b_data)[(bit + i) >> 3]); 206 ((char *)bh->b_data)[(bit + i) >> 3]);
207 } else { 207 } else {
208 if (inode) 208 if (inode)
209 DQUOT_FREE_BLOCK(inode, 1); 209 vfs_dq_free_block(inode, 1);
210 udf_add_free_space(sbi, sbi->s_partition, 1); 210 udf_add_free_space(sbi, sbi->s_partition, 1);
211 } 211 }
212 } 212 }
@@ -261,11 +261,11 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
261 while (bit < (sb->s_blocksize << 3) && block_count > 0) { 261 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
262 if (!udf_test_bit(bit, bh->b_data)) 262 if (!udf_test_bit(bit, bh->b_data))
263 goto out; 263 goto out;
264 else if (DQUOT_PREALLOC_BLOCK(inode, 1)) 264 else if (vfs_dq_prealloc_block(inode, 1))
265 goto out; 265 goto out;
266 else if (!udf_clear_bit(bit, bh->b_data)) { 266 else if (!udf_clear_bit(bit, bh->b_data)) {
267 udf_debug("bit already cleared for block %d\n", bit); 267 udf_debug("bit already cleared for block %d\n", bit);
268 DQUOT_FREE_BLOCK(inode, 1); 268 vfs_dq_free_block(inode, 1);
269 goto out; 269 goto out;
270 } 270 }
271 block_count--; 271 block_count--;
@@ -393,7 +393,7 @@ got_block:
393 /* 393 /*
394 * Check quota for allocation of this block. 394 * Check quota for allocation of this block.
395 */ 395 */
396 if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) { 396 if (inode && vfs_dq_alloc_block(inode, 1)) {
397 mutex_unlock(&sbi->s_alloc_mutex); 397 mutex_unlock(&sbi->s_alloc_mutex);
398 *err = -EDQUOT; 398 *err = -EDQUOT;
399 return 0; 399 return 0;
@@ -452,7 +452,7 @@ static void udf_table_free_blocks(struct super_block *sb,
452 /* We do this up front - There are some error conditions that 452 /* We do this up front - There are some error conditions that
453 could occure, but.. oh well */ 453 could occure, but.. oh well */
454 if (inode) 454 if (inode)
455 DQUOT_FREE_BLOCK(inode, count); 455 vfs_dq_free_block(inode, count);
456 if (udf_add_free_space(sbi, sbi->s_partition, count)) 456 if (udf_add_free_space(sbi, sbi->s_partition, count))
457 mark_buffer_dirty(sbi->s_lvid_bh); 457 mark_buffer_dirty(sbi->s_lvid_bh);
458 458
@@ -700,7 +700,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
700 epos.offset -= adsize; 700 epos.offset -= adsize;
701 701
702 alloc_count = (elen >> sb->s_blocksize_bits); 702 alloc_count = (elen >> sb->s_blocksize_bits);
703 if (inode && DQUOT_PREALLOC_BLOCK(inode, 703 if (inode && vfs_dq_prealloc_block(inode,
704 alloc_count > block_count ? block_count : alloc_count)) 704 alloc_count > block_count ? block_count : alloc_count))
705 alloc_count = 0; 705 alloc_count = 0;
706 else if (alloc_count > block_count) { 706 else if (alloc_count > block_count) {
@@ -806,7 +806,7 @@ static int udf_table_new_block(struct super_block *sb,
806 goal_eloc.logicalBlockNum++; 806 goal_eloc.logicalBlockNum++;
807 goal_elen -= sb->s_blocksize; 807 goal_elen -= sb->s_blocksize;
808 808
809 if (inode && DQUOT_ALLOC_BLOCK(inode, 1)) { 809 if (inode && vfs_dq_alloc_block(inode, 1)) {
810 brelse(goal_epos.bh); 810 brelse(goal_epos.bh);
811 mutex_unlock(&sbi->s_alloc_mutex); 811 mutex_unlock(&sbi->s_alloc_mutex);
812 *err = -EDQUOT; 812 *err = -EDQUOT;
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index 31fc84297ddb..47dbe5613f90 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -36,8 +36,8 @@ void udf_free_inode(struct inode *inode)
36 * Note: we must free any quota before locking the superblock, 36 * Note: we must free any quota before locking the superblock,
37 * as writing the quota to disk may need the lock as well. 37 * as writing the quota to disk may need the lock as well.
38 */ 38 */
39 DQUOT_FREE_INODE(inode); 39 vfs_dq_free_inode(inode);
40 DQUOT_DROP(inode); 40 vfs_dq_drop(inode);
41 41
42 clear_inode(inode); 42 clear_inode(inode);
43 43
@@ -154,8 +154,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
154 insert_inode_hash(inode); 154 insert_inode_hash(inode);
155 mark_inode_dirty(inode); 155 mark_inode_dirty(inode);
156 156
157 if (DQUOT_ALLOC_INODE(inode)) { 157 if (vfs_dq_alloc_inode(inode)) {
158 DQUOT_DROP(inode); 158 vfs_dq_drop(inode);
159 inode->i_flags |= S_NOQUOTA; 159 inode->i_flags |= S_NOQUOTA;
160 inode->i_nlink = 0; 160 inode->i_nlink = 0;
161 iput(inode); 161 iput(inode);
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 0d9ada173739..54c16ec95dff 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -85,7 +85,7 @@ void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count)
85 "bit already cleared for fragment %u", i); 85 "bit already cleared for fragment %u", i);
86 } 86 }
87 87
88 DQUOT_FREE_BLOCK (inode, count); 88 vfs_dq_free_block(inode, count);
89 89
90 90
91 fs32_add(sb, &ucg->cg_cs.cs_nffree, count); 91 fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
@@ -195,7 +195,7 @@ do_more:
195 ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno); 195 ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
196 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD) 196 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
197 ufs_clusteracct (sb, ucpi, blkno, 1); 197 ufs_clusteracct (sb, ucpi, blkno, 1);
198 DQUOT_FREE_BLOCK(inode, uspi->s_fpb); 198 vfs_dq_free_block(inode, uspi->s_fpb);
199 199
200 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1); 200 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
201 uspi->cs_total.cs_nbfree++; 201 uspi->cs_total.cs_nbfree++;
@@ -556,7 +556,7 @@ static u64 ufs_add_fragments(struct inode *inode, u64 fragment,
556 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1); 556 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
557 for (i = oldcount; i < newcount; i++) 557 for (i = oldcount; i < newcount; i++)
558 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i); 558 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i);
559 if(DQUOT_ALLOC_BLOCK(inode, count)) { 559 if (vfs_dq_alloc_block(inode, count)) {
560 *err = -EDQUOT; 560 *err = -EDQUOT;
561 return 0; 561 return 0;
562 } 562 }
@@ -664,7 +664,7 @@ cg_found:
664 for (i = count; i < uspi->s_fpb; i++) 664 for (i = count; i < uspi->s_fpb; i++)
665 ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i); 665 ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
666 i = uspi->s_fpb - count; 666 i = uspi->s_fpb - count;
667 DQUOT_FREE_BLOCK(inode, i); 667 vfs_dq_free_block(inode, i);
668 668
669 fs32_add(sb, &ucg->cg_cs.cs_nffree, i); 669 fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
670 uspi->cs_total.cs_nffree += i; 670 uspi->cs_total.cs_nffree += i;
@@ -676,7 +676,7 @@ cg_found:
676 result = ufs_bitmap_search (sb, ucpi, goal, allocsize); 676 result = ufs_bitmap_search (sb, ucpi, goal, allocsize);
677 if (result == INVBLOCK) 677 if (result == INVBLOCK)
678 return 0; 678 return 0;
679 if(DQUOT_ALLOC_BLOCK(inode, count)) { 679 if (vfs_dq_alloc_block(inode, count)) {
680 *err = -EDQUOT; 680 *err = -EDQUOT;
681 return 0; 681 return 0;
682 } 682 }
@@ -747,7 +747,7 @@ gotit:
747 ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno); 747 ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
748 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD) 748 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
749 ufs_clusteracct (sb, ucpi, blkno, -1); 749 ufs_clusteracct (sb, ucpi, blkno, -1);
750 if(DQUOT_ALLOC_BLOCK(inode, uspi->s_fpb)) { 750 if (vfs_dq_alloc_block(inode, uspi->s_fpb)) {
751 *err = -EDQUOT; 751 *err = -EDQUOT;
752 return INVBLOCK; 752 return INVBLOCK;
753 } 753 }
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 6f5dcf006096..3527c00fef0d 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -95,8 +95,8 @@ void ufs_free_inode (struct inode * inode)
95 95
96 is_directory = S_ISDIR(inode->i_mode); 96 is_directory = S_ISDIR(inode->i_mode);
97 97
98 DQUOT_FREE_INODE(inode); 98 vfs_dq_free_inode(inode);
99 DQUOT_DROP(inode); 99 vfs_dq_drop(inode);
100 100
101 clear_inode (inode); 101 clear_inode (inode);
102 102
@@ -355,8 +355,8 @@ cg_found:
355 355
356 unlock_super (sb); 356 unlock_super (sb);
357 357
358 if (DQUOT_ALLOC_INODE(inode)) { 358 if (vfs_dq_alloc_inode(inode)) {
359 DQUOT_DROP(inode); 359 vfs_dq_drop(inode);
360 err = -EDQUOT; 360 err = -EDQUOT;
361 goto fail_without_unlock; 361 goto fail_without_unlock;
362 } 362 }
diff --git a/include/linux/quota.h b/include/linux/quota.h
index d72d5d84fde5..78c48895b12a 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -198,6 +198,7 @@ struct mem_dqblk {
198 qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */ 198 qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */
199 qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */ 199 qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */
200 qsize_t dqb_curspace; /* current used space */ 200 qsize_t dqb_curspace; /* current used space */
201 qsize_t dqb_rsvspace; /* current reserved space for delalloc*/
201 qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */ 202 qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */
202 qsize_t dqb_isoftlimit; /* preferred inode limit */ 203 qsize_t dqb_isoftlimit; /* preferred inode limit */
203 qsize_t dqb_curinodes; /* current # allocated inodes */ 204 qsize_t dqb_curinodes; /* current # allocated inodes */
@@ -276,8 +277,6 @@ struct dquot {
276 struct mem_dqblk dq_dqb; /* Diskquota usage */ 277 struct mem_dqblk dq_dqb; /* Diskquota usage */
277}; 278};
278 279
279#define NODQUOT (struct dquot *)NULL
280
281#define QUOTA_OK 0 280#define QUOTA_OK 0
282#define NO_QUOTA 1 281#define NO_QUOTA 1
283 282
@@ -308,6 +307,14 @@ struct dquot_operations {
308 int (*release_dquot) (struct dquot *); /* Quota is going to be deleted from disk */ 307 int (*release_dquot) (struct dquot *); /* Quota is going to be deleted from disk */
309 int (*mark_dirty) (struct dquot *); /* Dquot is marked dirty */ 308 int (*mark_dirty) (struct dquot *); /* Dquot is marked dirty */
310 int (*write_info) (struct super_block *, int); /* Write of quota "superblock" */ 309 int (*write_info) (struct super_block *, int); /* Write of quota "superblock" */
310 /* reserve quota for delayed block allocation */
311 int (*reserve_space) (struct inode *, qsize_t, int);
312 /* claim reserved quota for delayed alloc */
313 int (*claim_space) (struct inode *, qsize_t);
314 /* release rsved quota for delayed alloc */
315 void (*release_rsv) (struct inode *, qsize_t);
316 /* get reserved quota for delayed alloc */
317 qsize_t (*get_reserved_space) (struct inode *);
311}; 318};
312 319
313/* Operations handling requests from userspace */ 320/* Operations handling requests from userspace */
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 0b35b3a1be05..36353d95c8db 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -35,6 +35,11 @@ void dquot_destroy(struct dquot *dquot);
35int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc); 35int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
36int dquot_alloc_inode(const struct inode *inode, qsize_t number); 36int dquot_alloc_inode(const struct inode *inode, qsize_t number);
37 37
38int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
39int dquot_claim_space(struct inode *inode, qsize_t number);
40void dquot_release_reserved_space(struct inode *inode, qsize_t number);
41qsize_t dquot_get_reserved_space(struct inode *inode);
42
38int dquot_free_space(struct inode *inode, qsize_t number); 43int dquot_free_space(struct inode *inode, qsize_t number);
39int dquot_free_inode(const struct inode *inode, qsize_t number); 44int dquot_free_inode(const struct inode *inode, qsize_t number);
40 45
@@ -183,6 +188,16 @@ static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
183 return ret; 188 return ret;
184} 189}
185 190
191static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
192{
193 if (sb_any_quota_active(inode->i_sb)) {
194 /* Used space is updated in alloc_space() */
195 if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
196 return 1;
197 }
198 return 0;
199}
200
186static inline int vfs_dq_alloc_inode(struct inode *inode) 201static inline int vfs_dq_alloc_inode(struct inode *inode)
187{ 202{
188 if (sb_any_quota_active(inode->i_sb)) { 203 if (sb_any_quota_active(inode->i_sb)) {
@@ -193,6 +208,31 @@ static inline int vfs_dq_alloc_inode(struct inode *inode)
193 return 0; 208 return 0;
194} 209}
195 210
211/*
212 * Convert in-memory reserved quotas to real consumed quotas
213 */
214static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
215{
216 if (sb_any_quota_active(inode->i_sb)) {
217 if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
218 return 1;
219 } else
220 inode_add_bytes(inode, nr);
221
222 mark_inode_dirty(inode);
223 return 0;
224}
225
226/*
227 * Release reserved (in-memory) quotas
228 */
229static inline
230void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
231{
232 if (sb_any_quota_active(inode->i_sb))
233 inode->i_sb->dq_op->release_rsv(inode, nr);
234}
235
196static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr) 236static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
197{ 237{
198 if (sb_any_quota_active(inode->i_sb)) 238 if (sb_any_quota_active(inode->i_sb))
@@ -339,6 +379,22 @@ static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
339 return 0; 379 return 0;
340} 380}
341 381
382static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
383{
384 return 0;
385}
386
387static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
388{
389 return vfs_dq_alloc_space(inode, nr);
390}
391
392static inline
393int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
394{
395 return 0;
396}
397
342static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr) 398static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
343{ 399{
344 inode_sub_bytes(inode, nr); 400 inode_sub_bytes(inode, nr);
@@ -354,67 +410,48 @@ static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
354 410
355static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr) 411static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
356{ 412{
357 return vfs_dq_prealloc_space_nodirty(inode, 413 return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
358 nr << inode->i_sb->s_blocksize_bits);
359} 414}
360 415
361static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr) 416static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
362{ 417{
363 return vfs_dq_prealloc_space(inode, 418 return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
364 nr << inode->i_sb->s_blocksize_bits);
365} 419}
366 420
367static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr) 421static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
368{ 422{
369 return vfs_dq_alloc_space_nodirty(inode, 423 return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
370 nr << inode->i_sb->s_blocksize_bits);
371} 424}
372 425
373static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr) 426static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
374{ 427{
375 return vfs_dq_alloc_space(inode, 428 return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
376 nr << inode->i_sb->s_blocksize_bits); 429}
430
431static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
432{
433 return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
434}
435
436static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
437{
438 return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
439}
440
441static inline
442void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
443{
444 vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
377} 445}
378 446
379static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr) 447static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
380{ 448{
381 vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits); 449 vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
382} 450}
383 451
384static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr) 452static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
385{ 453{
386 vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits); 454 vfs_dq_free_space(inode, nr << inode->i_blkbits);
387} 455}
388 456
389/*
390 * Define uppercase equivalents for compatibility with old function names
391 * Can go away when we think all users have been converted (15/04/2008)
392 */
393#define DQUOT_INIT(inode) vfs_dq_init(inode)
394#define DQUOT_DROP(inode) vfs_dq_drop(inode)
395#define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
396 vfs_dq_prealloc_space_nodirty(inode, nr)
397#define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
398#define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
399 vfs_dq_alloc_space_nodirty(inode, nr)
400#define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
401#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
402 vfs_dq_prealloc_block_nodirty(inode, nr)
403#define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
404#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
405 vfs_dq_alloc_block_nodirty(inode, nr)
406#define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
407#define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
408#define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
409 vfs_dq_free_space_nodirty(inode, nr)
410#define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
411#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
412 vfs_dq_free_block_nodirty(inode, nr)
413#define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
414#define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
415#define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
416#define DQUOT_SYNC(sb) vfs_dq_sync(sb)
417#define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
418#define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
419
420#endif /* _LINUX_QUOTAOPS_ */ 457#endif /* _LINUX_QUOTAOPS_ */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 00:46:54 -0500