fs/quota/quota_tree.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/kernel.h>
  10 #include <linux/init.h>
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/quotaops.h>
  14
  15 #include <asm/byteorder.h>
  16
  17 #include "quota_tree.h"
  18
  19 MODULE_AUTHOR("Jan Kara");
  20 MODULE_DESCRIPTION("Quota trie support");
  21 MODULE_LICENSE("GPL");
  22
  23 #define __QUOTA_QT_PARANOIA
  24
  25 static int __get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth)
  26 {
  27         unsigned int epb = info->dqi_usable_bs >> 2;
  28
  29         depth = info->dqi_qtree_depth - depth - 1;
  30         while (depth--)
  31                 id /= epb;
  32         return id % epb;
  33 }
  34
  35 static int get_index(struct qtree_mem_dqinfo *info, struct kqid qid, int depth)
  36 {
  37         qid_t id = from_kqid(&init_user_ns, qid);
  38
  39         return __get_index(info, id, depth);
  40 }
  41
  42 /* Number of entries in one blocks */
  43 static int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info)
  44 {
  45         return (info->dqi_usable_bs - sizeof(struct qt_disk_dqdbheader))
  46                / info->dqi_entry_size;
  47 }
  48
  49 static char *getdqbuf(size_t size)
  50 {
  51         char *buf = kmalloc(size, GFP_NOFS);
  52         if (!buf)
  53                 printk(KERN_WARNING
  54                        "VFS: Not enough memory for quota buffers.\n");
  55         return buf;
  56 }
  57
  58 static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf)
  59 {
  60         struct super_block *sb = info->dqi_sb;
  61
  62         memset(buf, 0, info->dqi_usable_bs);
  63         return sb->s_op->quota_read(sb, info->dqi_type, buf,
  64                info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits);
  65 }
  66
  67 static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf)
  68 {
  69         struct super_block *sb = info->dqi_sb;
  70         ssize_t ret;
  71
  72         ret = sb->s_op->quota_write(sb, info->dqi_type, buf,
  73                info->dqi_usable_bs, (loff_t)blk << info->dqi_blocksize_bits);
  74         if (ret != info->dqi_usable_bs) {
  75                 quota_error(sb, "dquota write failed");
  76                 if (ret >= 0)
  77                         ret = -EIO;
  78         }
  79         return ret;
  80 }
  81
  82 /* Remove empty block from list and return it */
  83 static int get_free_dqblk(struct qtree_mem_dqinfo *info)
  84 {
  85         char *buf = getdqbuf(info->dqi_usable_bs);
  86         struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
  87         int ret, blk;
  88
  89         if (!buf)
  90                 return -ENOMEM;
  91         if (info->dqi_free_blk) {
  92                 blk = info->dqi_free_blk;
  93                 ret = read_blk(info, blk, buf);
  94                 if (ret < 0)
  95                         goto out_buf;
  96                 info->dqi_free_blk = le32_to_cpu(dh->dqdh_next_free);
  97         }
  98         else {
  99                 memset(buf, 0, info->dqi_usable_bs);
 100                 /* Assure block allocation... */
 101                 ret = write_blk(info, info->dqi_blocks, buf);
 102                 if (ret < 0)
 103                         goto out_buf;
 104                 blk = info->dqi_blocks++;
 105         }
 106         mark_info_dirty(info->dqi_sb, info->dqi_type);
 107         ret = blk;
 108 out_buf:
 109         kfree(buf);
 110         return ret;
 111 }
 112
 113 /* Insert empty block to the list */
 114 static int put_free_dqblk(struct qtree_mem_dqinfo *info, char *buf, uint blk)
 115 {
 116         struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
 117         int err;
 118
 119         dh->dqdh_next_free = cpu_to_le32(info->dqi_free_blk);
 120         dh->dqdh_prev_free = cpu_to_le32(0);
 121         dh->dqdh_entries = cpu_to_le16(0);
 122         err = write_blk(info, blk, buf);
 123         if (err < 0)
 124                 return err;
 125         info->dqi_free_blk = blk;
 126         mark_info_dirty(info->dqi_sb, info->dqi_type);
 127         return 0;
 128 }
 129
 130 /* Remove given block from the list of blocks with free entries */
 131 static int remove_free_dqentry(struct qtree_mem_dqinfo *info, char *buf,
 132                                uint blk)
 133 {
 134         char *tmpbuf = getdqbuf(info->dqi_usable_bs);
 135         struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
 136         uint nextblk = le32_to_cpu(dh->dqdh_next_free);
 137         uint prevblk = le32_to_cpu(dh->dqdh_prev_free);
 138         int err;
 139
 140         if (!tmpbuf)
 141                 return -ENOMEM;
 142         if (nextblk) {
 143                 err = read_blk(info, nextblk, tmpbuf);
 144                 if (err < 0)
 145                         goto out_buf;
 146                 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free =
 147                                                         dh->dqdh_prev_free;
 148                 err = write_blk(info, nextblk, tmpbuf);
 149                 if (err < 0)
 150                         goto out_buf;
 151         }
 152         if (prevblk) {
 153                 err = read_blk(info, prevblk, tmpbuf);
 154                 if (err < 0)
 155                         goto out_buf;
 156                 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_next_free =
 157                                                         dh->dqdh_next_free;
 158                 err = write_blk(info, prevblk, tmpbuf);
 159                 if (err < 0)
 160                         goto out_buf;
 161         } else {
 162                 info->dqi_free_entry = nextblk;
 163                 mark_info_dirty(info->dqi_sb, info->dqi_type);
 164         }
 165         kfree(tmpbuf);
 166         dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0);
 167         /* No matter whether write succeeds block is out of list */
 168         if (write_blk(info, blk, buf) < 0)
 169                 quota_error(info->dqi_sb, "Can't write block (%u) "
 170                             "with free entries", blk);
 171         return 0;
 172 out_buf:
 173         kfree(tmpbuf);
 174         return err;
 175 }
 176
 177 /* Insert given block to the beginning of list with free entries */
 178 static int insert_free_dqentry(struct qtree_mem_dqinfo *info, char *buf,
 179                                uint blk)
 180 {
 181         char *tmpbuf = getdqbuf(info->dqi_usable_bs);
 182         struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf;
 183         int err;
 184
 185         if (!tmpbuf)
 186                 return -ENOMEM;
 187         dh->dqdh_next_free = cpu_to_le32(info->dqi_free_entry);
 188         dh->dqdh_prev_free = cpu_to_le32(0);
 189         err = write_blk(info, blk, buf);
 190         if (err < 0)
 191                 goto out_buf;
 192         if (info->dqi_free_entry) {
 193                 err = read_blk(info, info->dqi_free_entry, tmpbuf);
 194                 if (err < 0)
 195                         goto out_buf;
 196                 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free =
 197                                                         cpu_to_le32(blk);
 198                 err = write_blk(info, info->dqi_free_entry, tmpbuf);
 199                 if (err < 0)
 200                         goto out_buf;
 201         }
 202         kfree(tmpbuf);
 203         info->dqi_free_entry = blk;
 204         mark_info_dirty(info->dqi_sb, info->dqi_type);
 205         return 0;
 206 out_buf:
 207         kfree(tmpbuf);
 208         return err;
 209 }
 210
 211 /* Is the entry in the block free? */
 212 int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk)
 213 {
 214         int i;
 215
 216         for (i = 0; i < info->dqi_entry_size; i++)
 217                 if (disk[i])
 218                         return 0;
 219         return 1;
 220 }
 221 EXPORT_SYMBOL(qtree_entry_unused);
 222
 223 /* Find space for dquot */
 224 static uint find_free_dqentry(struct qtree_mem_dqinfo *info,
 225                               struct dquot *dquot, int *err)
 226 {
 227         uint blk, i;
 228         struct qt_disk_dqdbheader *dh;
 229         char *buf = getdqbuf(info->dqi_usable_bs);
 230         char *ddquot;
 231
 232         *err = 0;
 233         if (!buf) {
 234                 *err = -ENOMEM;
 235                 return 0;
 236         }
 237         dh = (struct qt_disk_dqdbheader *)buf;
 238         if (info->dqi_free_entry) {
 239                 blk = info->dqi_free_entry;
 240                 *err = read_blk(info, blk, buf);
 241                 if (*err < 0)
 242                         goto out_buf;
 243         } else {
 244                 blk = get_free_dqblk(info);
 245                 if ((int)blk < 0) {
 246                         *err = blk;
 247                         kfree(buf);
 248                         return 0;
 249                 }
 250                 memset(buf, 0, info->dqi_usable_bs);
 251                 /* This is enough as the block is already zeroed and the entry
 252                  * list is empty... */
 253                 info->dqi_free_entry = blk;
 254                 mark_info_dirty(dquot->dq_sb, dquot->dq_id.type);
 255         }
 256         /* Block will be full? */
 257         if (le16_to_cpu(dh->dqdh_entries) + 1 >= qtree_dqstr_in_blk(info)) {
 258                 *err = remove_free_dqentry(info, buf, blk);
 259                 if (*err < 0) {
 260                         quota_error(dquot->dq_sb, "Can't remove block (%u) "
 261                                     "from entry free list", blk);
 262                         goto out_buf;
 263                 }
 264         }
 265         le16_add_cpu(&dh->dqdh_entries, 1);
 266         /* Find free structure in block */
 267         ddquot = buf + sizeof(struct qt_disk_dqdbheader);
 268         for (i = 0; i < qtree_dqstr_in_blk(info); i++) {
 269                 if (qtree_entry_unused(info, ddquot))
 270                         break;
 271                 ddquot += info->dqi_entry_size;
 272         }
 273 #ifdef __QUOTA_QT_PARANOIA
 274         if (i == qtree_dqstr_in_blk(info)) {
 275                 quota_error(dquot->dq_sb, "Data block full but it shouldn't");
 276                 *err = -EIO;
 277                 goto out_buf;
 278         }
 279 #endif
 280         *err = write_blk(info, blk, buf);
 281         if (*err < 0) {
 282                 quota_error(dquot->dq_sb, "Can't write quota data block %u",
 283                             blk);
 284                 goto out_buf;
 285         }
 286         dquot->dq_off = ((loff_t)blk << info->dqi_blocksize_bits) +
 287                         sizeof(struct qt_disk_dqdbheader) +
 288                         i * info->dqi_entry_size;
 289         kfree(buf);
 290         return blk;
 291 out_buf:
 292         kfree(buf);
 293         return 0;
 294 }
 295
 296 /* Insert reference to structure into the trie */
 297 static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
 298                           uint *treeblk, int depth)
 299 {
 300         char *buf = getdqbuf(info->dqi_usable_bs);
 301         int ret = 0, newson = 0, newact = 0;
 302         __le32 *ref;
 303         uint newblk;
 304
 305         if (!buf)
 306                 return -ENOMEM;
 307         if (!*treeblk) {
 308                 ret = get_free_dqblk(info);
 309                 if (ret < 0)
 310                         goto out_buf;
 311                 *treeblk = ret;
 312                 memset(buf, 0, info->dqi_usable_bs);
 313                 newact = 1;
 314         } else {
 315                 ret = read_blk(info, *treeblk, buf);
 316                 if (ret < 0) {
 317                         quota_error(dquot->dq_sb, "Can't read tree quota "
 318                                     "block %u", *treeblk);
 319                         goto out_buf;
 320                 }
 321         }
 322         ref = (__le32 *)buf;
 323         newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]);
 324         if (!newblk)
 325                 newson = 1;
 326         if (depth == info->dqi_qtree_depth - 1) {
 327 #ifdef __QUOTA_QT_PARANOIA
 328                 if (newblk) {
 329                         quota_error(dquot->dq_sb, "Inserting already present "
 330                                     "quota entry (block %u)",
 331                                     le32_to_cpu(ref[get_index(info,
 332                                                 dquot->dq_id, depth)]));
 333                         ret = -EIO;
 334                         goto out_buf;
 335                 }
 336 #endif
 337                 newblk = find_free_dqentry(info, dquot, &ret);
 338         } else {
 339                 ret = do_insert_tree(info, dquot, &newblk, depth+1);
 340         }
 341         if (newson && ret >= 0) {
 342                 ref[get_index(info, dquot->dq_id, depth)] =
 343                                                         cpu_to_le32(newblk);
 344                 ret = write_blk(info, *treeblk, buf);
 345         } else if (newact && ret < 0) {
 346                 put_free_dqblk(info, buf, *treeblk);
 347         }
 348 out_buf:
 349         kfree(buf);
 350         return ret;
 351 }
 352
 353 /* Wrapper for inserting quota structure into tree */
 354 static inline int dq_insert_tree(struct qtree_mem_dqinfo *info,
 355                                  struct dquot *dquot)
 356 {
 357         int tmp = QT_TREEOFF;
 358
 359 #ifdef __QUOTA_QT_PARANOIA
 360         if (info->dqi_blocks <= QT_TREEOFF) {
 361                 quota_error(dquot->dq_sb, "Quota tree root isn't allocated!");
 362                 return -EIO;
 363         }
 364 #endif
 365         return do_insert_tree(info, dquot, &tmp, 0);
 366 }
 367
 368 /*
 369  * We don't have to be afraid of deadlocks as we never have quotas on quota
 370  * files...
 371  */
 372 int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
 373 {
 374         int type = dquot->dq_id.type;
 375         struct super_block *sb = dquot->dq_sb;
 376         ssize_t ret;
 377         char *ddquot = getdqbuf(info->dqi_entry_size);
 378
 379         if (!ddquot)
 380                 return -ENOMEM;
 381
 382         /* dq_off is guarded by dqio_sem */
 383         if (!dquot->dq_off) {
 384                 ret = dq_insert_tree(info, dquot);
 385                 if (ret < 0) {
 386                         quota_error(sb, "Error %zd occurred while creating "
 387                                     "quota", ret);
 388                         kfree(ddquot);
 389                         return ret;
 390                 }
 391         }
 392         spin_lock(&dquot->dq_dqb_lock);
 393         info->dqi_ops->mem2disk_dqblk(ddquot, dquot);
 394         spin_unlock(&dquot->dq_dqb_lock);
 395         ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size,
 396                                     dquot->dq_off);
 397         if (ret != info->dqi_entry_size) {
 398                 quota_error(sb, "dquota write failed");
 399                 if (ret >= 0)
 400                         ret = -ENOSPC;
 401         } else {
 402                 ret = 0;
 403         }
 404         dqstats_inc(DQST_WRITES);
 405         kfree(ddquot);
 406
 407         return ret;
 408 }
 409 EXPORT_SYMBOL(qtree_write_dquot);
 410
 411 /* Free dquot entry in data block */
 412 static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot,
 413                         uint blk)
 414 {
 415         struct qt_disk_dqdbheader *dh;
 416         char *buf = getdqbuf(info->dqi_usable_bs);
 417         int ret = 0;
 418
 419         if (!buf)
 420                 return -ENOMEM;
 421         if (dquot->dq_off >> info->dqi_blocksize_bits != blk) {
 422                 quota_error(dquot->dq_sb, "Quota structure has offset to "
 423                         "other block (%u) than it should (%u)", blk,
 424                         (uint)(dquot->dq_off >> info->dqi_blocksize_bits));
 425                 ret = -EIO;
 426                 goto out_buf;
 427         }
 428         ret = read_blk(info, blk, buf);
 429         if (ret < 0) {
 430                 quota_error(dquot->dq_sb, "Can't read quota data block %u",
 431                             blk);
 432                 goto out_buf;
 433         }
 434         dh = (struct qt_disk_dqdbheader *)buf;
 435         le16_add_cpu(&dh->dqdh_entries, -1);
 436         if (!le16_to_cpu(dh->dqdh_entries)) {   /* Block got free? */
 437                 ret = remove_free_dqentry(info, buf, blk);
 438                 if (ret >= 0)
 439                         ret = put_free_dqblk(info, buf, blk);
 440                 if (ret < 0) {
 441                         quota_error(dquot->dq_sb, "Can't move quota data block "
 442                                     "(%u) to free list", blk);
 443                         goto out_buf;
 444                 }
 445         } else {
 446                 memset(buf +
 447                        (dquot->dq_off & ((1 << info->dqi_blocksize_bits) - 1)),
 448                        0, info->dqi_entry_size);
 449                 if (le16_to_cpu(dh->dqdh_entries) ==
 450                     qtree_dqstr_in_blk(info) - 1) {
 451                         /* Insert will write block itself */
 452                         ret = insert_free_dqentry(info, buf, blk);
 453                         if (ret < 0) {
 454                                 quota_error(dquot->dq_sb, "Can't insert quota "
 455                                     "data block (%u) to free entry list", blk);
 456                                 goto out_buf;
 457                         }
 458                 } else {
 459                         ret = write_blk(info, blk, buf);
 460                         if (ret < 0) {
 461                                 quota_error(dquot->dq_sb, "Can't write quota "
 462                                             "data block %u", blk);
 463                                 goto out_buf;
 464                         }
 465                 }
 466         }
 467         dquot->dq_off = 0;      /* Quota is now unattached */
 468 out_buf:
 469         kfree(buf);
 470         return ret;
 471 }
 472
 473 /* Remove reference to dquot from tree */
 474 static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
 475                        uint *blk, int depth)
 476 {
 477         char *buf = getdqbuf(info->dqi_usable_bs);
 478         int ret = 0;
 479         uint newblk;
 480         __le32 *ref = (__le32 *)buf;
 481
 482         if (!buf)
 483                 return -ENOMEM;
 484         ret = read_blk(info, *blk, buf);
 485         if (ret < 0) {
 486                 quota_error(dquot->dq_sb, "Can't read quota data block %u",
 487                             *blk);
 488                 goto out_buf;
 489         }
 490         newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]);
 491         if (newblk < QT_TREEOFF || newblk >= info->dqi_blocks) {
 492                 quota_error(dquot->dq_sb, "Getting block too big (%u >= %u)",
 493                             newblk, info->dqi_blocks);
 494                 ret = -EUCLEAN;
 495                 goto out_buf;
 496         }
 497
 498         if (depth == info->dqi_qtree_depth - 1) {
 499                 ret = free_dqentry(info, dquot, newblk);
 500                 newblk = 0;
 501         } else {
 502                 ret = remove_tree(info, dquot, &newblk, depth+1);
 503         }
 504         if (ret >= 0 && !newblk) {
 505                 int i;
 506                 ref[get_index(info, dquot->dq_id, depth)] = cpu_to_le32(0);
 507                 /* Block got empty? */
 508                 for (i = 0; i < (info->dqi_usable_bs >> 2) && !ref[i]; i++)
 509                         ;
 510                 /* Don't put the root block into the free block list */
 511                 if (i == (info->dqi_usable_bs >> 2)
 512                     && *blk != QT_TREEOFF) {
 513                         put_free_dqblk(info, buf, *blk);
 514                         *blk = 0;
 515                 } else {
 516                         ret = write_blk(info, *blk, buf);
 517                         if (ret < 0)
 518                                 quota_error(dquot->dq_sb,
 519                                             "Can't write quota tree block %u",
 520                                             *blk);
 521                 }
 522         }
 523 out_buf:
 524         kfree(buf);
 525         return ret;
 526 }
 527
 528 /* Delete dquot from tree */
 529 int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
 530 {
 531         uint tmp = QT_TREEOFF;
 532
 533         if (!dquot->dq_off)     /* Even not allocated? */
 534                 return 0;
 535         return remove_tree(info, dquot, &tmp, 0);
 536 }
 537 EXPORT_SYMBOL(qtree_delete_dquot);
 538
 539 /* Find entry in block */
 540 static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info,
 541                                  struct dquot *dquot, uint blk)
 542 {
 543         char *buf = getdqbuf(info->dqi_usable_bs);
 544         loff_t ret = 0;
 545         int i;
 546         char *ddquot;
 547
 548         if (!buf)
 549                 return -ENOMEM;
 550         ret = read_blk(info, blk, buf);
 551         if (ret < 0) {
 552                 quota_error(dquot->dq_sb, "Can't read quota tree "
 553                             "block %u", blk);
 554                 goto out_buf;
 555         }
 556         ddquot = buf + sizeof(struct qt_disk_dqdbheader);
 557         for (i = 0; i < qtree_dqstr_in_blk(info); i++) {
 558                 if (info->dqi_ops->is_id(ddquot, dquot))
 559                         break;
 560                 ddquot += info->dqi_entry_size;
 561         }
 562         if (i == qtree_dqstr_in_blk(info)) {
 563                 quota_error(dquot->dq_sb,
 564                             "Quota for id %u referenced but not present",
 565                             from_kqid(&init_user_ns, dquot->dq_id));
 566                 ret = -EIO;
 567                 goto out_buf;
 568         } else {
 569                 ret = ((loff_t)blk << info->dqi_blocksize_bits) + sizeof(struct
 570                   qt_disk_dqdbheader) + i * info->dqi_entry_size;
 571         }
 572 out_buf:
 573         kfree(buf);
 574         return ret;
 575 }
 576
 577 /* Find entry for given id in the tree */
 578 static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info,
 579                                 struct dquot *dquot, uint blk, int depth)
 580 {
 581         char *buf = getdqbuf(info->dqi_usable_bs);
 582         loff_t ret = 0;
 583         __le32 *ref = (__le32 *)buf;
 584
 585         if (!buf)
 586                 return -ENOMEM;
 587         ret = read_blk(info, blk, buf);
 588         if (ret < 0) {
 589                 quota_error(dquot->dq_sb, "Can't read quota tree block %u",
 590                             blk);
 591                 goto out_buf;
 592         }
 593         ret = 0;
 594         blk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]);
 595         if (!blk)       /* No reference? */
 596                 goto out_buf;
 597         if (blk < QT_TREEOFF || blk >= info->dqi_blocks) {
 598                 quota_error(dquot->dq_sb, "Getting block too big (%u >= %u)",
 599                             blk, info->dqi_blocks);
 600                 ret = -EUCLEAN;
 601                 goto out_buf;
 602         }
 603
 604         if (depth < info->dqi_qtree_depth - 1)
 605                 ret = find_tree_dqentry(info, dquot, blk, depth+1);
 606         else
 607                 ret = find_block_dqentry(info, dquot, blk);
 608 out_buf:
 609         kfree(buf);
 610         return ret;
 611 }
 612
 613 /* Find entry for given id in the tree - wrapper function */
 614 static inline loff_t find_dqentry(struct qtree_mem_dqinfo *info,
 615                                   struct dquot *dquot)
 616 {
 617         return find_tree_dqentry(info, dquot, QT_TREEOFF, 0);
 618 }
 619
 620 int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
 621 {
 622         int type = dquot->dq_id.type;
 623         struct super_block *sb = dquot->dq_sb;
 624         loff_t offset;
 625         char *ddquot;
 626         int ret = 0;
 627
 628 #ifdef __QUOTA_QT_PARANOIA
 629         /* Invalidated quota? */
 630         if (!sb_dqopt(dquot->dq_sb)->files[type]) {
 631                 quota_error(sb, "Quota invalidated while reading!");
 632                 return -EIO;
 633         }
 634 #endif
 635         /* Do we know offset of the dquot entry in the quota file? */
 636         if (!dquot->dq_off) {
 637                 offset = find_dqentry(info, dquot);
 638                 if (offset <= 0) {      /* Entry not present? */
 639                         if (offset < 0)
 640                                 quota_error(sb,"Can't read quota structure "
 641                                             "for id %u",
 642                                             from_kqid(&init_user_ns,
 643                                                       dquot->dq_id));
 644                         dquot->dq_off = 0;
 645                         set_bit(DQ_FAKE_B, &dquot->dq_flags);
 646                         memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
 647                         ret = offset;
 648                         goto out;
 649                 }
 650                 dquot->dq_off = offset;
 651         }
 652         ddquot = getdqbuf(info->dqi_entry_size);
 653         if (!ddquot)
 654                 return -ENOMEM;
 655         ret = sb->s_op->quota_read(sb, type, ddquot, info->dqi_entry_size,
 656                                    dquot->dq_off);
 657         if (ret != info->dqi_entry_size) {
 658                 if (ret >= 0)
 659                         ret = -EIO;
 660                 quota_error(sb, "Error while reading quota structure for id %u",
 661                             from_kqid(&init_user_ns, dquot->dq_id));
 662                 set_bit(DQ_FAKE_B, &dquot->dq_flags);
 663                 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk));
 664                 kfree(ddquot);
 665                 goto out;
 666         }
 667         spin_lock(&dquot->dq_dqb_lock);
 668         info->dqi_ops->disk2mem_dqblk(dquot, ddquot);
 669         if (!dquot->dq_dqb.dqb_bhardlimit &&
 670             !dquot->dq_dqb.dqb_bsoftlimit &&
 671             !dquot->dq_dqb.dqb_ihardlimit &&
 672             !dquot->dq_dqb.dqb_isoftlimit)
 673                 set_bit(DQ_FAKE_B, &dquot->dq_flags);
 674         spin_unlock(&dquot->dq_dqb_lock);
 675         kfree(ddquot);
 676 out:
 677         dqstats_inc(DQST_READS);
 678         return ret;
 679 }
 680 EXPORT_SYMBOL(qtree_read_dquot);
 681
 682 /* Check whether dquot should not be deleted. We know we are
 683  * the only one operating on dquot (thanks to dq_lock) */
 684 int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
 685 {
 686         if (test_bit(DQ_FAKE_B, &dquot->dq_flags) &&
 687             !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace))
 688                 return qtree_delete_dquot(info, dquot);
 689         return 0;
 690 }
 691 EXPORT_SYMBOL(qtree_release_dquot);
 692
 693 static int find_next_id(struct qtree_mem_dqinfo *info, qid_t *id,
 694                         unsigned int blk, int depth)
 695 {
 696         char *buf = getdqbuf(info->dqi_usable_bs);
 697         __le32 *ref = (__le32 *)buf;
 698         ssize_t ret;
 699         unsigned int epb = info->dqi_usable_bs >> 2;
 700         unsigned int level_inc = 1;
 701         int i;
 702
 703         if (!buf)
 704                 return -ENOMEM;
 705
 706         for (i = depth; i < info->dqi_qtree_depth - 1; i++)
 707                 level_inc *= epb;
 708
 709         ret = read_blk(info, blk, buf);
 710         if (ret < 0) {
 711                 quota_error(info->dqi_sb,
 712                             "Can't read quota tree block %u", blk);
 713                 goto out_buf;
 714         }
 715         for (i = __get_index(info, *id, depth); i < epb; i++) {
 716                 if (ref[i] == cpu_to_le32(0)) {
 717                         *id += level_inc;
 718                         continue;
 719                 }
 720                 if (depth == info->dqi_qtree_depth - 1) {
 721                         ret = 0;
 722                         goto out_buf;
 723                 }
 724                 ret = find_next_id(info, id, le32_to_cpu(ref[i]), depth + 1);
 725                 if (ret != -ENOENT)
 726                         break;
 727         }
 728         if (i == epb) {
 729                 ret = -ENOENT;
 730                 goto out_buf;
 731         }
 732 out_buf:
 733         kfree(buf);
 734         return ret;
 735 }
 736
 737 int qtree_get_next_id(struct qtree_mem_dqinfo *info, struct kqid *qid)
 738 {
 739         qid_t id = from_kqid(&init_user_ns, *qid);
 740         int ret;
 741
 742         ret = find_next_id(info, &id, QT_TREEOFF, 0);
 743         if (ret < 0)
 744                 return ret;
 745         *qid = make_kqid(&init_user_ns, qid->type, id);
 746         return 0;
 747 }
 748 EXPORT_SYMBOL(qtree_get_next_id);