diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2009-03-27 17:48:34 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2009-03-27 17:48:34 -0400 |
commit | 2c9e15a011c55ff96b2b8d2b126d1b9a96abba20 (patch) | |
tree | 6d9b27a07f88ad4509dcd86aa74a2cdecd0d5f4b /fs | |
parent | 805de022b100bcf796860fe88d7db4164066d1c3 (diff) | |
parent | c16831b4cc9b0805adf8ca3001752a7ec10a17bf (diff) |
Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-quota-2.6
* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-quota-2.6: (27 commits)
ext2: Zero our b_size in ext2_quota_read()
trivial: fix typos/grammar errors in fs/Kconfig
quota: Coding style fixes
quota: Remove superfluous inlines
quota: Remove uppercase aliases for quota functions.
nfsd: Use lowercase names of quota functions
jfs: Use lowercase names of quota functions
udf: Use lowercase names of quota functions
ufs: Use lowercase names of quota functions
reiserfs: Use lowercase names of quota functions
ext4: Use lowercase names of quota functions
ext3: Use lowercase names of quota functions
ext2: Use lowercase names of quota functions
ramfs: Remove quota call
vfs: Use lowercase names of quota functions
quota: Remove dqbuf_t and other cleanups
quota: Remove NODQUOT macro
quota: Make global quota locks cacheline aligned
quota: Move quota files into separate directory
ext4: quota reservation for delayed allocation
...
Diffstat (limited to 'fs')
-rw-r--r-- | fs/Kconfig | 56 | ||||
-rw-r--r-- | fs/Makefile | 6 | ||||
-rw-r--r-- | fs/attr.c | 3 | ||||
-rw-r--r-- | fs/ext2/balloc.c | 8 | ||||
-rw-r--r-- | fs/ext2/ialloc.c | 10 | ||||
-rw-r--r-- | fs/ext2/inode.c | 2 | ||||
-rw-r--r-- | fs/ext2/super.c | 1 | ||||
-rw-r--r-- | fs/ext2/xattr.c | 8 | ||||
-rw-r--r-- | fs/ext3/balloc.c | 8 | ||||
-rw-r--r-- | fs/ext3/ialloc.c | 12 | ||||
-rw-r--r-- | fs/ext3/inode.c | 6 | ||||
-rw-r--r-- | fs/ext3/namei.c | 6 | ||||
-rw-r--r-- | fs/ext3/super.c | 48 | ||||
-rw-r--r-- | fs/ext3/xattr.c | 6 | ||||
-rw-r--r-- | fs/ext4/balloc.c | 2 | ||||
-rw-r--r-- | fs/ext4/ext4.h | 2 | ||||
-rw-r--r-- | fs/ext4/ialloc.c | 12 | ||||
-rw-r--r-- | fs/ext4/inode.c | 40 | ||||
-rw-r--r-- | fs/ext4/mballoc.c | 46 | ||||
-rw-r--r-- | fs/ext4/namei.c | 6 | ||||
-rw-r--r-- | fs/ext4/super.c | 54 | ||||
-rw-r--r-- | fs/ext4/xattr.c | 6 | ||||
-rw-r--r-- | fs/inode.c | 4 | ||||
-rw-r--r-- | fs/jfs/acl.c | 2 | ||||
-rw-r--r-- | fs/jfs/inode.c | 6 | ||||
-rw-r--r-- | fs/jfs/jfs_dtree.c | 18 | ||||
-rw-r--r-- | fs/jfs/jfs_extent.c | 10 | ||||
-rw-r--r-- | fs/jfs/jfs_inode.c | 4 | ||||
-rw-r--r-- | fs/jfs/jfs_xtree.c | 14 | ||||
-rw-r--r-- | fs/jfs/namei.c | 6 | ||||
-rw-r--r-- | fs/jfs/xattr.c | 12 | ||||
-rw-r--r-- | fs/namei.c | 22 | ||||
-rw-r--r-- | fs/nfsd/vfs.c | 4 | ||||
-rw-r--r-- | fs/open.c | 2 | ||||
-rw-r--r-- | fs/quota/Kconfig | 59 | ||||
-rw-r--r-- | fs/quota/Makefile | 14 | ||||
-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.c | 6 | ||||
-rw-r--r-- | fs/reiserfs/bitmap.c | 14 | ||||
-rw-r--r-- | fs/reiserfs/inode.c | 10 | ||||
-rw-r--r-- | fs/reiserfs/namei.c | 6 | ||||
-rw-r--r-- | fs/reiserfs/stree.c | 14 | ||||
-rw-r--r-- | fs/reiserfs/super.c | 60 | ||||
-rw-r--r-- | fs/super.c | 8 | ||||
-rw-r--r-- | fs/sync.c | 2 | ||||
-rw-r--r-- | fs/udf/balloc.c | 14 | ||||
-rw-r--r-- | fs/udf/ialloc.c | 8 | ||||
-rw-r--r-- | fs/ufs/balloc.c | 12 | ||||
-rw-r--r-- | fs/ufs/ialloc.c | 8 |
56 files changed, 815 insertions, 654 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 | ||
57 | source "fs/notify/Kconfig" | 57 | source "fs/notify/Kconfig" |
58 | 58 | ||
59 | config QUOTA | 59 | source "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 | |||
72 | config 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 | |||
80 | config 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. | ||
91 | config QUOTA_TREE | ||
92 | tristate | ||
93 | |||
94 | config 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 | |||
102 | config 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 | |||
110 | config QUOTACTL | ||
111 | bool | ||
112 | depends on XFS_QUOTA || QUOTA | ||
113 | default y | ||
114 | 60 | ||
115 | source "fs/autofs/Kconfig" | 61 | source "fs/autofs/Kconfig" |
116 | source "fs/autofs4/Kconfig" | 62 | source "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 | |||
51 | obj-$(CONFIG_NFS_COMMON) += nfs_common/ | 51 | obj-$(CONFIG_NFS_COMMON) += nfs_common/ |
52 | obj-$(CONFIG_GENERIC_ACL) += generic_acl.o | 52 | obj-$(CONFIG_GENERIC_ACL) += generic_acl.o |
53 | 53 | ||
54 | obj-$(CONFIG_QUOTA) += dquot.o | 54 | obj-y += quota/ |
55 | obj-$(CONFIG_QFMT_V1) += quota_v1.o | ||
56 | obj-$(CONFIG_QFMT_V2) += quota_v2.o | ||
57 | obj-$(CONFIG_QUOTA_TREE) += quota_tree.o | ||
58 | obj-$(CONFIG_QUOTACTL) += quota.o | ||
59 | 55 | ||
60 | obj-$(CONFIG_PROC_FS) += proc/ | 56 | obj-$(CONFIG_PROC_FS) += proc/ |
61 | obj-y += partitions/ | 57 | obj-y += partitions/ |
@@ -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: | |||
570 | error_return: | 570 | error_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 | ||
607 | fail_free_drop: | 607 | fail_free_drop: |
608 | DQUOT_FREE_INODE(inode); | 608 | vfs_dq_free_inode(inode); |
609 | 609 | ||
610 | fail_drop: | 610 | fail_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 | ||
622 | fail_free_drop: | 622 | fail_free_drop: |
623 | DQUOT_FREE_INODE(inode); | 623 | vfs_dq_free_inode(inode); |
624 | 624 | ||
625 | fail_drop: | 625 | fail_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 | ||
710 | static int ext3_dquot_initialize(struct inode *inode, int type); | ||
711 | static int ext3_dquot_drop(struct inode *inode); | ||
712 | static int ext3_write_dquot(struct dquot *dquot); | 710 | static int ext3_write_dquot(struct dquot *dquot); |
713 | static int ext3_acquire_dquot(struct dquot *dquot); | 711 | static int ext3_acquire_dquot(struct dquot *dquot); |
714 | static int ext3_release_dquot(struct dquot *dquot); | 712 | static 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 | ||
725 | static struct dquot_operations ext3_quota_operations = { | 723 | static 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 | ||
2717 | static 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 | |||
2733 | static 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 | |||
2755 | static int ext3_write_dquot(struct dquot *dquot) | 2715 | static 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 | ||
850 | cleanup_dquot: | 850 | cleanup_dquot: |
851 | DQUOT_FREE_BLOCK(inode, 1); | 851 | vfs_dq_free_block(inode, 1); |
852 | goto cleanup; | 852 | goto cleanup; |
853 | 853 | ||
854 | bad_block: | 854 | bad_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); | |||
1098 | extern int ext4_block_truncate_page(handle_t *handle, | 1099 | extern int ext4_block_truncate_page(handle_t *handle, |
1099 | struct address_space *mapping, loff_t from); | 1100 | struct address_space *mapping, loff_t from); |
1100 | extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page); | 1101 | extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page); |
1102 | extern qsize_t ext4_get_reserved_space(struct inode *inode); | ||
1101 | 1103 | ||
1102 | /* ioctl.c */ | 1104 | /* ioctl.c */ |
1103 | extern long ext4_ioctl(struct file *, unsigned int, unsigned long); | 1105 | extern 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 | ||
958 | fail_free_drop: | 958 | fail_free_drop: |
959 | DQUOT_FREE_INODE(inode); | 959 | vfs_dq_free_inode(inode); |
960 | 960 | ||
961 | fail_drop: | 961 | fail_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 | ||
978 | qsize_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, | |||
1553 | static int ext4_da_reserve_space(struct inode *inode, int nrblocks) | 1570 | static 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 | ||
1634 | static void ext4_da_page_release_reservation(struct page *page, | 1664 | static 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: | |||
4654 | out2: | 4662 | out2: |
4655 | kmem_cache_free(ext4_ac_cachep, ac); | 4663 | kmem_cache_free(ext4_ac_cachep, ac); |
4656 | out1: | 4664 | out1: |
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); |
4659 | out3: | 4667 | out3: |
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 | ||
929 | static int ext4_dquot_initialize(struct inode *inode, int type); | ||
930 | static int ext4_dquot_drop(struct inode *inode); | ||
931 | static int ext4_write_dquot(struct dquot *dquot); | 929 | static int ext4_write_dquot(struct dquot *dquot); |
932 | static int ext4_acquire_dquot(struct dquot *dquot); | 930 | static int ext4_acquire_dquot(struct dquot *dquot); |
933 | static int ext4_release_dquot(struct dquot *dquot); | 931 | static 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 | ||
944 | static struct dquot_operations ext4_quota_operations = { | 942 | static 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 | ||
3383 | static 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 | |||
3399 | static 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 | |||
3421 | static int ext4_write_dquot(struct dquot *dquot) | 3385 | static 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 | ||
862 | cleanup_dquot: | 862 | cleanup_dquot: |
863 | DQUOT_FREE_BLOCK(inode, 1); | 863 | vfs_dq_free_block(inode, 1); |
864 | goto cleanup; | 864 | goto cleanup; |
865 | 865 | ||
866 | bad_block: | 866 | bad_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 | ||
164 | fail_drop: | 164 | fail_drop: |
165 | DQUOT_DROP(inode); | 165 | vfs_dq_drop(inode); |
166 | inode->i_flags |= S_NOQUOTA; | 166 | inode->i_flags |= S_NOQUOTA; |
167 | fail_unlock: | 167 | fail_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); |
@@ -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 | |||
5 | config 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 | |||
18 | config 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 | |||
26 | config 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. | ||
37 | config QUOTA_TREE | ||
38 | tristate | ||
39 | |||
40 | config 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 | |||
48 | config 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 | |||
56 | config 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 | |||
8 | obj-y := | ||
9 | |||
10 | obj-$(CONFIG_QUOTA) += dquot.o | ||
11 | obj-$(CONFIG_QFMT_V1) += quota_v1.o | ||
12 | obj-$(CONFIG_QFMT_V2) += quota_v2.o | ||
13 | obj-$(CONFIG_QUOTA_TREE) += quota_tree.o | ||
14 | obj-$(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 | ||
132 | static DEFINE_SPINLOCK(dq_list_lock); | 132 | static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); |
133 | static DEFINE_SPINLOCK(dq_state_lock); | 133 | static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); |
134 | DEFINE_SPINLOCK(dq_data_lock); | 134 | __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); |
135 | EXPORT_SYMBOL(dq_data_lock); | ||
135 | 136 | ||
136 | static char *quotatypes[] = INITQFNAMES; | 137 | static char *quotatypes[] = INITQFNAMES; |
137 | static struct quota_format_type *quota_formats; /* List of registered formats */ | 138 | static 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 | } |
152 | EXPORT_SYMBOL(register_quota_format); | ||
151 | 153 | ||
152 | void unregister_quota_format(struct quota_format_type *fmt) | 154 | void 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 = "a_formats; *actqf && *actqf != fmt; actqf = &(*actqf)->qf_next); | 159 | for (actqf = "a_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 | } |
166 | EXPORT_SYMBOL(unregister_quota_format); | ||
162 | 167 | ||
163 | static struct quota_format_type *find_quota_format(int id) | 168 | static 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; | |||
215 | static struct hlist_head *dquot_hash; | 227 | static struct hlist_head *dquot_hash; |
216 | 228 | ||
217 | struct dqstats dqstats; | 229 | struct dqstats dqstats; |
230 | EXPORT_SYMBOL(dqstats); | ||
218 | 231 | ||
219 | static inline unsigned int | 232 | static inline unsigned int |
220 | hashfn(const struct super_block *sb, unsigned int id, int type) | 233 | hashfn(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 | */ |
231 | static inline void insert_dquot_hash(struct dquot *dquot) | 244 | static 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 | ||
242 | static inline struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, unsigned int id, int type) | 256 | static 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 | } |
328 | EXPORT_SYMBOL(dquot_mark_dquot_dirty); | ||
312 | 329 | ||
313 | /* This function needs dq_list_lock */ | 330 | /* This function needs dq_list_lock */ |
314 | static inline int clear_dquot_dirty(struct dquot *dquot) | 331 | static 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 | } |
382 | EXPORT_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 | } |
414 | EXPORT_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 | } |
445 | EXPORT_SYMBOL(dquot_release); | ||
420 | 446 | ||
421 | void dquot_destroy(struct dquot *dquot) | 447 | void 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 | } |
545 | EXPORT_SYMBOL(dquot_scan_active); | ||
519 | 546 | ||
520 | int vfs_quota_sync(struct super_block *sb, int type) | 547 | int 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 | } |
594 | EXPORT_SYMBOL(vfs_quota_sync); | ||
566 | 595 | ||
567 | /* Free unused dquots from cache */ | 596 | /* Free unused dquots from cache */ |
568 | static void prune_dqcache(int count) | 597 | static 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 | } |
704 | EXPORT_SYMBOL(dqput); | ||
675 | 705 | ||
676 | struct dquot *dquot_alloc(struct super_block *sb, int type) | 706 | struct 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) | |||
711 | struct dquot *dqget(struct super_block *sb, unsigned int id, int type) | 741 | struct 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; |
718 | we_slept: | 748 | we_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 | } |
803 | EXPORT_SYMBOL(dqget); | ||
770 | 804 | ||
771 | static int dqinit_needed(struct inode *inode, int type) | 805 | static 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 | */ | ||
817 | static inline int dqput_blocks(struct dquot *dquot) | 854 | static 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 | */ | ||
826 | static int remove_inode_dquot_ref(struct inode *inode, int type, | 866 | static 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 | */ | ||
851 | static void put_dquot_list(struct list_head *tofree_head) | 896 | static 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 | ||
902 | static inline void dquot_decr_inodes(struct dquot *dquot, qsize_t number) | 947 | static 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 | */ | ||
955 | static 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 | |||
963 | static inline | ||
964 | void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) | ||
965 | { | ||
966 | dquot->dq_dqb.dqb_rsvspace -= number; | ||
967 | } | ||
968 | |||
969 | static 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 | ||
914 | static inline void dquot_decr_space(struct dquot *dquot, qsize_t number) | 981 | static 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 |
939 | static int flag_print_warnings = 1; | 1006 | static int flag_print_warnings = 1; |
940 | 1007 | ||
941 | static inline int need_print_warning(struct dquot *dquot) | 1008 | static 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 | /* | |
1069 | static 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 | */ | ||
1140 | static 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 | ||
1085 | static inline char ignore_hardlimit(struct dquot *dquot) | 1156 | static 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 */ |
1094 | static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype) | 1166 | static 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 */ |
1127 | static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype) | 1203 | static 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 | ||
1169 | static int info_idq_free(struct dquot *dquot, qsize_t inodes) | 1253 | static 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 | } |
1244 | out_err: | 1331 | out_err: |
@@ -1248,6 +1335,7 @@ out_err: | |||
1248 | dqput(got[cnt]); | 1335 | dqput(got[cnt]); |
1249 | return ret; | 1336 | return ret; |
1250 | } | 1337 | } |
1338 | EXPORT_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 | } |
1359 | EXPORT_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 */ |
1273 | void vfs_dq_drop(struct inode *inode) | 1362 | void 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 | } |
1382 | EXPORT_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 | */ |
1306 | int dquot_alloc_space(struct inode *inode, qsize_t number, int warn) | 1396 | int __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)) { | ||
1314 | out_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); |
1340 | warn_put_all: | 1425 | out_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 | |||
1431 | int 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]); | ||
1458 | out_unlock: | ||
1459 | up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); | ||
1460 | out: | ||
1461 | return ret; | ||
1462 | } | ||
1463 | EXPORT_SYMBOL(dquot_alloc_space); | ||
1464 | |||
1465 | int 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); | ||
1477 | out_unlock: | ||
1348 | up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); | 1478 | up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); |
1479 | out: | ||
1349 | return ret; | 1480 | return ret; |
1350 | } | 1481 | } |
1482 | EXPORT_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 | } |
1529 | EXPORT_SYMBOL(dquot_alloc_inode); | ||
1530 | |||
1531 | int 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); | ||
1563 | out: | ||
1564 | return ret; | ||
1565 | } | ||
1566 | EXPORT_SYMBOL(dquot_claim_space); | ||
1567 | |||
1568 | /* | ||
1569 | * Release reserved quota space | ||
1570 | */ | ||
1571 | void 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 | |||
1590 | out_unlock: | ||
1591 | up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); | ||
1592 | out: | ||
1593 | return; | ||
1594 | } | ||
1595 | EXPORT_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 | } |
1636 | EXPORT_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 | } |
1673 | EXPORT_SYMBOL(dquot_free_inode); | ||
1674 | |||
1675 | /* | ||
1676 | * call back function, get reserved quota space from underlying fs | ||
1677 | */ | ||
1678 | qsize_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 | */ |
1479 | int dquot_transfer(struct inode *inode, struct iattr *iattr) | 1694 | int 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 | } |
1570 | warn_put_all: | 1785 | warn_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 | } |
1804 | EXPORT_SYMBOL(dquot_transfer); | ||
1589 | 1805 | ||
1590 | /* Wrapper for transferring ownership of an inode */ | 1806 | /* Wrapper for transferring ownership of an inode */ |
1591 | int vfs_dq_transfer(struct inode *inode, struct iattr *iattr) | 1807 | int 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 | 1816 | EXPORT_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 | } |
1831 | EXPORT_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 | } |
1986 | EXPORT_SYMBOL(vfs_quota_disable); | ||
1767 | 1987 | ||
1768 | int vfs_quota_off(struct super_block *sb, int type, int remount) | 1988 | int 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 | 1993 | EXPORT_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 | } |
2152 | EXPORT_SYMBOL(vfs_quota_on_path); | ||
1930 | 2153 | ||
1931 | int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name, | 2154 | int 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 | } |
2170 | EXPORT_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: | |||
1990 | load_quota: | 2214 | load_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 | } |
2217 | EXPORT_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 | } |
2247 | EXPORT_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 */ |
2024 | int vfs_dq_quota_on_remount(struct super_block *sb) | 2250 | int 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 | } |
2264 | EXPORT_SYMBOL(vfs_dq_quota_on_remount); | ||
2038 | 2265 | ||
2039 | static inline qsize_t qbtos(qsize_t blocks) | 2266 | static 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 | ||
2067 | int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) | 2294 | int 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 | } |
2307 | EXPORT_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 */ |
2081 | static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di) | 2310 | static 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 | ||
2155 | int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di) | 2387 | int 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 | |||
2167 | out: | 2400 | out: |
2168 | return rc; | 2401 | return rc; |
2169 | } | 2402 | } |
2403 | EXPORT_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 */ |
2172 | int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) | 2406 | int 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 | } |
2425 | EXPORT_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 */ |
2193 | int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) | 2428 | int 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 | } |
2455 | EXPORT_SYMBOL(vfs_set_dqinfo); | ||
2219 | 2456 | ||
2220 | struct quotactl_ops vfs_quotactl_ops = { | 2457 | struct 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("a_genl_family) != 0) | 2604 | if (genl_register_family("a_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 | } |
2373 | module_init(dquot_init); | 2611 | module_init(dquot_init); |
2374 | |||
2375 | EXPORT_SYMBOL(register_quota_format); | ||
2376 | EXPORT_SYMBOL(unregister_quota_format); | ||
2377 | EXPORT_SYMBOL(dqstats); | ||
2378 | EXPORT_SYMBOL(dq_data_lock); | ||
2379 | EXPORT_SYMBOL(vfs_quota_enable); | ||
2380 | EXPORT_SYMBOL(vfs_quota_on); | ||
2381 | EXPORT_SYMBOL(vfs_quota_on_path); | ||
2382 | EXPORT_SYMBOL(vfs_quota_on_mount); | ||
2383 | EXPORT_SYMBOL(vfs_quota_disable); | ||
2384 | EXPORT_SYMBOL(vfs_quota_off); | ||
2385 | EXPORT_SYMBOL(dquot_scan_active); | ||
2386 | EXPORT_SYMBOL(vfs_quota_sync); | ||
2387 | EXPORT_SYMBOL(vfs_get_dqinfo); | ||
2388 | EXPORT_SYMBOL(vfs_set_dqinfo); | ||
2389 | EXPORT_SYMBOL(vfs_get_dqblk); | ||
2390 | EXPORT_SYMBOL(vfs_set_dqblk); | ||
2391 | EXPORT_SYMBOL(dquot_commit); | ||
2392 | EXPORT_SYMBOL(dquot_commit_info); | ||
2393 | EXPORT_SYMBOL(dquot_acquire); | ||
2394 | EXPORT_SYMBOL(dquot_release); | ||
2395 | EXPORT_SYMBOL(dquot_mark_dquot_dirty); | ||
2396 | EXPORT_SYMBOL(dquot_initialize); | ||
2397 | EXPORT_SYMBOL(dquot_drop); | ||
2398 | EXPORT_SYMBOL(vfs_dq_drop); | ||
2399 | EXPORT_SYMBOL(dqget); | ||
2400 | EXPORT_SYMBOL(dqput); | ||
2401 | EXPORT_SYMBOL(dquot_alloc_space); | ||
2402 | EXPORT_SYMBOL(dquot_alloc_inode); | ||
2403 | EXPORT_SYMBOL(dquot_free_space); | ||
2404 | EXPORT_SYMBOL(dquot_free_inode); | ||
2405 | EXPORT_SYMBOL(dquot_transfer); | ||
2406 | EXPORT_SYMBOL(vfs_dq_transfer); | ||
2407 | EXPORT_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 */ |
23 | static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) | 23 | static 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 */ |
95 | static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) | 97 | static 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 | ||
145 | static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) | 148 | static 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); |
201 | restart: | 206 | restart: |
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 */ |
230 | static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void __user *addr) | 236 | static 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 | */ |
344 | static inline struct super_block *quotactl_block(const char __user *special) | 355 | static 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 | ||
25 | typedef char *dqbuf_t; | ||
26 | |||
27 | static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth) | 25 | static 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 */ |
38 | static inline int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info) | 36 | static 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 | ||
44 | static dqbuf_t getdqbuf(size_t size) | 42 | static 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 | ||
52 | static inline void freedqbuf(dqbuf_t buf) | 51 | static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) |
53 | { | ||
54 | kfree(buf); | ||
55 | } | ||
56 | |||
57 | static 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 | ||
66 | static inline ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, dqbuf_t buf) | 60 | static 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 */ |
75 | static int get_free_dqblk(struct qtree_mem_dqinfo *info) | 69 | static 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; |
100 | out_buf: | 94 | out_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 */ |
106 | static int put_free_dqblk(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) | 100 | static 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 */ |
123 | static int remove_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) | 117 | static 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; |
162 | out_buf: | 159 | out_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 */ |
168 | static int insert_free_dqentry(struct qtree_mem_dqinfo *info, dqbuf_t buf, uint blk) | 165 | static 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; |
195 | out_buf: | 193 | out_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; |
278 | out_buf: | 280 | out_buf: |
279 | freedqbuf(buf); | 281 | kfree(buf); |
280 | return 0; | 282 | return 0; |
281 | } | 283 | } |
282 | 284 | ||
@@ -284,7 +286,7 @@ out_buf: | |||
284 | static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, | 286 | static 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 | } |
335 | out_buf: | 337 | out_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 | */ |
351 | int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | 354 | int 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 */ |
446 | out_buf: | 449 | out_buf: |
447 | freedqbuf(buf); | 450 | kfree(buf); |
448 | return ret; | 451 | return ret; |
449 | } | 452 | } |
450 | 453 | ||
@@ -452,7 +455,7 @@ out_buf: | |||
452 | static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, | 455 | static 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 | } |
493 | out_buf: | 495 | out_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); | |||
510 | static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, | 512 | static 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 | } |
537 | out_buf: | 542 | out_buf: |
538 | freedqbuf(buf); | 543 | kfree(buf); |
539 | return ret; | 544 | return ret; |
540 | } | 545 | } |
541 | 546 | ||
@@ -543,7 +548,7 @@ out_buf: | |||
543 | static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info, | 548 | static 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); |
565 | out_buf: | 570 | out_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); |
631 | out: | 636 | out: |
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) */ |
639 | int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | 644 | int 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; | ||
162 | out: | 177 | out: |
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 | ||
436 | void reiserfs_free_block(struct reiserfs_transaction_handle *th, | 436 | void 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 | */ |
556 | static int drop_new_inode(struct inode *inode) | 556 | static 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 | ||
632 | static int reiserfs_dquot_initialize(struct inode *, int); | ||
633 | static int reiserfs_dquot_drop(struct inode *); | ||
634 | static int reiserfs_write_dquot(struct dquot *); | 632 | static int reiserfs_write_dquot(struct dquot *); |
635 | static int reiserfs_acquire_dquot(struct dquot *); | 633 | static int reiserfs_acquire_dquot(struct dquot *); |
636 | static int reiserfs_release_dquot(struct dquot *); | 634 | static int reiserfs_release_dquot(struct dquot *); |
@@ -639,8 +637,8 @@ static int reiserfs_write_info(struct super_block *, int); | |||
639 | static int reiserfs_quota_on(struct super_block *, int, int, char *, int); | 637 | static int reiserfs_quota_on(struct super_block *, int, int, char *, int); |
640 | 638 | ||
641 | static struct dquot_operations reiserfs_quota_operations = { | 639 | static 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 |
1899 | static 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 | |||
1922 | static 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 | |||
1951 | static int reiserfs_write_dquot(struct dquot *dquot) | 1897 | static 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); | |||
266 | void __fsync_super(struct super_block *sb) | 266 | void __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 | ||
@@ -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 | } |