6 files changed, 431 insertions, 281 deletions

diff --git a/fs/quota/Kconfig b/fs/quota/Kconfig
index 8047e01ef46b..efc02ebb8c70 100644
--- a/fs/quota/Kconfig
+++ b/fs/quota/Kconfig
@@ -17,7 +17,7 @@ config QUOTA
 
 config QUOTA_NETLINK_INTERFACE
         bool "Report quota messages through netlink interface"
-        depends on QUOTA && NET
+        depends on QUOTACTL && NET
         help
           If you say Y here, quota warnings (about exceeding softlimit, reaching
           hardlimit, etc.) will be reported through netlink interface. If unsure,
@@ -46,12 +46,14 @@ config QFMT_V1
           format say Y here.
 
 config QFMT_V2
-        tristate "Quota format v2 support"
+        tristate "Quota format vfsv0 and vfsv1 support"
         depends on QUOTA
         select QUOTA_TREE
         help
-          This quota format allows using quotas with 32-bit UIDs/GIDs. If you
-          need this functionality say Y here.
+          This config option enables kernel support for vfsv0 and vfsv1 quota
+          formats. Both these formats support 32-bit UIDs/GIDs and vfsv1 format
+          also supports 64-bit inode and block quota limits. If you need this
+          functionality say Y here.
 
 config QUOTACTL
         bool
diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index 39b49c42a7ed..dea86abdf2e7 100644
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -77,10 +77,6 @@
 #include <linux/capability.h>
 #include <linux/quotaops.h>
 #include <linux/writeback.h> /* for inode_lock, oddly enough.. */
-#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
-#include <net/netlink.h>
-#include <net/genetlink.h>
-#endif
 
 #include <asm/uaccess.h>
 
@@ -327,6 +323,30 @@ int dquot_mark_dquot_dirty(struct dquot *dquot)
 }
 EXPORT_SYMBOL(dquot_mark_dquot_dirty);
 
+/* Dirtify all the dquots - this can block when journalling */
+static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
+{
+        int ret, err, cnt;
+
+        ret = err = 0;
+        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
+                if (dquot[cnt])
+                        /* Even in case of error we have to continue */
+                        ret = mark_dquot_dirty(dquot[cnt]);
+                if (!err)
+                        err = ret;
+        }
+        return err;
+}
+
+static inline void dqput_all(struct dquot **dquot)
+{
+        unsigned int cnt;
+
+        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
+                dqput(dquot[cnt]);
+}
+
 /* This function needs dq_list_lock */
 static inline int clear_dquot_dirty(struct dquot *dquot)
 {
@@ -1071,73 +1091,6 @@ static void print_warning(struct dquot *dquot, const int warntype)
 }
 #endif
 
-#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
-
-/* Netlink family structure for quota */
-static struct genl_family quota_genl_family = {
-        .id = GENL_ID_GENERATE,
-        .hdrsize = 0,
-        .name = "VFS_DQUOT",
-        .version = 1,
-        .maxattr = QUOTA_NL_A_MAX,
-};
-
-/* Send warning to userspace about user which exceeded quota */
-static void send_warning(const struct dquot *dquot, const char warntype)
-{
-        static atomic_t seq;
-        struct sk_buff *skb;
-        void *msg_head;
-        int ret;
-        int msg_size = 4 * nla_total_size(sizeof(u32)) +
-                       2 * nla_total_size(sizeof(u64));
-
-        /* We have to allocate using GFP_NOFS as we are called from a
-         * filesystem performing write and thus further recursion into
-         * the fs to free some data could cause deadlocks. */
-        skb = genlmsg_new(msg_size, GFP_NOFS);
-        if (!skb) {
-                printk(KERN_ERR
-                  "VFS: Not enough memory to send quota warning.\n");
-                return;
-        }
-        msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq),
-                        &quota_genl_family, 0, QUOTA_NL_C_WARNING);
-        if (!msg_head) {
-                printk(KERN_ERR
-                  "VFS: Cannot store netlink header in quota warning.\n");
-                goto err_out;
-        }
-        ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, dquot->dq_type);
-        if (ret)
-                goto attr_err_out;
-        ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, dquot->dq_id);
-        if (ret)
-                goto attr_err_out;
-        ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
-        if (ret)
-                goto attr_err_out;
-        ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR,
-                MAJOR(dquot->dq_sb->s_dev));
-        if (ret)
-                goto attr_err_out;
-        ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR,
-                MINOR(dquot->dq_sb->s_dev));
-        if (ret)
-                goto attr_err_out;
-        ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid());
-        if (ret)
-                goto attr_err_out;
-        genlmsg_end(skb, msg_head);
-
-        genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS);
-        return;
-attr_err_out:
-        printk(KERN_ERR "VFS: Not enough space to compose quota message!\n");
-err_out:
-        kfree_skb(skb);
-}
-#endif
 /*
  * Write warnings to the console and send warning messages over netlink.
  *
@@ -1145,18 +1098,20 @@ err_out:
  */
 static void flush_warnings(struct dquot *const *dquots, char *warntype)
 {
+        struct dquot *dq;
         int i;
 
-        for (i = 0; i < MAXQUOTAS; i++)
-                if (dquots[i] && warntype[i] != QUOTA_NL_NOWARN &&
-                    !warning_issued(dquots[i], warntype[i])) {
+        for (i = 0; i < MAXQUOTAS; i++) {
+                dq = dquots[i];
+                if (dq && warntype[i] != QUOTA_NL_NOWARN &&
+                    !warning_issued(dq, warntype[i])) {
 #ifdef CONFIG_PRINT_QUOTA_WARNING
-                        print_warning(dquots[i], warntype[i]);
-#endif
-#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
-                        send_warning(dquots[i], warntype[i]);
+                        print_warning(dq, warntype[i]);
 #endif
+                        quota_send_warning(dq->dq_type, dq->dq_id,
+                                           dq->dq_sb->s_dev, warntype[i]);
                 }
+        }
 }
 
 static int ignore_hardlimit(struct dquot *dquot)
@@ -1337,8 +1292,7 @@ int dquot_initialize(struct inode *inode, int type)
 out_err:
         up_write(&sb_dqopt(sb)->dqptr_sem);
         /* Drop unused references */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                dqput(got[cnt]);
+        dqput_all(got);
         return ret;
 }
 EXPORT_SYMBOL(dquot_initialize);
@@ -1357,9 +1311,7 @@ int dquot_drop(struct inode *inode)
                 inode->i_dquot[cnt] = NULL;
         }
         up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
-
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                dqput(put[cnt]);
+        dqput_all(put);
         return 0;
 }
 EXPORT_SYMBOL(dquot_drop);
@@ -1388,6 +1340,67 @@ void vfs_dq_drop(struct inode *inode)
 EXPORT_SYMBOL(vfs_dq_drop);
 
 /*
+ * inode_reserved_space is managed internally by quota, and protected by
+ * i_lock similar to i_blocks+i_bytes.
+ */
+static qsize_t *inode_reserved_space(struct inode * inode)
+{
+        /* Filesystem must explicitly define it's own method in order to use
+         * quota reservation interface */
+        BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
+        return inode->i_sb->dq_op->get_reserved_space(inode);
+}
+
+static void inode_add_rsv_space(struct inode *inode, qsize_t number)
+{
+        spin_lock(&inode->i_lock);
+        *inode_reserved_space(inode) += number;
+        spin_unlock(&inode->i_lock);
+}
+
+
+static void inode_claim_rsv_space(struct inode *inode, qsize_t number)
+{
+        spin_lock(&inode->i_lock);
+        *inode_reserved_space(inode) -= number;
+        __inode_add_bytes(inode, number);
+        spin_unlock(&inode->i_lock);
+}
+
+static void inode_sub_rsv_space(struct inode *inode, qsize_t number)
+{
+        spin_lock(&inode->i_lock);
+        *inode_reserved_space(inode) -= number;
+        spin_unlock(&inode->i_lock);
+}
+
+static qsize_t inode_get_rsv_space(struct inode *inode)
+{
+        qsize_t ret;
+        spin_lock(&inode->i_lock);
+        ret = *inode_reserved_space(inode);
+        spin_unlock(&inode->i_lock);
+        return ret;
+}
+
+static void inode_incr_space(struct inode *inode, qsize_t number,
+                                int reserve)
+{
+        if (reserve)
+                inode_add_rsv_space(inode, number);
+        else
+                inode_add_bytes(inode, number);
+}
+
+static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
+{
+        if (reserve)
+                inode_sub_rsv_space(inode, number);
+        else
+                inode_sub_bytes(inode, number);
+}
+
+/*
  * Following four functions update i_blocks+i_bytes fields and
  * quota information (together with appropriate checks)
  * NOTE: We absolutely rely on the fact that caller dirties
@@ -1405,6 +1418,21 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number,
         int cnt, ret = QUOTA_OK;
         char warntype[MAXQUOTAS];
 
+        /*
+         * First test before acquiring mutex - solves deadlocks when we
+         * re-enter the quota code and are already holding the mutex
+         */
+        if (IS_NOQUOTA(inode)) {
+                inode_incr_space(inode, number, reserve);
+                goto out;
+        }
+
+        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
+        if (IS_NOQUOTA(inode)) {
+                inode_incr_space(inode, number, reserve);
+                goto out_unlock;
+        }
+
         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
                 warntype[cnt] = QUOTA_NL_NOWARN;
 
@@ -1415,7 +1443,8 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number,
                 if (check_bdq(inode->i_dquot[cnt], number, warn, warntype+cnt)
                     == NO_QUOTA) {
                         ret = NO_QUOTA;
-                        goto out_unlock;
+                        spin_unlock(&dq_data_lock);
+                        goto out_flush_warn;
                 }
         }
         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
@@ -1426,64 +1455,29 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number,
                 else
                         dquot_incr_space(inode->i_dquot[cnt], number);
         }
-        if (!reserve)
-                inode_add_bytes(inode, number);
-out_unlock:
+        inode_incr_space(inode, number, reserve);
         spin_unlock(&dq_data_lock);
+
+        if (reserve)
+                goto out_flush_warn;
+        mark_all_dquot_dirty(inode->i_dquot);
+out_flush_warn:
         flush_warnings(inode->i_dquot, warntype);
+out_unlock:
+        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
+out:
         return ret;
 }
 
 int dquot_alloc_space(struct inode *inode, qsize_t number, int warn)
 {
-        int cnt, ret = QUOTA_OK;
-
-        /*
-         * First test before acquiring mutex - solves deadlocks when we
-         * re-enter the quota code and are already holding the mutex
-         */
-        if (IS_NOQUOTA(inode)) {
-                inode_add_bytes(inode, number);
-                goto out;
-        }
-
-        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-        if (IS_NOQUOTA(inode)) {
-                inode_add_bytes(inode, number);
-                goto out_unlock;
-        }
-
-        ret = __dquot_alloc_space(inode, number, warn, 0);
-        if (ret == NO_QUOTA)
-                goto out_unlock;
-
-        /* Dirtify all the dquots - this can block when journalling */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                if (inode->i_dquot[cnt])
-                        mark_dquot_dirty(inode->i_dquot[cnt]);
-out_unlock:
-        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-out:
-        return ret;
+        return __dquot_alloc_space(inode, number, warn, 0);
 }
 EXPORT_SYMBOL(dquot_alloc_space);
 
 int dquot_reserve_space(struct inode *inode, qsize_t number, int warn)
 {
-        int ret = QUOTA_OK;
-
-        if (IS_NOQUOTA(inode))
-                goto out;
-
-        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-        if (IS_NOQUOTA(inode))
-                goto out_unlock;
-
-        ret = __dquot_alloc_space(inode, number, warn, 1);
-out_unlock:
-        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-out:
-        return ret;
+        return __dquot_alloc_space(inode, number, warn, 1);
 }
 EXPORT_SYMBOL(dquot_reserve_space);
 
@@ -1524,10 +1518,7 @@ int dquot_alloc_inode(const struct inode *inode, qsize_t number)
 warn_put_all:
         spin_unlock(&dq_data_lock);
         if (ret == QUOTA_OK)
-                /* Dirtify all the dquots - this can block when journalling */
-                for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                        if (inode->i_dquot[cnt])
-                                mark_dquot_dirty(inode->i_dquot[cnt]);
+                mark_all_dquot_dirty(inode->i_dquot);
         flush_warnings(inode->i_dquot, warntype);
         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
         return ret;
@@ -1540,14 +1531,14 @@ int dquot_claim_space(struct inode *inode, qsize_t number)
         int ret = QUOTA_OK;
 
         if (IS_NOQUOTA(inode)) {
-                inode_add_bytes(inode, number);
+                inode_claim_rsv_space(inode, number);
                 goto out;
         }
 
         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
         if (IS_NOQUOTA(inode))  {
                 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-                inode_add_bytes(inode, number);
+                inode_claim_rsv_space(inode, number);
                 goto out;
         }
 
@@ -1559,12 +1550,9 @@ int dquot_claim_space(struct inode *inode, qsize_t number)
                                                         number);
         }
         /* Update inode bytes */
-        inode_add_bytes(inode, number);
+        inode_claim_rsv_space(inode, number);
         spin_unlock(&dq_data_lock);
-        /* Dirtify all the dquots - this can block when journalling */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                if (inode->i_dquot[cnt])
-                        mark_dquot_dirty(inode->i_dquot[cnt]);
+        mark_all_dquot_dirty(inode->i_dquot);
         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
 out:
         return ret;
@@ -1572,38 +1560,9 @@ out:
 EXPORT_SYMBOL(dquot_claim_space);
 
 /*
- * Release reserved quota space
- */
-void dquot_release_reserved_space(struct inode *inode, qsize_t number)
-{
-        int cnt;
-
-        if (IS_NOQUOTA(inode))
-                goto out;
-
-        down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-        if (IS_NOQUOTA(inode))
-                goto out_unlock;
-
-        spin_lock(&dq_data_lock);
-        /* Release reserved dquots */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
-                if (inode->i_dquot[cnt])
-                        dquot_free_reserved_space(inode->i_dquot[cnt], number);
-        }
-        spin_unlock(&dq_data_lock);
-
-out_unlock:
-        up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
-out:
-        return;
-}
-EXPORT_SYMBOL(dquot_release_reserved_space);
-
-/*
  * This operation can block, but only after everything is updated
  */
-int dquot_free_space(struct inode *inode, qsize_t number)
+int __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
 {
         unsigned int cnt;
         char warntype[MAXQUOTAS];
@@ -1612,7 +1571,7 @@ int dquot_free_space(struct inode *inode, qsize_t number)
          * re-enter the quota code and are already holding the mutex */
         if (IS_NOQUOTA(inode)) {
 out_sub:
-                inode_sub_bytes(inode, number);
+                inode_decr_space(inode, number, reserve);
                 return QUOTA_OK;
         }
 
@@ -1627,21 +1586,40 @@ out_sub:
                 if (!inode->i_dquot[cnt])
                         continue;
                 warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
-                dquot_decr_space(inode->i_dquot[cnt], number);
+                if (reserve)
+                        dquot_free_reserved_space(inode->i_dquot[cnt], number);
+                else
+                        dquot_decr_space(inode->i_dquot[cnt], number);
         }
-        inode_sub_bytes(inode, number);
+        inode_decr_space(inode, number, reserve);
         spin_unlock(&dq_data_lock);
-        /* Dirtify all the dquots - this can block when journalling */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                if (inode->i_dquot[cnt])
-                        mark_dquot_dirty(inode->i_dquot[cnt]);
+
+        if (reserve)
+                goto out_unlock;
+        mark_all_dquot_dirty(inode->i_dquot);
+out_unlock:
         flush_warnings(inode->i_dquot, warntype);
         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
         return QUOTA_OK;
 }
+
+int dquot_free_space(struct inode *inode, qsize_t number)
+{
+        return  __dquot_free_space(inode, number, 0);
+}
 EXPORT_SYMBOL(dquot_free_space);
 
 /*
+ * Release reserved quota space
+ */
+void dquot_release_reserved_space(struct inode *inode, qsize_t number)
+{
+        __dquot_free_space(inode, number, 1);
+
+}
+EXPORT_SYMBOL(dquot_release_reserved_space);
+
+/*
  * This operation can block, but only after everything is updated
  */
 int dquot_free_inode(const struct inode *inode, qsize_t number)
@@ -1668,10 +1646,7 @@ int dquot_free_inode(const struct inode *inode, qsize_t number)
                 dquot_decr_inodes(inode->i_dquot[cnt], number);
         }
         spin_unlock(&dq_data_lock);
-        /* Dirtify all the dquots - this can block when journalling */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
-                if (inode->i_dquot[cnt])
-                        mark_dquot_dirty(inode->i_dquot[cnt]);
+        mark_all_dquot_dirty(inode->i_dquot);
         flush_warnings(inode->i_dquot, warntype);
         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
         return QUOTA_OK;
@@ -1679,19 +1654,6 @@ int dquot_free_inode(const struct inode *inode, qsize_t number)
 EXPORT_SYMBOL(dquot_free_inode);
 
 /*
- * call back function, get reserved quota space from underlying fs
- */
-qsize_t dquot_get_reserved_space(struct inode *inode)
-{
-        qsize_t reserved_space = 0;
-
-        if (sb_any_quota_active(inode->i_sb) &&
-            inode->i_sb->dq_op->get_reserved_space)
-                reserved_space = inode->i_sb->dq_op->get_reserved_space(inode);
-        return reserved_space;
-}
-
-/*
  * Transfer the number of inode and blocks from one diskquota to an other.
  *
  * This operation can block, but only after everything is updated
@@ -1734,7 +1696,7 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
         }
         spin_lock(&dq_data_lock);
         cur_space = inode_get_bytes(inode);
-        rsv_space = dquot_get_reserved_space(inode);
+        rsv_space = inode_get_rsv_space(inode);
         space = cur_space + rsv_space;
         /* Build the transfer_from list and check the limits */
         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
@@ -1778,25 +1740,18 @@ int dquot_transfer(struct inode *inode, struct iattr *iattr)
         spin_unlock(&dq_data_lock);
         up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
 
-        /* Dirtify all the dquots - this can block when journalling */
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
-                if (transfer_from[cnt])
-                        mark_dquot_dirty(transfer_from[cnt]);
-                if (transfer_to[cnt]) {
-                        mark_dquot_dirty(transfer_to[cnt]);
-                        /* The reference we got is transferred to the inode */
-                        transfer_to[cnt] = NULL;
-                }
-        }
+        mark_all_dquot_dirty(transfer_from);
+        mark_all_dquot_dirty(transfer_to);
+        /* The reference we got is transferred to the inode */
+        for (cnt = 0; cnt < MAXQUOTAS; cnt++)
+                transfer_to[cnt] = NULL;
 warn_put_all:
         flush_warnings(transfer_to, warntype_to);
         flush_warnings(transfer_from, warntype_from_inodes);
         flush_warnings(transfer_from, warntype_from_space);
 put_all:
-        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
-                dqput(transfer_from[cnt]);
-                dqput(transfer_to[cnt]);
-        }
+        dqput_all(transfer_from);
+        dqput_all(transfer_to);
         return ret;
 over_quota:
         spin_unlock(&dq_data_lock);
@@ -2233,7 +2188,9 @@ int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
         struct dentry *dentry;
         int error;
 
+        mutex_lock(&sb->s_root->d_inode->i_mutex);
         dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
+        mutex_unlock(&sb->s_root->d_inode->i_mutex);
         if (IS_ERR(dentry))
                 return PTR_ERR(dentry);
 
@@ -2473,100 +2430,89 @@ const struct quotactl_ops vfs_quotactl_ops = {
 
 static ctl_table fs_dqstats_table[] = {
         {
-                .ctl_name       = FS_DQ_LOOKUPS,
                 .procname       = "lookups",
                 .data           = &dqstats.lookups,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_DROPS,
                 .procname       = "drops",
                 .data           = &dqstats.drops,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_READS,
                 .procname       = "reads",
                 .data           = &dqstats.reads,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_WRITES,
                 .procname       = "writes",
                 .data           = &dqstats.writes,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_CACHE_HITS,
                 .procname       = "cache_hits",
                 .data           = &dqstats.cache_hits,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_ALLOCATED,
                 .procname       = "allocated_dquots",
                 .data           = &dqstats.allocated_dquots,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_FREE,
                 .procname       = "free_dquots",
                 .data           = &dqstats.free_dquots,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
         {
-                .ctl_name       = FS_DQ_SYNCS,
                 .procname       = "syncs",
                 .data           = &dqstats.syncs,
                 .maxlen         = sizeof(int),
                 .mode           = 0444,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
 #ifdef CONFIG_PRINT_QUOTA_WARNING
         {
-                .ctl_name       = FS_DQ_WARNINGS,
                 .procname       = "warnings",
                 .data           = &flag_print_warnings,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = proc_dointvec,
         },
 #endif
-        { .ctl_name = 0 },
+        { },
 };
 
 static ctl_table fs_table[] = {
         {
-                .ctl_name       = FS_DQSTATS,
                 .procname       = "quota",
                 .mode           = 0555,
                 .child          = fs_dqstats_table,
         },
-        { .ctl_name = 0 },
+        { },
 };
 
 static ctl_table sys_table[] = {
         {
-                .ctl_name       = CTL_FS,
                 .procname       = "fs",
                 .mode           = 0555,
                 .child          = fs_table,
         },
-        { .ctl_name = 0 },
+        { },
 };
 
 static int __init dquot_init(void)
@@ -2607,12 +2553,6 @@ static int __init dquot_init(void)
 
         register_shrinker(&dqcache_shrinker);
 
-#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
-        if (genl_register_family(&quota_genl_family) != 0)
-                printk(KERN_ERR
-                       "VFS: Failed to create quota netlink interface.\n");
-#endif
-
         return 0;
 }
 module_init(dquot_init);
diff --git a/fs/quota/quota.c b/fs/quota/quota.c
index 95c5b42384b2..ee91e2756950 100644
--- a/fs/quota/quota.c
+++ b/fs/quota/quota.c
@@ -18,6 +18,8 @@
 #include <linux/capability.h>
 #include <linux/quotaops.h>
 #include <linux/types.h>
+#include <net/netlink.h>
+#include <net/genetlink.h>
 
 /* Check validity of generic quotactl commands */
 static int generic_quotactl_valid(struct super_block *sb, int type, int cmd,
@@ -525,3 +527,94 @@ asmlinkage long sys32_quotactl(unsigned int cmd, const char __user *special,
         return ret;
 }
 #endif
+
+
+#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
+
+/* Netlink family structure for quota */
+static struct genl_family quota_genl_family = {
+        .id = GENL_ID_GENERATE,
+        .hdrsize = 0,
+        .name = "VFS_DQUOT",
+        .version = 1,
+        .maxattr = QUOTA_NL_A_MAX,
+};
+
+/**
+ * quota_send_warning - Send warning to userspace about exceeded quota
+ * @type: The quota type: USRQQUOTA, GRPQUOTA,...
+ * @id: The user or group id of the quota that was exceeded
+ * @dev: The device on which the fs is mounted (sb->s_dev)
+ * @warntype: The type of the warning: QUOTA_NL_...
+ *
+ * This can be used by filesystems (including those which don't use
+ * dquot) to send a message to userspace relating to quota limits.
+ *
+ */
+
+void quota_send_warning(short type, unsigned int id, dev_t dev,
+                        const char warntype)
+{
+        static atomic_t seq;
+        struct sk_buff *skb;
+        void *msg_head;
+        int ret;
+        int msg_size = 4 * nla_total_size(sizeof(u32)) +
+                       2 * nla_total_size(sizeof(u64));
+
+        /* We have to allocate using GFP_NOFS as we are called from a
+         * filesystem performing write and thus further recursion into
+         * the fs to free some data could cause deadlocks. */
+        skb = genlmsg_new(msg_size, GFP_NOFS);
+        if (!skb) {
+                printk(KERN_ERR
+                  "VFS: Not enough memory to send quota warning.\n");
+                return;
+        }
+        msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq),
+                        &quota_genl_family, 0, QUOTA_NL_C_WARNING);
+        if (!msg_head) {
+                printk(KERN_ERR
+                  "VFS: Cannot store netlink header in quota warning.\n");
+                goto err_out;
+        }
+        ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, type);
+        if (ret)
+                goto attr_err_out;
+        ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, id);
+        if (ret)
+                goto attr_err_out;
+        ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
+        if (ret)
+                goto attr_err_out;
+        ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, MAJOR(dev));
+        if (ret)
+                goto attr_err_out;
+        ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, MINOR(dev));
+        if (ret)
+                goto attr_err_out;
+        ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid());
+        if (ret)
+                goto attr_err_out;
+        genlmsg_end(skb, msg_head);
+
+        genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS);
+        return;
+attr_err_out:
+        printk(KERN_ERR "VFS: Not enough space to compose quota message!\n");
+err_out:
+        kfree_skb(skb);
+}
+EXPORT_SYMBOL(quota_send_warning);
+
+static int __init quota_init(void)
+{
+        if (genl_register_family(&quota_genl_family) != 0)
+                printk(KERN_ERR
+                       "VFS: Failed to create quota netlink interface.\n");
+        return 0;
+};
+
+module_init(quota_init);
+#endif
+
diff --git a/fs/quota/quota_v1.c b/fs/quota/quota_v1.c
index 0edcf42b1778..2ae757e9c008 100644
--- a/fs/quota/quota_v1.c
+++ b/fs/quota/quota_v1.c
@@ -204,7 +204,7 @@ out:
         return ret;
 }
 
-static struct quota_format_ops v1_format_ops = {
+static const struct quota_format_ops v1_format_ops = {
         .check_quota_file       = v1_check_quota_file,
         .read_file_info         = v1_read_file_info,
         .write_file_info        = v1_write_file_info,
diff --git a/fs/quota/quota_v2.c b/fs/quota/quota_v2.c
index a5475fb1ae44..e3da02f4986f 100644
--- a/fs/quota/quota_v2.c
+++ b/fs/quota/quota_v2.c
@@ -23,14 +23,23 @@ MODULE_LICENSE("GPL");
 
 #define __QUOTA_V2_PARANOIA
 
-static void v2_mem2diskdqb(void *dp, struct dquot *dquot);
-static void v2_disk2memdqb(struct dquot *dquot, void *dp);
-static int v2_is_id(void *dp, struct dquot *dquot);
-
-static struct qtree_fmt_operations v2_qtree_ops = {
-        .mem2disk_dqblk = v2_mem2diskdqb,
-        .disk2mem_dqblk = v2_disk2memdqb,
-        .is_id = v2_is_id,
+static void v2r0_mem2diskdqb(void *dp, struct dquot *dquot);
+static void v2r0_disk2memdqb(struct dquot *dquot, void *dp);
+static int v2r0_is_id(void *dp, struct dquot *dquot);
+static void v2r1_mem2diskdqb(void *dp, struct dquot *dquot);
+static void v2r1_disk2memdqb(struct dquot *dquot, void *dp);
+static int v2r1_is_id(void *dp, struct dquot *dquot);
+
+static struct qtree_fmt_operations v2r0_qtree_ops = {
+        .mem2disk_dqblk = v2r0_mem2diskdqb,
+        .disk2mem_dqblk = v2r0_disk2memdqb,
+        .is_id = v2r0_is_id,
+};
+
+static struct qtree_fmt_operations v2r1_qtree_ops = {
+        .mem2disk_dqblk = v2r1_mem2diskdqb,
+        .disk2mem_dqblk = v2r1_disk2memdqb,
+        .is_id = v2r1_is_id,
 };
 
 #define QUOTABLOCK_BITS 10
@@ -46,23 +55,33 @@ static inline qsize_t v2_qbtos(qsize_t blocks)
         return blocks << QUOTABLOCK_BITS;
 }
 
+static int v2_read_header(struct super_block *sb, int type,
+                          struct v2_disk_dqheader *dqhead)
+{
+        ssize_t size;
+
+        size = sb->s_op->quota_read(sb, type, (char *)dqhead,
+                                    sizeof(struct v2_disk_dqheader), 0);
+        if (size != sizeof(struct v2_disk_dqheader)) {
+                printk(KERN_WARNING "quota_v2: Failed header read:"
+                       " expected=%zd got=%zd\n",
+                        sizeof(struct v2_disk_dqheader), size);
+                return 0;
+        }
+        return 1;
+}
+
 /* Check whether given file is really vfsv0 quotafile */
 static int v2_check_quota_file(struct super_block *sb, int type)
 {
         struct v2_disk_dqheader dqhead;
-        ssize_t size;
         static const uint quota_magics[] = V2_INITQMAGICS;
         static const uint quota_versions[] = V2_INITQVERSIONS;
  
-        size = sb->s_op->quota_read(sb, type, (char *)&dqhead,
-                                    sizeof(struct v2_disk_dqheader), 0);
-        if (size != sizeof(struct v2_disk_dqheader)) {
-                printk("quota_v2: failed read expected=%zd got=%zd\n",
-                        sizeof(struct v2_disk_dqheader), size);
+        if (!v2_read_header(sb, type, &dqhead))
                 return 0;
-        }
         if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type] ||
-            le32_to_cpu(dqhead.dqh_version) != quota_versions[type])
+            le32_to_cpu(dqhead.dqh_version) > quota_versions[type])
                 return 0;
         return 1;
 }
@@ -71,14 +90,23 @@ static int v2_check_quota_file(struct super_block *sb, int type)
 static int v2_read_file_info(struct super_block *sb, int type)
 {
         struct v2_disk_dqinfo dinfo;
+        struct v2_disk_dqheader dqhead;
         struct mem_dqinfo *info = sb_dqinfo(sb, type);
         struct qtree_mem_dqinfo *qinfo;
         ssize_t size;
+        unsigned int version;
+
+        if (!v2_read_header(sb, type, &dqhead))
+                return -1;
+        version = le32_to_cpu(dqhead.dqh_version);
+        if ((info->dqi_fmt_id == QFMT_VFS_V0 && version != 0) ||
+            (info->dqi_fmt_id == QFMT_VFS_V1 && version != 1))
+                return -1;
 
         size = sb->s_op->quota_read(sb, type, (char *)&dinfo,
                sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
         if (size != sizeof(struct v2_disk_dqinfo)) {
-                printk(KERN_WARNING "Can't read info structure on device %s.\n",
+                printk(KERN_WARNING "quota_v2: Can't read info structure on device %s.\n",
                         sb->s_id);
                 return -1;
         }
@@ -89,9 +117,15 @@ static int v2_read_file_info(struct super_block *sb, int type)
                 return -1;
         }
         qinfo = info->dqi_priv;
-        /* limits are stored as unsigned 32-bit data */
-        info->dqi_maxblimit = 0xffffffff;
-        info->dqi_maxilimit = 0xffffffff;
+        if (version == 0) {
+                /* limits are stored as unsigned 32-bit data */
+                info->dqi_maxblimit = 0xffffffff;
+                info->dqi_maxilimit = 0xffffffff;
+        } else {
+                /* used space is stored as unsigned 64-bit value */
+                info->dqi_maxblimit = 0xffffffffffffffffULL;    /* 2^64-1 */
+                info->dqi_maxilimit = 0xffffffffffffffffULL;
+        }
         info->dqi_bgrace = le32_to_cpu(dinfo.dqi_bgrace);
         info->dqi_igrace = le32_to_cpu(dinfo.dqi_igrace);
         info->dqi_flags = le32_to_cpu(dinfo.dqi_flags);
@@ -103,8 +137,13 @@ static int v2_read_file_info(struct super_block *sb, int type)
         qinfo->dqi_blocksize_bits = V2_DQBLKSIZE_BITS;
         qinfo->dqi_usable_bs = 1 << V2_DQBLKSIZE_BITS;
         qinfo->dqi_qtree_depth = qtree_depth(qinfo);
-        qinfo->dqi_entry_size = sizeof(struct v2_disk_dqblk);
-        qinfo->dqi_ops = &v2_qtree_ops;
+        if (version == 0) {
+                qinfo->dqi_entry_size = sizeof(struct v2r0_disk_dqblk);
+                qinfo->dqi_ops = &v2r0_qtree_ops;
+        } else {
+                qinfo->dqi_entry_size = sizeof(struct v2r1_disk_dqblk);
+                qinfo->dqi_ops = &v2r1_qtree_ops;
+        }
         return 0;
 }
 
@@ -135,9 +174,9 @@ static int v2_write_file_info(struct super_block *sb, int type)
         return 0;
 }
 
-static void v2_disk2memdqb(struct dquot *dquot, void *dp)
+static void v2r0_disk2memdqb(struct dquot *dquot, void *dp)
 {
-        struct v2_disk_dqblk *d = dp, empty;
+        struct v2r0_disk_dqblk *d = dp, empty;
         struct mem_dqblk *m = &dquot->dq_dqb;
 
         m->dqb_ihardlimit = le32_to_cpu(d->dqb_ihardlimit);
@@ -149,15 +188,15 @@ static void v2_disk2memdqb(struct dquot *dquot, void *dp)
         m->dqb_curspace = le64_to_cpu(d->dqb_curspace);
         m->dqb_btime = le64_to_cpu(d->dqb_btime);
         /* We need to escape back all-zero structure */
-        memset(&empty, 0, sizeof(struct v2_disk_dqblk));
+        memset(&empty, 0, sizeof(struct v2r0_disk_dqblk));
         empty.dqb_itime = cpu_to_le64(1);
-        if (!memcmp(&empty, dp, sizeof(struct v2_disk_dqblk)))
+        if (!memcmp(&empty, dp, sizeof(struct v2r0_disk_dqblk)))
                 m->dqb_itime = 0;
 }
 
-static void v2_mem2diskdqb(void *dp, struct dquot *dquot)
+static void v2r0_mem2diskdqb(void *dp, struct dquot *dquot)
 {
-        struct v2_disk_dqblk *d = dp;
+        struct v2r0_disk_dqblk *d = dp;
         struct mem_dqblk *m = &dquot->dq_dqb;
         struct qtree_mem_dqinfo *info =
                         sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
@@ -175,9 +214,60 @@ static void v2_mem2diskdqb(void *dp, struct dquot *dquot)
                 d->dqb_itime = cpu_to_le64(1);
 }
 
-static int v2_is_id(void *dp, struct dquot *dquot)
+static int v2r0_is_id(void *dp, struct dquot *dquot)
 {
-        struct v2_disk_dqblk *d = dp;
+        struct v2r0_disk_dqblk *d = dp;
+        struct qtree_mem_dqinfo *info =
+                        sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
+
+        if (qtree_entry_unused(info, dp))
+                return 0;
+        return le32_to_cpu(d->dqb_id) == dquot->dq_id;
+}
+
+static void v2r1_disk2memdqb(struct dquot *dquot, void *dp)
+{
+        struct v2r1_disk_dqblk *d = dp, empty;
+        struct mem_dqblk *m = &dquot->dq_dqb;
+
+        m->dqb_ihardlimit = le64_to_cpu(d->dqb_ihardlimit);
+        m->dqb_isoftlimit = le64_to_cpu(d->dqb_isoftlimit);
+        m->dqb_curinodes = le64_to_cpu(d->dqb_curinodes);
+        m->dqb_itime = le64_to_cpu(d->dqb_itime);
+        m->dqb_bhardlimit = v2_qbtos(le64_to_cpu(d->dqb_bhardlimit));
+        m->dqb_bsoftlimit = v2_qbtos(le64_to_cpu(d->dqb_bsoftlimit));
+        m->dqb_curspace = le64_to_cpu(d->dqb_curspace);
+        m->dqb_btime = le64_to_cpu(d->dqb_btime);
+        /* We need to escape back all-zero structure */
+        memset(&empty, 0, sizeof(struct v2r1_disk_dqblk));
+        empty.dqb_itime = cpu_to_le64(1);
+        if (!memcmp(&empty, dp, sizeof(struct v2r1_disk_dqblk)))
+                m->dqb_itime = 0;
+}
+
+static void v2r1_mem2diskdqb(void *dp, struct dquot *dquot)
+{
+        struct v2r1_disk_dqblk *d = dp;
+        struct mem_dqblk *m = &dquot->dq_dqb;
+        struct qtree_mem_dqinfo *info =
+                        sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
+
+        d->dqb_ihardlimit = cpu_to_le64(m->dqb_ihardlimit);
+        d->dqb_isoftlimit = cpu_to_le64(m->dqb_isoftlimit);
+        d->dqb_curinodes = cpu_to_le64(m->dqb_curinodes);
+        d->dqb_itime = cpu_to_le64(m->dqb_itime);
+        d->dqb_bhardlimit = cpu_to_le64(v2_stoqb(m->dqb_bhardlimit));
+        d->dqb_bsoftlimit = cpu_to_le64(v2_stoqb(m->dqb_bsoftlimit));
+        d->dqb_curspace = cpu_to_le64(m->dqb_curspace);
+        d->dqb_btime = cpu_to_le64(m->dqb_btime);
+        d->dqb_id = cpu_to_le32(dquot->dq_id);
+        if (qtree_entry_unused(info, dp))
+                d->dqb_itime = cpu_to_le64(1);
+}
+
+static int v2r1_is_id(void *dp, struct dquot *dquot)
+{
+        struct v2r1_disk_dqblk *d = dp;
         struct qtree_mem_dqinfo *info =
                         sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
 
@@ -207,7 +297,7 @@ static int v2_free_file_info(struct super_block *sb, int type)
         return 0;
 }
 
-static struct quota_format_ops v2_format_ops = {
+static const struct quota_format_ops v2_format_ops = {
         .check_quota_file       = v2_check_quota_file,
         .read_file_info         = v2_read_file_info,
         .write_file_info        = v2_write_file_info,
@@ -217,20 +307,32 @@ static struct quota_format_ops v2_format_ops = {
         .release_dqblk          = v2_release_dquot,
 };
 
-static struct quota_format_type v2_quota_format = {
+static struct quota_format_type v2r0_quota_format = {
         .qf_fmt_id      = QFMT_VFS_V0,
         .qf_ops         = &v2_format_ops,
         .qf_owner       = THIS_MODULE
 };
 
+static struct quota_format_type v2r1_quota_format = {
+        .qf_fmt_id      = QFMT_VFS_V1,
+        .qf_ops         = &v2_format_ops,
+        .qf_owner       = THIS_MODULE
+};
+
 static int __init init_v2_quota_format(void)
 {
-        return register_quota_format(&v2_quota_format);
+        int ret;
+
+        ret = register_quota_format(&v2r0_quota_format);
+        if (ret)
+                return ret;
+        return register_quota_format(&v2r1_quota_format);
 }
 
 static void __exit exit_v2_quota_format(void)
 {
-        unregister_quota_format(&v2_quota_format);
+        unregister_quota_format(&v2r0_quota_format);
+        unregister_quota_format(&v2r1_quota_format);
 }
 
 module_init(init_v2_quota_format);
diff --git a/fs/quota/quotaio_v2.h b/fs/quota/quotaio_v2.h
index 530fe580685c..f1966b42c2fd 100644
--- a/fs/quota/quotaio_v2.h
+++ b/fs/quota/quotaio_v2.h
@@ -17,8 +17,8 @@
 }
 
 #define V2_INITQVERSIONS {\
-        0,              /* USRQUOTA */\
-        0               /* GRPQUOTA */\
+        1,              /* USRQUOTA */\
+        1               /* GRPQUOTA */\
 }
 
 /* First generic header */
@@ -32,7 +32,7 @@ struct v2_disk_dqheader {
  * (as it appears on disk) - the file is a radix tree whose leaves point
  * to blocks of these structures.
  */
-struct v2_disk_dqblk {
+struct v2r0_disk_dqblk {
         __le32 dqb_id;          /* id this quota applies to */
         __le32 dqb_ihardlimit;  /* absolute limit on allocated inodes */
         __le32 dqb_isoftlimit;  /* preferred inode limit */
@@ -44,6 +44,19 @@ struct v2_disk_dqblk {
         __le64 dqb_itime;       /* time limit for excessive inode use */
 };
 
+struct v2r1_disk_dqblk {
+        __le32 dqb_id;          /* id this quota applies to */
+        __le32 dqb_pad;
+        __le64 dqb_ihardlimit;  /* absolute limit on allocated inodes */
+        __le64 dqb_isoftlimit;  /* preferred inode limit */
+        __le64 dqb_curinodes;   /* current # allocated inodes */
+        __le64 dqb_bhardlimit;  /* absolute limit on disk space (in QUOTABLOCK_SIZE) */
+        __le64 dqb_bsoftlimit;  /* preferred limit on disk space (in QUOTABLOCK_SIZE) */
+        __le64 dqb_curspace;    /* current space occupied (in bytes) */
+        __le64 dqb_btime;       /* time limit for excessive disk use */
+        __le64 dqb_itime;       /* time limit for excessive inode use */
+};
+
 /* Header with type and version specific information */
 struct v2_disk_dqinfo {
         __le32 dqi_bgrace;      /* Time before block soft limit becomes hard limit */