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 586e358..d11f6e4 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,
        .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,
        .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,
        .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,
 };
        .release        = ext2_release_file,
        .fsync          = ext2_fsync,
 };

diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 3cfcfd9..c87840c 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)
 {
  */
 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))
        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;
        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);
        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 dd7175c..5923df7 100644 (file)
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -31,6 +31,7 @@
  */
 
 #include <linux/pagemap.h>
  */
 
 #include <linux/pagemap.h>

+#include <linux/quotaops.h>

 #include "ext2.h"
 #include "xattr.h"
 #include "acl.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)
 {
  */
 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)
 }
 
 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;
 
        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)) {
        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;
 
        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))
        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;
 
        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);
        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;
 
        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);
        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;
 
        struct page * page;
        int err = -ENOENT;
 

+       vfs_dq_init(dir);
+

        de = ext2_find_entry (dir, &dentry->d_name, &page);
        if (!de)
                goto out;
        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;
 
        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;
        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 a86d330..3c7fb11 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,
        .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,
        .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 14d40a4..d7962b0 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;
 
 {
        handle_t *handle;
 

+       if (!is_bad_inode(inode))
+               vfs_dq_init(inode);
+

        truncate_inode_pages(&inode->i_data, 0);
 
        if (is_bad_inode(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 (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;
        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 7b0e44f..a492b37 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;
 
        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 +
 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;
 
        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 +
 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;
 
        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 +
 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 */
 
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */

+       vfs_dq_init(dir);

        vfs_dq_init(dentry->d_inode);
        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);
        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 */
 
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */

+       vfs_dq_init(dir);

        vfs_dq_init(dentry->d_inode);
        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);
        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;
 
        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 +
 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;
 
        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.
        /*
         * 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;
 
        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
        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 9630583..85fa464 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;
                }
        }
                        sb->s_dirt = 1;
                }
        }

-       return generic_file_open(inode, filp);
+       return dquot_file_open(inode, filp);

 }
 
 const struct file_operations ext4_file_operations = {
 }
 
 const struct file_operations ext4_file_operations = {

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 6a002a6..eaa22ae 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;
 
        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);
        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 (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;
        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 17a17e1..20f55c2 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;
 
        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 +
 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;
 
        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 +
 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;
 
        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 +
 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 */
 
        /* Initialize quotas before so that eventual writes go in
         * separate transaction */

+       vfs_dq_init(dir);

        vfs_dq_init(dentry->d_inode);
        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);
        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 */
 
        /* Initialize quotas before so that eventual writes go
         * in separate transaction */

+       vfs_dq_init(dir);

        vfs_dq_init(dentry->d_inode);
        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);
        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;
 
        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 +
 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;
 
        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.
        /*
         * 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;
 
        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
        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 f1aef34..407bf39 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/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>
 #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 (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()
                /* 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 2c20178..f19bb33 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;
 
 {
        int rc;
 

-       if ((rc = generic_file_open(inode, file)))
+       if ((rc = dquot_file_open(inode, file)))

                return rc;
 
        /*
                return rc;
 
        /*


@@ -98,6 +98,8 @@ int jfs_setattr(struct dentry *dentry, struct iattr *iattr)
        if (rc)
                return rc;
 
        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);
        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 22fa412..1aa2dda 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);
 
 {
        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);
        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 1d1390a..b7cc29d 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);
 
 
        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)
        /*
         * 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);
 
 
        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;
        /* 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. */
        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 */
        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. */
        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)))
        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;
 
        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);
        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);
 
 
        jfs_info("jfs_symlink: dip:0x%p name:%s", dip, name);
 

+       vfs_dq_init(dip);
+

        ssize = strlen(name) + 1;
 
        /*
        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);
 
        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;
 
        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);
 
 
        jfs_info("jfs_mknod: %s", dentry->d_name.name);
 

+       vfs_dq_init(dir);
+

        if ((rc = get_UCSname(&dname, dentry)))
                goto out;
 
        if ((rc = get_UCSname(&dname, dentry)))
                goto out;
 

diff --git a/fs/namei.c b/fs/namei.c
index a4855af..06abd2b 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/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>
 #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;
        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);
        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 (!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) {
                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;
 
        if (error)
                return error;
 

-       vfs_dq_init(dir);

        error = dir->i_op->mknod(dir, dentry, mode, dev);
        if (!error)
                fsnotify_create(dir, dentry);
        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;
 
        if (error)
                return error;
 

-       vfs_dq_init(dir);

        error = dir->i_op->mkdir(dir, dentry, mode);
        if (!error)
                fsnotify_mkdir(dir, dentry);
        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;
 
        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))
        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;
 
        if (!dir->i_op->unlink)
                return -EPERM;
 

-       vfs_dq_init(dir);
-

        mutex_lock(&dentry->d_inode->i_mutex);
        if (d_mountpoint(dentry))
                error = -EBUSY;
        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;
 
        if (error)
                return error;
 

-       vfs_dq_init(dir);

        error = dir->i_op->symlink(dir, dentry, oldname);
        if (!error)
                fsnotify_create(dir, dentry);
        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);
                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)
        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;
 
        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)
        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 8715d19..09e9fc0 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/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>
 #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;
                }
                        put_write_access(inode);
                        goto out_nfserr;
                }

-               vfs_dq_init(inode);

        }
 
        /* sanitize the mode change */
        }
 
        /* 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;
                        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());
        }
        *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 472e8f8..126198f 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);
 
        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
        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) {
 
        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);
                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 00eb6a0..77681a6 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;
        }
 
                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
        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 99766b6..8b5b142 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);
 
                   (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);
 
        /* 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;
 
        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)
        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);
 
        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);
        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);
 
                   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) {
        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);
 
        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);
 
        sb = dir->i_sb;
        osb = OCFS2_SB(sb);
 

diff --git a/fs/open.c b/fs/open.c
index 040cef7..b740c42 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/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>
 #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);
        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);
                error = do_truncate(path.dentry, length, 0, NULL);

-       }

 
 put_write_and_out:
        put_write_access(inode);
 
 put_write_and_out:
        put_write_access(inode);

diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index cd83c5b..6244bca 100644 (file)
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -1821,6 +1821,20 @@ const struct dquot_operations dquot_operations = {
 };
 
 /*
 };
 
 /*

+ * 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)
  */
 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)
  * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
  */
 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)

diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index da2dba0..1d9c127 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,
        .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,
        .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 f07c3b6..06995cb 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;
 
        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);
        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) {
 
        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
                 */
                /* 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 9dea84e..c55e1b9 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;
 
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;
 

+       vfs_dq_init(dir);
+

        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
        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;
 
        if (!new_valid_dev(rdev))
                return -EINVAL;
 

+       vfs_dq_init(dir);
+

        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
        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));
 
            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;
 #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);
 
            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)
        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;
 
        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
        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));
 
            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;
        }
        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);
 
            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
        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);
 
            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;
 
        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 81f09fa..37d034c 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));
 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
        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));
 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);
 }
 
        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));
 {
        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);
 
        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));
 {
        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);
 
        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 2df7fcb..013fa44 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,
        .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,
        .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 (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);
        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 1199e8e..f195202 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/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>
 
 #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)
 {
 
 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))
        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 cd21150..e360c3f 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;
 
        int err;
        struct udf_inode_info *iinfo;
 

+       vfs_dq_init(dir);
+

        lock_kernel();
        inode = udf_new_inode(dir, mode, &err);
        if (!inode) {
        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;
 
        if (!old_valid_dev(rdev))
                return -EINVAL;
 

+       vfs_dq_init(dir);
+

        lock_kernel();
        err = -EIO;
        inode = udf_new_inode(dir, mode, &err);
        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;
 
        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)
        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;
 
        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);
        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;
 
        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);
        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;
 
        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)
        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;
 
        int err;
        struct buffer_head *bh;
 

+       vfs_dq_init(dir);
+

        lock_kernel();
        if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
                unlock_kernel();
        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);
 
        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) {
        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 73655c6..d84762f 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,
        .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,
 };
        .fsync          = simple_fsync,
        .splice_read    = generic_file_splice_read,
 };

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 7cf3337..fff8eda 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/mm.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>

+#include <linux/quotaops.h>

 
 #include "ufs_fs.h"
 #include "ufs.h"
 
 #include "ufs_fs.h"
 #include "ufs.h"


@@ -908,6 +909,9 @@ void ufs_delete_inode (struct inode * inode)
 {
        loff_t old_i_size;
 
 {
        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;
        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 4c26d9e..c33cb90 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/time.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>

+#include <linux/quotaops.h>

 
 #include "ufs_fs.h"
 #include "ufs.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");
        int err;
 
        UFSD("BEGIN\n");

+
+       vfs_dq_init(dir);
+

        inode = ufs_new_inode(dir, mode);
        err = PTR_ERR(inode);
 
        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;
 
        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)) {
        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;
 
        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);
        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;
        }
 
                return -EMLINK;
        }
 

+       vfs_dq_init(dir);
+

        inode->i_ctime = CURRENT_TIME_SEC;
        inode_inc_link_count(inode);
        atomic_inc(&inode->i_count);
        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;
 
        if (dir->i_nlink >= UFS_LINK_MAX)
                goto out;
 

+       vfs_dq_init(dir);
+

        lock_kernel();
        inode_inc_link_count(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;
 
        struct page *page;
        int err = -ENOENT;
 

+       vfs_dq_init(dir);
+

        de = ufs_find_entry(dir, &dentry->d_name, &page);
        if (!de)
                goto out;
        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;
 
        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;
        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 87bbab6..e5ef8a3 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;
        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;
                error = vmtruncate(inode, attr->ia_size);
                if (error)
                        return error;

diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index a5ebd1a..93ac788 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_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,
 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);
 }
 
        __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 }
 

+#define dquot_file_open                generic_file_open
+

 #endif /* _LINUX_QUOTAOPS_ */
 #endif /* _LINUX_QUOTAOPS_ */