quota: Implement quota format with 64-bit space and inode limits

So far the maximum quota space limit was 4TB. Apparently this isn't enough
for Lustre guys anymore. So implement new quota format which raises block
limits to 2^64 bytes. Also store number of inodes and inode limits in
64-bit variables as 2^32 files isn't that insanely high anymore.

The first version of the patch has been developed by Andrew Perepechko
<Andrew.Perepechko@Sun.COM>.

CC: Andrew.Perepechko@Sun.COM
Signed-off-by: Jan Kara <jack@suse.cz>

diff --git a/fs/quota/Kconfig b/fs/quota/Kconfig
index 353e78a..efc02eb 100644 (file)
--- a/fs/quota/Kconfig
+++ b/fs/quota/Kconfig
@@ -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/quota_v2.c b/fs/quota/quota_v2.c
index 01f25ea..3dfc23e 100644 (file)
--- 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,20 @@ 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 0;
+       version = le32_to_cpu(dqhead.dqh_version);
 
        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 +114,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 = 0xffffffffffffffff;       /* 2^64-1 */
+               info->dqi_maxilimit = 0xffffffffffffffff;
+       }
        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 +134,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 +171,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 +185,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 +211,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 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 v2_disk_dqblk *d = dp;
+       struct v2r1_disk_dqblk *d = dp;
        struct qtree_mem_dqinfo *info =
                        sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
 
@@ -217,20 +304,32 @@ static const 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 530fe58..f1966b4 100644 (file)
--- 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 */

diff --git a/include/linux/quota.h b/include/linux/quota.h
index 7db3a00..e70e621 100644 (file)
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -74,6 +74,7 @@
 #define        QFMT_VFS_OLD 1
 #define        QFMT_VFS_V0 2
 #define QFMT_OCFS2 3
+#define        QFMT_VFS_V1 4
 
 /* Size of block in which space limits are passed through the quota
  * interface */