Hello!
We are in need of large (above 4 TB) block quota limits, but it seems like XFS filesystem
(having its own quota implementation) is the only available fs that supports them. Currently
ext3 supports up to 8 TB of data and forthcoming ext4 will support even more.
Linux kernel has two implementations of quota format modules:
quota_v1 (with QFMT_VFS_OLD id)
quota_v2 (with QFMT_VFS_V0 id)
Either uses 32-bit data types to store quota limits on disk
(see struct v1_disk_dqblk and struct v2_disk_dqblk). Block quota limits
are stored in 1kb units (QUOTABLOCK_SIZE constant) which gives
the largest possible quota limit of (2^32-1)*2^10 bytes ~ 4 TB.
In-memory quota entries representation suffers from the same 4 TB
limitation (see struct mem_dqblk).
The patch below adds a separate quota_v3 module which deals with 64-bit data to solve the problem
(another possible approach is to merge the code into quota_v2 module to reuse some amount of the code -
this won't reuse a lot because there're too many references to disk_dqblk structures and dependent constants).
Could you comment on the patch and the idea behind it in general?
Thank you.
Andrew.
---
fs/Kconfig | 7
fs/Makefile | 1
fs/ext3/super.c | 12
fs/quota_v1.c | 50 ++-
fs/quota_v2.c | 45 +-
fs/quota_v3.c | 739 +++++++++++++++++++++++++++++++++++++++++++++
fs/reiserfs/super.c | 2
include/linux/dqblk_v3.h | 26 +
include/linux/quota.h | 23 -
include/linux/quotaio_v3.h | 81 ++++
10 files changed, 952 insertions(+), 34 deletions(-)
---
diff -rNpu quota.orig/fs/Kconfig quota/fs/Kconfig
--- quota.orig/fs/Kconfig 2008-01-24 14:33:56.000000000 +0300
+++ quota/fs/Kconfig 2008-02-27 16:49:56.108413855 +0300
@@ -488,6 +488,13 @@ config QFMT_V2
This quota format allows using quotas with 32-bit UIDs/GIDs. If you
need this functionality say Y here.
+config QFMT_V3
+ tristate "Quota format v3 support"
+ depends on QUOTA
+ help
+ This quota format allows using quotas with 32-bit UIDs/GIDs and 64-bit
+ limits. If you need this functionality say Y here.
+
config QUOTACTL
bool
depends on XFS_QUOTA || QUOTA
diff -rNpu quota.orig/fs/Makefile quota/fs/Makefile
--- quota.orig/fs/Makefile 2008-01-24 14:33:54.000000000 +0300
+++ quota/fs/Makefile 2008-02-27 16:50:13.436477156 +0300
@@ -40,6 +40,7 @@ obj-$(CONFIG_GENERIC_ACL) += generic_acl
obj-$(CONFIG_QUOTA) += dquot.o
obj-$(CONFIG_QFMT_V1) += quota_v1.o
obj-$(CONFIG_QFMT_V2) += quota_v2.o
+obj-$(CONFIG_QFMT_V3) += quota_v3.o
obj-$(CONFIG_QUOTACTL) += quota.o
obj-$(CONFIG_DMAPI) += dmapi/
diff -rNpu quota.orig/fs/quota_v1.c quota/fs/quota_v1.c
--- quota.orig/fs/quota_v1.c 2006-03-20 08:53:29.000000000 +0300
+++ quota/fs/quota_v1.c 2008-02-29 19:15:23.325159161 +0300
@@ -25,8 +25,16 @@ static void v1_disk2mem_dqblk(struct mem
m->dqb_btime = d->dqb_btime;
}
-static void v1_mem2disk_dqblk(struct v1_disk_dqblk *d, struct mem_dqblk *m)
+static int v1_mem2disk_dqblk(struct v1_disk_dqblk *d, struct mem_dqblk *m)
{
+ __u32 typelimit = ~((__u32)0);
+
+ if (m->dqb_ihardlimit > typelimit ||
+ m->dqb_isoftlimit > typelimit ||
+ m->dqb_bhardlimit > typelimit ||
+ m->dqb_bsoftlimit > typelimit)
+ return -EINVAL;
+
d->dqb_ihardlimit = m->dqb_ihardlimit;
d->dqb_isoftlimit = m->dqb_isoftlimit;
d->dqb_curinodes = m->dqb_curinodes;
@@ -35,6 +43,8 @@ static void v1_mem2disk_dqblk(struct v1_
d->dqb_curblocks = toqb(m->dqb_curspace);
d->dqb_itime = m->dqb_itime;
d->dqb_btime = m->dqb_btime;
+
+ return 0;
}
static int v1_read_dqblk(struct dquot *dquot)
@@ -64,7 +74,10 @@ static int v1_commit_dqblk(struct dquot
ssize_t ret;
struct v1_disk_dqblk dqblk;
- v1_mem2disk_dqblk(&dqblk, &dquot->dq_dqb);
+ ret = v1_mem2disk_dqblk(&dqblk, &dquot->dq_dqb);
+ if (ret < 0)
+ return ret;
+
if (dquot->dq_id == 0) {
dqblk.dqb_btime = sb_dqopt(dquot->dq_sb)->info[type].dqi_bgrace;
dqblk.dqb_itime = sb_dqopt(dquot->dq_sb)->info[type].dqi_igrace;
@@ -88,7 +101,7 @@ out:
return ret;
}
-/* Magics of new quota format */
+/* Magics of vfsv0 quota format */
#define V2_INITQMAGICS {\
0xd9c01f11, /* USRQUOTA */\
0xd9c01927 /* GRPQUOTA */\
@@ -100,15 +113,29 @@ struct v2_disk_dqheader {
__le32 dqh_version; /* File version */
};
+/* Magics of vfsv1 quota format */
+#define V3_INITQMAGICS {\
+ 0xd9c01f11, /* USRQUOTA */\
+ 0xd9c01927 /* GRPQUOTA */\
+}
+
+/* Header of new quota format */
+struct v3_disk_dqheader {
+ __le32 dqh_magic; /* Magic number identifying file */
+ __le32 dqh_version; /* File version */
+};
+
static int v1_check_quota_file(struct super_block *sb, int type)
{
struct inode *inode = sb_dqopt(sb)->files[type];
ulong blocks;
size_t off;
- struct v2_disk_dqheader dqhead;
- ssize_t size;
+ struct v2_disk_dqheader dqhead_v2;
+ struct v3_disk_dqheader dqhead_v3;
+ ssize_t size_v2, size_v3;
loff_t isize;
- static const uint quota_magics[] = V2_INITQMAGICS;
+ static const uint quota_magics_v2[] = V2_INITQMAGICS,
+ quota_magics_v3[] = V3_INITQMAGICS;
isize = i_size_read(inode);
if (!isize)
@@ -118,10 +145,15 @@ static int v1_check_quota_file(struct su
if ((blocks % sizeof(struct v1_disk_dqblk) * BLOCK_SIZE + off) % sizeof(struct v1_disk_dqblk))
return 0;
/* Doublecheck whether we didn't get file with new format - with old quotactl() this could happen */
- size = sb->s_op->quota_read(sb, type, (char *)&dqhead, sizeof(struct v2_disk_dqheader), 0);
- if (size != sizeof(struct v2_disk_dqheader))
+ size_v2 = sb->s_op->quota_read(sb, type, (char *)&dqhead_v2,
+ sizeof(struct v2_disk_dqheader), 0);
+ size_v3 = sb->s_op->quota_read(sb, type, (char *)&dqhead_v3,
+ sizeof(struct v3_disk_dqheader), 0);
+ if (size_v2 != sizeof(struct v2_disk_dqheader) &&
+ size_v3 != sizeof(struct v3_disk_dqheader))
return 1; /* Probably not new format */
- if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type])
+ if (le32_to_cpu(dqhead_v2.dqh_magic) != quota_magics_v2[type] &&
+ le32_to_cpu(dqhead_v3.dqh_magic) != quota_magics_v3[type])
return 1; /* Definitely not new format */
printk(KERN_INFO "VFS: %s: Refusing to turn on old quota format on given file. It probably contains newer quota format.\n", sb->s_id);
return 0; /* Seems like a new format file -> refuse it */
diff -rNpu quota.orig/fs/quota_v2.c quota/fs/quota_v2.c
--- quota.orig/fs/quota_v2.c 2006-03-20 08:53:29.000000000 +0300
+++ quota/fs/quota_v2.c 2008-02-28 10:37:31.067602129 +0300
@@ -106,17 +106,27 @@ static void disk2memdqb(struct mem_dqblk
m->dqb_btime = le64_to_cpu(d->dqb_btime);
}
-static void mem2diskdqb(struct v2_disk_dqblk *d, struct mem_dqblk *m, qid_t id)
+static int mem2diskdqb(struct v2_disk_dqblk *d, struct mem_dqblk *m, qid_t id)
{
- d->dqb_ihardlimit = cpu_to_le32(m->dqb_ihardlimit);
- d->dqb_isoftlimit = cpu_to_le32(m->dqb_isoftlimit);
- d->dqb_curinodes = cpu_to_le32(m->dqb_curinodes);
+ __u32 typelimit = ~((__u32)0);
+
+ if (m->dqb_ihardlimit > typelimit ||
+ m->dqb_isoftlimit > typelimit ||
+ m->dqb_bhardlimit > typelimit ||
+ m->dqb_bsoftlimit > typelimit)
+ return -EINVAL;
+
+ d->dqb_ihardlimit = cpu_to_le32((__u32)m->dqb_ihardlimit);
+ d->dqb_isoftlimit = cpu_to_le32((__u32)m->dqb_isoftlimit);
+ d->dqb_curinodes = cpu_to_le32((__u32)m->dqb_curinodes);
d->dqb_itime = cpu_to_le64(m->dqb_itime);
- d->dqb_bhardlimit = cpu_to_le32(m->dqb_bhardlimit);
- d->dqb_bsoftlimit = cpu_to_le32(m->dqb_bsoftlimit);
+ d->dqb_bhardlimit = cpu_to_le32((__u32)m->dqb_bhardlimit);
+ d->dqb_bsoftlimit = cpu_to_le32((__u32)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(id);
+
+ return 0;
}
static dqbuf_t getdqbuf(void)
@@ -394,14 +404,12 @@ static int v2_write_dquot(struct dquot *
ssize_t ret;
struct v2_disk_dqblk ddquot, empty;
- /* dq_off is guarded by dqio_sem */
- if (!dquot->dq_off)
- if ((ret = dq_insert_tree(dquot)) < 0) {
- printk(KERN_ERR "VFS: Error %zd occurred while creating quota.\n", ret);
- return ret;
- }
spin_lock(&dq_data_lock);
- mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id);
+ ret = mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id);
+ if (ret < 0) {
+ spin_unlock(&dq_data_lock);
+ return ret;
+ }
/* Argh... We may need to write structure full of zeroes but that would be
* treated as an empty place by the rest of the code. Format change would
* be definitely cleaner but the problems probably are not worth it */
@@ -409,6 +417,17 @@ static int v2_write_dquot(struct dquot *
if (!memcmp(&empty, &ddquot, sizeof(struct v2_disk_dqblk)))
ddquot.dqb_itime = cpu_to_le64(1);
spin_unlock(&dq_data_lock);
+
+ /* dq_off is guarded by dqio_sem */
+ if (!dquot->dq_off) {
+ ret = dq_insert_tree(dquot);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Error %zd occurred "
+ "while creating quota.\n", ret);
+ return ret;
+ }
+ }
+
ret = dquot->dq_sb->s_op->quota_write(dquot->dq_sb, type,
(char *)&ddquot, sizeof(struct v2_disk_dqblk), dquot->dq_off);
if (ret != sizeof(struct v2_disk_dqblk)) {
diff -rNpu quota.orig/fs/quota_v3.c quota/fs/quota_v3.c
--- quota.orig/fs/quota_v3.c 1970-01-01 03:00:00.000000000 +0300
+++ quota/fs/quota_v3.c 2008-02-28 10:55:05.981528558 +0300
@@ -0,0 +1,739 @@
+/*
+ * vfsv1 quota IO operations on file
+ *
+ * adds support for quota limits above 4 TB
+ *
+ * based on quota_v3.c by Jan Kara
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/dqblk_v3.h>
+#include <linux/quotaio_v3.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <asm/byteorder.h>
+
+MODULE_DESCRIPTION("Quota format v3 support");
+MODULE_LICENSE("GPL");
+
+#define __QUOTA_V3_PARANOIA
+
+typedef char *dqbuf_t;
+
+#define GETIDINDEX(id, depth) (((id) >> ((V3_DQTREEDEPTH-(depth)-1)*8)) & 0xff)
+#define GETENTRIES(buf) ((struct v3_disk_dqblk *) \
+ (((char *)buf)+sizeof(struct v3_disk_dqdbheader)))
+
+/* Check whether given file is really vfsv1 quotafile */
+static int v3_check_quota_file(struct super_block *sb, int type)
+{
+ struct v3_disk_dqheader dqhead;
+ ssize_t size;
+ static const uint quota_magics[] = V3_INITQMAGICS;
+ static const uint quota_versions[] = V3_INITQVERSIONS;
+
+ size = sb->s_op->quota_read(sb, type, (char *)&dqhead,
+ sizeof(struct v3_disk_dqheader), 0);
+ if (size != sizeof(struct v3_disk_dqheader)) {
+ printk(KERN_WARNING "quota_v3: failed read expected=%zd, "
+ "got=%zd\n", sizeof(struct v3_disk_dqheader), size);
+ return 0;
+ }
+ if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type] ||
+ le32_to_cpu(dqhead.dqh_version) != quota_versions[type])
+ return 0;
+ return 1;
+}
+
+/* Read information header from quota file */
+static int v3_read_file_info(struct super_block *sb, int type)
+{
+ struct v3_disk_dqinfo dinfo;
+ struct mem_dqinfo *info = sb_dqopt(sb)->info+type;
+ ssize_t size;
+
+ size = sb->s_op->quota_read(sb, type, (char *)&dinfo,
+ sizeof(struct v3_disk_dqinfo), V3_DQINFOOFF);
+ if (size != sizeof(struct v3_disk_dqinfo)) {
+ printk(KERN_WARNING "Can't read info structure on device %s.\n",
+ sb->s_id);
+ return -1;
+ }
+ 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);
+ info->u.v3_i.dqi_blocks = le32_to_cpu(dinfo.dqi_blocks);
+ info->u.v3_i.dqi_free_blk = le32_to_cpu(dinfo.dqi_free_blk);
+ info->u.v3_i.dqi_free_entry = le32_to_cpu(dinfo.dqi_free_entry);
+ return 0;
+}
+
+/* Write information header to quota file */
+static int v3_write_file_info(struct super_block *sb, int type)
+{
+ struct v3_disk_dqinfo dinfo;
+ struct mem_dqinfo *info = sb_dqopt(sb)->info+type;
+ ssize_t size;
+
+ spin_lock(&dq_data_lock);
+ info->dqi_flags &= ~DQF_INFO_DIRTY;
+ dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace);
+ dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace);
+ dinfo.dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK);
+ spin_unlock(&dq_data_lock);
+ dinfo.dqi_blocks = cpu_to_le32(info->u.v3_i.dqi_blocks);
+ dinfo.dqi_free_blk = cpu_to_le32(info->u.v3_i.dqi_free_blk);
+ dinfo.dqi_free_entry = cpu_to_le32(info->u.v3_i.dqi_free_entry);
+ size = sb->s_op->quota_write(sb, type, (char *)&dinfo,
+ sizeof(struct v3_disk_dqinfo), V3_DQINFOOFF);
+ if (size != sizeof(struct v3_disk_dqinfo)) {
+ printk(KERN_WARNING "Can't write info structure "
+ "on device %s.\n", sb->s_id);
+ return -1;
+ }
+ return 0;
+}
+
+static void disk2memdqb(struct mem_dqblk *m, struct v3_disk_dqblk *d)
+{
+ 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 = le64_to_cpu(d->dqb_bhardlimit);
+ m->dqb_bsoftlimit = le64_to_cpu(d->dqb_bsoftlimit);
+ m->dqb_curspace = le64_to_cpu(d->dqb_curspace);
+ m->dqb_btime = le64_to_cpu(d->dqb_btime);
+}
+
+static void mem2diskdqb(struct v3_disk_dqblk *d, struct mem_dqblk *m, qid_t id)
+{
+ 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(m->dqb_bhardlimit);
+ d->dqb_bsoftlimit = cpu_to_le64(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(id);
+}
+
+static dqbuf_t getdqbuf(void)
+{
+ dqbuf_t buf = kmalloc(V3_DQBLKSIZE, GFP_NOFS);
+ if (!buf)
+ printk(KERN_WARNING "Not enough memory for quota buffers.\n");
+ return buf;
+}
+
+static inline void freedqbuf(dqbuf_t buf)
+{
+ kfree(buf);
+}
+
+static inline ssize_t read_blk(struct super_block *sb, int type,
+ uint blk, dqbuf_t buf)
+{
+ memset(buf, 0, V3_DQBLKSIZE);
+ return sb->s_op->quota_read(sb, type, (char *)buf,
+ V3_DQBLKSIZE, blk << V3_DQBLKSIZE_BITS);
+}
+
+static inline ssize_t write_blk(struct super_block *sb, int type,
+ uint blk, dqbuf_t buf)
+{
+ return sb->s_op->quota_write(sb, type, (char *)buf,
+ V3_DQBLKSIZE, blk << V3_DQBLKSIZE_BITS);
+}
+
+/* Remove empty block from list and return it */
+static int get_free_dqblk(struct super_block *sb, int type)
+{
+ dqbuf_t buf = getdqbuf();
+ struct mem_dqinfo *info = sb_dqinfo(sb, type);
+ struct v3_disk_dqdbheader *dh = (struct v3_disk_dqdbheader *)buf;
+ int ret, blk;
+
+ if (!buf)
+ return -ENOMEM;
+ if (info->u.v3_i.dqi_free_blk) {
+ blk = info->u.v3_i.dqi_free_blk;
+ ret = read_blk(sb, type, blk, buf);
+ if (ret < 0)
+ goto out_buf;
+ info->u.v3_i.dqi_free_blk = le32_to_cpu(dh->dqdh_next_free);
+ } else {
+ memset(buf, 0, V3_DQBLKSIZE);
+ /* Assure block allocation... */
+ ret = write_blk(sb, type, info->u.v3_i.dqi_blocks, buf);
+ if (ret < 0)
+ goto out_buf;
+ blk = info->u.v3_i.dqi_blocks++;
+ }
+ mark_info_dirty(sb, type);
+ ret = blk;
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Insert empty block to the list */
+static int put_free_dqblk(struct super_block *sb, int type,
+ dqbuf_t buf, uint blk)
+{
+ struct mem_dqinfo *info = sb_dqinfo(sb, type);
+ struct v3_disk_dqdbheader *dh = (struct v3_disk_dqdbheader *)buf;
+ int err;
+
+ dh->dqdh_next_free = cpu_to_le32(info->u.v3_i.dqi_free_blk);
+ dh->dqdh_prev_free = cpu_to_le32(0);
+ dh->dqdh_entries = cpu_to_le16(0);
+ info->u.v3_i.dqi_free_blk = blk;
+ mark_info_dirty(sb, type);
+ /* Some strange block. We had better leave it... */
+ err = write_blk(sb, type, blk, buf);
+ if (err < 0)
+ return err;
+ return 0;
+}
+
+/* Remove given block from the list of blocks with free entries */
+static int remove_free_dqentry(struct super_block *sb,
+ int type, dqbuf_t buf, uint blk)
+{
+ dqbuf_t tmpbuf = getdqbuf();
+ struct mem_dqinfo *info = sb_dqinfo(sb, type);
+ struct v3_disk_dqdbheader *dh = (struct v3_disk_dqdbheader *)buf;
+ uint nextblk = le32_to_cpu(dh->dqdh_next_free),
+ prevblk = le32_to_cpu(dh->dqdh_prev_free);
+ int err;
+
+ if (!tmpbuf)
+ return -ENOMEM;
+ if (nextblk) {
+ err = read_blk(sb, type, nextblk, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ ((struct v3_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = dh->dqdh_prev_free;
+ err = write_blk(sb, type, nextblk, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ }
+ if (prevblk) {
+ err = read_blk(sb, type, prevblk, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ ((struct v3_disk_dqdbheader *)tmpbuf)->dqdh_next_free = dh->dqdh_next_free;
+ err = write_blk(sb, type, prevblk, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ } else {
+ info->u.v3_i.dqi_free_entry = nextblk;
+ mark_info_dirty(sb, type);
+ }
+ freedqbuf(tmpbuf);
+ dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0);
+ /* No matter whether write succeeds block is out of list */
+ if (write_blk(sb, type, blk, buf) < 0)
+ printk(KERN_ERR "VFS: Can't write block (%u) "
+ "with free entries.\n", blk);
+ return 0;
+out_buf:
+ freedqbuf(tmpbuf);
+ return err;
+}
+
+/* Insert given block to the beginning of list with free entries */
+static int insert_free_dqentry(struct super_block *sb,
+ int type, dqbuf_t buf, uint blk)
+{
+ dqbuf_t tmpbuf = getdqbuf();
+ struct mem_dqinfo *info = sb_dqinfo(sb, type);
+ struct v3_disk_dqdbheader *dh = (struct v3_disk_dqdbheader *)buf;
+ int err;
+
+ if (!tmpbuf)
+ return -ENOMEM;
+ dh->dqdh_next_free = cpu_to_le32(info->u.v3_i.dqi_free_entry);
+ dh->dqdh_prev_free = cpu_to_le32(0);
+ err = write_blk(sb, type, blk, buf);
+ if (err < 0)
+ goto out_buf;
+ if (info->u.v3_i.dqi_free_entry) {
+ err = read_blk(sb, type, info->u.v3_i.dqi_free_entry, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ ((struct v3_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = cpu_to_le32(blk);
+ err = write_blk(sb, type, info->u.v3_i.dqi_free_entry, tmpbuf);
+ if (err < 0)
+ goto out_buf;
+ }
+ freedqbuf(tmpbuf);
+ info->u.v3_i.dqi_free_entry = blk;
+ mark_info_dirty(sb, type);
+ return 0;
+out_buf:
+ freedqbuf(tmpbuf);
+ return err;
+}
+
+/* Find space for dquot */
+static uint find_free_dqentry(struct dquot *dquot, int *err)
+{
+ struct super_block *sb = dquot->dq_sb;
+ struct mem_dqinfo *info = sb_dqopt(sb)->info+dquot->dq_type;
+ uint blk, i;
+ struct v3_disk_dqdbheader *dh;
+ struct v3_disk_dqblk *ddquot;
+ struct v3_disk_dqblk fakedquot;
+ dqbuf_t buf;
+
+ *err = 0;
+ buf = getdqbuf();
+ if (!buf) {
+ *err = -ENOMEM;
+ return 0;
+ }
+ dh = (struct v3_disk_dqdbheader *)buf;
+ ddquot = GETENTRIES(buf);
+ if (info->u.v3_i.dqi_free_entry) {
+ blk = info->u.v3_i.dqi_free_entry;
+ *err = read_blk(sb, dquot->dq_type, blk, buf);
+ if (*err < 0)
+ goto out_buf;
+ } else {
+ blk = get_free_dqblk(sb, dquot->dq_type);
+ if ((int)blk < 0) {
+ *err = blk;
+ freedqbuf(buf);
+ return 0;
+ }
+ memset(buf, 0, V3_DQBLKSIZE);
+ /* This is enough as block is already zeroed */
+ /* and entry list is empty... */
+ info->u.v3_i.dqi_free_entry = blk;
+ mark_info_dirty(sb, dquot->dq_type);
+ }
+ if (le16_to_cpu(dh->dqdh_entries)+1 >= V3_DQSTRINBLK) {
+ *err = remove_free_dqentry(sb, dquot->dq_type, buf, blk);
+ if (*err < 0) {
+ printk(KERN_ERR "VFS: find_free_dqentry(): Can't "
+ "remove block (%u) from entry free list.\n",
+ blk);
+ goto out_buf;
+ }
+ }
+ dh->dqdh_entries = cpu_to_le16(le16_to_cpu(dh->dqdh_entries)+1);
+ memset(&fakedquot, 0, sizeof(struct v3_disk_dqblk));
+ /* Find free structure in block */
+ for (i = 0; i < V3_DQSTRINBLK && memcmp(&fakedquot, ddquot+i,
+ sizeof(struct v3_disk_dqblk)); i++);
+#ifdef __QUOTA_V3_PARANOIA
+ if (i == V3_DQSTRINBLK) {
+ printk(KERN_ERR "VFS: find_free_dqentry(): "
+ "Data block full but it shouldn't.\n");
+ *err = -EIO;
+ goto out_buf;
+ }
+#endif
+ *err = write_blk(sb, dquot->dq_type, blk, buf);
+ if (*err < 0) {
+ printk(KERN_ERR "VFS: find_free_dqentry(): "
+ "Can't write quota data block %u.\n", blk);
+ goto out_buf;
+ }
+ dquot->dq_off = (blk<<V3_DQBLKSIZE_BITS)+
+ sizeof(struct v3_disk_dqdbheader)+
+ i*sizeof(struct v3_disk_dqblk);
+ freedqbuf(buf);
+ return blk;
+out_buf:
+ freedqbuf(buf);
+ return 0;
+}
+
+/* Insert reference to structure into the trie */
+static int do_insert_tree(struct dquot *dquot, uint *treeblk, int depth)
+{
+ struct super_block *sb = dquot->dq_sb;
+ dqbuf_t buf;
+ int ret = 0, newson = 0, newact = 0;
+ __le32 *ref;
+ uint newblk;
+
+ buf = getdqbuf();
+ if (!buf)
+ return -ENOMEM;
+ if (!*treeblk) {
+ ret = get_free_dqblk(sb, dquot->dq_type);
+ if (ret < 0)
+ goto out_buf;
+ *treeblk = ret;
+ memset(buf, 0, V3_DQBLKSIZE);
+ newact = 1;
+ } else {
+ ret = read_blk(sb, dquot->dq_type, *treeblk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't read tree quota "
+ "block %u.\n", *treeblk);
+ goto out_buf;
+ }
+ }
+ ref = (__le32 *)buf;
+ newblk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
+ if (!newblk)
+ newson = 1;
+ if (depth == V3_DQTREEDEPTH-1) {
+#ifdef __QUOTA_V3_PARANOIA
+ if (newblk) {
+ printk(KERN_ERR "VFS: Inserting already present "
+ "quota entry (block %u).\n",
+ le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]));
+ ret = -EIO;
+ goto out_buf;
+ }
+#endif
+ newblk = find_free_dqentry(dquot, &ret);
+ } else
+ ret = do_insert_tree(dquot, &newblk, depth+1);
+ if (newson && ret >= 0) {
+ ref[GETIDINDEX(dquot->dq_id, depth)] = cpu_to_le32(newblk);
+ ret = write_blk(sb, dquot->dq_type, *treeblk, buf);
+ } else if (newact && ret < 0)
+ put_free_dqblk(sb, dquot->dq_type, buf, *treeblk);
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Wrapper for inserting quota structure into tree */
+static inline int dq_insert_tree(struct dquot *dquot)
+{
+ int tmp = V3_DQTREEOFF;
+ return do_insert_tree(dquot, &tmp, 0);
+}
+
+/*
+ * We don't have to be afraid of deadlocks
+ * as we never have quotas on quota files...
+ */
+static int v3_write_dquot(struct dquot *dquot)
+{
+ int type = dquot->dq_type;
+ ssize_t ret;
+ struct v3_disk_dqblk ddquot, empty;
+
+ /* dq_off is guarded by dqio_sem */
+ if (!dquot->dq_off) {
+ ret = dq_insert_tree(dquot);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Error %zd occurred "
+ "while creating quota.\n", ret);
+ return ret;
+ }
+ }
+ spin_lock(&dq_data_lock);
+ mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id);
+ /* Argh... We may need to write structure full of zeroes but that would
+ * be treated as an empty place by the rest of the code. Format change
+ * would be definitely cleaner but the problems are not worth it */
+ memset(&empty, 0, sizeof(struct v3_disk_dqblk));
+ if (!memcmp(&empty, &ddquot, sizeof(struct v3_disk_dqblk)))
+ ddquot.dqb_itime = cpu_to_le64(1);
+ spin_unlock(&dq_data_lock);
+ ret = dquot->dq_sb->s_op->quota_write(dquot->dq_sb, type,
+ (char *)&ddquot, sizeof(struct v3_disk_dqblk), dquot->dq_off);
+ if (ret != sizeof(struct v3_disk_dqblk)) {
+ printk(KERN_WARNING "VFS: dquota write failed on dev %s\n",
+ dquot->dq_sb->s_id);
+ if (ret >= 0)
+ ret = -ENOSPC;
+ } else
+ ret = 0;
+ dqstats.writes++;
+
+ return ret;
+}
+
+/* Free dquot entry in data block */
+static int free_dqentry(struct dquot *dquot, uint blk)
+{
+ struct super_block *sb = dquot->dq_sb;
+ int type = dquot->dq_type;
+ struct v3_disk_dqdbheader *dh;
+ dqbuf_t buf = getdqbuf();
+ int ret = 0;
+
+ if (!buf)
+ return -ENOMEM;
+ if (dquot->dq_off >> V3_DQBLKSIZE_BITS != blk) {
+ printk(KERN_ERR "VFS: Quota structure has offset to other "
+ "block (%u) than it should (%u).\n", blk,
+ (uint)(dquot->dq_off >> V3_DQBLKSIZE_BITS));
+ goto out_buf;
+ }
+ ret = read_blk(sb, type, blk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't read quota data block %u\n", blk);
+ goto out_buf;
+ }
+ dh = (struct v3_disk_dqdbheader *)buf;
+ dh->dqdh_entries = cpu_to_le16(le16_to_cpu(dh->dqdh_entries)-1);
+ if (!le16_to_cpu(dh->dqdh_entries)) {
+ ret = remove_free_dqentry(sb, type, buf, blk);
+ if (ret < 0 ||
+ (ret = put_free_dqblk(sb, type, buf, blk)) < 0) {
+ printk(KERN_ERR "VFS: Can't move quota data block (%u) "
+ "to free list.\n", blk);
+ goto out_buf;
+ }
+ } else {
+ memset(buf+(dquot->dq_off & ((1 << V3_DQBLKSIZE_BITS)-1)), 0,
+ sizeof(struct v3_disk_dqblk));
+ if (le16_to_cpu(dh->dqdh_entries) == V3_DQSTRINBLK-1) {
+ /* Insert will write block itself */
+ ret = insert_free_dqentry(sb, type, buf, blk);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't insert quota data "
+ "block (%u) to free entry list.\n", blk);
+ goto out_buf;
+ }
+ } else
+ ret = write_blk(sb, type, blk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't write quota data "
+ "block %u\n", blk);
+ goto out_buf;
+ }
+ }
+ dquot->dq_off = 0; /* Quota is now unattached */
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Remove reference to dquot from tree */
+static int remove_tree(struct dquot *dquot, uint *blk, int depth)
+{
+ struct super_block *sb = dquot->dq_sb;
+ int type = dquot->dq_type;
+ dqbuf_t buf = getdqbuf();
+ int ret = 0;
+ uint newblk;
+ __le32 *ref = (__le32 *)buf;
+
+ if (!buf)
+ return -ENOMEM;
+ ret = read_blk(sb, type, *blk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't read quota data block %u\n", *blk);
+ goto out_buf;
+ }
+ newblk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
+ if (depth == V3_DQTREEDEPTH-1) {
+ ret = free_dqentry(dquot, newblk);
+ newblk = 0;
+ } else
+ ret = remove_tree(dquot, &newblk, depth+1);
+ if (ret >= 0 && !newblk) {
+ int i;
+ ref[GETIDINDEX(dquot->dq_id, depth)] = cpu_to_le32(0);
+ for (i = 0; i < V3_DQBLKSIZE && !buf[i]; i++);
+ /* Don't put the root block into the free block list */
+ if (i == V3_DQBLKSIZE && *blk != V3_DQTREEOFF) {
+ put_free_dqblk(sb, type, buf, *blk);
+ *blk = 0;
+ } else {
+ ret = write_blk(sb, type, *blk, buf);
+ if (ret < 0)
+ printk(KERN_ERR "VFS: Can't write quota tree "
+ "block %u.\n", *blk);
+ }
+ }
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Delete dquot from tree */
+static int v3_delete_dquot(struct dquot *dquot)
+{
+ uint tmp = V3_DQTREEOFF;
+
+ if (!dquot->dq_off) /* Even not allocated? */
+ return 0;
+ return remove_tree(dquot, &tmp, 0);
+}
+
+/* Find entry in block */
+static loff_t find_block_dqentry(struct dquot *dquot, uint blk)
+{
+ dqbuf_t buf = getdqbuf();
+ loff_t ret = 0;
+ int i;
+ struct v3_disk_dqblk *ddquot = GETENTRIES(buf);
+
+ if (!buf)
+ return -ENOMEM;
+ ret = read_blk(dquot->dq_sb, dquot->dq_type, blk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
+ goto out_buf;
+ }
+ if (dquot->dq_id)
+ for (i = 0; i < V3_DQSTRINBLK &&
+ le32_to_cpu(ddquot[i].dqb_id) != dquot->dq_id; i++);
+ else { /* ID 0 as a bit more complicated searching... */
+ struct v3_disk_dqblk fakedquot;
+
+ memset(&fakedquot, 0, sizeof(struct v3_disk_dqblk));
+ for (i = 0; i < V3_DQSTRINBLK; i++)
+ if (!le32_to_cpu(ddquot[i].dqb_id) &&
+ memcmp(&fakedquot, ddquot+i,
+ sizeof(struct v3_disk_dqblk)))
+ break;
+ }
+ if (i == V3_DQSTRINBLK) {
+ printk(KERN_ERR "VFS: Quota for id %u referenced "
+ "but not present.\n", dquot->dq_id);
+ ret = -EIO;
+ goto out_buf;
+ } else
+ ret = (blk << V3_DQBLKSIZE_BITS) + sizeof(struct
+ v3_disk_dqdbheader) + i * sizeof(struct v3_disk_dqblk);
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Find entry for given id in the tree */
+static loff_t find_tree_dqentry(struct dquot *dquot, uint blk, int depth)
+{
+ dqbuf_t buf = getdqbuf();
+ loff_t ret = 0;
+ __le32 *ref = (__le32 *)buf;
+
+ if (!buf)
+ return -ENOMEM;
+ ret = read_blk(dquot->dq_sb, dquot->dq_type, blk, buf);
+ if (ret < 0) {
+ printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
+ goto out_buf;
+ }
+ ret = 0;
+ blk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
+ if (!blk) /* No reference? */
+ goto out_buf;
+ if (depth < V3_DQTREEDEPTH-1)
+ ret = find_tree_dqentry(dquot, blk, depth+1);
+ else
+ ret = find_block_dqentry(dquot, blk);
+out_buf:
+ freedqbuf(buf);
+ return ret;
+}
+
+/* Find entry for given id in the tree - wrapper function */
+static inline loff_t find_dqentry(struct dquot *dquot)
+{
+ return find_tree_dqentry(dquot, V3_DQTREEOFF, 0);
+}
+
+static int v3_read_dquot(struct dquot *dquot)
+{
+ int type = dquot->dq_type;
+ loff_t offset;
+ struct v3_disk_dqblk ddquot, empty;
+ int ret = 0;
+
+#ifdef __QUOTA_V3_PARANOIA
+ /* Invalidated quota? */
+ if (!dquot->dq_sb || !sb_dqopt(dquot->dq_sb)->files[type]) {
+ printk(KERN_ERR "VFS: Quota invalidated while reading!\n");
+ return -EIO;
+ }
+#endif
+ offset = find_dqentry(dquot);
+ if (offset <= 0) {
+ if (offset < 0)
+ printk(KERN_ERR "VFS: Can't read quota "
+ "structure for id %u.\n", dquot->dq_id);
+ dquot->dq_off = 0;
+ set_bit(DQ_FAKE_B, &dquot->dq_flags);
+ memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
+ ret = offset;
+ } else {
+ dquot->dq_off = offset;
+ ret = dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type,
+ (char *)&ddquot, sizeof(struct v3_disk_dqblk), offset);
+ if (ret != sizeof(struct v3_disk_dqblk)) {
+ if (ret >= 0)
+ ret = -EIO;
+ printk(KERN_ERR "VFS: Error while reading quota "
+ "structure for id %u.\n", dquot->dq_id);
+ memset(&ddquot, 0, sizeof(struct v3_disk_dqblk));
+ } else {
+ ret = 0;
+ /* We need to escape back all-zero structure */
+ memset(&empty, 0, sizeof(struct v3_disk_dqblk));
+ empty.dqb_itime = cpu_to_le64(1);
+ if (!memcmp(&empty, &ddquot,
+ sizeof(struct v3_disk_dqblk)))
+ ddquot.dqb_itime = 0;
+ }
+ disk2memdqb(&dquot->dq_dqb, &ddquot);
+ if (!dquot->dq_dqb.dqb_bhardlimit &&
+ !dquot->dq_dqb.dqb_bsoftlimit &&
+ !dquot->dq_dqb.dqb_ihardlimit &&
+ !dquot->dq_dqb.dqb_isoftlimit)
+ set_bit(DQ_FAKE_B, &dquot->dq_flags);
+ }
+ dqstats.reads++;
+
+ return ret;
+}
+
+/* Check whether dquot should not be deleted. We know we are
+ * the only one operating on dquot (thanks to dq_lock) */
+static int v3_release_dquot(struct dquot *dquot)
+{
+ if (test_bit(DQ_FAKE_B, &dquot->dq_flags) &&
+ !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace))
+ return v3_delete_dquot(dquot);
+ return 0;
+}
+
+static struct quota_format_ops v3_format_ops = {
+ .check_quota_file = v3_check_quota_file,
+ .read_file_info = v3_read_file_info,
+ .write_file_info = v3_write_file_info,
+ .free_file_info = NULL,
+ .read_dqblk = v3_read_dquot,
+ .commit_dqblk = v3_write_dquot,
+ .release_dqblk = v3_release_dquot,
+};
+
+static struct quota_format_type v3_quota_format = {
+ .qf_fmt_id = QFMT_VFS_V1,
+ .qf_ops = &v3_format_ops,
+ .qf_owner = THIS_MODULE
+};
+
+static int __init init_v3_quota_format(void)
+{
+ return register_quota_format(&v3_quota_format);
+}
+
+static void __exit exit_v3_quota_format(void)
+{
+ unregister_quota_format(&v3_quota_format);
+}
+
+module_init(init_v3_quota_format);
+module_exit(exit_v3_quota_format);
diff -rNpu quota.orig/include/linux/dqblk_v3.h quota/include/linux/dqblk_v3.h
--- quota.orig/include/linux/dqblk_v3.h 1970-01-01 03:00:00.000000000 +0300
+++ quota/include/linux/dqblk_v3.h 2008-02-27 16:31:45.964283988 +0300
@@ -0,0 +1,26 @@
+/*
+ * Definitions of structures for vfsv1 quota format
+ */
+
+#ifndef _LINUX_DQBLK_V3_H
+#define _LINUX_DQBLK_V3_H
+
+#include <linux/types.h>
+
+/* id numbers of quota format */
+#define QFMT_VFS_V1 3
+
+/* Numbers of blocks needed for updates */
+#define V3_INIT_ALLOC 4
+#define V3_INIT_REWRITE 2
+#define V3_DEL_ALLOC 0
+#define V3_DEL_REWRITE 6
+
+/* Inmemory copy of version specific information */
+struct v3_mem_dqinfo {
+ unsigned int dqi_blocks;
+ unsigned int dqi_free_blk;
+ unsigned int dqi_free_entry;
+};
+
+#endif /* _LINUX_DQBLK_V3_H */
diff -rNpu quota.orig/include/linux/quota.h quota/include/linux/quota.h
--- quota.orig/include/linux/quota.h 2006-03-20 08:53:29.000000000 +0300
+++ quota/include/linux/quota.h 2008-02-27 16:30:15.306620367 +0300
@@ -136,24 +136,27 @@ struct if_dqinfo {
#include <linux/dqblk_xfs.h>
#include <linux/dqblk_v1.h>
#include <linux/dqblk_v2.h>
+#include <linux/dqblk_v3.h>
/* Maximal numbers of writes for quota operation (insert/delete/update)
* (over VFS all formats) */
-#define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, V2_INIT_ALLOC)
-#define DQUOT_INIT_REWRITE max(V1_INIT_REWRITE, V2_INIT_REWRITE)
-#define DQUOT_DEL_ALLOC max(V1_DEL_ALLOC, V2_DEL_ALLOC)
-#define DQUOT_DEL_REWRITE max(V1_DEL_REWRITE, V2_DEL_REWRITE)
+#define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, max(V2_INIT_ALLOC, V3_INIT_ALLOC))
+#define DQUOT_INIT_REWRITE max(max(V2_INIT_REWRITE, V3_INIT_REWRITE),\
+ V1_INIT_REWRITE)
+#define DQUOT_DEL_ALLOC max(V1_DEL_ALLOC, max(V2_DEL_ALLOC, V3_DEL_ALLOC))
+#define DQUOT_DEL_REWRITE max(max(V2_DEL_REWRITE, V3_DEL_REWRITE),\
+ V1_DEL_REWRITE)
/*
* Data for one user/group kept in memory
*/
struct mem_dqblk {
- __u32 dqb_bhardlimit; /* absolute limit on disk blks alloc */
- __u32 dqb_bsoftlimit; /* preferred limit on disk blks */
+ qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */
+ qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */
qsize_t dqb_curspace; /* current used space */
- __u32 dqb_ihardlimit; /* absolute limit on allocated inodes */
- __u32 dqb_isoftlimit; /* preferred inode limit */
- __u32 dqb_curinodes; /* current # allocated inodes */
+ qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */
+ qsize_t dqb_isoftlimit; /* preferred inode limit */
+ qsize_t dqb_curinodes; /* current # allocated inodes */
time_t dqb_btime; /* time limit for excessive disk use */
time_t dqb_itime; /* time limit for excessive inode use */
};
@@ -172,6 +173,7 @@ struct mem_dqinfo {
union {
struct v1_mem_dqinfo v1_i;
struct v2_mem_dqinfo v2_i;
+ struct v3_mem_dqinfo v3_i;
} u;
};
@@ -315,6 +317,7 @@ struct quota_module_name {
#define INIT_QUOTA_MODULE_NAMES {\
{QFMT_VFS_OLD, "quota_v1"},\
{QFMT_VFS_V0, "quota_v2"},\
+ {QFMT_VFS_V1, "quota_v3"},\
{0, NULL}}
#else
diff -rNpu quota.orig/include/linux/quotaio_v3.h quota/include/linux/quotaio_v3.h
--- quota.orig/include/linux/quotaio_v3.h 1970-01-01 03:00:00.000000000 +0300
+++ quota/include/linux/quotaio_v3.h 2008-02-29 19:16:26.281092724 +0300
@@ -0,0 +1,81 @@
+/*
+ * Definitions of structures for vfsv1quota format
+ */
+
+#ifndef _LINUX_QUOTAIO_V3_H
+#define _LINUX_QUOTAIO_V3_H
+
+#include <linux/types.h>
+#include <linux/quota.h>
+
+/*
+ * Definitions of magics and versions of current quota files
+ */
+#define V3_INITQMAGICS {\
+ 0xd9c01f11, /* USRQUOTA */\
+ 0xd9c01927 /* GRPQUOTA */\
+}
+
+#define V3_INITQVERSIONS {\
+ 1, /* USRQUOTA */\
+ 1 /* GRPQUOTA */\
+}
+
+/*
+ * The following structure defines the format of the disk quota file
+ * (as it appears on disk) - the file is a radix tree whose leaves point
+ * to blocks of these structures.
+ */
+struct v3_disk_dqblk {
+ __le32 dqb_id; /* id this quota applies to */
+ __le32 dqb_padding; /* padding field */
+ __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 blocks) */
+ __le64 dqb_bsoftlimit; /* preferred limit on disk space (in blocks) */
+ __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 */
+};
+
+/*
+ * Here are header structures as written on disk and their in-memory copies
+ */
+/* First generic header */
+struct v3_disk_dqheader {
+ __le32 dqh_magic; /* Magic number identifying file */
+ __le32 dqh_version; /* File version */
+};
+
+/* Header with type and version specific information */
+struct v3_disk_dqinfo {
+ __le32 dqi_bgrace; /* Time before block soft limit becomes hard */
+ __le32 dqi_igrace; /* Time before inode soft limit becomes hard */
+ __le32 dqi_flags; /* Flags for quotafile (DQF_*) */
+ __le32 dqi_blocks; /* Number of blocks in file */
+ __le32 dqi_free_blk; /* Number of first free block in the list */
+ __le32 dqi_free_entry; /* Number of block with a free entry */
+};
+
+/*
+ * Structure of header of block with quota structures. It is padded to
+ * 16 bytes so there will be space for exactly 21 quota-entries in a block
+ */
+struct v3_disk_dqdbheader {
+ __le32 dqdh_next_free; /* Number of next block with free entry */
+ __le32 dqdh_prev_free; /* Number of previous block with free entry */
+ __le16 dqdh_entries; /* Number of valid entries in block */
+ __le16 dqdh_pad1;
+ __le32 dqdh_pad2;
+};
+
+#define V3_DQINFOOFF sizeof(struct v3_disk_dqheader)
+#define V3_DQBLKSIZE_BITS 10
+#define V3_DQBLKSIZE (1 << V3_DQBLKSIZE_BITS)
+#define V3_DQTREEOFF 1 /* Offset of tree in file in blocks */
+#define V3_DQTREEDEPTH 4 /* Depth of quota tree */
+#define V3_DQSTRINBLK ((V3_DQBLKSIZE - sizeof(struct v3_disk_dqdbheader)) / \
+ sizeof(struct v3_disk_dqblk))
+
+#endif /* _LINUX_QUOTAIO_V3_H */
diff -rNpu quota.orig/fs/ext3/super.c quota/fs/ext3/super.c
--- quota.orig/fs/ext3/super.c 2008-01-24 14:33:52.000000000 +0300
+++ quota/fs/ext3/super.c 2008-03-01 17:50:26.000000000 +0300
@@ -522,7 +522,8 @@ static inline void ext3_show_quota_optio
if (sbi->s_jquota_fmt)
seq_printf(seq, ",jqfmt=%s",
- (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
+ (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold":
+ ((sbi->s_jquota_fmt == QFMT_VFS_V0) ? "vfsv0" : "vfsv1"));
if (sbi->s_qf_names[USRQUOTA])
seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
@@ -673,7 +674,7 @@ enum {
Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
- Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
+ Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
- Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
+ Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota, Opt_noquota,
Opt_grpquota
};
@@ -719,6 +720,7 @@ static match_table_t tokens = {
{Opt_grpjquota, "grpjquota=%s"},
{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
+ {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
{Opt_grpquota, "grpquota"},
{Opt_noquota, "noquota"},
{Opt_quota, "quota"},
@@ -990,6 +992,9 @@ clear_qf_name:
case Opt_jqfmt_vfsv0:
sbi->s_jquota_fmt = QFMT_VFS_V0;
break;
+ case Opt_jqfmt_vfsv1:
+ sbi->s_jquota_fmt = QFMT_VFS_V1;
+ break;
case Opt_quota:
case Opt_usrquota:
set_opt(sbi->s_mount_opt, QUOTA);
@@ -1019,6 +1024,7 @@ clear_qf_name:
case Opt_offgrpjquota:
case Opt_jqfmt_vfsold:
case Opt_jqfmt_vfsv0:
+ case Opt_jqfmt_vfsv1:
printk(KERN_ERR
"EXT3-fs: journalled quota options not "
"supported.\n");
diff -rNpu quota.orig/fs/reiserfs/super.c quota/fs/reiserfs/super.c
--- quota.orig/fs/reiserfs/super.c 2008-01-24 14:33:52.000000000 +0300
+++ quota/fs/reiserfs/super.c 2008-03-01 17:51:12.000000000 +0300
@@ -1021,6 +1021,8 @@ static int reiserfs_parse_options(struct
REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_OLD;
else if (!strcmp(arg, "vfsv0"))
REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V0;
+ else if (!strcmp(arg, "vfsv1"))
+ REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V1;
else {
reiserfs_warning(s,
"reiserfs_parse_options: unknown quota format specified.");
Signed-off-by: Andrew Perepechko <andrew.perepechko@xxxxxxx>
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
