On Sun 16-03-08 14:21:17, Andrew Perepechko wrote:
> Introduce 64-bit quota limits support with QFMT_VFS_V0.
>
> This patch is incremental to quota-do-not-allow-setting-of-quota-limits-to-too-high-values.patch included in -mm tree.
>
> Signed-off-by: Andrew Perepechko <andrew.perepechko@xxxxxxx>
Nice, I like the patch. Do you have patches for quota tools so that we
can also create files in the format with the new revision? I ask mainly
because I'd like to test it a bit before submitting ;).
Honza
>
> ---
>
> fs/quota_v2.c | 263 ++++++++++++++++++++++++++++++++-------------
> include/linux/dqblk_v2.h | 1
> include/linux/quota.h | 10 -
> include/linux/quotaio_v2.h | 34 ++++-
> 4 files changed, 222 insertions(+), 86 deletions(-)
>
> diff -rNpu linux.2.6.24.3.old/fs/quota_v2.c linux-2.6.24.3/fs/quota_v2.c
> --- linux.2.6.24.3.old/fs/quota_v2.c 2008-03-14 15:34:16.000000000 +0300
> +++ linux-2.6.24.3/fs/quota_v2.c 2008-03-16 13:46:01.000000000 +0300
> @@ -23,26 +23,64 @@ MODULE_LICENSE("GPL");
> typedef char *dqbuf_t;
>
> #define GETIDINDEX(id, depth) (((id) >> ((V2_DQTREEDEPTH-(depth)-1)*8)) & 0xff)
> -#define GETENTRIES(buf) ((struct v2_disk_dqblk *)(((char *)buf)+sizeof(struct v2_disk_dqdbheader)))
> +#define GETENTRIES(buf) ((union v2_disk_dqblk *)(((char *)buf) + \
> + sizeof(struct v2_disk_dqdbheader)))
> +#define REV_ASSERT(r) BUG_ON((rev) != 0 && (rev) != 1)
>
> -/* Check whether given file is really vfsv0 quotafile */
> -static int v2_check_quota_file(struct super_block *sb, int type)
> +static const union v2_disk_dqblk emptydquot;
> +static const union v2_disk_dqblk fakedquot[2] = {
> + {.r0 = {.dqb_itime = __constant_cpu_to_le64(1LLU)} },
> + {.r1 = {.dqb_itime = __constant_cpu_to_le64(1LLU)} }
> +};
> +
> +static inline uint v2_dqblksz(uint rev)
> +{
> + uint sz;
> +
> + REV_ASSERT(rev);
> +
> + if (rev == 0)
> + sz = sizeof(struct v2_disk_dqblk_r0);
> + else
> + sz = sizeof(struct v2_disk_dqblk_r1);
> +
> + return sz;
> +}
> +
> +/* Number of quota entries in a block */
> +static inline int v2_dqstrinblk(uint rev)
> +{
> + return (V2_DQBLKSIZE-sizeof(struct v2_disk_dqdbheader))/v2_dqblksz(rev);
> +}
> +
> +/* Get revision of a quota file, -1 if it does not look a quota file */
> +static int v2_quota_file_revision(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;
> + static const uint quota_versions_r0[] = V2_INITQVERSIONS_R0;
> + static const uint quota_versions_r1[] = V2_INITQVERSIONS_R1;
>
> 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);
> - return 0;
> + return -1;
> }
> - if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type] ||
> - le32_to_cpu(dqhead.dqh_version) != quota_versions[type])
> - return 0;
> - return 1;
> + if (le32_to_cpu(dqhead.dqh_magic) == quota_magics[type]) {
> + if (le32_to_cpu(dqhead.dqh_version) == quota_versions_r0[type])
> + return 0;
> + if (le32_to_cpu(dqhead.dqh_version) == quota_versions_r1[type])
> + return 1;
> + }
> + return -1;
> +}
> +
> +/* Check whether given file is really vfsv0 quotafile */
> +static inline int v2_check_quota_file(struct super_block *sb, int type)
> +{
> + return v2_quota_file_revision(sb, type) != -1;
> }
>
> /* Read information header from quota file */
> @@ -51,6 +89,13 @@ static int v2_read_file_info(struct supe
> struct v2_disk_dqinfo dinfo;
> struct mem_dqinfo *info = sb_dqopt(sb)->info+type;
> ssize_t size;
> + int rev;
> +
> + rev = v2_quota_file_revision(sb, type);
> + if (rev < 0) {
> + printk(KERN_WARNING "Second quota file check failed.\n");
> + return -1;
> + }
>
> size = sb->s_op->quota_read(sb, type, (char *)&dinfo,
> sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
> @@ -59,15 +104,22 @@ static int v2_read_file_info(struct supe
> sb->s_id);
> return -1;
> }
> - /* limits are stored as unsigned 32-bit data */
> - info->dqi_maxblimit = 0xffffffff;
> - info->dqi_maxilimit = 0xffffffff;
> 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.v2_i.dqi_blocks = le32_to_cpu(dinfo.dqi_blocks);
> info->u.v2_i.dqi_free_blk = le32_to_cpu(dinfo.dqi_free_blk);
> info->u.v2_i.dqi_free_entry = le32_to_cpu(dinfo.dqi_free_entry);
> +
> + info->u.v2_i.dqi_revision = rev;
> + if (rev == 0) {
> + info->dqi_maxblimit = 0xffffffffULL;
> + info->dqi_maxilimit = 0xffffffffULL;
> + } else {
> + info->dqi_maxblimit = 0xffffffffffffffffULL;
> + info->dqi_maxilimit = 0xffffffffffffffffULL;
> + }
> +
> return 0;
> }
>
> @@ -97,29 +149,61 @@ static int v2_write_file_info(struct sup
> return 0;
> }
>
> -static void disk2memdqb(struct mem_dqblk *m, struct v2_disk_dqblk *d)
> +static void disk2memdqb(struct mem_dqblk *m, union v2_disk_dqblk *d, uint rev)
> {
> - m->dqb_ihardlimit = le32_to_cpu(d->dqb_ihardlimit);
> - m->dqb_isoftlimit = le32_to_cpu(d->dqb_isoftlimit);
> - m->dqb_curinodes = le32_to_cpu(d->dqb_curinodes);
> - m->dqb_itime = le64_to_cpu(d->dqb_itime);
> - m->dqb_bhardlimit = le32_to_cpu(d->dqb_bhardlimit);
> - m->dqb_bsoftlimit = le32_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 v2_disk_dqblk *d, struct mem_dqblk *m, qid_t id)
> -{
> - 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((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);
> + REV_ASSERT(rev);
> +
> + if (rev == 0) {
> + struct v2_disk_dqblk_r0 *ddqblk = &d->r0;
> + m->dqb_ihardlimit = le32_to_cpu(ddqblk->dqb_ihardlimit);
> + m->dqb_isoftlimit = le32_to_cpu(ddqblk->dqb_isoftlimit);
> + m->dqb_curinodes = le32_to_cpu(ddqblk->dqb_curinodes);
> + m->dqb_itime = le64_to_cpu(ddqblk->dqb_itime);
> + m->dqb_bhardlimit = le32_to_cpu(ddqblk->dqb_bhardlimit);
> + m->dqb_bsoftlimit = le32_to_cpu(ddqblk->dqb_bsoftlimit);
> + m->dqb_curspace = le64_to_cpu(ddqblk->dqb_curspace);
> + m->dqb_btime = le64_to_cpu(ddqblk->dqb_btime);
> + } else {
> + struct v2_disk_dqblk_r1 *ddqblk = &d->r1;
> + m->dqb_ihardlimit = le64_to_cpu(ddqblk->dqb_ihardlimit);
> + m->dqb_isoftlimit = le64_to_cpu(ddqblk->dqb_isoftlimit);
> + m->dqb_curinodes = le64_to_cpu(ddqblk->dqb_curinodes);
> + m->dqb_itime = le64_to_cpu(ddqblk->dqb_itime);
> + m->dqb_bhardlimit = le64_to_cpu(ddqblk->dqb_bhardlimit);
> + m->dqb_bsoftlimit = le64_to_cpu(ddqblk->dqb_bsoftlimit);
> + m->dqb_curspace = le64_to_cpu(ddqblk->dqb_curspace);
> + m->dqb_btime = le64_to_cpu(ddqblk->dqb_btime);
> + }
> +}
> +
> +static void mem2diskdqb(union v2_disk_dqblk *d, struct mem_dqblk *m,
> + qid_t id, uint rev)
> +{
> + REV_ASSERT(rev);
> +
> + if (rev == 0) {
> + struct v2_disk_dqblk_r0 *ddqblk = &d->r0;
> + ddqblk->dqb_id = cpu_to_le32(id);
> + ddqblk->dqb_ihardlimit = cpu_to_le32((__u32)m->dqb_ihardlimit);
> + ddqblk->dqb_isoftlimit = cpu_to_le32((__u32)m->dqb_isoftlimit);
> + ddqblk->dqb_curinodes = cpu_to_le32((__u32)m->dqb_curinodes);
> + ddqblk->dqb_itime = cpu_to_le64(m->dqb_itime);
> + ddqblk->dqb_bhardlimit = cpu_to_le32((__u32)m->dqb_bhardlimit);
> + ddqblk->dqb_bsoftlimit = cpu_to_le32((__u32)m->dqb_bsoftlimit);
> + ddqblk->dqb_curspace = cpu_to_le64(m->dqb_curspace);
> + ddqblk->dqb_btime = cpu_to_le64(ddqblk->dqb_btime);
> + } else {
> + struct v2_disk_dqblk_r1 *ddqblk = &d->r1;
> + ddqblk->dqb_id = cpu_to_le32(id);
> + ddqblk->dqb_ihardlimit = cpu_to_le64(m->dqb_ihardlimit);
> + ddqblk->dqb_isoftlimit = cpu_to_le64(m->dqb_isoftlimit);
> + ddqblk->dqb_curinodes = cpu_to_le64(m->dqb_curinodes);
> + ddqblk->dqb_itime = cpu_to_le64(m->dqb_itime);
> + ddqblk->dqb_bhardlimit = cpu_to_le64(m->dqb_bhardlimit);
> + ddqblk->dqb_bsoftlimit = cpu_to_le64(m->dqb_bsoftlimit);
> + ddqblk->dqb_curspace = cpu_to_le64(m->dqb_curspace);
> + ddqblk->dqb_btime = cpu_to_le64(ddqblk->dqb_btime);
> + }
> }
>
> static dqbuf_t getdqbuf(void)
> @@ -271,10 +355,10 @@ static uint find_free_dqentry(struct dqu
> {
> struct super_block *sb = dquot->dq_sb;
> struct mem_dqinfo *info = sb_dqopt(sb)->info+dquot->dq_type;
> - uint blk, i;
> + uint blk, i, rev = info->u.v2_i.dqi_revision;
> + uint dqblksz = v2_dqblksz(rev), dqstrinblk = v2_dqstrinblk(rev);
> struct v2_disk_dqdbheader *dh;
> - struct v2_disk_dqblk *ddquot;
> - struct v2_disk_dqblk fakedquot;
> + union v2_disk_dqblk *ddquot;
> dqbuf_t buf;
>
> *err = 0;
> @@ -301,17 +385,18 @@ static uint find_free_dqentry(struct dqu
> info->u.v2_i.dqi_free_entry = blk;
> mark_info_dirty(sb, dquot->dq_type);
> }
> - if (le16_to_cpu(dh->dqdh_entries)+1 >= V2_DQSTRINBLK) /* Block will be full? */
> + /* Block will be full? */
> + if (le16_to_cpu(dh->dqdh_entries)+1 >= dqstrinblk)
> if ((*err = remove_free_dqentry(sb, dquot->dq_type, buf, blk)) < 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 v2_disk_dqblk));
> /* Find free structure in block */
> - for (i = 0; i < V2_DQSTRINBLK && memcmp(&fakedquot, ddquot+i, sizeof(struct v2_disk_dqblk)); i++);
> + for (i = 0; i < dqstrinblk && memcmp(&emptydquot, ddquot, dqblksz);
> + i++, ddquot++);
> #ifdef __QUOTA_V2_PARANOIA
> - if (i == V2_DQSTRINBLK) {
> + if (i == dqstrinblk) {
> printk(KERN_ERR "VFS: find_free_dqentry(): Data block full but it shouldn't.\n");
> *err = -EIO;
> goto out_buf;
> @@ -321,7 +406,8 @@ static uint find_free_dqentry(struct dqu
> printk(KERN_ERR "VFS: find_free_dqentry(): Can't write quota data block %u.\n", blk);
> goto out_buf;
> }
> - dquot->dq_off = (blk<<V2_DQBLKSIZE_BITS)+sizeof(struct v2_disk_dqdbheader)+i*sizeof(struct v2_disk_dqblk);
> + dquot->dq_off = (blk<<V2_DQBLKSIZE_BITS)+
> + ((char *)ddquot - (char *)buf);
> freedqbuf(buf);
> return blk;
> out_buf:
> @@ -395,7 +481,9 @@ static int v2_write_dquot(struct dquot *
> {
> int type = dquot->dq_type;
> ssize_t ret;
> - struct v2_disk_dqblk ddquot, empty;
> + union v2_disk_dqblk ddquot;
> + uint rev = sb_dqopt(dquot->dq_sb)->info[type].u.v2_i.dqi_revision;
> + uint dqblksz = v2_dqblksz(rev);
>
> /* dq_off is guarded by dqio_mutex */
> if (!dquot->dq_off)
> @@ -404,18 +492,22 @@ static int v2_write_dquot(struct dquot *
> return ret;
> }
> spin_lock(&dq_data_lock);
> - mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id);
> + mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id, rev);
> /* 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 */
> - memset(&empty, 0, sizeof(struct v2_disk_dqblk));
> - if (!memcmp(&empty, &ddquot, sizeof(struct v2_disk_dqblk)))
> - ddquot.dqb_itime = cpu_to_le64(1);
> + if (!memcmp(&emptydquot, &ddquot, dqblksz)) {
> + if (rev == 0)
> + ddquot.r0.dqb_itime = cpu_to_le64(1);
> + else
> + ddquot.r1.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 v2_disk_dqblk), dquot->dq_off);
> - if (ret != sizeof(struct v2_disk_dqblk)) {
> - printk(KERN_WARNING "VFS: dquota write failed on dev %s\n", dquot->dq_sb->s_id);
> + (char *)&ddquot, dqblksz, dquot->dq_off);
> + if (ret != dqblksz) {
> + printk(KERN_WARNING "VFS: dquota write failed on dev %s\n",
> + dquot->dq_sb->s_id);
> if (ret >= 0)
> ret = -ENOSPC;
> }
> @@ -434,6 +526,7 @@ static int free_dqentry(struct dquot *dq
> struct v2_disk_dqdbheader *dh;
> dqbuf_t buf = getdqbuf();
> int ret = 0;
> + uint rev = sb_dqopt(sb)->info[type].u.v2_i.dqi_revision;
>
> if (!buf)
> return -ENOMEM;
> @@ -459,8 +552,8 @@ static int free_dqentry(struct dquot *dq
> }
> else {
> memset(buf+(dquot->dq_off & ((1 << V2_DQBLKSIZE_BITS)-1)), 0,
> - sizeof(struct v2_disk_dqblk));
> - if (le16_to_cpu(dh->dqdh_entries) == V2_DQSTRINBLK-1) {
> + v2_dqblksz(rev));
> + if (le16_to_cpu(dh->dqdh_entries) == v2_dqstrinblk(rev)-1) {
> /* Insert will write block itself */
> if ((ret = insert_free_dqentry(sb, type, buf, blk)) < 0) {
> printk(KERN_ERR "VFS: Can't insert quota data block (%u) to free entry list.\n", blk);
> @@ -532,41 +625,56 @@ static int v2_delete_dquot(struct dquot
> return remove_tree(dquot, &tmp, 0);
> }
>
> +static inline __u32 dqid(union v2_disk_dqblk *ddquot, uint rev)
> +{
> + __u32 dq_id;
> +
> + REV_ASSERT(rev);
> +
> + if (rev == 0)
> + dq_id = le32_to_cpu(ddquot->r0.dqb_id);
> + else
> + dq_id = le32_to_cpu(ddquot->r1.dqb_id);
> +
> + return dq_id;
> +}
> +
> /* 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 v2_disk_dqblk *ddquot = GETENTRIES(buf);
> + union v2_disk_dqblk *ddquot = GETENTRIES(buf);
> + int type = dquot->dq_type;
> + uint rev = sb_dqopt(dquot->dq_sb)->info[type].u.v2_i.dqi_revision;
> + uint dqblksz = v2_dqblksz(rev), dqstrinblk = v2_dqstrinblk(rev);
>
> if (!buf)
> return -ENOMEM;
> - if ((ret = read_blk(dquot->dq_sb, dquot->dq_type, blk, buf)) < 0) {
> +
> + ret = read_blk(dquot->dq_sb, 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 < V2_DQSTRINBLK &&
> - le32_to_cpu(ddquot[i].dqb_id) != dquot->dq_id; i++);
> + for (i = 0; i < dqstrinblk && dqid(ddquot, rev) != dquot->dq_id;
> + i++, ddquot++);
> else { /* ID 0 as a bit more complicated searching... */
> - struct v2_disk_dqblk fakedquot;
> -
> - memset(&fakedquot, 0, sizeof(struct v2_disk_dqblk));
> - for (i = 0; i < V2_DQSTRINBLK; i++)
> - if (!le32_to_cpu(ddquot[i].dqb_id) &&
> - memcmp(&fakedquot, ddquot+i, sizeof(struct v2_disk_dqblk)))
> + for (i = 0; i < dqstrinblk; i++, ddquot++)
> + if (!dqid(ddquot, rev) &&
> + memcmp(&emptydquot, ddquot, dqblksz))
> break;
> }
> - if (i == V2_DQSTRINBLK) {
> + if (i == 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 << V2_DQBLKSIZE_BITS) + sizeof(struct
> - v2_disk_dqdbheader) + i * sizeof(struct v2_disk_dqblk);
> + ret = (blk << V2_DQBLKSIZE_BITS)+((char *)ddquot-(char *)buf);
> out_buf:
> freedqbuf(buf);
> return ret;
> @@ -608,7 +716,7 @@ static int v2_read_dquot(struct dquot *d
> {
> int type = dquot->dq_type;
> loff_t offset;
> - struct v2_disk_dqblk ddquot, empty;
> + union v2_disk_dqblk ddquot;
> int ret = 0;
>
> #ifdef __QUOTA_V2_PARANOIA
> @@ -629,25 +737,30 @@ static int v2_read_dquot(struct dquot *d
> ret = offset;
> }
> else {
> + uint rev = sb_dqopt(dquot->dq_sb)->info[type].u.v2_i.
> + dqi_revision;
> + uint dqblksz = v2_dqblksz(rev);
> dquot->dq_off = offset;
> - if ((ret = dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type,
> - (char *)&ddquot, sizeof(struct v2_disk_dqblk), offset))
> - != sizeof(struct v2_disk_dqblk)) {
> + ret = dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type,
> + (char *)&ddquot, dqblksz, offset);
> + if (ret != dqblksz) {
> 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 v2_disk_dqblk));
> + memset(&ddquot, 0, dqblksz);
> }
> else {
> ret = 0;
> /* We need to escape back all-zero structure */
> - memset(&empty, 0, sizeof(struct v2_disk_dqblk));
> - empty.dqb_itime = cpu_to_le64(1);
> - if (!memcmp(&empty, &ddquot, sizeof(struct v2_disk_dqblk)))
> - ddquot.dqb_itime = 0;
> + if (!memcmp(&fakedquot[rev], &ddquot, dqblksz)) {
> + if (rev == 0)
> + ddquot.r0.dqb_itime = cpu_to_le64(0);
> + else
> + ddquot.r1.dqb_itime = cpu_to_le64(0);
> + }
> }
> - disk2memdqb(&dquot->dq_dqb, &ddquot);
> + disk2memdqb(&dquot->dq_dqb, &ddquot, rev);
> if (!dquot->dq_dqb.dqb_bhardlimit &&
> !dquot->dq_dqb.dqb_bsoftlimit &&
> !dquot->dq_dqb.dqb_ihardlimit &&
> diff -rNpu linux.2.6.24.3.old/include/linux/dqblk_v2.h linux-2.6.24.3/include/linux/dqblk_v2.h
> --- linux.2.6.24.3.old/include/linux/dqblk_v2.h 2008-02-26 03:20:20.000000000 +0300
> +++ linux-2.6.24.3/include/linux/dqblk_v2.h 2008-03-13 22:01:48.000000000 +0300
> @@ -21,6 +21,7 @@ struct v2_mem_dqinfo {
> unsigned int dqi_blocks;
> unsigned int dqi_free_blk;
> unsigned int dqi_free_entry;
> + unsigned int dqi_revision;
> };
>
> #endif /* _LINUX_DQBLK_V2_H */
> diff -rNpu linux.2.6.24.3.old/include/linux/quota.h linux-2.6.24.3/include/linux/quota.h
> --- linux.2.6.24.3.old/include/linux/quota.h 2008-03-14 15:34:16.000000000 +0300
> +++ linux-2.6.24.3/include/linux/quota.h 2008-03-13 22:01:48.000000000 +0300
> @@ -181,12 +181,12 @@ extern spinlock_t dq_data_lock;
> * 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 */
> };
> diff -rNpu linux.2.6.24.3.old/include/linux/quotaio_v2.h linux-2.6.24.3/include/linux/quotaio_v2.h
> --- linux.2.6.24.3.old/include/linux/quotaio_v2.h 2008-02-26 03:20:20.000000000 +0300
> +++ linux-2.6.24.3/include/linux/quotaio_v2.h 2008-03-16 13:46:47.000000000 +0300
> @@ -16,28 +16,51 @@
> 0xd9c01927 /* GRPQUOTA */\
> }
>
> -#define V2_INITQVERSIONS {\
> +#define V2_INITQVERSIONS_R0 {\
> 0, /* USRQUOTA */\
> 0 /* GRPQUOTA */\
> }
>
> +#define V2_INITQVERSIONS_R1 {\
> + 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 v2_disk_dqblk {
> +struct v2_disk_dqblk_r0 {
> __le32 dqb_id; /* id this quota applies to */
> __le32 dqb_ihardlimit; /* absolute limit on allocated inodes */
> __le32 dqb_isoftlimit; /* preferred inode limit */
> __le32 dqb_curinodes; /* current # allocated inodes */
> - __le32 dqb_bhardlimit; /* absolute limit on disk space (in QUOTABLOCK_SIZE) */
> - __le32 dqb_bsoftlimit; /* preferred limit on disk space (in QUOTABLOCK_SIZE) */
> + __le32 dqb_bhardlimit; /* absolute limit on disk space */
> + __le32 dqb_bsoftlimit; /* preferred limit on disk space */
> + __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 */
> +};
> +
> +struct v2_disk_dqblk_r1 {
> + __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 */
> + __le64 dqb_bsoftlimit; /* preferred limit on disk space */
> __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 */
> };
>
> +union v2_disk_dqblk {
> + struct v2_disk_dqblk_r0 r0;
> + struct v2_disk_dqblk_r1 r1;
> +};
> +
> /*
> * Here are header structures as written on disk and their in-memory copies
> */
> @@ -59,7 +82,7 @@ struct v2_disk_dqinfo {
>
> /*
> * 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
> + * there will be space for exactly 21 (r0) or 14 (r1) quota-entries in a block
> */
> struct v2_disk_dqdbheader {
> __le32 dqdh_next_free; /* Number of next block with free entry */
> @@ -74,6 +97,5 @@ struct v2_disk_dqdbheader {
> #define V2_DQBLKSIZE (1 << V2_DQBLKSIZE_BITS) /* Size of block with quota structures */
> #define V2_DQTREEOFF 1 /* Offset of tree in file in blocks */
> #define V2_DQTREEDEPTH 4 /* Depth of quota tree */
> -#define V2_DQSTRINBLK ((V2_DQBLKSIZE - sizeof(struct v2_disk_dqdbheader)) / sizeof(struct v2_disk_dqblk)) /* Number of entries in one blocks */
>
> #endif /* _LINUX_QUOTAIO_V2_H */
>
--
Jan Kara <jack@xxxxxxx>
SUSE Labs, CR
--
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
