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