fs/quota_v2.c

   1 /*
   2  *      vfsv0 quota IO operations on file
   3  */
   4
   5 #include <linux/errno.h>
   6 #include <linux/fs.h>
   7 #include <linux/mount.h>
   8 #include <linux/dqblk_v2.h>
   9 #include <linux/quotaio_v2.h>
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/quotaops.h>
  15
  16 #include <asm/byteorder.h>
  17
  18 MODULE_AUTHOR("Jan Kara");
  19 MODULE_DESCRIPTION("Quota format v2 support");
  20 MODULE_LICENSE("GPL");
  21
  22 #define __QUOTA_V2_PARANOIA
  23
  24 typedef char *dqbuf_t;
  25
  26 #define GETIDINDEX(id, depth) (((id) >> ((V2_DQTREEDEPTH-(depth)-1)*8)) & 0xff)
  27 #define GETENTRIES(buf) ((struct v2_disk_dqblk *)(((char *)buf)+sizeof(struct v2_disk_dqdbheader)))
  28
  29 /* Check whether given file is really vfsv0 quotafile */
  30 static int v2_check_quota_file(struct super_block *sb, int type)
  31 {
  32         struct v2_disk_dqheader dqhead;
  33         ssize_t size;
  34         static const uint quota_magics[] = V2_INITQMAGICS;
  35         static const uint quota_versions[] = V2_INITQVERSIONS;
  36
  37         size = sb->s_op->quota_read(sb, type, (char *)&dqhead, sizeof(struct v2_disk_dqheader), 0);
  38         if (size != sizeof(struct v2_disk_dqheader)) {
  39                 printk("quota_v2: failed read expected=%zd got=%zd\n",
  40                         sizeof(struct v2_disk_dqheader), size);
  41                 return 0;
  42         }
  43         if (le32_to_cpu(dqhead.dqh_magic) != quota_magics[type] ||
  44             le32_to_cpu(dqhead.dqh_version) != quota_versions[type])
  45                 return 0;
  46         return 1;
  47 }
  48
  49 /* Read information header from quota file */
  50 static int v2_read_file_info(struct super_block *sb, int type)
  51 {
  52         struct v2_disk_dqinfo dinfo;
  53         struct mem_dqinfo *info = sb_dqopt(sb)->info+type;
  54         ssize_t size;
  55
  56         size = sb->s_op->quota_read(sb, type, (char *)&dinfo,
  57                sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
  58         if (size != sizeof(struct v2_disk_dqinfo)) {
  59                 printk(KERN_WARNING "Can't read info structure on device %s.\n",
  60                         sb->s_id);
  61                 return -1;
  62         }
  63         /* limits are stored as unsigned 32-bit data */
  64         info->dqi_maxblimit = 0xffffffff;
  65         info->dqi_maxilimit = 0xffffffff;
  66         info->dqi_bgrace = le32_to_cpu(dinfo.dqi_bgrace);
  67         info->dqi_igrace = le32_to_cpu(dinfo.dqi_igrace);
  68         info->dqi_flags = le32_to_cpu(dinfo.dqi_flags);
  69         info->u.v2_i.dqi_blocks = le32_to_cpu(dinfo.dqi_blocks);
  70         info->u.v2_i.dqi_free_blk = le32_to_cpu(dinfo.dqi_free_blk);
  71         info->u.v2_i.dqi_free_entry = le32_to_cpu(dinfo.dqi_free_entry);
  72         return 0;
  73 }
  74
  75 /* Write information header to quota file */
  76 static int v2_write_file_info(struct super_block *sb, int type)
  77 {
  78         struct v2_disk_dqinfo dinfo;
  79         struct mem_dqinfo *info = sb_dqopt(sb)->info+type;
  80         ssize_t size;
  81
  82         spin_lock(&dq_data_lock);
  83         info->dqi_flags &= ~DQF_INFO_DIRTY;
  84         dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace);
  85         dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace);
  86         dinfo.dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK);
  87         spin_unlock(&dq_data_lock);
  88         dinfo.dqi_blocks = cpu_to_le32(info->u.v2_i.dqi_blocks);
  89         dinfo.dqi_free_blk = cpu_to_le32(info->u.v2_i.dqi_free_blk);
  90         dinfo.dqi_free_entry = cpu_to_le32(info->u.v2_i.dqi_free_entry);
  91         size = sb->s_op->quota_write(sb, type, (char *)&dinfo,
  92                sizeof(struct v2_disk_dqinfo), V2_DQINFOOFF);
  93         if (size != sizeof(struct v2_disk_dqinfo)) {
  94                 printk(KERN_WARNING "Can't write info structure on device %s.\n",
  95                         sb->s_id);
  96                 return -1;
  97         }
  98         return 0;
  99 }
 100
 101 static void disk2memdqb(struct mem_dqblk *m, struct v2_disk_dqblk *d)
 102 {
 103         m->dqb_ihardlimit = le32_to_cpu(d->dqb_ihardlimit);
 104         m->dqb_isoftlimit = le32_to_cpu(d->dqb_isoftlimit);
 105         m->dqb_curinodes = le32_to_cpu(d->dqb_curinodes);
 106         m->dqb_itime = le64_to_cpu(d->dqb_itime);
 107         m->dqb_bhardlimit = le32_to_cpu(d->dqb_bhardlimit);
 108         m->dqb_bsoftlimit = le32_to_cpu(d->dqb_bsoftlimit);
 109         m->dqb_curspace = le64_to_cpu(d->dqb_curspace);
 110         m->dqb_btime = le64_to_cpu(d->dqb_btime);
 111 }
 112
 113 static void mem2diskdqb(struct v2_disk_dqblk *d, struct mem_dqblk *m, qid_t id)
 114 {
 115         d->dqb_ihardlimit = cpu_to_le32(m->dqb_ihardlimit);
 116         d->dqb_isoftlimit = cpu_to_le32(m->dqb_isoftlimit);
 117         d->dqb_curinodes = cpu_to_le32(m->dqb_curinodes);
 118         d->dqb_itime = cpu_to_le64(m->dqb_itime);
 119         d->dqb_bhardlimit = cpu_to_le32(m->dqb_bhardlimit);
 120         d->dqb_bsoftlimit = cpu_to_le32(m->dqb_bsoftlimit);
 121         d->dqb_curspace = cpu_to_le64(m->dqb_curspace);
 122         d->dqb_btime = cpu_to_le64(m->dqb_btime);
 123         d->dqb_id = cpu_to_le32(id);
 124 }
 125
 126 static dqbuf_t getdqbuf(void)
 127 {
 128         dqbuf_t buf = kmalloc(V2_DQBLKSIZE, GFP_NOFS);
 129         if (!buf)
 130                 printk(KERN_WARNING "VFS: Not enough memory for quota buffers.\n");
 131         return buf;
 132 }
 133
 134 static inline void freedqbuf(dqbuf_t buf)
 135 {
 136         kfree(buf);
 137 }
 138
 139 static inline ssize_t read_blk(struct super_block *sb, int type, uint blk, dqbuf_t buf)
 140 {
 141         memset(buf, 0, V2_DQBLKSIZE);
 142         return sb->s_op->quota_read(sb, type, (char *)buf,
 143                V2_DQBLKSIZE, blk << V2_DQBLKSIZE_BITS);
 144 }
 145
 146 static inline ssize_t write_blk(struct super_block *sb, int type, uint blk, dqbuf_t buf)
 147 {
 148         return sb->s_op->quota_write(sb, type, (char *)buf,
 149                V2_DQBLKSIZE, blk << V2_DQBLKSIZE_BITS);
 150 }
 151
 152 /* Remove empty block from list and return it */
 153 static int get_free_dqblk(struct super_block *sb, int type)
 154 {
 155         dqbuf_t buf = getdqbuf();
 156         struct mem_dqinfo *info = sb_dqinfo(sb, type);
 157         struct v2_disk_dqdbheader *dh = (struct v2_disk_dqdbheader *)buf;
 158         int ret, blk;
 159
 160         if (!buf)
 161                 return -ENOMEM;
 162         if (info->u.v2_i.dqi_free_blk) {
 163                 blk = info->u.v2_i.dqi_free_blk;
 164                 if ((ret = read_blk(sb, type, blk, buf)) < 0)
 165                         goto out_buf;
 166                 info->u.v2_i.dqi_free_blk = le32_to_cpu(dh->dqdh_next_free);
 167         }
 168         else {
 169                 memset(buf, 0, V2_DQBLKSIZE);
 170                 /* Assure block allocation... */
 171                 if ((ret = write_blk(sb, type, info->u.v2_i.dqi_blocks, buf)) < 0)
 172                         goto out_buf;
 173                 blk = info->u.v2_i.dqi_blocks++;
 174         }
 175         mark_info_dirty(sb, type);
 176         ret = blk;
 177 out_buf:
 178         freedqbuf(buf);
 179         return ret;
 180 }
 181
 182 /* Insert empty block to the list */
 183 static int put_free_dqblk(struct super_block *sb, int type, dqbuf_t buf, uint blk)
 184 {
 185         struct mem_dqinfo *info = sb_dqinfo(sb, type);
 186         struct v2_disk_dqdbheader *dh = (struct v2_disk_dqdbheader *)buf;
 187         int err;
 188
 189         dh->dqdh_next_free = cpu_to_le32(info->u.v2_i.dqi_free_blk);
 190         dh->dqdh_prev_free = cpu_to_le32(0);
 191         dh->dqdh_entries = cpu_to_le16(0);
 192         info->u.v2_i.dqi_free_blk = blk;
 193         mark_info_dirty(sb, type);
 194         /* Some strange block. We had better leave it... */
 195         if ((err = write_blk(sb, type, blk, buf)) < 0)
 196                 return err;
 197         return 0;
 198 }
 199
 200 /* Remove given block from the list of blocks with free entries */
 201 static int remove_free_dqentry(struct super_block *sb, int type, dqbuf_t buf, uint blk)
 202 {
 203         dqbuf_t tmpbuf = getdqbuf();
 204         struct mem_dqinfo *info = sb_dqinfo(sb, type);
 205         struct v2_disk_dqdbheader *dh = (struct v2_disk_dqdbheader *)buf;
 206         uint nextblk = le32_to_cpu(dh->dqdh_next_free), prevblk = le32_to_cpu(dh->dqdh_prev_free);
 207         int err;
 208
 209         if (!tmpbuf)
 210                 return -ENOMEM;
 211         if (nextblk) {
 212                 if ((err = read_blk(sb, type, nextblk, tmpbuf)) < 0)
 213                         goto out_buf;
 214                 ((struct v2_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = dh->dqdh_prev_free;
 215                 if ((err = write_blk(sb, type, nextblk, tmpbuf)) < 0)
 216                         goto out_buf;
 217         }
 218         if (prevblk) {
 219                 if ((err = read_blk(sb, type, prevblk, tmpbuf)) < 0)
 220                         goto out_buf;
 221                 ((struct v2_disk_dqdbheader *)tmpbuf)->dqdh_next_free = dh->dqdh_next_free;
 222                 if ((err = write_blk(sb, type, prevblk, tmpbuf)) < 0)
 223                         goto out_buf;
 224         }
 225         else {
 226                 info->u.v2_i.dqi_free_entry = nextblk;
 227                 mark_info_dirty(sb, type);
 228         }
 229         freedqbuf(tmpbuf);
 230         dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0);
 231         /* No matter whether write succeeds block is out of list */
 232         if (write_blk(sb, type, blk, buf) < 0)
 233                 printk(KERN_ERR "VFS: Can't write block (%u) with free entries.\n", blk);
 234         return 0;
 235 out_buf:
 236         freedqbuf(tmpbuf);
 237         return err;
 238 }
 239
 240 /* Insert given block to the beginning of list with free entries */
 241 static int insert_free_dqentry(struct super_block *sb, int type, dqbuf_t buf, uint blk)
 242 {
 243         dqbuf_t tmpbuf = getdqbuf();
 244         struct mem_dqinfo *info = sb_dqinfo(sb, type);
 245         struct v2_disk_dqdbheader *dh = (struct v2_disk_dqdbheader *)buf;
 246         int err;
 247
 248         if (!tmpbuf)
 249                 return -ENOMEM;
 250         dh->dqdh_next_free = cpu_to_le32(info->u.v2_i.dqi_free_entry);
 251         dh->dqdh_prev_free = cpu_to_le32(0);
 252         if ((err = write_blk(sb, type, blk, buf)) < 0)
 253                 goto out_buf;
 254         if (info->u.v2_i.dqi_free_entry) {
 255                 if ((err = read_blk(sb, type, info->u.v2_i.dqi_free_entry, tmpbuf)) < 0)
 256                         goto out_buf;
 257                 ((struct v2_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = cpu_to_le32(blk);
 258                 if ((err = write_blk(sb, type, info->u.v2_i.dqi_free_entry, tmpbuf)) < 0)
 259                         goto out_buf;
 260         }
 261         freedqbuf(tmpbuf);
 262         info->u.v2_i.dqi_free_entry = blk;
 263         mark_info_dirty(sb, type);
 264         return 0;
 265 out_buf:
 266         freedqbuf(tmpbuf);
 267         return err;
 268 }
 269
 270 /* Find space for dquot */
 271 static uint find_free_dqentry(struct dquot *dquot, int *err)
 272 {
 273         struct super_block *sb = dquot->dq_sb;
 274         struct mem_dqinfo *info = sb_dqopt(sb)->info+dquot->dq_type;
 275         uint blk, i;
 276         struct v2_disk_dqdbheader *dh;
 277         struct v2_disk_dqblk *ddquot;
 278         struct v2_disk_dqblk fakedquot;
 279         dqbuf_t buf;
 280
 281         *err = 0;
 282         if (!(buf = getdqbuf())) {
 283                 *err = -ENOMEM;
 284                 return 0;
 285         }
 286         dh = (struct v2_disk_dqdbheader *)buf;
 287         ddquot = GETENTRIES(buf);
 288         if (info->u.v2_i.dqi_free_entry) {
 289                 blk = info->u.v2_i.dqi_free_entry;
 290                 if ((*err = read_blk(sb, dquot->dq_type, blk, buf)) < 0)
 291                         goto out_buf;
 292         }
 293         else {
 294                 blk = get_free_dqblk(sb, dquot->dq_type);
 295                 if ((int)blk < 0) {
 296                         *err = blk;
 297                         freedqbuf(buf);
 298                         return 0;
 299                 }
 300                 memset(buf, 0, V2_DQBLKSIZE);
 301                 /* This is enough as block is already zeroed and entry list is empty... */
 302                 info->u.v2_i.dqi_free_entry = blk;
 303                 mark_info_dirty(sb, dquot->dq_type);
 304         }
 305         if (le16_to_cpu(dh->dqdh_entries)+1 >= V2_DQSTRINBLK)   /* Block will be full? */
 306                 if ((*err = remove_free_dqentry(sb, dquot->dq_type, buf, blk)) < 0) {
 307                         printk(KERN_ERR "VFS: find_free_dqentry(): Can't remove block (%u) from entry free list.\n", blk);
 308                         goto out_buf;
 309                 }
 310         le16_add_cpu(&dh->dqdh_entries, 1);
 311         memset(&fakedquot, 0, sizeof(struct v2_disk_dqblk));
 312         /* Find free structure in block */
 313         for (i = 0; i < V2_DQSTRINBLK && memcmp(&fakedquot, ddquot+i, sizeof(struct v2_disk_dqblk)); i++);
 314 #ifdef __QUOTA_V2_PARANOIA
 315         if (i == V2_DQSTRINBLK) {
 316                 printk(KERN_ERR "VFS: find_free_dqentry(): Data block full but it shouldn't.\n");
 317                 *err = -EIO;
 318                 goto out_buf;
 319         }
 320 #endif
 321         if ((*err = write_blk(sb, dquot->dq_type, blk, buf)) < 0) {
 322                 printk(KERN_ERR "VFS: find_free_dqentry(): Can't write quota data block %u.\n", blk);
 323                 goto out_buf;
 324         }
 325         dquot->dq_off = (blk<<V2_DQBLKSIZE_BITS)+sizeof(struct v2_disk_dqdbheader)+i*sizeof(struct v2_disk_dqblk);
 326         freedqbuf(buf);
 327         return blk;
 328 out_buf:
 329         freedqbuf(buf);
 330         return 0;
 331 }
 332
 333 /* Insert reference to structure into the trie */
 334 static int do_insert_tree(struct dquot *dquot, uint *treeblk, int depth)
 335 {
 336         struct super_block *sb = dquot->dq_sb;
 337         dqbuf_t buf;
 338         int ret = 0, newson = 0, newact = 0;
 339         __le32 *ref;
 340         uint newblk;
 341
 342         if (!(buf = getdqbuf()))
 343                 return -ENOMEM;
 344         if (!*treeblk) {
 345                 ret = get_free_dqblk(sb, dquot->dq_type);
 346                 if (ret < 0)
 347                         goto out_buf;
 348                 *treeblk = ret;
 349                 memset(buf, 0, V2_DQBLKSIZE);
 350                 newact = 1;
 351         }
 352         else {
 353                 if ((ret = read_blk(sb, dquot->dq_type, *treeblk, buf)) < 0) {
 354                         printk(KERN_ERR "VFS: Can't read tree quota block %u.\n", *treeblk);
 355                         goto out_buf;
 356                 }
 357         }
 358         ref = (__le32 *)buf;
 359         newblk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
 360         if (!newblk)
 361                 newson = 1;
 362         if (depth == V2_DQTREEDEPTH-1) {
 363 #ifdef __QUOTA_V2_PARANOIA
 364                 if (newblk) {
 365                         printk(KERN_ERR "VFS: Inserting already present quota entry (block %u).\n", le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]));
 366                         ret = -EIO;
 367                         goto out_buf;
 368                 }
 369 #endif
 370                 newblk = find_free_dqentry(dquot, &ret);
 371         }
 372         else
 373                 ret = do_insert_tree(dquot, &newblk, depth+1);
 374         if (newson && ret >= 0) {
 375                 ref[GETIDINDEX(dquot->dq_id, depth)] = cpu_to_le32(newblk);
 376                 ret = write_blk(sb, dquot->dq_type, *treeblk, buf);
 377         }
 378         else if (newact && ret < 0)
 379                 put_free_dqblk(sb, dquot->dq_type, buf, *treeblk);
 380 out_buf:
 381         freedqbuf(buf);
 382         return ret;
 383 }
 384
 385 /* Wrapper for inserting quota structure into tree */
 386 static inline int dq_insert_tree(struct dquot *dquot)
 387 {
 388         int tmp = V2_DQTREEOFF;
 389         return do_insert_tree(dquot, &tmp, 0);
 390 }
 391
 392 /*
 393  *      We don't have to be afraid of deadlocks as we never have quotas on quota files...
 394  */
 395 static int v2_write_dquot(struct dquot *dquot)
 396 {
 397         int type = dquot->dq_type;
 398         ssize_t ret;
 399         struct v2_disk_dqblk ddquot, empty;
 400
 401         /* dq_off is guarded by dqio_mutex */
 402         if (!dquot->dq_off)
 403                 if ((ret = dq_insert_tree(dquot)) < 0) {
 404                         printk(KERN_ERR "VFS: Error %zd occurred while creating quota.\n", ret);
 405                         return ret;
 406                 }
 407         spin_lock(&dq_data_lock);
 408         mem2diskdqb(&ddquot, &dquot->dq_dqb, dquot->dq_id);
 409         /* Argh... We may need to write structure full of zeroes but that would be
 410          * treated as an empty place by the rest of the code. Format change would
 411          * be definitely cleaner but the problems probably are not worth it */
 412         memset(&empty, 0, sizeof(struct v2_disk_dqblk));
 413         if (!memcmp(&empty, &ddquot, sizeof(struct v2_disk_dqblk)))
 414                 ddquot.dqb_itime = cpu_to_le64(1);
 415         spin_unlock(&dq_data_lock);
 416         ret = dquot->dq_sb->s_op->quota_write(dquot->dq_sb, type,
 417               (char *)&ddquot, sizeof(struct v2_disk_dqblk), dquot->dq_off);
 418         if (ret != sizeof(struct v2_disk_dqblk)) {
 419                 printk(KERN_WARNING "VFS: dquota write failed on dev %s\n", dquot->dq_sb->s_id);
 420                 if (ret >= 0)
 421                         ret = -ENOSPC;
 422         }
 423         else
 424                 ret = 0;
 425         dqstats.writes++;
 426
 427         return ret;
 428 }
 429
 430 /* Free dquot entry in data block */
 431 static int free_dqentry(struct dquot *dquot, uint blk)
 432 {
 433         struct super_block *sb = dquot->dq_sb;
 434         int type = dquot->dq_type;
 435         struct v2_disk_dqdbheader *dh;
 436         dqbuf_t buf = getdqbuf();
 437         int ret = 0;
 438
 439         if (!buf)
 440                 return -ENOMEM;
 441         if (dquot->dq_off >> V2_DQBLKSIZE_BITS != blk) {
 442                 printk(KERN_ERR "VFS: Quota structure has offset to other "
 443                   "block (%u) than it should (%u).\n", blk,
 444                   (uint)(dquot->dq_off >> V2_DQBLKSIZE_BITS));
 445                 goto out_buf;
 446         }
 447         if ((ret = read_blk(sb, type, blk, buf)) < 0) {
 448                 printk(KERN_ERR "VFS: Can't read quota data block %u\n", blk);
 449                 goto out_buf;
 450         }
 451         dh = (struct v2_disk_dqdbheader *)buf;
 452         le16_add_cpu(&dh->dqdh_entries, -1);
 453         if (!le16_to_cpu(dh->dqdh_entries)) {   /* Block got free? */
 454                 if ((ret = remove_free_dqentry(sb, type, buf, blk)) < 0 ||
 455                     (ret = put_free_dqblk(sb, type, buf, blk)) < 0) {
 456                         printk(KERN_ERR "VFS: Can't move quota data block (%u) "
 457                           "to free list.\n", blk);
 458                         goto out_buf;
 459                 }
 460         }
 461         else {
 462                 memset(buf+(dquot->dq_off & ((1 << V2_DQBLKSIZE_BITS)-1)), 0,
 463                   sizeof(struct v2_disk_dqblk));
 464                 if (le16_to_cpu(dh->dqdh_entries) == V2_DQSTRINBLK-1) {
 465                         /* Insert will write block itself */
 466                         if ((ret = insert_free_dqentry(sb, type, buf, blk)) < 0) {
 467                                 printk(KERN_ERR "VFS: Can't insert quota data block (%u) to free entry list.\n", blk);
 468                                 goto out_buf;
 469                         }
 470                 }
 471                 else
 472                         if ((ret = write_blk(sb, type, blk, buf)) < 0) {
 473                                 printk(KERN_ERR "VFS: Can't write quota data "
 474                                   "block %u\n", blk);
 475                                 goto out_buf;
 476                         }
 477         }
 478         dquot->dq_off = 0;      /* Quota is now unattached */
 479 out_buf:
 480         freedqbuf(buf);
 481         return ret;
 482 }
 483
 484 /* Remove reference to dquot from tree */
 485 static int remove_tree(struct dquot *dquot, uint *blk, int depth)
 486 {
 487         struct super_block *sb = dquot->dq_sb;
 488         int type = dquot->dq_type;
 489         dqbuf_t buf = getdqbuf();
 490         int ret = 0;
 491         uint newblk;
 492         __le32 *ref = (__le32 *)buf;
 493
 494         if (!buf)
 495                 return -ENOMEM;
 496         if ((ret = read_blk(sb, type, *blk, buf)) < 0) {
 497                 printk(KERN_ERR "VFS: Can't read quota data block %u\n", *blk);
 498                 goto out_buf;
 499         }
 500         newblk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
 501         if (depth == V2_DQTREEDEPTH-1) {
 502                 ret = free_dqentry(dquot, newblk);
 503                 newblk = 0;
 504         }
 505         else
 506                 ret = remove_tree(dquot, &newblk, depth+1);
 507         if (ret >= 0 && !newblk) {
 508                 int i;
 509                 ref[GETIDINDEX(dquot->dq_id, depth)] = cpu_to_le32(0);
 510                 for (i = 0; i < V2_DQBLKSIZE && !buf[i]; i++);  /* Block got empty? */
 511                 /* Don't put the root block into the free block list */
 512                 if (i == V2_DQBLKSIZE && *blk != V2_DQTREEOFF) {
 513                         put_free_dqblk(sb, type, buf, *blk);
 514                         *blk = 0;
 515                 }
 516                 else
 517                         if ((ret = write_blk(sb, type, *blk, buf)) < 0)
 518                                 printk(KERN_ERR "VFS: Can't write quota tree "
 519                                   "block %u.\n", *blk);
 520         }
 521 out_buf:
 522         freedqbuf(buf);
 523         return ret;
 524 }
 525
 526 /* Delete dquot from tree */
 527 static int v2_delete_dquot(struct dquot *dquot)
 528 {
 529         uint tmp = V2_DQTREEOFF;
 530
 531         if (!dquot->dq_off)     /* Even not allocated? */
 532                 return 0;
 533         return remove_tree(dquot, &tmp, 0);
 534 }
 535
 536 /* Find entry in block */
 537 static loff_t find_block_dqentry(struct dquot *dquot, uint blk)
 538 {
 539         dqbuf_t buf = getdqbuf();
 540         loff_t ret = 0;
 541         int i;
 542         struct v2_disk_dqblk *ddquot = GETENTRIES(buf);
 543
 544         if (!buf)
 545                 return -ENOMEM;
 546         if ((ret = read_blk(dquot->dq_sb, dquot->dq_type, blk, buf)) < 0) {
 547                 printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
 548                 goto out_buf;
 549         }
 550         if (dquot->dq_id)
 551                 for (i = 0; i < V2_DQSTRINBLK &&
 552                      le32_to_cpu(ddquot[i].dqb_id) != dquot->dq_id; i++);
 553         else {  /* ID 0 as a bit more complicated searching... */
 554                 struct v2_disk_dqblk fakedquot;
 555
 556                 memset(&fakedquot, 0, sizeof(struct v2_disk_dqblk));
 557                 for (i = 0; i < V2_DQSTRINBLK; i++)
 558                         if (!le32_to_cpu(ddquot[i].dqb_id) &&
 559                             memcmp(&fakedquot, ddquot+i, sizeof(struct v2_disk_dqblk)))
 560                                 break;
 561         }
 562         if (i == V2_DQSTRINBLK) {
 563                 printk(KERN_ERR "VFS: Quota for id %u referenced "
 564                   "but not present.\n", dquot->dq_id);
 565                 ret = -EIO;
 566                 goto out_buf;
 567         }
 568         else
 569                 ret = (blk << V2_DQBLKSIZE_BITS) + sizeof(struct
 570                   v2_disk_dqdbheader) + i * sizeof(struct v2_disk_dqblk);
 571 out_buf:
 572         freedqbuf(buf);
 573         return ret;
 574 }
 575
 576 /* Find entry for given id in the tree */
 577 static loff_t find_tree_dqentry(struct dquot *dquot, uint blk, int depth)
 578 {
 579         dqbuf_t buf = getdqbuf();
 580         loff_t ret = 0;
 581         __le32 *ref = (__le32 *)buf;
 582
 583         if (!buf)
 584                 return -ENOMEM;
 585         if ((ret = read_blk(dquot->dq_sb, dquot->dq_type, blk, buf)) < 0) {
 586                 printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk);
 587                 goto out_buf;
 588         }
 589         ret = 0;
 590         blk = le32_to_cpu(ref[GETIDINDEX(dquot->dq_id, depth)]);
 591         if (!blk)       /* No reference? */
 592                 goto out_buf;
 593         if (depth < V2_DQTREEDEPTH-1)
 594                 ret = find_tree_dqentry(dquot, blk, depth+1);
 595         else
 596                 ret = find_block_dqentry(dquot, blk);
 597 out_buf:
 598         freedqbuf(buf);
 599         return ret;
 600 }
 601
 602 /* Find entry for given id in the tree - wrapper function */
 603 static inline loff_t find_dqentry(struct dquot *dquot)
 604 {
 605         return find_tree_dqentry(dquot, V2_DQTREEOFF, 0);
 606 }
 607
 608 static int v2_read_dquot(struct dquot *dquot)
 609 {
 610         int type = dquot->dq_type;
 611         loff_t offset;
 612         struct v2_disk_dqblk ddquot, empty;
 613         int ret = 0;
 614
 615 #ifdef __QUOTA_V2_PARANOIA
 616         /* Invalidated quota? */
 617         if (!dquot->dq_sb || !sb_dqopt(dquot->dq_sb)->files[type]) {
 618                 printk(KERN_ERR "VFS: Quota invalidated while reading!\n");
 619                 return -EIO;
 620         }
 621 #endif
 622         offset = find_dqentry(dquot);
 623         if (offset <= 0) {      /* Entry not present? */
 624                 if (offset < 0)
 625                         printk(KERN_ERR "VFS: Can't read quota "
 626                           "structure for id %u.\n", dquot->dq_id);
 627                 dquot->dq_off = 0;
 628                 set_bit(DQ_FAKE_B, &dquot->dq_flags);
 629                 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
 630                 ret = offset;
 631         }
 632         else {
 633                 dquot->dq_off = offset;
 634                 if ((ret = dquot->dq_sb->s_op->quota_read(dquot->dq_sb, type,
 635                     (char *)&ddquot, sizeof(struct v2_disk_dqblk), offset))
 636                     != sizeof(struct v2_disk_dqblk)) {
 637                         if (ret >= 0)
 638                                 ret = -EIO;
 639                         printk(KERN_ERR "VFS: Error while reading quota "
 640                           "structure for id %u.\n", dquot->dq_id);
 641                         memset(&ddquot, 0, sizeof(struct v2_disk_dqblk));
 642                 }
 643                 else {
 644                         ret = 0;
 645                         /* We need to escape back all-zero structure */
 646                         memset(&empty, 0, sizeof(struct v2_disk_dqblk));
 647                         empty.dqb_itime = cpu_to_le64(1);
 648                         if (!memcmp(&empty, &ddquot, sizeof(struct v2_disk_dqblk)))
 649                                 ddquot.dqb_itime = 0;
 650                 }
 651                 disk2memdqb(&dquot->dq_dqb, &ddquot);
 652                 if (!dquot->dq_dqb.dqb_bhardlimit &&
 653                         !dquot->dq_dqb.dqb_bsoftlimit &&
 654                         !dquot->dq_dqb.dqb_ihardlimit &&
 655                         !dquot->dq_dqb.dqb_isoftlimit)
 656                         set_bit(DQ_FAKE_B, &dquot->dq_flags);
 657         }
 658         dqstats.reads++;
 659
 660         return ret;
 661 }
 662
 663 /* Check whether dquot should not be deleted. We know we are
 664  * the only one operating on dquot (thanks to dq_lock) */
 665 static int v2_release_dquot(struct dquot *dquot)
 666 {
 667         if (test_bit(DQ_FAKE_B, &dquot->dq_flags) && !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace))
 668                 return v2_delete_dquot(dquot);
 669         return 0;
 670 }
 671
 672 static struct quota_format_ops v2_format_ops = {
 673         .check_quota_file       = v2_check_quota_file,
 674         .read_file_info         = v2_read_file_info,
 675         .write_file_info        = v2_write_file_info,
 676         .free_file_info         = NULL,
 677         .read_dqblk             = v2_read_dquot,
 678         .commit_dqblk           = v2_write_dquot,
 679         .release_dqblk          = v2_release_dquot,
 680 };
 681
 682 static struct quota_format_type v2_quota_format = {
 683         .qf_fmt_id      = QFMT_VFS_V0,
 684         .qf_ops         = &v2_format_ops,
 685         .qf_owner       = THIS_MODULE
 686 };
 687
 688 static int __init init_v2_quota_format(void)
 689 {
 690         return register_quota_format(&v2_quota_format);
 691 }
 692
 693 static void __exit exit_v2_quota_format(void)
 694 {
 695         unregister_quota_format(&v2_quota_format);
 696 }
 697
 698 module_init(init_v2_quota_format);
 699 module_exit(exit_v2_quota_format);