]> Git Repo - linux.git/blob - fs/xfs/xfs_dquot.c
enetc: Migrate to PHYLINK and PCS_LYNX
[linux.git] / fs / xfs / xfs_dquot.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2003 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_format.h"
9 #include "xfs_log_format.h"
10 #include "xfs_shared.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_bit.h"
13 #include "xfs_mount.h"
14 #include "xfs_defer.h"
15 #include "xfs_inode.h"
16 #include "xfs_bmap.h"
17 #include "xfs_quota.h"
18 #include "xfs_trans.h"
19 #include "xfs_buf_item.h"
20 #include "xfs_trans_space.h"
21 #include "xfs_trans_priv.h"
22 #include "xfs_qm.h"
23 #include "xfs_trace.h"
24 #include "xfs_log.h"
25 #include "xfs_bmap_btree.h"
26 #include "xfs_error.h"
27
28 /*
29  * Lock order:
30  *
31  * ip->i_lock
32  *   qi->qi_tree_lock
33  *     dquot->q_qlock (xfs_dqlock() and friends)
34  *       dquot->q_flush (xfs_dqflock() and friends)
35  *       qi->qi_lru_lock
36  *
37  * If two dquots need to be locked the order is user before group/project,
38  * otherwise by the lowest id first, see xfs_dqlock2.
39  */
40
41 struct kmem_zone                *xfs_qm_dqtrxzone;
42 static struct kmem_zone         *xfs_qm_dqzone;
43
44 static struct lock_class_key xfs_dquot_group_class;
45 static struct lock_class_key xfs_dquot_project_class;
46
47 /*
48  * This is called to free all the memory associated with a dquot
49  */
50 void
51 xfs_qm_dqdestroy(
52         struct xfs_dquot        *dqp)
53 {
54         ASSERT(list_empty(&dqp->q_lru));
55
56         kmem_free(dqp->q_logitem.qli_item.li_lv_shadow);
57         mutex_destroy(&dqp->q_qlock);
58
59         XFS_STATS_DEC(dqp->q_mount, xs_qm_dquot);
60         kmem_cache_free(xfs_qm_dqzone, dqp);
61 }
62
63 /*
64  * If default limits are in force, push them into the dquot now.
65  * We overwrite the dquot limits only if they are zero and this
66  * is not the root dquot.
67  */
68 void
69 xfs_qm_adjust_dqlimits(
70         struct xfs_dquot        *dq)
71 {
72         struct xfs_mount        *mp = dq->q_mount;
73         struct xfs_quotainfo    *q = mp->m_quotainfo;
74         struct xfs_def_quota    *defq;
75         int                     prealloc = 0;
76
77         ASSERT(dq->q_id);
78         defq = xfs_get_defquota(q, xfs_dquot_type(dq));
79
80         if (!dq->q_blk.softlimit) {
81                 dq->q_blk.softlimit = defq->blk.soft;
82                 prealloc = 1;
83         }
84         if (!dq->q_blk.hardlimit) {
85                 dq->q_blk.hardlimit = defq->blk.hard;
86                 prealloc = 1;
87         }
88         if (!dq->q_ino.softlimit)
89                 dq->q_ino.softlimit = defq->ino.soft;
90         if (!dq->q_ino.hardlimit)
91                 dq->q_ino.hardlimit = defq->ino.hard;
92         if (!dq->q_rtb.softlimit)
93                 dq->q_rtb.softlimit = defq->rtb.soft;
94         if (!dq->q_rtb.hardlimit)
95                 dq->q_rtb.hardlimit = defq->rtb.hard;
96
97         if (prealloc)
98                 xfs_dquot_set_prealloc_limits(dq);
99 }
100
101 /*
102  * Determine if this quota counter is over either limit and set the quota
103  * timers as appropriate.
104  */
105 static inline void
106 xfs_qm_adjust_res_timer(
107         struct xfs_dquot_res    *res,
108         struct xfs_quota_limits *qlim)
109 {
110         ASSERT(res->hardlimit == 0 || res->softlimit <= res->hardlimit);
111
112         if ((res->softlimit && res->count > res->softlimit) ||
113             (res->hardlimit && res->count > res->hardlimit)) {
114                 if (res->timer == 0)
115                         res->timer = ktime_get_real_seconds() + qlim->time;
116         } else {
117                 if (res->timer == 0)
118                         res->warnings = 0;
119                 else
120                         res->timer = 0;
121         }
122 }
123
124 /*
125  * Check the limits and timers of a dquot and start or reset timers
126  * if necessary.
127  * This gets called even when quota enforcement is OFF, which makes our
128  * life a little less complicated. (We just don't reject any quota
129  * reservations in that case, when enforcement is off).
130  * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
131  * enforcement's off.
132  * In contrast, warnings are a little different in that they don't
133  * 'automatically' get started when limits get exceeded.  They do
134  * get reset to zero, however, when we find the count to be under
135  * the soft limit (they are only ever set non-zero via userspace).
136  */
137 void
138 xfs_qm_adjust_dqtimers(
139         struct xfs_dquot        *dq)
140 {
141         struct xfs_mount        *mp = dq->q_mount;
142         struct xfs_quotainfo    *qi = mp->m_quotainfo;
143         struct xfs_def_quota    *defq;
144
145         ASSERT(dq->q_id);
146         defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
147
148         xfs_qm_adjust_res_timer(&dq->q_blk, &defq->blk);
149         xfs_qm_adjust_res_timer(&dq->q_ino, &defq->ino);
150         xfs_qm_adjust_res_timer(&dq->q_rtb, &defq->rtb);
151 }
152
153 /*
154  * initialize a buffer full of dquots and log the whole thing
155  */
156 STATIC void
157 xfs_qm_init_dquot_blk(
158         struct xfs_trans        *tp,
159         struct xfs_mount        *mp,
160         xfs_dqid_t              id,
161         xfs_dqtype_t            type,
162         struct xfs_buf          *bp)
163 {
164         struct xfs_quotainfo    *q = mp->m_quotainfo;
165         struct xfs_dqblk        *d;
166         xfs_dqid_t              curid;
167         unsigned int            qflag;
168         unsigned int            blftype;
169         int                     i;
170
171         ASSERT(tp);
172         ASSERT(xfs_buf_islocked(bp));
173
174         switch (type) {
175         case XFS_DQTYPE_USER:
176                 qflag = XFS_UQUOTA_CHKD;
177                 blftype = XFS_BLF_UDQUOT_BUF;
178                 break;
179         case XFS_DQTYPE_PROJ:
180                 qflag = XFS_PQUOTA_CHKD;
181                 blftype = XFS_BLF_PDQUOT_BUF;
182                 break;
183         case XFS_DQTYPE_GROUP:
184                 qflag = XFS_GQUOTA_CHKD;
185                 blftype = XFS_BLF_GDQUOT_BUF;
186                 break;
187         default:
188                 ASSERT(0);
189                 return;
190         }
191
192         d = bp->b_addr;
193
194         /*
195          * ID of the first dquot in the block - id's are zero based.
196          */
197         curid = id - (id % q->qi_dqperchunk);
198         memset(d, 0, BBTOB(q->qi_dqchunklen));
199         for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
200                 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
201                 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
202                 d->dd_diskdq.d_id = cpu_to_be32(curid);
203                 d->dd_diskdq.d_type = type;
204                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
205                         uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
206                         xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
207                                          XFS_DQUOT_CRC_OFF);
208                 }
209         }
210
211         xfs_trans_dquot_buf(tp, bp, blftype);
212
213         /*
214          * quotacheck uses delayed writes to update all the dquots on disk in an
215          * efficient manner instead of logging the individual dquot changes as
216          * they are made. However if we log the buffer allocated here and crash
217          * after quotacheck while the logged initialisation is still in the
218          * active region of the log, log recovery can replay the dquot buffer
219          * initialisation over the top of the checked dquots and corrupt quota
220          * accounting.
221          *
222          * To avoid this problem, quotacheck cannot log the initialised buffer.
223          * We must still dirty the buffer and write it back before the
224          * allocation transaction clears the log. Therefore, mark the buffer as
225          * ordered instead of logging it directly. This is safe for quotacheck
226          * because it detects and repairs allocated but initialized dquot blocks
227          * in the quota inodes.
228          */
229         if (!(mp->m_qflags & qflag))
230                 xfs_trans_ordered_buf(tp, bp);
231         else
232                 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
233 }
234
235 /*
236  * Initialize the dynamic speculative preallocation thresholds. The lo/hi
237  * watermarks correspond to the soft and hard limits by default. If a soft limit
238  * is not specified, we use 95% of the hard limit.
239  */
240 void
241 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
242 {
243         uint64_t space;
244
245         dqp->q_prealloc_hi_wmark = dqp->q_blk.hardlimit;
246         dqp->q_prealloc_lo_wmark = dqp->q_blk.softlimit;
247         if (!dqp->q_prealloc_lo_wmark) {
248                 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
249                 do_div(dqp->q_prealloc_lo_wmark, 100);
250                 dqp->q_prealloc_lo_wmark *= 95;
251         }
252
253         space = dqp->q_prealloc_hi_wmark;
254
255         do_div(space, 100);
256         dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
257         dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
258         dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
259 }
260
261 /*
262  * Ensure that the given in-core dquot has a buffer on disk backing it, and
263  * return the buffer locked and held. This is called when the bmapi finds a
264  * hole.
265  */
266 STATIC int
267 xfs_dquot_disk_alloc(
268         struct xfs_trans        **tpp,
269         struct xfs_dquot        *dqp,
270         struct xfs_buf          **bpp)
271 {
272         struct xfs_bmbt_irec    map;
273         struct xfs_trans        *tp = *tpp;
274         struct xfs_mount        *mp = tp->t_mountp;
275         struct xfs_buf          *bp;
276         xfs_dqtype_t            qtype = xfs_dquot_type(dqp);
277         struct xfs_inode        *quotip = xfs_quota_inode(mp, qtype);
278         int                     nmaps = 1;
279         int                     error;
280
281         trace_xfs_dqalloc(dqp);
282
283         xfs_ilock(quotip, XFS_ILOCK_EXCL);
284         if (!xfs_this_quota_on(dqp->q_mount, qtype)) {
285                 /*
286                  * Return if this type of quotas is turned off while we didn't
287                  * have an inode lock
288                  */
289                 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
290                 return -ESRCH;
291         }
292
293         /* Create the block mapping. */
294         xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
295         error = xfs_bmapi_write(tp, quotip, dqp->q_fileoffset,
296                         XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA, 0, &map,
297                         &nmaps);
298         if (error)
299                 return error;
300         ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
301         ASSERT(nmaps == 1);
302         ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
303                (map.br_startblock != HOLESTARTBLOCK));
304
305         /*
306          * Keep track of the blkno to save a lookup later
307          */
308         dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
309
310         /* now we can just get the buffer (there's nothing to read yet) */
311         error = xfs_trans_get_buf(tp, mp->m_ddev_targp, dqp->q_blkno,
312                         mp->m_quotainfo->qi_dqchunklen, 0, &bp);
313         if (error)
314                 return error;
315         bp->b_ops = &xfs_dquot_buf_ops;
316
317         /*
318          * Make a chunk of dquots out of this buffer and log
319          * the entire thing.
320          */
321         xfs_qm_init_dquot_blk(tp, mp, dqp->q_id, qtype, bp);
322         xfs_buf_set_ref(bp, XFS_DQUOT_REF);
323
324         /*
325          * Hold the buffer and join it to the dfops so that we'll still own
326          * the buffer when we return to the caller.  The buffer disposal on
327          * error must be paid attention to very carefully, as it has been
328          * broken since commit efa092f3d4c6 "[XFS] Fixes a bug in the quota
329          * code when allocating a new dquot record" in 2005, and the later
330          * conversion to xfs_defer_ops in commit 310a75a3c6c747 failed to keep
331          * the buffer locked across the _defer_finish call.  We can now do
332          * this correctly with xfs_defer_bjoin.
333          *
334          * Above, we allocated a disk block for the dquot information and used
335          * get_buf to initialize the dquot. If the _defer_finish fails, the old
336          * transaction is gone but the new buffer is not joined or held to any
337          * transaction, so we must _buf_relse it.
338          *
339          * If everything succeeds, the caller of this function is returned a
340          * buffer that is locked and held to the transaction.  The caller
341          * is responsible for unlocking any buffer passed back, either
342          * manually or by committing the transaction.  On error, the buffer is
343          * released and not passed back.
344          */
345         xfs_trans_bhold(tp, bp);
346         error = xfs_defer_finish(tpp);
347         if (error) {
348                 xfs_trans_bhold_release(*tpp, bp);
349                 xfs_trans_brelse(*tpp, bp);
350                 return error;
351         }
352         *bpp = bp;
353         return 0;
354 }
355
356 /*
357  * Read in the in-core dquot's on-disk metadata and return the buffer.
358  * Returns ENOENT to signal a hole.
359  */
360 STATIC int
361 xfs_dquot_disk_read(
362         struct xfs_mount        *mp,
363         struct xfs_dquot        *dqp,
364         struct xfs_buf          **bpp)
365 {
366         struct xfs_bmbt_irec    map;
367         struct xfs_buf          *bp;
368         xfs_dqtype_t            qtype = xfs_dquot_type(dqp);
369         struct xfs_inode        *quotip = xfs_quota_inode(mp, qtype);
370         uint                    lock_mode;
371         int                     nmaps = 1;
372         int                     error;
373
374         lock_mode = xfs_ilock_data_map_shared(quotip);
375         if (!xfs_this_quota_on(mp, qtype)) {
376                 /*
377                  * Return if this type of quotas is turned off while we
378                  * didn't have the quota inode lock.
379                  */
380                 xfs_iunlock(quotip, lock_mode);
381                 return -ESRCH;
382         }
383
384         /*
385          * Find the block map; no allocations yet
386          */
387         error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
388                         XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
389         xfs_iunlock(quotip, lock_mode);
390         if (error)
391                 return error;
392
393         ASSERT(nmaps == 1);
394         ASSERT(map.br_blockcount >= 1);
395         ASSERT(map.br_startblock != DELAYSTARTBLOCK);
396         if (map.br_startblock == HOLESTARTBLOCK)
397                 return -ENOENT;
398
399         trace_xfs_dqtobp_read(dqp);
400
401         /*
402          * store the blkno etc so that we don't have to do the
403          * mapping all the time
404          */
405         dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
406
407         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
408                         mp->m_quotainfo->qi_dqchunklen, 0, &bp,
409                         &xfs_dquot_buf_ops);
410         if (error) {
411                 ASSERT(bp == NULL);
412                 return error;
413         }
414
415         ASSERT(xfs_buf_islocked(bp));
416         xfs_buf_set_ref(bp, XFS_DQUOT_REF);
417         *bpp = bp;
418
419         return 0;
420 }
421
422 /* Allocate and initialize everything we need for an incore dquot. */
423 STATIC struct xfs_dquot *
424 xfs_dquot_alloc(
425         struct xfs_mount        *mp,
426         xfs_dqid_t              id,
427         xfs_dqtype_t            type)
428 {
429         struct xfs_dquot        *dqp;
430
431         dqp = kmem_cache_zalloc(xfs_qm_dqzone, GFP_KERNEL | __GFP_NOFAIL);
432
433         dqp->q_type = type;
434         dqp->q_id = id;
435         dqp->q_mount = mp;
436         INIT_LIST_HEAD(&dqp->q_lru);
437         mutex_init(&dqp->q_qlock);
438         init_waitqueue_head(&dqp->q_pinwait);
439         dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
440         /*
441          * Offset of dquot in the (fixed sized) dquot chunk.
442          */
443         dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
444                         sizeof(xfs_dqblk_t);
445
446         /*
447          * Because we want to use a counting completion, complete
448          * the flush completion once to allow a single access to
449          * the flush completion without blocking.
450          */
451         init_completion(&dqp->q_flush);
452         complete(&dqp->q_flush);
453
454         /*
455          * Make sure group quotas have a different lock class than user
456          * quotas.
457          */
458         switch (type) {
459         case XFS_DQTYPE_USER:
460                 /* uses the default lock class */
461                 break;
462         case XFS_DQTYPE_GROUP:
463                 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
464                 break;
465         case XFS_DQTYPE_PROJ:
466                 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
467                 break;
468         default:
469                 ASSERT(0);
470                 break;
471         }
472
473         xfs_qm_dquot_logitem_init(dqp);
474
475         XFS_STATS_INC(mp, xs_qm_dquot);
476         return dqp;
477 }
478
479 /* Copy the in-core quota fields in from the on-disk buffer. */
480 STATIC int
481 xfs_dquot_from_disk(
482         struct xfs_dquot        *dqp,
483         struct xfs_buf          *bp)
484 {
485         struct xfs_disk_dquot   *ddqp = bp->b_addr + dqp->q_bufoffset;
486
487         /*
488          * Ensure that we got the type and ID we were looking for.
489          * Everything else was checked by the dquot buffer verifier.
490          */
491         if ((ddqp->d_type & XFS_DQTYPE_REC_MASK) != xfs_dquot_type(dqp) ||
492             be32_to_cpu(ddqp->d_id) != dqp->q_id) {
493                 xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
494                           "Metadata corruption detected at %pS, quota %u",
495                           __this_address, dqp->q_id);
496                 xfs_alert(bp->b_mount, "Unmount and run xfs_repair");
497                 return -EFSCORRUPTED;
498         }
499
500         /* copy everything from disk dquot to the incore dquot */
501         dqp->q_type = ddqp->d_type;
502         dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
503         dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit);
504         dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
505         dqp->q_ino.softlimit = be64_to_cpu(ddqp->d_ino_softlimit);
506         dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
507         dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
508
509         dqp->q_blk.count = be64_to_cpu(ddqp->d_bcount);
510         dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);
511         dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);
512
513         dqp->q_blk.warnings = be16_to_cpu(ddqp->d_bwarns);
514         dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);
515         dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);
516
517         dqp->q_blk.timer = be32_to_cpu(ddqp->d_btimer);
518         dqp->q_ino.timer = be32_to_cpu(ddqp->d_itimer);
519         dqp->q_rtb.timer = be32_to_cpu(ddqp->d_rtbtimer);
520
521         /*
522          * Reservation counters are defined as reservation plus current usage
523          * to avoid having to add every time.
524          */
525         dqp->q_blk.reserved = dqp->q_blk.count;
526         dqp->q_ino.reserved = dqp->q_ino.count;
527         dqp->q_rtb.reserved = dqp->q_rtb.count;
528
529         /* initialize the dquot speculative prealloc thresholds */
530         xfs_dquot_set_prealloc_limits(dqp);
531         return 0;
532 }
533
534 /* Copy the in-core quota fields into the on-disk buffer. */
535 void
536 xfs_dquot_to_disk(
537         struct xfs_disk_dquot   *ddqp,
538         struct xfs_dquot        *dqp)
539 {
540         ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
541         ddqp->d_version = XFS_DQUOT_VERSION;
542         ddqp->d_type = dqp->q_type;
543         ddqp->d_id = cpu_to_be32(dqp->q_id);
544         ddqp->d_pad0 = 0;
545         ddqp->d_pad = 0;
546
547         ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
548         ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
549         ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
550         ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);
551         ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);
552         ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);
553
554         ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);
555         ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
556         ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
557
558         ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings);
559         ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings);
560         ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings);
561
562         ddqp->d_btimer = cpu_to_be32(dqp->q_blk.timer);
563         ddqp->d_itimer = cpu_to_be32(dqp->q_ino.timer);
564         ddqp->d_rtbtimer = cpu_to_be32(dqp->q_rtb.timer);
565 }
566
567 /* Allocate and initialize the dquot buffer for this in-core dquot. */
568 static int
569 xfs_qm_dqread_alloc(
570         struct xfs_mount        *mp,
571         struct xfs_dquot        *dqp,
572         struct xfs_buf          **bpp)
573 {
574         struct xfs_trans        *tp;
575         int                     error;
576
577         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_dqalloc,
578                         XFS_QM_DQALLOC_SPACE_RES(mp), 0, 0, &tp);
579         if (error)
580                 goto err;
581
582         error = xfs_dquot_disk_alloc(&tp, dqp, bpp);
583         if (error)
584                 goto err_cancel;
585
586         error = xfs_trans_commit(tp);
587         if (error) {
588                 /*
589                  * Buffer was held to the transaction, so we have to unlock it
590                  * manually here because we're not passing it back.
591                  */
592                 xfs_buf_relse(*bpp);
593                 *bpp = NULL;
594                 goto err;
595         }
596         return 0;
597
598 err_cancel:
599         xfs_trans_cancel(tp);
600 err:
601         return error;
602 }
603
604 /*
605  * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
606  * and release the buffer immediately.  If @can_alloc is true, fill any
607  * holes in the on-disk metadata.
608  */
609 static int
610 xfs_qm_dqread(
611         struct xfs_mount        *mp,
612         xfs_dqid_t              id,
613         xfs_dqtype_t            type,
614         bool                    can_alloc,
615         struct xfs_dquot        **dqpp)
616 {
617         struct xfs_dquot        *dqp;
618         struct xfs_buf          *bp;
619         int                     error;
620
621         dqp = xfs_dquot_alloc(mp, id, type);
622         trace_xfs_dqread(dqp);
623
624         /* Try to read the buffer, allocating if necessary. */
625         error = xfs_dquot_disk_read(mp, dqp, &bp);
626         if (error == -ENOENT && can_alloc)
627                 error = xfs_qm_dqread_alloc(mp, dqp, &bp);
628         if (error)
629                 goto err;
630
631         /*
632          * At this point we should have a clean locked buffer.  Copy the data
633          * to the incore dquot and release the buffer since the incore dquot
634          * has its own locking protocol so we needn't tie up the buffer any
635          * further.
636          */
637         ASSERT(xfs_buf_islocked(bp));
638         error = xfs_dquot_from_disk(dqp, bp);
639         xfs_buf_relse(bp);
640         if (error)
641                 goto err;
642
643         *dqpp = dqp;
644         return error;
645
646 err:
647         trace_xfs_dqread_fail(dqp);
648         xfs_qm_dqdestroy(dqp);
649         *dqpp = NULL;
650         return error;
651 }
652
653 /*
654  * Advance to the next id in the current chunk, or if at the
655  * end of the chunk, skip ahead to first id in next allocated chunk
656  * using the SEEK_DATA interface.
657  */
658 static int
659 xfs_dq_get_next_id(
660         struct xfs_mount        *mp,
661         xfs_dqtype_t            type,
662         xfs_dqid_t              *id)
663 {
664         struct xfs_inode        *quotip = xfs_quota_inode(mp, type);
665         xfs_dqid_t              next_id = *id + 1; /* simple advance */
666         uint                    lock_flags;
667         struct xfs_bmbt_irec    got;
668         struct xfs_iext_cursor  cur;
669         xfs_fsblock_t           start;
670         int                     error = 0;
671
672         /* If we'd wrap past the max ID, stop */
673         if (next_id < *id)
674                 return -ENOENT;
675
676         /* If new ID is within the current chunk, advancing it sufficed */
677         if (next_id % mp->m_quotainfo->qi_dqperchunk) {
678                 *id = next_id;
679                 return 0;
680         }
681
682         /* Nope, next_id is now past the current chunk, so find the next one */
683         start = (xfs_fsblock_t)next_id / mp->m_quotainfo->qi_dqperchunk;
684
685         lock_flags = xfs_ilock_data_map_shared(quotip);
686         if (!(quotip->i_df.if_flags & XFS_IFEXTENTS)) {
687                 error = xfs_iread_extents(NULL, quotip, XFS_DATA_FORK);
688                 if (error)
689                         return error;
690         }
691
692         if (xfs_iext_lookup_extent(quotip, &quotip->i_df, start, &cur, &got)) {
693                 /* contiguous chunk, bump startoff for the id calculation */
694                 if (got.br_startoff < start)
695                         got.br_startoff = start;
696                 *id = got.br_startoff * mp->m_quotainfo->qi_dqperchunk;
697         } else {
698                 error = -ENOENT;
699         }
700
701         xfs_iunlock(quotip, lock_flags);
702
703         return error;
704 }
705
706 /*
707  * Look up the dquot in the in-core cache.  If found, the dquot is returned
708  * locked and ready to go.
709  */
710 static struct xfs_dquot *
711 xfs_qm_dqget_cache_lookup(
712         struct xfs_mount        *mp,
713         struct xfs_quotainfo    *qi,
714         struct radix_tree_root  *tree,
715         xfs_dqid_t              id)
716 {
717         struct xfs_dquot        *dqp;
718
719 restart:
720         mutex_lock(&qi->qi_tree_lock);
721         dqp = radix_tree_lookup(tree, id);
722         if (!dqp) {
723                 mutex_unlock(&qi->qi_tree_lock);
724                 XFS_STATS_INC(mp, xs_qm_dqcachemisses);
725                 return NULL;
726         }
727
728         xfs_dqlock(dqp);
729         if (dqp->q_flags & XFS_DQFLAG_FREEING) {
730                 xfs_dqunlock(dqp);
731                 mutex_unlock(&qi->qi_tree_lock);
732                 trace_xfs_dqget_freeing(dqp);
733                 delay(1);
734                 goto restart;
735         }
736
737         dqp->q_nrefs++;
738         mutex_unlock(&qi->qi_tree_lock);
739
740         trace_xfs_dqget_hit(dqp);
741         XFS_STATS_INC(mp, xs_qm_dqcachehits);
742         return dqp;
743 }
744
745 /*
746  * Try to insert a new dquot into the in-core cache.  If an error occurs the
747  * caller should throw away the dquot and start over.  Otherwise, the dquot
748  * is returned locked (and held by the cache) as if there had been a cache
749  * hit.
750  */
751 static int
752 xfs_qm_dqget_cache_insert(
753         struct xfs_mount        *mp,
754         struct xfs_quotainfo    *qi,
755         struct radix_tree_root  *tree,
756         xfs_dqid_t              id,
757         struct xfs_dquot        *dqp)
758 {
759         int                     error;
760
761         mutex_lock(&qi->qi_tree_lock);
762         error = radix_tree_insert(tree, id, dqp);
763         if (unlikely(error)) {
764                 /* Duplicate found!  Caller must try again. */
765                 WARN_ON(error != -EEXIST);
766                 mutex_unlock(&qi->qi_tree_lock);
767                 trace_xfs_dqget_dup(dqp);
768                 return error;
769         }
770
771         /* Return a locked dquot to the caller, with a reference taken. */
772         xfs_dqlock(dqp);
773         dqp->q_nrefs = 1;
774
775         qi->qi_dquots++;
776         mutex_unlock(&qi->qi_tree_lock);
777
778         return 0;
779 }
780
781 /* Check our input parameters. */
782 static int
783 xfs_qm_dqget_checks(
784         struct xfs_mount        *mp,
785         xfs_dqtype_t            type)
786 {
787         if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp)))
788                 return -ESRCH;
789
790         switch (type) {
791         case XFS_DQTYPE_USER:
792                 if (!XFS_IS_UQUOTA_ON(mp))
793                         return -ESRCH;
794                 return 0;
795         case XFS_DQTYPE_GROUP:
796                 if (!XFS_IS_GQUOTA_ON(mp))
797                         return -ESRCH;
798                 return 0;
799         case XFS_DQTYPE_PROJ:
800                 if (!XFS_IS_PQUOTA_ON(mp))
801                         return -ESRCH;
802                 return 0;
803         default:
804                 WARN_ON_ONCE(0);
805                 return -EINVAL;
806         }
807 }
808
809 /*
810  * Given the file system, id, and type (UDQUOT/GDQUOT), return a locked
811  * dquot, doing an allocation (if requested) as needed.
812  */
813 int
814 xfs_qm_dqget(
815         struct xfs_mount        *mp,
816         xfs_dqid_t              id,
817         xfs_dqtype_t            type,
818         bool                    can_alloc,
819         struct xfs_dquot        **O_dqpp)
820 {
821         struct xfs_quotainfo    *qi = mp->m_quotainfo;
822         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
823         struct xfs_dquot        *dqp;
824         int                     error;
825
826         error = xfs_qm_dqget_checks(mp, type);
827         if (error)
828                 return error;
829
830 restart:
831         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
832         if (dqp) {
833                 *O_dqpp = dqp;
834                 return 0;
835         }
836
837         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
838         if (error)
839                 return error;
840
841         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
842         if (error) {
843                 /*
844                  * Duplicate found. Just throw away the new dquot and start
845                  * over.
846                  */
847                 xfs_qm_dqdestroy(dqp);
848                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
849                 goto restart;
850         }
851
852         trace_xfs_dqget_miss(dqp);
853         *O_dqpp = dqp;
854         return 0;
855 }
856
857 /*
858  * Given a dquot id and type, read and initialize a dquot from the on-disk
859  * metadata.  This function is only for use during quota initialization so
860  * it ignores the dquot cache assuming that the dquot shrinker isn't set up.
861  * The caller is responsible for _qm_dqdestroy'ing the returned dquot.
862  */
863 int
864 xfs_qm_dqget_uncached(
865         struct xfs_mount        *mp,
866         xfs_dqid_t              id,
867         xfs_dqtype_t            type,
868         struct xfs_dquot        **dqpp)
869 {
870         int                     error;
871
872         error = xfs_qm_dqget_checks(mp, type);
873         if (error)
874                 return error;
875
876         return xfs_qm_dqread(mp, id, type, 0, dqpp);
877 }
878
879 /* Return the quota id for a given inode and type. */
880 xfs_dqid_t
881 xfs_qm_id_for_quotatype(
882         struct xfs_inode        *ip,
883         xfs_dqtype_t            type)
884 {
885         switch (type) {
886         case XFS_DQTYPE_USER:
887                 return i_uid_read(VFS_I(ip));
888         case XFS_DQTYPE_GROUP:
889                 return i_gid_read(VFS_I(ip));
890         case XFS_DQTYPE_PROJ:
891                 return ip->i_d.di_projid;
892         }
893         ASSERT(0);
894         return 0;
895 }
896
897 /*
898  * Return the dquot for a given inode and type.  If @can_alloc is true, then
899  * allocate blocks if needed.  The inode's ILOCK must be held and it must not
900  * have already had an inode attached.
901  */
902 int
903 xfs_qm_dqget_inode(
904         struct xfs_inode        *ip,
905         xfs_dqtype_t            type,
906         bool                    can_alloc,
907         struct xfs_dquot        **O_dqpp)
908 {
909         struct xfs_mount        *mp = ip->i_mount;
910         struct xfs_quotainfo    *qi = mp->m_quotainfo;
911         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
912         struct xfs_dquot        *dqp;
913         xfs_dqid_t              id;
914         int                     error;
915
916         error = xfs_qm_dqget_checks(mp, type);
917         if (error)
918                 return error;
919
920         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
921         ASSERT(xfs_inode_dquot(ip, type) == NULL);
922
923         id = xfs_qm_id_for_quotatype(ip, type);
924
925 restart:
926         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
927         if (dqp) {
928                 *O_dqpp = dqp;
929                 return 0;
930         }
931
932         /*
933          * Dquot cache miss. We don't want to keep the inode lock across
934          * a (potential) disk read. Also we don't want to deal with the lock
935          * ordering between quotainode and this inode. OTOH, dropping the inode
936          * lock here means dealing with a chown that can happen before
937          * we re-acquire the lock.
938          */
939         xfs_iunlock(ip, XFS_ILOCK_EXCL);
940         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
941         xfs_ilock(ip, XFS_ILOCK_EXCL);
942         if (error)
943                 return error;
944
945         /*
946          * A dquot could be attached to this inode by now, since we had
947          * dropped the ilock.
948          */
949         if (xfs_this_quota_on(mp, type)) {
950                 struct xfs_dquot        *dqp1;
951
952                 dqp1 = xfs_inode_dquot(ip, type);
953                 if (dqp1) {
954                         xfs_qm_dqdestroy(dqp);
955                         dqp = dqp1;
956                         xfs_dqlock(dqp);
957                         goto dqret;
958                 }
959         } else {
960                 /* inode stays locked on return */
961                 xfs_qm_dqdestroy(dqp);
962                 return -ESRCH;
963         }
964
965         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
966         if (error) {
967                 /*
968                  * Duplicate found. Just throw away the new dquot and start
969                  * over.
970                  */
971                 xfs_qm_dqdestroy(dqp);
972                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
973                 goto restart;
974         }
975
976 dqret:
977         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
978         trace_xfs_dqget_miss(dqp);
979         *O_dqpp = dqp;
980         return 0;
981 }
982
983 /*
984  * Starting at @id and progressing upwards, look for an initialized incore
985  * dquot, lock it, and return it.
986  */
987 int
988 xfs_qm_dqget_next(
989         struct xfs_mount        *mp,
990         xfs_dqid_t              id,
991         xfs_dqtype_t            type,
992         struct xfs_dquot        **dqpp)
993 {
994         struct xfs_dquot        *dqp;
995         int                     error = 0;
996
997         *dqpp = NULL;
998         for (; !error; error = xfs_dq_get_next_id(mp, type, &id)) {
999                 error = xfs_qm_dqget(mp, id, type, false, &dqp);
1000                 if (error == -ENOENT)
1001                         continue;
1002                 else if (error != 0)
1003                         break;
1004
1005                 if (!XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
1006                         *dqpp = dqp;
1007                         return 0;
1008                 }
1009
1010                 xfs_qm_dqput(dqp);
1011         }
1012
1013         return error;
1014 }
1015
1016 /*
1017  * Release a reference to the dquot (decrement ref-count) and unlock it.
1018  *
1019  * If there is a group quota attached to this dquot, carefully release that
1020  * too without tripping over deadlocks'n'stuff.
1021  */
1022 void
1023 xfs_qm_dqput(
1024         struct xfs_dquot        *dqp)
1025 {
1026         ASSERT(dqp->q_nrefs > 0);
1027         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1028
1029         trace_xfs_dqput(dqp);
1030
1031         if (--dqp->q_nrefs == 0) {
1032                 struct xfs_quotainfo    *qi = dqp->q_mount->m_quotainfo;
1033                 trace_xfs_dqput_free(dqp);
1034
1035                 if (list_lru_add(&qi->qi_lru, &dqp->q_lru))
1036                         XFS_STATS_INC(dqp->q_mount, xs_qm_dquot_unused);
1037         }
1038         xfs_dqunlock(dqp);
1039 }
1040
1041 /*
1042  * Release a dquot. Flush it if dirty, then dqput() it.
1043  * dquot must not be locked.
1044  */
1045 void
1046 xfs_qm_dqrele(
1047         struct xfs_dquot        *dqp)
1048 {
1049         if (!dqp)
1050                 return;
1051
1052         trace_xfs_dqrele(dqp);
1053
1054         xfs_dqlock(dqp);
1055         /*
1056          * We don't care to flush it if the dquot is dirty here.
1057          * That will create stutters that we want to avoid.
1058          * Instead we do a delayed write when we try to reclaim
1059          * a dirty dquot. Also xfs_sync will take part of the burden...
1060          */
1061         xfs_qm_dqput(dqp);
1062 }
1063
1064 /*
1065  * This is the dquot flushing I/O completion routine.  It is called
1066  * from interrupt level when the buffer containing the dquot is
1067  * flushed to disk.  It is responsible for removing the dquot logitem
1068  * from the AIL if it has not been re-logged, and unlocking the dquot's
1069  * flush lock. This behavior is very similar to that of inodes..
1070  */
1071 static void
1072 xfs_qm_dqflush_done(
1073         struct xfs_log_item     *lip)
1074 {
1075         struct xfs_dq_logitem   *qip = (struct xfs_dq_logitem *)lip;
1076         struct xfs_dquot        *dqp = qip->qli_dquot;
1077         struct xfs_ail          *ailp = lip->li_ailp;
1078         xfs_lsn_t               tail_lsn;
1079
1080         /*
1081          * We only want to pull the item from the AIL if its
1082          * location in the log has not changed since we started the flush.
1083          * Thus, we only bother if the dquot's lsn has
1084          * not changed. First we check the lsn outside the lock
1085          * since it's cheaper, and then we recheck while
1086          * holding the lock before removing the dquot from the AIL.
1087          */
1088         if (test_bit(XFS_LI_IN_AIL, &lip->li_flags) &&
1089             ((lip->li_lsn == qip->qli_flush_lsn) ||
1090              test_bit(XFS_LI_FAILED, &lip->li_flags))) {
1091
1092                 spin_lock(&ailp->ail_lock);
1093                 xfs_clear_li_failed(lip);
1094                 if (lip->li_lsn == qip->qli_flush_lsn) {
1095                         /* xfs_ail_update_finish() drops the AIL lock */
1096                         tail_lsn = xfs_ail_delete_one(ailp, lip);
1097                         xfs_ail_update_finish(ailp, tail_lsn);
1098                 } else {
1099                         spin_unlock(&ailp->ail_lock);
1100                 }
1101         }
1102
1103         /*
1104          * Release the dq's flush lock since we're done with it.
1105          */
1106         xfs_dqfunlock(dqp);
1107 }
1108
1109 void
1110 xfs_dquot_done(
1111         struct xfs_buf          *bp)
1112 {
1113         struct xfs_log_item     *lip, *n;
1114
1115         list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
1116                 list_del_init(&lip->li_bio_list);
1117                 xfs_qm_dqflush_done(lip);
1118         }
1119 }
1120
1121 /* Check incore dquot for errors before we flush. */
1122 static xfs_failaddr_t
1123 xfs_qm_dqflush_check(
1124         struct xfs_dquot        *dqp)
1125 {
1126         xfs_dqtype_t            type = xfs_dquot_type(dqp);
1127
1128         if (type != XFS_DQTYPE_USER &&
1129             type != XFS_DQTYPE_GROUP &&
1130             type != XFS_DQTYPE_PROJ)
1131                 return __this_address;
1132
1133         if (dqp->q_id == 0)
1134                 return NULL;
1135
1136         if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&
1137             !dqp->q_blk.timer)
1138                 return __this_address;
1139
1140         if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&
1141             !dqp->q_ino.timer)
1142                 return __this_address;
1143
1144         if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&
1145             !dqp->q_rtb.timer)
1146                 return __this_address;
1147
1148         return NULL;
1149 }
1150
1151 /*
1152  * Write a modified dquot to disk.
1153  * The dquot must be locked and the flush lock too taken by caller.
1154  * The flush lock will not be unlocked until the dquot reaches the disk,
1155  * but the dquot is free to be unlocked and modified by the caller
1156  * in the interim. Dquot is still locked on return. This behavior is
1157  * identical to that of inodes.
1158  */
1159 int
1160 xfs_qm_dqflush(
1161         struct xfs_dquot        *dqp,
1162         struct xfs_buf          **bpp)
1163 {
1164         struct xfs_mount        *mp = dqp->q_mount;
1165         struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
1166         struct xfs_buf          *bp;
1167         struct xfs_dqblk        *dqblk;
1168         xfs_failaddr_t          fa;
1169         int                     error;
1170
1171         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1172         ASSERT(!completion_done(&dqp->q_flush));
1173
1174         trace_xfs_dqflush(dqp);
1175
1176         *bpp = NULL;
1177
1178         xfs_qm_dqunpin_wait(dqp);
1179
1180         /*
1181          * Get the buffer containing the on-disk dquot
1182          */
1183         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1184                                    mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK,
1185                                    &bp, &xfs_dquot_buf_ops);
1186         if (error == -EAGAIN)
1187                 goto out_unlock;
1188         if (error)
1189                 goto out_abort;
1190
1191         fa = xfs_qm_dqflush_check(dqp);
1192         if (fa) {
1193                 xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
1194                                 dqp->q_id, fa);
1195                 xfs_buf_relse(bp);
1196                 error = -EFSCORRUPTED;
1197                 goto out_abort;
1198         }
1199
1200         /* Flush the incore dquot to the ondisk buffer. */
1201         dqblk = bp->b_addr + dqp->q_bufoffset;
1202         xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp);
1203
1204         /*
1205          * Clear the dirty field and remember the flush lsn for later use.
1206          */
1207         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1208
1209         xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1210                                         &dqp->q_logitem.qli_item.li_lsn);
1211
1212         /*
1213          * copy the lsn into the on-disk dquot now while we have the in memory
1214          * dquot here. This can't be done later in the write verifier as we
1215          * can't get access to the log item at that point in time.
1216          *
1217          * We also calculate the CRC here so that the on-disk dquot in the
1218          * buffer always has a valid CRC. This ensures there is no possibility
1219          * of a dquot without an up-to-date CRC getting to disk.
1220          */
1221         if (xfs_sb_version_hascrc(&mp->m_sb)) {
1222                 dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
1223                 xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk),
1224                                  XFS_DQUOT_CRC_OFF);
1225         }
1226
1227         /*
1228          * Attach the dquot to the buffer so that we can remove this dquot from
1229          * the AIL and release the flush lock once the dquot is synced to disk.
1230          */
1231         bp->b_flags |= _XBF_DQUOTS;
1232         list_add_tail(&dqp->q_logitem.qli_item.li_bio_list, &bp->b_li_list);
1233
1234         /*
1235          * If the buffer is pinned then push on the log so we won't
1236          * get stuck waiting in the write for too long.
1237          */
1238         if (xfs_buf_ispinned(bp)) {
1239                 trace_xfs_dqflush_force(dqp);
1240                 xfs_log_force(mp, 0);
1241         }
1242
1243         trace_xfs_dqflush_done(dqp);
1244         *bpp = bp;
1245         return 0;
1246
1247 out_abort:
1248         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1249         xfs_trans_ail_delete(lip, 0);
1250         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1251 out_unlock:
1252         xfs_dqfunlock(dqp);
1253         return error;
1254 }
1255
1256 /*
1257  * Lock two xfs_dquot structures.
1258  *
1259  * To avoid deadlocks we always lock the quota structure with
1260  * the lowerd id first.
1261  */
1262 void
1263 xfs_dqlock2(
1264         struct xfs_dquot        *d1,
1265         struct xfs_dquot        *d2)
1266 {
1267         if (d1 && d2) {
1268                 ASSERT(d1 != d2);
1269                 if (d1->q_id > d2->q_id) {
1270                         mutex_lock(&d2->q_qlock);
1271                         mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1272                 } else {
1273                         mutex_lock(&d1->q_qlock);
1274                         mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1275                 }
1276         } else if (d1) {
1277                 mutex_lock(&d1->q_qlock);
1278         } else if (d2) {
1279                 mutex_lock(&d2->q_qlock);
1280         }
1281 }
1282
1283 int __init
1284 xfs_qm_init(void)
1285 {
1286         xfs_qm_dqzone = kmem_cache_create("xfs_dquot",
1287                                           sizeof(struct xfs_dquot),
1288                                           0, 0, NULL);
1289         if (!xfs_qm_dqzone)
1290                 goto out;
1291
1292         xfs_qm_dqtrxzone = kmem_cache_create("xfs_dqtrx",
1293                                              sizeof(struct xfs_dquot_acct),
1294                                              0, 0, NULL);
1295         if (!xfs_qm_dqtrxzone)
1296                 goto out_free_dqzone;
1297
1298         return 0;
1299
1300 out_free_dqzone:
1301         kmem_cache_destroy(xfs_qm_dqzone);
1302 out:
1303         return -ENOMEM;
1304 }
1305
1306 void
1307 xfs_qm_exit(void)
1308 {
1309         kmem_cache_destroy(xfs_qm_dqtrxzone);
1310         kmem_cache_destroy(xfs_qm_dqzone);
1311 }
1312
1313 /*
1314  * Iterate every dquot of a particular type.  The caller must ensure that the
1315  * particular quota type is active.  iter_fn can return negative error codes,
1316  * or -ECANCELED to indicate that it wants to stop iterating.
1317  */
1318 int
1319 xfs_qm_dqiterate(
1320         struct xfs_mount        *mp,
1321         xfs_dqtype_t            type,
1322         xfs_qm_dqiterate_fn     iter_fn,
1323         void                    *priv)
1324 {
1325         struct xfs_dquot        *dq;
1326         xfs_dqid_t              id = 0;
1327         int                     error;
1328
1329         do {
1330                 error = xfs_qm_dqget_next(mp, id, type, &dq);
1331                 if (error == -ENOENT)
1332                         return 0;
1333                 if (error)
1334                         return error;
1335
1336                 error = iter_fn(dq, type, priv);
1337                 id = dq->q_id;
1338                 xfs_qm_dqput(dq);
1339         } while (error == 0 && id != 0);
1340
1341         return error;
1342 }
This page took 0.10952 seconds and 4 git commands to generate.