Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6: (33 commits)
  quota: stop using QUOTA_OK / NO_QUOTA
  dquot: cleanup dquot initialize routine
  dquot: move dquot initialization responsibility into the filesystem
  dquot: cleanup dquot drop routine
  dquot: move dquot drop responsibility into the filesystem
  dquot: cleanup dquot transfer routine
  dquot: move dquot transfer responsibility into the filesystem
  dquot: cleanup inode allocation / freeing routines
  dquot: cleanup space allocation / freeing routines
  ext3: add writepage sanity checks
  ext3: Truncate allocated blocks if direct IO write fails to update i_size
  quota: Properly invalidate caches even for filesystems with blocksize < pagesize
  quota: generalize quota transfer interface
  quota: sb_quota state flags cleanup
  jbd: Delay discarding buffers in journal_unmap_buffer
  ext3: quota_write cross block boundary behaviour
  quota: drop permission checks from xfs_fs_set_xstate/xfs_fs_set_xquota
  quota: split out compat_sys_quotactl support from quota.c
  quota: split out netlink notification support from quota.c
  quota: remove invalid optimization from quota_sync_all
  ...

Fixed trivial conflicts in fs/namei.c and fs/ufs/inode.c

6 files changed, 126 insertions, 268 deletions

diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index deac2566450e..cac84b006667 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -202,14 +202,6 @@ static inline __u32 ext3_mask_flags(umode_t mode, __u32 flags)
                 return flags & EXT3_OTHER_FLMASK;
 }
 
-/*
- * Inode dynamic state flags
- */
-#define EXT3_STATE_JDATA                0x00000001 /* journaled data exists */
-#define EXT3_STATE_NEW                  0x00000002 /* inode is newly created */
-#define EXT3_STATE_XATTR                0x00000004 /* has in-inode xattrs */
-#define EXT3_STATE_FLUSH_ON_CLOSE       0x00000008
-
 /* Used to pass group descriptor data when online resize is done */
 struct ext3_new_group_input {
         __u32 group;            /* Group number for this data */
@@ -560,6 +552,31 @@ static inline int ext3_valid_inum(struct super_block *sb, unsigned long ino)
                 (ino >= EXT3_FIRST_INO(sb) &&
                  ino <= le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count));
 }
+
+/*
+ * Inode dynamic state flags
+ */
+enum {
+        EXT3_STATE_JDATA,               /* journaled data exists */
+        EXT3_STATE_NEW,                 /* inode is newly created */
+        EXT3_STATE_XATTR,               /* has in-inode xattrs */
+        EXT3_STATE_FLUSH_ON_CLOSE,      /* flush dirty pages on close */
+};
+
+static inline int ext3_test_inode_state(struct inode *inode, int bit)
+{
+        return test_bit(bit, &EXT3_I(inode)->i_state);
+}
+
+static inline void ext3_set_inode_state(struct inode *inode, int bit)
+{
+        set_bit(bit, &EXT3_I(inode)->i_state);
+}
+
+static inline void ext3_clear_inode_state(struct inode *inode, int bit)
+{
+        clear_bit(bit, &EXT3_I(inode)->i_state);
+}
 #else
 /* Assume that user mode programs are passing in an ext3fs superblock, not
  * a kernel struct super_block.  This will allow us to call the feature-test
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index 93e7428156ba..7679acdb519a 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -87,7 +87,7 @@ struct ext3_inode_info {
          * near to their parent directory's inode.
          */
         __u32   i_block_group;
-        __u32   i_state;                /* Dynamic state flags for ext3 */
+        unsigned long   i_state;        /* Dynamic state flags for ext3 */
 
         /* block reservation info */
         struct ext3_block_alloc_info *i_block_alloc_info;
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 331530cd3cc6..f3aa59cb675d 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -246,19 +246,8 @@ typedef struct journal_superblock_s
 
 #define J_ASSERT(assert)        BUG_ON(!(assert))
 
-#if defined(CONFIG_BUFFER_DEBUG)
-void buffer_assertion_failure(struct buffer_head *bh);
-#define J_ASSERT_BH(bh, expr)                                           \
-        do {                                                            \
-                if (!(expr))                                            \
-                        buffer_assertion_failure(bh);                   \
-                J_ASSERT(expr);                                         \
-        } while (0)
-#define J_ASSERT_JH(jh, expr)   J_ASSERT_BH(jh2bh(jh), expr)
-#else
 #define J_ASSERT_BH(bh, expr)   J_ASSERT(expr)
 #define J_ASSERT_JH(jh, expr)   J_ASSERT(expr)
-#endif
 
 #if defined(JBD_PARANOID_IOFAIL)
 #define J_EXPECT(expr, why...)          J_ASSERT(expr)
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 8ada2a129d08..1ec876358180 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -277,19 +277,8 @@ typedef struct journal_superblock_s
 
 #define J_ASSERT(assert)        BUG_ON(!(assert))
 
-#if defined(CONFIG_BUFFER_DEBUG)
-void buffer_assertion_failure(struct buffer_head *bh);
-#define J_ASSERT_BH(bh, expr)                                           \
-        do {                                                            \
-                if (!(expr))                                            \
-                        buffer_assertion_failure(bh);                   \
-                J_ASSERT(expr);                                         \
-        } while (0)
-#define J_ASSERT_JH(jh, expr)   J_ASSERT_BH(jh2bh(jh), expr)
-#else
 #define J_ASSERT_BH(bh, expr)   J_ASSERT(expr)
 #define J_ASSERT_JH(jh, expr)   J_ASSERT(expr)
-#endif
 
 #if defined(JBD2_PARANOID_IOFAIL)
 #define J_EXPECT(expr, why...)          J_ASSERT(expr)
diff --git a/include/linux/quota.h b/include/linux/quota.h
index a6861f117480..b462916b2a0a 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -279,9 +279,6 @@ struct dquot {
         struct mem_dqblk dq_dqb;        /* Diskquota usage */
 };
 
-#define QUOTA_OK          0
-#define NO_QUOTA          1
-
 /* Operations which must be implemented by each quota format */
 struct quota_format_ops {
         int (*check_quota_file)(struct super_block *sb, int type);      /* Detect whether file is in our format */
@@ -295,13 +292,6 @@ struct quota_format_ops {
 
 /* Operations working with dquots */
 struct dquot_operations {
-        int (*initialize) (struct inode *, int);
-        int (*drop) (struct inode *);
-        int (*alloc_space) (struct inode *, qsize_t, int);
-        int (*alloc_inode) (const struct inode *, qsize_t);
-        int (*free_space) (struct inode *, qsize_t);
-        int (*free_inode) (const struct inode *, qsize_t);
-        int (*transfer) (struct inode *, struct iattr *);
         int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
         struct dquot *(*alloc_dquot)(struct super_block *, int);        /* Allocate memory for new dquot */
         void (*destroy_dquot)(struct dquot *);          /* Free memory for dquot */
@@ -309,12 +299,6 @@ struct dquot_operations {
         int (*release_dquot) (struct dquot *);          /* Quota is going to be deleted from disk */
         int (*mark_dirty) (struct dquot *);             /* Dquot is marked dirty */
         int (*write_info) (struct super_block *, int);  /* Write of quota "superblock" */
-        /* reserve quota for delayed block allocation */
-        int (*reserve_space) (struct inode *, qsize_t, int);
-        /* claim reserved quota for delayed alloc */
-        int (*claim_space) (struct inode *, qsize_t);
-        /* release rsved quota for delayed alloc */
-        void (*release_rsv) (struct inode *, qsize_t);
         /* get reserved quota for delayed alloc, value returned is managed by
          * quota code only */
         qsize_t *(*get_reserved_space) (struct inode *);
@@ -324,7 +308,7 @@ struct dquot_operations {
 struct quotactl_ops {
         int (*quota_on)(struct super_block *, int, int, char *, int);
         int (*quota_off)(struct super_block *, int, int);
-        int (*quota_sync)(struct super_block *, int);
+        int (*quota_sync)(struct super_block *, int, int);
         int (*get_info)(struct super_block *, int, struct if_dqinfo *);
         int (*set_info)(struct super_block *, int, struct if_dqinfo *);
         int (*get_dqblk)(struct super_block *, int, qid_t, struct if_dqblk *);
@@ -357,26 +341,25 @@ enum {
 #define DQUOT_STATE_FLAGS       (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED | \
                                  DQUOT_SUSPENDED)
 /* Other quota flags */
-#define DQUOT_QUOTA_SYS_FILE    (1 << 6)        /* Quota file is a special
+#define DQUOT_STATE_LAST        (_DQUOT_STATE_FLAGS * MAXQUOTAS)
+#define DQUOT_QUOTA_SYS_FILE    (1 << DQUOT_STATE_LAST)
+                                                /* Quota file is a special
                                                  * system file and user cannot
                                                  * touch it. Filesystem is
                                                  * responsible for setting
                                                  * S_NOQUOTA, S_NOATIME flags
                                                  */
-#define DQUOT_NEGATIVE_USAGE    (1 << 7)        /* Allow negative quota usage */
+#define DQUOT_NEGATIVE_USAGE    (1 << (DQUOT_STATE_LAST + 1))
+                                               /* Allow negative quota usage */
 
 static inline unsigned int dquot_state_flag(unsigned int flags, int type)
 {
-        if (type == USRQUOTA)
-                return flags;
-        return flags << _DQUOT_STATE_FLAGS;
+        return flags << _DQUOT_STATE_FLAGS * type;
 }
 
 static inline unsigned int dquot_generic_flag(unsigned int flags, int type)
 {
-        if (type == USRQUOTA)
-                return flags;
-        return flags >> _DQUOT_STATE_FLAGS;
+        return (flags >> _DQUOT_STATE_FLAGS * type) & DQUOT_STATE_FLAGS;
 }
 
 #ifdef CONFIG_QUOTA_NETLINK_INTERFACE
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 3ebb23153640..e6fa7acce290 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -19,15 +19,12 @@ static inline struct quota_info *sb_dqopt(struct super_block *sb)
 /*
  * declaration of quota_function calls in kernel.
  */
-void sync_quota_sb(struct super_block *sb, int type);
-static inline void writeout_quota_sb(struct super_block *sb, int type)
-{
-        if (sb->s_qcop->quota_sync)
-                sb->s_qcop->quota_sync(sb, type);
-}
+void inode_add_rsv_space(struct inode *inode, qsize_t number);
+void inode_claim_rsv_space(struct inode *inode, qsize_t number);
+void inode_sub_rsv_space(struct inode *inode, qsize_t number);
 
-int dquot_initialize(struct inode *inode, int type);
-int dquot_drop(struct inode *inode);
+void dquot_initialize(struct inode *inode);
+void dquot_drop(struct inode *inode);
 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
 void dqput(struct dquot *dquot);
 int dquot_scan_active(struct super_block *sb,
@@ -36,24 +33,23 @@ int dquot_scan_active(struct super_block *sb,
 struct dquot *dquot_alloc(struct super_block *sb, int type);
 void dquot_destroy(struct dquot *dquot);
 
-int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
-int dquot_alloc_inode(const struct inode *inode, qsize_t number);
+int __dquot_alloc_space(struct inode *inode, qsize_t number,
+                int warn, int reserve);
+void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
 
-int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
-int dquot_claim_space(struct inode *inode, qsize_t number);
-void dquot_release_reserved_space(struct inode *inode, qsize_t number);
-qsize_t dquot_get_reserved_space(struct inode *inode);
+int dquot_alloc_inode(const struct inode *inode);
 
-int dquot_free_space(struct inode *inode, qsize_t number);
-int dquot_free_inode(const struct inode *inode, qsize_t number);
+int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
+void dquot_free_inode(const struct inode *inode);
 
-int dquot_transfer(struct inode *inode, struct iattr *iattr);
 int dquot_commit(struct dquot *dquot);
 int dquot_acquire(struct dquot *dquot);
 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,
@@ -64,14 +60,13 @@ int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
         int format_id, int type);
 int vfs_quota_off(struct super_block *sb, int type, int remount);
 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
-int vfs_quota_sync(struct super_block *sb, int type);
+int vfs_quota_sync(struct super_block *sb, int type, int wait);
 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
 
-void vfs_dq_drop(struct inode *inode);
-int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
+int dquot_transfer(struct inode *inode, struct iattr *iattr);
 int vfs_dq_quota_on_remount(struct super_block *sb);
 
 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
@@ -83,53 +78,56 @@ static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
  * Functions for checking status of quota
  */
 
-static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
+static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
 {
         return sb_dqopt(sb)->flags &
                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
 }
 
-static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
+static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
 {
         return sb_dqopt(sb)->flags &
                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
 }
 
-static inline int sb_has_quota_suspended(struct super_block *sb, int type)
+static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
 {
         return sb_dqopt(sb)->flags &
                                 dquot_state_flag(DQUOT_SUSPENDED, type);
 }
 
-static inline int sb_any_quota_suspended(struct super_block *sb)
+static inline unsigned sb_any_quota_suspended(struct super_block *sb)
 {
-        return sb_has_quota_suspended(sb, USRQUOTA) ||
-                sb_has_quota_suspended(sb, GRPQUOTA);
+        unsigned type, tmsk = 0;
+        for (type = 0; type < MAXQUOTAS; type++)
+                tmsk |= sb_has_quota_suspended(sb, type) << type;
+        return tmsk;
 }
 
 /* Does kernel know about any quota information for given sb + type? */
-static inline int sb_has_quota_loaded(struct super_block *sb, int type)
+static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
 {
         /* Currently if anything is on, then quota usage is on as well */
         return sb_has_quota_usage_enabled(sb, type);
 }
 
-static inline int sb_any_quota_loaded(struct super_block *sb)
+static inline unsigned sb_any_quota_loaded(struct super_block *sb)
 {
-        return sb_has_quota_loaded(sb, USRQUOTA) ||
-                sb_has_quota_loaded(sb, GRPQUOTA);
+        unsigned type, tmsk = 0;
+        for (type = 0; type < MAXQUOTAS; type++)
+                tmsk |= sb_has_quota_loaded(sb, type) << type;
+        return  tmsk;
 }
 
-static inline int sb_has_quota_active(struct super_block *sb, int type)
+static inline bool sb_has_quota_active(struct super_block *sb, int type)
 {
         return sb_has_quota_loaded(sb, type) &&
                !sb_has_quota_suspended(sb, type);
 }
 
-static inline int sb_any_quota_active(struct super_block *sb)
+static inline unsigned sb_any_quota_active(struct super_block *sb)
 {
-        return sb_has_quota_active(sb, USRQUOTA) ||
-               sb_has_quota_active(sb, GRPQUOTA);
+        return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
 }
 
 /*
@@ -141,122 +139,6 @@ extern const struct quotactl_ops vfs_quotactl_ops;
 #define sb_dquot_ops (&dquot_operations)
 #define sb_quotactl_ops (&vfs_quotactl_ops)
 
-/* It is better to call this function outside of any transaction as it might
- * need a lot of space in journal for dquot structure allocation. */
-static inline void vfs_dq_init(struct inode *inode)
-{
-        BUG_ON(!inode->i_sb);
-        if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
-                inode->i_sb->dq_op->initialize(inode, -1);
-}
-
-/* The following allocation/freeing/transfer functions *must* be called inside
- * a transaction (deadlocks possible otherwise) */
-static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb)) {
-                /* Used space is updated in alloc_space() */
-                if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
-                        return 1;
-        }
-        else
-                inode_add_bytes(inode, nr);
-        return 0;
-}
-
-static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
-{
-        int ret;
-        if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
-                mark_inode_dirty(inode);
-        return ret;
-}
-
-static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb)) {
-                /* Used space is updated in alloc_space() */
-                if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
-                        return 1;
-        }
-        else
-                inode_add_bytes(inode, nr);
-        return 0;
-}
-
-static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
-{
-        int ret;
-        if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
-                mark_inode_dirty(inode);
-        return ret;
-}
-
-static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb)) {
-                /* Used space is updated in alloc_space() */
-                if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
-                        return 1;
-        }
-        return 0;
-}
-
-static inline int vfs_dq_alloc_inode(struct inode *inode)
-{
-        if (sb_any_quota_active(inode->i_sb)) {
-                vfs_dq_init(inode);
-                if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
-                        return 1;
-        }
-        return 0;
-}
-
-/*
- * Convert in-memory reserved quotas to real consumed quotas
- */
-static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb)) {
-                if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
-                        return 1;
-        } else
-                inode_add_bytes(inode, nr);
-
-        mark_inode_dirty(inode);
-        return 0;
-}
-
-/*
- * Release reserved (in-memory) quotas
- */
-static inline
-void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb))
-                inode->i_sb->dq_op->release_rsv(inode, nr);
-}
-
-static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
-{
-        if (sb_any_quota_active(inode->i_sb))
-                inode->i_sb->dq_op->free_space(inode, nr);
-        else
-                inode_sub_bytes(inode, nr);
-}
-
-static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
-{
-        vfs_dq_free_space_nodirty(inode, nr);
-        mark_inode_dirty(inode);
-}
-
-static inline void vfs_dq_free_inode(struct inode *inode)
-{
-        if (sb_any_quota_active(inode->i_sb))
-                inode->i_sb->dq_op->free_inode(inode, 1);
-}
-
 /* Cannot be called inside a transaction */
 static inline int vfs_dq_off(struct super_block *sb, int remount)
 {
@@ -316,28 +198,20 @@ static inline int sb_any_quota_active(struct super_block *sb)
 #define sb_dquot_ops                            (NULL)
 #define sb_quotactl_ops                         (NULL)
 
-static inline void vfs_dq_init(struct inode *inode)
+static inline void dquot_initialize(struct inode *inode)
 {
 }
 
-static inline void vfs_dq_drop(struct inode *inode)
+static inline void dquot_drop(struct inode *inode)
 {
 }
 
-static inline int vfs_dq_alloc_inode(struct inode *inode)
+static inline int dquot_alloc_inode(const struct inode *inode)
 {
         return 0;
 }
 
-static inline void vfs_dq_free_inode(struct inode *inode)
-{
-}
-
-static inline void sync_quota_sb(struct super_block *sb, int type)
-{
-}
-
-static inline void writeout_quota_sb(struct super_block *sb, int type)
+static inline void dquot_free_inode(const struct inode *inode)
 {
 }
 
@@ -351,110 +225,116 @@ static inline int vfs_dq_quota_on_remount(struct super_block *sb)
         return 0;
 }
 
-static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
+static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 {
         return 0;
 }
 
-static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
+                int warn, int reserve)
 {
-        inode_add_bytes(inode, nr);
+        if (!reserve)
+                inode_add_bytes(inode, number);
         return 0;
 }
 
-static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
+static inline void __dquot_free_space(struct inode *inode, qsize_t number,
+                int reserve)
 {
-        vfs_dq_prealloc_space_nodirty(inode, nr);
-        mark_inode_dirty(inode);
-        return 0;
+        if (!reserve)
+                inode_sub_bytes(inode, number);
 }
 
-static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 {
-        inode_add_bytes(inode, nr);
+        inode_add_bytes(inode, number);
         return 0;
 }
 
-static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
+#define dquot_file_open         generic_file_open
+
+#endif /* CONFIG_QUOTA */
+
+static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        vfs_dq_alloc_space_nodirty(inode, nr);
-        mark_inode_dirty(inode);
-        return 0;
+        return __dquot_alloc_space(inode, nr, 1, 0);
 }
 
-static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
 {
-        return 0;
+        int ret;
+
+        ret = dquot_alloc_space_nodirty(inode, nr);
+        if (!ret)
+                mark_inode_dirty(inode);
+        return ret;
 }
 
-static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
 {
-        return vfs_dq_alloc_space(inode, nr);
+        return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 }
 
-static inline
-int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
+static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 {
-        return 0;
+        return dquot_alloc_space(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 {
-        inode_sub_bytes(inode, nr);
+        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
 }
 
-static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
+static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 {
-        vfs_dq_free_space_nodirty(inode, nr);
-        mark_inode_dirty(inode);
-}       
-
-#endif /* CONFIG_QUOTA */
+        int ret;
 
-static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
-{
-        return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
+        ret = dquot_prealloc_block_nodirty(inode, nr);
+        if (!ret)
+                mark_inode_dirty(inode);
+        return ret;
 }
 
-static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
+static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 {
-        return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
+        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
 }
 
-static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
+static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
 {
-        return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
-}
+        int ret;
 
-static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
-{
-        return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
+        ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
+        if (!ret)
+                mark_inode_dirty(inode);
+        return ret;
 }
 
-static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
+        __dquot_free_space(inode, nr, 0);
 }
 
-static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_space(struct inode *inode, qsize_t nr)
 {
-        return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
+        dquot_free_space_nodirty(inode, nr);
+        mark_inode_dirty(inode);
 }
 
-static inline
-void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
+static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
 {
-        vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
+        dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
+static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 {
-        vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
+        dquot_free_space(inode, nr << inode->i_blkbits);
 }
 
-static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
+static inline void dquot_release_reservation_block(struct inode *inode,
+                qsize_t nr)
 {
-        vfs_dq_free_space(inode, nr << inode->i_blkbits);
+        __dquot_free_space(inode, nr << inode->i_blkbits, 1);
 }
 
 #endif /* _LINUX_QUOTAOPS_ */