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