dquot: move dquot initialization responsibility into the filesystem

Currently various places in the VFS call vfs_dq_init directly.  This means
we tie the quota code into the VFS.  Get rid of that and make the
filesystem responsible for the initialization.   For most metadata operations
this is a straight forward move into the methods, but for truncate and
open it's a bit more complicated.

For truncate we currently only call vfs_dq_init for the sys_truncate case
because open already takes care of it for ftruncate and open(O_TRUNC) - the
new code causes an additional vfs_dq_init for those which is harmless.

For open the initialization is moved from do_filp_open into the open method,
which means it happens slightly earlier now, and only for regular files.
The latter is fine because we don't need to initialize it for operations
on special files, and we already do it as part of the namespace operations
for directories.

Add a dquot_file_open helper that filesystems that support generic quotas
can use to fill in ->open.

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

diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index 586e3589d4c2c4f2c4f0de1f1bc4e4fbec0816ed..d11f6e484519ccbfac8937ee0d147dd3dda93e5f 100644 (file)
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -70,7 +70,7 @@ const struct file_operations ext2_file_operations = {
        .compat_ioctl   = ext2_compat_ioctl,
 #endif
        .mmap           = generic_file_mmap,
-       .open           = generic_file_open,
+       .open           = dquot_file_open,
        .release        = ext2_release_file,
        .fsync          = ext2_fsync,
        .splice_read    = generic_file_splice_read,
@@ -87,7 +87,7 @@ const struct file_operations ext2_xip_file_operations = {
        .compat_ioctl   = ext2_compat_ioctl,
 #endif
        .mmap           = xip_file_mmap,
-       .open           = generic_file_open,
+       .open           = dquot_file_open,
        .release        = ext2_release_file,
        .fsync          = ext2_fsync,
 };

diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 3cfcfd9a131acefd31bd9b8aedd5578042fb2422..c87840c33e17f8c0111247ea8aca2b6a33a8796d 100644 (file)
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -58,6 +58,8 @@ static inline int ext2_inode_is_fast_symlink(struct inode *inode)
  */
 void ext2_delete_inode (struct inode * inode)
 {
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
        truncate_inode_pages(&inode->i_data, 0);
 
        if (is_bad_inode(inode))
@@ -1457,6 +1459,9 @@ int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
        error = inode_change_ok(inode, iattr);
        if (error)
                return error;
+
+       if (iattr->ia_valid & ATTR_SIZE)
+               vfs_dq_init(inode);
        if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
            (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
                error = dquot_transfer(inode, iattr);

diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index dd7175ce56068b18acecc048e88635ca26ef9909..5923df7b22affaa3b89a1cae3fc99a5593bfb579 100644 (file)
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -31,6 +31,7 @@
  */
 
 #include <linux/pagemap.h>
+#include <linux/quotaops.h>
 #include "ext2.h"
 #include "xattr.h"
 #include "acl.h"
@@ -99,24 +100,27 @@ struct dentry *ext2_get_parent(struct dentry *child)
  */
 static int ext2_create (struct inode * dir, struct dentry * dentry, int mode, struct nameidata *nd)
 {
-       struct inode * inode = ext2_new_inode (dir, mode);
-       int err = PTR_ERR(inode);
-       if (!IS_ERR(inode)) {
-               inode->i_op = &ext2_file_inode_operations;
-               if (ext2_use_xip(inode->i_sb)) {
-                       inode->i_mapping->a_ops = &ext2_aops_xip;
-                       inode->i_fop = &ext2_xip_file_operations;
-               } else if (test_opt(inode->i_sb, NOBH)) {
-                       inode->i_mapping->a_ops = &ext2_nobh_aops;
-                       inode->i_fop = &ext2_file_operations;
-               } else {
-                       inode->i_mapping->a_ops = &ext2_aops;
-                       inode->i_fop = &ext2_file_operations;
-               }
-               mark_inode_dirty(inode);
-               err = ext2_add_nondir(dentry, inode);
+       struct inode *inode;
+
+       vfs_dq_init(dir);
+
+       inode = ext2_new_inode(dir, mode);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       inode->i_op = &ext2_file_inode_operations;
+       if (ext2_use_xip(inode->i_sb)) {
+               inode->i_mapping->a_ops = &ext2_aops_xip;
+               inode->i_fop = &ext2_xip_file_operations;
+       } else if (test_opt(inode->i_sb, NOBH)) {
+               inode->i_mapping->a_ops = &ext2_nobh_aops;
+               inode->i_fop = &ext2_file_operations;
+       } else {
+               inode->i_mapping->a_ops = &ext2_aops;
+               inode->i_fop = &ext2_file_operations;
        }
-       return err;
+       mark_inode_dirty(inode);
+       return ext2_add_nondir(dentry, inode);
 }
 
 static int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
@@ -127,6 +131,8 @@ static int ext2_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_
        if (!new_valid_dev(rdev))
                return -EINVAL;
 
+       vfs_dq_init(dir);
+
        inode = ext2_new_inode (dir, mode);
        err = PTR_ERR(inode);
        if (!IS_ERR(inode)) {
@@ -151,6 +157,8 @@ static int ext2_symlink (struct inode * dir, struct dentry * dentry,
        if (l > sb->s_blocksize)
                goto out;
 
+       vfs_dq_init(dir);
+
        inode = ext2_new_inode (dir, S_IFLNK | S_IRWXUGO);
        err = PTR_ERR(inode);
        if (IS_ERR(inode))
@@ -194,6 +202,8 @@ static int ext2_link (struct dentry * old_dentry, struct inode * dir,
        if (inode->i_nlink >= EXT2_LINK_MAX)
                return -EMLINK;
 
+       vfs_dq_init(dir);
+
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
        atomic_inc(&inode->i_count);
@@ -216,6 +226,8 @@ static int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
        if (dir->i_nlink >= EXT2_LINK_MAX)
                goto out;
 
+       vfs_dq_init(dir);
+
        inode_inc_link_count(dir);
 
        inode = ext2_new_inode (dir, S_IFDIR | mode);
@@ -262,6 +274,8 @@ static int ext2_unlink(struct inode * dir, struct dentry *dentry)
        struct page * page;
        int err = -ENOENT;
 
+       vfs_dq_init(dir);
+
        de = ext2_find_entry (dir, &dentry->d_name, &page);
        if (!de)
                goto out;
@@ -304,6 +318,9 @@ static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
        struct ext2_dir_entry_2 * old_de;
        int err = -ENOENT;
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_de = ext2_find_entry (old_dir, &old_dentry->d_name, &old_page);
        if (!old_de)
                goto out;

diff --git a/fs/ext3/file.c b/fs/ext3/file.c
index a86d3302cdc2f6f70c56c484151c4f3557db1ed1..3c7fb11a3b2905681b3a440b270090fc2b8b3dc3 100644 (file)
--- a/fs/ext3/file.c
+++ b/fs/ext3/file.c
@@ -62,7 +62,7 @@ const struct file_operations ext3_file_operations = {
        .compat_ioctl   = ext3_compat_ioctl,
 #endif
        .mmap           = generic_file_mmap,
-       .open           = generic_file_open,
+       .open           = dquot_file_open,
        .release        = ext3_release_file,
        .fsync          = ext3_sync_file,
        .splice_read    = generic_file_splice_read,

diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 14d40a4dd6f037d40a8ccec4412dc3ddd03a5652..d7962b0c57b3f0cd208c94acbbfdae7cb6bf4aa1 100644 (file)
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -196,6 +196,9 @@ void ext3_delete_inode (struct inode * inode)
 {
        handle_t *handle;
 
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        truncate_inode_pages(&inode->i_data, 0);
 
        if (is_bad_inode(inode))
@@ -3148,6 +3151,8 @@ int ext3_setattr(struct dentry *dentry, struct iattr *attr)
        if (error)
                return error;
 
+       if (ia_valid & ATTR_SIZE)
+               vfs_dq_init(inode);
        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
                handle_t *handle;

diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 7b0e44f7d66fb839c7c8002fb6e3928b5e3e04a8..a492b371b134b4c21986bf1f91aec1ea3e1961d8 100644 (file)
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1696,6 +1696,8 @@ static int ext3_create (struct inode * dir, struct dentry * dentry, int mode,
        struct inode * inode;
        int err, retries = 0;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -1730,6 +1732,8 @@ static int ext3_mknod (struct inode * dir, struct dentry *dentry,
        if (!new_valid_dev(rdev))
                return -EINVAL;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -1766,6 +1770,8 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
        if (dir->i_nlink >= EXT3_LINK_MAX)
                return -EMLINK;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT3_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -2060,7 +2066,9 @@ static int ext3_rmdir (struct inode * dir, struct dentry *dentry)
 
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */
+       vfs_dq_init(dir);
        vfs_dq_init(dentry->d_inode);
+
        handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -2119,7 +2127,9 @@ static int ext3_unlink(struct inode * dir, struct dentry *dentry)
 
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
+       vfs_dq_init(dir);
        vfs_dq_init(dentry->d_inode);
+
        handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -2174,6 +2184,8 @@ static int ext3_symlink (struct inode * dir,
        if (l > dir->i_sb->s_blocksize)
                return -ENAMETOOLONG;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT3_INDEX_EXTRA_TRANS_BLOCKS + 5 +
@@ -2228,6 +2240,9 @@ static int ext3_link (struct dentry * old_dentry,
 
        if (inode->i_nlink >= EXT3_LINK_MAX)
                return -EMLINK;
+
+       vfs_dq_init(dir);
+
        /*
         * Return -ENOENT if we've raced with unlink and i_nlink is 0.  Doing
         * otherwise has the potential to corrupt the orphan inode list.
@@ -2278,6 +2293,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
        struct ext3_dir_entry_2 * old_de, * new_de;
        int retval, flush_file = 0;
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_bh = new_bh = dir_bh = NULL;
 
        /* Initialize quotas before so that eventual writes go

diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 9630583cef280d541e87505eba2cfa37589266e3..85fa464a24ad29062ebf2a0ad27548af1e2ddbcc 100644 (file)
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -127,7 +127,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                        sb->s_dirt = 1;
                }
        }
-       return generic_file_open(inode, filp);
+       return dquot_file_open(inode, filp);
 }
 
 const struct file_operations ext4_file_operations = {

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 6a002a6d062436f1a4abb3c38cb935fe4e13e12e..eaa22ae9f1f632ee7b010dc6ab51ad8d782a4134 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -170,6 +170,9 @@ void ext4_delete_inode(struct inode *inode)
        handle_t *handle;
        int err;
 
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        if (ext4_should_order_data(inode))
                ext4_begin_ordered_truncate(inode, 0);
        truncate_inode_pages(&inode->i_data, 0);
@@ -5251,6 +5254,8 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr)
        if (error)
                return error;
 
+       if (ia_valid & ATTR_SIZE)
+               vfs_dq_init(inode);
        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
                (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
                handle_t *handle;

diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 17a17e10dd605198ddfe2dfed530d4cfff6812c1..20f55c2e7571bb7f7b59306459cda691763259b8 100644 (file)
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1766,6 +1766,8 @@ static int ext4_create(struct inode *dir, struct dentry *dentry, int mode,
        struct inode *inode;
        int err, retries = 0;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -1800,6 +1802,8 @@ static int ext4_mknod(struct inode *dir, struct dentry *dentry,
        if (!new_valid_dev(rdev))
                return -EINVAL;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -1837,6 +1841,8 @@ static int ext4_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        if (EXT4_DIR_LINK_MAX(dir))
                return -EMLINK;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3 +
@@ -2136,7 +2142,9 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
 
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */
+       vfs_dq_init(dir);
        vfs_dq_init(dentry->d_inode);
+
        handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -2195,7 +2203,9 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry)
 
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */
+       vfs_dq_init(dir);
        vfs_dq_init(dentry->d_inode);
+
        handle = ext4_journal_start(dir, EXT4_DELETE_TRANS_BLOCKS(dir->i_sb));
        if (IS_ERR(handle))
                return PTR_ERR(handle);
@@ -2250,6 +2260,8 @@ static int ext4_symlink(struct inode *dir,
        if (l > dir->i_sb->s_blocksize)
                return -ENAMETOOLONG;
 
+       vfs_dq_init(dir);
+
 retry:
        handle = ext4_journal_start(dir, EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
                                        EXT4_INDEX_EXTRA_TRANS_BLOCKS + 5 +
@@ -2308,6 +2320,8 @@ static int ext4_link(struct dentry *old_dentry,
        if (inode->i_nlink >= EXT4_LINK_MAX)
                return -EMLINK;
 
+       vfs_dq_init(dir);
+
        /*
         * Return -ENOENT if we've raced with unlink and i_nlink is 0.  Doing
         * otherwise has the potential to corrupt the orphan inode list.
@@ -2358,6 +2372,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct ext4_dir_entry_2 *old_de, *new_de;
        int retval, force_da_alloc = 0;
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_bh = new_bh = dir_bh = NULL;
 
        /* Initialize quotas before so that eventual writes go

diff --git a/fs/inode.c b/fs/inode.c
index f1aef3482b0e4a2a884163d62c84606a14c945d6..407bf392e20a67e9494537258ffe2ad73b92a8cb 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -8,7 +8,6 @@
 #include <linux/mm.h>
 #include <linux/dcache.h>
 #include <linux/init.h>
-#include <linux/quotaops.h>
 #include <linux/slab.h>
 #include <linux/writeback.h>
 #include <linux/module.h>
@@ -1210,8 +1209,6 @@ void generic_delete_inode(struct inode *inode)
 
        if (op->delete_inode) {
                void (*delete)(struct inode *) = op->delete_inode;
-               if (!is_bad_inode(inode))
-                       vfs_dq_init(inode);
                /* Filesystems implementing their own
                 * s_op->delete_inode are required to call
                 * truncate_inode_pages and clear_inode()

diff --git a/fs/jfs/file.c b/fs/jfs/file.c
index 2c201783836f0fe9ff2eb2c711ada8e1b5a635ff..f19bb33eb1eba5a7c74db03814dbdec2ba5529cc 100644 (file)
--- a/fs/jfs/file.c
+++ b/fs/jfs/file.c
@@ -48,7 +48,7 @@ static int jfs_open(struct inode *inode, struct file *file)
 {
        int rc;
 
-       if ((rc = generic_file_open(inode, file)))
+       if ((rc = dquot_file_open(inode, file)))
                return rc;
 
        /*
@@ -98,6 +98,8 @@ int jfs_setattr(struct dentry *dentry, struct iattr *iattr)
        if (rc)
                return rc;
 
+       if (iattr->ia_valid & ATTR_SIZE)
+               vfs_dq_init(inode);
        if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
            (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
                rc = dquot_transfer(inode, iattr);

diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 22fa412c52898306e1b72ba634b2daba617c177f..1aa2dda165900435240fc47c4480cc66c55b9661 100644 (file)
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -146,6 +146,9 @@ void jfs_delete_inode(struct inode *inode)
 {
        jfs_info("In jfs_delete_inode, inode = 0x%p", inode);
 
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        if (!is_bad_inode(inode) &&
            (JFS_IP(inode)->fileset == FILESYSTEM_I)) {
                truncate_inode_pages(&inode->i_data, 0);

diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 1d1390afe55ef946da1e72473ffe753eb6215132..b7cc29da50b49646b11f225bb188d5b702687fb6 100644 (file)
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -85,6 +85,8 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, int mode,
 
        jfs_info("jfs_create: dip:0x%p name:%s", dip, dentry->d_name.name);
 
+       vfs_dq_init(dip);
+
        /*
         * search parent directory for entry/freespace
         * (dtSearch() returns parent directory page pinned)
@@ -215,6 +217,8 @@ static int jfs_mkdir(struct inode *dip, struct dentry *dentry, int mode)
 
        jfs_info("jfs_mkdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 
+       vfs_dq_init(dip);
+
        /* link count overflow on parent directory ? */
        if (dip->i_nlink == JFS_LINK_MAX) {
                rc = -EMLINK;
@@ -356,6 +360,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
        jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 
        /* Init inode for quota operations. */
+       vfs_dq_init(dip);
        vfs_dq_init(ip);
 
        /* directory must be empty to be removed */
@@ -483,6 +488,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
        jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
 
        /* Init inode for quota operations. */
+       vfs_dq_init(dip);
        vfs_dq_init(ip);
 
        if ((rc = get_UCSname(&dname, dentry)))
@@ -805,6 +811,8 @@ static int jfs_link(struct dentry *old_dentry,
        if (ip->i_nlink == 0)
                return -ENOENT;
 
+       vfs_dq_init(dir);
+
        tid = txBegin(ip->i_sb, 0);
 
        mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
@@ -896,6 +904,8 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
 
        jfs_info("jfs_symlink: dip:0x%p name:%s", dip, name);
 
+       vfs_dq_init(dip);
+
        ssize = strlen(name) + 1;
 
        /*
@@ -1087,6 +1097,9 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        jfs_info("jfs_rename: %s %s", old_dentry->d_name.name,
                 new_dentry->d_name.name);
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_ip = old_dentry->d_inode;
        new_ip = new_dentry->d_inode;
 
@@ -1360,6 +1373,8 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
 
        jfs_info("jfs_mknod: %s", dentry->d_name.name);
 
+       vfs_dq_init(dir);
+
        if ((rc = get_UCSname(&dname, dentry)))
                goto out;
 

diff --git a/fs/namei.c b/fs/namei.c
index a4855af776a8b6670b753aa3af71203519de94a7..06abd2bf473c79a560de606786a5f052dec30a95 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -19,7 +19,6 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/namei.h>
-#include <linux/quotaops.h>
 #include <linux/pagemap.h>
 #include <linux/fsnotify.h>
 #include <linux/personality.h>
@@ -1461,7 +1460,6 @@ int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
        error = security_inode_create(dir, dentry, mode);
        if (error)
                return error;
-       vfs_dq_init(dir);
        error = dir->i_op->create(dir, dentry, mode, nd);
        if (!error)
                fsnotify_create(dir, dentry);
@@ -1813,9 +1811,6 @@ ok:
                }
        }
        if (!IS_ERR(filp)) {
-               if (acc_mode & MAY_WRITE)
-                       vfs_dq_init(nd.path.dentry->d_inode);
-
                if (will_truncate) {
                        error = handle_truncate(&nd.path);
                        if (error) {
@@ -1996,7 +1991,6 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
        if (error)
                return error;
 
-       vfs_dq_init(dir);
        error = dir->i_op->mknod(dir, dentry, mode, dev);
        if (!error)
                fsnotify_create(dir, dentry);
@@ -2095,7 +2089,6 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        if (error)
                return error;
 
-       vfs_dq_init(dir);
        error = dir->i_op->mkdir(dir, dentry, mode);
        if (!error)
                fsnotify_mkdir(dir, dentry);
@@ -2181,8 +2174,6 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry)
        if (!dir->i_op->rmdir)
                return -EPERM;
 
-       vfs_dq_init(dir);
-
        mutex_lock(&dentry->d_inode->i_mutex);
        dentry_unhash(dentry);
        if (d_mountpoint(dentry))
@@ -2268,8 +2259,6 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry)
        if (!dir->i_op->unlink)
                return -EPERM;
 
-       vfs_dq_init(dir);
-
        mutex_lock(&dentry->d_inode->i_mutex);
        if (d_mountpoint(dentry))
                error = -EBUSY;
@@ -2379,7 +2368,6 @@ int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
        if (error)
                return error;
 
-       vfs_dq_init(dir);
        error = dir->i_op->symlink(dir, dentry, oldname);
        if (!error)
                fsnotify_create(dir, dentry);
@@ -2463,7 +2451,6 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
                return error;
 
        mutex_lock(&inode->i_mutex);
-       vfs_dq_init(dir);
        error = dir->i_op->link(old_dentry, dir, new_dentry);
        mutex_unlock(&inode->i_mutex);
        if (!error)
@@ -2662,9 +2649,6 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (!old_dir->i_op->rename)
                return -EPERM;
 
-       vfs_dq_init(old_dir);
-       vfs_dq_init(new_dir);
-
        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
 
        if (is_dir)

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 8715d194561aa626bff1d18991a2ac667be00715..09e9fc04360064ba6b2648f58f0e8aeef683e89a 100644 (file)
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -20,7 +20,6 @@
 #include <linux/fcntl.h>
 #include <linux/namei.h>
 #include <linux/delay.h>
-#include <linux/quotaops.h>
 #include <linux/fsnotify.h>
 #include <linux/posix_acl_xattr.h>
 #include <linux/xattr.h>
@@ -377,7 +376,6 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
                        put_write_access(inode);
                        goto out_nfserr;
                }
-               vfs_dq_init(inode);
        }
 
        /* sanitize the mode change */
@@ -745,8 +743,6 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
                        flags = O_RDWR|O_LARGEFILE;
                else
                        flags = O_WRONLY|O_LARGEFILE;
-
-               vfs_dq_init(inode);
        }
        *filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt),
                            flags, current_cred());

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 472e8f8bc8925ebb51dfdf44ab9bf91ab4ffc4a7..126198f5a67c0d5e581574cb16a3ff20fd92c4f2 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -107,6 +107,9 @@ static int ocfs2_file_open(struct inode *inode, struct file *file)
        mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
                   file->f_path.dentry->d_name.len, file->f_path.dentry->d_name.name);
 
+       if (file->f_mode & FMODE_WRITE)
+               vfs_dq_init(inode);
+
        spin_lock(&oi->ip_lock);
 
        /* Check that the inode hasn't been wiped from disk by another
@@ -977,6 +980,8 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 
        size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
        if (size_change) {
+               vfs_dq_init(inode);
+
                status = ocfs2_rw_lock(inode, 1);
                if (status < 0) {
                        mlog_errno(status);

diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index 00eb6a095e686f126294a6c7713287038f4e0a64..77681a690d16d1c6acd8a1c054a86dc601d50c96 100644 (file)
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -971,6 +971,8 @@ void ocfs2_delete_inode(struct inode *inode)
                goto bail;
        }
 
+       vfs_dq_init(inode);
+
        if (!ocfs2_inode_is_valid_to_delete(inode)) {
                /* It's probably not necessary to truncate_inode_pages
                 * here but we do it for safety anyway (it will most

diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 99766b6418eb19e9d8a4f65dc03d9d371735980c..8b5b142eb638e564a1e7b349a1352f236d010cdf 100644 (file)
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -244,6 +244,8 @@ static int ocfs2_mknod(struct inode *dir,
                   (unsigned long)dev, dentry->d_name.len,
                   dentry->d_name.name);
 
+       vfs_dq_init(dir);
+
        /* get our super block */
        osb = OCFS2_SB(dir->i_sb);
 
@@ -632,6 +634,8 @@ static int ocfs2_link(struct dentry *old_dentry,
        if (S_ISDIR(inode->i_mode))
                return -EPERM;
 
+       vfs_dq_init(dir);
+
        err = ocfs2_inode_lock_nested(dir, &parent_fe_bh, 1, OI_LS_PARENT);
        if (err < 0) {
                if (err != -ENOENT)
@@ -787,6 +791,8 @@ static int ocfs2_unlink(struct inode *dir,
        mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
                   dentry->d_name.len, dentry->d_name.name);
 
+       vfs_dq_init(dir);
+
        BUG_ON(dentry->d_parent->d_inode != dir);
 
        mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
@@ -1047,6 +1053,9 @@ static int ocfs2_rename(struct inode *old_dir,
                   old_dentry->d_name.len, old_dentry->d_name.name,
                   new_dentry->d_name.len, new_dentry->d_name.name);
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        osb = OCFS2_SB(old_dir->i_sb);
 
        if (new_inode) {
@@ -1595,6 +1604,8 @@ static int ocfs2_symlink(struct inode *dir,
        mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
                   dentry, symname, dentry->d_name.len, dentry->d_name.name);
 
+       vfs_dq_init(dir);
+
        sb = dir->i_sb;
        osb = OCFS2_SB(sb);
 

diff --git a/fs/open.c b/fs/open.c
index 040cef72bc00e46a0c58790f1c18cef7722756c8..b740c4244833f8f3db70b47811799dc8d84c4e40 100644 (file)
--- a/fs/open.c
+++ b/fs/open.c
@@ -8,7 +8,6 @@
 #include <linux/mm.h>
 #include <linux/file.h>
 #include <linux/fdtable.h>
-#include <linux/quotaops.h>
 #include <linux/fsnotify.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -278,10 +277,8 @@ static long do_sys_truncate(const char __user *pathname, loff_t length)
        error = locks_verify_truncate(inode, NULL, length);
        if (!error)
                error = security_path_truncate(&path, length, 0);
-       if (!error) {
-               vfs_dq_init(inode);
+       if (!error)
                error = do_truncate(path.dentry, length, 0, NULL);
-       }
 
 put_write_and_out:
        put_write_access(inode);

diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index cd83c5b871bab94dea6a41ccd93fda8e3ad1c24d..6244bca45c9d74ae5ac6b93c4a64fab6fc22862f 100644 (file)
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -1820,6 +1820,20 @@ const struct dquot_operations dquot_operations = {
        .destroy_dquot  = dquot_destroy,
 };
 
+/*
+ * Generic helper for ->open on filesystems supporting disk quotas.
+ */
+int dquot_file_open(struct inode *inode, struct file *file)
+{
+       int error;
+
+       error = generic_file_open(inode, file);
+       if (!error && (file->f_mode & FMODE_WRITE))
+               vfs_dq_init(inode);
+       return error;
+}
+EXPORT_SYMBOL(dquot_file_open);
+
 /*
  * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
  */

diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index da2dba082e2d4e6ba5191bf938d134ca647d3877..1d9c12714c5cd4a69384519d4a183447b956d27d 100644 (file)
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -289,7 +289,7 @@ const struct file_operations reiserfs_file_operations = {
        .compat_ioctl = reiserfs_compat_ioctl,
 #endif
        .mmap = reiserfs_file_mmap,
-       .open = generic_file_open,
+       .open = dquot_file_open,
        .release = reiserfs_file_release,
        .fsync = reiserfs_sync_file,
        .aio_read = generic_file_aio_read,

diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index f07c3b69247d88a3032520e214ebd6b44a0322c8..06995cb48e3999ce649cac19e258bb455f352aa7 100644 (file)
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -34,6 +34,9 @@ void reiserfs_delete_inode(struct inode *inode)
        int depth;
        int err;
 
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        truncate_inode_pages(&inode->i_data, 0);
 
        depth = reiserfs_write_lock_once(inode->i_sb);
@@ -3073,6 +3076,8 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
 
        depth = reiserfs_write_lock_once(inode->i_sb);
        if (attr->ia_valid & ATTR_SIZE) {
+               vfs_dq_init(inode);
+
                /* version 2 items will be caught by the s_maxbytes check
                 ** done for us in vmtruncate
                 */

diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index 9dea84e8a79a73442188120fbcafb9fa669ef9b1..c55e1b9fee5f4df1a4bbfdf967773a1ce471d552 100644 (file)
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -594,6 +594,8 @@ static int reiserfs_create(struct inode *dir, struct dentry *dentry, int mode,
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;
 
+       vfs_dq_init(dir);
+
        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
@@ -666,6 +668,8 @@ static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
        if (!new_valid_dev(rdev))
                return -EINVAL;
 
+       vfs_dq_init(dir);
+
        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
@@ -739,6 +743,8 @@ static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
            2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
 
+       vfs_dq_init(dir);
+
 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
        /* set flag that new packing locality created and new blocks for the content     * of that directory are not displaced yet */
        REISERFS_I(dir)->new_packing_locality = 1;
@@ -842,6 +848,8 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
            JOURNAL_PER_BALANCE_CNT * 2 + 2 +
            4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
 
+       vfs_dq_init(dir);
+
        reiserfs_write_lock(dir->i_sb);
        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval)
@@ -923,6 +931,8 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
        unsigned long savelink;
        int depth;
 
+       vfs_dq_init(dir);
+
        inode = dentry->d_inode;
 
        /* in this transaction we can be doing at max two balancings and update
@@ -1024,6 +1034,8 @@ static int reiserfs_symlink(struct inode *parent_dir,
            2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
 
+       vfs_dq_init(parent_dir);
+
        if (!(inode = new_inode(parent_dir->i_sb))) {
                return -ENOMEM;
        }
@@ -1111,6 +1123,8 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
            JOURNAL_PER_BALANCE_CNT * 3 +
            2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
 
+       vfs_dq_init(dir);
+
        reiserfs_write_lock(dir->i_sb);
        if (inode->i_nlink >= REISERFS_LINK_MAX) {
                //FIXME: sd_nlink is 32 bit for new files
@@ -1235,6 +1249,9 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
            JOURNAL_PER_BALANCE_CNT * 3 + 5 +
            4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_inode = old_dentry->d_inode;
        new_dentry_inode = new_dentry->d_inode;
 

diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 81f09fab8ae476ccbdb9547d226e397e1b8cb6d1..37d034ca7d994a8c84496dde7d9d88c54a3f441b 100644 (file)
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -61,7 +61,6 @@
 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
 {
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
-       vfs_dq_init(dir);
        return dir->i_op->create(dir, dentry, mode, NULL);
 }
 #endif
@@ -69,7 +68,6 @@ static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
-       vfs_dq_init(dir);
        return dir->i_op->mkdir(dir, dentry, mode);
 }
 
@@ -81,7 +79,6 @@ static int xattr_unlink(struct inode *dir, struct dentry *dentry)
 {
        int error;
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
-       vfs_dq_init(dir);
 
        reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
                                        I_MUTEX_CHILD, dir->i_sb);
@@ -97,7 +94,6 @@ static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
 {
        int error;
        BUG_ON(!mutex_is_locked(&dir->i_mutex));
-       vfs_dq_init(dir);
 
        reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
                                        I_MUTEX_CHILD, dir->i_sb);

diff --git a/fs/udf/file.c b/fs/udf/file.c
index 2df7fcb677b39c62805651597d69d86f084df017..013fa44d9a5eb5d817eff435fedfc79194681ed4 100644 (file)
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -208,7 +208,7 @@ const struct file_operations udf_file_operations = {
        .read                   = do_sync_read,
        .aio_read               = generic_file_aio_read,
        .ioctl                  = udf_ioctl,
-       .open                   = generic_file_open,
+       .open                   = dquot_file_open,
        .mmap                   = generic_file_mmap,
        .write                  = do_sync_write,
        .aio_write              = udf_file_aio_write,
@@ -227,6 +227,9 @@ static int udf_setattr(struct dentry *dentry, struct iattr *iattr)
        if (error)
                return error;
 
+       if (iattr->ia_valid & ATTR_SIZE)
+               vfs_dq_init(inode);
+
        if ((iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) ||
             (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)) {
                error = dquot_transfer(inode, iattr);

diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 1199e8e21ee21ef83d7d6cf8d556f7bc8e0c9e92..f1952026840431616350c32bab1fe96d10b2ec55 100644 (file)
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -36,6 +36,7 @@
 #include <linux/pagemap.h>
 #include <linux/buffer_head.h>
 #include <linux/writeback.h>
+#include <linux/quotaops.h>
 #include <linux/slab.h>
 #include <linux/crc-itu-t.h>
 
@@ -70,6 +71,9 @@ static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
 
 void udf_delete_inode(struct inode *inode)
 {
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        truncate_inode_pages(&inode->i_data, 0);
 
        if (is_bad_inode(inode))

diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index cd2115060fdcc728aeefc7a21e80f6fc6af9c28c..e360c3fc4ae4ca68b1f27d4acc884769cd9e5cd8 100644 (file)
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -563,6 +563,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
        int err;
        struct udf_inode_info *iinfo;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        inode = udf_new_inode(dir, mode, &err);
        if (!inode) {
@@ -616,6 +618,8 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
        if (!old_valid_dev(rdev))
                return -EINVAL;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        err = -EIO;
        inode = udf_new_inode(dir, mode, &err);
@@ -662,6 +666,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        struct udf_inode_info *dinfo = UDF_I(dir);
        struct udf_inode_info *iinfo;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        err = -EMLINK;
        if (dir->i_nlink >= (256 << sizeof(dir->i_nlink)) - 1)
@@ -799,6 +805,8 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
        struct fileIdentDesc *fi, cfi;
        struct kernel_lb_addr tloc;
 
+       vfs_dq_init(dir);
+
        retval = -ENOENT;
        lock_kernel();
        fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
@@ -845,6 +853,8 @@ static int udf_unlink(struct inode *dir, struct dentry *dentry)
        struct fileIdentDesc cfi;
        struct kernel_lb_addr tloc;
 
+       vfs_dq_init(dir);
+
        retval = -ENOENT;
        lock_kernel();
        fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);
@@ -899,6 +909,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
        struct buffer_head *bh;
        struct udf_inode_info *iinfo;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        inode = udf_new_inode(dir, S_IFLNK, &err);
        if (!inode)
@@ -1069,6 +1081,8 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
        int err;
        struct buffer_head *bh;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
                unlock_kernel();
@@ -1131,6 +1145,9 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct kernel_lb_addr tloc;
        struct udf_inode_info *old_iinfo = UDF_I(old_inode);
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        lock_kernel();
        ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
        if (ofi) {

diff --git a/fs/ufs/file.c b/fs/ufs/file.c
index 73655c61240a0bb756ad4af3d0b841f04c709ae1..d84762f3028ef9f1d8283f19da22ab0621baab03 100644 (file)
--- a/fs/ufs/file.c
+++ b/fs/ufs/file.c
@@ -40,7 +40,7 @@ const struct file_operations ufs_file_operations = {
        .write          = do_sync_write,
        .aio_write      = generic_file_aio_write,
        .mmap           = generic_file_mmap,
-       .open           = generic_file_open,
+       .open           = dquot_file_open,
        .fsync          = simple_fsync,
        .splice_read    = generic_file_splice_read,
 };

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 7cf33379fd467825d91957befaab253bcc78f4a1..fff8edab382f99b4e57b780ee4ca406ae707bcc3 100644 (file)
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -36,6 +36,7 @@
 #include <linux/mm.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
+#include <linux/quotaops.h>
 
 #include "ufs_fs.h"
 #include "ufs.h"
@@ -908,6 +909,9 @@ void ufs_delete_inode (struct inode * inode)
 {
        loff_t old_i_size;
 
+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+
        truncate_inode_pages(&inode->i_data, 0);
        if (is_bad_inode(inode))
                goto no_delete;

diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index 4c26d9e8bc94f8f24578495985e14202cce5be8e..c33cb90c516dc4b69944b08fc5e2edb065caec9d 100644 (file)
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -30,6 +30,7 @@
 #include <linux/time.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>
+#include <linux/quotaops.h>
 
 #include "ufs_fs.h"
 #include "ufs.h"
@@ -84,6 +85,9 @@ static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
        int err;
 
        UFSD("BEGIN\n");
+
+       vfs_dq_init(dir);
+
        inode = ufs_new_inode(dir, mode);
        err = PTR_ERR(inode);
 
@@ -107,6 +111,9 @@ static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t
 
        if (!old_valid_dev(rdev))
                return -EINVAL;
+
+       vfs_dq_init(dir);
+
        inode = ufs_new_inode(dir, mode);
        err = PTR_ERR(inode);
        if (!IS_ERR(inode)) {
@@ -131,6 +138,8 @@ static int ufs_symlink (struct inode * dir, struct dentry * dentry,
        if (l > sb->s_blocksize)
                goto out_notlocked;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
        err = PTR_ERR(inode);
@@ -176,6 +185,8 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
                return -EMLINK;
        }
 
+       vfs_dq_init(dir);
+
        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
        atomic_inc(&inode->i_count);
@@ -193,6 +204,8 @@ static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
        if (dir->i_nlink >= UFS_LINK_MAX)
                goto out;
 
+       vfs_dq_init(dir);
+
        lock_kernel();
        inode_inc_link_count(dir);
 
@@ -237,6 +250,8 @@ static int ufs_unlink(struct inode *dir, struct dentry *dentry)
        struct page *page;
        int err = -ENOENT;
 
+       vfs_dq_init(dir);
+
        de = ufs_find_entry(dir, &dentry->d_name, &page);
        if (!de)
                goto out;
@@ -281,6 +296,9 @@ static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
        struct ufs_dir_entry *old_de;
        int err = -ENOENT;
 
+       vfs_dq_init(old_dir);
+       vfs_dq_init(new_dir);
+
        old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
        if (!old_de)
                goto out;

diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index 87bbab68590169b85ef37d9c8de52abbe0f2e0be..e5ef8a3ec23045a15b11184e3d16c1ca58a003a6 100644 (file)
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -527,6 +527,9 @@ static int ufs_setattr(struct dentry *dentry, struct iattr *attr)
        if (ia_valid & ATTR_SIZE &&
            attr->ia_size != i_size_read(inode)) {
                loff_t old_i_size = inode->i_size;
+
+               vfs_dq_init(inode);
+
                error = vmtruncate(inode, attr->ia_size);
                if (error)
                        return error;

diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index a5ebd1abccd8d9b068682fd25fe0419e5cf05e19..93ac788345e215a0965d236ca79501b58c7afbb1 100644 (file)
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -48,6 +48,8 @@ int dquot_release(struct dquot *dquot);
 int dquot_commit_info(struct super_block *sb, int type);
 int dquot_mark_dquot_dirty(struct dquot *dquot);
 
+int dquot_file_open(struct inode *inode, struct file *file);
+
 int vfs_quota_on(struct super_block *sb, int type, int format_id,
        char *path, int remount);
 int vfs_quota_enable(struct inode *inode, int type, int format_id,
@@ -342,4 +344,6 @@ static inline void dquot_release_reservation_block(struct inode *inode,
        __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 }
 
+#define dquot_file_open                generic_file_open
+
 #endif /* _LINUX_QUOTAOPS_ */