GNU Linux-libre 4.14.295-gnu1
[releases.git] / 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);